From 63037dcc9f2869e07686673fd1977eb70db3a0a6 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Fri, 19 Jul 2024 14:30:18 +0200 Subject: [PATCH 01/30] Implemented kernels on GraphEdge --- geometric_kernels/spaces/graph_edge.py | 228 ++++ notebooks/EdgeSpaceGraph.ipynb | 927 ++++++++++++++ notebooks/EdgeSpaceSimplicialComplex.ipynb | 1082 ++++++++++++++++ notebooks/Graph.ipynb | 116 +- notebooks/backends/JAX_EdgeSpaceGraph.ipynb | 939 ++++++++++++++ .../JAX_EdgeSpaceSimplicialComplex.ipynb | 1085 ++++++++++++++++ notebooks/backends/JAX_Graph.ipynb | 39 +- .../backends/PyTorch_EdgeSpaceGraph.ipynb | 952 +++++++++++++++ .../PyTorch_EdgeSpaceSimplicialComplex.ipynb | 1087 +++++++++++++++++ notebooks/backends/PyTorch_Graph.ipynb | 34 +- 10 files changed, 6411 insertions(+), 78 deletions(-) create mode 100644 geometric_kernels/spaces/graph_edge.py create mode 100644 notebooks/EdgeSpaceGraph.ipynb create mode 100644 notebooks/EdgeSpaceSimplicialComplex.ipynb create mode 100644 notebooks/backends/JAX_EdgeSpaceGraph.ipynb create mode 100644 notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb create mode 100644 notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb create mode 100644 notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py new file mode 100644 index 00000000..15f1cb53 --- /dev/null +++ b/geometric_kernels/spaces/graph_edge.py @@ -0,0 +1,228 @@ +""" +This module provides the :class:`EdgeGraph` space. +""" + +import lab as B +import numpy as np +from beartype.typing import Dict, Tuple + +from geometric_kernels.lab_extras import ( + degree, + dtype_integer, + eigenpairs, + reciprocal_no_nan, + set_value, +) +from geometric_kernels.spaces.base import DiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import ( + Eigenfunctions, + EigenfunctionsFromEigenvectors, +) + + +class GraphEdge(DiscreteSpectrumSpace): + """ + The GeometricKernels space representing the edge set of any user-provided undirected graph. + + The elements of this space are represented by edge indices, integer values + from 0 to m-1, where m is the number of edges in the user-provided graph. + + Each individual eigenfunction constitutes a *level*. + + .. note:: + A tutorial on how to use this space is available in the + :doc:`EdgeSpaceGraph.ipynb ` notebook. + + :param incidence_matrix: + An n x m dimensional matrix where n is the number of nodes and m is the number of edges. + incidence_matrix[i, e] is -1 if node i is the start node of edge e, 1 if node i is the end node of edge e. + + Note that the -1s and 1s in the incidence matrix do not necessarily mean that the graph is directed. Instead, they are used to allow oriented computations along edges. + + :param edge_triangle_incidence_matrix: optional + An m x t dimensional matrix where m is the number of edges and t is the number of triangles. + edge_triangle_incidence_matrix[e, t] is -1 if edge e is anti-aligned with triangle t, 1 if edge e is aligned with triangle t, 0 otherwise. + + :param edge_laplacian: + An m x m dimensional matrix where m is the number of edges. + edge_laplcian is computed as + incidence_matrix.T @ incidence_matrix, if edge_triangle_incidence_matrix is None + incidence_matrix.T @ incidence_matrix + edge_triangle_incidence_matrix @ edge_triangle_incidence_matrix.T, if edge_triangle_incidence_matrix is not None + + .. admonition:: Citation + + If you use this GeometricKernels space in your research, please consider + citing :cite:t:`yang2024`. + """ + + def __init__(self, incidence_matrix: B.Numeric, edge_triangle_incidence_matrix=None): # type: ignore + self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} + self.incidence_matrix = incidence_matrix + if edge_triangle_incidence_matrix is not None: + self.edge_triangle_incidence_matrix = edge_triangle_incidence_matrix + else: + self.edge_triangle_incidence_matrix = None + + self._checks(incidence_matrix, self.edge_triangle_incidence_matrix) + self._set_laplacian(incidence_matrix) # type: ignore + + + @staticmethod + def _checks(incidence, edge_triangle_incidence_matrix=None): + """ + Checks if 'incidence' has dimension n x m and if each column has two non-zero entries. + """ + nnz = np.count_nonzero(incidence, axis=0) + assert np.all(nnz == 2), "Each column of the incidence matrix should have exactly two non-zero entries." + if edge_triangle_incidence_matrix is not None: + nnz2 = np.count_nonzero(edge_triangle_incidence_matrix, axis=0) + assert np.all(nnz2 == 3), "Each column of the edge triangle incidence matrix should have exactly 3 non-zero entries." + + + @property + def dimension(self) -> int: + """ + :return: + 0. + """ + return 0 # this is needed for the kernel math to work out + + @property + def num_vertices(self) -> int: + """ + Number of vertices in the graph. + """ + return self.incidence_matrix.shape[0] + + @property + def num_edges(self) -> int: + """ + Number of edges in the graph. + """ + return self.incidence_matrix.shape[1] + + @property + def num_triangles(self) -> int: + """ + Number of triangles in the graph. + """ + if self.edge_triangle_incidence_matrix is None: + return 0 + else: + return self.edge_triangle_incidence_matrix.shape[1] + + def _set_laplacian(self, incidence_matrix): + """ + Construct the appropriate graph Laplacian from the adjacency matrix. + """ + if self.edge_triangle_incidence_matrix is None: + self._edge_laplacian = incidence_matrix.T @ incidence_matrix + else: + self._down_edge_laplacian = incidence_matrix.T @ incidence_matrix + self._up_edge_laplacian = self.edge_triangle_incidence_matrix @ self.edge_triangle_incidence_matrix.T + self._edge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian + + + @property + def edge_laplacian(self): + """ + Return the Edge Laplacian + """ + if self.edge_triangle_incidence_matrix is None: + return self._edge_laplacian + else: + return self._edge_laplacian, self._down_edge_laplacian, self._up_edge_laplacian + + + def get_eigensystem(self, num): + """ + Returns the first `num` eigenvalues and eigenvectors of the Hodge Laplacian. + Caches the solution to prevent re-computing the same values. + + :param num: + Number of eigenpairs to return. Performs the computation at the + first call. Afterwards, fetches the result from cache. + + :return: + A tuple of eigenvectors [n, num], eigenvalues [num, 1]. + """ + eps = np.finfo(float).eps + if num not in self.cache: + evals, evecs = eigenpairs(self._edge_laplacian, num) + if self.edge_triangle_incidence_matrix is not None: + # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian + total_var = [] + total_div = [] + total_curl = [] + num_eigemodes = len(evals) + for i in range(num_eigemodes): + total_var.append(evecs[:, i].T@self._edge_laplacian@evecs[:, i]) + total_div.append(evecs[:, i].T@self._down_edge_laplacian@evecs[:, i]) + total_curl.append(evecs[:, i].T@self._up_edge_laplacian@evecs[:, i]) + + harm_evecs = np.where(np.array(total_var) < eps)[0] + grad_evecs = np.where(np.array(total_div) > eps)[0] + curl_eflow = np.where(np.array(total_curl) > eps)[0] + assert len(harm_evecs) + len(grad_evecs) + len(curl_eflow) == num_eigemodes, "The eigenmodes are not correctly organized" + evals = np.concatenate((evals[harm_evecs], evals[grad_evecs], evals[curl_eflow])) + evecs = np.concatenate((evecs[:, harm_evecs], evecs[:, grad_evecs], evecs[:, curl_eflow]), axis=1) + + self.cache[num] = (evecs, evals[:, None]) + + return self.cache[num] + + def get_eigenfunctions(self, num: int) -> Eigenfunctions: + """ + Returns the :class:`~.EigenfunctionsFromEigenvectors` object with + `num` levels (i.e., in this case, `num` eigenpairs). + + :param num: + Number of levels. + """ + eigenfunctions = EigenfunctionsFromEigenvectors(self.get_eigenvectors(num)) + return eigenfunctions + + def get_eigenvectors(self, num: int) -> B.Numeric: + """ + :param num: + Number of eigenvectors to return. + + :return: + Array of eigenvectors, with shape [n, num]. + """ + return self.get_eigensystem(num)[0] + + def get_eigenvalues(self, num: int) -> B.Numeric: + """ + :param num: + Number of eigenvalues to return. + + :return: + Array of eigenvalues, with shape [num, 1]. + """ + return self.get_eigensystem(num)[1] + + def get_repeated_eigenvalues(self, num: int) -> B.Numeric: + """ + Same as :meth:`get_eigenvalues`. + + :param num: + Same as :meth:`get_eigenvalues`. + """ + return self.get_eigenvalues(num) + + def random(self, key, number): + num_edges = B.shape(self._edge_laplacian)[0] + key, random_edges = B.randint( + key, dtype_integer(key), number, 1, lower=0, upper=num_edges + ) + + return key, random_edges + + @property + def element_shape(self): + """ + :return: + [1]. + """ + return [1] diff --git a/notebooks/EdgeSpaceGraph.ipynb b/notebooks/EdgeSpaceGraph.ipynb new file mode 100644 index 00000000..c4f847ef --- /dev/null +++ b/notebooks/EdgeSpaceGraph.ipynb @@ -0,0 +1,927 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on (Oriented) Graphs\n", + "This notebook shows how to define and evaluate kernels on the edge space of an oriented simple graph.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For testing, we need to set the path right. **This is to be removed by code reviewers**." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [], + "source": [ + "# Import a backend, we use numpy in this example.\n", + "import numpy as np\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "# import geometric_kernels.jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of the graph.\n", + "\n", + "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. The entry `incidence_matrix[i, j]` is `-1` if node `i` is the source of edge `j`, `1` if node `i` is the target of edge `j`, and `0` otherwise. \n", + "\n", + "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations.\n", + "\n", + "This space essentially contains the Edge-Laplacian matrix, which is the Laplacian matrix of the edge space of the graph. In the general case, it is the Hodge-Laplacian matrix of the edge space of a simplicial 2-complex.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "\n", + "\n", + "edge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n" + ] + } + ], + "source": [ + "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", + "edge_graph = GraphEdge(incidence_matrix)\n", + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('incidence matrix:\\n', incidence_matrix)\n", + "print('\\n')\n", + "print('edge Laplacian:\\n', edge_graph.edge_laplacian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `edge_graph` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(edge_graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = np.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = np.array([3/2])\n", + "params_inf[\"nu\"] = np.array([np.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n" + ] + } + ], + "source": [ + "key = np.random.RandomState(1234)\n", + "\n", + "key, xs = edge_graph.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = np.min([np.min(kernel_mat_32), np.min(kernel_mat_inf)])\n", + "maxmax = np.max([np.max(kernel_mat_32), np.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "other_edges = np.arange(edge_graph.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, np.array([[base_edge]]),\n", + " other_edges).flatten()\n", + "values_inf = kernel.K(params_inf, np.array([[base_edge]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_32, other_edges)\n", + "variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.18,\n", + "Variance in the edge (1,3) is 0.20,\n", + "The average variance is 0.17.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % np.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[3]\n", + " [5]\n", + " [4]]\n", + "\n", + "emedding (shape = (3, 6)):\n", + "[[-4.17448397e-02 3.83051484e-01 1.08504235e-01 -5.26867410e-02\n", + " 1.02519158e-01 -4.08723427e-02]\n", + " [ 3.28045722e-01 -6.11498784e-02 2.26833021e-16 -1.70497875e-01\n", + " -9.57952499e-17 5.05209940e-02]\n", + " [-3.28045722e-01 6.11498784e-02 1.75563540e-01 -3.25621967e-02\n", + " -6.33603240e-02 6.61328397e-02]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.163336342344337e-17\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[ 0.36024923 -0.21070873]\n", + " [-0.02141462 -0.21293585]\n", + " [-0.14648103 0.75575338]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = np.random.RandomState(seed=1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = np.random.RandomState(seed=1234)\n", + "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/EdgeSpaceSimplicialComplex.ipynb b/notebooks/EdgeSpaceSimplicialComplex.ipynb new file mode 100644 index 00000000..52bd14e5 --- /dev/null +++ b/notebooks/EdgeSpaceSimplicialComplex.ipynb @@ -0,0 +1,1082 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For testing, we need to set the path right. **This is to be removed by code reviewers**." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [], + "source": [ + "# Import a backend, we use numpy in this example.\n", + "import numpy as np\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "# import geometric_kernels.jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the triangle set " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "triangles = [(1,2,3)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "# shade the area of the triangle\n", + "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the sets of nodes, edges and triangles. \n", + "\n", + "**Note that**: \n", + "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", + "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('triangles:', triangles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", + "\n", + "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. \n", + "\n", + "The entry `incidence_matrix[i, e]` is \n", + "- `-1` if node `i` is the source of edge `e`, \n", + "- `1` if node `i` is the target of edge `e`, and \n", + "- `0` otherwise. \n", + "\n", + "The `edge_triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph.\n", + "\n", + "The entry `edge_triangle_incidence_matrix[e, t]` is\n", + "- `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$,\n", + "- `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and\n", + "- `0` otherwise.\n", + "\n", + "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def triangles_to_B2(striangles: list, edges: list) -> np.ndarray:\n", + " \"\"\"\n", + " Create the B2 matrix (edge-triangle) from the triangles.\n", + "\n", + " Args:\n", + " triangles (list): List of triangles.\n", + " edges (list): List of edges.\n", + "\n", + " Returns:\n", + " np.ndarray: B2 matrix.\n", + " \"\"\"\n", + " B2 = np.zeros((len(edges), len(triangles)))\n", + " for j, triangle in enumerate(triangles):\n", + " a, b, c = triangle\n", + " try:\n", + " index_a = edges.index((a, b))\n", + " except ValueError:\n", + " index_a = edges.index((b, a))\n", + " try:\n", + " index_b = edges.index((b, c))\n", + " except ValueError:\n", + " index_b = edges.index((c, b))\n", + " try:\n", + " index_c = edges.index((a, c))\n", + " except ValueError:\n", + " index_c = edges.index((c, a))\n", + "\n", + " B2[index_a, j] = 1\n", + " B2[index_c, j] = -1\n", + " B2[index_b, j] = 1\n", + "\n", + " return B2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "\n", + "\n", + "edge triangle incidence matrix:\n", + " [[ 1.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 1.]\n", + " [ 0.]\n", + " [ 0.]]\n" + ] + } + ], + "source": [ + "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", + "edge_triangle_incidence_matrix = triangles_to_B2(triangles, list(G.edges))\n", + "print('incidence matrix:\\n', incidence_matrix)\n", + "print('\\n')\n", + "print('edge triangle incidence matrix:\\n', edge_triangle_incidence_matrix)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the Simplicial 2-Complex " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hodge Laplacian:\n", + " [[ 3. 0. 1. 0. 0. 0.]\n", + " [ 0. 3. 1. 0. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [ 0. 0. 0. 3. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Down Hodge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Up Hodge Laplacian:\n", + " [[ 1. -1. 0. 1. 0. 0.]\n", + " [-1. 1. 0. -1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 1. -1. 0. 1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "sc = GraphEdge(incidence_matrix, edge_triangle_incidence_matrix)\n", + "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('\\n')\n", + "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('\\n')\n", + "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(sc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = np.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = np.array([3/2])\n", + "params_inf[\"nu\"] = np.array([np.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n" + ] + } + ], + "source": [ + "key = np.random.RandomState(1234)\n", + "\n", + "key, xs = sc.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = np.min([np.min(kernel_mat_32), np.min(kernel_mat_inf)])\n", + "maxmax = np.max([np.max(kernel_mat_32), np.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "other_edges = np.arange(sc.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, np.array([[base_edge]]),\n", + " other_edges).flatten()\n", + "values_inf = kernel.K(params_inf, np.array([[base_edge]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_32, other_edges)\n", + "variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "# shade the area of the triangle\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.08,\n", + "Variance in the edge (1,3) is 0.13,\n", + "The average variance is 0.17.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % np.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[3]\n", + " [5]\n", + " [4]]\n", + "\n", + "emedding (shape = (3, 6)):\n", + "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 -1.29344481e-01\n", + " 5.15670639e-02 1.39200889e-01]\n", + " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 -1.59503941e-16\n", + " -6.37403964e-02 7.76266537e-16]\n", + " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 7.99392856e-02\n", + " -8.34372621e-02 9.36873407e-17]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-0.12815855 0.03939647]\n", + " [-0.35448662 0.8352028 ]\n", + " [-0.08106564 -0.25947495]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = np.random.RandomState(seed=1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = np.random.RandomState(seed=1234)\n", + "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/Graph.ipynb b/notebooks/Graph.ipynb index 8c18fd17..285e2986 100644 --- a/notebooks/Graph.ipynb +++ b/notebooks/Graph.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "id": "N2YCQeyY50Xg" }, @@ -61,7 +61,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -74,7 +86,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n" + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" ] } ], @@ -118,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "id": "PM1H-As8-KF7" }, @@ -136,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -152,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -165,7 +178,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -195,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -227,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -249,14 +262,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "params: {'lengthscale': array(1.), 'nu': array(inf)}\n" + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" ] } ], @@ -283,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -319,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -349,7 +362,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -366,12 +379,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -425,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -442,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -461,7 +474,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -470,6 +483,27 @@ "variance_inf = kernel.K_diag(params_inf, other_points)" ] }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.4852701 , 1.08578832, 1.08578832, 1.08578832, 1.08578832,\n", + " 1.08578832, 1.08578832])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "variance_32" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -481,12 +515,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -523,7 +557,7 @@ "\n", "# Plot kernel values 32\n", "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=values_32,\n", - " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors, edge_color='red',\n", " linewidths=2.0, **kwargs)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -578,7 +612,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -631,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -659,7 +693,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -672,14 +706,14 @@ " [5]]\n", "\n", "emedding (shape = (3, 7)):\n", - "[[-6.41113328e-01 -1.64036543e-01 -2.00902915e-01 -4.58519688e-17\n", - " -4.04993805e-18 7.78093645e-01 -4.54128597e-02]\n", - " [-6.41113328e-01 -1.64036543e-01 -2.00902915e-01 -3.66796862e-01\n", - " 6.35310801e-01 -2.59364548e-01 -4.54128597e-02]\n", - " [-6.41113328e-01 -1.64036543e-01 -2.00902915e-01 -3.66796862e-01\n", - " -6.35310801e-01 -2.59364548e-01 -4.54128597e-02]]\n", + "[[-0.64111333 -0.10633366 0.79213149 -0.10633366 -0.10633366 -0.10633366\n", + " -0.04541286]\n", + " [-0.64111333 -0.10633366 -0.10633366 -0.10633366 -0.10633366 0.79213149\n", + " -0.04541286]\n", + " [-0.64111333 -0.10633366 -0.10633366 -0.10633366 0.79213149 -0.10633366\n", + " -0.04541286]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.839349969133127e-16\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 2.220446049250313e-16\n" ] } ], @@ -719,7 +753,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -727,9 +761,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[ 0.45905103 1.50022096]\n", - " [-1.03938522 -0.72020871]\n", - " [-1.05932937 2.12939523]]\n" + "[[-1.28404228 1.792016 ]\n", + " [ 0.3966486 1.88615994]\n", + " [-0.62251577 -1.02004327]]\n" ] } ], @@ -759,12 +793,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -860,9 +894,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "gkconda_updated_sh", + "display_name": "base", "language": "python", - "name": "gkconda_updated_sh" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -874,7 +908,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/notebooks/backends/JAX_EdgeSpaceGraph.ipynb b/notebooks/backends/JAX_EdgeSpaceGraph.ipynb new file mode 100644 index 00000000..1c74af8e --- /dev/null +++ b/notebooks/backends/JAX_EdgeSpaceGraph.ipynb @@ -0,0 +1,939 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on (Oriented) Graphs\n", + "This notebook shows how to define and evaluate kernels on the edge space of an oriented simple graph.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For testing, we need to set the path right. **This is to be removed by code reviewers**." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): JAX backend enabled.\n" + ] + }, + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'geometric_kernels.spaces.graph_edge'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 17\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m jax\n\u001b[1;32m 16\u001b[0m \u001b[38;5;66;03m# Import a space and an appropriate kernel.\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mspaces\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgraph_edge\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m GraphEdge\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mkernels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MaternGeometricKernel\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# We use networkx to visualize graphs\u001b[39;00m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'geometric_kernels.spaces.graph_edge'" + ] + } + ], + "source": [ + "# Import a backend, we use jax in this example.\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from jax.random import PRNGKey\n", + "jax.config.update(\"jax_enable_x64\", True) # enable float64 in JAX\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "from geometric_kernels import jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of the graph.\n", + "\n", + "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. The entry `incidence_matrix[i, j]` is `-1` if node `i` is the source of edge `j`, `1` if node `i` is the target of edge `j`, and `0` otherwise. \n", + "\n", + "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations.\n", + "\n", + "This space essentially contains the Edge-Laplacian matrix, which is the Laplacian matrix of the edge space of the graph. In the general case, it is the Hodge-Laplacian matrix of the edge space of a simplicial 2-complex.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'GraphEdge' 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 2\u001b[0m\n\u001b[1;32m 1\u001b[0m incidence_matrix \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39marray(nx\u001b[38;5;241m.\u001b[39mincidence_matrix(G, oriented\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\u001b[38;5;241m.\u001b[39mtoarray())\n\u001b[0;32m----> 2\u001b[0m edge_graph \u001b[38;5;241m=\u001b[39m \u001b[43mGraphEdge\u001b[49m(incidence_matrix)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnodes:\u001b[39m\u001b[38;5;124m'\u001b[39m, G\u001b[38;5;241m.\u001b[39mnodes)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124medges:\u001b[39m\u001b[38;5;124m'\u001b[39m, G\u001b[38;5;241m.\u001b[39medges)\n", + "\u001b[0;31mNameError\u001b[0m: name 'GraphEdge' is not defined" + ] + } + ], + "source": [ + "incidence_matrix = jnp.array(nx.incidence_matrix(G, oriented=True).toarray())\n", + "edge_graph = GraphEdge(incidence_matrix)\n", + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('incidence matrix:\\n', incidence_matrix)\n", + "print('\\n')\n", + "print('edge Laplacian:\\n', edge_graph.edge_laplacian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `edge_graph` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(edge_graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = jnp.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = jnp.array([3/2])\n", + "params_inf[\"nu\"] = jnp.array([jnp.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n" + ] + } + ], + "source": [ + "key = PRNGKey(1234)\n", + "\n", + "key, xs = edge_graph.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = min([jnp.min(kernel_mat_32), jnp.min(kernel_mat_inf)])\n", + "maxmax = max([jnp.max(kernel_mat_32), jnp.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "other_edges = jnp.arange(edge_graph.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, jnp.array([[base_edge]]),\n", + " other_edges).flatten()\n", + "values_inf = kernel.K(params_inf, jnp.array([[base_edge]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_32, other_edges)\n", + "variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.18,\n", + "Variance in the edge (1,3) is 0.20,\n", + "The average variance is 0.17.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % jnp.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[3]\n", + " [5]\n", + " [4]]\n", + "\n", + "emedding (shape = (3, 6)):\n", + "[[-4.17448397e-02 3.83051484e-01 1.08504235e-01 -5.26867410e-02\n", + " 1.02519158e-01 -4.08723427e-02]\n", + " [ 3.28045722e-01 -6.11498784e-02 2.26833021e-16 -1.70497875e-01\n", + " -9.57952499e-17 5.05209940e-02]\n", + " [-3.28045722e-01 6.11498784e-02 1.75563540e-01 -3.25621967e-02\n", + " -6.33603240e-02 6.61328397e-02]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.163336342344337e-17\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = jnp.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', jnp.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[ 0.36024923 -0.21070873]\n", + " [-0.02141462 -0.21293585]\n", + " [-0.14648103 0.75575338]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = PRNGKey(1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = PRNGKey(1234)\n", + "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb b/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb new file mode 100644 index 00000000..e4471ec0 --- /dev/null +++ b/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb @@ -0,0 +1,1085 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For testing, we need to set the path right. **This is to be removed by code reviewers**." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [], + "source": [ + "# Import a backend, we use jax in this example.\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from jax.random import PRNGKey\n", + "jax.config.update(\"jax_enable_x64\", True) # enable float64 in JAX\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "from geometric_kernels import jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the triangle set " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "triangles = [(1,2,3)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "# shade the area of the triangle\n", + "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the sets of nodes, edges and triangles. \n", + "\n", + "**Note that**: \n", + "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", + "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('triangles:', triangles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", + "\n", + "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. \n", + "\n", + "The entry `incidence_matrix[i, e]` is \n", + "- `-1` if node `i` is the source of edge `e`, \n", + "- `1` if node `i` is the target of edge `e`, and \n", + "- `0` otherwise. \n", + "\n", + "The `edge_triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph.\n", + "\n", + "The entry `edge_triangle_incidence_matrix[e, t]` is\n", + "- `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$,\n", + "- `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and\n", + "- `0` otherwise.\n", + "\n", + "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def triangles_to_B2(striangles: list, edges: list) -> np.ndarray:\n", + " \"\"\"\n", + " Create the B2 matrix (edge-triangle) from the triangles.\n", + "\n", + " Args:\n", + " triangles (list): List of triangles.\n", + " edges (list): List of edges.\n", + "\n", + " Returns:\n", + " np.ndarray: B2 matrix.\n", + " \"\"\"\n", + " B2 = np.zeros((len(edges), len(triangles)))\n", + " for j, triangle in enumerate(triangles):\n", + " a, b, c = triangle\n", + " try:\n", + " index_a = edges.index((a, b))\n", + " except ValueError:\n", + " index_a = edges.index((b, a))\n", + " try:\n", + " index_b = edges.index((b, c))\n", + " except ValueError:\n", + " index_b = edges.index((c, b))\n", + " try:\n", + " index_c = edges.index((a, c))\n", + " except ValueError:\n", + " index_c = edges.index((c, a))\n", + "\n", + " B2[index_a, j] = 1\n", + " B2[index_c, j] = -1\n", + " B2[index_b, j] = 1\n", + "\n", + " return B2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "\n", + "\n", + "edge triangle incidence matrix:\n", + " [[ 1.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 1.]\n", + " [ 0.]\n", + " [ 0.]]\n" + ] + } + ], + "source": [ + "incidence_matrix = jnp.array(nx.incidence_matrix(G, oriented=True).toarray())\n", + "edge_triangle_incidence_matrix = jnp.array(triangles_to_B2(triangles, list(G.edges)))\n", + "print('incidence matrix:\\n', incidence_matrix)\n", + "print('\\n')\n", + "print('edge triangle incidence matrix:\\n', edge_triangle_incidence_matrix)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the Simplicial 2-Complex " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hodge Laplacian:\n", + " [[ 3. 0. 1. 0. 0. 0.]\n", + " [ 0. 3. 1. 0. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [ 0. 0. 0. 3. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Down Hodge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Up Hodge Laplacian:\n", + " [[ 1. -1. 0. 1. 0. 0.]\n", + " [-1. 1. 0. -1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 1. -1. 0. 1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "sc = GraphEdge(incidence_matrix, edge_triangle_incidence_matrix)\n", + "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('\\n')\n", + "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('\\n')\n", + "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(sc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = jnp.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = jnp.array([3/2])\n", + "params_inf[\"nu\"] = jnp.array([jnp.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n" + ] + } + ], + "source": [ + "key = PRNGKey(1234)\n", + "\n", + "key, xs = sc.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = min([jnp.min(kernel_mat_32), jnp.min(kernel_mat_inf)])\n", + "maxmax = max([jnp.max(kernel_mat_32), jnp.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "other_edges = jnp.arange(sc.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, jnp.array([[base_edge]]),\n", + " other_edges).flatten()\n", + "values_inf = kernel.K(params_inf, jnp.array([[base_edge]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_32, other_edges)\n", + "variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "# shade the area of the triangle\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.08,\n", + "Variance in the edge (1,3) is 0.13,\n", + "The average variance is 0.17.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % jnp.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[3]\n", + " [5]\n", + " [4]]\n", + "\n", + "emedding (shape = (3, 6)):\n", + "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 -1.29344481e-01\n", + " 5.15670639e-02 1.39200889e-01]\n", + " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 -1.59503941e-16\n", + " -6.37403964e-02 7.76266537e-16]\n", + " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 7.99392856e-02\n", + " -8.34372621e-02 9.36873407e-17]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = jnp.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', jnp.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-0.12815855 0.03939647]\n", + " [-0.35448662 0.8352028 ]\n", + " [-0.08106564 -0.25947495]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = PRNGKey(1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = PRNGKey(seed=1234)\n", + "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/backends/JAX_Graph.ipynb b/notebooks/backends/JAX_Graph.ipynb index ee7e5e68..1e839545 100644 --- a/notebooks/backends/JAX_Graph.ipynb +++ b/notebooks/backends/JAX_Graph.ipynb @@ -101,7 +101,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", "INFO (geometric_kernels): JAX backend enabled.\n" ] } @@ -196,7 +197,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -287,7 +288,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "params: {'lengthscale': array(1.), 'nu': array(inf)}\n" + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" ] } ], @@ -411,7 +412,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAEJCAYAAABG9Sd8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAYCklEQVR4nO3df2xV9f3H8de5hbbwhQs67C3UQmFM1CEwS2iqmwMttMwU3UYkMKA2gNHRBVsNyiY/NgfEGbuyDNPIKDiHGUu3LMvo6Fi3zjFZcLgatwlEUGGyXtqgFitQued8/wCuK1R6zuWWTz/wfJjPHxw+55zPXXLGK+/P53OO43meJwAAAENCpgcAAACuboQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEkV5g1apVchxHra2tpocC4DJIxjPf2Ngox3HU2NiY0PnRaFQzZ87UZz7zGTmOo6qqqoTHAlwqwsgV4siRI5o7d67GjBmjgQMHavDgwZo0aZKef/55nf/G/1/96leaNWuWRo0apf79+2vMmDF65JFH9P7775sZPIDLrry8XPX19Vq2bJleeOEFFRUVmR4SrmJ9TA8AydHa2qr//Oc/mjlzpoYPH66PP/5YO3bs0P333699+/ZpzZo18b4PPPCAhg0bprlz52r48OF6/fXX9eMf/1h1dXV69dVX1a9fP4O/BIAfd9xxh06cOKHU1NSEzv/jH/+oe+65R48++miSRwYERxi5QowbN+6Ccm1ZWZmKi4v1ox/9SE8++aRSUlIkSbW1tZo8eXKnvrm5uSopKdGWLVu0cOHCyzRqAIkKhUJKT09P+PyjR49q8ODByRsQcAmYpuml3nnnHY0ePVpjx45VNBpN+Do5OTn66KOP1NHRET92fhCRpK9+9auSpDfeeCPhewFIXNBnvqs1I5MnT9bYsWP173//W1OmTFH//v2VlZWlH/zgB/E+mzdvluM48jxP69evl+M4chynJ34SesDJkyfV1tYWqJ08edL0sLtFZaQXOnDggO68805de+212rFjh4YMGeL73BMnTqi9vV0ffvih/vznP2vTpk3Kz8/vduqlublZkgLdC0ByXMozf7733ntPRUVF+trXvqb77rtPtbW1euyxx3TLLbdo+vTpuuOOO/TCCy9o3rx5mjp1qubPn5/EX4KedPLkSY0cMUDNR2OBzsvMzNRbb711SZW0nkYY6WX27t2ru+66S1lZWaqvr9c111wT6Px169Zp2bJl8T/fdddd2rRpU7fnPfXUU0pJSdHMmTMDjxlA4i71mT/fkSNH9NOf/lTz5s2TJC1YsEAjRozQxo0bNX36dI0aNUqjRo3SvHnzdMMNN2ju3LnJ+Bm4DDo6OtR8NKa39oxQeKC/iY22465G5r6jjo4Owgj8+ec//6lZs2Zp9OjR+t3vfqdwOBz4GrNnz9bEiRPV0tKi3/72t4pGozpx4sRFz3nxxRe1ceNGLV26VJ/73OcSHT6AgJLxzJ9vwIABnQJGamqqJk2apIMHD17ytdE7/N+AM82PmNd9n96ANSO9SHFxsQYOHKj6+vqE/09pxIgRKigo0OzZs7VlyxaNGjVKBQUFnxpI/vKXv2jBggUqLCzU6tWrL2X4AAJKxjN/vuuvv/6CNSDXXHON3nvvvaRcH+a58gI1GxBGepGvf/3rOnDggLZs2ZK0a86cOVOHDx/WSy+9dMHfvfbaa5oxY4bGjh2r2tpa9elDoQy4nHrimT+3a+58579vCPZyA/5nA/716UWefvpp9enTR9/85jc1cOBAzZkz55Kvea4i8sEHH3Q6fuDAARUVFSkjI0N1dXUaMMBnzQ9A0vTEM48rX8zzFPMZLv32M40w0os4jqPnnntOx48fV0lJiQYMGKAZM2b4OrelpUXXXXfdBcc3btwox3F06623xo81Nzdr2rRpCoVCqq+v7/I8AD3vUp55XL2CTL/YMk1DGOllQqGQfvazn+nee+/Vfffdp7q6Ot15553dnrd69Wr99a9/VVFRkYYPH65jx47pl7/8pV555RV961vf0ujRo+N9i4qKdPDgQS1dulQ7d+7Uzp07438XiUQ0derUHvltAC6U6DOPq9dpufo4QF8bEEZ6ob59+6q2tlbTp0/XPffcoz/84Q/Ky8u76Dl33323Dhw4oJqaGrW0tCg9PV3jxo3Tpk2bVFJS0qnva6+9JkmdXoR0zpe//GXCCHCZJfLM4+p1JU7TOB6rmgAA6PXa2to0aNAg7X0jooE+3zNy/LirG2+K6oMPPkjajq2eQGUEAACLxOQp5nMtiN9+phFGerkTJ05csBPmfNdee23CX+4E0LvwzKM7Mc//y8xseekZYaSX27p1q0pLSy/a509/+lOXH78DYB+eeXTHPdv89rUBYaSXKyws1I4dOy7aZ/z48ZdpNAB6Gs88uuPKUUz+vrTs+uxnGmGklxs6dKiGDh1qehgALhOeeXTH9c40v31tQBgBAMAisQCVEb/9TCOMAABgkas6jLjNfFq+K4XDJpgeQq/k5H7e9BB6rd+/ssr0EHxpO5Jtegi90rRHHjY9hF7p+HC+u/pp/vVUeVKv53qOXM/nmhGf/UyjMgIAgEWu6soIAAAwL6aQYvJXiYr18FiShTACAIBFvADTNJ4l0zRM8gEAYJFz0zR+WxAvvfSSiouLNWzYMDmOo1//+tfdntPY2Khbb71VaWlpGj16tDZv3hz4NxFGAACwSMwLBWpBtLe3a/z48Vq/fr2v/m+99ZbuvvtuTZkyRU1NTXr44Ye1cOFC1dfXB7ov0zQAAFjkY4X0sVJ89g1m+vTpmj59uu/+1dXVGjlypJ555hlJ0k033aSdO3fqhz/8oQoLC31fh8oIAAAW6cnKSFC7du1SQUFBp2OFhYXatWtXoOtQGQEAwCKuHN/fnDnXr62trdPxtLQ0paWlXfJYmpubFYlEOh2LRCJqa2vTiRMn1K9fP1/XoTICAIBF3LNbe/009+w/89nZ2Ro0aFC8rV271vCv6IzKCAAAFgky/RLzznwp7/DhwwqHw/HjyaiKSFJmZqai0WinY9FoVOFw2HdVRCKMAABgFfd/Kh7d9z0TRsLhcKcwkiz5+fmqq6vrdGzHjh3Kz88PdB2maQAAsEjMcwK1ID788EM1NTWpqalJ0pmtu01NTTp06JAkadmyZZo/f368/4MPPqiDBw9q6dKl2rt3r5599ln94he/UHl5sO/xUBkBAMAiwV4H7wW69t///ndNmTIl/ueKigpJUklJiTZv3qz//ve/8WAiSSNHjtS2bdtUXl6udevW6frrr9dPfvKTQNt6JcIIAABWcb2QXJ9rRlwvWBiZPHmyvIuc09XbVSdPnqx//OMfge5zPsIIAAAW6cnKiCmEEQAALOJKvteCuD07lKQhjAAAYJFgu2ns2KdCGAEAwCLB3jNCGAEAAEmWyOvgezvCCAAAFunw+ijF8/fPd4cd61cJIwAA2MT1HLl+F7AGfOmZKYQRAAAs4gbY2ssCVgAAkHTBXnpGGAEAAEkWk6OYz4WpfvuZRhgBAMAiVEYAAIBRMfmveMR6dihJQxgBAMAiVEYAAIBRvIEVAAAY5QV4A6vHAlYAAJBsVEYAAIBRvIEVAAAYFQvwBla//UwjjAAAYBEqIwAAwChXId/fnOHbNAAAIOlinqOYz4qH336mEUYAALBIzE3RaTfFZ1+3h0eTHIQRAAAswofyAACAUa7nf2Gq6/XwYJKEMAIAgEX4Ng0AADDKDfA6eL/9TCOMAABgEXbTAAAAo5imAQAARrkK8AZWpmkAAECyeQHWjHiEEQAAkGx8mwYAABjFmhEAAGAUlREAAGAU7xkBAABGURkBAABGnXZDclx/a0FO++xnGmEEAACLUBkBAABGefK/FsSSj/YSRgAAsAmVEQAAYBRhBAAAGEUYAQAARhFGAACAUZ7nyPMZMvz2M40wAgCARXgDKwAAMIppGgAAYBTTNAAAwCgqIwAAwCgqIwAAwCgvQGXEljBix+f8AACApDPfm/E8ny3Be6xfv145OTlKT09XXl6edu/efdH+VVVVGjNmjPr166fs7GyVl5fr5MmTvu9HZQQAAIvEvJDk+aslxHz2+19bt25VRUWFqqurlZeXp6qqKhUWFmrfvn3KyMi4oP+LL76oxx9/XDU1Nbrtttu0f/9+3X///XIcR5WVlb7uSWUEAACLnFvA6rcFVVlZqUWLFqm0tFQ333yzqqur1b9/f9XU1HTZ/+WXX9btt9+uOXPmKCcnR9OmTdPs2bO7rab8L8IIAAAW8T1Fc7ZJUltbW6d26tSpLq/d0dGhPXv2qKCgIH4sFAqpoKBAu3bt6vKc2267TXv27ImHj4MHD6qurk5f+cpXfP8mpmkAALBIIrtpsrOzOx1fuXKlVq1adUH/1tZWxWIxRSKRTscjkYj27t3b5T3mzJmj1tZWffGLX5TneTp9+rQefPBBffvb3/Y1RokwAgCAVRIJI4cPH1Y4HI4fT0tLS9p4GhsbtWbNGj377LPKy8vTm2++qSVLlujJJ5/U8uXLfV3DdxgpHDYh0XFe0eqPNJkeQq9UVPx500PAJZr2yMOmh9Ar/f6ZKtND6JXy11WYHsJVw/UcOQFfehYOhzuFkU8zZMgQpaSkKBqNdjoejUaVmZnZ5TnLly/XvHnztHDhQknSLbfcovb2dj3wwAP6zne+o1Co+xUhrBkBAMAiiawZ8Ss1NVW5ublqaGiIH3NdVw0NDcrPz+/ynI8++uiCwJGSknJ2rP4GwDQNAAAWORMy/E7TBL9+RUWFSkpKNHHiRE2aNElVVVVqb29XaWmpJGn+/PnKysrS2rVrJUnFxcWqrKzUF77whfg0zfLly1VcXBwPJd0hjAAAYJGefh38rFmz1NLSohUrVqi5uVkTJkzQ9u3b44taDx061KkS8sQTT8hxHD3xxBN69913dd1116m4uFirV6/2fU/CCAAAFvHk/82qib6BtaysTGVlZV3+XWNjY6c/9+nTRytXrtTKlSsTvBthBAAAq/ChPAAAYNblKI1cZoQRAABsEqAyIiojAAAg2YJs2U1kN40JhBEAACzCmhEAAGCU5zryXJ9hxGc/0wgjAADYhAWsAADAJKZpAACAeZZUPPwijAAAYBEqIwAAwCzWjAAAALOcs81v396PMAIAgE2ojAAAAKMIIwAAwCjP8f/NGRawAgCAZOPbNAAAwCymaQAAgFFM0wAAAJMc70zz29cGhBEAAGzCNA0AADDKdc40v30tQBgBAMAmVEYAAIBRhBEAAGAUu2kAAIBJ7KYBAABmXYHTNCHTAwAAAFc3KiMAAFjEUYBpmh4dSfIQRgAAsAkLWAEAgFFX4JoRwggAADYhjAAAAJPY2gsAAMyiMgIAAIwijAAAAJOYpgEAAGaxtRcAAJjkuGea3742IIwAAGAT1owAAACjAqwZIYwAAIDkozICAACMIowAAACTrsStvSHTAwAAAFc3KiMAANiEaRoAAGDSlThNQxgBAMA2loQMvwgjAADYhGkaAABg0pU4TcNuGgAAbOIFbAlYv369cnJylJ6erry8PO3evfui/d9//30tXrxYQ4cOVVpamm644QbV1dX5vh+VEQAALNLTlZGtW7eqoqJC1dXVysvLU1VVlQoLC7Vv3z5lZGRc0L+jo0NTp05VRkaGamtrlZWVpXfeeUeDBw/2fU/CCAAANnHPNr99A6qsrNSiRYtUWloqSaqurta2bdtUU1Ojxx9//IL+NTU1OnbsmF5++WX17dtXkpSTkxPonkzTAABgkXOVEb9Nktra2jq1U6dOdXntjo4O7dmzRwUFBfFjoVBIBQUF2rVrV5fn/OY3v1F+fr4WL16sSCSisWPHas2aNYrFYr5/E2EEAACbJLBmJDs7W4MGDYq3tWvXdnnp1tZWxWIxRSKRTscjkYiam5u7POfgwYOqra1VLBZTXV2dli9frmeeeUbf//73ff8kpmkAALBJAlt7Dx8+rHA4HD+clpaWtOG4rquMjAw999xzSklJUW5urt599109/fTTWrlypa9rEEYAALBIIgtYw+FwpzDyaYYMGaKUlBRFo9FOx6PRqDIzM7s8Z+jQoerbt69SUlLix2666SY1Nzero6NDqamp3d6XaRoAAGzSg1t7U1NTlZubq4aGhvgx13XV0NCg/Pz8Ls+5/fbb9eabb8p1P1ktu3//fg0dOtRXEJEIIwAAWCWRBaxBVFRUaMOGDXr++ef1xhtv6KGHHlJ7e3t8d838+fO1bNmyeP+HHnpIx44d05IlS7R//35t27ZNa9as0eLFi33fk2kaAABs0sOvg581a5ZaWlq0YsUKNTc3a8KECdq+fXt8UeuhQ4cUCn1Sy8jOzlZ9fb3Ky8s1btw4ZWVlacmSJXrsscd835MwAgCATS7Dt2nKyspUVlbW5d81NjZecCw/P19/+9vfEruZCCMAAFjFOdv89rUBYQQAAJvw1V4AAGDSlfjVXsIIAAA2oTICAACMsyRk+EUYAQDAIkzTAAAAoxz3TPPb1wa+w4iT+/meHIe1ior536Ur7SMGmB4CLtHx4byguSv56ypMDwFXO9aMAAAAk5imAQAAZlEZAQAARhFGAACASUzTAAAAs6iMAAAAkxzPk+P5Sxl++5lGGAEAwCZURgAAgEmsGQEAAGZRGQEAACZRGQEAAGZRGQEAACZRGQEAAGZRGQEAAEZ5nhzXZ8rgPSMAACDZmKYBAABmMU0DAABMctwzzW9fGxBGAACwCZURAABgEmtGAACAWZ7nf5cMu2kAAECyURkBAABmsWYEAACYRGUEAACYxZoRAABgEpURAABgFmtGAACASVRGAACAWa53pvntawHCCAAAFnG8AN+msSOLEEYAALAKu2kAAIBJrBkBAABmsZsGAACY5HieHJ/TL377mUYYAQDAJu7Z5revBQgjAABYhMoIAAAwizUjAADAKLb2AgAAk9jaCwAAzKIyAgAATHLcAK+DZzcNAABIuiuwMhIyPQAAABCAF7AlYP369crJyVF6erry8vK0e/duX+f9/Oc/l+M4uvfeewPdjzACAIBFzr1nxG8LauvWraqoqNDKlSv16quvavz48SosLNTRo0cvet7bb7+tRx99VF/60pcC35MwAgCATVxPivlsbvAwUllZqUWLFqm0tFQ333yzqqur1b9/f9XU1HzqObFYTN/4xjf03e9+V6NGjQp8T8IIAAAWSaQy0tbW1qmdOnWqy2t3dHRoz549KigoiB8LhUIqKCjQrl27PnVM3/ve95SRkaEFCxYk9JsIIwAA2MTTJ4tYu21nTsnOztagQYPibe3atV1eurW1VbFYTJFIpNPxSCSi5ubmLs/ZuXOnNm7cqA0bNiT8k9hNAwCATRLYTXP48GGFw+H44bS0tKQM5fjx45o3b542bNigIUOGJHwdwggAADZxJTkB+koKh8OdwsinGTJkiFJSUhSNRjsdj0ajyszMvKD/gQMH9Pbbb6u4uPiTW7pnbtqnTx/t27dPn/3sZ7u9L9M0AABYpCd306Smpio3N1cNDQ3xY67rqqGhQfn5+Rf0v/HGG/X666+rqakp3mbMmKEpU6aoqalJ2dnZvu5LZQQAAJv08EvPKioqVFJSookTJ2rSpEmqqqpSe3u7SktLJUnz589XVlaW1q5dq/T0dI0dO7bT+YMHD5akC45fDGEEAACb9HAYmTVrllpaWrRixQo1NzdrwoQJ2r59e3xR66FDhxQKJXdihTACAIBNLsPr4MvKylRWVtbl3zU2Nl703M2bNwe+H2EEAACbJLCAtbcjjAAAYJEgC1MTeR28CYQRAABscgV+tZcwAgCATVxPcnyGjAS+TWMCYQQAAJtQGQEAAGYFCCMijAAAgGSjMgIAAIyKxSQv5q+v67OfYYQRAABsQmUEAAAY5XryvRaE3TQAACDpqIwAAACjPAUIIz06kqQhjAAAYBMqIwAAwCjXle8v4Ll2fCmPMAIAgE2ojAAAAKMIIwAAwKireWvv719Z1YPDANDb/OupctNDANAFz3Plef7WgvjtZxqVEQAAbOJ5/iseTNMAAICk8wJM0xBGAABA0rmu5PicfmGaBgAAJJsXi8lz/H2N1/P7dV/DCCMAANiEaRoAAGCU60kOYQQAAJjiefL9OnjCCAAASDbP9eT5rIx4hBEAAJB0XoAP5bGbBgAAJBuVEQAAYNRp75TvisdpfdzDo0kOwggAABZITU1VZmamdjbXBTovMzNTqampPTSq5HA8W2o4AABc5U6ePKmOjo5A56Smpio9Pb2HRpQchBEAAGBUyPQAAADA1Y0wAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACj/h8sXV1Mw5QrwgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -526,7 +527,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -710,14 +711,14 @@ " [0]]\n", "\n", "emedding (shape = (3, 7)):\n", - "[[ 6.41113328e-01 -1.49568079e-01 -6.27429672e-01 -1.91494425e-01\n", - " -4.33620981e-01 -1.78784271e-01 4.54128597e-02]\n", - " [ 6.41113328e-01 2.18591915e-01 1.75155061e-01 -5.48113035e-01\n", - " -2.98734457e-17 5.42042498e-01 4.54128597e-02]\n", - " [ 6.41113328e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 -0.00000000e+00 -2.72477158e-01]]\n", + "[[ 6.41113328e-01 -5.83886545e-02 6.17736550e-01 -4.27352887e-01\n", + " -3.11382096e-01 -9.00150537e-02 -4.54128597e-02]\n", + " [ 6.41113328e-01 -5.94955097e-01 -8.38744739e-02 -9.08091414e-02\n", + " 5.37162459e-01 -1.22079428e-01 -4.54128597e-02]\n", + " [ 6.41113328e-01 -1.39164210e-17 -1.80081302e-17 -1.70475463e-17\n", + " -3.65882793e-17 1.27432374e-17 2.72477158e-01]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.041272810440265e-16\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 2.4196749845665633e-16\n" ] } ], @@ -765,9 +766,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[ 0.3998562 0.46701571]\n", - " [ 1.33493251 -0.18550569]\n", - " [ 0.50898399 -0.45234307]]\n" + "[[ 1.10845648 -0.5087827 ]\n", + " [-0.14199361 -0.39358291]\n", + " [ 0.01605173 0.02902955]]\n" ] } ], @@ -802,7 +803,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -896,9 +897,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "gkconda_updated_sh", + "display_name": "base", "language": "python", - "name": "gkconda_updated_sh" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -910,7 +911,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb b/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb new file mode 100644 index 00000000..014182ad --- /dev/null +++ b/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb @@ -0,0 +1,952 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on (Oriented) Graphs\n", + "This notebook shows how to define and evaluate kernels on the edge space of an oriented simple graph.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For testing, we need to set the path right. **This is to be removed by code reviewers**." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): Torch backend enabled.\n" + ] + }, + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'geometric_kernels.spaces.graph_edge'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 14\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mtorch\u001b[39;00m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m# from geometric_kernels import jax\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# Import a space and an appropriate kernel.\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mspaces\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgraph_edge\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m GraphEdge\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mkernels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MaternGeometricKernel\n\u001b[1;32m 17\u001b[0m \u001b[38;5;66;03m# We use networkx to visualize graphs\u001b[39;00m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'geometric_kernels.spaces.graph_edge'" + ] + } + ], + "source": [ + "# Import a backend, we use jax in this example.\n", + "import torch\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "import geometric_kernels.torch\n", + "# from geometric_kernels import jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of the graph.\n", + "\n", + "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. The entry `incidence_matrix[i, j]` is `-1` if node `i` is the source of edge `j`, `1` if node `i` is the target of edge `j`, and `0` otherwise. \n", + "\n", + "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations.\n", + "\n", + "This space essentially contains the Edge-Laplacian matrix, which is the Laplacian matrix of the edge space of the graph. In the general case, it is the Hodge-Laplacian matrix of the edge space of a simplicial 2-complex.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "\n", + "\n", + "edge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n" + ] + } + ], + "source": [ + "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", + "incidence_matrix = torch.tensor(incidence_matrix, dtype=torch.float32)\n", + "edge_graph = GraphEdge(incidence_matrix)\n", + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('incidence matrix:\\n', incidence_matrix)\n", + "print('\\n')\n", + "print('edge Laplacian:\\n', edge_graph.edge_laplacian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `edge_graph` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(edge_graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = torch.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = torch.array([3/2])\n", + "params_inf[\"nu\"] = torch.array([torch.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n" + ] + } + ], + "source": [ + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "\n", + "key, xs = edge_graph.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = min([torch.min(kernel_mat_32), torch.min(kernel_mat_inf)])\n", + "maxmax = max([torch.max(kernel_mat_32), torch.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "other_edges = torch.arange(edge_graph.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, torch.tensor([[base_edge]]),\n", + " other_edges).flatten()\n", + "values_inf = kernel.K(params_inf, torch.tensor([[base_edge]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_32, other_edges)\n", + "variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.18,\n", + "Variance in the edge (1,3) is 0.20,\n", + "The average variance is 0.17.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % torch.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[3]\n", + " [5]\n", + " [4]]\n", + "\n", + "emedding (shape = (3, 6)):\n", + "[[-4.17448397e-02 3.83051484e-01 1.08504235e-01 -5.26867410e-02\n", + " 1.02519158e-01 -4.08723427e-02]\n", + " [ 3.28045722e-01 -6.11498784e-02 2.26833021e-16 -1.70497875e-01\n", + " -9.57952499e-17 5.05209940e-02]\n", + " [-3.28045722e-01 6.11498784e-02 1.75563540e-01 -3.25621967e-02\n", + " -6.33603240e-02 6.61328397e-02]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.163336342344337e-17\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = torch.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', torch.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[ 0.36024923 -0.21070873]\n", + " [-0.02141462 -0.21293585]\n", + " [-0.14648103 0.75575338]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb b/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb new file mode 100644 index 00000000..ed573640 --- /dev/null +++ b/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb @@ -0,0 +1,1087 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For testing, we need to set the path right. **This is to be removed by code reviewers**." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [], + "source": [ + "# Import a backend, we use jax in this example.\n", + "import torch\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "import geometric_kernels.torch\n", + "# from geometric_kernels import jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the triangle set " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "triangles = [(1,2,3)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAGjCAYAAACBlXr0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0MElEQVR4nO3df1TUdb4/8Of4AxoDUlGESoykKzJSesQFTfvmZiU321136BDYrTyCq3Qild3tWKPdK6C7tSH+aOTGsHutRS5nYStrlZO2tWWJSatXZMBCEX/tiqDyQxDQ5vuHC6EwMD8+vz/PxzmdYzDz4e3Z1qfz+Tzf75fB4XA4QEREJKMhci+AiIiIYURERLJjGBERkewYRkREJDuGERERyY5hREREsmMYERGR7BhGREQkO4YRERHJjmFERESyYxgREZHsGEZERCQ7hhEREcmOYURERLJjGBERkewYRkREJDuGERERyY5hREREsmMYERGR7BhGREQkO4YRERHJjmFERESyYxgREZHsGEZERCQ7hhEREcmOYURERLJjGBERkewYRkREJDuGERERyY5hREREshsm9wLc0draipqaGnR0dMDX1xfh4eHw8/OTe1lEROQlxYeR3W5Hbm4u9uzZg2PHjsHhcPR8z2AwYNKkSXj00UexbNkyREZGyrhSIiLylMHR+093BamtrUVqaipKS0sRFBQEs9mMGTNmIDIyEiNGjEBbWxvsdjsOHjyIkpIS1NfXY/78+bBarQgLC5N7+URE5AZFhpHNZsOKFSswZswYrF+/HvHx8fDx8XH6+s7OThQXF2P16tVobGxETk4OkpOTJVwxERF5Q3EFhqysLKSkpCAxMREVFRVISkoaMIgAwMfHB0lJSTh69CgSExORkpKCrKwsiVZMRETeUtQzI5vNBovFgoyMDFgsFrff7+/vj7y8PISGhsJisSA4OBhLliwRYaVERCQkxdymq62tRVRUFBITE5GXl3fT9w4ePIjt27fj008/xcmTJxEYGIjY2FhkZmbi3/7t3/pcy+FwYOnSpSgsLERFRQWfIRERKZxiwiguLg5VVVWoqKiAv7//Td+Lj4/Hl19+iaeeegr3338//vnPf2Lr1q1obW1FWVkZpkyZ0ud6zc3NiIqKQmRkJHbv3i3Vb4OIiDygiDCy2+0wmUwoKChAUlJSn+9/9dVXiI6OvunZ0XfffYeoqCjEx8fjj3/8Y7/X3bFjBxYtWgS73Y7JkyeLtn4iIvKOIsIoLS0NRUVFOH369KBlhd6mT58OAPjmm2/6/X5HRwdCQ0ORkJCAzZs3C7JWIiISniLadHv27IHZbHYriBwOB86fP48xY8Y4fY2vry/MZjP27t0rxDKJiEgksodRS0sLjh07hhkzZrj1voKCApw9exYJCQkDvi46OhrV1dVobW31ZplERCQi2cPo+PHjcDgcbh3lU11djRdeeAEzZ87Ec889N+BrTSYTHA4HampqvF0qERGJRPYw6ujoAACMGDHCpdf/85//xBNPPIE77rgDxcXFGDp06ICvNxqNN/0cIiJSHtk3vfr6+gIA2traBn1tU1MT4uLicPnyZXzxxRe48847B31Pe3v7TT+HiIiUR/ZPRuHh4TAYDLDb7QO+7urVq3jyySfx7bff4qOPPnL5tl5lZSUMBgPCw8OFWC4REYlA9jDy8/PDpEmTcPDgQaevuX79OhISErB//3786U9/wsyZM12+fnl5OSIiIjj3iIhIwWS/TQcAjz76KIqKipCTk9NvvTs9PR07d+7Ek08+iYsXL/bZ5PrMM8/0e92Ojg6UlJQM2rgjIiJ5KWLT62AnMDz88MP429/+5vT9zn4LPIGBiEgdFBFGwMBn03mCZ9MREamH7M+MulmtVjQ0NGDVqlVeX8vhcGDVqlX4xz/+gfXr1wuwOiIiEpNiwigsLAw5OTmw2WzIzMz0+DoOhwOZmZnIz8/HtWvXkJiYiBMnTgi4UiIiEpoiCgzdkpOTcf78eVgsFtTV1SE7O9utW3bNzc1YtWoV8vPzERISgiFDhuDEiROIjY3Fzp07ERsbK+LqiYjIU4r5ZNTt1VdfRV5eHgoLCzFlyhTs2LEDnZ2dA76no6MDO3bsQFRUFAoLC/Gb3/wGJSUlmDhxIoKDg9Hc3Iy5c+eipKREot8FERG5QzEFhlvV1tYiNTUVpaWlCAoKgtlsRnR0NEwmE4xGI9rb21FZWYny8nKUlJSgvr4e/+///T9kZGRg/PjxAG4cwrp27VocOnQIDQ0NaGtrw+9+9zusXLkSBoNB5t8hERF1U2wYdbPb7cjNzcXevXtRXV3dp8YdGhqKuXPn4plnnun3lIWuri688cYb2LNnDy5duoSmpia88MILyMnJwbBhirpLSUSkW4oPo95aW1tRU1OD//3f/8Vvf/tbjB8/HitXrsTChQsHfJ/D4cD27duxfft2tLS0oLGxEQsWLEBhYSFPZiAiUgDFPTMaiJ+fH6ZOnYoFCxYAuHFM0MmTJwd9n8FgwPPPP4+XX34ZI0eOxLhx47Br1y489NBDOHfunMirJiKiwagqjLp1H5La1dWFuro6l983f/58/Pa3v8WYMWMQHByMI0eOIDY2FkePHhVrqURE5AJVhtHo0aMRHByMrq4ulz4Z9TZ9+nRs2bIFd999N0JCQnD+/Hk8+OCDHE1ORCQjVYYRcGOCa2dnJ5qamnDp0iW33hsWFoZt27YhMjKyJ9Ti4uLw+9//XqTVEhHRQFQbRpGRkejq6gIAt27VdRs9ejRycnLw4IMPIigoCEajEUuWLMGaNWucHrxKRETiUG0YmUwmdHV1weFwoLa21qNrGI1GZGRk4Oc//zkCAwMxatQoZGZm4plnnuGYciIiCak6jAB49Nyot6FDhyItLQ0vvPAC7rjjDowdOxaFhYV47LHHcPHiRYFWS0REA1FtGHnaqHMmPj4eGRkZGDVqFIKDg7Fv3z7MmjWLh6wSEUlAtWHkTaPOmdmzZyMnJwfjxo1DSEhIzyGrZWVlglyfiIj6p9owArxr1DkzefJkWK1WHrJKRCQhVYeRt406Z0JCQrB161ZMnz4dwcHBGDp0KJ566ilkZ2ezaUdEJAJVh5EQjTpn/P398frrr+Oxxx7D2LFjERAQgPT0dLz44ou4du2aoD+LiEjvVB9GgPeNOmeGDx+O1atX47nnnsOoUaMQGBiIt956CwsXLkRra6vgP4+ISK9UHUZCN+r6w0NWiYjEp+owEqNR5wwPWSUiEo+qwwgQp1HnDA9ZJSISh+rDSKxGnTM8ZJWISHiqDyMxG3XO8JBVIiJhaSKMAPEadc7wkFUiIuGoPoykaNQ5w0NWiYiEofowkrJR5wwPWSUi8o7qwwiQtlHnDA9ZJSLynCbCSOpGnTM8ZJVIHVpbW3H48GEcOHAAhw8f5okqCqCJMJKjUecMD1klUia73Y60tDRMnjwZAQEBmDZtGmJjYzFt2jQEBARg8uTJSEtLg91ul3upuqSZMAKkb9Q5w0NWiZSjtrYWcXFxMJlMKCoqwty5c5Gfn4+ysjIcOXIEZWVlyM/Px9y5c1FUVASTyYS4uDjZ/2KrNwaHBv66fvHiRQQGBmLs2LGYNWsWcnJy5F4SAMDhcGD79u3Yvn07Wlpa0NjYiAULFqCwsBB+fn5yL49I82w2G1asWIExY8Zg/fr1iI+Ph4+Pj9PXd3Z2ori4GKtXr0ZjYyNycnKQnJws4Yr1SxOfjJTQqOsPD1klkk9WVhZSUlKQmJiIiooKJCUlDRhEAODj44OkpCQcPXoUiYmJSElJQVZWlkQr1jdNhBGgjEadMzxklUhaNpsNFosFGRkZyMvLg7+/v1vv9/f3R15eHtatWweLxYL8/HyRVkrdNBNGSmnUOcNDVomkUVtbixUrViA5ORkWi2XQ12dlZcFgMGDKlCl9vmexWJCcnIyXXnqJz5BEppkwUlKjzhkeskokvtTUVIwZMwbZ2dmDvvbMmTNYv349br/99n6/bzAY8OabbyIwMBCpqalCL5V60VQYAcpp1DnDQ1aJxGO321FaWor169e7dGvul7/8JWJjYxEdHe30NQEBAdiwYQNKS0tRVVUl5HKpF82EkZxn1LmLh6wSiSM3NxdBQUGIj48f9LWff/45iouLXWrfms1mBAUFYdu2bQKskvqjmTBSaqPOGR6ySiS8PXv2wGw2D9qau379Ol588UUkJycjKipq0Ov6+vrCbDbzGa+INBNGgLIbdc7wkFUiYbS0tODYsWOYMWPGoK/Nzc1FXV0dMjIyXL5+dHQ0qqureXSQSDQVRkpv1DnDQ1aJvHf8+HE4HI6eW/bONDY2Yu3atVizZg3Gjh3r8vVNJhMcDgdqamq8XSr1Q1NhpIZGnTM8ZJXIO93PW0eMGDHg6ywWC0aPHo0XX3zRresbjcabfg4JS3NhBCi/UecMD1kl8pyvry8AoK2tzelrvvvuO7z99ttIS0vDuXPncPLkSZw8eRJXr17t+XPD2TPb9vb2m34OCUtTYaSmRp0zPGSVyDPh4eEwGAwDnrp99uxZfP/990hLS0NYWFjPPwcOHMC3336LsLAwrFu3rt/3VlZWwmAwIDw8XKzfgq4Nk3sBQupu1F29elWVn4y6DR8+HKtXr8add96J7du3Y9iwYXjrrbdQV1fHQ1aJnPDz88OkSZNw8OBBLF68uN/XTJkyBe+9916fr1ssFrS0tGDTpk2YOHFiv+8tLy9HREQE//8nEk2c2t3bvHnzsH//fgQFBeHPf/4zRo0aJfeSvFJaWorf/e53aG1txYULF/DAAw/go48+wp133in30ogUJy0tDUVFRTh9+vSg9e7eHn74YTQ0NDg9L7KjowOhoaFISEjA5s2bhVou9aKp23SAeht1zvCQVSLXLVu2DPX19SguLhb0uiUlJaivr8fy5csFvS79QHNhpOZGnTM8ZJXINZGRkZg/fz5Wr16NlpYWl9/32WefOf0LXnNzM1avXo358+dj8uTJQi2VbqHJMALU26hzhoesEg3O4XBg+vTpOHPmDFauXCnI9dLT09HY2Air1SrACskZzYWRFhp1zvCQVSLnurq6kJqaiqysLHz//ffIz89HZmamx9dzOBzIzMyEzWbDpk2bEBYWJuBq6VaaCyO1nVHnLh6yStTX5cuX8cQTTyA3N7fnaw8//DDWrFmDlJQUt27ZATduzS1duhRr165FVlYWlixZIvSS6RaaCyNAnWfUuYOHrBL9oLa2FrNmzcKePXsA3Bgd/s477+DTTz9FXl4eCgsLMWXKFOzYsQOdnZ0DXqujowM7duxAVFQUCgsLYbPZ8Morr0jx29A9zVW7gRv1ztzcXNx1113YuHEjpk6dKveSRLNv3z5kZGSgpaUF58+fx3333Yddu3bh3nvvlXtpRKL76quv8LOf/QwXLlwAAAQGBuK9997DnDlzel5TW1uL1NRUlJaWIigoCGazGdHR0TCZTDAajWhvb0dlZSXKy8t7WnPz58+H1WrlrTkJaTKM/vu//xvLli3DhAkT8NJLL2HhwoVyL0lUVVVVeOWVV3DhwgXU19dj5MiR2LlzJ2JjY+VeGpFoCgsLsXjx4p7b05MmTcJHH33k9IQEu92O3Nxc7N27F9XV1X2esw4fPhzz5s3Dm2++ydacDDR7mw7QXqPOGR6ySnricDiwbt06JCUl9QTRj3/8Y+zfv3/Ao3oiIyOxefNm2O12NDc349ChQygrK+sZrtfV1YXIyEgGkUw0GUZabtQ5w0NWSQ86Ojrw7LPP4rXXXuv52pIlS1BaWurWaSt+fn6YOnUqYmJikJSU1PP1/fv3C7pecp0mw0jrjTpneMgqadmFCxfwyCOP4I9//CMAwGAw4PXXX0deXh6GDx/u8XXHjh3b84nqm2++GbTkQOLQZBgBNzfqLl++LPdyJNN9yOpzzz2HUaNGITAwEG+99RYWLlzICZWkWtXV1YiNjcWXX34J4MYWh5KSEvzqV7+CwWDw+vozZ84EcOOT16FDh7y+HrlPs2HU+4w6PX06Am78jfH555/Hyy+/jJEjR2LcuHHYtWsXHnroIZw7d07u5RG55ZNPPkFsbCxOnDgB4MYt6c8//1zQYlJ3GAG8VScXzYaRFs+ocxcPWSW1y8vLw/z589HU1AQAeOCBB/D1118jOjpa0J/DMJKfpsMI0FeJoT88ZJXU6Pvvv8evf/1rLF26tOd554IFC7Bv3z7cfffdgv+8KVOm4PbbbwfAMJKLZsOod6NOb7fpbsVDVklNrly5ArPZjDfeeKPnaytWrMD7778v2mC7YcOGYcaMGQCA06dP4+zZs6L8HHJOs2Gk10adMzxkldTg7NmzeOihh/D+++8DuHH0ldVqxcaNGzF06FBRf3bvW3VlZWWi/izqS7NhBOi3UecMD1klJTt06BBiYmLw97//HQAQEBCAv/zlL5INtONzI3lpOoz03KhzhoeskhJ9+OGHmDNnTs/tsXvuuQdfffUVHn/8ccnW0Pv4LIaR9DQdRmzUORcfH4+MjAyMGjUKwcHB2LdvH2bNmtVTnyWSgsPhwMaNG/HTn/4UV65cAXAjFA4cONBTQpIKN7/KS/NhBLBR58zs2bORk5ODcePGISQkBCdOnEBsbCzvl5MkuofhrVq1que5ZUJCAv76178iKChIljVx86t8NB1GbNQNjoeskhz6G4a3Zs0a7NixA0ajUbZ18bmRfDQdRmzUuYaHrJKUnA3DW7duHYYMkfePJIaRfDQdRgAbda7iIaskha+++goxMTGoqqoCcGMY3t69e/Ef//EfMq/sBm5+lY/mw4iNOtfxkFUSU2FhIX784x/3TGWdNGkSDhw4cNNUVrlx86t8NB9GbNS5h4esktAGGoY3ceJEmVfXFze/ykMXYQSwUecuZ4esVlRUyL00UhGhhuFJic+N5KH5MGKjznP9HbI6e/ZsHrJKLhFrGJ7YuPlVHpoPIzbqvNN9yKrJZOIhq+QysYfhiYmbX+Wh+TAC2Kjz1ujRo7Fx40bMnj2bh6zSoKQYhic2bn6Vni7CiI067xmNRqxbt46HrNKApBqGJzY+N5KeLsKIjTph8JBVckbqYXhiYxhJTzdhBLBRJxQeskq9yTEMT2zc/Co9XYQRG3XC4yGrBADnzp2TbRiemLj5VXq6CCM26sTBQ1b17dChQ/jRj34k2zA8sXHzq7R0EUYAG3Vi4SGr+qSEYXhi43MjaekmjNioEw8PWdUPJQ3DExs3v0pLN2HERp24eMiq9ilxGJ6YuPlVWroKI4CNOjHxkFXtampqwoIFCxQ3DE9s3PwqHd2EERt10uEhq9rSPQzv448/BqCsYXhi43Mj6Wj7v6Re2KiTFg9Z1YbuYXh2ux2A8obhiY1hJB3dhBHARp3UeMiquqlhGJ7YuPlVOroKIzbqpMdDVtVHbcPwxMTNr9LRVRixUScPHrKqHmochic2bn6Vhu7CCGCjTg48ZFX51DoMT2x8biQNXYURG3Xy4yGryqTmYXhi4+ZXaegqjNioUwYesqos/Q3D++KLL1Q1DE9M3PwqDV2FEcBGnVLwkFVlcDYMb/r06TKvTFm4+VV8ugsjNuqUg4esykdrw/DExudG4tNdGLFRpyw8ZFV6WhyGJzaGkfh0GUYAG3VKwkNWpaPVYXhi4+ZX8ekujNioUyYesio+rQ/DExM3v4pPd2HERp2y8ZBVcehhGJ7YuPlVXLoLI4CNOqXjIavC0dMwPLHxuZG4dBlGbNQpHw9Z9Z7ehuGJjZtfxaXLMGKjTh14yKrn9DoMT0zc/Cou3YYRwEadGvCQVffpeRie2Lj5VTy6/C+TjTp14SGrrutvGN4nn3yim2F4YuNzI/HoMozYqFMnHrI6MGfD8GbPni3zyrSDYSQeXYYRwEadWvGQ1b44DE863PwqHt2GERt16sVDVn/AYXjS4uZX8eg2jNioUzcesgo0NDRg3rx5HIYnMW5+FYeuwwhgo07N9HzIanV1NWJiYrBv3z4AHIYnJT43Eoduw4iNOm3Q4yGrHIYnL25+FYduw4iNOu3Q0yGrHIYnP25+FYduwwhgo05rtHzIKofhKQs3vwpP12HERp32aPGQVQ7DUx4+NxKersOIjTpt0tIhq/0Nw9u2bRuH4cmMYSQ83YcRwEadFmnhkNX+huHt2rULy5Ytk3llxM2vwtN1GLFRp21qPmTV2TC8xx57TOaVEcDNr2LQdRixUad9ajtklcPw1IObX4Wl6zAC2KjTCzUcsspheOrC50bC0n0YsVGnH0o+ZJXD8NSHm1+FpfswYqNOX5R4yGp/w/DeffddDsNTOG5+FZbu/0tno05/lHTIqrNheM8884yk6yDPcPOrcHQfRmzU6ZMSDlnlMDz143Mj4eg+jNio0y8hDlltbW3F4cOHceDAARw+fNil93EYnnYwjISj+zAC2KjTM08OWbXb7UhLS8PkyZMREBCAadOmITY2FtOmTUNAQAAmT56MtLS0nltvvXEYnrZw86twGEZgo45cO2S1trYWcXFxMJlMKCoqwty5c5Gfn4+ysjIcOXIEZWVlyM/Px9y5c1FUVASTyYS4uLieYgyH4WkPN78Kh2EENurohoEOWbXZbIiKikJVVRUKCgpw+vRpWK1WLF68GDExMYiKikJMTAwWL14Mq9WK06dPo6CgAHa7HVFRUcjIyOAwPI3i5ldhMIzARh39oL9DVh9//HGkpKQgMTERFRUVSEpKgo+Pz4DX8fHxQVJSEo4ePYqnn34aa9eu5TA8jeJzI2EwjMBGHd2s9yGrRqMR33//PTIyMpCXlwd/f3+3ruXv7w+bzYZ169YBAO6++24Ow9MYbn4VBsMIbNRRX0ajESkpKWhtbcWSJUtgsVhu+n5lZSWeeuop3HvvvRgxYgTGjBmDhx56CB9++GG/17NYLFiyZAkuXbrU83yStIGbX4XBMPoXNuroVv/5n/+JkJAQbNy4sc/36urq0NLSgueeew6bNm3CmjVrAAA/+clP8Pbbb/d5vcFgQHZ2NgIDA5Gamir62kla3PzqPYbRv7BRR7199913+Nvf/ob169f3e2vu3//931FaWorXXnsNKSkpeOmll/Dpp5/igQceQHZ2dr/XDAgIwIYNG1BaWoqqqiqxfwskIT438h7D6F/YqKPeCgoKEBQUhPj4eJffM3ToUIwfP37AT9ZmsxlBQUHYtm2bAKskpWAYeW+Y3AtQCjbqqLcvv/wSZrN50NbclStX0N7ejqamJuzcuRO7d+9GQkKC09f7+vrCbDZj7969Qi+ZZNS9+fXKlSsMIw/xk9G/sFFH3VpbW3H8+PGezYwDSU9P73mA/ctf/hILFy7E1q1bB3xPdHQ0qqurXT5yiJSPm1+9xzD6FzbqqNupU6fgcDh6/oIykBUrVmDPnj3Yvn074uLicP369UHbVCaTCQ6HAzU1NUItmRSAm1+9wzDqhY06AtBzeOmIESMGfW1ERATmzZuHZ599Fh999BFaW1vx5JNPDjiKontYXvfPIW3gcyPvMIx6YaOOgBvPdQCgra3N7ffGx8fj4MGD+Pbbb52+pr29/aafQ9rAza/eYRj1wkYdAcCECRNgMBj6PXV7MN1B09TU5PQ1lZWVMBgMPRslSRu4+dU7DKNe2KgjALj99tsxceJEHDx40Olr6uvr+3ytq6sL77zzDoxG44DPm8rLyxEREQE/Pz9B1kvKwc2vnmMY9cJGHXV78MEHUVJS4vRvt7/4xS/wyCOP4L/+679gs9mQmZmJ+++/H3//+9+RmZnpNGg6OjpQUlKCefPmibl8kgmfG3mOYdQLG3XUbdGiRaivr0dxcXG/309ISMCQIUOwbds2LF++HNnZ2bj77rvxwQcfYNWqVU6vW1JSgvr6eixfvlyspZOMGEaeMzgGqv3o0Lx587B//34EBQXhvffew8iRI+VeEsnk+eefx8mTJ1FRUeH2ad39aW5uRlRUFCIjI7F7924BVkhKc+3aNYwcORJXrlzB+PHjcerUKbmXpBr8ZHQLNuqoW0ZGBi5cuICVK1d6fS2Hw4H09HQ0NjbCarUKsDpSIm5+9RzD6BZs1FG38ePHY82aNcjPz0dmZqbH13E4HMjMzITNZsOmTZsQFhYm4CpJabj51TMMo1uwUUe9Pf3000hPT8eaNWuQnJyMlpYWt97f3NyMpUuXYu3atcjKysKSJUtEWikpBZ8beYZhdAs26uhWy5cvx+TJk/E///M/iIiIwI4dOwbdQ9LR0YEdO3YgKioKhYWFsNlseOWVVyRaMcmJm189wwJDP0JCQnD16lVMmDAB77//vtzLIZl9+OGHyM7Oxrlz52A0GtHU1ISgoCCYzWZER0fDZDLBaDSivb0dlZWVKC8v72nNzZ8/H1arlbfmdOa+++5DTU0NfH190dzcPOjp78QREv0ymUzYv39/zxl1bNTpV3NzM2w2G1pbW9HZ2YlPPvkEo0ePRm5uLvbu3Yvc3NybzqEzGAyIiIhAQkJCzycq0p+ZM2eipqamZ/NrTEyM3EtSPIZRPyIjI/H5558DuNGomzp1qrwLItn84Q9/wOXLl3Hp0iUkJSVh9uzZAIDNmzcDuDFuovsPHV9fX4SHh/NkBcLMmTPx7rvvArhxq45hNDg+M+oHG3UEAMePH8cHH3yAy5cv47bbbsPrr7/e5zV+fn6YOnUqYmJiMHXqVAYRAWCJwRMMo36wUUcOhwObN29GZ2cnWlpaYLFYcNddd8m9LFKJ7smvAMPIVQyjfrBRR59++imOHDmCxsZGTJw4UZCNr6Qf3PzqPoZRP3hGnb61t7cjNzcXbW1tuHr1KnJycjh7iNzGza/uYRg5wamv+lVQUID6+npcvHgRTzzxBJ544gm5l0QqxOdG7mEYOcEz6vTp7NmzKCoqQlNTE4YMGYKcnBy5l0Qqxc2v7mEYOcFGnT699dZbuHr1KpqamrBq1SpOYyWPcfKrexhGTrBRpz8HDhzA/v37cfHiRYSEhODVV1+Ve0mkcpz86jqGkRNs1OlLV1cXtm7diqtXr6KtrQ1vvPEG9wyR1/jcyHUMIyfYqNOXkpISnD59Go2NjZgzZw4SExPlXhJpAMPIdQyjAbBRpw8NDQ1455130NLSguvXr2Pz5s0wGAxyL4s0gJtfXccwGgAbdfrw9ttvo7W1FZcvX8YvfvELnkVIguHmV9cxjAbARp32VVRUYM+ePbh06RJGjhyJjIwMuZdEGsPNr65hGA2AjTpt674l19HRgdbWVmRmZiIwMFDuZZHG8LmRaxhGA2CjTtt27dqFmpoaXLx4EQ888ACWLl0q95JIg7j51TUMowGwUaddvYfmdXR0YMuWLRg6dKjcyyIN4uZX1zCMBsFGnTbdOjRvzpw5ci+JNIybXwfHMBoEG3Xa48rQPCIh8bnR4BhGg2CjTls4NI/kwDAaHMNoEGzUaQuH5pEcuPl1cAyjQbBRpx0cmkdy4ebXwTGMBsFGnXZwaB7JiZtfB8YwcgEbderHoXkkNz43GhjDyAVs1Kkfh+aR3Lj5dWAMIxewUaduHJpHSsDNrwNjGLmAjTr14tA8UhJufnWOYeQCNurUq7i4mEPzSDH43Mg5hpEL2KhTp4aGBrz77rscmkeKwTByjmHkIjbq1IdD80hpuPnVOYaRi9ioUxcOzSMl4uZX5xhGLmKjTj04NI+UjJtf+8cwchEbderBoXmkZHxu1D+GkYvYqFMHDs0jpePm1/4xjFzERp06cGgeKR03v/aPYeQGNuqUjUPzSC24+bUvhpEb2KhTLg7NIzXhc6O+GEZuYKNOuTg0j9SEYdQXw8gNbNQpE4fmkdpw82tfDCM3sFGnTByaR2rDza99MYzcwEad8nBoHqkVN7/ejGHkJjbqlIVD80it+NzoZgwjN7FRpxwcmkdqxs2vN2MYual3o45hJB8OzSO14+bXmzGM3NS7Uccwkk/voXmzZ8/m0DxSJW5+/QHDyE1s1Mnv1qF5W7Zs4dA8UiU+N/oBw8hNbNTJj0PzSCsYRj9gGHmAjTr5cGgeaQk3v/6AYeQBNurkwaF5pDXc/PoDhpEH2KiTx1/+8hcOzSPN4ebXGxhGHmCjTnrNzc3Iz8/n0DzSHD43uoFh5AE26qTHoXmkVdz8egPDyANs1EmLQ/NIy7j59QaGkYfYqJMGh+aRHnDzK8PIY2zUSYND80gP+NyIYeQxNurEx6F5pBcMI4aRx9ioEx+H5pFecPMrw8hjbNSJi0PzSE+4+ZVh5DE26sTFoXmkN3q/Vccw8gIbdeLg0DzSI72fxMAw8gIbdcLj0DzSK71vfmUYeYGNOuFxaB7pld43vzKMvMBGnbA4NI/0Ts+bXxlGXmCjTlgcmkd6p+cSA8PIC2zUCYdD84gYRuQFNuq8x6F5RDfoefMrw8hLbNR5j0PziG4YNmwYfvSjHwHQ3+ZXhpGX2KjzDofmEd1MrxVvhpGX2KjzDofmEd1Mr5tfGUZeYqPOcxyaR9QXPxmRR9io8wyH5hH1T6+bXxlGAmCjzn0cmkfknB43vzKMBMBGnXva29uxbds2Ds0jckKP+40YRgJgo849BQUFuHDhAofmETnBMCKPsFHnuluH5m3cuFHuJREpjh43vzKMBMBGnetuHZp33333yb0kIsXR4+ZXhpEA2KhzDYfmEblObxVvhpFA2KgbGIfmEblHb5tfGUYCYaNuYByaR+QefjIij7BR5xyH5hG5T2+bXxlGAmGjzjkOzSPyjJ42vzKMBMJGXf84NI/Ic3rab8QwEggbdX1xaB6RdxhG5BE26m7GoXlE3tHT5leGkYDYqPsBh+YReU9Pm18ZRgJio+4HHJpHJAy9VLwZRgJio+4GDs0jEo5eNr8Ok3sBWsJGXd+heevXr+fQPCIv8JMRuY2NOg7NIxKaXja/MowEpudGHYfmEYlDD5tfGUYC03OjjkPziMShh/1GDCOB6bVRx6F5ROJhGJHb9Nqo49A8IvHoYfMrw0hgemzUcWgekbj0sPmVYSQwvTXqurq6sGXLFg7NIxKZ1iveDCMR6KlRV1xcjDNnznBoHpHItL75lWEkAr006jg0j0g6/GREbtNLo45D84iko/XNrwwjEeihUceheUTS0/LmV4aRCLTeqOPQPCJ5aHm/EcNIBFpv1HFoHpE8GEbkNq026jg0j0g+Wt78yjASiVYbdRyaRyQfLW9+ZRiJRIuNOg7NI5KfViveDCORaK1Rd+vQPIvFwqF5RDLQ6uZXhpFItNao49A8ImXgJyNyi5YadRyaR6QcWt38yjASkVYadRyaR6QsWtz8yjASkRYadRyaR6Q8WtxvxDASkRYadRyaR6Q8DCNyi9obdRyaR6RMWtz8yjASkZobdRyaR6RcWtz8yjASkZobdRyaR6RsWqt4M4xEpsZGHYfmESmf1ja/MoxEpsZGHYfmESkfPxmRW9TWqOPQPCJ10NrmV4aRyNTUqOPQPCJ10dLmV4aRyNTUqOPQPCJ10dJ+I4aRyNTSqOPQPCL1YRiRW9TQqOPQPCL10dLmV4aRBJTeqKupqeHQPCIV0tLmV4aRBJTcqHM4HNiyZQuH5hGplFYq3gwjCSi5Udc9NO/ixYscmkekQlrZ/MowkoBSG3W9h+a1t7dzaB6RCvGTEblMqY06Ds0jUj+tbH5lGElEaY06Ds0j0g4tbH5lGElEaY06Ds0j0g4t7DdiGElESY06Ds0j0hYthNEwuRegF0pp1N06NC8vL49D84hUrnvz65UrV/Dll1/i8OHD6OjogK+vL8LDw1Xx/3GGkUSU0qjj0Dwi7fn2228xcuRIdHZ24uzZs5g2bVrP9wwGAyZNmoRHH30Uy5Yt6/mzSGl4m04iSmjUcWgekbbU1tYiLi4OJpMJHR0dSE5Oxu9//3uUlZXhyJEjKCsrQ35+PubOnYuioiKYTCbExcWhtrZW7qX3wTCSkNyNOg7NI9IOm82GqKgoVFVVoaCgAGfPnoXVasXixYsRExODqKgoxMTEYPHixbBarTh9+jQKCgpgt9sRFRUFm80m92/hJgwjCcnZqOPQPCLtyMrKQkpKChITE1FRUYGkpCT4+PgM+B4fHx8kJSXh6NGjSExMREpKCrKysiRa8eD4zEhCtzbqpPpkcuvQPKvVyqF5RCpls9lgsViQkZEBi8Xi9vv9/f2Rl5eH0NBQWCwWBAcHY8mSJSKs1D38ZCQhuRp1HJpHpA21tbVYsWIFkpOT+wTRZ599BoPB0O8//Z1ZZ7FYkJycjJdeekkRz5D4yUhCcjTqODSPSDtSU1MxZswYZGdnO31NWloaZsyYcdPXuo8L6s1gMODNN9/Exx9/jNTUVOzevVvw9bqDYSSh7kbd1atXJQsjDs0j0ga73Y7S0lIUFBTA39/f6evmzJmD+Ph4l64ZEBCADRs2YNGiRaiqqsLkyZOFWq7beJtOYlI26jg0j0g7cnNzERQU5FLQtLS04Nq1ay5d12w2IygoCNu2bfN2iV5hGElMqkYdh+YRacuePXtgNpsHbc0tXrwYAQEBuO222zB37lyUl5cP+HpfX1+YzWbs3btXyOW6jWEkManOqOPQPCLtaGlpwbFjx/o8C+rNx8cHZrMZmzZtwgcffIDMzExUVFRgzpw5g57kHR0djerqarS2tgq9dJfxmZHEpGjUcWgekbYcP34cDodjwKN8Zs2ahVmzZvX8+09+8hPEx8fj/vvvx+rVq1FaWur0vSaTCQ6HAzU1NbJthmcYSUyKRh2H5hGpV1tbG06dOoW6ujrU1dXh1KlT+OabbwAAI0aMcOta4eHh+OlPf4o///nPuH79utMmrdFoBHBjHpJcGEYSE7tRx6F5RMrlcDjQ2Nh4U9h0B073rxsaGpy+v62tze2fOX78eHR2duLKlSsICAjo9zXt7e0AIOsdFIaRDEwmE/bv39/TqBs5cqRg1+49NO/ll1/m0DwiCV27dg3nzp3rEzC9/92TQOlmt9sRExPj1ntOnDiB2267bcAxEpWVlTAYDP3uR5IKw0gGkZGR+PzzzwFA0GOBODSPSFz93ULr/eszZ87g+vXrHl17yJAhuOuuuzBhwgSEhoZiwoQJPf+EhoZi4cKFOHjwIBYvXtzv+y9cuICxY8fe9LX/+7//w86dOxEXF4chQ5z31crLyxERESHr3COGkQzEOKOOQ/OIvOPtLbTBGI3Gm0Lm1l/fddddGD58uNP3P/744ygqKkJOTk6/9e6EhAQYjUbMmjULQUFBsNvtePvttzFixAj85je/cXrdjo4OlJSUICEhwePfmxAYRjIQo1HHoXlEAxP7FlpgYGC/n2i6fz1mzBiv5octW7YMW7ZsQXFxMZKSkvp8/2c/+xkKCgqQnZ2N5uZmjB07Fj//+c/x2muvDXj7raSkBPX19Vi+fLnHaxOCweFwOGRdgQ5dvHgRgYGBGDt2LGbNmoWcnByvrtfQ0IBnn30W58+fx+XLl/HNN99wVhHpjpy30EJDQyW5ExEXF4eqqipUVFQMeCSQq5qbmxEVFYXIyEieTadHQjfqODSPtE7pt9CkYrVaERUVhVWrViEvL8+razkcDqSnp6OxsRFWq1WgFXqOYSQToRp1HJpHWqD2W2hSCQsLQ05ODlJSUjBhwgSP5hkBN4IoMzMTNpsNNpsNYWFhAq/UfQwjmQjRqOPQPFILPdxCk0pycjLOnz8Pi8WCuro6ZGdnu3XLrrm5Genp6bDZbMjKylLEYD2AYSQbIRp1HJpHSsBbaNJ79dVXMW7cOKxYsQIff/wxNmzYgPj4+AEPUe1uza1evRqNjY2w2WyKCSKAYSQbbxt1HJpHUuEtNGVKTk7GI488gtTUVCxatAgrV66E2WxGdHQ0TCYTjEYj2tvbUVlZifLy8p7W3Pz582G1WhVxa643hpFMvD2jjkPzSCi8haZeYWFh2L17N+x2O3Jzc7F3717k5uaid0naYDAgIiICCQkJWL58uawD9AbCareMQkJCcPXqVUyYMAHvv/++y++rqanB0qVL0djYiOvXr+PYsWOcVUT94i00/WltbUVNTQ06Ojrg6+uL8PBwVQQ+PxnJyJNG3a1D89avX88g0jGpb6Hd+umGt9CUx8/PT5XbOxhGMvKkUcehefoixy207l/zFhpJiWEkI3cbdRyapy28hUb0A4aRjNxt1HFonrrwFhqR6xhGMnKnUcehecrDW2hEwmEYycidM+o4NE9avIVGJC2Gkcy6G3WXLl3CgQMH4OPjA19fX0yYMAG33347AA7NEwNvoREpC8NIRna7HRcuXEBXVxdOnTqFp59+uud7BoMBEydOxMyZM3H06FEOzXMTb6ERqQs3vcqgtrYWqampKC0txdixYxEfH48ZM2YgMjISI0aMQFtbG+x2Ow4ePIg//elPaGhowNChQzFt2jR8/fXXuv8bdX+30G79dMNbaETqwjCSmM1mw4oVKzBmzBisX79+0MMNOzs7UVxcjF/96le4fPkyNm3ahOTkZAlXLD1nt9C6f33q1ClcuXLF4+vzFhqR8jCMJJSVlQWLxYLk5GS3j31vaWnBqlWrYLPZkJmZqernRryFRkS34jMjidhsNlgsFmRkZHg0EMvf3x95eXkIDQ2FxWJBcHCwoo5/7yb2LbTbbrvN6Sca3kIjUi9+MpJAbW0toqKikJiY2GdUcGtrK9544w0cOHAAX3/9NS5duoQ//OEPeP755/u9lsPhwNKlS1FYWIiKigrJj4HnLTQiEgPDSAJxcXGoqqpCRUVFn1tzJ0+eRFhYGEJDQ3Hvvffis88+GzCMgBuzjKKiohAZGYndu3cLulbeQiMiOfA2ncjsdjtKS0tRUFDQ7zOikJAQ/OMf/0BwcDDKy8sxY8aMQa8ZEBCADRs2YNGiRaiqqnJ5PglvoRGRUjGMRJabm4ugoCDEx8f3+31fX18EBwe7fV2z2YyVK1di27Zt2Lx5MwDxb6GNHj3a6TRO3kIjIm8wjES2Z88emM3mAevbnvD19YXZbEZBQQEOHz4s2C00Z+OfeQuNiMTEMBJRS0sLjh07hl//+teiXD86Ohrbtm3DF198MehreQuNiJSMYSSi48ePw+Fw9JzOLbTuERQAb6ERkboxjETU0dEBABgxYoQo1zcajQCAv/71r5g7d64oP4OISApD5F6AlnVPYfXm9OeBtLe3AwBGjRolyvWJiKTCMBJReHg4DAYD7Ha7KNevrKyEwWBAeHi4KNcnIpIKw0hEfn5+mDRpEg4ePCjK9cvLyxEREcGWGxGpHp8ZiezRRx9FUVERcnJynNa7t27disuXL+PcuXMAgA8//BBnzpwBALz44ou44447+ryno6MDJSUlSEhIEG/xREQS4XFAIrPb7TCZTCgoKEBSUlK/r7nnnntQV1fX7/dqa2txzz339Pn6jh07sGjRItjtdpdPYCAiUiqGkQQGOpvOE2KeTUdEJAc+M5KA1WpFQ0MDVq1a5fW1HA4H0tPT0djYCKvVKsDqiIjkxzCSQFhYGHJycnoG43nK4XAgMzMTNpsNmzZtknx8BBGRWFhgkEhycjLOnz8Pi8WCuro6tye9Njc3Iz09HTabDVlZWYocrEdE5Ck+M5KYzWbDihUrEBgYiA0bNiA+Pn7AQ1S7W3OrV69GY2MjNm3axCAiIs1hGMmgtrYWqampKC0tRVBQEMxmM6Kjo2EymWA0GtHe3o7KykqUl5ejpKQE9fX1mD9/PqxWK2/NEZEmMYxkZLfbkZubi71796K6uhq9/6cwGAyIiIjAvHnzsHz5cta3iUjTGEYK0draipqaGnR0dMDX1xfh4eE8WYGIdINhREREsmO1m4iIZMcwIiIi2TGMiIhIdgwjIiKSHcOIiIhkxzAiIiLZMYyIiEh2DCMiIpIdw4iIiGTHMCIiItkxjIiISHYMIyIikh3DiIiIZMcwIiIi2TGMiIhIdgwjIiKSHcOIiIhkxzAiIiLZMYyIiEh2DCMiIpIdw4iIiGTHMCIiItkxjIiISHYMIyIikh3DiIiIZMcwIiIi2TGMiIhIdgwjIiKSHcOIiIhkxzAiIiLZ/X/i7DfO0bbeawAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "# shade the area of the triangle\n", + "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the sets of nodes, edges and triangles. \n", + "\n", + "**Note that**: \n", + "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", + "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('triangles:', triangles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", + "\n", + "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. \n", + "\n", + "The entry `incidence_matrix[i, e]` is \n", + "- `-1` if node `i` is the source of edge `e`, \n", + "- `1` if node `i` is the target of edge `e`, and \n", + "- `0` otherwise. \n", + "\n", + "The `edge_triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph.\n", + "\n", + "The entry `edge_triangle_incidence_matrix[e, t]` is\n", + "- `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$,\n", + "- `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and\n", + "- `0` otherwise.\n", + "\n", + "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def triangles_to_B2(striangles: list, edges: list) -> np.ndarray:\n", + " \"\"\"\n", + " Create the B2 matrix (edge-triangle) from the triangles.\n", + "\n", + " Args:\n", + " triangles (list): List of triangles.\n", + " edges (list): List of edges.\n", + "\n", + " Returns:\n", + " np.ndarray: B2 matrix.\n", + " \"\"\"\n", + " B2 = np.zeros((len(edges), len(triangles)))\n", + " for j, triangle in enumerate(triangles):\n", + " a, b, c = triangle\n", + " try:\n", + " index_a = edges.index((a, b))\n", + " except ValueError:\n", + " index_a = edges.index((b, a))\n", + " try:\n", + " index_b = edges.index((b, c))\n", + " except ValueError:\n", + " index_b = edges.index((c, b))\n", + " try:\n", + " index_c = edges.index((a, c))\n", + " except ValueError:\n", + " index_c = edges.index((c, a))\n", + "\n", + " B2[index_a, j] = 1\n", + " B2[index_c, j] = -1\n", + " B2[index_b, j] = 1\n", + "\n", + " return B2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "\n", + "\n", + "edge triangle incidence matrix:\n", + " [[ 1.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 1.]\n", + " [ 0.]\n", + " [ 0.]]\n" + ] + } + ], + "source": [ + "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", + "incidence_matrix = torch.tensor(incidence_matrix, dtype=torch.float32)\n", + "edge_triangle_incidence_matrix = triangles_to_B2(triangles, list(G.edges))\n", + "edge_triangle_incidence_matrix = torch.tensor(edge_triangle_incidence_matrix, dtype=torch.float32)\n", + "print('incidence matrix:\\n', incidence_matrix)\n", + "print('\\n')\n", + "print('edge triangle incidence matrix:\\n', edge_triangle_incidence_matrix)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the Simplicial 2-Complex " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hodge Laplacian:\n", + " [[ 3. 0. 1. 0. 0. 0.]\n", + " [ 0. 3. 1. 0. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [ 0. 0. 0. 3. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Down Hodge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Up Hodge Laplacian:\n", + " [[ 1. -1. 0. 1. 0. 0.]\n", + " [-1. 1. 0. -1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 1. -1. 0. 1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "sc = GraphEdge(incidence_matrix, edge_triangle_incidence_matrix)\n", + "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('\\n')\n", + "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('\\n')\n", + "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(sc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = torch.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = torch.array([3/2])\n", + "params_inf[\"nu\"] = torch.array([torch.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n" + ] + } + ], + "source": [ + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "\n", + "key, xs = sc.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = min([torch.min(kernel_mat_32), torch.min(kernel_mat_inf)])\n", + "maxmax = max([torch.max(kernel_mat_32), torch.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "other_edges = torch.arange(sc.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, torch.tensor([[base_edge]]),\n", + " other_edges).flatten()\n", + "values_inf = kernel.K(params_inf, torch.tensor([[base_edge]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_32, other_edges)\n", + "variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "# shade the area of the triangle\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.08,\n", + "Variance in the edge (1,3) is 0.13,\n", + "The average variance is 0.17.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % torch.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[3]\n", + " [5]\n", + " [4]]\n", + "\n", + "emedding (shape = (3, 6)):\n", + "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 -1.29344481e-01\n", + " 5.15670639e-02 1.39200889e-01]\n", + " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 -1.59503941e-16\n", + " -6.37403964e-02 7.76266537e-16]\n", + " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 7.99392856e-02\n", + " -8.34372621e-02 9.36873407e-17]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = torch.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', torch.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-0.12815855 0.03939647]\n", + " [-0.35448662 0.8352028 ]\n", + " [-0.08106564 -0.25947495]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/backends/PyTorch_Graph.ipynb b/notebooks/backends/PyTorch_Graph.ipynb index 652b4fee..1565d772 100644 --- a/notebooks/backends/PyTorch_Graph.ipynb +++ b/notebooks/backends/PyTorch_Graph.ipynb @@ -101,7 +101,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", "INFO (geometric_kernels): Torch backend enabled.\n" ] } @@ -193,7 +194,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -284,7 +285,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "params: {'lengthscale': array(1.), 'nu': array(inf)}\n" + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" ] } ], @@ -409,7 +410,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -524,7 +525,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -708,14 +709,11 @@ " [0]], dtype=torch.int32)\n", "\n", "emedding (shape = torch.Size([3, 7])):\n", - "tensor([[ 6.4111e-01, -3.5117e-02, -1.9342e-01, 4.7708e-01, 6.3531e-01,\n", - " 5.3155e-02, 4.5413e-02],\n", - " [ 6.4111e-01, 1.0346e-02, -2.3692e-01, -4.4906e-01, -7.8950e-17,\n", - " 6.4406e-01, 4.5413e-02],\n", - " [ 6.4111e-01, 0.0000e+00, 0.0000e+00, -0.0000e+00, 0.0000e+00,\n", - " 0.0000e+00, -2.7248e-01]])\n", + "tensor([[ 0.6411, -0.1063, -0.1063, -0.1063, -0.1063, 0.7921, 0.0454],\n", + " [ 0.6411, -0.1063, -0.1063, 0.7921, -0.1063, -0.1063, 0.0454],\n", + " [ 0.6411, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, -0.2725]])\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(5.1619e-08)\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(1.8612e-07)\n" ] } ], @@ -763,8 +761,8 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "tensor([[ 0.1226, 1.7916],\n", - " [ 0.1192, -0.3994],\n", + "tensor([[ 0.2799, -0.3914],\n", + " [ 0.3957, 0.4641],\n", " [ 0.0718, 0.6314]])\n" ] } @@ -801,7 +799,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -896,9 +894,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "gkconda_updated_sh", + "display_name": "base", "language": "python", - "name": "gkconda_updated_sh" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -910,7 +908,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.4" } }, "nbformat": 4, From 7ed01f6159c618d6ead49a05c73cb747da719725 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Fri, 19 Jul 2024 16:16:35 +0200 Subject: [PATCH 02/30] Implemented kernels on the edge space of graphs or simplicial complexes --- tests/spaces/test_graph_edge.py | 198 ++++++++++++++++++++++++++++++++ 1 file changed, 198 insertions(+) create mode 100644 tests/spaces/test_graph_edge.py diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edge.py new file mode 100644 index 00000000..ef04e81b --- /dev/null +++ b/tests/spaces/test_graph_edge.py @@ -0,0 +1,198 @@ +# current path +import os +import sys +sys.path.append(os.path.dirname(os.getcwd())) +# add the first parent path +sys.path.append(os.path.dirname(os.path.dirname(os.getcwd()))) + +import warnings + +import jax +import lab as B +import numpy as np +import scipy.sparse as sp +# import tensorflow as tf +import torch + +from geometric_kernels.jax import * # noqa +from geometric_kernels.kernels import MaternKarhunenLoeveKernel +from geometric_kernels.spaces.graph_edge import GraphEdge +# from geometric_kernels.tensorflow import * # noqa +from geometric_kernels.torch import * # noqa + +warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") + +B1 = np.array( +[[-1, -1, -1, 0, 0, 0], + [ 1, 0, 0, -1, 0, 0], + [ 0, 1, 0, 1, -1, 0], + [ 0, 0, 1, 0, 0, -1], + [ 0, 0, 0, 0, 1, 1], + ] +).astype(np.float64) + +B2 = np.array( + [[ 1], + [-1], + [ 0], + [ 1], + [ 0], + [ 0],] +).astype(np.float64) + + +def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): + ############################################## + # Inits + + m= B1.shape[1] + B1 = B.cast(B.dtype(B1), B1) + B2 = B.cast(B.dtype(B2), B2) + sc = GraphEdge(B1, B2) + + ############################################## + # Laplacian computation + L = B.matmul(B.transpose(B1), B1) + B.matmul(B2, B2.T) + comparison = sc.edge_laplacian[0] == (L) + + + if sp.issparse(comparison): + comparison = comparison.toarray() + + if isinstance(comparison, np.matrix): # bug with lab? + assert comparison.all(), "Laplacian does not match." + else: + assert B.all(comparison), "Laplacian does not match." + + + ############################################## + # Eigendecomposition checks + + evecs = sc.get_eigenvectors(m) + evals = sc.get_eigenvalues(m) + + evals_np, evecs_np = np.linalg.eigh(L) + + # check vals + np.testing.assert_allclose(evals[:, 0], evals_np, atol=tol, rtol=tol) + + # check vecs + np.testing.assert_allclose( + np.abs(evecs)[:, 2:], np.abs(evecs_np)[:, 2:], atol=tol, rtol=tol + ) + + try: + np.testing.assert_allclose( + np.abs(evecs)[:, :2], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol + ) + except AssertionError: + np.testing.assert_allclose( + np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol + ) + + + ############################################## + # Kernel init checks + + K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) + params = K_cons.init_params() + + idx = B.cast(B.dtype(B1), np.arange(m)[:, None]) + + nu = B.cast(B.dtype(B1), np.array([1.0])) + lscale = B.cast(B.dtype(B1), np.array([1.0])) + + K_normed_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) + normed_params = K_normed_cons.init_params() + + ############################################## + # Matern 1 check + + params["nu"], params["lengthscale"] = nu, lscale + Kg = K_cons.K(params, idx) + K1 = evecs_np @ np.diag(np.power(evals_np + 2, -1)) @ evecs_np.T + np.testing.assert_allclose(Kg, K1, atol=tol, rtol=tol) + + normed_params["nu"], normed_params["lengthscale"] = nu, lscale + K_normed_cons.K(normed_params, idx) + + ############################################## + # Matern 2 check + + nu = B.cast(B.dtype(B1), np.array([2.0])) + params["nu"], params["lengthscale"] = nu, lscale + Kg = K_cons.K(params, idx) + K2 = evecs_np @ np.diag(np.power(evals_np + 4, -2)) @ evecs_np.T + np.testing.assert_allclose(Kg, K2, atol=tol, rtol=tol) + + ############################################## + # RBF check + + nu = B.cast(B.dtype(B1), np.array([np.inf])) + params["nu"], params["lengthscale"] = nu, lscale + Kg = K_cons.K(params, idx) + Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T + np.testing.assert_allclose(Kg, Ki, atol=tol, rtol=tol) + + ############################################## + # Fewer than meigencomps check + + m = 4 + evecs = sc.get_eigenvectors(m) + evals = sc.get_eigenvalues(m) + if isinstance(L, jax.numpy.ndarray): + evals_np, evecs_np = np.linalg.eigh(B.to_numpy(L)) + evals_np, evecs_np = evals_np[:m], evecs_np[:, :m] + else: + evals_np, evecs_np = sp.linalg.eigsh(B.to_numpy(L), m, sigma=1e-8) + + np.testing.assert_allclose(evals[:, 0], evals_np, atol=tol_m, rtol=tol_m) + + try: + np.testing.assert_allclose( + np.abs(evecs)[:, :2], np.abs(evecs_np)[:, :2], atol=tol_m, rtol=tol_m + ) + except AssertionError: + np.testing.assert_allclose( + np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol_m, rtol=tol_m + ) + + K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) + params = K_cons.init_params() + + nu = B.cast(B.dtype(B1), np.array([np.inf])) + params["nu"], params["lengthscale"] = nu, lscale + Kg = K_cons.K(params, idx) + Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T + np.testing.assert_allclose(Kg, Ki, atol=tol_m, rtol=tol_m) + + +def test_graphs_numpy(): + run_tests_with_adj(B1, B2) + +def test_graphs_torch(): + run_tests_with_adj(torch.tensor(B1), torch.tensor(B2)) + + +def test_graphs_jax(): + run_tests_with_adj(jax.numpy.array(B1), jax.numpy.array(B2), 1e-4, 1e-4) + + +def test_graphs_torch_cuda(): + if torch.cuda.is_available(): + B1 = torch.tensor(B1).cuda() + B2 = torch.tensor(B2).cuda() + m = B1.shape[1] + sc = GraphEdge(B1,B2) + # normed_graph = Graph(adj, normalize_laplacian=True) # fails due to bug in lab + + K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) + params = K_cons.init_params() + + params["nu"] = torch.nn.Parameter(torch.tensor([1.0]).cuda()) + params["lengthscale"] = torch.nn.Parameter(torch.tensor([1.0]).cuda()) + + idx = torch.arange(m)[:, None].cuda() + K_cons.K(params, idx) + else: + pass From b4a908933d0e1cca478d8d6fd9cda761733a7b50 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Mon, 22 Jul 2024 15:14:53 +0200 Subject: [PATCH 03/30] Fix few hacks --- geometric_kernels/spaces/graph_edge.py | 41 ++-- notebooks/EdgeSpaceGraph.ipynb | 68 +++--- notebooks/EdgeSpaceSimplicialComplex.ipynb | 100 ++++----- notebooks/backends/JAX_EdgeSpaceGraph.ipynb | 153 +++++++------- .../JAX_EdgeSpaceSimplicialComplex.ipynb | 148 ++++++------- .../backends/PyTorch_EdgeSpaceGraph.ipynb | 182 ++++++++-------- .../PyTorch_EdgeSpaceSimplicialComplex.ipynb | 198 ++++++++---------- notebooks/backends/PyTorch_Graph.ipynb | 81 +++++-- tests/spaces/test_graph_edge.py | 10 - 9 files changed, 484 insertions(+), 497 deletions(-) diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index 15f1cb53..f84179cb 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -12,7 +12,9 @@ eigenpairs, reciprocal_no_nan, set_value, + take_along_axis, ) + from geometric_kernels.spaces.base import DiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import ( Eigenfunctions, @@ -134,7 +136,7 @@ def edge_laplacian(self): return self._edge_laplacian, self._down_edge_laplacian, self._up_edge_laplacian - def get_eigensystem(self, num): + def get_eigensystem(self, num, hgc_order=False): """ Returns the first `num` eigenvalues and eigenvectors of the Hodge Laplacian. Caches the solution to prevent re-computing the same values. @@ -142,31 +144,44 @@ def get_eigensystem(self, num): :param num: Number of eigenpairs to return. Performs the computation at the first call. Afterwards, fetches the result from cache. + + :param hgc_order: + If True, the eigenmodes are organized according to the Harmonic, Gradient and Curl eigenvalues from small to big. + :return: A tuple of eigenvectors [n, num], eigenvalues [num, 1]. """ - eps = np.finfo(float).eps + eps = 1e-6 if num not in self.cache: evals, evecs = eigenpairs(self._edge_laplacian, num) - if self.edge_triangle_incidence_matrix is not None: + if self.edge_triangle_incidence_matrix is not None and hgc_order: # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian total_var = [] total_div = [] total_curl = [] num_eigemodes = len(evals) for i in range(num_eigemodes): - total_var.append(evecs[:, i].T@self._edge_laplacian@evecs[:, i]) - total_div.append(evecs[:, i].T@self._down_edge_laplacian@evecs[:, i]) - total_curl.append(evecs[:, i].T@self._up_edge_laplacian@evecs[:, i]) + total_var.append(B.matmul(evecs[:, i].reshape(1,-1), B.matmul(self._edge_laplacian, evecs[:, i]))) + total_div.append(B.matmul(evecs[:, i].reshape(1,-1), B.matmul(self._down_edge_laplacian,evecs[:, i]))) + total_curl.append(B.matmul(evecs[:, i].reshape(1,-1), B.matmul(self._up_edge_laplacian,evecs[:, i]))) - harm_evecs = np.where(np.array(total_var) < eps)[0] - grad_evecs = np.where(np.array(total_div) > eps)[0] - curl_eflow = np.where(np.array(total_curl) > eps)[0] - assert len(harm_evecs) + len(grad_evecs) + len(curl_eflow) == num_eigemodes, "The eigenmodes are not correctly organized" - evals = np.concatenate((evals[harm_evecs], evals[grad_evecs], evals[curl_eflow])) - evecs = np.concatenate((evecs[:, harm_evecs], evecs[:, grad_evecs], evecs[:, curl_eflow]), axis=1) - + harm_evecs, grad_evecs, curl_evecs = [], [], [] + for i in range(num_eigemodes): + if total_var[i] < eps: + harm_evecs.append(i) + elif total_div[i] > eps: + grad_evecs.append(i) + elif total_curl[i] > eps: + curl_evecs.append(i) + + reorder_indices = harm_evecs + grad_evecs + curl_evecs + assert len(reorder_indices) == num_eigemodes, "The eigenmodes are not correctly organized" + + evals = B.take(evals, reorder_indices, axis=0) + evecs = B.take(evecs, reorder_indices, axis=1) + + self.cache[num] = (evecs, evals[:, None]) return self.cache[num] diff --git a/notebooks/EdgeSpaceGraph.ipynb b/notebooks/EdgeSpaceGraph.ipynb index c4f847ef..013c424d 100644 --- a/notebooks/EdgeSpaceGraph.ipynb +++ b/notebooks/EdgeSpaceGraph.ipynb @@ -57,28 +57,9 @@ "## Basics" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For testing, we need to set the path right. **This is to be removed by code reviewers**." - ] - }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -86,7 +67,16 @@ "id": "NaG9OvVp-Ryf", "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" + ] + } + ], "source": [ "# Import a backend, we use numpy in this example.\n", "import numpy as np\n", @@ -127,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -151,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -168,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -221,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -283,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -305,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -334,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -400,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -417,7 +407,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -476,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -494,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -513,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -533,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -625,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -680,7 +670,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -708,7 +698,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -768,7 +758,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -808,7 +798,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { diff --git a/notebooks/EdgeSpaceSimplicialComplex.ipynb b/notebooks/EdgeSpaceSimplicialComplex.ipynb index 52bd14e5..4d4ce37f 100644 --- a/notebooks/EdgeSpaceSimplicialComplex.ipynb +++ b/notebooks/EdgeSpaceSimplicialComplex.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": { "id": "N2YCQeyY50Xg" }, @@ -57,28 +57,9 @@ "## Basics" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For testing, we need to set the path right. **This is to be removed by code reviewers**." - ] - }, { "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -86,7 +67,16 @@ "id": "NaG9OvVp-Ryf", "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" + ] + } + ], "source": [ "# Import a backend, we use numpy in this example.\n", "import numpy as np\n", @@ -127,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -151,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -167,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -184,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -237,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -281,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -321,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -365,7 +355,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -432,7 +422,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -454,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -483,7 +473,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -519,7 +509,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -549,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -566,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -625,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -643,7 +633,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -662,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -682,7 +672,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -778,7 +768,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -833,7 +823,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -861,7 +851,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -874,12 +864,12 @@ " [4]]\n", "\n", "emedding (shape = (3, 6)):\n", - "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 -1.29344481e-01\n", - " 5.15670639e-02 1.39200889e-01]\n", - " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 -1.59503941e-16\n", - " -6.37403964e-02 7.76266537e-16]\n", - " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 7.99392856e-02\n", - " -8.34372621e-02 9.36873407e-17]]\n", + "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 1.39200889e-01\n", + " -1.29344481e-01 5.15670639e-02]\n", + " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 7.76266537e-16\n", + " -1.59503941e-16 -6.37403964e-02]\n", + " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 9.36873407e-17\n", + " 7.99392856e-02 -8.34372621e-02]]\n", "\n", "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" ] @@ -921,7 +911,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -929,9 +919,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-0.12815855 0.03939647]\n", - " [-0.35448662 0.8352028 ]\n", - " [-0.08106564 -0.25947495]]\n" + "[[-0.00094174 0.18726061]\n", + " [-0.42678986 0.62902614]\n", + " [-0.24317193 -0.6577591 ]]\n" ] } ], @@ -961,12 +951,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/backends/JAX_EdgeSpaceGraph.ipynb b/notebooks/backends/JAX_EdgeSpaceGraph.ipynb index 1c74af8e..01269466 100644 --- a/notebooks/backends/JAX_EdgeSpaceGraph.ipynb +++ b/notebooks/backends/JAX_EdgeSpaceGraph.ipynb @@ -57,28 +57,9 @@ "## Basics" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For testing, we need to set the path right. **This is to be removed by code reviewers**." - ] - }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -95,21 +76,11 @@ "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", "INFO (geometric_kernels): JAX backend enabled.\n" ] - }, - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'geometric_kernels.spaces.graph_edge'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[3], line 17\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m jax\n\u001b[1;32m 16\u001b[0m \u001b[38;5;66;03m# Import a space and an appropriate kernel.\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mspaces\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgraph_edge\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m GraphEdge\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mkernels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MaternGeometricKernel\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# We use networkx to visualize graphs\u001b[39;00m\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'geometric_kernels.spaces.graph_edge'" - ] } ], "source": [ "# Import a backend, we use jax in this example.\n", + "import numpy as np\n", "import jax\n", "import jax.numpy as jnp\n", "from jax.random import PRNGKey\n", @@ -151,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -175,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -192,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -245,20 +216,32 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": { "id": "YJXKhf4y-tgV" }, "outputs": [ { - "ename": "NameError", - "evalue": "name 'GraphEdge' 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 2\u001b[0m\n\u001b[1;32m 1\u001b[0m incidence_matrix \u001b[38;5;241m=\u001b[39m jnp\u001b[38;5;241m.\u001b[39marray(nx\u001b[38;5;241m.\u001b[39mincidence_matrix(G, oriented\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\u001b[38;5;241m.\u001b[39mtoarray())\n\u001b[0;32m----> 2\u001b[0m edge_graph \u001b[38;5;241m=\u001b[39m \u001b[43mGraphEdge\u001b[49m(incidence_matrix)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnodes:\u001b[39m\u001b[38;5;124m'\u001b[39m, G\u001b[38;5;241m.\u001b[39mnodes)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124medges:\u001b[39m\u001b[38;5;124m'\u001b[39m, G\u001b[38;5;241m.\u001b[39medges)\n", - "\u001b[0;31mNameError\u001b[0m: name 'GraphEdge' is not defined" + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "\n", + "\n", + "edge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n" ] } ], @@ -295,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -317,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -346,7 +329,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -382,16 +365,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n" + "[[0]\n", + " [1]\n", + " [2]]\n" ] } ], @@ -412,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -429,12 +412,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -488,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -506,7 +489,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -525,7 +508,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -545,7 +528,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -558,7 +541,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -575,7 +558,7 @@ "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", @@ -583,7 +566,7 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", " vmin=values_32.min(), vmax=values_32.max(), \n", " **options)\n", "# add a label at the base edge \n", @@ -595,7 +578,7 @@ "\n", "\n", "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", @@ -603,7 +586,7 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", " vmin=values_inf.min(), vmax=values_inf.max(),\n", " **options)\n", "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", @@ -637,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -692,7 +675,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -720,7 +703,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -728,19 +711,19 @@ "output_type": "stream", "text": [ "xs (shape = (3, 1)):\n", - "[[3]\n", - " [5]\n", - " [4]]\n", + "[[0]\n", + " [1]\n", + " [2]]\n", "\n", "emedding (shape = (3, 6)):\n", - "[[-4.17448397e-02 3.83051484e-01 1.08504235e-01 -5.26867410e-02\n", - " 1.02519158e-01 -4.08723427e-02]\n", - " [ 3.28045722e-01 -6.11498784e-02 2.26833021e-16 -1.70497875e-01\n", - " -9.57952499e-17 5.05209940e-02]\n", - " [-3.28045722e-01 6.11498784e-02 1.75563540e-01 -3.25621967e-02\n", + "[[ 3.68915277e-01 1.11232141e-01 -1.08504235e-01 5.26867410e-02\n", + " -1.02519158e-01 4.08723427e-02]\n", + " [-3.68915277e-01 2.22464283e-01 -7.78347676e-17 1.05373482e-01\n", + " -1.00770134e-19 8.17446854e-02]\n", + " [ 0.00000000e+00 -3.33696424e-01 1.75563540e-01 -3.25621967e-02\n", " -6.33603240e-02 6.61328397e-02]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.163336342344337e-17\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 6.245004513516506e-17\n" ] } ], @@ -780,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -788,9 +771,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[ 0.36024923 -0.21070873]\n", - " [-0.02141462 -0.21293585]\n", - " [-0.14648103 0.75575338]]\n" + "[[-0.02020849 0.12888007]\n", + " [-1.36094681 0.04504047]\n", + " [ 1.03439484 -0.46260735]]\n" ] } ], @@ -820,12 +803,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/UAAAGeCAYAAADVFyFJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADIX0lEQVR4nOzdd3hTZRsG8Psk3XsvVsvsAAEBCyjOIqCiKCBDPwEBlaEgOD6UpSxFZTgAmS4QFNwKCnygbFBARstuWaUt3Xsl7/dH2jSh6Uzak3H/riuXzek5yRNMmuc9532fRxJCCBARERERERGRxVHIHQARERERERER1Q8H9UREREREREQWioN6IiIiIiIiIgvFQT0RERERERGRheKgnoiIiIiIiMhCcVBPREREREREZKE4qCciIiIiIiKyUBzUExEREREREVkoDuqJiIiIiIiILBQH9UREREREREQWioN6IiIiIiIiIgtlU4P6zz77DJIkISEhQe5QGpRarcbcuXPRqlUr2Nvbo1WrVli4cCHCw8OhVqurPXbFihVo3rw5ioqKav18R44cQc+ePeHq6gpJknD8+HEjX4FpmNv/79mzZ0OSJLnDqBdD7ylLU9vPgDFyc3OhUCiwePHiBnsOY9Tn801E9WNu30ENhTmHhrn9/2bOIS/mHMw5Glu9BvUnT57EoEGD0KJFCzg5OaFJkybo3bs3PvroI1PHZ1H+/fdfSJKEs2fPAgAWL16M0NDQSvvl5uZi1qxZ6Nu3L3x8fCBJEj777DOTxbFs2TLMnDkTTzzxBNauXYvFixfj3Xffxeuvvw6Fovr/5SNHjkRxcTE+/fTTWj1XSUkJBg8ejPT0dCxevBhffvklWrRoYYqXQWbk1vdUbd8fdRUfH4+JEyeibdu2cHFxgYuLCyIjIzFhwgScOHFCb9/yBKr85uTkhLZt22LixIlITk7W2zc7O7vKz0BRURFef/11hISEwNnZGdHR0di+fXu94j916hSEEGjfvn29jm9odf18E5kD5hyG1TbnOHLkCCZOnIioqCi4urqiefPmePLJJ3Hu3DmTxMGcg0yNOUftMOcgPaKO9u3bJxwcHETr1q3FnDlzxKpVq8TMmTPFgw8+KFq1alXXh2tU69atEwBEfHx8gzz+p59+Knx8fIRarRZCCDF48GAxZMiQSvvFx8cLAKJ58+bi3nvvFQDEunXrTBbH7bffLh588EHt/cWLFwsPDw9RUFBQq+Nfe+010aJFC+3rqE5cXJwAIFatWlXveBtKaWmpKCgoqNXraAyzZs0S9fjImYVb31MN4eeffxYuLi7Cw8NDjBs3TqxYsUKsXLlSTJkyRYSGhgpJkkRCQoJ2//LP89tvvy2+/PJLsWrVKjFixAihUChEWFiYyMvL0+5b3Wdg6NChws7OTrzyyivi008/FT169BB2dnZiz549dX4NK1euFADEjRs36veP0Ajq8vkmkhtzjqrVNucYOHCgCAoKEi+++KJYtWqVmDNnjggMDBSurq7i5MmTRsfBnEODOYfpMOeoHeYcpKvOn/aHHnpI+Pv7i4yMjEq/S05ONkVMDaahv2BHjx4t+vbtq73ftGlTsWjRokr7FRYWaj+AR44cMemgvqCgQCiVSjF37lzttttuu008/fTTtX6Mv//+WwAQO3furHHfP//8UwAQ3377bb3iNSQ3N9dkj2VOLPUL1tB7ytQuXLggXF1dRUREhEhMTKz0+5KSErF06VJx5coV7bbyz/ORI0f09p0yZYoAIDZs2KDdVtVn4NChQwKAeO+997TbCgoKRKtWrUSPHj3q/DpefPFF4efnV+fjGlNdPt9EcmPOUbXa5hz79u0TRUVFetvOnTsnHB0dxVNPPWVUDMw5zBdzjqox52g8zDkaT52n31+8eBFRUVHw8vKq9LuAgADtz5cvX8b48ePRrl07ODs7w9fXF4MHD6601qh8zc+5c+fw9NNPw9PTE/7+/pgxYwaEELh69Soee+wxeHh4ICgoCB988IHB48+cOYMnn3wSHh4e8PX1xaRJk1BYWFir13T9+nU8++yzCAwMhKOjI6KiorB27dpaHZuRkYHU1FSkpqbi0KFDaN++PVJTU3H69Glcu3YNbdq0QWpqKnJzc7XHODo6IigoqFaPDwBnzpzBlStXatxv9OjRcHZ2hkqlwvTp0yFJEoKDg3HixAnExMTU+vm6dOkCHx8f/Pjjj9XuN3LkSNxzzz0AgMGDB0OSJNx7773a3x87dgz9+vWDh4cH3Nzc8MADD+DgwYN6j1H+/y82NhbDhw+Ht7c37rrrrlrHWp1b17eVP9eFCxcwcuRIeHl5wdPTE6NGjUJ+fn6tHrO275W9e/eiW7ducHJyQqtWraqderR792507dpVb19Da+Fq+9w5OTmYPHkyQkND4ejoiICAAPTu3RtHjx6t1WvUZeg91aNHjzo/Tk0WLlyIvLw8rFu3DsHBwZV+b2dnh5deegnNmjWr8bHuv/9+AJppdeX/reozsHnzZiiVSjz33HPabU5OThg9ejQOHDiAq1ev1ul1nDx5ElFRUXrbVq1aBQcHB0yePBkqlapOj9cQavv5JjIHzDn01Sfn6NmzJxwcHPQep02bNoiKikJcXFyl52DOUT/MOZhzlP+XOUcF5hyNx66uB7Ro0QIHDhzAqVOnql3DceTIEezfvx9Dhw5F06ZNkZCQgOXLl+Pee+9FbGwsXFxc9PYfMmQIIiIi8M477+DXX3/F3Llz4ePjg08//RT3338/3n33Xaxfvx6vvPIKunXrhrvvvlvv+CeffBKhoaFYsGABDh48iA8//BAZGRn44osvqn09ycnJ6N69OyRJwsSJE+Hv74+tW7di9OjRyM7OxuTJk6s9vnPnzrh8+bL2/qlTp/D+++9r7/fv3x8AMGLEiHqvm4+IiMA999yD3bt3V7vfU089BXt7e3z66adYunQpfHx8cPHiRcyePRu33357nZ7z9ttvx759+6rd5/nnn0eTJk0wf/58vPTSS+jWrRsCAwMBAKdPn0avXr3g4eGB1157TRvXvffeiz///BPR0dF6jzV48GC0adMG8+fPhxCiTrHW1ZNPPomwsDAsWLAAR48exerVqxEQEIB333232uNq+145efIkHnzwQfj7+2P27NkoLS3FrFmztP82uo4dO4a+ffsiODgYb731FlQqFd5++234+/vX67kB4IUXXsDmzZsxceJEREZGIi0tDXv37kVcXFyd3weG3lMNsX7xl19+QevWrSu9L+rj4sWLAABfX18AwP79+wHA4Gs/duwY2rZtCw8PD73td9xxBwDg+PHjtfpSL3fy5EkMGzYMAFBaWorJkydj5cqV+OSTTzB27Ni6v5gGUpvPN5E5YM6hz1Q5hxACycnJlQYEAHMOU2POUXvMOZhzkBHqemn/jz/+EEqlUiiVStGjRw/x2muvid9//10UFxfr7Zefn1/p2AMHDggA4osvvtBuK58e9Nxzz2m3lZaWiqZNmwpJksQ777yj3Z6RkSGcnZ3FiBEjKh3/6KOP6j3X+PHjBQDx77//arcZmgo3evRoERwcLFJTU/WOHzp0qPD09DT4OnTt3btXbN++XcyYMUPY2dmJrVu3iu3bt4t+/fqJrl27iu3bt4vt27eL06dPGzy+NtPvAYh77rmn2jjKvfHGG8LV1VWoVCohhBDTp08XAEROTk6tji/33HPPCWdn5xr327Vrl8GpcAMGDBAODg7i4sWL2m2JiYnC3d1d3H333dpt5f//hg0bVqf4auPW/9/lz/Xss8/q7ff4448LX1/fGh+vtu+VAQMGCCcnJ3H58mXtPrGxsUKpVFaaCte/f3/h4uIirl+/rt12/vx5YWdnp7dvXd6nnp6eYsKECTW+ntq69T1lallZWQKAGDBgQKXfZWRkiJs3b2pvuq+z/P/vjh07xM2bN8XVq1fFxo0bha+vr3B2dhbXrl0TQlT/GYiKihL3339/pe2nT58WAMSKFStq/ToSExO1x6SlpYn7779f+Pj4iF27dtX6MRpLbT/fRHJjzqHP2Jyj3JdffikAiDVr1lT6HXOO+mHOYRrMOWqHOQfdqs7T73v37o0DBw7g0Ucfxb///ouFCxeiT58+aNKkCX766Sftfs7OztqfS0pKkJaWhtatW8PLy8vglJwxY8Zof1YqlejatSuEEBg9erR2u5eXF9q1a4dLly5VOn7ChAl691988UUAwG+//VblaxFCYMuWLejfvz+EENopbampqejTpw+ysrJqnD505513IiYmBrm5uejWrRv69u2LmJgYXLlyBY888ghiYmIQExODyMjIah+nOkKIGs+Ylztx4gSioqK01TbT0tJgZ2cHNze3SvsePHgQkiRh9uzZlX7n7e2NgoKCWk8R06VSqfDHH39gwIABaNmypXZ7cHAwhg8fjr179yI7O1vvmBdeeKFWj11dzLV163P16tULaWlplWLSVdv3ikqlwu+//44BAwagefPm2uMjIiLQp08fvcdUqVTYsWMHBgwYgJCQEO321q1bo1+/fnV+7nJeXl44dOgQEhMT6/1vpOvW91RVdu3ahYULF2LZsmU4c+ZMpd/v378f165dq7S9/N/d0Hv03nvvhb+/v/b2ySefVNonJiYG/v7+aNasGYYOHQo3Nzd8//33aNKkCYDqPwMFBQVwdHSstN3JyUn7+9oqr5QrSRK6deuGxMREHDp0SG96qLkw5vNN1JiYc+gzRc5x5swZTJgwAT169MCIESMMxsmco+aYa4s5R90w56gd5hx0qzpPvweAbt264bvvvkNxcTH+/fdffP/991i8eDEGDRqE48ePIzIyEgUFBViwYAHWrVuH69ev601vysrKqvSYun+MAMDT0xNOTk7w8/OrtD0tLa3S8W3atNG736pVKygUimr7hd68eROZmZlYuXIlVq5caXCflJSUKo/PyspCSUkJAGDnzp24//77kZqaivT0dJw+fRpz585Famoq7O3t4enpWeXjmNK///5b6Q95fZT//6pPj9ObN28iPz8f7dq1q/S7iIgIqNVqXL16VW/aX1hYWP2DraNb32ve3t4ANGsVb50SVa6275WbN2+ioKCg0vsRANq1a6eX8KWkpKCgoACtW7eutK/utrq+TxcuXIgRI0agWbNm6NKlCx566CE888wzeslOXdT0nrp58yYef/xx7N+/HwEBAUhPT0dJSQluv/12PPzwwwgICMDevXvx3XffITY2ttLx7u7uAKC3BrTcp59+ipycHCQnJ+Ppp582+PyffPIJ2rZtCzs7OwQGBqJdu3Y1JgPlnJ2dDfZPLV8bqztQqMnJkycBABMnTkTXrl3x22+/VVoH/Nxzz+Hnn39GXl4eWrRogfnz52uny5Y7fvw4Ro0ahc6dO2PHjh3IzMxEZGQkFi9ebLK1hcZ8vokaG3MODVPkHElJSXj44Yfh6empXd9rDOYcNWPOUTfMOWqHOQfdql6D+nIODg7o1q0bunXrhrZt22LUqFH49ttvMWvWLLz44otYt24dJk+ejB49esDT0xOSJGHo0KFQq9WVHsvQF0tVXza6X9ZVqc0bpzyOp59+2uDZagC47bbbqjz+sccew59//qm9f+LECSxZskR7//HHHweAWq1NM4XMzExcvXoVHTp00G7z9fVFaWkpcnJytH/Iyt1+++24evWqwS+VjIwMuLi41OkPjDFq+zzVxVxb9Xlf1fa9Yui9bay6vk+ffPJJ9OrVC99//z3++OMPvPfee3j33Xfx3Xff6Z2Nrw1D76lbnT17Fi1atMCGDRvQvHlzFBYWYuvWrdiwYQOWLVuGgoIC3HXXXfjzzz8NJhOenp4IDg7GqVOnKv2ufL1bdYnyHXfcga5du1b5++o+A8HBwbh+/XqlY27cuAEAelczanLy5Em0aNECrVq1wqlTp5Cbm1vpC3bKlCn46KOP4OjoiCNHjiAmJgaXLl3SrsUDgG3btiEmJgbu7u7Yu3cvmjZtim+++Qb9+/dHQkKCwbP/ddXYn28iU2DOYVzOkZWVhX79+iEzMxN79uyp0983Q5hz1A5zjtpjzsGcg+rPqEG9rvI3ePkbc/PmzRgxYoRe5djCwkJkZmaa6in1nD9/Xu/M64ULF6BWqxEaGlrlMf7+/nB3d4dKpapTpdZyH3zwATIyMnDgwAG89dZb+OWXX2BnZ4ePPvoI169fxzvvvAOg4qxsQyufiqP7xzY8PByAphrnrcmCg4MDmjZtavCx4uPjERERUa84/P394eLigrNnz1b63ZkzZ6BQKOpUCERXdTE3pNq+V1QqFZydnXH+/PlKv7v13yMgIABOTk64cOFCpX11t9XnfRocHIzx48dj/PjxSElJwe2334558+bV+QvW0HvqVnfccYde9WAnJyc8/vjj2gSzNh5++GGsXr0ahw8f1haMMZXqPgOdOnXCrl27kJ2drZe0HTp0SPv72jp58iQ6deqEVatWoWvXrnj88cexZ88e7bQ63VgAzSCguLgY169fr/QF+84776B79+7abUOHDsWUKVNw9uxZdOnSpcoY1qxZg59++gk//vgjzpw5g8GDB+O9995D37599fYz5vNNZA6Yc9Qt5ygsLET//v1x7tw57Nixw6glgeWYczQc5hzMOWrCnINuVec19bt27TJ4drF8ik/59CelUllpv48++qjB2ivcuu7lo48+AoBq/6AolUoMHDgQW7ZsMXjG7ubNm9U+Z5cuXRATE4PS0lK0b99eu7YtOTlZu64tJiam2g9EbdS2vcy///4LQP+PYfnUmb///rtOz3n06FH07NmzTseUUyqVePDBB/Hjjz/qne1MTk7Ghg0bcNdddxl11lsOtX2vKJVK9OnTBz/88IPe/7O4uDj8/vvvlR4zJiYGP/zwg95atAsXLmDr1q11fm5A8wV/61TTgIAAhISEGJzyVRND76lb3doqqT5ee+01uLi44Nlnn0VycnKl39fmSllVqvsMDBo0CCqVSm+KYVFREdatW4fo6OhaJ4IqlQpxcXHo0KED/P398d133+HUqVMYN25cpX3Hjx8PZ2dndOvWDffff7/eFYmcnBycPXu2UpJx/vx5pKenG7zqoOvkyZO47bbbsH//fgwcOBCfffZZpS9XwLjPN1FjYs5Rob45h0qlwpAhQ3DgwAF8++23NU6pZc4hP+YczDmqw5yDDKnzlfoXX3wR+fn5ePzxxxEeHo7i4mLs378fmzZtQmhoKEaNGgUAeOSRR/Dll1/C09MTkZGROHDgAHbs2KF3dsiU4uPj8eijj6Jv3744cOAAvvrqKwwfPhwdO3as9rh33nkHu3btQnR0NMaOHYvIyEikp6fj6NGj2LFjB9LT02t87n379mnfrIWFhTh27BjeeOONao/5+OOPkZmZqf3D+vPPP2sLerz44ot66+Fq217mxIkTaNKkCXx8fLTbWrZsifbt22PHjh149tlna3wtAPDPP/8gPT0djz32WK32N2Tu3LnYvn077rrrLowfPx52dnb49NNPUVRUhIULF9b7ceVU2/fKW2+9hW3btqFXr14YP348SktL8dFHHyEqKkp7Frrc7Nmz8ccff+DOO+/EuHHjoFKp8PHHH6N9+/Y4fvx4nZ87JycHTZs2xaBBg9CxY0e4ublhx44dOHLkiN4VLEmS6v2eaght2rTBhg0bMGzYMLRr1w5PPfUUOnbsCCEE4uPjsWHDBigUinpdManuMxAdHY3Bgwdj2rRpSElJQevWrfH5558jISEBa9as0du3un+z8+fPo7CwUPtl2aVLFyxfvhyjRo1Cly5dMHHiRO2+y5Ytw0cffYTdu3fj1KlTetN2d+7ciXvuuUdvfV5BQQGefvppTJs2rcbaHCdPnkRQUBAee+wxHDp0yOCaRlN8vokaC3OOyuqac0ydOhU//fQT+vfvj/T0dHz11Vd6v7917TBzDvPAnKPhMOfQYM5hZepaLn/r1q3i2WefFeHh4cLNzU04ODiI1q1bixdffFEkJydr98vIyBCjRo0Sfn5+ws3NTfTp00ecOXNGtGjRwmB7mJs3b+o9z4gRI4Srq2ul57/nnntEVFRUpeNjY2PFoEGDhLu7u/D29hYTJ04UBQUFescaai8jhBDJycliwoQJolmzZsLe3l4EBQWJBx54QKxcubLGf4/S0lLh5uYmvvzySyGEpt0MAJGSklLtcS1atBAADN5ujQ+1bC9zxx13iH79+lXavmjRIuHm5lZjq5xyr7/+umjevLlQq9U17ltVexkhhDh69Kjo06ePcHNzEy4uLuK+++4T+/fv19unqv//plBVe5lbn6uq94UhtX2v/Pnnn6JLly7CwcFBtGzZUqxYsUL7/LfauXOn6Ny5s3BwcBCtWrUSq1evFlOnThVOTk51fu6ioiLx6quvio4dOwp3d3fh6uoqOnbsKJYtW6bdJycnRwAQQ4cOrfH1VvWeaigXLlwQ48aNE61btxZOTk7C2dlZhIeHixdeeEEcP35cb9/y/29Hjhyp8XGr+wwUFBSIV155RQQFBQlHR0fRrVs3sW3bNr19avo3++abbwSASm2kxo8fL+zt7cWff/5p8LhHHnlE/Prrr9r7zz//vF57y+LiYvHwww+L4cOH1+rz6O/vL3r16iU8PT2rfM66fL6J5MacQ199co577rmnynzD0HcSc476Yc7BnKMcc44KzDkaT50H9eamIf9AW4vMzEzh4+MjVq9eXeO+hYWFIigoSCxZsqQRIqOqPPbYY6J169YN8ti//vqrkCRJnDhxokEe3xzV5TNgSEP9m/Xt21csXbpUez8sLEwkJiYKIYRQqVRiyJAh4pFHHhElJSU1PlZSUpJwcnIShYWF4o033hAxMTGV9uHnm8g4zDlqxpzD8jDnMC3mHBr8fDeuOq+pJ8vj6emJ1157De+9916NlVLXrVsHe3v7WvdwJePd2pf0/Pnz+O233xqs1+iuXbswdOjQaqvLWpu6fAYMMcW/WVZWFjZs2IDc3FyUlpbi22+/xa5du3D33XcD0Kxj9fDwQHBwMADg+eefx40bN/Dtt9/Czq7ySqmRI0di5MiR2vsnT55EREQEHB0dMXnyZOzfvx8HDx7UO4afbyJqaMw5zBtzjobHnEODn+/GJQlhRDUIMzB79my89dZbuHnzZqX+skSWIDg4GCNHjkTLli1x+fJlLF++HEVFRTh27JjB3rNkmbKzs/HYY4/h2LFjEEKgdevWePPNN/HEE08AAJYsWYKkpCS88847uHz5MkJDQ+Hk5KTXDmnr1q3o1asXACAmJgZDhgzB2LFjAQCLFy/GsWPH8MUXXwAAJk2ahAsXLuDXX39t5FdKZL2Yc5ClY85hG5hz2B6TtbQjovrp27cvvv76ayQlJcHR0RE9evTA/Pnz+eVqZTw8PLBr164qf79t2zb897//BQC0aNGi2uq7paWlSExM1Dtr/vLLL+vts3TpUuMCJiIiq8OcwzYw57A9Fn+lnojIGixcuBAvv/wy7O3t5Q6FiIiIrBhzDuvDQT0RERERERGRhWKhPCIiIiIiIiILxTX1RERUb4WFhSguLjb6cRwcHODk5GSCiIiIiMgaMeeoGgf1RERUL4WFhQhr4YakFJXRjxUUFIT4+Hir+5IlIiIi4zHnqB4H9UREVC/FxcVISlHh8j+h8HCv/2qu7Bw1WnRJQHFxsVV9wRIREZFpMOeoHgf1RERkFDd3CW7uUr2PV6P+xxIREZHtYM5hGAf1RERkFJVQQ2VEHxWVUJsuGCIiIrJazDkMY/V7IiIiIiIiIgvFK/VERGQUNQTUqP9pc2OOJSIiItvBnMMwDuqJiMgoaqhhzGQ2444mIiIiW8GcwzBOvyciIiIiIiKyULxST0RERlEJAZWo/3Q2Y44lIiIi28GcwzAO6omIyChc30ZERESNgTmHYZx+T0RERERERGSheKWeiIiMooaAimfNiYiIqIEx5zCMg3oiIjIKp8IRERFRY2DOYRgH9UREZBQWrSEiIqLGwJzDMK6pJyIiIiIiIrJQvFJPRERGUZfdjDmeiIiIqCbMOQzjoJ6IiIyiMrJojTHHEhERke1gzmEYp98TERERERERWSheqSciIqOohOZmzPFERERENWHOYZhFD+pzc3Nx4cIFFBUVwdHREa1bt4abm5vcYRER2RSubyNbwJyDiEh+zDkMs7hBfWxsLFasWIHt27fj7NmzEDptCSRJQrt27dC7d2+88MILiIyMlDFSIiIismTMOYiIyBJYzJr6+Ph49OvXD1FRUdi0aRPuu+8+rFmzBgcPHsSJEydw8OBBrFmzBvfddx82bdqEqKgo9OvXD/Hx8XKHTkRk1dSQoDLipoYk90sg0sOcg4jIPDHnMEwSuqedzdTq1asxefJk+Pn5Yf78+Rg0aBAcHByq3L+4uBibN2/GtGnTkJaWhiVLlmDMmDGNGDERkfXLzs6Gp6cn/j4dCDf3+p8jzs1Ro2tUMrKysuDh4WHCCInqjjkHEZH5Yc5RPbO/Uj9v3jyMHTsWw4YNw8mTJzF8+PBqv1wBwMHBAcOHD8epU6cwbNgwjB07FvPmzWukiImIiMgSMecgIiJLZNZr6levXo3p06djzpw5mD59ep2Pd3d3x6pVq9C8eXNMnz4dQUFBGD16dANESkRku8qntBlzPJHcmHMQEZk/5hyGme2V+vj4eEyePBljxoyp9OV65MgRTJw4EVFRUXB1dUXz5s3x5JNP4ty5cwYfa/r06RgzZgwmTZrE9W5ERCZmzNo2Y7+ciUyBOQcRkWVgzmGY2a6p79evH+Li4nDy5Em4u7vr/W7QoEHYt28fBg8ejNtuuw1JSUn4+OOPkZubi4MHD6J9+/aVHi87OxsdOnRAZGQktm7d2lgvg4jIapWvb9t7KsTo9W13tU+0uvVtZDmYcxARmTfmHNUzy0F9bGwsoqKisH79egwfPrzS7/fv34+uXbvqrXM7f/48OnTogEGDBuGrr74y+LgbNmzAU089hdjYWERERDRY/EREtoBfsGQNmHMQEZk/5hzVM8vp9ytWrEBAQAAGDRpk8Pc9e/asVLimTZs2iIqKQlxcXJWPO3DgQAQEBGD58uUmjZeIyJZxKhxZMuYcRESWgzmHYWZZKG/79u0YOHBgjRVndQkhkJycjKioqCr3cXR0xMCBA7Fjxw5ThElERABUUEBlxDlilQljIaor5hxERJaDOYdhZnelPicnB2fPnkW3bt3qdNz69etx/fp1DBkypNr9unbtijNnziA3N9eYMImIiMjCMecgIiJrYHaD+osXL0IIgcjIyFofc+bMGUyYMAE9evTAiBEjqt03KioKQghcuHDB2FCJiAiAEBLURtyEsM6pcGT+mHMQEVkW5hyGmd30+6KiIgCAi4tLrfZPSkrCww8/DE9PT2zevBlKpbLa/Z2dnfWeh4iIjMOesWSpmHMQEVkW5hyGmd2VekdHRwBAfn5+jftmZWWhX79+yMzMxLZt2xASElLjMQUFBXrPQ0RElumTTz5BaGgonJycEB0djcOHD1e7f2ZmJiZMmIDg4GA4Ojqibdu2+O233xopWjJHzDmIiKg2zD3nMLtBfevWrSFJEmJjY6vdr7CwEP3798e5c+fwyy+/1Hrq3OnTpyFJElq3bm2KcImIbJ5KKIy+1dWmTZswZcoUzJo1C0ePHkXHjh3Rp08fpKSkGNy/uLgYvXv3RkJCAjZv3oyzZ89i1apVaNKkibEvnywYcw4iIsvCnMMwsxvUu7m5oV27djhy5EiV+6hUKgwZMgQHDhzAt99+ix49etT68f/++2+Eh4fDzc3NFOESEdk8NSSooTDiVvepcIsWLcLYsWMxatQoREZGYsWKFXBxccHatWsN7r927Vqkp6fjhx9+wJ133onQ0FDcc8896Nixo7EvnywYcw4iIsvCnMMwsxvUA0Dv3r2xZcsWFBcXG/z91KlT8dNPP6Ffv35IT0/HV199pXerSlFREbZs2YKYmJiGCp2IyOY0ds/Y4uJi/PPPP3p/yxUKBWJiYnDgwAGDx/z000/o0aMHJkyYgMDAQLRv3x7z58+HSmWtzW2otphzEBFZDuYchpldoTwAeOGFF/DRRx9h8+bNGD58eKXfHz9+HADw888/4+eff670+6efftrg427ZsgUpKSkYN26cSeMlIiLjZWdn6913dHQ0uBY5NTUVKpUKgYGBetsDAwNx5swZg4996dIl/O9//8NTTz2F3377DRcuXMD48eNRUlKCWbNmme5FkMVhzkFEZHusLecwyyv1kZGR6Nu3L9544w3k5ORU+v3u3bshhKjyZkh2djamTZuGvn37IiIioqFfAhGRzTDV+rZmzZrB09NTe1uwYIHJYlSr1QgICMDKlSvRpUsXDBkyBG+++SZWrFhhsucgy8Scg4jIcjDnMMwsr9QDwLJly9ChQwdMmTIFq1atMuqxhBCYMmUK0tLSsGzZMhNFSEREQPn6tvq3iCk/9urVq/Dw8NBur6piuJ+fH5RKJZKTk/W2JycnIygoyOAxwcHBsLe312tBFhERgaSkJBQXF8PBwaHe8ZPlY85BRGQZmHMYZpZX6gEgLCwMS5YswerVqzF37tx6P44QAnPnzsWaNWvw4ltd0LSFvwmjJCIiU/Hw8NC7VfUF6+DggC5dumDnzp3abWq1Gjt37qyyiNmdd96JCxcuQK1Wa7edO3cOwcHBHNBTg+Qc3fx7wcvVx4RREhGRqVhbzmG2g3oAGDNmDObOnYsZM2Zg7NixBqfFVSc7Oxtjx47FzJkz8dTUIHR/PAt7E59FQanh9gNERFR3aiigMuKmrsdXUfkV1c8//xxxcXEYN24c8vLyMGrUKADAM888g2nTpmn3HzduHNLT0zFp0iScO3cOv/76K+bPn48JEyaY7N+BLJspc45WiILdZTdM6vkmrp2/0UARExHZHuYchpnt9Ptyb775JgIDAzF58mT88ccfWLBgAQYNGlTtWY7yirPTpk1DWloali6fhTZ9d6NYnYns4nPYkzgC3YM+hodDq0Z8JURE1qm+fV8rjje8Lrk6Q4YMwc2bNzFz5kwkJSWhU6dO2LZtm7aQzZUrV6BQVMTUrFkz/P7773j55Zdx2223oUmTJpg0aRJef/31esdN1scUOceCt97FidWXcPNaGm5cSsbkO9/EnJ+nISK6TSO+EiIi68ScwzBJVFXlxczEx8dj/Pjx2LZtGwICAjBw4EB07doVUVFRcHZ2RkFBAU6fPo2///5bW3G2b9++WLZsGcLCwpBTnICDSeORX5oIALBXuCM6cCl8nW+X+ZUREVmm7OxseHp6YuPxSLi4K2s+oAr5OSoM7RSLrKwsvfVtRHIxNue4eS0Nbzw0DwmnrgIAHJ0dMH3TFHR/pIvMr4yIyDIx56iexQzqy8XGxmLFihXYsWMHzpw5o1d5VpKA8PBwxMT0xrhx4ypVnC0sTcXBpInIKta0H1BIDujiPx8hbuwhS0RUV+VfsBuOtzf6C3Z4p1NW9wVLlq+6nAOShLZt2qJPnwcN5hy5mXmY/cR7+Hf3aQCAQiHhpWVj8fBzvRvzJRARWQXmHNWzuEG9rtzcXFy4cAEFqe/DEXvQOswe7s1/gWQfXuUxJeo8/J38KlIK9pdtkdDe91W08qzcm5aIiKpW/gX75bEORn/B/qfzSav7giXrUp5zfPnTAfxx8Dyc3Pzw8YzhiO4QWuUxxUUleG/UJ9i9cZ9221PTB2LEW0MgSfWv3kxEZGuYc1TPrAvl1cTNzQ2dOnVC9+53oVN7R7i5KoDSC9UeY69wRXTQUjRz61+2ReBU2kKcTlsMIdTVHktERES2qTznuPfuu+Dq3QRKe0ckXE+v9hgHR3tM++olDJ7aX7tt/dwt+GD0cpSWlDZ0yEREZCMselCvZdda+6MovVjj7grJHp3930Zbr7HabReyPsc/KW9AJYobJEQiImtlTBXa8huRpQhr4qv9Of56Wo37KxQKPPfeMxi3eKT26vzvn+3CzMfeRUFuQYPFSURkjZhzGGYdr8pOp4p9LQb1ACBJEiJ8JqCj33SU/zNcz9uGgzcmoERdtzY2RES2TC0URt+ILEWozqA+oRaD+nJPTHoYb258GfaO9gCAI9uOY+q9s5CelGHyGImIrBVzDsOs41UpmwHQfElCVf30+1uFegzCHYGLoJScAACphUfKetknmzhIIiLrxLPmZEvcXBzh7+0GALh0PQ11KU10z+AeeOf36XDzcgUAnD8aj0l3Tse1c4kNEisRkbVhzmGYVbwqSbID7Fpq7pQmQIiSOh0f7HovegavhIPCCwCQXXwee66PQHZx3U4QEBERkfULbeIDAMjOLURGdt2m0N92dyQW75kD/2aaK/5J8SmYdOd0xB48Z/I4iYjINljFoB5AxaAepYDqSp0P93G6Db1CPoeLXRMAQIEqCXsTRyG14G8TBklEZH3UAFRCqveNJUrJ0oSG6EzBT6z9FHzt8VHN8OH+eWh5WwsAQHZaDl574C3s/+mIyWIkIrJGzDkMs5pBvaRTLK+mCvhVcXNogV4hX8DTIRIAUKLOwYEb43A993dThEhEZJXUUBh9I7IkdS2WZ4hfE18s+vMtdLq/PQCgqKAYbz3xHn5e8YdJYiQiskbMOQyznlelN6ivXbE8Q5zsfHFXyGoEON8JAFCjBH+n/BcXs74yNkIiIiKyAqYY1AOAq6cr5v/2Bu4ffhcAQK0W+HD8Kqyb/nWd1uoTEZFts55BvbKiAn5t2tpVx07hguigJWju9lj5I+JU2vs4lbaIveyJiG6hEgqjb0SWpHxNPYAae9XXxN7BHq9/8SKefPUx7bYN87/De89+wl72RES3YM5hmPW8KrtQAErNz/Wcfq9LIdmjk/9stPN6TrvtYtYX7GVPRHQLNSSjb0SWxNvDBV7uzgDq1tauKgqFAmPffRoTlj6r7WW//fM/Mb3/O8jPYS97IqJyzDkMs5pBvSQ5AMrmmjullyCEygSPKSHcZzw6+s2Afi/78ShRZRv9+ERERGSZyqfgp2bmISev0CSPOeDFfpjxzRRtL/t//viXveyJiKhGVjOoBwDYlU/BLwJU1032sKEeAxEduESnl/3f2MNe9kREADgVjmxTaIjOFPxE46bg6+o1sDsWbp8Bd29NL/sLx+IxqeebuHrWdHkNEZGlYs5hmHW9KhMVyzMkyPVu3Bm8Cg4KbwBATskF/HX9GfayJyKbp4LC6BuRpQk1UbE8Q9rfFYHFe+cioLkfACAp4SYm3Tkdp/efNenzEBFZGuYchlnVq9Jra6cy7aAeALydOqBXk8/hatcMAFCoSsaexJFILWBfWSIiIlsS1lSnV72JB/UA0CKiKZbun4eWHTW97HPSc/FazFvY98Nhkz8XERFZNqsa1FdMvweECYrlGeJm3xy9mnwOL0dNL/tSdS4O3BjPXvZEZLPUQjL6RmRpdKffxxtZAb8qfiE+WPTn2+j8QAcAQHFhCd4e9D5+Wsacg4hsE3MOw6xsUN8SKK9o2ECDegBwVPrgzuDVCHQu6yuLEvyd8jouZH7ZYM9JRGSu1EZOg1Nb2VcR2QZ/bze4OjsAMP30e12uHi6Y9+s0PPB0LwCaXvYfTVyNNdPWs5c9Edkc5hyGWdWrkiRnQNlEc6f0YoN+2dkpXHBH0BI0d39cu+10+gc4mfoee9kTkU1RC4XRNyJLI0kSQkM0U/CTUrNRUFjSYM9l72CP1z9/EUNfH6DdtvHdH7Bw5McoKW645yUiMjfMOQyzvldVPgVf5AHqhq1Or5Ds0MlvJtp5v6Dddil7Pf5O+S9U6qIGfW4iIiKSV1jTiin4l280zBT8cpIkYfSCpzDxo9HaXvY7vvwL0x9ZgLzs/AZ9biIiMm/WN6hX6lbAb/jK9JIkIdz7BXTymwUJSgBAYt4fOJA0HsXsZU9ENkAFyegbkSUK062Af63hpuDremxCX8zcPBUOTppe9kd3nMTUe2ch1YRt9YiIzBVzDsOsblAv6RTLM3Vbu+q08Hgc0UEVvezTCv/B3sRRKChNarQYiKxJbm4ujh8/jkOHDuH48ePIzc2VOySqAqfCka0qn34PAAmJjTOoB4C7Ho/Gu9tnwt3HDQBw8XgCJvV8E5fjrjVaDETWhDmH5WDOYZj1vSqdtnYNVQG/KoEuvXBn8GqdXvYX8df1/yCr6FyjxkFkqWJjY/HSSy8hIiICHh4e6Ny5M7p3747OnTvDw8MDEREReOmllxAbGyt3qERE+lfqG7BYniHt7wzHkr1zEdjCHwCQciUVL981Haf2nWnUOIgsFXMOsiZWOKjXvVLfuIN6APB2ao+7m3yh08v+JvYmPoub7GVPVKX4+Hj069cPUVFR2LRpE+677z6sWbMGBw8exIkTJ3Dw4EGsWbMG9913HzZt2oSoqCj069cP8fHxcodOAFQwdjockWUK8vOAo4MdgIZra1ed5uFNsHT/PLTqFAoAyMnIw2sxb2PPd4caPRYiS8Gcw7Ix5zDM6gb1ksIdUARo7jRwBfyquNo3K+tl314ThsjFgRvjcC13a6PHQmTuVq9ejQ4dOiAuLg7r16/H1atXsWzZMowaNQrR0dHo0KEDoqOjMWrUKCxbtgxXr17F+vXrERsbiw4dOmD16tVyvwSbx6lwZKsUCgktyvrVX0/ORHFJaaPH4BvsjQ92v4Xbe98GACgpKsGcwR/gh4+ZcxDdijmH5WPOYZh1vqryKfgiE1DLUzhG08t+FQJd7taEglL8kzINFzI/Z19ZojLz5s3D2LFjMWzYMJw8eRLDhw+Hg4NDtcc4ODhg+PDhOHXqFIYNG4axY8di3rx5jRQxEZG+8in4aiFw5UaGLDG4erhg7s//Re9n7gEACCHwyUtrser1r6BWs80uEcCcg6ybdQ/qAVmm4GvDUDjjjsBFaOH+hHbb6fTFOJW2EEJY6+QPotpZvXo1pk+fjjlz5mDVqlVwd3evct958+ZBkiS0b99eu83d3R2rVq3C22+/jenTp2PNmjWNETYZoBIKo29ElkrOdfW67B3s8eq6CRg27XHttm/e+xELR7CXPRFzDuvBnMMwq3xVehXwVY1XAd8QhWSHjn4zEO49XrvtUvbX+DvldfayJ5sVHx+PyZMnY8yYMZg+fXq1+167dg3z58+Hq6urwd9Pnz4dY8aMwaRJk7jeTSYCEtRG3ISVtpch2xAaUtGrPkHmtnKSJOHZecPx0idjoFBoPlc71+/Bmw8vQF5WnqyxEcmFOYd1Yc5hmFUO6uWsgG+IJElo5/0cOvnP1ullvwMHksahWJUlc3REjW/8+PHw8/PDokWLatz3lVdeQffu3dG1a1eDv5ckCR988AF8fX0xfvx4g/sQETUU3Sv1CTJeqdfVf1wfzNryqraX/bGdJzHlHvayJ9vEnINsgZUO6uXpVV+TFu4DEB20FErJGQCQVngUexJHIb/0hsyRETWe2NhYbNu2DfPnz692+hsA/PXXX9i8eTOWLFlS7X4eHh5YsGABtm3bhri4OBNGS7XBqXBky5oEesFOqXkPJ8hQAb8qPR/rhvd2zoKHr+bv7KUTlzW97GOvyhwZUeNhzmF9mHMYZpWvSlL4AJKmV7w5DeoBINDlLtwZshqOSs10vdySS9hz/RlkFZ2VOTKixrFixQoEBARg0KBB1e6nUqnw4osvYsyYMejQoUONjztw4EAEBARg+fLlpgqVakktJKNvRJbKTqlA82BNznH5RjpKVeZTmC6yRzss2TsHQaEVvewn3zUDJ/dwIEK2gTmH9WHOYZhVDuoBVEzBV6dAqLPljeUW3o5R6BXyBVztmwPQ7WXPvrJk/bZv346BAwfWWHF2xYoVuHz5MubMmVOrx3V0dMTAgQOxY8cOU4RJdaCCwugbkSUrn4JfqlLjenKmvMHcolk7TS/7NreHAQByM/Pw+oNz8NfmAzJHRtTwmHNYH+YchlnnqwLMdgp+OVf7pugV8hm8HTVnA0tFHg7cmICrOb/KHBlRw8nJycHZs2fRrVu3avdLS0vDzJkzMWPGDPj7+9f68bt27YozZ84gNzfX2FCJiGpNv1ieeayr1+UT5I33d72Frn06AtD0sp87ZDG+//A3mSMjajjMOciWWO2gXjKTtnbVcVT6oGfwSgS53AtA08v+6M03cT5zHXvZk1W6ePEihBCIjIysdr/p06fDx8cHL774Yp0ePyoqCkIIXLhgnp95a8WpcGTrQvXa2pnPunpdLu7OmPPTf9F7REUv+2WT12HVa1+ylz1ZJeYc1ok5h2F2cgfQYHSu1IvSC2bbvMBO4Yxuge/jZOo7SMjZDACITV+KgtIUdPB9BZKklDlCItMpKtK0cXRxcalyn/Pnz2PlypVYsmQJEhMTtdsLCwtRUlKChIQEeHh4wMfHp9Kxzs7Oes9DjUMNBdRGnCM25lgic2AuveprYmdvh1fXTkBAUz+sn7cFAPDN+z/h5vU0vLJ2Ahwc7WWOkMh0mHNYJ+YchlnnqwLMfvq9LoVkh9v83kS49wTttvjsr3Ek+TWo1IUyRkZkWo6OjgCA/Pz8Kve5fv061Go1XnrpJYSFhWlvhw4dwrlz5xAWFoa3337b4LEFBQV6z0NE1BiaB3tDIWkuH5hLW7uqSJKEkXOGYtLy57S97Hd9vQ9vPjSPvezJqjDnIFtivVfqFYGA5AaIXLMf1APlvezHwtkuAMdvzoFAKW7k78T+G2mIDloKB6Wn3CESGa1169aQJAmxsbGIjo42uE/79u3x/fffV9o+ffp05OTkYOnSpWjVqpWBI4HTp09DkiS0bt3a4O+pYaiEBJUR09mMOZbIHDjY26FJoBeuJmUgITEdarXQDpjN1SPP94ZPsBfmD1uCooJiHN91Gi/fPRPzf3sDfjozD4gsFXMO68ScwzCrHdRLkgRh1xooOQ6or0Oo8yApXOUOq0bN3R+Dk9Ifh5OnQiUKkF50HHsSR6JH0CdwsQ+ROzwio7i5uaFdu3Y4cuQIRo0aZXAfPz8/DBgwoNL28r6xhn5X7u+//0Z4eDjc3NxMEC3VlrFr1Kx1fRvZlrAmPrialIGi4lIkpWYjJMD8T8b3fLQbFu6chZmPvoOs1BzEn7yCl3q8iflb30RoVDO5wyMyCnMO68ScwzDrnX4P6E/BV8XLF0cdBbj0xF0ha+Co1Jwpzy2Jx1+JzyCr6IzMkREZr3fv3tiyZQuKi4tN+rhFRUXYsmULYmJiTPq4ZL4++eQThIaGwsnJCdHR0Th8+HCtjtu4cSMkSao2WSOqq9CQiqvb5lgBvyqR3dtiyb55CG4ZCAC4eS0NL/eagX//PC1zZETGY85BpmLuOYdVD+otoQJ+VbwcI8t62bcAABSpUrE3cTRS8tlXlizbCy+8gJSUFGzevLlOx+3evRunTp2q8vdbtmxBSkoKxo0bZ2yIVEdCKKA24iZE3b+KNm3ahClTpmDWrFk4evQoOnbsiD59+iAlJaXa4xISEvDKK6+gV69e9X25RAZZSrE8Q5q2CcbSfXPRpktLAJpe9tP6zMWf3+yXOTIi4zDnsD7MOQyz6kH9rRXwLY2rfZOyXva3AdD0sj+Y9CKu5vwic2RE9RcZGYm+ffti2htvICcnxySPmZ2djWnTpqFv376IiIgwyWNS7akgGX2rq0WLFmHs2LEYNWoUIiMjsWLFCri4uGDt2rVVx6lS4amnnsJbb72Fli1bGvOSiSoJa2q5g3oA8A70wge7ZqNbv84AgJLiUswbtgTfLflV5siI6q8853iDOYfVYM5hmHUP6pWWUwG/Ko5Kb/QM/vSWXvbTcS5zLXvZk8Ua+MorSExOwssvv2z0YwkhMHXqVKSlpWHZsmUmiI7kkp2drXerqk1QcXEx/vnnH71pjwqFAjExMThwoOrZTG+//TYCAgIwevRok8dO1CK4ouVVgpn2qq+Js5sz3v7hNfQZeR8Azd/X5VM+w4qpn7OXPVmsTxaPQmrqdeYcpMfacg4rH9Q3AeCk+dlCB/WAppf9HYEfINRjsHZbXPqHOJG2AEKoZIyMqG6EEFhx5DDmn/gXXo8+ijVr1mDu3LlGPd7cuXOxevVqLF26FGFhYSaMlmpLLSoK19TvpnmcZs2awdPTU3tbsGCBwedLTU2FSqVCYGCg3vbAwEAkJSUZPGbv3r1Ys2YNVq1aZdLXTlTO2ckeQX4eADRX6i31xLudvR2mrhmHp2cM0m7bsvgXLHhqKYqLSmSMjKjuRP5mhHrNwqK3fJhzWAnmHIZZbfV7AJAkBYRdK6D0NKC6AiGKIUkOcodVL5KkxG2+b8BZGYS4jI8AAAnZ36Cw9Ca6BiyAUuEkc4RE1StVqzF71/+w4cQJAIB79+4Id3bBjBkzcPnyZSxatAju7u61frzs7GxMnToVq1evxrx583j1VUbl69SMOR4Arl69Cg8PD+12U/X+zcnJwX/+8x+sWrUKfn5+JnlMIkPCmvgiKTUbeQXFSM3Mg7+3ZVbFliQJI94aAv+mvlg6biXUaoHdm/YjIzkLs797FW5e5t9NiGybEAIidwmQtxwAMOYpT6RktGDOYQWYcxhm3VfqAZ119Wqg1HIq4BsiSRLaeo9GZ/85kMrOxyTl78L+G8+jWJUpb3BE1cgrLsZzP/2oHdADwJSePfHXunVYtWoVvv76a7Rv3x4bNmyosUJtUVERNmzYgA4dOuDrr7/G6tWr8cYbbzT0S6BqqCEZfQMADw8PvVtVX7B+fn5QKpVITk7W256cnIygoKBK+1+8eBEJCQno378/7OzsYGdnhy+++AI//fQT7OzscPGi5c7kIvMSGlIxBd8S19Xf6qGxMXjrh9fh5KL5LP67+zRevnsGUq6myhwZUdWEKIbIelU7oAcAuDyDN+ccYM5hBZhzGGb1g3pJt62dBRbLM6S5e390D/oQSskFAJBe9C/2JI5EXsl1mSMjqiw5NxdDv/0Gu+M1J9XsFQos6tsXE6O7Q5IkjBkzBidPnkRkZCSeeuopNGvWDOPHj8fatWtx6NAhnDhxAocOHcLatWsxfvx4NG/eHE899RQiIyNx8uRJni23QQ4ODujSpQt27typ3aZWq7Fz50706NGj0v7h4eE4efIkjh8/rr09+uijuO+++3D8+HE0a8Z+3GQaesXyrln+oB4Auj/SBe/9bxY8/TRXNRNOXcWknm8i/uRlmSMjqkyosyAyRgOFP5VtkSC5vwmFx3RIkpI5B9WZpeQcVj39HsAtFfAv1qPeoXnS9LJfi4NJE1GkSkVuSQL2JD6D7kEfw8uRlTjJPJxNTcWzP3yPG2UVZ90dHbGif3/0aNZcb7+wsDBs3boVsbGxWLFiBXbs2IEVK1bor0mVJDg3CcSgAY9i2uQprDhrRlRCgkrU/69rfY6dMmUKRowYga5du+KOO+7AkiVLkJeXh1GjRgEAnnnmGTRp0gQLFiyAk5MT2rdvr3e8l5cXAFTaTmQM3Sv1CYmWWSzPkPA72mDp/nl4o988JF5MRur1dLx890y89f1r6HhvlNzhEQEAROk1iIyxgKr8SqgjJK8PIDk9qLdfrXIOSPCw98LDj/TDjHnTmXOYEeYchtnAoF6nV73KuqZYejmG4+6Qz3EgaQJySxJQpErD3sTRuCPwfQS49JQ7PLJx+69cwQs//4TcsqltTTw8sHbA42jj61vlMZGRkfjwww8BALm5ubhw4QKKiorw47U4bMiKh8LJEY92fwQRLfnlak5Mtb6tLoYMGYKbN29i5syZSEpKQqdOnbBt2zZtIZsrV65AobD6yWhkZkJ1etUnWMH0e11NWgdjyb55mNF/Ac4euYi8rHxM6zsXr342EfcNvVPu8MjGiZKTEBnPA+qypSEKH0hen0Jy6FjlMVXlHH9vO4HNs3+DXakdHr1jEAf0ZoY5h2GSsNTyrLUkRClEckcAJYBdGyj8rK/farEqE4eSJiG96F8AgAQ7dPKfhebu/WWOjGzVd7GxmLb9D5SUtUBqHxCINQMGwN+1fsWVDiZfxvCd6wEAw1p3xrw7+pksVqq/7OxseHp6YujOp+HgVv8ipMW5xdj4wFfIysrSK1pDZIkembACqZl58HJ3xrYV4+UOx+QK8goxd8giHP7tmHbb8+8/g0FTmHOQPEThLoisyYAo0GxQhkHyXgXJrnm1x1Xlctw1jInStL+7c0A3zP7uNRNFSsZgzlE9q7+MIUl2gF2o5k5pAoQolTWehuCg9ELP4E8R7HI/AE0v+2M3Z+BcxmqLbalDlkkIgQ8PHsArv2/TDujvD2uJrwcPrveAHgA6+ARDIWmmSx1PZe0Ic6OGMa1lKorWEFmD8qv1mTkFyMjOlzka03N2dcLbP7yOfqMf0G779JUvsPzlz9jLnhqdyF8PkTmuYkBv3wWS78Z6D+gBoFm7ELh6aupWxR08z1zazDDnMMzqB/UAdKbglwCqK7KG0lCUCid0C3wPYR5DtNviMj7GidT57GVPjaJYpcJrf/yBJQcOaLc93bEjVjz6KFwdjGsl6WrvgLae/gCAs1k3kV9afbVaalzCyCq0wkq/YMk2hTbRWVd/3XrW1etS2inx8srn8cysJ7Xbvlv6K+YNW4LiQv59poYnhBrq7Hchst8CUHYyyekhSD6fQVJ4G/XYCoUC7e7QjB3SkzJxk90ezApzDsNsY1CvtL4K+IZIkhIdfP+LSJ9J2m0JOd/icPJUlKoLZIyMrF12URFG//A9tsSe1m6b1utuvHXf/bAz0RqjTr4hAAC1EDiZdsMkj0lEZGphOuvqraGtXVUkScJ/Zg3GlFUvQKHU/J3/69sD+G/fucjJyJU5OrJmQhRCZE4G8tdUbHQdC8lzESTJNL3GI+5oo/057uB5kzwmUUOyiUG9fls76yqWdytJktDGaxRu95+n08t+N/bfeB5FqgyZoyNrlJiTgyc3bcS+K5pZMA5KJT5++BGM7doVkmS6s6Gd/Jpofz6elmiyxyXjGTUNruxGZC1CQ3SK5SVa76C+XL/RD+DtHyt62Z/8Kw4v92Ive2oYQp0OkT4SKNpWtkUByeNtKNxfhSSZblgT0V1nUH+Ig3pzwpzDMJsY1OtWwBdWPqgv18z9YXQP+hh2kmYdc0bRCexJHIG8kmsyR0bW5HRKCp74egPOpWkSV28nJ3w1cBAeatvW5M9VfqUeAI5xXb1ZKa9Ea8yNyFrYypV6XdEP3Y73d82Gl7+m6NTl2Gt4qccbuHSCvezJdETpZYi0IUDJUc0GyQWS9wpILkNN/lzl0+8BDurNDXMOw6zzVd3KLgzal2rF0+9vFeDSHXeFrIGjUrMWOa/kCvYkPoPMoliZIyNrsDs+HkO/2YSUvDwAQAtPT2weOgxdmzSp4cj6ae3pBzd7zZWg42mJLFxDRGbJ28MZnm5OAKx3Tb0h7bq1xtL98xDSOggAkJaYgZfvnoFj/zspc2RkDUTxUYi0wYCq7ESRIgCSz3pIjvc2yPN5+XsipJWmXdmFo5dQUlzSIM9DZCo2MaiXJAdAWVYFs/QShLCd6qyeZb3s3ezDAABFqnTsTRyN5Px9MkdGluzrEycw9scfkFei+ZK7PTgYm4cOQ5i3ccVpqqOQJNzmEwwASCnIxY38nAZ7LqobToUjqiBJkrYC/s2MXOTmF8kcUeMJaRWEpfvmIrzsKmd+dgHe6DcP//t6r8yRkSUThdsg0p8BRKZmg10bSL7fQLKPatDnDY/WTMEvLizBpRPWWWjbEjHnMMwmBvUAAO26+kJAZVtTd13sQ9Ar5DP4OHUGAKhEAQ4lvYQrOT/KHBlZGrUQWLh3D97cuQOqsivlfVu3wVeDBsHXxaXBn7+zX8UU/ONptvU5NmfGVKEtvxFZE90p+Ak2MgW/nJe/JxbunIXuj3QBAJSWqLDgqaX49v2fOMOK6kQIAZG3BiJzEoCyrgoOPSD5bISkDKn2WFOIiK5YSniGU/DNBnMOw2xoUF+xNgYq21hXr8tB6YmeQSsQ7BoDABBQ4djNWTibsYpfslQrRaWlmLz1N6w4ckS7bUyXLvj4kUfgZGffKDF08tUplpfKYnnmgmfNifTpDeoTbWcKfjlnVyfM/u5VPDSmopf9yte+xLLJ66BSsc0u1UwIFUTO2xA57wIoy1OdHofkvQqSwr1RYtAvlneuUZ6TasacwzCbGdTbUgX8qigVjugW8C7CPIZpt53J+AT/ps6FWpTKGBmZu8zCAjzz3Rb8cvYsAM1U+Nn33Y837r4HChNWuK9JR16pJyILEBpS0aveVorl3Uppp8TkT5/HiLeGaLf98NFWzBu6mL3sqVpCnQ+ROQHIX6/dJrm9CMnzHc2S2kbSsmML2DtqLlqcOWQ7NbnIMtnMoF6/Ar7tfjA1vexfQ6TPZO22yzlbcIS97KkKVzIzMWjjRhy5rhlEO9vZ4dP+j+KZTp0aPRY/J1c0c/UCAJxMT0KJmld8zAHPmhPps8UK+IZIkoSnZwzC1DXjtb3s92w5hP/2mYvsdNZFocqE6iZE+tNA0f/KtthpBvNuL5q0TW5t2DvYo83tmppU18/fQHYa37PmgDmHYbYzqFe2rPjZRq/Ul9P0sh+JLgHzdXrZ/4n9N55Dkcr2pglS1f5NuoGBG7/GpYwMAICfiwu+HvwkHmjVqoYjG06nsqv1RapSnM28KVscVIFfsET6/H3c4OKkuaJoSxXwq9J31H2Y89N/4eRa1st+j6aXffJl/g2nCqL0AkTak0DpKc0GyQ2S92pIzk/IFlP4HRVT8M8ctt2LguaEOYdhNjOolxQugKJsPW7pBa4jB9DU7SH0CF4GO8kNAJBRdBJ7ro9AXslVmSMjc/DHhQsY9u23SCvQzOBo5eOD74YOw21BQbLG1dmvYl09+9UTkTnSVMDXTMG/kZqFgkK2w7qjX2e8v+steAV4AgCuxF3HSz3fxMV/E+QNjMyCKDoEkTYUUJd9ryuCNQXxHHvKGpfeuvqDXFdP5stmBvUAKirgi1xAnSxvLGbC3/kO3BWyFk7lvexLr2JP4ghkFJ6SOTKS07qjRzHu559QWKqptRDdtCk2DxmKpp6eMkcGdPKtWFf/bxqL5ZkDnjUnqqx8Cr4QwOUbvFoPAO26tsKH++ehSRtNe9L0GxmYcvdMHN3JXva2TBT8CJHxLCCyNRvsIspa1rWt/sBGUN7WDgDOHGYFfHPAnMMw2xzUAzY/BV+Xp2Nb9GryBdztNUsUilTp2HdjDJLz98gcGTU2lVqNt3fvwpw/d5fXmsWj4eH47PEn4OnkJGts5SK8A+GgUALglXpzIWBcixnOmyJrpFsszxYr4FcluGWgppd92WApP6cAbz40DzvXM+ewNUIIiNxlEFmvAiibzeJwNySf9ZCUgbLGVi6whT+8AzUXNM4cugC1Wi1zRMScwzCbGtRLum3tOKjX42IXjLtCPoOv0+0AAJUoxKGkybic/YO8gVGjKSgpwYRff8Fnx45pt024IxqL+/aDo52djJHpc1TaIdJb82Ufn5OOzCIWeCQi88NieVXz9PPAeztnocejXQFoetm/858PsfHdH7g80kYIUQKR/SZE7pKKjc5DIXmvgKRwky2uW0mSpD0BlZuZh+vnb8gcEZFhNjWoZwX86jkoPdAjaDlCdHrZH0+djbMZn/JL1sql5ufjqc3f4o8Lms+FUpKwIKY3pt55Z6NXm62NTjrr6jkFX36cCkdUWVhTnV71HNRX4uTiiFmbX8Ejz/fWblszbT0+eWkte9lbOaHOhch4HijYrN0mub0CyeMtSJL5XEQoFxFdsQwg7iCn4MuNOYdhNjao5/T7migVjugasBAtPYZrt53JWI5/U+eAveyt06WMDAza+DWOJyUBAFzt7bFmwOMY0qGDzJFVTXdd/XEO6mXHL1iiyoL8POBorxmgcFBvmNJOiZeWjcWoucO02378ZBvmPLkIRQVFMkZGDUWokiDShwHFe8u22EPyXATJ7TmzvIgAAOHRFRcFzxzioF5uzDkMs6lBvaTwABQBmju8Ul8lSVKgg99riPKZqt12Oec7HE5+mb3srcyR69cxaOPXuJKVBQAIcnPDN0OG4u7QUHkDq4FuBfzjXFdPRGZIqVCgRYg3AOBaciaKS3hi3BBJkjD8jSfwytrxUNpp6qXs+/4wXn9wDvuCWxlRcgYibTBQelazQfKE5PMZJOdH5A2sBu26tdaecIjjoJ7MlE0N6gHoVMDPgFCzcE11Wnv9B10C3tH2sk/O34N9N8awl72V+OXsWfxny2ZkFhYCAML9/LBl6DBE+PvLHFnNmrp6wtfRBYDmSj2Xh8iLZ82JDAstW1evUgtcTcqUNxgz12fkfZjz83/h7KYpynp631lMvms6khJSZI6MTEEU7dVcoS/vPqVsCsl3EySHbvIGVgsu7s5oEdUUAHDpxGUU5nMWiZyYcxhmu4N6gFPwa6GpW1/0CF6u7WWfWXQae66PQG7JFZkjo/oSQmDFkcN46bdfUVy2bvGu5i2w6ckhCHZ3lzm62pEkSbuuPqu4EPE5PNEkJ37BEhkWGqKzrj6RU/Br0q1PJ3yw+y1ttfGrZxMxqeebuHA8XubIyBgifzNExlhA5Gk22N8GyedbSHYt5Q2sDsrX1atVapz/55LM0dg25hyG2dygXr8CPqfg14a/czf0arIOTkrN0oW80qvYc30EMgrZV9bSlKrVmPG/nVi4d6922+CoKKwZMADujo4yRlZ37FdvPoSQjL4RWSPdYnnx1zior402t7fE0v3z0LRtWS/7pExMvWcW/tn+r8yRUV0JIaDOWQyR/QaAsuKHjjGQfL6EpPSt9lhzo9uvPu7gORkjIeYchtncoF6/Aj6v1NeWh0Mb3N3kC7jba2Y6FKszsO/GWCTl/yVzZFRbecXFeO6nH7HhxAnttik9e+Kd3g/CXqmUMbL66eRXMahnv3oiMkdhTdirvj6CwwKxZO9cRPbQXB3NzynAmw8vwPYv/5Q5MqotIYo1/efzlldsdBkByesjSJKzfIHVU0T3ikH9mcNcV0/mx/YG9Urd6fe8Ul8XznZB6BWyDr5OXQBoetkfTnoZl7O/kzkyqklybi6GfvsNdsdrpjDaKxRY1LcvJkZ3N9tqszW5zTcE5ZGzAr681JCMvhFZo6YBXlAqNakWe9XXjaefBxbumIk7B2jWXKtKVVg44mN8veB71lExc0KdBZExGij8qWyLBMn9TSg83oQkWd5FBABoHtFEW++Bbe3kxZzDMNsb1Ct8AMlL8zMH9XVmr/RAj+DlCHF9EEB5L/u3cSZ9Ob9kzdTZ1FQ8sfFrnE7RFBvycHTE508MxICISJkjM467vSPaePoBAM5kpKCgtETmiGwX17cRGWZnp0TzIE0F/Cs3MlCqUssckWVxdHbEjG+nov+4Ptpta9/cgI8mrmEvezMlSq9BpA0Fig+VbXGC5PUxJNcRssZlLKVSiXZ3aGb7pl5Px00up5ENcw7DbG5QL0lSRbE8dQqEmu1S6kopOaBrwDto5fkf7bazmZ/ieOpbUAsOrMzJvitXMHjTRtzI0bzPm3h44NshQ9G9WTOZIzONjr6aYnmlQo1T6UkyR0NEVFloiGYKfkmpCok3s2SOxvIolUq8+PFojJ4/XLvt5+W/Y87gD9jL3syIkpMQ6U8CqrLlrQofzfp5p97yBmYi4XfoTMFnazsyMzY3qAegt66eFfDrR5IUaO87Fe11etlfyfkBh5Imo1SdL2NkVG7L6dMY9f13yC0uBgC0DwjEd0OHoY2vZRWnqU5nPxbLMwcsWkNUNd1ieQm8ulcvkiRh6H8fx2ufT6zoZf/DEbwW8zZ72ZsJUfg/iPSnAXWqZoMyDJLPN5AcOsobmAnpravnoF42zDkMs8lBPSvgm04rr/+ga8C7UMAeAJBSsA/7boxBYSkTF7kIIbD0wAG8+sfvKFVrpno+0LIlNj75JPxdXWWOzrTKr9QDLJYnJ06FI6paWBOdCvhcV2+U3v+5B/N+naZd2xx74Bwm3zUdN+KTZY7Mtom8ryAyxwOiQLPBvqumB71dc3kDM7EI3Qr4HNTLhjmHYTY5qNftVc8K+MZr4tYHPYKXwU5R3ss+FnsSRyC35LLMkdmeYpUKr/3xB5YePKDd9p+OHbGi/6NwsbeXMbKG0dbTDy52mtfFYnlEZI7Kp98DrIBvCl16d8SiP9+GT5AXgIpe9uePsnd4YxNCDXX2OxA5bwMoqxfh9DAkn3WQFF5yhtYgvAO9EBTqDwA49/dFqEpZ14HMh40O6nWu1Kt4pd4U/Jy7oVfIZ3BSBgIA8kuvYc/1kUhnL/tGk11UhGe//x5bYk9rt71x992Yfd/9UCqs86OuVChwm4+ml/GN/Gwk53Maphw4FY6oas2CvaEo6zLCK/Wm0bpzGJbun4dm4ZrZWhnJWZh67ywc+f24vIHZECEKITInA/lrKza6PgfJ8wNIkqNscTW08O6aNotFBcWIP3lF5mhsE3MOw6wz06+JIhCQyqYh80q9yXg4tC7rZa85aVKszsD+G2ORlMde9g3tenY2nty0Efuvar5gHJRKfPzwIxjTpavFtqyrrU5+FVPwebVeHsLIaXDW+gVLBABODvYICfAEACQkpkGtZqcYUwgKDcCSvXMQdWc7AEBBbiFm9H8Hf3y+W97AbIBQp0OkjwCKtpVtUULyeBsK91cgSdY9tIi4g1Pw5cacwzDr/uRVQa8Cvuo6BAu7mYyzXSB6hayFn1NXAJpe9oeSJyMhe7PMkVmv0ykpGLjxa5xL01wB8nZywvpBg/FQ27YyR9Y4OvlWFMvjunoiMkehTTRT8AuLSpHMwm4m4+Hjjnf/mIE7H78DgKaX/XujPsGG+d+xzW4DEaUJEGlDgJJjmg2SCyTvFZBchsobWCMJ7647qD8nYyRE+mxyUA9AZwq+AFTxsoZibeyVHugevAxNXPuWbVHj39S5iEtfxi9ZE9sVfwlDvtmElLw8AEALLy9sHjoMXUJCajjSeuheqWcFfHkIAEIYcZP7BRA1MBbLaziOzo6Y8c0UPDahr3bbuulf48Pxq7jm2cRE8VGItCcBVVnNJEUAJJ8NkBzvkTewRtS6Uyjs7DUdGM4c4hJeOTDnMMxmB/WsgN+wlJIDugTMR2vPZ7TbzmWuxPGbs9nL3kQ2nDiB5378Efklmn/P24ODsWXoMIR5e8scWeMKcHZDiIsHAOBE2g1txX9qPGpIRt+IrBkH9Q1LqVRiwofPYsw7T2u3/fLpdrw16H0U5rOXvSmIwq0Q6c8AIlOzwa4tJN9vINlHyhpXY3NwckDrzmEAgKtnriMnI1fmiGwPcw7DbHZQDyUr4Dc0SVIgyncK2vu+CpR9gK7k/she9kZSC4GFe/dg+s4dUJXNfOjXpg2+GjQIPs7OMkcnj85lV+sLVCU4n3VT5mhsD4vWEFUvNESnV30iB/UNQZIkDHntMfz3y5e0V1IP/PQ3Xot5C1mp2TJHZ7mEEBB5ayAyJwEo1mx06AnJ52tIStuZFagrXGdd/dkjHEM0NuYchtnuoF6nrR2v1DesVp5PoVvAQigkBwCaXvZ7E0ejsDRV5sgsT1FpKSZv/Q0rjhzRbhvbpQs+evgRONlZX8u62urIdfVEZMZa6La145X6BvXAU70w77c34eKuOckdd/A8Jt05HTcusZd9XQmhgsh5GyLn3YqNzk9A8l4JSeEuX2Ayi9BdV3+Q6+rJPNjuoF7ZBICT5mdeqW9wIW690SNoOezLvgSyiuM0veyL2cu+tjILC/DMd1vwy9mzAACFJGH2ffdj2t33aNsl2arOrIAvK2Oq0JbfiKyZq7MDgnw1338J19NZX6aB3f5AByz66234BGuWo10/fwMv9XwT5/5hvldbQp0PkTkByF+v3Sa5vQTJYwGksos0tio8umJQf+YwK+A3NuYchtnsoF6SlICdZk0MVFcgRLG8AdkAP+cuuCtkHZyVQQCA/NLr2JM4AumFJ2SOzPxdyczEoI0bceS65iq0s50dPu3/KJ7p1EnewMxElHcg7BWaP2fHeaW+0RlVsKbsVh+ffPIJQkND4eTkhOjoaBw+fLjKfVetWoVevXrB29sb3t7eiImJqXZ/IlMLLVtXn5NfhLTMPJmjsX6tOobiw/3z0DxCc9I3M6Wsl/22YzJHZv6E6iZE+tNA0f/KtthB8nwHkttEq2+TWxvBLQPh6ac5SXfm0AWepGtkzDkMs9lBPQCdCvgqoDRBzkhshodDa/Rq8jk8HDTt1orVmdh/4zncyNstb2Bm7N+kGxi48WtcysgAAPi5uODrwU/igVatajjSdjjZ2SPcKxAAcCE7DdnFhTJHRA1t06ZNmDJlCmbNmoWjR4+iY8eO6NOnD1JSUgzuv3v3bgwbNgy7du3CgQMH0KxZMzz44IO4fp0ngahxhLJYXqMLbOGPxXvmoP1d4QCAwrwiTO//Drat2yVzZOZLlF7QVLgvPaXZILlB8l4NyfkJeQMzI5Ikaa/WZ6flIPFikswRUUOzhJzDpgf1ku66ehWnZDUWZ7tA3BWyBn5OZX1lRSEOJ09BfPa3Mkdmfv64cAHDvv0WaQUFAIDWPj74bugw3BYUJHNk5qezX8W6+n/TbsgYie2Ro2jNokWLMHbsWIwaNQqRkZFYsWIFXFxcsHbtWoP7r1+/HuPHj0enTp0QHh6O1atXQ61WY+fOnca+fKJaCdVdV5+YLmMktqW8l32vgdEAALVKjQ9GL8NXczbzCustRNEhiLShgLps4KEIhuSzEZJjT3kDM0MR0W21P8cd5BT8xsScwzCbHtSzWJ587BXu6BH8CZq69SvbosaJ1HmIS/+YX7Jl1h09inE//4TC0lIAQHTTpvh2yFA09fSUOTLz1MlXt189r742JlN9wWZnZ+vdiooMt6IqLi7GP//8g5iYGO02hUKBmJgYHDhwoFYx5+fno6SkBD4+PjXvTGQCbGsnHwcnB7y58WUMeLGfdtvnszZhyfOfspd9GVHwI0TGs4Ao6xRgF1nWsq5t9QfaqPDoitbYLJbXuJhzGGbjg/qKD6TgoL7RKSR73O4/D609R2q3nctcjWM3Z9p0L3uVWo23d+/CnD93o/z0xmPh4fjs8Sfg6eQka2zmrJOfbgV8FsuzRM2aNYOnp6f2tmDBAoP7paamQqVSITAwUG97YGAgkpJqNw3y9ddfR0hIiN6XNFFDCm1SkcxxUN/4lEolxi8ZhecW/ke77bfVOzH7ifdQkGe7S7aEEBC5yyCyXgVQlns53gPJZz0kZWC1x9qy8Dtaa+sLnDnMMYQlsracw67BHtkSKJtD809QCpRekjsam6TpZT8ZznaBOJm2EIDA1dyfUahKRbfA92GvcJU7xEZVUFKCl7dtxR8XKr4gJkZH4+UePVmcpgYt3Lzh7eiMjKIC/Jt2HUII/ps1ErWQIBlRTba8Eu3Vq1fh4eGh3e7o6Gh0bIa888472LhxI3bv3g0nniijRuLp5gwfTxekZ+Uj4Tqn38tBkiQMfuVR+IZ4471Rn6C0RIWDv/yD1x54C3N+/i+8/G1rJpwQJRDZs4CCzRUbnYdC8pgJSbLtIUJNXD1d0Sw8BFfiruPi8QQUFRTB0blhvrNIH3MOw2z6Sr0k2QN2oZo7pZcgRKms8diylp7D0C3gPW0v+5sFB7DPxnrZp+bn46nN32oH9EpJwoLevTGl550cnNaCJEnafvXpRQW4kpspb0A2xFSVaD08PPRuVX3B+vn5QalUIjlZv+90cnIygmqoN/H+++/jnXfewR9//IHbbrvNJK+fqLbKp+BnZOcjMydf5mhs1/3De2H+1jfh4qHpZX/m8AVMunO6TRU8E+pciIzn9Qb0kturkDze4oC+lsrX1atKVbhwLEHeYGwIcw7DbHpQDwBQlk/BLwFUV2UNxdaFuMWgZ/CnsFdozpplFZ/BnsRnkFOcIG9gjeBSejoGbfwax8um8bg5OGDt449jSPsOMkdmWTr5VkzBZ7966+Xg4IAuXbroFZwpL0DTo0ePKo9buHAh5syZg23btqFr166NESqRHt119bxaL6/O93fA4r/mwDdE08s+8UISJvV8E2ePWP9UaqFKgkgfBhTvLdtiD8lzMSS3sbyIUAe6/eq5rt56WUrOwUG9XrE8VsCXm69TZ/QK+QzOdsEAgPzSxLJe9sflDawBHb52DYM2bcSVrCwAQJCbGzY9OQS9WoTKG5gF6uxXUSyP/eobj+bMtzFFa+r+nFOmTMGqVavw+eefIy4uDuPGjUNeXh5GjRoFAHjmmWcwbdo07f7vvvsuZsyYgbVr1yI0NBRJSUlISkpCbm6uqf4ZiGrECvjmpeVtLfDh/nloEdkUAJB5Mxuv3Dcbh347KnNkDUeUxEGkDQZKz2o2SF6QfD6H5PywvIFZoIjuFYP6M4dZAb+xMOcwzOYH9RIr4Jsdd4eW6BVS0cu+RJ2FfTeex428/8kcmen9cvYsnvluCzILNUV6wv38sGXoMET4+8scmWXqyCv1spCjvcyQIUPw/vvvY+bMmejUqROOHz+Obdu2aQvZXLlyBTduVLQ2XL58OYqLizFo0CAEBwdrb++//77J/h2IasIK+OYnoLmml32HuyMAAIX5RZj52LvYusb62l2Koj0Q6cMBddk0YmUzSL4bITlw5lJ9hEY1g5OLZso229o1HuYchnHRzC0V8DnpyDw42wXgrpC1OJw8FakFh6AWRTic/Apu830dYZ5D5A7PaEIIfPr3ESzcu1e7rVeLFvj44Ufg3kCFOmyBh4MTWnn44mJ2GmIzklCkKoWjkn/mGpoouxlzfH1MnDgREydONPi73bt3691PSEio57MQmU5oU51B/TUO6s2Fu7cb3tk2He+O+Bh/fXsAapUai8auQOq1dDw9c5BVTEkX+d9CZM8EUNbCz74jJK8VkJS+1R5HVVPaKdG2Wyuc+DMWKVdSkXYjA77B3nKHZfWYcxhm81fqYRcG7T8DK+CbFXuFG3oEfYymbuVTwtQ4kbYAsekfwpJ72Zeq1Zi+c6fegP7J9u2x+rEBHNCbQPm6+hK1GrEZyTXsTUTUeHw8XODhqql+nJDIQb05cXBywJtfT8YTkyqmoX/x1jdY/Jxl97IXQkCdsxgi+01oB/SOvSH5fMEBvQlE6KyrP3OIV+tJPjY/qJckR0DZTHNHdRFCqOUNiPRoetnPRRuvZ7XbzmeuxdGbMyyyl31ucTHG/vgDvj55Qrttas87sSCmN+yVShkjsx6ddNbVH+O6+kYhx1Q4IkskSZK2X31Kei7y8otkjoh0KRQKjFs8Es+//4x229Y1OzFzwLsW2cteiGKIrFeAvOUVG11GQvL6EJLkLF9gViScg/pGx5zDMJsf1AOomIIvCgD1jer3pUYnSRIifV5CB9//AmULJK7l/oKDSRNRoracIlfJubkY9u03+LNsSo69QoFFffthQnS0VUztMxesgC8DYYIbkY3Qq4B/g8XyzNGgKf3xxobJsHfQLN86/NsxvHr/bGSkZMkbWB0IdRZE+rNA4c9lWyRI7tOh8HgDksSLCKaiVwGfg/rGwZzDIA7qAcCuZcXPLJZntlp6DkW3wA+gkDRT1G8WHMK+xNEoKE2RObKanU1NxRMbv8bpFE2sHo6O+PyJgRgQESFzZNannVcAnMrW0bMCPhGZm9AmXFdvCe4beicWbJsOV08XAMDZIxcx+c43cf2C+V/8EaVXIdKGACWHy7Y4QfL6GJLrM9UeR3XnF+ID/2aaz/TZIxegUlnuUg2ybBzUA5B0iuVxUG/eQlzvR8/gFbBXeAIAsorPYk/iCOQUm289hH1XrmDwpo24kZMDAGjq4YHNQ4aie7NmMkdmnewUCnTw0bREvJaXhZsFljObw2IZOw3OSqfCERnCCviWo+O9UVj819vwK1sykXgxGZPvnG7W7ctEyUmI9CcBVVlepPCF5PMlJKfe8gZmxSK6a7o1FeYV4fLpazJHYwOYcxjEQT2g16tesFe92bu1l31B6Q3sSRyJtMJjMkdW2ZbTpzHq+++QW1wMAOgQGIgtQ4ehtS+L0zQk3X71/3IKfoPT9Iw17kZkK9ir3rKEdWiBDw/MR2h7zYn4zJvZePX+t3Dwl39kjqwyUfg/iPSnAXXZySJlGCSfTZAcOsobmJULv4Pr6hsTcw7DOKgHAKXu9HsO6i2Bu0MY7g75Ap4O7QAAJeps7L/xAhLNpJe9EAJLDxzAq3/8jlK1pvjiAy1b4uvBT8Lf1VXm6Kyfbr/6Y6kc1BOR+Qj0dYeLkz0AIIFX6i2Cf1NfLP5rDm67JxKAppf9rAHv4rdVO2SOrILI+woic7ymPhQA2HeD5LsJkl1zeQOzARHdddbVHzwnYyRkyzioByAp3ABF2SCg9IJFt0uzJU52/rgzZA38nbsDANSiCEeSp+JS1kZZ4ypWqfDaH39g6cED2m3PdOqEFf0fhYu9vYyR2Q7dK/XH07iuvqGxEi1R7UmShNAQzWytxJtZKCy2vE4utsjNyxULtk3HPU/2AACo1QKLn/8Un8/aJGveKIQa6ux3IHLeBlDWwcnpEUg+6yApvGSLy5a0uT0MSjtN8cEzh7mMt6Ex5zCMg/py5VPwRQ6gvilvLFRr9go3dA/6CM3cHinbInAy7R2cTlsCOdoTZhcV4dnvv8eW2NMANLX637j7Hsy69z4oFfy4NZYgF3cEObsDAE6k3YBKzVaVDap8jZoxNyIbUt7WTgjgSmKGzNFQbTk42uONDZMx8OVHtNu+mrMZH4xejtKS0kaPR4hCiMzJQP7aio2uz0PyfB+S5NDo8dgqR2dHtOzYAgBwOfYa8rLzZY7IyjHnMIijjHI66+pZLM+yKCR7dPafgzZeo7XbLmR9hqM3pzdqL/vr2dl4ctNG7L96BQDgqFTi40cewZguXdiyTgad/DSzb/JKi3EhO1XmaIiIKoSyWJ7FUigUeOGDERi3aKT2u/33z3Zh5oCFKMgtaLQ4hDodIn0EULStbIsSksfbULhPhSQxvW9s5evqhRA4e4RLeanx8VNfhhXwLZuml/2LuM3vDZS/ra/l/oYDSRNRos5p8Oc/nZKCgRu/xrk0TXLm4+yM9YMGo1+btg3+3GRYJ1+dKfhcV9+gWLSGqG5YAd/yPTH5Ybz5dUUv+yNbj2HqfbORkZzZ4M8tShPKWtaVFQiWXCF5r4DkMrTBn5sM47r6xsOcwzAO6svpVcA33/ZoVL0wjydxh04v+9SCQ9hbh172ubm5OH78OA4dOoTjx48jN7fmdmi74i9hyDebkJKXBwBo4eWFzUOH4vaQkBqOpIZUfqUeAI6zAn7DEia4EdkQVsC3Dvc82RMLfp8ONy9NAdzz/1zCpDun49q52n3n1CfnEMVHIdKeBFSXNRsUAZB81kNyvKfer4OMFxGtUwHfjFseWgXmHAZxUF+O0++tRrDrfbgzeCUcygrEZBefw57EEcguNjwdKjY2Fi+99BIiIiLg4eGBzp07o3v37ujcuTM8PDwQERGBl156CbGxsZWO3XDiBJ778Ufkl2im+d8eHIwtQ4ch1Mu7wV4f1U4Hn2Aoy6ZGHktlsbyGxKI1RHUTEuAJB3tNYS1eqbdsHe+JwuI9c+DfVDP74salZEy6czpiq7haa0zOIQq3QqQ/A4hMzQa7tpB8v4FkH9lQL49qqUmbYLh7a07unDl4nkW3GxBzDsM4qC8jKbwAhb/mjoqDekvn49QRd4V8Bhc7zdXagtIb2Js4EmkFR7X7xMfHo1+/foiKisKmTZtw3333Yc2aNTh48CBOnDiBgwcPYs2aNbjvvvuwadMmREVFoV+/foiPj4daCLy7Zw+m79wBVdkf7n5t2uCrQYPg4+wsy2smfc529gj3CgAAnM+6idySIpkjIiLSUCoUaBGsuVp/LSkDJaUqmSMiY4RGNcPS/fMQ1kHTPi47LQevPfAWDvz8t3YfY3IOIQRE3hqIzEkAijUP6NATks/XkJScFWgOJElCeNnV+syb2UiKr90MUSJT4aBeV/nVenU6hJrT4Sydu0MoeoV8AU+HCABAiToH+5NeQGLuDqxevRodOnRAXFwc1q9fj6tXr2LZsmUYNWoUoqOj0aFDB0RHR2PUqFFYtmwZrl69ivXr1yM2NhYdOnRA78mT8OnfR7TPNbZLF3z08CNwsmPLOnPSqay1nYCmCj41IE6DI6qT8gr4KrXAtaRMeYMho2l62b+NTvdFAQCKCoox+/GF+OXT7UbnHKs+fgwi592KJ3N+ApL3SkgKd5leLRkSEV1RRynuEKfgNyjmHJVwUK9Lbwo+K1daAyc7P9wZshoBzj0BAGpRjNdm/Qdjx47FsGHDcPLkSQwfPhwODtW3fnFwcMDw4cNx6tQpDB06FP/78CNkbt8BhSThrfvvx7S774GCFe7NTidfrqtvDJwKR1R3LJZnfVw9XTHvtzdx37A7AWh62U9+4WWMHTsWQ4cOrXfO8fxLP2P+Es3FJsntJUgeC9iyzgyFR1cU3WaxvIbDnMMwDup16FfA56DeWtgrXBEdtBTN3Ppj+6Y0rF+UhDlz5mDVqlVwd9ec5T59+jQGDx6Mli1bwsXFBX5+frj77rvx888/6z2Wu7s7Vq9ejbfffhsZW7diQEEh/tOxkwyvimqjs59uBXyuqyci86Hb1i4hkYN6a+HgaI//fvkSnnzlUVwX8biI05gzZw5Wr15tVM4x4900rP2+NyS3iWyTa6ba3VExjjhzmEt5qXFxUK9LqVsBn4N6a6KQ7OGVOwrr5qVi9OjRmD59ut7vL1++jJycHIwYMQJLly7FjBkzAACPPvooVq5cWenxpk+fjtGjR2PFvHmIj49vlNdAdRfq7gMPeycAmiv1LFzTQFiJlqjOwkJ4pd5aKRQKxIy7CwmOsSbNOSa/+jlzDjPm4eOOpm2DAQAXj8WjuKhE5oisFHMOgyTBLFdLqFIhbmqmacPhTih81skbEJlUv379EBcXh5MnT2rPlldHpVKhS5cuKCwsxJkzZyr9Pjs7Gx06dEBkZCS2bt3aECGTCYzctRF/3dC0qfzr0fFo6uYlb0BWJDs7G56enmi2YjYUzk71fhx1QSGuvjAbWVlZ8PDwMGGEROarpFSFe5/9ECqVGq2b++OrBc/IHRKZEHMO27Rw5MfY/sWfAIAPD8zXa3VHxmHOUT1eqdel8AUkT83PvFJvVWJjY7Ft2zbMnz+/Vl+uAKBUKtGsWTNkZmYa/L2HhwcWLFiAbdu2IS4uzoTRkil15Lp6IjJD9nZKNA30AgBcuZEOlVotb0BkMsw5bFf4HRWDeK6rp8bEQb0OSZJ0KuAnQahz5Q2ITGbFihUICAjAoEGDqt0vLy8PqampuHjxIhYvXoytW7figQceqHL/gQMHIiAgAMuXLzd1yGQiuuvq2a++gXAqHFG9lBfLKy5RITElS+ZoyFSYc9iuiO4Vg/ozh1kBv0Ew5zDITu4AzI5da6CkrJd56UXAoaO88ZBJbN++HQMHDqyx4uzUqVPx6aefAtCsiXviiSfw8ccfV7m/o6MjBg4ciB07dpg0XjKdjr7B2p//5ZX6hmHsl6SVfsES1SSsiS92H9Ek/vHX09AsyFvmiMgUmHPYrrAOzeHo7ICigmLEHeSgvkEw5zCIV+pvIbGtndXJycnB2bNn0a1btxr3nTx5MrZv347PP/8c/fr1g0qlQnFxcbXHdO3aFWfOnEFuLmd2mCNvRxeEumv6QZ9KT0KxSiVzREREGqEhPtqfExLTZYyETIU5h22zs7dDmy4tAQBJ8SnI4AwcaiQc1N9Kp62dULEdhTW4ePEihBCIjIyscd/w8HDExMTgmWeewS+//ILc3Fz079+/2qrpUVFREELgwgW+X8xVeb/6YrUKcZnJMkdjhYRk/I3IBun2qk9gBXyrwJyDdIvjnTnEq/Umx5zDIA7qb6XXq55/MK1BUVERAMDFxaXOxw4aNAhHjhzBuXNVFztxdnbWex4yP538dIrlcV29yQlh/I3IFjUP8UZ5y3G2tbMOzDkonIP6BsWcwzAO6m+lCAIkV83PnH5vFRwdHQEA+fn5dT62oKAAAJCVVfX0qfJ9yp+HzE8n34pieayA3wBYtIaoXpwc7BHir+m6k3A9vdortGQZmHNQRPe22p/jOKg3PeYcBnFQfwtNBXzNWhiorkGIAnkDIqO1bt0akiQhNja2yn1SUlIqbSspKcEXX3wBZ2fnaqfRnT59GpIkoXXr1lXuQ/IK9wqAo1JTF/R4Kgf1RGQ+Qsum4BcUlSA5LUfmaMhYzDnIv6kvfEM0RS/PHr4AFWv5UCNg9XtDlK2BkpMABFAaD9jXvC6KzJebmxvatWuHI0eOYNSoUQb3ef7555GdnY27774bTZo0QVJSEtavX48zZ87ggw8+gJubW5WP//fffyM8PLzafUheDkol2nsH4Z/Ua7icm4H0wnz4ONV9aiRVwdg1ala6vo2oNsKa+GLfsUsANFPwg/w8ZI6IjMGcgwDN1fq93x1Cfk4Brp5JRGhUM7lDsh7MOQzilXoDWAHf+vTu3RtbtmypsqrskCFDoFAosHz5cowbNw6LFi1C06ZN8eOPP2LKlClVPm5RURG2bNmCmJiYhgqdTERvXT2n4JuUJIy/EdkqVsC3Psw5KPwOrqtvKMw5DOOg3hDdCvgslmcVXnjhBaSkpGDz5s0Gfz906FBs374dSUlJKCkpQXp6OrZv345HH3202sfdsmULUlJSMG7cuIYIm0yovAI+wGJ5RGQ+wppWVMCPv8ZiedaAOQdFdK8Y1McdrLrwIZGpcFBviF4FfF6ptwaRkZHo27cv3njjDeTkmGbNYnZ2NqZNm4a+ffsiIiLCJI9JDaeTH4vlNRgWrSGqt9AQnbZ2iRzUWwPmHNSmS0solJph1pnDvEBoUsw5DOKg3hBlEwAOmp95pd5qLFu2DKmpqdVObastIQSmTp2KtLQ0LFu2zATRUUMLcfGAv5Oms8XxtESoWWXadNgzlqjeXJ0dEOCjWR/NCvjWgzmHbXN2dUJYh+YAgIRTV5Cfw8LbJsOcwyAO6g2QJKVOBfzLEMLwmiiyLGFhYViyZAlWr16NuXPn1vtxhBCYO3cuVq9ejaVLlyIsLMyEUVJDkSQJncuu1ueWFOFSNq+IEZF5CCurgJ+dV4j0rLq3QiPzw5yDytfVq9UC5/7mzF9qWBzUV0U7BV8FqK7IGgqZzpgxYzB37lzMmDEDY8aMqfO0uOzsbDz33HOYOXMm5s2bh9GjRzdQpNQQOuqsqz/GdfWmw6lwREYpH9QDQMJ1nnC0Fsw5bJvuunoWyzMh5hwGcVBfBf0K+JyCb00mPv8iOrn0wBfrvkBEeAQ2bNhQZYXackVFRdiwYQM6dOiAr7/+GqtXr8Ybb7zRSBGTqXTmuvqGwS9YIqOE6gzq4zmotypT//sqOkx9Ap9v+AoRUZHMOWxIeLROsTwO6k2HOYdB7FNfFb1ieRzUW5PPZ26CX0ET3CG8kKa8gqeeegovv/wyBg4ciK5duyIqKgrOzs4oKCjA6dOn8ffff2srzvbt2xfLli3j9DcL1cEnGApJgloIVsAnIrMR2qSirR0H9dbly0t74PhAO0REBSJn9T7mHDakWbsQuHq6IC8rH2cOnYcQApJkneu5SX4c1FdF50q9KL0IfgStQ/zJy/h15XYAgI+7L348tB7JGTewYsUK7NixAytWrNArUiRJEsLDwzFkyBCMGzeOFWctnKu9A9p6+uNMZgrOZt1EfmkxXOwc5A7L8hl75ttKz5oT1VaYXgV89qq3FkkFmfj80l8AAJdgH/z0+3bkX0llzmEjFAoF2t3RGke3n0B6UiZSrqQisIW/3GFZPuYcBnH6fVWUzaE958Er9VZBCIHlUz6HWq35NA+b9gR8g70RGRmJDz/8ELGxscjOzsaxY8dw8OBBHDt2DNnZ2YiNjcWHH37IL1crUd6vXi0ETqbdkDkaKyFTJdpPPvkEoaGhcHJyQnR0NA4fPlzt/t9++y3Cw8Ph5OSEDh064LfffqvX8xKZmqe7M7w9XADwSr01+fjs7yhSlwAABjfvjlC3AOYcNiYimuvqTY45h0Ec1FdBkhwAZQvNndJ4CKGSNyAy2oGf/saxnScBAEFhARj48sOV9nFzc0OnTp0QHR2NTp06wc3NrbHDpAbGfvWmJwnjb3W1adMmTJkyBbNmzcLRo0fRsWNH9OnTBykpKQb3379/P4YNG4bRo0fj2LFjGDBgAAYMGIBTp04Z+eqJTKO8WF56Vj6yctn+ytKdyLiC32/8CwDwtHfB2DYPVNqHOYf10x3Uxx08J2Mk1oM5h2Ec1FdHOwW/GFBdkzUUMk5xUQk+feVz7f3nFv4HDk6cdm2LOrECvlVYtGgRxo4di1GjRiEyMhIrVqyAi4sL1q5da3D/pUuXom/fvnj11VcRERGBOXPm4Pbbb8fHH3/cyJETGaa7rj7hOqfgWzK1UOODuF+0959vEwMPe2cZIyK56BXLO8yZv5bKEnIODuqrw2J5VuOHD39D4sVkAMBt90TirieiZY6I5NLa0w9u9o4ANFfqddczUj2ZqBJtdna23q2oqMjg0xUXF+Off/5BTEyMdptCoUBMTAwOHDhg8JgDBw7o7Q8Affr0qXJ/osYWxgr4VmNr4nHEZmkuBrVyC8TjzbrJHBHJxdPPAyGtAgEA5/+5hJLiEpkjsgLMOQzioL4aEgf1ViEjORPr524BoClCM27xSFYftWEKSUJH32AAQEpBLm7k161vMDWcZs2awdPTU3tbsGCBwf1SU1OhUqkQGBiotz0wMBBJSUkGj0lKSqrT/kSNjb3qrUN+aRE+Pvu79v7LEQ/DTqGUMSKSW0T3tgCAkqISXDpxReZoqJy15Rysfl8du5baH1kB33Ktm74R+Tma9Yn9Rt+P1p3YGsbWdfINwb6kBADA8bTrCHH1kDcgAgBcvXoVHh4V/y8cHR1ljIaocYWG6Ey/ZwV8i/X5pT+RWqQ5WXx3QASi/VrXcARZu/DoNti5fg8Azbr6dl1b1XAENQZryzk4qK+OXUsAEgDBK/UW6sKxeGxb+z8AgIuHM0bOHSZzRGQO9IrlpSbioeasMmwMCfUrPKN7PAB4eHjofcFWxc/PD0qlEsnJyXrbk5OTERQUZPCYoKCgOu1P1Nh8vVzh7uKInPwiTr+3UIn5Gfgqfi8AwE5SYlJ4P5kjInOgVwH/8HkAfF8YgzmHYZx+Xw1JcgKUzTR3VJe49tbCCCGw7OV12v9vT08fBO8AT5mjInOgWyzveBqL5RmtkdvLODg4oEuXLti5c6d2m1qtxs6dO9GjRw+Dx/To0UNvfwDYvn17lfsTNTZJkhBaNgU/OS0HeQXFMkdEdfXR2a0oVpcCAIaG9kRzVz+ZIyJz0LJjC9g72gMA4g6yrZ3RmHMYxEF9Tcor4It8QM2e1pZkz5aDOPlXHAAgpFUgHnuRZ0ZJw9fJFc3dvAAAJ9OTUKJmy0pLM2XKFKxatQqff/454uLiMG7cOOTl5WHUqFEAgGeeeQbTpk3T7j9p0iRs27YNH3zwAc6cOYPZs2fj77//xsSJE+V6CUSV6FbAv8wp+BblaHo8diRp2lV5O7hidKv7ZI6IzIW9gz3a3K5Z+pl4IQnZaazlY2ksIefgoL4mLJZnkYoLi7HqtS+1959/fwQcys6SEgFAx7Kr9UWqUpzNvClzNBbORJVo62LIkCF4//33MXPmTHTq1AnHjx/Htm3btIVprly5ghs3Kk7E9uzZExs2bMDKlSvRsWNHbN68GT/88APat29f31dNZHKsgG+ZVEKNRXG/au+/0KY33OydZIyIzI1ev/pDvFpvFOYcBnFNfQ0ku1YV/+9LLwKOd8sZDtXS5kW/IClBM1Dr/EAH9Hi0q8wRkbnp7NcEP1+OBaDpV9/eh2ur662eX5J6x9fDxIkTqzzrvXv37krbBg8ejMGDB9fvyYgagV4F/EQO6i3FL9eO4mx2IgCgjXswHmvGnIP06farP3PoPKIful3GaCwccw6DeKW+JsqKCpWCV+otQmpiOr5e8B0AQKGQMG7RCLawo0p019X/m5YoYyRERBqhIbxSb2lySwqx7Nwf2vtTIx6GUmJ6TfrK29oBvFJPDYN/dWpip9N2ovSifHFQra19cwMK84oAAA8/1xthHVrIHBGZowjvQDiU9Q4+lspiecaQhPE3IgICfd3hXLZULOE619RbgnWXdiO9OBcAcF9gFLr4tqzhCLJFAc394B2oKdZ89vAFqNVqmSOyXMw5DOOgvgaSwg1QlE3LLb3ICvhm7uyRC9j++Z8AADcvV4x4e4jMEZG5clTaIdJbsxYqPicdmUUFMkdkwWRY30ZkjRQKCS3K+tUnpmShsLhE5oioOtfy0vB1/D4AgL2kxEtsYUdVkCRJe7U+NzMP186x+Ha9MecwiIP62igvlieyAHWqvLFQlTQt7D7T3v/PzMHw9Ku5/yTZLt1+9ZyCbwR+wRKZTPm6erUQuHojQ+ZoqDpLz25FidB0TxkedheauvjUcATZsvA79NfVUz0x5zCIg/raYAV8i7Br4z7E7j8LAGjWLgSPTugjc0Rk7vT71XNQT0TyC9Npa8d19ebr77SL2J2sKbbq6+iOUa3ulTcgMnsR3XUq4B88J2MkZI04qK8FyU5nfRTX1ZulwvwirH79K+395z8YATt7Nneg6nXWuVJ/nOvq643r24hMR7dYXgJ71ZulW1vYjW/7IFztHGWMiCxB266ttIWbWSyv/phzGMZBfW3oXKkXKl6pN0ffvv8Tbl7TXNHo1rcTW4VQrTR19YSvowsAzZV61syoJyEZfyMiAEBoU50K+Nd4pd4c/Xj1CM7nJAEAIjya4JEmnWWOiCyBi7szQts3AwDEn7yCgrxCmSOyUMw5DOKgvjZYAd+s3byWhm8W/ggAUCgVeP6DETJHRJZCkiTtuvqs4kLE5/CqGBHJK8TfEw72ms4cnH5vfnJKCrD83Hbt/SkRD0PBFnZUS+Xr6tUqNc7/c0nmaMia8K9QLUgKb0BRduacg3qzs2baehTma1rYPTq+D1pENJU5IrIkeuvqU7muvl5YtIbIZOyUCjQL8gYAXE3ORGmpSuaISNfqC7uQWZIPAOgd3AGdfELlDYgsiu66ehbLqyfmHAZxUF9b5VPw1akQ6kxZQ6EKsQfPYef6PQAAdx83/GfWYJkjIkvTyU+3WB7X1dcH17cRmVZ5BXyVSo2ryZnyBkNal/NSsenyfgCAo8IOL7VjCzuqm/BonWJ5HNTXC3MOwziory1OwTc7arUayyev094f8dYQePi4yxgRWaLbfENQvrqKV+qJyByUD+oBFsszJ0vifoNKqAEAT4f1QpCzl7wBkcVpHtEELu7OAHilnkyLg/pakpS6g3oWyzMHO9fvwZnDmv8XoVHN8MjzvWWOiCyRu70j2nj6AQDOZKagoLRE5ogsEKfCEZlUqG5bOxbLMwsHb57H3ptnAAABjh4Y0fIemSMiS6RUKtG2m2ZMkXo9XVvkmeqAOYdBHNTXlm4FfF6pl11BbgHWTFuvvf/CohFQ2illjIgsWUdfTbG8UqHGqfQkmaOxQMZOg7PSL1ii+tK7Us9iebIrVauw6ExFC7sJ7frA2c5BxojIkkVEc129UZhzGMRBfW3pDOo5/V5+m979EWmJGQCA7v27oEvvjjJHRJass866+n/TOAWfiOTVLMgbSoVmYVBCIgf1cvvu6mHE56YAANp7NkPfEOYcVH966+oPnpMxErImHNTXlsIPkDw0P3P6vaySL9/Etx/8BACws1fi+fdHyBwRWbryK/UAcCyVxfLqjFPhiEzK3k6JpoFeAIDLiRlQqdXyBmTDsorzsfL8Du39qZGPsIUdGUXvSv1hjinqjDmHQfyrVEuSJOlUwL8Boc6VNyAbtur1L1FcqFn3PODFh9C0TbDMEZGla+vpBxc7ewDAcV6przt+wRKZXGjZFPyiklLcuJktczS2a9WFncgqKQAA9AvphPZezWSOiCydd6AXgsICAADn/r6I0pJSmSOyMMw5DOKgvi7sWlb8rLokXxw27OSeOPz5zQEAgJe/B56eMVDmiMgaKBUK3OajOTl0Iz8byfk5MkdkWdhehsj0QrmuXnaXcpKx+cohAICT0h4T2/WROSKyFuVT8IsKipFw6qrM0VgW5hyGcVBfB5LeunpOl2lsarUay19ep70/cs5QuHq6yhgRWZNOfhVT8Hm1nojkplssL56D+kYnhMDiMxUt7Ea0vAcBTp4yR0XWIoLr6snEOKivC1bAl9Ufn+3G+aPxAICWHVug7+j7ZY6IrElnP66rJyLzEabb1u46e9U3tn03z+JgqqYyeZCTF54O6yVzRGRN9IrlHWYFfDKendwBWBQ73V71HNQ3przsfKx9c4P2/vjFo6BUsoUdmU4nX1bArzdj16hZ6VQ4ImO0CPaBJAFCsAJ+YytRl2Lxmd+0918M7wsnpb2MEZG1ad05DPYOdigpLsWZgxzU1wlzDoN4pb4uFMGA5KL5mdPvG9XX879DRnIWAOCuJ6LR8d4omSMia+Pv7IYmrpqplSfSbqCU1aaJSEZOjvYI9tP8TUq4ngYhrDQTNUPfXj6IK3mpAIBO3i3QO6iDzBGRtXFwtEerTqEAgKtnE5GTwQLcZBwO6utAkhSAsqxYnuoqhCiUNyAbkXgxCd8t+RUAYO9gh+cW/kfmiMhalV+tL1CV4HzWTZmjsRwsWkPUMMrX1ecXliAlnQU8G0NGUS5WXfgfAECChCkRj2g6IBGZWDhb29ULcw7DOKivK+0UfAGUxssaiq1Y+dqXKCnWtPsY+PIjCG4ZKHNEZK06cV19/bG1DJHJheqsq0/guvpG8en5Hcgt1Vy0eaTJ7YjwbFLDEUT1o9ev/hCn4NcJc45KOKivI/0K+FxX39CO7zqFfd8fBgD4BHlh2BtPyBwRWTPddfWsgE9EcmMF/MZ1PvsGvr96BADgonTA+HYPyhwRWbOI7m21P8dxUE9G4qC+rlgBv9GoVCosf/kz7f1R84bDxd1ZvoDI6kV5B8JeofmzeJxX6mvPmDPmVn7mnMgYer3qE3mlviEJIbDozK9Ql/1BGtXqPvg5usscFVmzoLAAePpp3mNnDp1n3YzaYs5hEAf1daVXAZ/rXxrS1tX/w6UTlwEAbbq0xIMj7pE5IrJ2Tnb2CPfSLO+4kJ2G7GLWzagNrm8jahihIbpt7XilviH9mRKHv9MuAQBCnL0xLLSnzBGRtZMkSXu1Pic9F9cvJMkckWVgzmEYB/V1pWwKwEHzMwf1DSY3Mw+fzfhae3/84pFQKPh2pYbX2U+3td0NGSMhIlvn5uIIf283AJpBPa/kNYxiVSmW6rSwmxTeD45sYUeNIPwOnX71B8/JGAlZOo6S6kiS7AC7MM0d1WUIUSJvQFbqqzmbkZWqqfR775CeaH9XhMwRka3o5FtRFOnfNE7BrxVOhSNqMOXr6rNzC5GRXSBzNNZp4+X9uJavWd7QxScM9wWybS41jojuLJZXZ8w5DOKgvj60U/BLAdVlWUOxRtfOJeKHj7YCAByc7DH23adljohsSSedK/XHUlksrzY4FY6o4ehWwOcUfNNLK8rB2gu7AAAKtrCjRtauWyvt+43F8mqHOYdhHNTXAyvgN6xPX/kCqlIVAGDwK48ioLm/zBGRLWnh5g1vR01Bxn/TrnO6a23wrDlRg2EF/Ia1/Nx25KmKAACPNeuKth7BMkdEtsTV0xXNIzQzBC/9exlFBUUyR2QBmHMYxEF9fegVy+Og3pT+/uNfHPzlHwCAXxMfDHl9gLwBkc2RJAkdy1rbpRcV4EpuprwBEZFNCw3RrYDPQb0pnc1KxE/XNDmHq50jXmjTW+aIyBaVr6tXlapw/mi8zNGQpeKgvj6Uum3tWCzPVFSlKqyY8pn2/ugFT8HZ1Um+gMhm6farP8bWdjXjWXOiBhPWtGL6fcJ1trUzFSEEPoj7BaLsD9CY1vfDx9FN5qjIFnFdfR0x5zCIg/r6sGsBQKn5mYN6k/l5xR+4HHsNABAe3Qb3D79L5ojIVnX20y2Wx3X1NeH6NqKG4+XuAm8PzZIgTr83nZ1Jp3AsIwEA0NzFF0Na9JA3ILJZ4dE6FfA5qK8Rcw7DOKivB0lyAJTNNXdK4yGESt6ArEB2eg6+mP2N9v74JaPYwo5k05FX6onIjJRPwU/LzEN2XqHM0Vi+IlUJPjy7VXt/UvhDsFfYyRgR2bLQqGZwcnUEwCv1VH8cNdWXtlheEaBi0m+sL2d/i5z0XADAA0/3QoTOWUuixubh4IRWHpokOi4zGUWqUpkjMnOcCkfUoEJ1iuUl8Gq90TYk7MONgkwAQLRva/QKCJc3ILJpSjsl2nbV1OtKuZKKtBsZMkdk5phzGMRBfX3pVcDnFHxjXI69ip+W/w4AcHJxxJgFT8kcEVHFuvoStRqn05NkjsbM8QuWqEGFsa2dydwszMa6i7sBAEpJgZcjHmYLO5Kd7sUsXq2vAXMOgzioryeJFfBNQgiBFVM/h1qlBgAMeX0A/HSuSBDJpZPOuvrjXFdPRDLSv1LPYnnG+OTcHyhQFQMAnmh2B1q5B8ocEREQ0b2t9ue4g+dkjIQsFQf19WXHCvimcPi3o/j7938BAP7NfDH4lf4yR0SkoVsB/zjX1VfLnIvWpKen46mnnoKHhwe8vLwwevRo5ObmVrv/iy++iHbt2sHZ2RnNmzfHSy+9hKysrIYLkqgG7FVvGqczr+HX60cBAO52TniuTYzMERFp6BbLO3OY44rqMOcwjIP6+rILA1A2XUvFK/X1UVJcghVTP9feH/vuf+Do7ChjREQV2nkFwEmpKZzEK/U1MOOpcE899RROnz6N7du345dffsFff/2F5557rsr9ExMTkZiYiPfffx+nTp3CZ599hm3btmH06NENFyRRDfy8XOHmovl+TEjklfr6EEJgUdwv2vtj2zwALwcXGSMiquAb7I2A5n4AgLNHLkClYhHuKjHnMIilPutJkpwhlE0A1TWg9CKEEFyTVUc/ffI7rp27AQCIurMd7h3SU+aIiCrYKRTo4BOMIzev4lpeFm4W5MLfmT2MLUlcXBy2bduGI0eOoGvXrgCAjz76CA899BDef/99hISEVDqmffv22LJli/Z+q1atMG/ePDz99NMoLS2FnR2/NqnxSZKE0BAfnLpwA0mp2cgvLIaLk4PcYVmUP26cwInMKwCAUFd/DG7eXeaIiPSFR7dBypVUFOYV4fLpa2h5Wwu5Q6I6kDvn4JV6Y5RPwRd5gJqFtOoi82YWvnz7W+39cYtH8aQImR32q68dU02Fy87O1rsVFRUZFdeBAwfg5eWl/XIFgJiYGCgUChw6dKjWj5OVlQUPDw8O6ElWulPwL/NqfZ0Uqorx4dlt2vuTIx6CnUIpY0RElekWy+O6+qox5zCMg3pj6FXA5xT8uvh85ibkZeUDAB4ceS/adW1VwxFEjU+/Xz0H9VUy0VS4Zs2awdPTU3tbsGCBUWElJSUhICBAb5udnR18fHyQlFS7E7GpqamYM2dOtdPniBoDi+XV35eX9iClULNGtad/W9zp307miIgqC2cF/NphzmEQLzsYQVK2qliWUXoBcLxLznAsxqUTl/Hbqh0AAGc3Jzw7b7jMEREZ1lmvAj6L5VXJ2DVqZcdevXoVHh4e2s2OjoZrbPz3v//Fu+++W+1DxsXFGRGQRnZ2Nh5++GFERkZi9uzZRj8ekTHY1q5+kgoy8fmlvwCUtbALf0jmiIgMa3N7GJR2SqhKVYjjoL5qzDkM4qDeGLdUwOfk8ZoJIbB8ymdQqzWfqGHTnoBvsLfMUREZFuTijmAXd9zIz8GJtBtQqdVQKjjBqaF4eHjofcFWZerUqRg5cmS1+7Rs2RJBQUFISUnR215aWor09HQEBQVVe3xOTg769u0Ld3d3fP/997C3t68xLqKGFMoK+PXy8dnfUaQuAQAMbt4doW4BNRxBJA9HZ0e07NgC5/+5hCtx15GXlQdXT1e5w7Ja1pZzcFBvDLuWFT9z+n2t7P/xCI7/7xQAICgsAANffljmiIiq19E3BDfyzyKvtBgXslPRzosJ4a0kwKiTmnU91t/fH/7+/jXu16NHD2RmZuKff/5Bly5dAAD/+9//oFarER0dXeVx2dnZ6NOnDxwdHfHTTz/BycmpjhESmV6QrwecHO1QWFTKCvi1dCLjCn6/oWmb62nvgrFtHpA5IqLqRUS3wfl/LkEIgbNHLuL2mNvkDsnsMOcwjJecjCAp3AFFoOZO6QUI0YA9EqxAcVEJVr76hfb+cwv/AwdW7yUzpzcFn+vqDTPT9jIRERHo27cvxo4di8OHD2Pfvn2YOHEihg4dqq1Ce/36dYSHh+Pw4cMANF+uDz74IPLy8rBmzRpkZ2cjKSkJSUlJbDFEslIoJLQI1kzBv56ciaLiUpkjMm9qocYHOi3snm8TAw97ZxkjIqqZ7rp6TsGvAnMOgzioN5a2An4WoOZ0uOp8v/Q3JF5MBgDcdk8k7nqi6rNWROZCt1ge+9VbnvXr1yM8PBwPPPAAHnroIdx1111YuXKl9vclJSU4e/Ys8vM1hTuPHj2KQ4cO4eTJk2jdujWCg4O1t6tXr8r1MogAVFTAVwuBK0kZMkdj3rYmHkds1jUAQCu3QDzerJvMERHVLKJ7W+3PLJZneeTMOTj93lh2rYDifZqfSy8CSj954zFTGcmZ2DBP04dRkiSMWzySLezIInTwCYZSkqASAsdSWSzPEN0WMfU9vqH4+Phgw4YNVf4+NDRUb5bVvffey1lXZLb0K+CnoU3zmqeE2qL80iJ8fPZ37f2XIx5mCzuyCE1aB8Hdxw056bmIO3gOQgjmy7dgzmEYr9QbSdJta6e6IF8gZm7d9I3IzykAAPQbfT9adwqTOSKi2nG2s0d42Tr681k3kVtiXB9Tq2SmU+GIrI1uBfwEFsur0ueX/kRqUQ4A4O6ACET7ta7hCCLzIEmSdgp+VmoOkuJTajjCBjHnMIiDemPZVfRXF6Uc1Bty4Vg8tq39HwDAxcMZI+cOkzkiorrpVLauXgA4kXZD3mCIyGaF6VXAZ7E8QxLzM/BV/F4AgJ2kxKTwfjJHRFQ3EXforKs/eE7GSMiScFBvLJ1BPSvgVyaEwLKX12mnljw9fRC8AzxljoqobjpxXX3NeMacqMGFBHjB3k4zjTwhkVfqDfno7FYUqzVFBIeG9kRzVy6LJMsS3p3F8mrEnKMSDuqNJCl8AEXZdDgO6ivZs+UgTv4VBwAIaR2EAS/xjDlZHv0K+FxXf6vy9W3G3IioZnZKBZoHeQMArtzIQKlKLXNE5uVoejx2JGna5nr/v717j2+yPvsH/rmTtOkhSUtP9AgtFGiLCEyEyeTxALqCp211Q2FTUHDAFEE2B9rf3KMy3KMi6oY8Uo8TlEfcnDrFgejcFBBUEGkpFgr0QM+HpKcc798fadOEpgWS3Llz+Lxfr7xoSnPn6ibtdd3f7/e6ImNx5+irZI6I6MLlTe0/LsJmeQMx53CPRb0vKHv/8dkaIdra5Y0lgJh6TNh8/18cz3/5xG2IiIyQMSIiz2RrE6CLsM8NPdhcy0ZqRCSb7N5z9RarDTX1bfIGE0Csog3ry/7heL507LXQRHg275lITtphGmSNs+8QPH7wJExGs8wRUTBgUe8L3ILv1vb176HuZCMA4HuzJuCyG6bIHBGRZxSCgElJ9l+wTT2dqOnkzTsXbFpD5DfZLufquQW/z3vVX6Fcbz8eNUabhhszL5E5IiLP9TXLM5ssqPi6UuZoAgxzDrdY1PuA4FLUs1keADTVtuD1dX8FACgUApas5wg7Cm6cVz84boUj8p8cFvUDdJh7sPFY/wi7VfnXQSkwxaXglT+t/1w9t+C7Ys7hHn/i+YLTWDuRK/UAgBcf3IqeTvvor+t+eS1yLhohc0RE3nE+V8959WfhXXMiv3Eu6k/WsgM+ALx0/BO0mDoBAFcPH49LEkfJHBGRd/KmsVneoJhzuMWi3he4Uu+ifH8Fdr7yLwCAJj4Wt//3z2SOiMh7ExPTHB8fbOJKPRHJIys1HorenW9cqQeqO5vx+snPAACRChWWc4QdhYCcCSOgjo4EwJV6Oj8s6n1BkQIIWvvHYb5Sbx9h97Lj+S8e+iniknTyBUTkI8PUMcjW2htUHWmtg9FqkTmiwMGtcET+ExmhQmZqPADgVG0LbLbw/gf0dPkHMItWAMC87B8gIyZB5oiIvKeKUGHsFPuiYV1lA1ob2MunD3MO91jU+4AgCP2r9bZaiLZOeQOS0cdvfIbSz8sBAFl5Gbhx2Q9ljojId/rm1ZtsVhxtbZA5mgDCrXBEfpWdbi9cjSYL6pr0Mkcjn/3Nx/FJfSkAIFGtxYLRV8obEJEPcbTdIJhzuMWi3lecztXDekK+OGTU02VEyW9fczxf8uTtUEWoZIyIyLf6OuADwMFmnqsnInmwWR5gsVldRtj9auy1iFWpZYyIyLfyvz/W8XHZ3mMyRkLBgEW9j7ADPvDm4++gsdqeXFw6ezKmzp4sc0REvjUp0blZHs/VO/CuOZFfcawd8PfqA6gw1AEA8uMycF0Gcw4KLc7N8o5+EZ61hVvMOdxiUe8rTkV9OHbAb6hqwrb/eRsAoFQpseTJ2+UNiEgCefEpUCvtu08OcaydA8+3EfmXawf88CvqDeZubDq20/F8Vf71UHCEHYWY5MxEJGXYj9qUf1EBq9Uqc0SBgTmHe/wJ6CtKp+33YVjUv7BmC4zdJgDAjct+iBF5Ged4BVHwiVQqcdGwVADAqY5WNPeEb/8MIpLPyLT+ZnCV1eE31q6kYjfazF0AgGvTLsbEYSNljohIGn2r9V2GblQd5WICDY5Fva8o0wEh2v5xmG2/L91Tjt1b/wMA0CVq8YuHfipzRETScT5Xf6j5jIyRBBBuhSPyq+ioCKQl2yfLVNY0QxTD5x/RyY5GbDu1BwCgVkTgnnGFMkdEJJ1853n1PFdvx5zDLRb1PiIICkA5yv7EWgVRNMobkJ/YbDZsXPGS4/nt/z0X2mEaGSMiklZfB3wAONjEZnkAIIii1w8iujDZ6fYt+F09JjS2dsgcjf88ffR9WEUbAOAXo2YgNTpe3oCIJORyrp4d8AEw5xgMi3pfcpyrtwGWSllD8ZePXvs3yvfbjxtkX5SF6+6aJXNERNKalNR/tOQgz9UTkUxyMpy24IdJs7w9jcfwn0b72NwUtQ635fyXzBERSWvMJaOgUNrLtTIW9TQEFvU+JKjC61x9d0c3StZscTxfun4BlCqljBERSS89RofkqFgA9qLeFqJ3fC8It8IR+Z1Ls7ya0D9Xb7FZ8ZTTCLu7xxUiWhUpY0RE0ouOjULOhBEAgFNHqtBl6JY5ogDAnMMtFvW+5NIBP/TP1b/x2NtoOdMKALjsxin43qyLZY6ISHqCIGBy72p9h9mIE/rwWCEbCjvREvlftktRH/o/h/5a9QUqOxsBABPis1CYPlHmiIj8o+9cvc0m4tiB0F80PBfmHO6xqPelMFqprzvZgDeffBcAoIpQ4q7Hb5M5IiL/cd6C/zXP1fOuOZEMstPDZ/t9u6kLz3+3y/F8Vf71EARBxoiI/CfPpVket+Az53CPRb0vKbMARNg/toZ2Ub/5t6/BbDQDAH68fA4yx6TJHBGR/7g0y+O5eiKSgTY2Csm9jWlP1ob29vvNFR+h3WzfdjwnfTLGx2fJHBGR/+R/f6zj46NfsKgn91jU+5AgqABVjv2J5SRE0SxvQBL55tNSfPqmfZxMfLIO84uLZI6IyL8mJKRB0btKxA743ApHJJeRvav1bYZutOq7ZI5GGicM9dh+eh8AIEoZgV+Nu1bmiIj8K3NsGmLjYgDYx9qF0whLd5hzuMei3tcc5+rNgPW0rKFIwWq14rmVLzueL3z0VsTGxcoXEJEMYiMiMTYuGQBQ3t6ILotJ5ohkxq1wRLJwbpYXilvwRVHEU04j7BaMugIpUXEyR0XkXwqFwrEFv7W+HQ2nm2SOSGbMOdxiUe9ryv5meaF4rv6fL3+Ciq8rAQCjJo7ED++4SuaIiOQxOcm+Bd8mijjcfEbmaIgoHGU7jbULxQ74nzWWY2+TfbtxWnQ85ufMkDkiInnkTe3v21W295iMkVCgYlHvY6E81q5T34UXH3zd8XzZhoVQKjnCjsLTxETOq+/DrXBE8gjllXqzzYKnjr7veH7PuEJEKSNkjIhIPi7n6sN8Xj1zDvdUcgcQcpyKetFSgVDqzbp17V/R1tAOAJhRNA0Trxgvc0RE8ulbqQfYAd/r7Wwh+guWSGqhXNS/eWovTnfatxlPHpaNWakTZI6ISD4uK/VhXtQz53CPK/W+psqG43/WEFqprz1eh789/Q8AQIQ6Aov/5xcyR0Qkr9G6JGgi1ADsK/Xh3riGiPxvmC4GcZooAMCpEOqA32rswOaK3QAAAQLuy7+OI+worMUl6ZCemwoA+O6rSphNodmMmzzHot7HBCESUI60P7Echyha5Q3IR57/zaswmywAgKKV1yMtZ7jMERHJSyEImJhoH+XY0N2BM10GmSOSF7fBEcmjb7W+sbUDhs4emaPxjf/9bhc6LPbv5YbM7yEvLuMcryAKffm9zfLMRjNOHDolczTyYs4xEIt6KTg64BsBa/Bvy/1692F89vZ+AEBCajxuXfNjmSMiCgyu8+qD/9+6x0TR+wcRecR5C34ozKv/Tn8Gf6uy5xyxSjWWjuUIOyIAjg74QJhvwWfO4RaLeimoQqcDvtXiOsLujj/MQ4w2Wr6AiALIpCSnZnlN4dssj01riOST7VzUB/m5elEUsf7oP2DrPfS6cPSVSFJrZY6KKDCwWZ4dcw73WNRLwKUDvjW4i/r3Sz5C5eHTAIAxl4zCNbddIXNERIGDK/VEJDfnsXbB3izvXw1lONB8AgCQHj0Mt2RPlzkiosAx6uIRiFDbJ0CE9Uo9ucWiXgouHfCDt6jvaOvEK797w/F82VMLoFDwPxmiPolRsRihiQcAHG6pg9kWGj00LpjogwcReSRUtt+brBY87TTC7t682VBzhB2RQ0RkBMZcMgoAUFtRh/YmvcwRyYQ5h1us0KSgzOn/2FIhXxxeeu3hN9HeZG/+deXc6bjo8nyZIyIKPBN7V+uNVgvK2xpljkYegs37BxF5JnmYBjFRkQCCe6X+jVOfo7rLflPikoQcXDWcY3OJzpbvNNru6BfBW2N4gzmHeyzqJSAoYgBlpv2JpSIoR11Vldfg7T/tAABERkVg8R9/LnNERIFpstO5+rCfV09EficIgmO1/kyjHt09wTfqqtlowIsVHwMAFBBwX/71HGFH5IbzufqyvcdkjIQCDYt6qfQ1yxM7AVu9vLF44H9//SqsFvtW4p/++kakjEiWOSKiwORyrj5ci3puhSOSVU5m/7n6U2eCbwv+c8d2otNqBADclDUFY3VpMkdEFJicO+CH60o9cw73WNRLRRm8HfD3f3gQ+/7xFQAgKSMBc3/7I3kDIgpg+cOGI1KhBAAcbA7PDvjsREskr+z0/nP1wbYFv7y9Fu9UfwkAiFWpsWTMNTJHRBS4UkYkISE1HoC9A77NFqJ7yYfAnMM9FvUScemAH0Tn6i1mCzbd97Lj+Z3r5iM6Nkq+gIgCnFqpQsGw4QCASkML2ozdMkdEzlpaWjB//nzodDrEx8fjzjvvREdHx3m9VhRFzJ49G4Ig4O2335Y2UCIv5ATpWDtRFPFk2XsQe5fOFuVejQS1RuaoiAKXIAiO1frO9i5UHzsjc0TkTM6cg0W9VJxm1QdTB/z3Nu3E6TL7FuK8aWNw9bzLZY6IKPA5z6s/FI6r9aLo/UMi8+fPx5EjR7Bz50689957+PTTT3HXXXed12s3bNjAc70UFJzH2gVTB/yP6r7F160nAQAjYhIxd+Rl8gZEFATynbbgh+W5euYcbrGol4rKeft9cKzU65sNePX32xzPl21YyBF2ROfB+Vx9ODbLC9StcGVlZdixYwdKSkowbdo0XH755Xj22WfxxhtvoLZ26JsvBw8exJNPPokXX3xRmuCIfCg1SQd1pApA8Gy/77Ga8Uz5B47n9+bNQYRCJWNERMHB5Vx9GM6rZ87hHis2iQgKHaBIsT8JkqL+L//9JgytnQCAmT+f4XInkIgGNzncV+p9RK/XuzyMRqNX19uzZw/i4+MxZcoUx+dmzZoFhUKBffv2Dfq6rq4uzJs3D3/+85+RmprqVQxE/qBUKDAy3b5aX13XBpPZInNE57a18j84090GAJiWmIsZKXnyBkQUJMZOGQ2Fwr6iWxaGRb2vhFrOwaJeSo4O+G0QbYG9He5UaRXeee5DAEBUjBqL1s2XOSKi4JEZG4dEdQwAe7O8YBxj6RUfdaLNyspCXFyc47Fu3Tqvwqqrq0NKSorL51QqFRISElBXVzfo61auXInp06fjpptu8ur9ifwpu7eot4kiqura5A3mHBp79Hj5xL8AAEpBgZX51/GoC9F5itFGY+T4LABA5Ten0N3ZI3NEfsacwy0W9VIKkmZ5oihi06pXYLPaO2jO/e2PkOTUdIeIhiYIguNcfbupB5WGwL6J52u+2gpXVVWF9vZ2x2PNmjVu32/16tUQBGHIx9GjRz36Xt555x3s3r0bGzZs8PB/DSJ5ODfLC/Qt+H8+9iG6rSYAwE+ypmK0drjMEREFl77dtDabiO++PCFzNP7FnMM9Hl6SkKDK7R+FaKkAIqfKGc6gvnj/Kxz48BAA+6iMn/76BpkjIgo+kxLT8VGNfRvcwaZajNKF0Y0xbxvP9L5Wp9NBp9Od88tXrVqFBQsWDPk1o0aNQmpqKhoaGlw+b7FY0NLSMugWt927d+P48eOIj493+XxRURFmzJiBTz755JzxEckhWIr6I21V+EfN1wAAXUQ07hozS+aIiIJP3rQxeL/kIwBA2d7vcPF/FcgckR8x53CLRb2UzuqAH4gby8wmMzatesXxfPEffw51tFrGiIiC06Sk/mZ5B5tr8JNRE2SMJrQlJycjOTn5nF932WWXoa2tDV9++SUuueQSAPZfoDabDdOmTXP7mtWrV2PRokUun5swYQKeeuop3HADb3hS4HLpgB+gRb19hN0/HM8X585EfGSMjBERBaf87491fHz0C56rl1Kw5Bws6qUUBNvv3/nzh44ZlxddnocrfjZd5oiIgtPFiekQYD+qdbApvJrledtNVqpOtPn5+SgsLMTixYuxadMmmM1m3H333bjllluQnm6/CVNTU4OZM2fi1VdfxdSpU5Gamur2jvqIESOQk5MjTaBEPpCZEg+VUgGL1YaTNYF5BOjDM4dwuO00ACAnNhk3j3Cf6BLR0LLy0hGjjUaXoTvsxtox53CPZ+olJCgSAGGY/UkAzqpva2zHXx5+E4D9TPDSpxawUQ2Rh7QRaoyJSwIAHG1rQLfFLHNEfuSjpjVS2LJlC/Ly8jBz5kzMmTMHl19+OZ5//nnH35vNZpSXl6Orq0u6IIj8QKVSYkSaPec4XdcKS2+fnEDRbTHh2fIPHc9X5F8HlUIpY0REwUupVGLcVPviYXNtKxqrA3N3jiSYc7jFlXqpqUYD5gOArQGiTW8fdRcgXvndNnS22/+juvb2KzH2ktHneAURDWVSUgaOtTfBItrwbUsdLk3JkjuksJeQkICtW7cO+vfZ2dnnnFYQdtMMKGhlpyfiRHUzzBYrahvaMCIt4dwv8pO/VH6Khp52AMAPksdhevLYc7yCiIaSNzUXX390GABQtvcYkm++TOaISM6cgyv1UnPZgh84q/UnvjmF9zfvAgBEa6Jwxx9ulTkiouA3KbH/XH04zav3VSdaIvJOjtO5+kBqllfX3YZXT/wbgH2E3Yq8OTJHRBT8XM7Vh9G8euYc7rGol5gQgEW9KIp47r6XYbPZ/6ue98BPkJA6TOaoiIJf31g7APi6qUbGSPzMJnr/ICKvZTt1wA+kc/V/Kt8Bo81+JOlnIy9DtubcTaeIaGh5vWPtAKAsjIp65hzusaiXmksH/MBolvf53/fj4O5vAQCpOSn4yYrrZI6IKDSM0SUhVhUJADgYRiv1RBQYsgNwrN2h1lP48Mw3AIC4iBgsyr1a5oiIQsOwlDik5qQAAL778gQsZovMEZGcWNRLzamoD4QO+CajGc//5lXH87sevw2RUZEyRkQUOpQKBS5OTAMAnOnSo77LIHNEfhLATWuIwsmI1GFQ9Da8DYSi3ibasN5phN2SMbOgi4iWMSKi0JL/fftqvbHbhMrDp2WOxk+Yc7jFol5qiuGAEGv/2HpC3lgA/O3p91F7vB4AMPHK8bj8x1NljogotExMdJ5XHx6r9QK8PN8m9zdAFCLUkSqkp8QBAE6daXEcs5PLB7UHUdpeDQAYrRmOH2VdKms8RKEmb2r/FvxwOVfPnMM9FvUSEwShv1metRqiTb6xSa31bdi69i0AgELBEXZEUpgcrufqiSgg5PRuwe8xWlDXrJctji6LEX9yGmF3H0fYEfmcc7O8sDpXTwOwqPcH52Z5Mq7Wv/jg6+gydAMAZt85E6MnZssWC1GoCssO+KLo/YOIfCLHpVmefFvwXznxLzQZ7UeQrkjJx9Sk3HO8gogu1OhJ2YiItE8oD5eVeuYc7rGo9wPB5Vy9PB3wK76uxIcvfQwAiNFF4/ZHbpElDqJQlxytQUasffvrN81nYLHZZI5IehwvQxQ4sl3G2snTAb+2qxWvVf4HAKASlLiXI+yIJBGpjsDoyTkAgKryWhhaO2SOSHrMOdxjUe8PSnk74IuiiI0rXoLYe2fq5//vpxjWe+aOiHyvb7W+22rGd+2NMkfjB2xaQxQwAmGl/tnyD2Cy2Ttx35o9HVmxied4BRF5Km9q/y6Yo1/I35Rbcsw53FLJHUBYcJlV7/9/bJ9u34vD/y4DAGSMScOP7in0ewxE4WRSUgb+cdr+b27Pqe9gPHUGRqMRarUaubm50Gg0MkdIRKFqZLrzSr3/i/qvWiqxq84+NjchMhZ3jL7K7zEQhZP874/F289+AAA4+K/DiBgO5hxhiEW9PygzAEQB6AEs/j1Tb+w2YvP9f3E8/+UTtyEiMsKvMRCFG11TB5pfeQ/m0hNYVFPs2CUD2Jtnjhs3Dtdccw2WLFmCgoICGSP1DUEUIXhxRs2b1xKRq5ioSKQmalHXbMDJ2haIoui3prjWs0bYLR17LTQRUX55b6JwpUywoVw8iPaIJnz02FsQ1zHnONfrQxG33/uBICgA1Sj7E+spiKLJb++9ff17qD9l3/77vWsuxvevv8Rv700UbiorKzF79mz8bMZMRHz9HRbc8BO88MIL2Lt3L7755hvs3bsXL7zwAq666ips27YN48ePx+zZs1FZWSl36N6x+eBBRD6T3bsFv6PLiKa2Tr+973vVX6Fcb28QOlabhhsymXMQSaUv57iy8Ap0J7Zh/qJbmXOEcc7Bot5fHFvwbYDlpF/esqm2BW889jcAgEKpwNL1HGFHJJWSkhJMmDABZWVl2LJlC2qra7Bx40YsXLgQ06ZNw4QJEzBt2jQsXLgQGzduRFVVFbZs2YLS0lJMmDABJSUlcn8LRBQi5DhX32HuwcZj/SPsVhVcD6XANJNICmfnHDW1zDnCHX/a+olrB3z/nKt/8YGt6Ok0AgCu/+U1yB6f5Zf3JQo3a9euxeLFi3Hrrbfi8OHDmDdvHiIjI4d8TWRkJObNm4dvv/0Wt956KxYvXoy1a9f6KWLf6tsK582DiHzHtQO+f4r6l45/ghaTfVfAzNSL8L2EHL+8L1G4Yc7BnMMdFvX+ovJvB/yjX3yHna/+CwCgHRaL2/97ruTvSRSOSkpKUFxcjEceeQSbN2+GVqsFAHzyyScQBMHtY+/evY7Xa7VabN68GQ8//DCKi4vxwgsvyPWteI6daIkCivNKvT/G2lV3NuP1k58BACIVKiwfN1vy9yQKR8w5wJxjEGyU5y/OHfCt0s6qF0URz6182fH8Fw/9DLpEraTvSRSOKisrsWLFCixatAjFxcVuv2b58uW49NJLXT6Xm5s74OuKi4tx+vRp3Hvvvbj66quRk8NVLiLyTLbz9vta6Vfqny7/AGbRCgCYn3M50mOGSf6eROGGOQcNhUW9vyhHAIgAYAYs0hb1H7/+H5TuOQYAGJGfgRuWXivp+xGFq2XLliEpKQnr168f9GtmzJiBm2+++ZzXEgQBTz75JP75z39i2bJl+OCDD3wZqrRE0f7w5vVE5DO62Cgkxseiua1T8jP1+5uP45P6UgBAklqLBaOukPT9iMIVc45ezDnc4vZ7PxEEFaDKtj+xVEIULZK8T3dnD0pWb3E8X/Lk7VBF8N4Nka+VlpZix44d+MMf/uDY/jYYg8EAi+Xc/+Z1Oh3WrVuHHTt2oKyszFehSk4QvX8QkW/1bcFv1XejzdAlyXtYbFaXEXa/GvtDxKjUkrwXUThjztGPOYd7LOr9Sdl3rt4MWKskeYs3H38HjdX2u/JT50zGpYWTJXkfonC3adMmpKSknPOO+MKFC6HT6RAVFYWrrroKBw4cGPLri4qKkJKSgueee86X4RJRmMlO72+Wd1Kic/V/rz6ACkMdAKAgLhNzMiZJ8j5E4Y45B50Ll3D9STUaMPZ+bKkAVL49v9JQ1YT/e/zvAAClSoklT97u0+sTUb+dO3eiqKho0I6zkZGRKCoqwpw5c5CUlITS0lI88cQTmDFjBj7//HNMnuz+hptarUZRURF27dolZfi+xa1wRAEn26VZXjMm5WX69PoGczc2HdvpeH5f/nVQcIQdkSSYczhhzuEWf/r6keDcLE+CDvglq1+DsdsEALjpV4XIGpfh8/cgIvvWtvLy8gHNaJxNnz4d27dvxx133IEbb7wRq1evxt69eyEIAtasWTPk9adMmYKjR4+io6PD16FLQrB5/yAi38o5q6j3tZKK3Wgz27f1/zDtYkwcNtLn70FEzDnOxpzDPRb1/uQy1s63zfKOfF6Oj1+3j5PRJWrx89+du0kGEXnm+PHjEEURBQUFF/S63Nxc3HTTTfj4449htVoH/brx48dDFEVUVEg//tIn+u6ae/MgIp9ynlXv6+33Jzsase3UHgCAWhGBu8cV+vT6RNSPOcdZmHO4xe33/qTKgf0+is2nHfBtNhs2rnjJ8XzBw3OhHabx2fWJwp3RasEZgwHVBj1qDHp89uUXAICYmJgLvlZWVhZMJhM6Ozuh0+ncfk10dLT9fY1Gt39PRHQuCboY6DRR0Hf0+Hyl/umj78Mq2pe7bhs1A6nR8T69PlE4s5itaKptRX1VMxqqmvHZZ58DYM5BQ2NR70eCoIaoHAFYTwKW4xBFGwQfnD/b9ZdPceyA/SZB9kVZmLN4ltfXJAon3WYzajr0qNbbi/a+4r3a0I4agwENnR1wvq9rqq4BAHR1XXhH6RMnTiAqKgoazeA33rq7uwHYz7oFBbH34c3ricinBEFATkYiDpXXoLG1Ax1dRmhivP+ZsqfxGP7TWA4ASImKw22j/svraxKFE1OPGQ01LWioau4t3Ftc/mypa4PN1v+LUW9pAsCcw4E5h1ss6v1NNdpe1KMHsNYCKu8a13R3dOOFB7Y6ni9dvwBKldK7GIlCjMFkRE1foe6mcG/u/YV2vlTJSYAgoLS0FNOmTXP7NY2NjUhOTnb53KFDh/DOO+9g9uzZUCgGv6F35MgRCIKA3NzcQb8mkAiiCMGL7WzevJaIBpednoBD5fabkCdrW3BRbppX17PYrHjKaYTd3WN/iCil+8ZdROGqp9OI+uqBxXpDdTPqTzejtUF/QdeLUcZBAHOOPsw53GNR72+q0YDxI/vH1gqvi/rX1/0NLWdaAQCX3TgF35t1sbcREgUVURShNxpRZWh3Ldadivd2Y4/H10+KjkGmLg4ZWi0ytXHI1OqQqdVh8aaXsX//fixcuNDt6+bOnYvo6GhMnz4dKSkpKC0txfPPP4+YmBg89thjQ77ngQMHkJeXN+SddSKic3Fulneyptnrov6t0/tQ2dkIAJgQn4XC9IleXY8oGHXqux2r7PVVzivuzaivboG+2fOGc7pEDYZnJSIlMwHDRyQiJTMRw0ck4uSyT5lz0JBY1PuZoMrt3/VhOQ6or/T4Wmcq67F9/XsAAFWEEnc9fpvX8REFGlEU0dzd7bQdfmDh3mE2eXRtAcDwWA0ydTpkaHS9xbu9aM/Q6pCh1SJKFeH2tXMKC7Ft2zZs2LDB7YiZH/3oR9iyZQvWr18PvV6P5ORk/OQnP8FDDz005N1wo9GIt956C3PnzvXoe5IFx8sQBSRfdsBvM3Xh+YqPHM9X5V8PQRC8uiZRoBFFEYbWzgGr6w3VLY4/O9ovfBt8n4ThcUjJSrAX61mJSMlK6P8zMxFRse63wM++bjZzjj7MOdxiUe9vZ3XA9+bX4ebfvgaz0QwA+PHyOcgc490deCI52EQRjV2dqDboUa0/q2jv/bPHYvHo2kpBQJpGay/UdXHI0GiRqetfbU/VaBGp9Oy4ypIlS/Dss89i+/btmDdv3oC/X758OZYvX37B133rrbfQ0NCApUuXehSXLEQA3oyICc3fr0Sy82UH/M0Vu6A3248qzUmfjPHxWV5dj0gOoiiirdHQv7Leuz2+obrF8bnuTs8axikUAhLT4h2r6ymZCS6Fe3JGAiKj3C8UnAtzDifMOdxiUe9vylH9H3sxq/7Qv47g39v3AgDik3WYX1zkbWREkrDYbKjv7HBaXXct3GsNBphsg49aGUqEQtG7ot6/uu682j48VgPVEOfIvFFQUIDCwkI88MADuOGGG6DVar2+pl6vx5o1a1BYWIj8/HwfRElE4SwlQYuYqAh09Zi9Wqk/bqjHW6ftUz+ilBH41bhrfRUikU/ZbDa01LcPWF23/2n/2NRj9ujaSpUCyRkJA4r1lCz7qntS+jCoIqTpa8Wcg86FRb2fCYpYiIoMwFbT2wFfvODta1arFc+tfNnxfOGjtyI2LtbHkRKdH5PViroO+7g3x2p7h8FRvJ/pMMDq4VanKJXqrO3wOscqe6YuDskxsVDIuP1z48aNmDBhAu677z5s3rzZq2uJoohVq1ahubkZGzdu9FGE/sGmNUSBSRAEZGckovR4Hc40taPHaEaU+sJWCkVRxAanEXYLRl2BlKg4KcIlOierpW/cm+vqet+Ke2NNCyxmDxcK1CqkZCQgZUQihmcmOIp1+58JSEiNh1IpzULB+WDOYcecwz0W9XJQjQJMNYBoAGwNgHL4Bb38w5c+wfGDJwEAoyaOxA/vuEqCIInseixm1BgM/d3jXca96VHX0eHxTiZNRGTv6vpZq+1a+2p7YnR0QJ/ZzMnJwYYNG7B48WKMHDkSxcXFHl1HFEU8+uijKCkpQUlJCXJycnwcqcREeHm+zWeRENFZstPtRb0oAqfOtGBc9oXlHP9pLMfepu8AAGnR8ZifM0OKMIkAACajGU01raivbkHD6ebeLvL9DemazrTBZvVs77U6JtJpld31TPvwzETEp2iH7BIvN+YcvZhzuMWiXg6qXMD0b/vHlooLKuo79V14qfh1x/NlGxZC6eGZYCIA6DSZXAr2aqf57NX6djR1e94QJk4d5brKrnNdbY9TRwV00X4+Fi1ahPr6ehQXF+PUqVNYv379BW2L0+v1WLVqFUpKSrB27VrceeedEkZLROEmx+lcfWXNhRX1ZpsFG5xG2N0zrhBRSs/OBBMBgLHbhIZqdzPa7c9b6vUQPSzYYrRR/R3jz9oen5KZgLhEDXMO5hwhi0W9DATV6LM64P/gvF+79dG30NbQDgCYUTQNE68Y7/sAKaS0G3uGnNHe2uP5uLfE6GjHqnrmWYV7hlYHbaT7Lq6h5sEHH8Tw4cOxYsUK/POf/8S6detw8803u+1Q26ev4+yaNWvQ3NyMkpKS4P3lyk60RAEr+6yxdhfi/07txeku+2smD8vGrNQJPo2NQk9XR8+gBXtDdQvaGg0eX1s7LNa1WD9r7JsmLsaH30ngYs7BnMMdFvVyUPWPlriQDvg1FWfw16ftd8wj1BFY/D+/kCA4CiaiKKK1p9u+qt437k3fv+JeY9DDYPKsiysApMTEOq2ux7mssqdrdYiJ4IpNn0WLFmHmzJlYtmwZ5s+fj5UrV6KoqAhTpkzB+PHjER0dje7ubhw5cgQHDhxwdJwtLCzExo0bg2/7mzMb4NUoD2+62BLRkDwda9dq7EBJxW4AgAAB9+VfF/SrnOQdURTR0d7ltljva0hnaO30+PrDknUuI96cV9xTshIRo4ny4XcT3JhzePn6EMSiXg5OY+0upAP+5vv/4mj+UbTyeqTlXNi5OAo+oiiisatryBntXRbPurgqBAFpsZoBHeP7VtnTNFpEqfgj4kLk5OTggw8+QGlpKTZt2oRdu3Zh06ZNLlsJBUFAXl4e5s6di6VLl4ZEx1k2rSEKXGnJOqgjVDCaLRe0Ur/pu13osNh3ct2Q+T3kxWVIFSIFCFEU0d7cMeS4ty6DZ7v7BEFAQmqcvQHdCPsZ9r6GdMNH2Me9qaMHX2mmgZhzeP76UMSMXQaCIg6iIhmwNQLW4+f1mq93H8Znb+8HACSkxuPWNT+WMkTyE6vNhoauzt5O8YaBhbtBD5PVsy6uKoUC6X0z2t2Me0uN1SCC/RgkUVBQgGeeeQYA0NHRgYqKChiNRqjVauTm5kKj0cgcIRGFC6VCgRFpw/Dd6UZU17fBbLEiQjX0z/7v9GfwdpU954hVqrF0LEfYhQKbzYa2BvuM9vrq5t5GdE4N6apbYOwyeXRthVKBpPR4t+fZ7TPahyEikmWHFJhzEMCiXj6q0YCpEbC1QLS1QFAkDPqlVovrCLs7/jAPMdpoPwRJ3jJbragbakZ7hwEWm2f7gCKVSqdu8f3b4zO0WmTq4pASEwtlAHdxDRcajQaTJk2SOwxp8XwbUUDLyUjEd6cbYbWJqKprxajMpEG/VhRFrC/7B2y93X8Wjr4SSWrvZ2KT9KxWG5rPtKGhynU2u+N8e3ULLCaLR9dWRSiRnNF3hj1hQEO6pLR4KM9xs4ikx5zjPF8fgljUy0WVC5j22j+2HAciBy/q3y/5CJWHTwMAxk4ZjWtuu8IfEdJ5MFotqO0d9+bcMb6vMd2Zzg7YPO3iqooYctxbUkyMrDPaiRwC+BdsS0sL7rnnHrz77rtQKBQoKirC008/fc6Viz179uDBBx/Evn37oFQqMWnSJHz44YeIjuYNVQo+2Wedqx+qqP9XQxkOtJwAAGREJ+DW7PNv5kvSspitaKxpcS3Ye8+y11c1o6m2FVaLhwsFURGDjntLyUpAwvC4gB73RmGEOYdbLOplMqADfuSlbr+uo60Tr/zuDcfzpU8t4A9VP+o2m11Gvbmcbdfr0dDleUMYbaTapWO8a9GuxbCowJ7RThQM5s+fjzNnzmDnzp0wm81YuHAh7rrrLmzdunXQ1+zZsweFhYVYs2YNnn32WahUKhw6dIg/eyloZTuNtTtZ0zLo15msFjx99H3H83vzZiNSyVTRX0w9ZjTUuBv3Zv+zpa4NNptnBUl0rNppdT3BpXBPyUxEfLKWOQeRl+TMOfiTWi5K5w74FYM2cXzt4TfR3mQf/3HlLT/ART/I80Nw4cNgMro0nTt73Ftzd7fH1x4WFTXkuLc4Nbu4UogI0LvmZWVl2LFjB/bv348pU6YAAJ599lnMmTMHTzzxBNLT092+buXKlVi+fDlWr17t+Ny4ceMkiZHIH863A/4bpz5HdZe96J+SMApXDi+QPLZw0tNpRP1Zq+vOneRbG/QeX1sTF9NbqCe4/tk37i0+hkU7hQbmHG6xqJdL71i7jk4bKsq/gDlq34CGFlXlNXj7TzsAAOroSCx+bL5s4QYjURTRbuxxXWXX6122yrcbPZ/RnhQd09t4TotMbZxj1Ftf0R47xLxQopASoONl9uzZg/j4eMcvVwCYNWsWFAoF9u3bhx//eGDD0YaGBuzbtw/z58/H9OnTcfz4ceTl5WHt2rW4/PLLpQmUSGJZw+OhVCpg6unGV199hX37kgfkHM1GA16s+BgAoOAIO4906rsdq+z1Vc4r7vaGdPrmDo+vHZekddoe77RNPtNevMfqeDSIwgRzDrdY1MugtLQUzz33HHZ9eAblFR0QxeMA3gVgHz0xbtw4XHPNNTB+o4DVYu98/tNf34iUEckyRh14RFFEc3e3Yzu8u3FvHWbPurgKAFI1mgHz2ftW29M1WkSpOKOdyJf0etdVKrVaDbVa7fH16urqkJKS4vI5lUqFhIQE1NXVuX3NiRP2s8S///3v8cQTT2DSpEl49dVXMXPmTHz77bcYM2aMx/EQyaFv3FXZjr+itakWEEV88PJDAFxzDlw9Gp1qIwDgR1mXYowuTc6wA44oijC0dg5YXXd+3qn3fHdfwvC4/mK9d3Xd0ZAuIwFRsZ7/LCSigUIt52BR70eVlZVYtmwZduzYgZSUFBQV/QL3r7kUBQUFiImJQVdXF0pLS7F//3688cY2NDY2IFmRhmkpV+Bn998kd/h+ZxNFNPaOe6s+a8xbXxHfY/Gsi6tSEJDWN+5NF4cMjb1jfN9qe6pGi0iOeyM6L76aGZuVleXy+Yceegi///3vB3z96tWr8cc//nHIa5aVlXkUi613GsUvf/lLLFy4EAAwefJkfPTRR3jxxRexbt06j65L5G9n5xy33FyESy91n3Ns27YNDc82IH7KaIy75wYsuXqW3OH7nSiKaGs0uC3W+xrT9XQZPbq2QiEgMS3esbp+9op7ckYCIqO4UEB0PphzuMei3k9KSkqwYsUKJCUlYcuWLbj55psR6WZ79rRp07Bw4UJs2LAB27dvx/2/uR8ftfwdW15/DYsWLZIhculYbDbUdXSgpmOQcW8GA0w2z2a0RyqUSNdq3c5nz9DqMDxWAxWbXhH5ho/Ot1VVVUGn0zk+Pdgd81WrVmHBggVDXnLUqFFITU1FQ0ODy+ctFgtaWlqQmprq9nVpafbVyYIC17PE+fn5OH369JDvSRQoPM45Vv8Wh5b+L94yjQ+5nMNqtaGlvt1tE7qG3hntph6zR9dWqhT2cW9ZzuPe+se+JaUPgyqCCwVEPsGcwy0W9X6wdu1aFBcXY9GiRVi/fj202nPPe42MjMS8efNwww03YOXKlVi8eDHq6+vx4IMP+iFi3zBZrTjTYXAU7Gevttd1GGD18B9llEp11pi3/uI9U6tDckwsx70RBRmdTufyC3YwycnJSE4+93Gkyy67DG1tbfjyyy9xySWXAAB2794Nm82GadOmuX1NdnY20tPTUV5e7vL5Y8eOYfbs2efxXRDJK1xzDqvFiqbaVtSftbreN6e9qaYVFrNnCwURahVSMhKQMqL/DHv/6LcEJKTaexYQUfAItZyDRb3ESkpKUFxcjEceeQTFxcUuf9fR0YHHH38c+/btwxdffIHW1la89NJLLneDtFotSkpKMHLkSBQXFyM1NRV33nmnn78L93osZtQ4ZrQ7rbZ32M+013d2wNP7aJqIyEHns2dodUiM5rg3ooBhEwHBi7vmHo5oOpf8/HwUFhZi8eLF2LRpE8xmM+6++27ccsstji60NTU1mDlzJl599VVMnToVgiDgN7/5DR566CFMnDgRkyZNwiuvvIKjR49i+/btksRJ5CuhnHOYjGY01bT2r7JX922TtzekazrTBpvVsw5Y6pjIs1bZXee0xydrOdKSKFAw53CLRb2EKisrsWLFCixatGjAL1cAaGpqwsMPP4wRI0Zg4sSJ+OSTTwa9VnFxMU6fPo17770XV199NXJyciSM3K7TZDprxFt/1/hqfTuaurs8vnacOmrAmLe+51naOOjUahbtRMEiQMfLAMCWLVtw9913Y+bMmVAoFCgqKsIzzzzj+Huz2Yzy8nJ0dfX/PFuxYgV6enqwcuVKtLS0YOLEidi5cydGjx4tWZxE3gr2nKOny4TGGqfVdZexb81oqddD9PBnRYw2ym2x3rfirkuIZc5BFCyYc7gliJ7+hKRzmj17NsrKynD48GG329+MRiNaW1uRmpqKAwcO4NJLLx1w19yZXq/HhAkTUFBQgA8++MDr+NqNPWeNeXMe96ZHa4/n494So6OHnNGujWQXV6Jgp9frERcXh1mjlkOl8PzftMVmxK4Tz6C9vf28tsIR0UCBnnN0dfQ4CvYB3eOrW9DWaPD42rqEWDcFewKGZyUhJSsBmrgYr+MnInkx5xgaV+olUlpaih07dmDLli2DnmdTq9WDNk5wR6fTYd26dZg/fz7KysqQn58/6NeKoojWnm6XTvHVer3LuXaDybMurgAwPFbjmM8+oHDX6BAdwS6uRERE/hAIOUdHe1f/6rrTWfa+Ar6jzfPdfcOSdWcV665j36I1UR5fm4goFLCol8imTZuQkpKCm2++2afXLSoqwsqVK7Fx40b8v8cec6yqnz2fvdrQjm4Px70pBAFpsRq3XeMztTqkabVQK/mfDhH1CuCtcEThwB85xyMP/WHIcW/dHZ7t7hMEAQmpcQO3xfeeb0/OSIA6emDnfiIKU8w53GJlJpGdO3eiqKjI7QgZb6jVahQVFeHFv76Fd/OyPbpGhEKBNE3fKrt2QOGeGqtBBGe0E9H5somAx20xIVnTGqJwIXXO8doLb6DiDc/GvSmUCiSlxw9YXe87456cMQwRkUxHieg8Medwiz9FJWAwGFBeXo77779fkutPmTIFz23aBJvRCIWbmYqRSqXLyrpji3zvmfaUmFgo2cWViIgo6Pkj59j03CZYYsxQCQOP1qkilEjpHfPmrnt8Ulo8lCouFBARSYlFvQSOHz8OURRRUFAgyfXHjx8PiCImqdSYeNFER/O5vuI9KSaGM9qJyH9Em/3hzeuJyCP+yDlEiBj5vURMvHjigNX2YSk6jnsjIv9hzuEWi3oJGI32BnQxMdJ0W42OjgYAPDjtckybNk2S9yAiOm8830YkG3/lHIsfKWLOQUTyY87hFm+tSkDduyXeeQahL3V3d7u8DxEREYUn5hxERMSiXgK5ubkQBAGlpaWSXP/IkSMQBAG5ubmSXJ+I6ILYRO8fROQR5hxEFFaYc7jF7fcS0Gg0GDduHPbv34+FCxcO+bV/+tOf0NbWhtraWgDAu+++i+rqagDAPffcg7i4uAGvOXDgAPLy8qDRaHwfPBHRheJWOCLZMOcgorDCnMMtQRRD9DuT2fLly7Ft2zZUVVUNOWImOzsbp06dcvt3lZWVyM7Odvmc0WjEiBEjMHfuXDzzzDO+DJmI6ILo9XrExcVhVvovoVJ4vjXXYjNiV+3/or29HTqdzocREoUH5hxEFOqYcwyN2+8lsmTJEjQ0NGD79u1Dft3JkychiqLbx9m/XAHgrbfeQkNDA5YuXSpR5EREF0hE/51zjx5yfwNEwY05BxGFDeYcbrGol0hBQQEKCwvxwAMPwGAw+OSaer0ea9asQWFhIfLz831yTSIir3n1y9XLbXRExJyDiMIHcw63WNRLaOPGjWhqasJ9993n9bVEUcSqVavQ3NyMjRs3+iA6IiIfsdm8fxCRV5hzEFFYYM7hFot6CeXk5GDDhg0oKSnBo48+6vF1RFHEo48+ipKSEjz99NPIycnxYZREREQU7JhzEBGFL3a/l9iiRYtQX1+P4uJinDp1CuvXr4dWqz3v1+v1eqxatQolJSVYu3Yt7rzzTgmjJSLyADvREgUE5hxEFPKYc7jFlXo/ePDBB7F582a8/vrruOiii7B161aYTKYhX2M0GrF161ZMmDABr7/+OkpKSvDAAw/4KWIiogvA821EAYM5BxGFNOYcbnGknR9VVlZi2bJl2LFjB1JSUlBUVIQpU6Zg/PjxiI6ORnd3N44cOYIDBw44Os4WFhZi48aN3P5GRAHHMV4m6Q6oFIOP0ToXi82EXU0vhtx4GSI5MecgolDCnGNoLOplUFpaik2bNmHXrl04evQonP8vEAQBeXl5mDVrFpYuXcqOs0QUsBy/YBMWev8LtuWlkPsFSxQImHMQUShgzjE0nqmXQUFBAZ555hkAQEdHByoqKmA0GqFWq5GbmwuNRiNzhERE508UbRBFz7vJevNaIhoacw4iCiXMOdxjUS8zjUaDSZMmyR0GERERhTjmHEREoYlFPREReUcUARs70RIREZHEmHO4xaKeiIi8I4oA+AuWiIiIJMacwy2OtCMiIiIiIiIKUlypJyIi79hsgOBF45kQbVpDREREPsacwy0W9URE5B1uhSMiIiJ/YM7hFot6IiLyimizQfTirnmojpchIiIi32LO4R7P1BMREREREREFKa7UExGRd7gVjoiIiPyBOYdbLOqJiMg7NhEQ+AuWiIiIJMacwy1uvyciIiIiIiIKUlypJyIi74giAG/Gy4TmXXMiIiLyMeYcbrGoJyIir4g2EaIXW+HEEP0FS0RERL7FnMM9br8nIiIiIiIiClJcqSciIu+INni3FS40Z8YSERGRjzHncItFPREReYVb4YiIiMgfmHO4x+33REREREREREGKK/VEROQVi2j0ajubBWYfRkNEREShijmHeyzqiYjII5GRkUhNTcV/6t73+lqpqamIjIz0QVREREQUaphzDE0QQ/VgARERSa6npwcmk8nr60RGRiIqKsoHEREREVEoYs4xOBb1REREREREREGKjfKIiIiIiIiIghSLeiIiIiIiIqIgxaKeiIiIiIiIKEixqCciIiIiIiIKUizqiYiIiIiIiIIUi3oiIiIiIiKiIMWinoiIiIiIiChI/X/qIY3A/FEX+AAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -851,7 +842,7 @@ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", "\n", "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", " vmin=vmin, vmax=vmax, **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -860,7 +851,7 @@ "\n", "\n", "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", " vmin=vmin, vmax=vmax, **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", diff --git a/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb b/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb index e4471ec0..d17f3b7b 100644 --- a/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb +++ b/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": { "id": "N2YCQeyY50Xg" }, @@ -57,28 +57,9 @@ "## Basics" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For testing, we need to set the path right. **This is to be removed by code reviewers**." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n" - ] - }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -86,9 +67,20 @@ "id": "NaG9OvVp-Ryf", "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): JAX backend enabled.\n" + ] + } + ], "source": [ "# Import a backend, we use jax in this example.\n", + "import numpy as np\n", "import jax\n", "import jax.numpy as jnp\n", "from jax.random import PRNGKey\n", @@ -130,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -154,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -170,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -187,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -240,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -284,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -324,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -368,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -395,11 +387,11 @@ "\n", "Up Hodge Laplacian:\n", " [[ 1. -1. 0. 1. 0. 0.]\n", - " [-1. 1. 0. -1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", + " [-1. 1. -0. -1. -0. -0.]\n", + " [ 0. -0. 0. 0. 0. 0.]\n", " [ 1. -1. 0. 1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]]\n" + " [ 0. -0. 0. 0. 0. 0.]\n", + " [ 0. -0. 0. 0. 0. 0.]]\n" ] } ], @@ -435,7 +427,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -457,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -486,7 +478,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -522,16 +514,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n" + "[[0]\n", + " [1]\n", + " [2]]\n" ] } ], @@ -552,7 +544,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -569,12 +561,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -628,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -646,7 +638,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -665,7 +657,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -685,7 +677,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -698,7 +690,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -715,7 +707,7 @@ "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", "# shade the area of the triangle\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", @@ -725,7 +717,7 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", " vmin=values_32.min(), vmax=values_32.max(), \n", " **options)\n", "# add a label at the base edge \n", @@ -738,7 +730,7 @@ "\n", "\n", "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -747,7 +739,7 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", " vmin=values_inf.min(), vmax=values_inf.max(),\n", " **options)\n", "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", @@ -781,7 +773,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -836,7 +828,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -864,7 +856,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -872,19 +864,19 @@ "output_type": "stream", "text": [ "xs (shape = (3, 1)):\n", - "[[3]\n", - " [5]\n", - " [4]]\n", + "[[0]\n", + " [1]\n", + " [2]]\n", "\n", "emedding (shape = (3, 6)):\n", - "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 -1.29344481e-01\n", - " 5.15670639e-02 1.39200889e-01]\n", - " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 -1.59503941e-16\n", - " -6.37403964e-02 7.76266537e-16]\n", - " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 7.99392856e-02\n", - " -8.34372621e-02 9.36873407e-17]]\n", + "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 1.39200889e-01\n", + " 1.29344481e-01 5.15670639e-02]\n", + " [ 2.80674635e-01 1.02621639e-17 1.32945672e-01 -1.39200889e-01\n", + " 1.74707239e-17 1.03134128e-01]\n", + " [-4.21011953e-01 2.21501771e-01 -4.10824721e-02 -7.22120964e-17\n", + " 7.99392856e-02 8.34372621e-02]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.277421474636178e-17\n" ] } ], @@ -924,7 +916,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -932,9 +924,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-0.12815855 0.03939647]\n", - " [-0.35448662 0.8352028 ]\n", - " [-0.08106564 -0.25947495]]\n" + "[[ 0.24385954 -0.46621535]\n", + " [ 0.61691489 -0.26225356]\n", + " [-1.16522011 0.33173476]]\n" ] } ], @@ -964,12 +956,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -995,7 +995,7 @@ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", "\n", "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", " vmin=vmin, vmax=vmax, **options)\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -1005,7 +1005,7 @@ "\n", "\n", "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", " vmin=vmin, vmax=vmax, **options)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", diff --git a/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb b/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb index 014182ad..be07577c 100644 --- a/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb +++ b/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb @@ -27,7 +27,7 @@ "\n", "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", "\n", - "We use the **numpy** backend here.\n", + "We use the **PyTorch** backend here.\n", "\n", "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." ] @@ -57,28 +57,9 @@ "## Basics" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For testing, we need to set the path right. **This is to be removed by code reviewers**." - ] - }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -95,23 +76,12 @@ "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", "INFO (geometric_kernels): Torch backend enabled.\n" ] - }, - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'geometric_kernels.spaces.graph_edge'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[3], line 14\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mtorch\u001b[39;00m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m# from geometric_kernels import jax\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# Import a space and an appropriate kernel.\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mspaces\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgraph_edge\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m GraphEdge\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgeometric_kernels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mkernels\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m MaternGeometricKernel\n\u001b[1;32m 17\u001b[0m \u001b[38;5;66;03m# We use networkx to visualize graphs\u001b[39;00m\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'geometric_kernels.spaces.graph_edge'" - ] } ], "source": [ - "# Import a backend, we use jax in this example.\n", + "# Import a backend, we use torch in this example.\n", "import torch\n", - "\n", + "import numpy as np\n", "# Import the geometric_kernels backend.\n", "import geometric_kernels\n", "\n", @@ -148,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -172,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -242,7 +212,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -254,26 +224,26 @@ "nodes: [1, 2, 3, 5, 4]\n", "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", "incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", + " tensor([[-1., -1., -1., 0., 0., 0.],\n", + " [ 1., 0., 0., -1., 0., 0.],\n", + " [ 0., 1., 0., 1., -1., 0.],\n", + " [ 0., 0., 1., 0., 0., -1.],\n", + " [ 0., 0., 0., 0., 1., 1.]], dtype=torch.float64)\n", "\n", "\n", "edge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n" + " tensor([[ 2., 1., 1., -1., 0., 0.],\n", + " [ 1., 2., 1., 1., -1., 0.],\n", + " [ 1., 1., 2., 0., 0., -1.],\n", + " [-1., 1., 0., 2., -1., 0.],\n", + " [ 0., -1., 0., -1., 2., 1.],\n", + " [ 0., 0., -1., 0., 1., 2.]], dtype=torch.float64)\n" ] } ], "source": [ "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", - "incidence_matrix = torch.tensor(incidence_matrix, dtype=torch.float32)\n", + "incidence_matrix = torch.tensor(incidence_matrix)\n", "edge_graph = GraphEdge(incidence_matrix)\n", "print('nodes:', G.nodes)\n", "print('edges:', G.edges)\n", @@ -305,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -327,7 +297,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -356,16 +326,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "params[\"lengthscale\"] = torch.array([2.0])\n", + "params[\"lengthscale\"] = torch.tensor([2.0])\n", "params_32 = params.copy()\n", "params_inf = params.copy()\n", "del params\n", - "params_32[\"nu\"] = torch.array([3/2])\n", - "params_inf[\"nu\"] = torch.array([torch.inf])" + "params_32[\"nu\"] = torch.tensor([3/2])\n", + "params_inf[\"nu\"] = torch.tensor([torch.inf])" ] }, { @@ -392,22 +362,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n" + "tensor([[4],\n", + " [2],\n", + " [1]], dtype=torch.int32)\n" ] } ], "source": [ "key = torch.Generator()\n", - "key.manual_seed(1234)\n", + "key.manual_seed(124)\n", "\n", "key, xs = edge_graph.random(key, 3)\n", "\n", @@ -423,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -440,12 +410,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -499,7 +469,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -517,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -536,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -545,6 +515,26 @@ "variance_inf = kernel.K_diag(params_inf, other_edges)" ] }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.1752, 0.2034, 0.1516, 0.1752, 0.1516, 0.1430], dtype=torch.float64)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "variance_32" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -556,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -569,7 +559,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -581,12 +571,10 @@ "source": [ "cmap = plt.get_cmap('viridis')\n", "\n", - "# Set the colorbar limits:\n", - "\n", "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", @@ -594,7 +582,7 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", " vmin=values_32.min(), vmax=values_32.max(), \n", " **options)\n", "# add a label at the base edge \n", @@ -606,7 +594,7 @@ "\n", "\n", "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", @@ -614,7 +602,7 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", " vmin=values_inf.min(), vmax=values_inf.max(),\n", " **options)\n", "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", @@ -648,7 +636,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -703,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -731,27 +719,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "xs (shape = (3, 1)):\n", - "[[3]\n", - " [5]\n", - " [4]]\n", + "xs (shape = torch.Size([3, 1])):\n", + "tensor([[4],\n", + " [2],\n", + " [1]], dtype=torch.int32)\n", "\n", - "emedding (shape = (3, 6)):\n", - "[[-4.17448397e-02 3.83051484e-01 1.08504235e-01 -5.26867410e-02\n", - " 1.02519158e-01 -4.08723427e-02]\n", - " [ 3.28045722e-01 -6.11498784e-02 2.26833021e-16 -1.70497875e-01\n", - " -9.57952499e-17 5.05209940e-02]\n", - " [-3.28045722e-01 6.11498784e-02 1.75563540e-01 -3.25621967e-02\n", - " -6.33603240e-02 6.61328397e-02]]\n", + "emedding (shape = torch.Size([3, 6])):\n", + "tensor([[-1.8151e-01, 2.8001e-01, 1.7556e-01, 3.2562e-02, 6.3360e-02,\n", + " 6.6133e-02],\n", + " [ 1.8151e-01, -2.8001e-01, 1.7556e-01, -3.2562e-02, 6.3360e-02,\n", + " -6.6133e-02],\n", + " [ 1.8856e-01, 3.8734e-01, -7.2911e-17, 1.0537e-01, 7.5690e-17,\n", + " -8.1745e-02]])\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.163336342344337e-17\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(4.9422e-08)\n" ] } ], @@ -791,7 +779,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -799,9 +787,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[ 0.36024923 -0.21070873]\n", - " [-0.02141462 -0.21293585]\n", - " [-0.14648103 0.75575338]]\n" + "tensor([[-0.4017, 0.2195],\n", + " [ 0.1529, 0.2334],\n", + " [-0.3671, 0.2540]])\n" ] } ], @@ -832,12 +820,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -864,7 +852,7 @@ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", "\n", "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", " vmin=vmin, vmax=vmax, **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -873,7 +861,7 @@ "\n", "\n", "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", " vmin=vmin, vmax=vmax, **options)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", diff --git a/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb b/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb index ed573640..ba3a5ab2 100644 --- a/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb +++ b/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": { "id": "N2YCQeyY50Xg" }, @@ -57,28 +57,9 @@ "## Basics" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For testing, we need to set the path right. **This is to be removed by code reviewers**." - ] - }, { "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -86,11 +67,21 @@ "id": "NaG9OvVp-Ryf", "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): Torch backend enabled.\n" + ] + } + ], "source": [ "# Import a backend, we use jax in this example.\n", "import torch\n", - "\n", + "import numpy as np\n", "# Import the geometric_kernels backend.\n", "import geometric_kernels\n", "\n", @@ -127,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -151,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -167,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -184,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -237,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -281,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -321,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -331,20 +322,20 @@ "output_type": "stream", "text": [ "incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", + " tensor([[-1., -1., -1., 0., 0., 0.],\n", + " [ 1., 0., 0., -1., 0., 0.],\n", + " [ 0., 1., 0., 1., -1., 0.],\n", + " [ 0., 0., 1., 0., 0., -1.],\n", + " [ 0., 0., 0., 0., 1., 1.]])\n", "\n", "\n", "edge triangle incidence matrix:\n", - " [[ 1.]\n", - " [-1.]\n", - " [ 0.]\n", - " [ 1.]\n", - " [ 0.]\n", - " [ 0.]]\n" + " tensor([[ 1.],\n", + " [-1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])\n" ] } ], @@ -367,7 +358,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -375,30 +366,30 @@ "output_type": "stream", "text": [ "Hodge Laplacian:\n", - " [[ 3. 0. 1. 0. 0. 0.]\n", - " [ 0. 3. 1. 0. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [ 0. 0. 0. 3. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", + " tensor([[ 3., 0., 1., 0., 0., 0.],\n", + " [ 0., 3., 1., 0., -1., 0.],\n", + " [ 1., 1., 2., 0., 0., -1.],\n", + " [ 0., 0., 0., 3., -1., 0.],\n", + " [ 0., -1., 0., -1., 2., 1.],\n", + " [ 0., 0., -1., 0., 1., 2.]])\n", "\n", "\n", "Down Hodge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", + " tensor([[ 2., 1., 1., -1., 0., 0.],\n", + " [ 1., 2., 1., 1., -1., 0.],\n", + " [ 1., 1., 2., 0., 0., -1.],\n", + " [-1., 1., 0., 2., -1., 0.],\n", + " [ 0., -1., 0., -1., 2., 1.],\n", + " [ 0., 0., -1., 0., 1., 2.]])\n", "\n", "\n", "Up Hodge Laplacian:\n", - " [[ 1. -1. 0. 1. 0. 0.]\n", - " [-1. 1. 0. -1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 1. -1. 0. 1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]]\n" + " tensor([[ 1., -1., 0., 1., 0., 0.],\n", + " [-1., 1., -0., -1., -0., -0.],\n", + " [ 0., -0., 0., 0., 0., 0.],\n", + " [ 1., -1., 0., 1., 0., 0.],\n", + " [ 0., -0., 0., 0., 0., 0.],\n", + " [ 0., -0., 0., 0., 0., 0.]])\n" ] } ], @@ -434,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -456,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -485,16 +476,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "params[\"lengthscale\"] = torch.array([2.0])\n", + "params[\"lengthscale\"] = torch.tensor([2.0])\n", "params_32 = params.copy()\n", "params_inf = params.copy()\n", "del params\n", - "params_32[\"nu\"] = torch.array([3/2])\n", - "params_inf[\"nu\"] = torch.array([torch.inf])" + "params_32[\"nu\"] = torch.tensor([3/2])\n", + "params_inf[\"nu\"] = torch.tensor([torch.inf])" ] }, { @@ -521,16 +512,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n" + "tensor([[3],\n", + " [3],\n", + " [0]], dtype=torch.int32)\n" ] } ], @@ -552,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -569,12 +560,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -628,7 +619,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -646,7 +637,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -665,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -685,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -698,7 +689,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/UAAAMPCAYAAACUsvWGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wU5dbA8d9sTd0lkEJoIYAECAGpActVryhgRQFpiiJFQVTAhkjxUhQUERUVpSheQVEQy1Wx8IINQYpI7wFCSUKA9GTrvH+kSCRAstlks7vnez/zuWF2ypm42T3PzPOcR1FVVUUIIYQQQgghhBBeR+PpAIQQQgghhBBCCOEaadQLIYQQQgghhBBeShr1QgghhBBCCCGEl5JGvRBCCCGEEEII4aWkUS+EEEIIIYQQQngpadQLIYQQQgghhBBeShr1QgghhBBCCCGEl5JGvRBCCCGEEEII4aWkUS+EEEIIIYQQQngpadQLIYQQQgghhBBeShr1QgghhBBCCCGEl5JGvRu8//77KIrCkSNHPB1KlcjJyUGj0fDqq696OpTLeumll2jRogVOp7Nazzt//nwaNWqExWIp9z6bNm3iqquuIjg4GEVR2LZtW9UFWE418b38/PPPoyiKp8MQQgi/447vBG/JITyVP5TFV3IKqHl5heQUwlf5XKP+jjvuICgoiOzs7ItuM2jQIAwGA2fOnKnGyLzXzp07UVWV1q1bezqUS8rKymLWrFk888wzaDTV+9Z+4IEHsFqtvPPOO+Xa3maz0bdvX86ePcurr77Kf//7X2JiYqo4SiGEENWpuEGzefPmUuszMzPp3LkzAQEBrF692kPRVQ9vyCHKyh9ycnKYMmUKPXr0oHbt2iiKwvvvv18t8UhOIYSoKJ9r1A8aNIj8/HxWrVpV5ut5eXl88cUX9OjRgzp16rjlnPfddx/5+fk++wG6Y8cOABISEjwcyaUtXrwYu93OgAEDqv3cAQEB3H///cyZMwdVVS+7/aFDhzh69ChPPvkkI0aM4N577yUsLKwaIr00X38vCyGEp2VlZXHzzTezfft2Vq1aRY8ePTwdUpXyhhyirPwhPT2dqVOnsmfPHtq2bVut8fhKTgGSVwhRXXyuUX/HHXcQGhrKsmXLynz9iy++IDc3l0GDBlX6XLm5uQBotVoCAgJ8tjvPjh07CA8Pp27dup4O5ZLee+897rjjDgICAjxy/nvuuYejR4+ydu3ay26blpYGQK1atdx2/uL3Y2X4+ntZCCE8KTs7m+7du7Nt2zZWrlxJz5493XJcd3z+VxVvyCHKyh+io6M5deoUR48e5eWXX672mHwhpwDJK4SoLj7XqA8MDOTuu+9mzZo1JR9y51u2bBmhoaHccccdABw9epRRo0YRFxdHYGAgderUoW/fvheM/Skeg7N7924GDhxIWFgY11xzDVD2eKGKHvfgwYM88MAD1KpVC7PZzJAhQ8jLyyu17YkTJxg6dCj16tXDaDQSGxvLyJEjsVqtpbZ58MEHiYqKwmg0Eh8fz+LFi8v8Xe3du5djx45d9ne6Y8cO4uPjS61bsGABBoOBMWPG4HA4LnuMqpaUlMT27dvp1q2bx2Lo0KEDtWvX5osvvrjkdg888ADXXXcdAH379kVRFK6//noA/vzzT3r27InJZCIkJIQbb7yRDRs2XHCMS70fK6Os93JF3qMXU9735a+//kqnTp0ICAigadOmF+16uG7dOjp27Fhqu4uNkyvPubOzsxkzZgyNGzfGaDQSGRnJTTfdxNatW8t1fUIIcTk5OTn06NGDrVu3snLlSm699dZSr5f3c/Jin/8V/ayuSL7wT+XNH6Dm5xAXyx+MRqNHb0S4I6eA8uUVVZVTwIV5RU3MKUDyCuH9dJ4OoCoMGjSIJUuW8MknnzB69OiS9WfPnuW7775jwIABBAYGAoWFRdavX0///v1p0KABR44c4e233+b6669n9+7dBAUFlTp23759ueKKK3jhhRcu2SWqose95557iI2N5cUXX2Tr1q0sXLiQyMhIZs2aBcDJkyfp3LkzGRkZjBgxghYtWnDixAlWrFhBXl4eBoOB1NRUunTpgqIojB49moiICL799luGDh1KVlYWY8aMKXXOli1bct1117Fu3bpL/j537NhR0iXNbrczZswY3n33Xd58802GDx9+yX2ry/r16wFo3769R+No3749v/322yW3eeihh6hfvz4vvPACjz32GJ06dSIqKopdu3Zx7bXXYjKZePrpp9Hr9bzzzjtcf/31/PTTTyQmJl5wrPK+H93hcu/Riynv+3LHjh3cfPPNRERE8Pzzz2O325kyZQpRUVGljvfnn3/So0cPoqOj+c9//oPD4WDq1KlERES4fO6HH36YFStWMHr0aFq1asWZM2f49ddf2bNnj8ffU0II75ebm0vPnj3ZtGkTK1as4Lbbbiv1ekW/v+HCz//iBxnl+ax25XznK2/+ADU/h6gp+UNZKpNTABXOK/wxpwDJK4SPUH2Q3W5Xo6Oj1a5du5ZaP3/+fBVQv/vuu5J1eXl5F+z/+++/q4D6wQcflKybMmWKCqgDBgy4YPv33ntPBdSkpCSXj/vggw+W2vauu+5S69SpU/LvwYMHqxqNRt20adMFx3U6naqqqurQoUPV6OhoNT09vdTr/fv3V81m8wUxAep11113wfHOd/LkSRVQ58+fr545c0b997//rdauXVtdu3btJferbhMnTlQBNTs726NxjBgxQg0MDLzsdmvXrlUB9dNPPy1Z16tXL9VgMKiHDh0qWXfy5Ek1NDRU/de//lVq/0u9HyujrPdyed+jF1Pe92WvXr3UgIAA9ejRoyXb7N69W9Vqter5H1W33367GhQUpJ44caJk3YEDB1SdTqf+8yOtvOc2m83qI488ctlrEUKIiij+TI2JiVH1er36+eefl7ldRb6/L/b5X5HP6vKer6zvBFUtX/6gqt6RQ5Qnf9i0aZMKqO+99171BaZWLqdQ1fLnFVWVU6jqhe+hmpZTqKrkFcI3+Fz3eygcv9O/f39+//33Ut2Ily1bRlRUFDfeeGPJuuIn9lBYPfTMmTM0a9aMWrVqldlF5uGHHy5XDJU97rXXXsuZM2fIysrC6XTy+eefc/vtt9OxY8cL9lUUBVVVWblyJbfffjuqqpKenl6ydO/enczMzAvOq6rqZe+yb9++veQcnTp14uTJk2zcuLFU166a4MyZM+h0OkJCQkqt37BhA4qi8Pzzz7t87IocIywsjPz8/HJ3ISvmcDj4/vvv6dWrF02aNClZHx0dzcCBA/n111/Jysq6YL/yvh/d8Xu41Hv0Ysr7vnQ4HHz33Xf06tWLRo0alezfsmVLunfvXvJvh8PBjz/+SK9evahXr17J+mbNml0wNrUifxO1atVi48aNnDx50uXfjxBCXExqaioBAQE0bNjwgtdc+f6Gi3/+X+6z2tXz/TPm8jyl94Yc4mL5Q1Uq73eyqzkFuJZX+FtOAZJXCN/hk416oKQQXnHBvOPHj/PLL7/Qv39/tFptyXb5+flMnjyZhg0bYjQaCQ8PJyIigoyMDDIzMy84bmxsbLnOX9Hjnv+hA5RULT137hynT58mKyvrktPBnD59moyMDN59910iIiJKLUOGDAEos8bA5RRXrR09ejRRUVH8/vvvNGvW7ILtRowYQXR0NCaTiYSEBL766qsLttm2bRvt2rXjwQcfpFGjRphMJrp06cLvv/9e4bhqKrWou1pFC8KcPn2avLw84uLiLnitZcuWOJ1OkpOTL3itvO9Hd7jUe/Riyvu+PH36NPn5+VxxxRUXHOP830laWhr5+fllvgf/ua4ifxMvvfQSO3fupGHDhnTu3Jnnn3+ew4cPl+fXIoQQl/XOO+9gMBjo0aMH+/btK/Waq9/fF/v8v9xndVXlC2UpTw4h+cPFuZpTgGt5hb/lFMXbS14hfIFPjqmHwgIjLVq04KOPPmLChAl89NFHqKp6QdX7Rx99lPfee48xY8bQtWtXzGYziqLQv39/nE7nBcc9/wn8pVT0uOffaDhf8Qf65RQf89577+X+++8vc5s2bdqU61jn27FjBzExMTRt2pSdO3eSk5NTZnXVcePG8cYbb2A0Gtm0aRPdunXj8OHDpaYNXL16Nd26dSM0NJRff/2VBg0a8Mknn3D77bdz5MiRSt0lr1OnDna7nezsbEJDQ0vWt2/fnuTkZEwmk8vHrsgxzp07R1BQULnfJ5VV3vO44/fgynu0vO/Lsv4mKqsifxP33HMP1157LatWreL777/n5ZdfZtasWXz22Wduq04thPBfrVq14ptvvuHGG2/kpptu4rfffit5au/q9/fFPv8v91ldVflCWcqTQ9TU/KEqlfc7WXKK0jyZU1Tk/CB5hah+Ptuoh8Kn9ZMmTWL79u0sW7aMK664gk6dOpXaZsWKFdx///288sorJesKCgrIyMio1LndedyIiAhMJhM7d+685DahoaE4HA63VoDfsWMHV155JQsWLKBjx47cdddd/PLLLxdMG9eiRYuSnxVFwWq1cuLEiQu+lGfOnEmXLl1K1vXv359x48axb98+OnTocNE4Fi1axJdffskXX3zB3r176du3Ly+//HLJ/L7F509KSiqVjBgMBho0aFCp30FFjpGUlETLli0rfI6IiAiCgoIueIIDhVWGNRpNmd02y8sdvwdXlPd96XA4CAwM5MCBAxe8dv7vJDIykoCAAA4ePHjBdv9cV9G/iejoaEaNGsWoUaNIS0ujffv2zJgxQ758hRBu0blzZz7//HNuvfVWbrrpJn755ZeSp3xV8f19MdV5vvLkEFWdP8Clc4iL5Q9Vqbzfya7mFFC1eYWv5BQgeYXwHT7b/R7+7oI/efJktm3bVubc9Fqt9oK7gm+88Ualp1hx53E1Gg29evXiq6++YvPmzRe8rqoqWq2W3r17s3LlyjIb/6dPn75g3eWmpHE4HOzZs4eEhAQiIiL47LPP2LlzJyNHjixz+1GjRhEYGEinTp3497//TUJCQslr2dnZ7Nu3j86dO5fa58CBA5w9e7bMbk/n27FjB23atGH9+vX07t2b999/v6RBD9C1a1eAMn8/1Wnr1q1cddVVFd5Pq9Vy880388UXX5SqA5GamsqyZcu45pprKnVH3FPK+77UarV0796dzz//vNR7cs+ePXz33XeljtetWzc+//zzUuPUDh48yLfffuvSuR0OxwVDYiIjI6lXrx4Wi8WFqxZCiLLdeOONfPTRRxw8eJAePXqQlZXl0vd3ZbjjfOWZ0q4iOURV5g9w6RyipuQPZXE1pwDfzCvcnVMUbyt5hfAFPv2kPjY2lquuuqpkjs+yGvW33XYb//3vfzGbzbRq1Yrff/+dH3/8sdQdYle4+7gvvPAC33//Pddddx0jRoygZcuWnDp1ik8//ZRff/2VWrVqMXPmTNauXUtiYiLDhw+nVatWnD17lq1bt/Ljjz9y9uzZUse83JQ0Bw4coKCgoOTLtUOHDrz99tsMGTKEDh06lJouEOCtt97ijTfeYN26dezcubPUGLA1a9Zw3XXXodH8fR8pPz+fe++9l2effRaz2XzJ69+xYwd169blzjvvZOPGjaWKvgA0adKE1q1b8+OPP/Lggw9e9vcJhU8EyjslT3ls2bKFs2fPcuedd7q0//Tp0/nhhx+45pprGDVqFDqdjnfeeQeLxcJLL73klhg9obzvy//85z+sXr2aa6+9llGjRmG323njjTeIj48vKbYEhXPcfv/991x99dWMHDkSh8PBvHnzaN26Ndu2bavwubOzs2nQoAF9+vShbdu2hISE8OOPP7Jp06ZSPW2EEMId7rrrLhYsWMCDDz7IHXfcUfIUuiLf35VV2fOVZ0q7iuQQVZk/wKVziEvlD/PmzSMjI6OksffVV19x/PhxoHCY5fnnrmk5BfhmXuHunAIkrxA+orrK7HvKm2++qQJq586dy3z93Llz6pAhQ9Tw8HA1JCRE7d69u7p37141JiZGvf/++0u2K56C4/Tp0xcco6wpXyp73LKOefToUXXw4MFqRESEajQa1SZNmqiPPPKIarFYSrZJTU1VH3nkEbVhw4aqXq9X69atq954443qu+++e0HcXGZKmk8++UQF1F27dpVaP2rUKFWv16s//fTTRfe97bbb1K+//rrk3w899FCpqWCsVqt66623qgMHDiyZku9SIiIi1GuvvVY1m80XPe+cOXPUkJCQMqcT/Kfs7GwVUPv373/ZbcvrmWeeURs1alSu67nY9DNbt25Vu3fvroaEhKhBQUHqDTfcoK5fv/6C/S/1fqyMS01pV5736MWU9335008/qR06dFANBoPapEkTdf78+SXnP9+aNWvUdu3aqQaDQW3atKm6cOFC9YknnlADAgIqfG6LxaI+9dRTatu2bdXQ0FA1ODhYbdu2rfrWW2+V87cmhBBlK/6cLGs62tmzZ6uAetttt6k2m63cn5MX+0yu6Gd1ec5XmSntXM0h3J0/qOrlc4iL5Q8xMTEqUOZy/u+kpuYUqlq+vKKqcgpVvfiUdjUpp1BVySuE9/P5Rr3wjB49eqivvfZayb9jY2PVkydPqqqqqg6HQ+3Xr19JInM5KSkpakBAgFpQUKBOmDBB7datW5nbZWRkqLVr11YXLlx42WN+/fXXqqIo6vbt28t5RZdWUFCg1q1bV507d65bjicq7s4771SbNWvm6TCEEEJUgjvzB1UtXw5RkfyhLJJT+CbJK4Q38ekx9aJ6ZGZmsmzZMnJycrDb7Xz66aesXbuWf/3rX0Dh2DuTyUR0dDQADz30UMnQAZ2u9AiQBx54gAceeKDUuh07dtCyZUuMRiNjxoxh/fr1bNiw4YI4zGYzTz/9NC+//PJlK5+uXbuW/v37lxq3Vxnvvfceer2+3HO8isrJz88v9e8DBw7wzTff1Ki5j4UQQlyaO/MHcD2HqEj+UBbJKbyf5BXC2ymqWs4504S4iKysLO68807+/PNPVFWlWbNmPPfcc9x9990AzJ07l5SUFGbOnMnRo0dp3LgxAQEBpaYz+fbbb7n22mvp1q0b/fr1Y/jw4SWvvfrqq/z555988MEHADz++OMcPHiQr7/+unovVNQY0dHRPPDAAzRp0oSjR4/y9ttvY7FY+PPPP8ucl1YIIUTN4878AZAcQrhM8grh7aRRL6pcjx49GD9+/GXvdtrtdtq0acNff/2FXq+vnuCEVxoyZAhr164lJSUFo9FI165deeGFF2jfvr2nQxNCCOEm5c0fQHIIUTmSVwhvJ416UeVeeuklxo4dK1+yQgghhCg3yR+EEKJ8pFEvhBBCCCGEEEJ4KSmUJ4QQQgghhBBCeClp1AshhLiogoICsrKyKrUUFBRU+LxvvvlmSVGsxMRE/vjjj4tuu2DBAq699lrCwsIICwujW7dul9z+4YcfRlEU5s6dW+G4hBBCCFE1PJVz+IIL5wMRQgghKPxyjY0JISXNUanj1K1bl6SkJAICAsq1/fLlyxk3bhzz588nMTGRuXPn0r17d/bt20dkZOQF269bt44BAwZw1VVXERAQwKxZs7j55pvZtWsX9evXL7XtqlWr2LBhA/Xq1avUNQkhhBDCfTyVc/gKGVMvhBCiTFlZWZjNZpK2xGAKda1jV1a2k9gOR8nMzMRkMpVrn8TERDp16sS8efMAcDqdNGzYkEcffZTx48dfdn+Hw0FYWBjz5s1j8ODBJetPnDhBYmIi3333HbfeeitjxoxhzJgxLl2XEEIIIdzHUzmHr5An9UIIIS4pOKRwcYWj6LZxVlZWqfVGoxGj0XjB9larlS1btvDss8+WrNNoNHTr1o3ff/+9XOfMy8vDZrNRu3btknVOp5P77ruPp556ivj4eBeuRAghhBBVzR05hz+SMfVCCCGqXMOGDTGbzSXLiy++WOZ26enpOBwOoqKiSq2PiooiJSWlXOd65plnqFevHt26dStZN2vWLHQ6HY899pjrFyGEEEIIUQPJk3ohhBCX5ETFiWu3v4v3S05OLtUVrqyn9O4wc+ZMPv74Y9atW1cynm7Lli289tprbN26FUVRquS8QgghhKg8d+Qc/kie1AshhLgkZyX/B2AymUotF2vUh4eHo9VqSU1NLbU+NTWVunXrXjLO2bNnM3PmTL7//nvatGlTsv6XX34hLS2NRo0aodPp0Ol0HD16lCeeeILGjRtX7pcjhBBCCLdxR87hj6RRL4QQ4pIcqlqppSIMBgMdOnRgzZo1JeucTidr1qyha9euF93vpZdeYtq0aaxevZqOHTuWeu2+++5j+/btbNu2rWSpV68eTz31FN99913FfhlCCCGEqDLVmXP4Eul+L4QQokYZN24c999/Px07dqRz587MnTuX3NxchgwZAsDgwYOpX79+ybj8WbNmMXnyZJYtW0bjxo1Lxt6HhIQQEhJCnTp1qFOnTqlz6PV66tatS1xcXPVenBBCCCGEm0mjXgghxCVV9/i2fv36cfr0aSZPnkxKSgpXXnklq1evLimed+zYMTSavzuavf3221itVvr06VPqOFOmTOH55593KW4hhBBCVD8ZU+8amadeCCFEmUrmjN0bTaiLc8ZmZzuJbXHKL+eMFUIIIUT5SM5ROfKkXgghxCXJXXMhhBBCVAfJOVwjhfKEEEIIIYQQQggvJU/qhRBCXFJlKsr6cyVaIYQQQlSM5ByukUa9EEKIS3IWLa7uK4QQQghRHpJzuEYa9UIIIS7JgYrDxXFqru4nhBBCCP8jOYdrZEy9EEIIIYQQQgjhpWr0k/qcnBwOHjyIxWLBaDTSrFkzQkJCPB2WEEL4FYdauLi6rxDeQHIOIYTwPMk5XFPjGvW7d+9m/vz5/PDDD+zbtw/1vIIHiqIQFxfHTTfdxMMPP0yrVq08GKkQQvgHGd8mfJXkHEIIUbNIzuGaGtP9PikpiZ49exIfH8/y5cu54YYbWLRoERs2bGD79u1s2LCBRYsWccMNN7B8+XLi4+Pp2bMnSUlJng5dCCF8mhMFh4uLE8XT4QtxAck5hBCiZpKcwzWKqnq+9v/ChQsZM2YM4eHhvPDCC/Tp0weDwXDR7a1WKytWrODZZ5/lzJkzzJ07l2HDhlVjxEII4fuysrIwm81s3hVFSKhr94Bzsp10jE8lMzMTk8nk5giFqDjJOYQQouaRnKNyPP6kfsaMGQwfPpwBAwawY8cOBg4ceMkvVwCDwcDAgQPZuXMnAwYMYPjw4cyYMaOaIhZCCCGEN5KcQwghhC/y6Jj6hQsXMnHiRKZNm8bEiRMrvH9oaCgLFiygUaNGTJw4kbp16zJ06NAqiFQIIfxXcbc2V/cVoiaQnEMIIWo+yTlc47En9UlJSYwZM4Zhw4Zd8OW6adMmRo8eTXx8PMHBwTRq1Ih77rmH/fv3l3msiRMnMmzYMB5//HEZ7yaEEG7m6ti2ynwxC+FOknMIIYR3kJzDNR4bU9+zZ0/27NnDjh07CA0NLfVanz59+O233+jbty9t2rQhJSWFefPmkZOTw4YNG2jduvUFx8vKyiIhIYFWrVrx7bffVtdlCCGEzyoe3/brznqVGt92TeuTfjm+TdQcknMIIUTNJjlH5XikUb97927i4+NZunQpAwcOvOD19evX07Fjx1Lj3A4cOEBCQgJ9+vThww8/LPO4y5YtY9CgQezevZuWLVtWWfxCCOEP5AtW+ALJOYQQouaTnKNyPNL9fv78+URGRtKnT58yX7/qqqsuKFxzxRVXEB8fz549ey563N69exMZGcnbb7/t1niFEMKfSVc44c0k5xBCCO8hOYdrPNKo/+GHH+jdu/dlK86eT1VVUlNTCQ8Pv+g2RqOR3r178+OPP7ojTCGEEIADTaUWITxJcg4hhPAeknO4ptqvPDs7m3379tGpU6cK7bd06VJOnDhBv379Lrldx44d2bt3Lzk5OZUJUwghRBFVVXC6uKiq/941F54nOYcQQngXyTlcU+2N+kOHDqGqKq1atSr3Pnv37uWRRx6ha9eu3H///ZfcNj4+HlVVOXjwYGVDFUIIIYQXk5xDCCGEP6j2eeotFgsAQUFB5do+JSWFW2+9FbPZzIoVK9BqtZfcPjAwsNR5hBBCVI7MGSu8leQcQgjhXSTncE21N+qNRiMAeXl5l902MzOTnj17kpGRwS+//EK9evUuu09+fn6p8wghhKgch6rBobrWscvhkUlThSgkOYcQQngXyTlcU+3d75s1a4aiKOzevfuS2xUUFHD77bezf/9+/ve//5W769yuXbtQFIVmzZq5I1whhPB7ThScaFxc/PeuufA8yTmEEMK7SM7hmmpv1IeEhBAXF8emTZsuuo3D4aBfv378/vvvfPrpp3Tt2rXcx9+8eTMtWrQgJCTEHeEKIYQQwktJziGEEMIfeKTu/0033cTKlSuxWq1lvv7EE0/w5Zdf0rNnT86ePcuHH35YarkYi8XCypUr6datW1WFLoQQfkfmjBXeTHIOIYTwHp7IOd58800aN25MQEAAiYmJ/PHHHxfddteuXfTu3ZvGjRujKApz586t9DHdodrH1AM8/PDDvPHGG6xYsYKBAwde8Pq2bdsA+Oqrr/jqq68ueP3ee+8t87grV64kLS2NkSNHujVeIYTwZ5Ub3+bHA9xEjSA5hxBCeI/qzjmWL1/OuHHjmD9/PomJicydO5fu3buzb98+IiMjL9g+Ly+PJk2a0LdvX8aOHeuWY7qDoqqeybh69uzJnj172LFjB6GhoZU+XlZWFvHx8cS3imf1d6vdEKEQQvi3rKwszGYzK/9qTnDopauAX0xutoPebfeTmZmJyWRyc4RClE+V5BytW9OyVUu+X/2dGyIUQgj/5qmcIzExkU6dOjFv3jwAnE4nDRs25NFHH2X8+PGX3Ldx48aMGTOGMWPGuO2YrvJI93uAt956i/T0dMaNG1fpY6mqyrhx40g9mUrdM804m3LODREKIYQQwhdURc6RcjoNx6BrSc6VnEMIIWqSrKysUsvFph21Wq1s2bKl1DAqjUZDt27d+P333106d1Ucszw81qiPjY1l7ty5LFy4kOnTp7t8HFVVmT59OosWLaKFsR0n/kzlkU7j2bfpoBujFUII/+VEg8PFxem5rxkhSlRFzlFvcHdOBjros3Yh69MOuzFaIYTwX+7IORo2bIjZbC5ZXnzxxTLPlZ6ejsPhICoqqtT6qKgoUlJSXIq/Ko5ZHh4ZU19s2LBhpKamMnHiRI4ePcqcOXMq1C0uKyuLcePGsWjRIkYOfYTcDSpnTp7jbOo5xv5rMmPmj+Dm+6+vugsQQgg/IGPqhS9wZ87xyFPjSL46huN558gmj6G/LuWZhJu4v1kiiiLFIYUQwlXuyDmSk5NLdb83Go1uia0m8/gjlOeee44FCxbw0Ucf0bp1a5YtW3bRCrXFLBYLy5YtIyEhgY8//pi5c+cybdZ/mLLySZp3aoLBpMeJg5eHvMlbY97DbrNX09UIIYTvcX2+WHlSL2oWd+Uc/3lmAq937kNinRiCbKCzO3lxx/c8s+ULChy2aroaIYTwPe7IOUwmU6nlYo368PBwtFotqamppdanpqZSt25dl+KvimOWR43ItoYNG8aOHTto1aoVgwYNomHDhowaNYrFixezceNGtm/fzsaNG1m8eDGjRo2iUaNGDBo0iCuuuIKff/65pDKtOdzE0++P5ob+V6MP1qEP0rLq9W94tsd0MtOzPHyVQgjhnRyqUqlFiJrEXTlHiMHI8+1vpX9sB4wOCLCpfHH0Lwb+9D6n8jI9fJVCCOGdqjPnMBgMdOjQgTVr1pSsczqdrFmzhq5du7oUf1Ucszw82v3+fLGxsXz77bfs3r2b+fPn8+OPPzJ//nzOL86voFArMIzeg+7mwQcfpHnz5hccR2/Qc/9/+hHTqgEfTluBorOzbd0uRncez/OrnqZp28bVeFVCCCFc8eabb/Lyyy+TkpJC27ZteeONN+jcuXOZ2y5YsIAPPviAnTt3AtChQwdeeOGFku1tNhsTJ07km2++4fDhw5jNZrp168bMmTOpV69etV2TqDnKk3OgKITUj6TP7bcxYuiwMnMOraJhyBVdaWqK4JUda9DYbOw+d5LeaxfyemIfOobHVONVCSGEqKhx48Zx//3307FjRzp37szcuXPJzc1lyJAhAAwePJj69euXjMu3Wq3s3r275OcTJ06wbds2QkJCaNasWbmOWRU8NqVdeeTk5HDw4EEsFguLx3/EwV+PEWQOZNYPk4hqFHHZ/fdvOcybjy0iIy0La7Ydg0HPk4tHcX2/q6sheiGE8G7F08u8/2dbglycXiYv28ED7f6q0PQyy5cvZ/DgwaXmd/30008vOr/roEGDuPrqq7nqqqsICAhg1qxZrFq1il27dlG/fn0yMzPp06cPw4cPp23btpw7d47HH38ch8PB5s2bXbou4XvOzzkWJf3BT7ZThOqMzOnUm/iw6Mvufzg7nf/8+Q2nCrLI14Oi1TKxbQ8GNOlYDdELIYR381TOATBv3rySBwlXXnklr7/+OomJiQBcf/31NG7cmPfffx+AI0eOEBsbe8ExrrvuOtatW1euY1aFGt2oP9/7kz9m6YyVBIQZeHTeUDrc1LZc+51NOce8RxdxePsxbDl2HFYn/Z/pxQPT+6PVuvaGEUIIf1D8Bbt4a7tKfcE+2P7PapszFsDhcBAWFsa8efMYPHhwmdts2rSJzp07c/ToURo1alT+CxJ+YemhTUzd9g2hVni05XXc1jChXPtlWvN5Yft3bDt7nAId2LQK/Rq3Z+KVPTFoJOcQQoiL8VTO4StqxJj68mjSJgZUQIXkfSfLvV/tumGM//Axru7VGX2IDl2Qlo9nfc6kO2aRk5FbdQELIYSPcHVqmeIFqnfO2Ly8PGw2G7Vr177oNpmZmSiKQq1atcr/ixB+I84cCYqCU4Gk7LPl3s9sCGRG+zu4u1FbAuyF4+yXJ21h8M9LOF2QU4URCyGEb3BHzuGPvObKm7QpHJfmtDs5XoFGPYDBaGDYzEEMnHA3hmA9hlAdm1b/yejEZzm653hVhCuEEOI81Tln7DPPPEO9evVK3Rg4X0FBAc888wwDBgzwuzv5onyamwrffw4FDuekV2hfnUbDQy2u5an4bgShJcgG284k0/v/FrD97ImqCFcIIYSf85pGfXTTKIyBBpwOleT9FWvUAyiKws33X88Ti0YSGhGC0azn5OEUHusygfVfbqqCiIUQwjc4cb0arbPoGMnJyWRmZpYszz77bJXEOnPmTD7++GNWrVpFQEDABa/bbDbuueceVFXl7bffrpIYhPczGQKoF2jGqcCR7DO4MlKxW/0WvNLpbqIMIQTZID0vi0E/v8+qo39VQcRCCOEb3JFz+COvadRrtVpi4hui2lXSjqZTkFd2183Lie8ax5SVT9KoVX2MJj0FBRam9HqJD6etwOn057eCEEKUzVvmjJ09ezYzZ87k+++/p02bNhe8XtygP3r0KD/88IM8pReXFGeOxKGBPIeVtIJsF48RxbwufUkwRxNkA9VmZ/yWL5jx13fYnA43RyyEEN7PHTmHP/KqK2+S0AinQ0VVVU4ePOXycSIbhPPcR2PpfGs7DKE6dIFalkxZzrR75pCXne/GiIUQwvs5VE2llopwdX7Xl156iWnTprF69Wo6dryw2nhxg/7AgQP8+OOP1KlTp0JxCf/T3BSJs2jK48PZFeuCf74wYzAzO/bi1gatCbCD0a7ywcENDP1tKWcteW6KVgghfEN15hy+xKuuPLZNDKqjsAtc8l7XG/UAAUFGRs55gL7jbkcfpMMQquPXzzby+FXPcaISNwyEEEJUzrhx41iwYAFLlixhz549jBw58oI5Y8/vvj9r1iwmTZrE4sWLady4MSkpKaSkpJCTU1iYzGaz0adPHzZv3szSpUtxOBwl21itVo9co6j54sxRqIqCCiTllL9YXlkMGi2Ptbqex1tdT5BTQ5AN/khLos/ahezNKF+tCCGEEOJivKpRX1wsT3WoHN9X+WIziqJw60M3MeadEYTUDsZo1nN0z3FGd36Wzd/LmDchhABwolRqqah+/foxe/ZsJk+ezJVXXsm2bdtYvXp1SfG8Y8eOcerU3zdf3377baxWK3369CE6OrpkmT17NgAnTpzgyy+/5Pjx41x55ZWltlm/fr17fknC58SZC99vhRXwXX9Sf75bGrRmVsdehOuDCLLBqZxz9PtpMd8c3+WW4wshhLer7pzDV+g8HUBFxCYUziXsdKgkH3Df0/S218Uz+dNxvDZqIacOpZKXk8dzt8xg2Mx76fPE7SiK/75BhBCiMl3aXN1v9OjRjB49uszX1q1bV+rfR44cueSxGjdu7FKhM+HfGofUQa/R4tDYOZJzxm3HbR1WjzcS72HqX9+wPyuNfNXG2D9WsicjhTHxN6BVvOp5ixBCuJUncg5f4FVXbg43UTs6DNWukrzvhFuTtLqxUUz6dBxX3hiPIVSPxqDh3af/y8z7Xne5KJ8QQvgCmTNW+COdRsMVoRE4FTiem4HVYXfbsSMCQ3il0910i25BYNE4+3f3/crD6z8my1rgtvMIIYS3kZzDNV535U3aFBbLy83IIyMtw63HDgoJ5LE3h3PHqO7ogrToQ3T837JfGXvtJNKOnXbruYQQQghRszU3R+JQwInK0UqOq/8ng1bHk61v5OG4awlwKgTa4ZeUA/Rdt5BDWZJzCCGEKD/va9QnxKA6Cqeeq2yxvLJoNBrufvxWRr8xlKBaARjNeg79lcQjncaz/efdbj+fEELUdE5VqdQihLeKM0eVVMBPcmMX/GKKonBXTFteaH8HtbUBBNngWNYZ+q5bxJqT+9x+PiGEqOkk53CN1zXqY9vEoDoBFZL3nayy83S8uS2Tlo8jqnEERrOBrHPZPN1tKl+8uVrGZgoh/IqzEt3g/HnOWOH94kyRoChuLZZXlnZ1GvJ6Yl+ahoQTZAOLxcKoDct5c8/POCXnEEL4Eck5XON1V15cAd/pUDl+oOoa9QANmtdj8oonaH1tCwwmPehU5j26iDnD52O12Kr03EIIUVM4VU2lFiG81fkV8A9XwZP680UHmXm1091cF9WsZJz963vW8djGT8mxSW0fIYR/kJzDNV535Q1b1EOr06I6nByvwif1xUJqBTP2nYfo+eC/0Qfp0AfrWL34/3jyhimkn3Tv+DohhBBC1BzhASHUMQbjUOCIm8fUlyVQZ2BCm+482KwrRgcE2lR+OLGH/j8tdvuYfiGEEL7D6xr1eoOehi3q4bSrnDyUis1a9U/MtTot/Z7pxUMvDybQZMBo0rNn4wEe6TSe3Rv2V/n5hfBVOTk5bNu2jY0bN7Jt2zZycnI8HZIogwOlUosQ3qy5KRKnAhnWPM5Zcqv8fIqi0K9JB6a2uw2zxkCwDQ5lpNFn7UJ+TT1U5ecXwldJzuEdJOdwjdc16qGwC77qUHHYHaQcTqu283a9oyMTPhpLnYZhBNQykHE6gyevn8Lqxf9XbTEI4e12797NY489RsuWLTGZTLRr144uXbrQrl07TCYTLVu25LHHHmP3bilMWVNIVzjhz+LMkSXF8g5nV20X/PN1jmjM64l9iQkKI8gGuZZ8hv+2jEX710ttHyHKSXIO7yM5h2u88spjE2Jw2gu/0KqyWF5ZGsc3ZMrKp4jr3BSDSY9TcfLKsLeZ9+gi7Db3zWErhK9JSkqiZ8+exMfHs3z5cm644QYWLVrEhg0b2L59Oxs2bGDRokXccMMNLF++nPj4eHr27ElSUpKnQ/d7Dipz51wI7xZnjsKpKWzVV0UF/EtpEBzGa5370iU8liAb6OxOXtr5I09uXkW+XWr7CHExknN4L8k5XOOVjfriYnmqU+X4/upt1AOY64Ty1HuPcOOga9AH69AHa/nizdU8c/M0Mk5nVns8QtR0CxcuJCEhgT179rB06VKSk5N56623GDJkCImJiSQkJJCYmMiQIUN46623SE5OZunSpezevZuEhAQWLlzo6Uvwa3LXXPizOFNhsTyHAknV+KS+WLDewPPtbmFgk44YHRBgU/nfsR0M/Ok9TuZJziHEP0nO4d0k53CNV155kzaNAFAdnmnUA+j0Ou6bfA9Dpg3AGGLAYNKz/efdPNJpPAf/lLt8QhSbMWMGw4cPZ8CAAezYsYOBAwdiMBguuY/BYGDgwIHs3LmTAQMGMHz4cGbMmFFNEQshxN+amSLQUDit3ZFqflJfTKMo3N+sC5Pa9iQUPUE22JNxit5rF7Ap/ahHYhKiJpKcQ/grr2zU16lXm9CwYJx2tdq73//Tdfd0Zfx/H6V2vVoYzXpOnzjDmGsm8n8f/erRuISoCRYuXMjEiROZNm0aCxYsIDQ0tMztZsyYgaIotG7dutT60NBQFixYwNSpU5k4cSKLFi2qjrDFPzhUTaUWIbyZUaujcWgdHBo4knsWu9PpsViuiWrK3MQ+NAgwE2yFzPxcHvjlvyw9tEnG2Qu/JzmHb5CcwzVeeeWKohBbVCzvXGom2ec8W72yWbsmTFnxBE3bxWI067E77Lw46DUWPPMhDoc/j+4Q/iwpKYkxY8YwbNgwJk6ceNHtjh8/zgsvvEBwcPBFt5k4cSLDhg3j8ccfl/FuHqCi4HRxUf24Eq3wHXFFFfDtTgcn8jI8GktsaB1eT+xLxzoNCbKBYncw9a9veW7rV1gdUttH+CfJOXyH5Byu8cpGPUCT84rlVcd89ZcTFlWL8f8dzbV3J6IP0aEL0vLJy18w8bYXPX7TQQhPGDVqFOHh4cyZM+eS2z355JN06dKFjh07XnQbRVF45ZVXqFOnDqNGjXJ3qOIy5K658Hdx5qiSCvhJ2emeDQYwGQKY2u52ese0I8BeOM5+5ZE/ue+XJaTmZ3s6PCGqneQcvkNyDtd47ZXHtolBdRY16vef8nA0hQxGAw++MJB7J/XGEKzHEKpj8/d/MbrzeI7sSvZ0eEJUm927d7N69WpeeOGFi3Z/A/j5559ZsWIFc+fOvewxTSYTL774IqtXr2bPnj1ujFYIIS4tzhyJqhSOq/dEsbyy6DQaRsRdzdOtbyIYHUE2+OvMcXqvXcC2s8c9HZ4Q1UZyDiG8uFF/frG85H0nPBzN3xRFodu91/H0e49gjgzFaNZz6kgaj3WdwG+f/+Hp8ISoFvPnzycyMpI+ffpcdBuHw8Gjjz7KsGHDSEhIKNdxe/fuTWRkJG+//ba7QhXl4FSVSi1CeLs4c2EFfKdS/dPaXc6N9eKY0+lu6hpCCLbC2bxs7v15CSuO/Onp0ISoFpJz+BbJOVzjtY36mPiGKIqC0+65CviX0iLxCqasfIqY+AYYzXqsVivP3/0yHzz/CU4PFtkRojr88MMP9O7d+5IVZ+fPn8/Ro0eZNm1auY9rNBrp3bs3P/74ozvCFOXkQFOpRQhvVy/QTIjOWKOe1J/vCnMkb3S5hzZh9QiyATY7z239imnbvsXmlNo+wrdJzuFbJOdwjddeeWBwANFNo3A6nBzff6pGFqQLr1+b5z4aS+Kt7QvH2Qdq+e/UT/lP79nkZuV5OjwhqkR2djb79u2jU6dOF93mzJkzTJ48mUmTJhEREVGh43fs2JG9e/eSkyO1KqqL3DUX/k5RFJqbI3EokGbJJsdq8XRIFwgzBvFihzu5vWFCyTj7Dw/9wYO/fshZS66nwxOiSkjO4Xsk53CN1zbqAZq0iUG1q1gLbJw+5vnCNWUxBhp4+JX7ueepOzAE6zCE6lj/xSYe6zqB4wdqRi0AIdzp0KFDqKpKq1atLrrNxIkTqV27No8++miFjx8fH4+qqhw8eLAyYQohRIXEmc4rlpdbM3MOvUbL6JbXMabVDQSiJcgGm04foff/LWR3huQcwvdIziFEIe9u1CfE4HTUrGJ5ZVEUhVuGdWPMuw8TWicYo1lP8r6TjO48nk2rZcyb8C0WS+ETrKCgoDJfP3DgAO+++y6PPfYYJ0+e5MiRIxw5coSCggJsNhtHjhzh7NmzFz1+YGBgqfOIqudEU6lFCF8QZ448rwJ+zeuCf76eDeJ5uUMvIgzBBNkgJTeDAT+9x/+Sd3o6NCHcSnIO3yM5h2u8+spj2zQCFVAhuQZMa3c5ba5tyeQVT9AgLhqjWU9+Xj7P3foiH8/6HFVVPR2eEG5hNBoByMsre4jJiRMncDqdPPbYY8TGxpYsGzduZP/+/cTGxjJ16tSLHj8/P7/UeUTVc6hKpRYhfEGcOQoUBYcCSTkXbwTUFK3Conkj8R5ahUYRbAO71cYTmz7jpR0/4FClto/wDZJz+B7JOVyj83QAlRGbUFgB32l3crwGVcC/lKiYSCZ+Mo6FT/+XLT/uwJ7nYNGzSzn01xGeWDiSgCD50BDerVmzZiiKwu7du0lMTLzg9datW7Nq1aoL1k+cOJHs7Gxee+01mjZtetHj79q1C0VRaNasmVvjFhdXmXFq/jy+TfiW5qZIoLAC/pEaMFd9eYQHBPNyp7t4Y89PfH9yD1ZVZdH+9ezLTGVO596YDYGeDlGISpGcw/dIzuEar27URzeJIiDIiN1hJ3lfze1+/0+BwQE88sZQvnzrOz5/41s0OoV1H/9G8t4TPP/ZU9RtHOnpEIVwWUhICHFxcWzatIkhQ4Zc8Hp4eDi9evW6YH3xvLFlvXa+zZs306JFC0JCQtwQrRBClE+I3kj9oFqkZZ/jcM4ZnKqKRqn5CaRBq2Nc/L9pZopg/r5f0Kgqv6Ueos/ahbzVtR9XmCTnEN5Lcg4hCnl193uNRkPjhEaodpW05HTycws8HVK5aTQaeo3uyWNvDiMoLBCjWc/h7Ud4pNN4tq2VMW/Cu910002sXLkSq9Xq1uNaLBZWrlxJt27d3HpccWmqqsHp4qKqXv01I0QpxePqCxw2UvOzPB1OuSmKwp2N2jCzw53U1gYSZIPj2We5Z91ifjy519PhCVEpknP4Fsk5XOP1V94koVFJsbwTXlhNvn23Nkz6ZBx1m0RgNBvIyczhmZunser1b2ScvfBaDz/8MGlpaaxYsaLc+6xbt46dOy99Q2vlypWkpaUxcuTIyoYoKsCBUqlFCF9RqgJ+DS+WV5a2tRswr0tfrgiJINgGVouFRzZ8whu71+GUnEN4Kck5fIvkHK7x+kZ9bJsY1OIK+F5QLK8s9ZtFM/nTJ2hzXUsMJj2KHt4a8x6zh76FtcC9dx2FqA4tm6bT/YZaTJjwDNnZ2W45ZlZWFs8++yw9evSgZcuWbjmmKB+nWpl5Yz0dvRDuE2eOQlUUVCApx/sa9QBRgSbmdLqb6+teQaAdjHaVeXt/ZvSGT8ixSYVv4X2aNM3j+hvMTJjwtOQcPkByDtd4f6O+qFie6lBJ9pJieWUJNgfz+PwR3DL8RvRBOvTBOr5/fx1PXD+F9BPemTgI/6OqTtSct1HPDefNmbVIT09h7NixbjiuyhNPPMGZM2d466233BCpEEJUXJy5cPy5QwOHc7yjWF5ZAnR6xifczNArriLAoRBoU1lzci/3rFvEES+9WSH8j6qqZOUsIeX03Uydruf0ack5hP/ymUa906Fy3IuK5ZVFq9Vyz5N3MvLV+wk0GzGa9ezddJBHOo1n1/p9ng5PiEtSnTmoGaNRc14FVGIb6Zkz42oWLVrE9OnTXT+uqjJ9+nQWLlzIa6+9RmxsrPuCFuXi6ti24kUIXxETUhujRodTgaTsmj+t3aUoisI9se2Z1v42ammMBNsgKfM0fdYu5KeUA54OT4hLcqoFnDk3jrMZ4wEbDRvp+M+0NpJz+ADJOVzj9Vduqh1KRIM6qHaV5H0nfWIceuItHXju47FENKpDQC0DGemZPHnDFL5ZuMbToQlRJtV+EPVMb7D8WLRGQQkZw/DH/o/p06czadIkhg8fXuFucVlZWYwYMYLJkyczY8YMhg4d6v7gxWU5USq1COErtIqGZqYInAqczDtHgd3m6ZAqrWN4DK8n9iU2qDZBNsizFPDQ+o94d9+vPpFTCd9jtx8nJa0XOXkfl6wzhQznibEbJefwAZJzuMbrG/UAsW0a4XQ4ycvO5+ypc54Oxy1iWjZg8oonaNHlCgwmPapG5dUR83n9kYXYrN6fRAjfoRZ8j3qmLziSClcoJpSwd1BCRqEoGp577jkWLFjARx99ROvWrVm2bNllK9RaLBaWLVtGQkICH330EQsXLmTChAnVcDWiLA5VqdQihC+JM0fhUEAFjuR499P6YvWDa/Fq5z5cHdGEIBvo7Sqv7Po/xm36jDy71PYRNUd+wW+cTOuO1fYXAIoSQHjtN6ldayqKopecwwdIzuEan2jUN0mIwWkvKpa33zuL5ZXFVDuUJxeN5Kb7/oU+WIc+WMtXb3/HMzdN41xapqfDE35OVR04s+egZowGNbdwpS4Opc5KFOP1pbYdNmwYO3bsoFWrVgwaNIiGDRsyatQoFi9ezMaNG9m+fTsbN25k8eLFjBo1ikaNGjFo0CBatWrFjh075G65h0lXOCH+VjytHXhvsbyyBOsNTLqyJ/c17YzRAYE2lW+SdzLgp/c4npvh6fCEn1NVlczs+aSm34PTWXgzTadtRHTE/wgJurvUtpJzeDfJOVzjE1cem9Co8Ja5CslePq7+n3R6HYMm9uHBFwYSEGrAaNKz49c9PNLpGfZvOeTp8ISfUp0ZqOdGQO78v1cG3IpSezmKLqbMfWJjY/n222/ZtWsX/fr1Y926dQwbNowuXbrQtm1bunTpwrBhQ1n94/v06n09u3fv5ttvv5XxbH7qzTffpHHjxgQEBJCYmMgff/xx0W0XLFjAtddeS1hYGGFhYXTr1u2C7VVVZfLkyURHRxMYGEi3bt04cEDGDYuKizNFgaLgVPC5onIaReHepp2Z0vYWQhQ9QTbYl5FC77UL2HA6ydPhCT/ldOaRfnYU5zL/AzgBCDBeT3TUagyG+DL3KVfOMXQYy95fwbWd/y05h/B6Ok8H4A6xbQobEU4vr4B/Kf/q3YX6zeoy79FFnD2VQfrJs4y9dhLjFozkxkHXejo84UdU2x7UjEfAcbxojRYl9CkIGoKiXL7bU6tWrXj99dcByMnJ4eDBg1gsFnIcP6PWepOgYA2Nav2LBmaZQqamcFI4VYyr+1bU8uXLGTduHPPnzycxMZG5c+fSvXt39u3bR2Rk5AXbr1u3jgEDBnDVVVcREBDArFmzuPnmm9m1axf169cH4KWXXuL1119nyZIlxMbGMmnSJLp3787u3bsJCAhw6dqEfyqpgK/41pP6810V1YTXg/vy/J/fcCI/g2w1jwd//ZDxCTdzX9PO5fqsF8IdbPYk0tIfxGbfW7LOHPo4tUxPoSjay+5/sZzjwF/HWTJ1DTqNgRvbXSvT1tUg1Z1z+AqfeFLfMK4eOr0W1e702rnqy6Np28ZMXvEkV3SIxWjW43A6mHnf68x/YgkOu8PT4Qk/oOZ/iXqm398Nek1tlLD3UIIfdCnJCwkJ4corryQxMZGrOvUlKLjwIymrYJM7wxaVpFaiYI3qwhfsnDlzGD58OEOGDKFVq1bMnz+foKAgFi9eXOb2S5cuZdSoUVx55ZW0aNGChQsX4nQ6WbOmsLioqqrMnTuXiRMncuedd9KmTRs++OADTp48yeeff16ZX43wQ7WNwUQYQ4oq4Kf7bDG5mJDavJ7Yh051GhFkA43dyYzt3zFhy5dYHHZPhyf8QF7+Gk6l9ixp0CtKCBF1FhFmHl+uBv0/nZ9z9OrXE73WCMDOTYfdGreonOrOOXyFTzTqdXodjVo1wOlQOZWUhtWHC8mFRZp5+oNHue6eruhDdOiDtKx89X9MuPUFss5WrMqnEOWlqjacWTNQM58ECgpX6lqj1FmFYuzilnME6GLQayMAyLZsRVXlRlVN4VSVSi1QWFX4/MVisZR5LqvVypYtW+jWrVvJOo1GQ7du3fj999/LFW9eXh42m43atWsDkJSUREpKSqljms1mEhMTy31MIc5XPK4+y1bAGUuep8OpMqGGAKa2v417GrcnwA4BNpXPjm7j3p/fJzU/y9PhCR+lqk4ysuaQduY+nGphDSm9rhnRkd8QHHiLW84RYg4itmU0AEm7T5Kble+W44rKc0fO4Y98olEP0KRNYbE8p8PJqUOpng6nShkMeh6Y2p/BU/piCDFgCNWx9cftjO78LEk7jno6POFjVEc66tkHIG/J3ysD+6DU+QhFG+228yiKgsnYCQCHmkOudY/bji08r2HDhpjN5pLlxRdfLHO79PR0HA4HUVFRpdZHRUWRkpJSrnM988wz1KtXr6QRX7xfZY4pxPmam6NwFGVQSdnpng2mimkVDUObX8WENt0JQUeQDXacPUHv/1vI1jPJng5P+BinM4u0Mw+SkfUyhQWzICigJ9GR32DQX+HWc8V3bgoU9ubavUVqRgjv5jON+tjWjVAdRRXwfbgLfjFFUfj3wGt56v1HqBVlwmjWk3I0jceueo5fVm7wdHjCR6jWv1DP3AW24u7wehTTVBTTDBTF6PbzFTfqAbIs0gW/pnBHJdrk5GQyMzNLlmeffbZKYp05cyYff/wxq1atkrHyosrEmaNQFQUV3x1X/0/X1b2CVzv3pp4xlGArnM3PZvDPS/g0aaunQxM+wmrbx8m0W8gv+K5ojUIt07NE1FmIRhPq9vO17tSk5Oddf0gX/JpCqt+7xmeuvLhYnupUSd7r+436Yi06NWPKZ08Rm9AQo1mPzWZjat9XeH/SxzidTk+HJ7yYmrcc9exAcBb1fNFEotT+ECWof5UVSTIFSKO+JnJHVziTyVRqMRrLvikUHh6OVqslNbV0j6vU1FTq1q17yThnz57NzJkz+f7772nTpk3J+uL9XDmmEGWJMxUWyyscV+8fjXqApqYIXu/Sl7Zh9QmyAXYHE//8H8//+Q1WpwyZEq7Lzfsfp9JuwW4vnNlJo9QiKnwptUyPoShV01xp3fnvRv1OadTXGNL93jU+06hvUtyot6sk7/fNCvgXUyc6jAnLxtD1jo7oQ3ToArUsnbGSKXe9RG6W7471E1VDVa04M59DzZoEFNWn0HcoHD9vaFel5w7Sx6FVQgDILtjkswWovI2rBWuKl4owGAx06NChpMgdUFL0rmvXrhfd76WXXmLatGmsXr2ajh07lnotNjaWunXrljpmVlYWGzduvOQxhbiYpqHhaIumtUvK9Z9GPUAtQxAvdLiDOxu1KRln/9HhTQz55b+kF+R4OjzhZVTVwdnMGZw+OxxVLcxZ9fp4oqNWExhwQ5Weu3aUmeiYcAD2/XUUa4Hv1uTyJtWZc/gSn2nU165bC3N4KE6H6hfd7//JEGBgxEv30e+ZXhiCdRhCdWz43xYe7TLBZ6f5E+6nOlIKn87nf/r3yqD7UGovQSkqYleVFEVLqLEDADbnGQrsMsbNH40bN44FCxawZMkS9uzZw8iRI8nNzWXIkCEADB48uFT3/VmzZjFp0iQWL15M48aNSUlJISUlhZycwgaGoiiMGTOG6dOn8+WXX7Jjxw4GDx5MvXr16NWrlycuUXg5g1ZHk9BwHBpIzjnrd0+p9Roto1r8i3GtbiQQLUE22JJ+lN5rF7LznP/lYMI1DsdZUtMHkpU9r2RdcOBdREd8iV4XUy0xFD+tt1sd7P/rWLWcU4iq4DONekVRiG0Tg+pQyUzPJvOM/1WCVxSFng/+m3ELRxIaHozRrOf4/pOMTnyWjV9v8XR4ooZTrX8UjZ/fXrTGiGJ+CY1pEopiqLY4SnXBl6ntaoTq7grXr18/Zs+ezeTJk7nyyivZtm0bq1evLil0d+zYMU6dOlWy/dtvv43VaqVPnz5ER0eXLLNnzy7Z5umnn+bRRx9lxIgRdOrUiZycHFavXi3j7oXL4kxROBWwq06O557zdDge0b1BS17peBeRhmCCbJCWm8nAn97ny2M7PB2aqOEs1h2cTOtOgeXnojVaapunEl77TTSaoGqLI/68Lvg7/jhUbecVFyfd713jM416KCyW57QXFcvb7793iltf3YLJK56kYYt6GM16CvItTLpjFste+Ey6M4sLqKqKmvs+6tn7wVnUjVTbAKXOcpTAXtUejxTLq3k88QU7evRojh49isViYePGjSQmJpa8tm7dOt5///2Sfx85cqTwffyP5fnnny/ZRlEUpk6dSkpKCgUFBfz44480b97c1V+JEMSZI3EUvb2P+EmxvLK0qFWXNxLvobWpLsE2cNhsPLV5FTO3f49davuIMuTkfkpK2h04HMcB0GjCqRvxCabQ4VVWs+diWhdVwAcplldTSKPeNT7VqG/SJgbVWdSo96NieWWJahTBxI/H0rFHWwyhOrQBGt6b+BHT+s0hP0fm4hSFVDUfNfNJ1OwXgKLuo4arUeqsRNG38khMIcY2KBT2DJBGfc0gX7BCXKi5KRKKx9X7UbG8stQJCGZWx170rB9PoB2MdpX3DvzOiPXLyLBKziEKqaqNM+eeI/3cY6gUAGAwtKde5HcEGK/ySEz1GocTFlFYWX/3liQcDrkR5WmSc7jGpxr1saWK5fl3ox4gIDiAR157kLvH3Io+SIchRMcvKzbw+NUTOZWUevkDCJ+m2o+hnukHBV/9vTJ4BErYQhRNmMfi0ihGQo1tAbDYk7HYZR5xIUTNE2cuHA4ijfpCBq2Ox1tdz+iW1xHo1BBoh/Wph+izdiH7MiXn8Hd2Rxopp/uQnbu4ZF1I8CCiIz5Dp6vnsbgURSG+aGq7/BwLSbulDpXwTj7VqI9p1QCNRsHpcHJcisMBhR9Wd4zszmNvDSM4LAijWc+RXcd4pNN4tq6RMW/+SrX8jHqmN9j3Fq5QglFqvYEm9EkURevZ4ACTsXPJz9nytN7j5K65EBeqG2jCpA/AqcDhnHRPh1MjKIrC7Q0TmNnxTuroAgmywYnss/Rft5jvTuzxdHjCQwosmzmV2h2L9Y+iNQbq1HqZ8LDZKErZ05tWp9aJf3fBl6ntPE9yDtf4VKM+IMhI/SuicTpUTh5MwWH3r2q0l9Lu3wlMWvEE0c0iMZoN5Gbn8myP6Xw292sZZ+9HVFVFzXkb9dxwUDMLV2pjUep8ihLQ3bPBnSdUiuXVKCquTzEjny7CVymKUjKu/owllyxrgadDqjHahNVnXuI9NA+JJNgGVquVxzZ+yqu7/g+n5Bx+Q1VVsnKWkHL6bhzOwl53Wm000RGrCA2518PR/U3mq69ZJOdwjU816gEaJzRCtatYLXZSj8md8/PVaxLFpE+eoM31rTCE6tHoFd4e9z4vD3kTS77F0+GJKqY6c1AzRqPmvArFH3vGG1HqrEDRNfNobP8UamxH8ceTjKv3PLlrLkTZiivgAxyRp/WlRAaGMqfzXdxQN65knP38fb8y6vePybbJDRBf51QLOHPuCc5mjAcK5383GrpQL/I7jMb2ng3uHxq3qEdQaOFMKLs2HZKHXR4mOYdrfK5R3yQhBqejuFiedMH/p2BTEI+/PZzbHroJXZAWfYiOHz74iXHXTeH0cRkT6KtU+yHUM33A8kPRGgUlZAxKrTdRNKEeja0sOk0owYbCQn15tv3YHZkejkgIIS4UZ/67UX8456xng6mBjFo9zyR0Y3jzqwlwKATaVNad2k/ftYs4nC03QXyV3X6clLRe5OR9VLLOFDKcuhGfoNVGeDCysmm1Glp1jAUgIz2HE0mnPRyREBXne436NjGggupUSd4nxfLKotVq6TPudkbNHUKQOQCjWc+BrYd4pNMz7Pxtr6fDE26mFvxQ2KB3FHUpU0woYe+ghIxCUWruR4DJ2LHoJ5Usy2aPxuLv5K65EGVrbi6sgO9QIEkaqWVSFIU+jdsxvf3thGmMBNngaFY6fdcuYt2p/Z4OT7hZfsFvnEzrjtX2FwCKEkB47TepXWsqiqL3cHQX17rT313wZWo7z5KcwzU1N6N3UWybRgCoDpXk/fKk/lI692zHxI/HEhkTjtFsIPNMFk/9+3n+984Pl91X1Hyq6sCZPQc14xFQcwtX6uIKp6szXu/R2MpD5quvOeQLVoiyXWGKBIor4Euj/lI6hDfijS730CS4DkE2KLAU8PDvHzN/7y/S3dkHqKpKZvZ8UtP74XQW9lrRaRsRHfE/QoLu9nB0lxff+fxieYc8GImQnMM1Pteoj4qJICg0EKdD5cT+U54Op8Zr2KI+U1Y8SaurmmMw6VE1Kq+NfJe5D72DzWrzdHjCRaozA/XcCMid//fKgFtRai9H0cV4LrAKCA3oWPJztjyp9yj5ghWibME6A42Cw3Bo4GjOOSkCdxnRQWZe7dybayObEmgHvV3l1d1refyPFeTarZ4OT7jI6cwj/ewozmX+BygsUh1gvJ7oqNUYDPGeDa6cmrdthN6oA6RYnqd5Iud48803ady4MQEBASQmJvLHH39ccvtPP/2UFi1aEBAQQEJCAt98802p1x944AEURSm19OjRw6XYysvnGvUajYbGrRui2lVOHz9LXnaep0Oq8ULCgnli4Ui6P3A9+mAd+mAdXy/4kadu/A9nU855OjxRQaptD+qZu8H6S9EaLUroeBTzHBRNkEdjqwiDNoIAXeEYtxzLDhxOKazkKaqqVGoRwpcVj6svcNo4lSf1Py4nSGdgYtse3N+sCwEOCLSpfHd8N/3XLSY5V3IOb2OzH+HU6dvIzf+8ZJ059HGiwj9EqwnzXGAVZDDqiGtb2Ns35dgZzqTI37KnVHfOsXz5csaNG8eUKVPYunUrbdu2pXv37qSlpZW5/fr16xkwYABDhw7lzz//pFevXvTq1YudO3eW2q5Hjx6cOnWqZPnoo4/KPJ67+FyjHiD2/GJ5+1M8HI130Oq0DHj2bobPupeAUANGk55d6/fxSKfx7Nt00NPhiXJS879CPdMPHMcLVyhhKGHvoQQ/iKJ4X+PKVDS1nYqNHOs2zwYjhBBliDNFlhTLS8qRgrPloSgKA5t0ZMqVtxCq6Am2wYHMVPqsXcjvafKU1Fvk5a/hVGoPbLY9AChKCBF1FhFmHo+iaD0cXcVJF3z/NGfOHIYPH86QIUNo1aoV8+fPJygoiMWLF5e5/WuvvUaPHj146qmnaNmyJdOmTaN9+/bMmzev1HZGo5G6deuWLGFhVXuTyycb9U3axKAWN+r3ybj6iri6V2eeXTaGOg3CMJr1nEk5x9h/TeaHD37ydGjiElTVhjNrBmrmE0DRE21da5TwVSjGLh6NrTJKjasvuHRXKFF1XJ0vtngRwpc1N0ehKoXzI8u4+orpGtmE17vcQ8PAMIKtkF2Qx4O/LuX9AxtknH0NpqpOMrLmkHbmPpxq4RNtva4Z0ZHfEBx4i4ejc53MV18zuCPnyMrKKrVYLGVP3W21WtmyZQvdunUrWafRaOjWrRu///57mfv8/vvvpbYH6N69+wXbr1u3jsjISOLi4hg5ciRnzlTtTV8fbdSfVyxPKuBXWJOERkxZ+STNOzXBaNbjxMFLD8zj7bHv47A7PB2e+AfVkY56dgjkLfl7ZWAflDofoWjreS4wN5BieTWDjKkX4uLizIXF8hwaeVLvikbBYbzeuQ+JdWIIsoHO7uTFHd/zzJYvKHBIbZ+axunMIu3Mg2RkvQwU3ngJCuhJdOQ3GPRXeDa4SmrZIRaNpvA7S57Ue447co6GDRtiNptLlhdffLHMc6Wnp+NwOIiKiiq1PioqipSUsnt7p6SkXHb7Hj168MEHH7BmzRpmzZrFTz/9RM+ePXE4qq4dpauyI3tQbEJho97pUDl+QBr1rjCHm3j6/dEsnf4Z65b/hkbr4LPXvubwjqNMWj4OU52aN7e5P1Ktf6FmjAZnatEaPYppIgT298ru9v9k1DXEoI3C6kgl2/InqmpHUXzyY6tGq8zYeBlTL3xdw+AwArV6nHYrh7OlUe+KEIOR59vfygcHN/Jx0hY0qsoXR//iUFY687r0JTrI7OkQBWC17SPtzFDs9uIGr0It0zOYQx+t0VPklldwaACxrepzaOdxju5LITsjj9Ba3lOLyFe4I+dITk7GZDKVrDcajW6Jrbz69+9f8nNCQgJt2rShadOmrFu3jhtvvLFKzun9f4FlCDYHExUTgWpXOb73lHThcpHeoOeBqf24/z/9MIYaMJj0bFu7k0c6PcPh7Uc9HZ7fU/OWo54d+HeDXhOJUvtDlKABPtGgh8Jxl6FFT+udah451l0ejkgIIUrTKhquMEXgUCAlP5M8qeLuEq2iYcgVXZnQpgeh6Amywa5zJ+i9diGb0495Ojy/l5v3P06l3VrSoNcotYgKX0ot0+M+0aAvVjxfvaqq7N6c5OFohKtMJlOp5WKN+vDwcLRaLampqaXWp6amUrdu3TL3qVu3boW2B2jSpAnh4eEcPFh1dcp856/wH2ITGuF0OMnPLSD9xFlPh+PVbuh/NU8veZSwuiaMZj2pyek8ftVz/PRp2WNNRNVSVSvOzImoWZOAoq6J+g4odVahGNp5NLaqUFwsDyBbuuB7hHS/F+LSiivgq8CxHMk5KuO6us14NbE39Y0mgq2QkZ/DA798wMeHt3g6NL+kqg7OZc7g9NnhqGouAHp9PNFRqwkMuMHD0blf60Qpludp1ZlzGAwGOnTowJo1a/4+v9PJmjVr6Nq1a5n7dO3atdT2AD/88MNFtwc4fvw4Z86cITo6ukLxVYRvN+rthU/ok6VYXqU179CEKSufpOmVMRjNemx2G9P7zWHRhGVVOj5ElKY6Ugqfzud/8vfKoPtQai9B0UZ4LrAqVLpYnsxX7wkypZ0Ql9b8vAr4h2VcfaU1CQ3n9S59aVe7AUE2wO5gyravmbz1f1idknNUF4fjLKnpA8nM/ruqd3DgXURHfIleF+PByKpOfKe/i+Xt2iTF8jyhunOOcePGsWDBApYsWcKePXsYOXIkubm5DBkyBIDBgwfz7LPPlmz/+OOPs3r1al555RX27t3L888/z+bNmxk9ejQAOTk5PPXUU2zYsIEjR46wZs0a7rzzTpo1a0b37t3d80sqg8826pu0iSm8Za7C8X2nPB2OT6hdN4zxHz7G1b06ow/RoQvS8vHMVUy+cxY5GbmeDs/nqdY/UM/cBbbtRWuMKOaX0JgmoSgGj8ZWlYL0zdFpCsdTZlk2y3AaD1ArccdcGvXCH8SZo0BRcCpSAd9dzIZAZrS/g7sbtSXADgE2leVJW7j/lw84XZDj6fB8nsW6g1NpPSiw/Fy0Rktt81TCa7+JRuO748zDIkKp36TwIcmB7clYCmQ4TXWr7pyjX79+zJ49m8mTJ3PllVeybds2Vq9eXVIM79ixY5w69Xdb8qqrrmLZsmW8++67tG3blhUrVvD555/TunVrALRaLdu3b+eOO+6gefPmDB06lA4dOvDLL79U6dh+n604Fdum8A6iFMtzL4PRwLCZg4hp1YCPZ32ORqvwx7d/8miXZ3l+1dPEtGzg6RB9jqqqkPcBavZMoOgJhaY+Stg8FH28R2OrDoqiIdTYgXP5/4fdeZZ8+yGC9M08HZYQQpRobiqqgK9IBXx30mk0PNTiWpqGRjB3z1o0Ngd/ph+j9/8tYF6Xe2hTu76nQ/RJObkrOHPuKdSiKXI1mnAi67xDgPEqD0dWPVp3bsqJw6ex2xzs+/Mobbp6d1V/cXmjR48uedL+T+vWrbtgXd++fenbt2+Z2wcGBvLdd9+5M7xy8dkn9Q2uiEZv1KPanSTvlUa9OymKws33X88Ti0YSGhGC0aznxKEUHusygd+/ku7R7qSq+aiZT6Fmz6CkQW+4GiX8M79o0Bcr3QVfxtVXNxVQVRcXTwcvRDUIMwYRFRBa9KT+jPQocrNu9VvwSqe7iTKEEGSD03lZDPr5fVYd/cvTofkUVbVxJmMi6eceLWnQGwztqRf5nd806KF0F3yZr776Sc7hGp9t1Gt1WmJaNcDpUEk9koZVus+4XXzXOKasfJJGrepjNOkpKLAwpddLLJ2+EqfT6enwvJ5qP4Z6ph8UfPn3yuARKGELUTRhngvMA6RYnmc5USq1COEP4sxRODSQY7eQXiBD0twtzhzFvC59aW2OJtgGqs3O+C1fMOOv77BLzlFpdkcaKaf7kp2zqGRdSPAgoiM+Q6er58HIql/rztKo9yTJOVzjs416gNg2hcXynE6VEwdTPB2OT4psEM5zH42l863tMITq0AZoeH/yx0y7Zw75OfmeDs9rqZZfUM/0BvvewhVKEEqtN9CEPomiaD0bnAcEG1qjUQIAeVLvCVIoT4jLa27+u1heUo6Mq68KYcZgZnXsxa0NWhNgB6Nd5YODGxj624ecteR5OjyvVWDZzKnU7lisG4vWGKhT62XCw2ajKNU7v3dNULdRHepEFdby2bv1CA67FGesTpJzuManG/VNEmJQHcUV8KULflUJCDIycs4D9B13O/ogHYZQHb9+tpHHrnqOk4fkZkpFqKqKmvM26rlhoGYWrtTGotRZgRJQdRUzazqNYiDEcCUAFscJLHb5exZC1CxxpihURUGlsAu+qBoGjZbHWl3P462uJ8ipIcgGG9OS6LN2IXszJOeoCFVVyc75gJTTd+NwFv7utNpooiNWERpyr4ej8xxFUYgvelqfn2vh0C6ZRUvUfL7dqC8qlqc6VU7sl0ZAVVIUhVsfuokx74wgpHYwRrOeo7uPM7rzeLb8IGPeykN15qBmjEbNeZWSUUHGGwsb9DopDHd+F/ws6YJfrWSeeiEuL85cWCzPKcXyqsUtDVozq2MvwvVBBNngVM45+v/0Ht8c3+Xp0LyCUy3gzLknOZPxDGADwGjoQr3I7zAa23s2uBrg/C74MrVd9ZKcwzU+3agvroCv2lV5Ul9N2l4Xz+RPx1HviroYzXpyc/KY0HMGn77ylRQOugTVfgj1TB+w/FC0RkEJeRyl1psomlCPxlZTmIwdS37OKvjDg5H4H5cL1hQtQviD2NBw9IoGhwYOS/f7atE6rB5vJN5Di9BIgm1gs1oZ+8dK5uxcg0OVcfYXY7efICXtLnLylpWsM4UMp27EJ2i1ER6MrOZo3blpyc87Nh7yYCT+R3IO1/h0oz4s0kytSDNOh0ry3hPSqKwmdWOjmPTpOK68MR5DqB6NQcO7T33ArMFvYMm3eDq8Gkct+KGwQe8ouhOsmFDC3kEJeQRF8ek/0QoJNbYHCusJZFlkloXqJOPbhLg8g0ZLE1METgWO52Zgddg9HZJfiAgM4ZVOd9MtugWBRePs39n3KyPXf0yWtcDT4dU4+QXrOZnWHattGwCKEkB47XnUrjUVRdF7NrgaJCauLiGmQKDwSb20IaqP5Byu8fkWQ5OiYnnZ53LJTM/ydDh+IygkkMfeHM4do7qjC9KiD9GxZukvjL12EmnHTns6vBpBVR04s+egZjwCalGlZF0cSp2VKMbrPRpbTaTVBBNsaAVAvu0ANsc5D0ckhBClNTcVFstzqE6O58pnVHUxaHU82fpGHo67lgCnQqAdfk45QN91iziUJTkHFI6fz8x+h9T0e3A6C4eH6LSNiI74HyFBvT0cXc2j0Who1TEWgKyzuSQfTPVwREJcms836mMTYlAdhV2wkved8nA0/kWj0XD347cy+o2hBNUKwGjWc3BbEo90Gs/2n3d7OjyPUp0ZqOdGQO78v1cG3IJSezmKLsZzgdVw589Xny1P66uN3DUXonzizJE4it7yh2VcfbVSFIW7YtryQvs7qK0NIMgGx7LS6btuEWtO7vN0eB7ldOaRfvYRzmU+DxRWcg8wXk901GoMhniPxlaTxcvUdh4hOYdrfL5R36RNDMXDqo5LsTyP6HhzWyYtH0dU4wiMZgNZ57J5uttUvnzrO7/szqTa9hROV2f9pWiNFiV0PIr5VRRNkEdjq+lMAZ1LfpZiedVHitYIUT5xpihQFJwKHJYK+B7Rrk5DXk/sS9OQcIJsYLFYGLVhOW/u+RmnH+YcNvsRTp2+jdz8VSXrzKGPExX+IVpNmAcjq/kSEv8eV79LGvXVRnIO1/hFox4Ki+Udl2J5HtOgeT0mr3iC+GviMJj0oFN5Y/RCXh3xDlaLzdPhVRs1/yvUM/3AkVy4QglDCXsPJfhBFMV/P4jKq3SxPGnUVxcpWiNE+cSZo4DCCvhHpFiex0QHmXm1091cF9WMQDsY7Cqv71nH4xs/JcfmP7V98vLXcCq1BzbbHgAUJYSIOosIM49HUbQejq7ma5bQEGNAYZ2BnZukWF51kZzDNT7fqG/Usj4arQanw0nyPpln0pNCagUz7t2H6fngv9EH6dAH6/h20Rqe+vfznDnl22MPVdWGM+sF1MwngKLCPbrWKOGrUIxdPBqbN9FraxOoL5zeL9e6C4czz8MR+YfCL0pXu8J5Onohqk9kQAi1DIFF09qd9XQ4fi1QZ2BCm+482KwrAQ4ItKl8f2IP/X9azDEf/2+jqk4ysl4l7cx9ONVMAHS6pkRHfkNw4C0ejs576A064toVPhxMO36O0yd9O1etKSTncI3PN+oNAQYaNI/GaVc5dSgFu02q0XqSVqel3zO9eOjlwQSaDBhNenZv2M8jnZ5hz8YDng6vSqiOdNSzQyDv/b9XBvZGqfMRiraex+LyVsXj6lXsZFv+9HA0oqq8+eabNG7cmICAABITE/njj4tPY7hr1y569+5N48aNURSFuXPnXrCNw+Fg0qRJxMbGEhgYSNOmTZk2bZpfDgESVUdRFOLMUTgUOGvJJcMqNx49SVEU+jXpwNR2t2HWGAi2waGMNPqsXchvqb755NXpzCLtzINkZL0EFH6+BQX0oF7ktxj0V3g2OC8k4+qFt/D5Rj0Ujat3qNisDlKOSBXUmqDrHR2Z8NFY6jQMI6CWgXNpGTxx3WS+e3+tp0NzK9X6F+qZu8BW3CDRo5j+g2J6AUUxejQ2b3V+sTwZV189qrtozfLlyxk3bhxTpkxh69attG3blu7du5OWllbm9nl5eTRp0oSZM2dSt27dMreZNWsWb7/9NvPmzWPPnj3MmjWLl156iTfeeKPC8QlxKcUV8AGSsn37ibC36BzRmNcT+xITFEaQDXIs+Qz7bRmL9q/3qRt7Vtt+TqbdQn7Bd0VrFGqZxhNRZxEaTahHY/NWrTv9Pa5+5x++eSOoppFCea7xi0Z9bEIMTkfhh7YUy6s5Gsc3ZMrKp4jr3BSDSY9TcTL7wbd48/HFPtGjQs37BPXsQHAWTYOiiUSp/SFK0AAZP18JoQHnV8CXRn11UCu5VNScOXMYPnw4Q4YMoVWrVsyfP5+goCAWL15c5vadOnXi5Zdfpn///hiNZd8sW79+PXfeeSe33norjRs3pk+fPtx8882X7AEghCvizFE4NYWf8Ukyrr7GaBAcxmud+9IlPJYgG+jsTl7a+SNPbf6cAof31/bJzf+aU2m3YLcXNjw1Si0iwz+klulxFMUv0v0q0bJDYzTawt+fFMurHtWdc/gKv/grb9ImBlRQnSrJUiyvRjHXCeWp9x7hxkHXoA/WoQ/W8vkb3zK++3QyTmd6OjyXqKoVZ+Yk1KyJQFGioO+AUmcViqGdR2PzBQG6+hi00QBkW7bhVL0/Gavp3HHXPCsrq9RisZRdrMpqtbJlyxa6detWsk6j0dCtWzd+//13l6/hqquuYs2aNezfvx+Av/76i19//ZWePXu6fEwhyhJnigTAoUCSVMCvUYL1Bp5vdwsDm3TE6IAAm8pXx7Yz8Kf3OZnnrTmHg3OZMzh9ZhiqmguAXh9PdNRqggL+7eHovF9gsJGm8fUBOLo/haxzuR6OyPfJk3rX+EWjPjahEQCqQyrg10Q6vY77Jt/DkGkDMIYYMJj0/PXTLkZ3fpaD25I8HV6FqI4U1LODIH/53yuD7kWpvQRFG+G5wHxMcRd8p5pPrnWXh6MR5dGwYUPMZnPJ8uKLL5a5XXp6Og6Hg6ioqFLro6KiSElJcfn848ePp3///rRo0QK9Xk+7du0YM2YMgwYNcvmYQpTlClMkCoUV8KVRX/NoFIX7m3VhUtuehKInyAa7z52k99oFbEo/6unwKsThOEtq+iAys+eVrAsOvIvoiC/R62I8GJlvaX3euPrdm7wrLxX+wy8a9ZGNwgkyBeK0q1IBvwa77p6ujP/vo9SuVwujWU/a8XTGXD2RtR//5unQykW1bioaP/9X0RojinkWGtNkFMXg0dh8jem8LvgytV01cENfuOTkZDIzM0uWZ599tlov4ZNPPmHp0qUsW7aMrVu3smTJEmbPns2SJUuqNQ7h+wJ1emJC6uDQwNHcszhUp6dDEmW4JqopcxP70CDATLAVMvNzeeCX/7L00CavGGdvse7gVFoPCiw/Fa3RUts8lfDab6LRBHk0Nl8T3/m8cfUytV3Vk/73LvGLRr2iKCXF8s6eyiA3U7rO1FTN2jVhyoonaNouFqNZj91h54WBc1nwzIc4HA5Ph1cmVVVRcz9APXs/OIueymjqo9T5GCXwLs8G56NKF8uTMdFVrjLd4Iq6wplMplLLxca+h4eHo9VqSU1NLbU+NTX1okXwyuOpp54qeVqfkJDAfffdx9ixYy/aY0CIyogrKpZnddq9tlu3P4gNrcPriX3pWKchQTZQ7A6m/vUtE7f+D6uj5tb2ycldQUraHdgdyQBoNOHUjfgEU+hwqdlTBeI7nVcBf6M06qucG3IOf+QXjXr4R7G8A6534RRVLyyqFuP/O5pr705EH6JDF6Tlk5e/YNLtM8k+l+Pp8EpR1XzUzKdQs6cDRQmA4SqU8M9Q9PEejc2XBeqbodPUAiDbshlVnoRVqcI5Y11fKsJgMNChQwfWrFlTss7pdLJmzRq6du3q8jXk5eWh0ZT+ytNqtTid8t4R7tfc/HcF/MPSBb9GMxkCmNrudnrHtCPAXjjOfsWRrQz+5QPS8rM9HV4pqmrjTMZE0s89ikoBAAZ9O+pFfkeA8SoPR+e7atUJoWGzwloZB3cepyCv7Jowwj2qM+fwJX7TqC9+Ug9IF3wvYDAaePCFgdw7qTeGYD2GUB2bvtvG6MRnObo72dPhAaDak1HP9IeCL/9eGTwcJWwRiibMc4H5AUXREGrsCIDdmUme7YCHIxLuNG7cOBYsWMCSJUvYs2cPI0eOJDc3lyFDhgAwePDgUt33rVYr27ZtY9u2bVitVk6cOMG2bds4ePBgyTa33347M2bM4Ouvv+bIkSOsWrWKOXPmcNdd0ptGuF8LcxSqohSNq5cK+DWdTqNhRNzVPN36JoLREWSDbWeSuXvtAv46e9zT4QFgd6SRcrov2TmLStaFBA8iOnIVOl09D0bmH+KLprZz2J3s2epdtReEf/CbRn2pYnl7pVieN1AUhW73XsfT7z2COTIUo1nPqaRUHu0ygfVfeHYctWr5BfXM3WDfUxRsEEqtN9CEPoWiaD0am784vwu+TG1Xtaq7Em2/fv2YPXs2kydP5sorr2Tbtm2sXr26pHjesWPHOHXqVMn2J0+epF27drRr145Tp04xe/Zs2rVrx7Bhw0q2eeONN+jTpw+jRo2iZcuWPPnkkzz00ENMmzat8r8gIf4hzlz4XnUqcCRH5qr3FjfWi2NOp7upawgh2Apn87IZ9PMSVh7Z5tG4CixbOJXaHYt1Y9EaA3VqvUx42GwUpeyhTMK9zi+Wt0vmq69SUv3eNX7TqG/cuiFAYbE8maveq7RIvIIpK58iJr4BRrMeq9XKlLte4r//+bTau86qqoqaMx/13DBQi8ZJahuj1FmBEtC9WmPxd6aAziU/S7G8KlY8Ts3VxQWjR4/m6NGjWCwWNm7cSGJiYslr69at4/333y/5d+PGjQv/Nv+xrFu3rmSb0NBQ5s6dy9GjR8nPz+fQoUNMnz4dg0GKWAr3qx9UiyCdQZ7Ue6ErzJG80eUe2oTVI8gG2OxM2Pol0/9ajc1Z/bV9snP+S8rpu3A4C4eOarXRREesIjTk3mqPxZ+1TjyvWJ7MV1+1PJBz+AK/adQHm4KoGxuJ0+Hk+P6TMo7Sy4TXr81zH40l8db2hePsA7V88J9PmNpnNnnZ+eU+Tk5ODtu2bWPjxo1s27aNnJzyj9FXnTmoGaNRc+ZQUl7TeCNKnZUoumYVvCJRWcGGVmiUQACyLJu9olqxt5LxbUJUjEZRaG6KwKFASkEWuTarp0MSFRBmDOLFDndye8OEknH2/z24kQd//ZCzlvIXW65MzuFUC0g/9wRnMp4GbAAYDV2oF/kdRmP7il6SqKSoBrWJqFcLgL1/HsVuq5nFm32B5Byu8ZtGPfw9rt6SZyX9hHSH8zbGQAMPv3I/9zx5B/ogHYZQHb99vonHuk7gxMFTF91v9+7dPPbYY7Rs2RKTyUS7du3o0qUL7dq1w2Qy0bJlSx577DF279590WOo9kOoZ/qA5YeiNQpKyOMotd5E0YS6+UpFeWgUPaHGdgBYHaewOKRWhhCi5ogzRZUUyzuSI8XyvI1eo2V0y+sY0+oGAlUNQTbYdPoIfdYuZHdG1eYcdvsJUtLuIid3Wck6U8hw6kZ8glYb4dbrFOVXPLWdJd/KwZ01o76TEMX8qlEfm9AIp724WJ50wfdGiqJwy/BujH33IULrBGM06zm29wSjOz/LptV/lto2KSmJnj17Eh8fz/Lly7nhhhtYtGgRGzZsYPv27WzYsIFFixZxww03sHz5cuLj4+nZsydJSUmljqMW/FDYoHcUdbdSQlHC3kEJeQRF8as/oRqn1NR20gW/6sicsUJUWJz570Z9Uo50wfdWPRvE83LHu4gwBBNkg1M5GQz46T3+l7yz1HbuyjnyC9ZzMq07Vts2ABQlgPDa86hdayqKoq+uyxZlaH3+1HbSBb/qSM7hEr9qkcQmxJT8B0/eK0/1vFmbf7Vi8oonaBAXjdGsJy83j4m3vcjyl75AVVUWLlxIQkICe/bsYenSpSQnJ/PWW28xZMgQEhMTSUhIIDExkSFDhvDWW2+RnJzM0qVL2b17NwkJCSxcuBBVdeDMfhU14xFQi7rb6Zqj1PkMxXi9R69fFJJiedVDitYIUXFx5kgoqoAvxfK8W6uwaN5IvIdWoVEE28ButfHEps94eeePOFSnm3IOlczsd0hNvwens7Bnh07biLoRXxES1NvDvwEB/yyWJ436qiI5h2v8qlHfpE1hBXynvXBcvfBuUTGRTPxkHB1uSsAQqkdj0LBw/IfcfOVtDB8+nAEDBrBjxw4GDhx42WJYBoOBgQMHsnPnTgYMGMDw4cOZMbEz5L7990YBt6DU/gRFF1PFVybKK8TYDgUdIE/qq5zcMReiQpqbCivgOxQ4LMXyvF54QDAvd7qLm+u1JNAORrvKwn2/0fmh/m7JOZ6b2IVzmc8DhWO1A4zXEx21GqOhddVfnCiXhldEEVorCIBdmw5Lfa6qJDlHhflVo75es7oYAvQ4Hap0v/cRgcEBPPLGUHo92hNdkJZUw1F+3P4N06ZNY8GCBYSGVmy8e2hoKAsWLGDq1KlMemEri5ZlAhqU0GdQzK+iaIKq5kKES7SaQIKLEp58+yFsDhm3KoSoGUyGAKIDTUUV8M9IMU8fYNDqGBf/b0a1+BcBToW877ewdcGnbsk5XnzhD5Z/nAeAOfQxosI/RKsJq4rLEC7SaDTEF3XBz87II/lAqocjEuJvftWo12q1NG7dCNWhknY0nYI8i6dDEm6g0WjoNbonfafcyl7HXwwdOpSJEyeW2mbXrl307duXJk2aEBQURHh4OP/617/46quvyjzmxIkTGTp0KGMnn+VIxgyU4KEoiv926anJTAHnjau3bPZgJL5LusIJ4Zo4cxQODeQ5rKQVZHs6HOEGiqJwZ6M2PB7ZkdQPvndrzjF1Sh652TMIMz+Lomir43JEBcV3lnH1VU1yDtf4VaMeoElRsTxVVTl5MMXT4Qg3+uCLxUTXi+bVV1+94LWjR4+SnZ3N/fffz2uvvcakSZMAuOOOO3j33Xcv2F5RFObMmUOdOvV4ZOzCKo9duE6K5VUDKVojhEviTJElxfKkC75vee+FOdSLquvWnCM8vB5Pjvu0ymMXrjt/XP3OTdKorxKSc7hE5+kAqltsQuG0dlBYAb9JGxkf7Qv27dvHmjVrWLp0aZnd32655RZuueWWUutGjx5Nhw4dmDNnDiNGjLhgH5PJxIsvvsigQYPYs2cPLVu2rLL4hetCjR1Kfs6y/OHBSHyZUrS4uq8Q/inOHIWqKKioJOWcpWtkk8vvJGo8yTn8V7PWDTEGGrDkW9m58RCqqkpPTreTnMMVfvekPraoWJ7qUDm+Tyrg+4r333+fyMhI+vTpU+59tFotDRs2JCMj46Lb9O7dm8jISN5+++2LbiM8S68NI1DfHIBc624czhwPR+SD5K65EC6JMxcWyyusgC81P3yF5Bz+S6fX0qJd4QPB9FMZpB2XmS3cTnIOl/hfoz6hqAK+QyV5/ykPRyPcZd26dfTu3fuyFWdzc3NJT0/n0KFDvPrqq3z77bfceOONF93eaDTSu3dvfvzxR3eHLNzIZOxY9JOTbMufHo1FCCGKxYTURq/R4tBAknS/9xmSc/i31jKuXtRAfteorxVhpnZ0GKpDJXnfCalG6wOys7M5ePAgnTp1uuy2TzzxBBERETRr1ownn3ySu+66i3nz5l1yn44dO7J3715ycuQJcE1VuliejKt3O7lrLoRL9BotzUIjcCpwPDcDq8Pu6ZBEJUnOIeI7Ny35WRr1VUByDpf4XaMeCuerd9pVcjPyyEjL9HQ4opKOHDmCqqq0atXqstuOGTOGH374gSVLltCzZ08cDgdWq/WS+8THx6OqKgcPHnRXyMLNpFheFVOVyi1C+LE4cyQOBZyoHM2RrrreTnIO0bJ9DFpdYRNq16ZDHo7GB0nO4RK/bNTHtm6E6nACyHz1PqD4CzIo6PJzyLdo0YJu3boxePBg/ve//5GTk8Ptt99+yR4bgYGBAFgsMgViTWXU1cOobQBAjnUbTlX+W7mTqlZuEcKfxZmjSirgJ8m4eq8nOYcICDLSLKEhAMkH08g4I70q3ElyDtf4Z6O+TQyqE1DhuDTqvV7xmLa8vLwK79unTx82bdrE/v37L7pNfn4+UDjWTdRcxV3wnaqFHMtOD0cjhBCF4kyRoCg4FUjKlka9t5OcQ0DpcfW7ZGo7UQP4ZaO+eBo71aGSvF8a9d4uNjYWRVHYvXt3hfct/vLMzLz4MIxdu3ahKArNmjVzOUZR9Up1wZdx9e4l49uEcNn5FfCTcqVYnreTnEMAtO7097j6XX9IF3y3kpzDJX7ZqG/Yoj5anRanwylP6n1ASEgIzZo1Y9Omizfk0tLSLlhns9n44IMPCAwMvOTYuM2bN9OiRQtCQkLcEq+oGqHnFcvLlka9e8n4NiFcFh4QQm1jEA4FkrJlTL23k5xDALTqFFvysxTLczPJOVyi83QAnmAw6mnYoh7JB05w6nAqNqsNvUHv6bBEJVx//fWsXLmSuXPnljnFzEMPPURWVhb/+te/qF+/PikpKSxdupS9e/fyyiuvXPTL02KxsHLlSvr161fVlyAqKVDXBJ2mDnbnGbIsW1BVJ4ril/ct3U5RCxdX9xXC38WZotiUd5gMax7nLLmEGYM9HZKoBMk5hCksmJjmdTm6P4VDu06Qn2shMFiGTLiD5Byu8duMNzahEapDxW5zkJp04R1V4V0eeOAB0tLSWLFiRZmv9+vXD41Gw9tvv83IkSOZM2cODRo04IsvvmDcuHEXPe7KlStJS0tj5MiRVRW6cBNFUTAZOwDgcGaRZ9vn4YiEEKJQnDmypFjeYRlX7/Uk5xAA8UXj6p0OJ3u2HPFsMMLv+W2jvklCDE574e2c5H2nPByNqKy4uDhuvPFGJkyYQHZ29gWv9+/fnx9++IGUlBRsNhtnz57lhx9+4I477rjoMbOysnj22Wfp0aMHLVu2rMrwhZvIfPVVRMa3CVEpceYonJrCVv0RqYDv9STnEACtz5+vXqa2cx/JOVzit4362OJieU6V5H0nPByNcIeXXnqJ9PR0xo4dW+ljqarKE088wZkzZ3jrrbfcEJ2oDqXnq9/swUh8jIxvE6JS4kyFxfIcUgHfZ0jOIUpVwJdx9e4jOYdL/LZRf34F/ONSAd8nxMTEMH36dBYtWsT06dNdPo6qqkyfPp2FCxfy2muvERsbe/mdRI0QbGiFRikcq5pl+eOScwGLCpC75kJUSlNTOBqKprWTJ/U+QXIOEVEvjMgGYQDs3XoUq8Xu4Yh8hOQcLvHbRn14/dqEhgXjtKskSwV8n3HfffcxYcIEJk2axLBhw8rsFncpWVlZjBgxgsmTJzNjxgyGDh1aRZGKqqAoOkKN7QCwOdKw2I95OCIhhIAArZ7GoXVwaOBI7lnsTqenQxJuIDmHKJ7azmqxcXBHsoejEf7Mbxv1iqIQ2yYG1aFyLjWTnHO5ng5JuMnYsWP5d6+hfPDfD2nZshXLli3DarVech+LxcKyZctISEjgo48+YuHChUyYMKGaIhbuJPPVVwG5ay5EpcWZCovl2Z0OTuRleDoc4Sbjxo1jzos38/FHS2jduqXkHH4m/rwu+Dtlvnr3kJzDJX45pV2x2NaN2PHLHgCO7z9Ji8QrPByRcIeftxxCNceR0HMcJ//6ikGDBjF27Fh69+5Nx44diY+PJzAwkPz8fHbt2sXmzZtLKs726NGDt956S7q/eTFTQCfILPw5q2ATkSF9PBuQL6jMF6Uff8EKcb44cxSrj+8CCovlxYTU9nBEwh1U6xbu7ZVOj2tiGDv5jOQcfuaCcfWjPBiMr5CcwyV+3ahv0iYG1VlcAV8a9b4gKzefJV9sxOEEfXAdVnz2BWHGAubPn8+PP/7I/PnzS42zVhSFFi1a0K9fP0aOHCkVZ31AiOFKFPSo2ORJvbtUpviMHxetEeJ8ceZIVEXBqagczk7nurqSc3g7VS1AzXkNvc5OXDMN3/5vAXuOtJKcw480bBaFqXYwWWdz2b05CafTiUbjtx2h3UNyDpf4daM+9rxieVIB3zd88OUmsvMsWBwKNyY25+p2hXdQX3/9dQBycnI4ePAgFosFo9FIs2bNCAkJ8WTIws20mgBCjG3ItmyhwH4Eq+M0Bm2Ep8MSQvi55kUV8J1SAd9nqHkfgjOF4BALGBIhsDetWimSc/gRRVFo3bkp61dvJycrn6P7UohtWc/TYQk/5NeN+sbxDVAUBadd5fh+mave223ff4KfNh/E6lAICQpg3OB/X7BNSEgIV155ZfUHJ6qVydiRbMsWoLALfnjwLR6OyLspauHi6r5CCKgfZCZYZ8But0ij3geotkOQt5KgAAtarRbF9B8UpfRTQsk5/EPrzk1Yv3o7UDiuXhr1lSM5h2v8un9IYEgg0U2jcDqcnDhwCofD4emQhIssVhsLVq7HqYLdqTB6wL+oUyvY02EJDwk9r1hetkXmq680KVojRKUpikKcOQqHAmmWbHKsFk+HJFykqg7UnFfRam0EGK0oIaNQdE0uv6PwSfGdzi+WJ/PVV5rkHC7x60Y9QGxCI1S7iiXfyulkuXPurVb+uJ2U9GwsdoW2cfW54/oET4ckPMgU0BEofGIi4+qFEDVFnCkKZ9HD3KRcyTmq2vnj2d0q/yuw7yckMB9F3wyCh1fNeYRXaBpfn8BgI1BYLK/K3ndCXILfN+qbJMTgdBT+8R2X+eq90tGTZ/ly3XZsDgWtVsv4oTeh0fhvoQwBOo2JIH0cALnWPdidFZs7WJSm8Hd3uAovng5eiBokzhz5d6M+O92zwfigfzam/tkd3i3ncKSh5r1HgNGKTudEMU1DUQxuP4/wHlqdlhbtGwNwJjWTlGNyw64yJOdwjd836mPbxJR010iWRr3XcTpV3l3xG3a7is0J99/Rmdj6dTwdlqgBTAHFXfCdZFu2ejQWUXFvvvkmjRs3JiAggMTERP7444+Lbrtr1y569+5N48aNURSFuXPnlrndiRMnuPfee6lTpw6BgYEkJCSwebMMzxDVp7k5EhQFhwJJOWc9HY5PUVW1pBH/008/MX78eF555RVWrFhBWlqa286h5sxDo+QRFGCBwP4ohg5uObbwbq07Sxd84Vl+36hv0qYRAE67k+P7pVHvbb7/fS/7j57G4lCIia7N4DsSPR2SqCFM542rzyqQLviVUjy9jKtLBS1fvpxx48YxZcoUtm7dStu2benevftFE/O8vDyaNGnCzJkzqVu3bpnbnDt3jquvvhq9Xs+3337L7t27eeWVVwgLC6twfEK4qrkpEiisgH9EntS7ldPpBGDevHm8+OKLKIrCjh07mDlzJklJSe45ifVXsG4gOLAARRuBEvqke44rvF6p+eo3SaO+Uqo55/AVfl39HiC6SRQBQUbsDrt0v/cyZzJyWfb1ZuxOcKoKzwy9CaPB79/SooipVLE8adRXSmWKz7iw35w5cxg+fDhDhgwBYP78+Xz99dcsXryY8ePHX7B9p06d6NSp8L93Wa8DzJo1i4YNG/Lee++VrIuNja14cEJUQqg+gPpBtTiddY7DOWdwqiqaKugi7m9UVUWr1XLixAkWLVrEW2+9RdeuXZk9ezYFBQV07twZu93OkSNHaNKkiUvziKvOXNSctzDo7Rj0dhTTJBSNqQquRnijuHYx6PRa7DYHO/845OlwvFs15xy+wu+f1Gs0Ghq3bohqV0k9lk5BboGnQxLltHjV7+RZbFgdCrdf35r2LRt6OiRRgxh0URh1hT1xsi1/4VSl0rTL3FCJNisrq9RisZT938NqtbJlyxa6detWsk6j0dCtWzd+//13ly/hyy+/pGPHjvTt25fIyEjatWvHggULXD6eEK6KM0fi0ECBw0Zqfpanw/EJxd3uf/vtN1q2bEnXrl3ZuHEjy5YtY8KECSiKwpYtW1iyZAnHjx936Rxq7mIUNZ3gwAIw3gDG7u68BOHljAEGrmhTmIeeOHyas2nyt+0yqX7vEr9v1APEnl8s74DMV+8N/thxhD92HsNqVwgzBTN6wL88HZKogYqf1qtYybH85eFo/FvDhg0xm80ly4svvljmdunp6TgcDqKiokqtj4qKIiUlxeXzHz58mLfffpsrrriC7777jpEjR/LYY4+xZMkSl48phCtKVcCX+erdqkmTJthsNqCwd06/fv1o06YNADk5OWzbto2QkJAKH1e17oKCrwgKsKDRBqKYplRJET7h3c6f2k664IvqJo16oEmbGFSpgO818vKtLFq1AYcKDlVh3OAbMIcEejosUQOZjB1Lfpap7VznchXaogUgOTmZzMzMkuXZZ5+t1mtwOp20b9+eF154gXbt2jFixAiGDx/O/PnzqzUOIZqbI1EVBRVIypFGvTs1aNCA7OxsbrzxRjIzM3nmmWeAwrobr7zyCjfeeCO1a9cuGX9fHqpqRc19DZ3WQYDRhhIyFkVbr6ouQXix1p2blvy8S4rlucwdOUdFVaQ4L8Cnn35KixYtCAgIICEhgW+++abU66qqMnnyZKKjowkMDKRbt24cOHDAteDKSRr1QGxRsTzVoUqj3gt8tHoLZzPzsNoVurRpTLcucZ4OSdRQf1fAh6wCqXLuMjd0hTOZTKUWo9FY5qnCw8PRarWkpqaWWp+amnrRInjlER0dTatWrUqta9myJceOHXP5mEK4Is5c2AvFoYHDOVIsrzKKp7A7duwYVquVunXrMmPGDOrVq4fdbue9997jvffeY+zYsej1esaMGQNUcKq7vBVgP0JwUAHoWkPQvVVwJcIXtOoYW/Le2ilP6l1Xzd3vK1qcd/369QwYMIChQ4fy559/0qtXL3r16sXOnTtLtnnppZd4/fXXmT9/Phs3biQ4OJju3btTUFB1w7ylUQ/EJhRVwHeoJEsF/Bpt/9E0vvttD1aHgtGo5+kh3aQLnLioAF0sek04ANmWLaiqw8MRealq/II1GAx06NCBNWvWlKxzOp2sWbOGrl27unwJV199Nfv27Su1bv/+/cTExLh8TCFcERNcG6NGh1OBpGyZ1q4yFEXhr7/+YuzYsXz22WekpqbSoUMHxowZw0033cR///tfPvnkE1q2bMlrr70GgN1uL3feoNqPo+YtJdBoRadVUMzTURRtVV6S8GKhtYJo3CIagKTdJ8jNljpdLqnmRv35xXlbtWrF/PnzCQoKYvHixWVu/9prr9GjRw+eeuopWrZsybRp02jfvj3z5s0rDF9VmTt3LhMnTuTOO++kTZs2fPDBB5w8eZLPP/+84gGWkzTqAVPtUMLr10a1Fz6pL77zK2oWu93BO5/+hsMJdicM73019SLNng5L1GCKopQ8rXeoOeTa9no4IlEe48aNY8GCBSxZsoQ9e/YwcuRIcnNzS6rhDx48uFT3favVyrZt29i2bRtWq5UTJ06wbds2Dh48WLLN2LFj2bBhAy+88AIHDx5k2bJlvPvuuzzyyCPVfn3Cv+k0GpqZInAqcDLvHAV2m6dD8jrnd5/PzMxk//79zJ49m5kzZ7Jp0ybat2/PxIkT+b//+z+WLVvGmDFjaNy4MQA6XflmySmck/51NBoLgQEWCB6Com91+R2FXyue2s7pVNmzJcnD0fivqizO+/vvv5faHqB79+4l2yclJZGSklJqG7PZTGJiYqUK/l6ONOqLxLaJwelwkpuVz9mUDE+HI8rwv592cuzUOawOheaNo+jXo72nQxJeoNTUdjJfvUuqe3xbv379mD17NpMnT+bKK69k27ZtrF69uqR43rFjxzh16u+ipidPnqRdu3a0a9eOU6dOMXv2bNq1a8ewYcNKtunUqROrVq3io48+onXr1kybNo25c+cyaNCgSv9+hKioOHMUDqXwodLRXHla76rp06ezatUq+vXrx6hRo9i2bRvPPvssCxYs4PDhwu7PYWFhrh284AewbSMksABF1wAleLQbIxe+6vxieTtlXL1L3JFzVGVx3pSUlEtuX/z/7i74ezkyqXeRJgmN2PzdnwAc33eCOtEufgmIKpGSnsWn32/D7lQADc8OvQmdVu5JicsLPX9cvWUT0TzguWC8laoULq7u64LRo0czenTZSfS6detK/btx48bl6mF12223cdttt7kUjxDuFGeOLFUBv3icvSgfjUbD0aNH+fTTT/noo49K6mXce++9TJs2jVdeeYU9e/Zw++23c80112AwGCp0fNWZgZr7LkaDDb3egWJ6HkUTVBWXInxM6WJ5Ml+9S9yQcyQnJ2MymUpWX6yOjy+RVlGRJm1iUJ2ACsf3ybR2NYmqqry78jcsNgdWB9zToz0tm7heMEv4l2B9C7RK4RRGWQWbZHiNK6p5fJsQvi7OFAmKUjiuXirgV0hx1/tTp05Rq1atkn9bLBYMBgPTpk2jQ4cO/PHHH8yYMYO1a9dW+BxqznwUMgkKsEDA7ShGmTZXlE+dumbqNqoDwL6/jmG12D0ckReq4cV569ate8nti//f3QV/L0ca9UVi2xQWSyoslnfCw9GI8/285RA79p/C6lCoW8fEiD5XeTok4UUURUuosQMANmc6BfYjng1ICOH3ip/MS6O+fJxOJ7t37wYKn9IDxMTEoNFo2LSpcFiV0WjEbi9sQF1zzTVMmTKF6667jqeeeork5ORyn0u1bgHL/xEcWIBGa0IJneDmqxG+rnhcvc1iZ/9fMsNKTeZKcd6uXbuW2h7ghx9+KNk+NjaWunXrltomKyuLjRs3Vqrg7+VIo75Iw7h66PRaVLtTntTXIFm5+Xzw5UYczsI56Z8a0o2ggIp1oxPCFCDz1VeGJ+aMFcKX1TYGE2EMwaFAUna69CC6jAULFjBlyhQ+/vhj0tMLpwGMjo5m8ODBzJw5k0mTJmG1WtFoNKSmprJixQry8/MZNmwYtWvXJiMjo1znUdUC1JzX0OvsGA12lNBnULR1qvDKhC+SLviVU905R0WL8z7++OOsXr2aV155hb179/L888+zefPmkiGDiqIwZswYpk+fzpdffsmOHTsYPHgw9erVo1evXu74FZVJxtQX0el1NGrZgKP7kjl5OBWr1YbBoPd0WH7vgy83kZVrweJQuDGxOVe3a3L5nYT4h/OL5WUVbCIq5B4PRuOFKtONXtoqQpQpzhzJhrxssmwFnLXkUScg2NMh1VgdO3Zk586dfPLJJ+zatYubb76Za6+9liFDhlC7dm3mzZtHx44dadGiBenp6URERHDnnXeSkpKCqqoXrXz9T2reh+BMITjEAoZECOxdxVcmfFF85/OK5W06TD8PxuKVqjnn6NevH6dPn2by5MmkpKRw5ZVXXlCct7iHEMBVV13FsmXLmDhxIhMmTOCKK67g888/p3Xr1iXbPP300+Tm5jJixAgyMjK45pprWL16NQEBAS5e2OVJo/48sW0acWT3MZwOJ6cOpRLTsoGnQ/Jr2/ef4KfNB7E6FEKCAhg3+N+eDkl4qRBjWxQMqFjJtmz2dDjepzJP3KVRL0SZmpuj+C218CleUk66NOovoUOHDnTo0IH333+fr7/+mgMHDrB//35uvfVW7rzzTq655hp++ukn9u/fT4cOHejYsbB31ksvvUSjRo1K/n0pqu0Q5K0kKMCCVqtFMf2n3PPZC3G++rER1AoPISM9h92bk3A4nGiluHP5eSDnqEhxXoC+ffvSt2/fix5PURSmTp3K1KlTXQvIBfIOO0+ThBic9sJ3w/F9Jz0cjX+zWG0sWLkepwp2p8LoAf+iTi1JeIRrNIqREGMbAArsR7HaUy+zhxBCVK04UySqoqACh7NlXP3FOByOUj87nU6OHTvGW2+9xcyZM1mzZg2hoaHcfffdjB8/nptuugmNRsPSpUv/n737Do+qSv8A/r3T02YoadQUkAAhdIjo2hZUWBv+otJWgQVcRUQEV0GzwNoQUcQCIiC67oKiYFndlaWsyCq9LZBQRFpCGklIT2Yy957fH0OGDKROyWQy38/z3Gdxcufed9gh875zznkPjhw5goULF9Z7DyFkiJK3oFZXwqC3QAqeCknDmYHkHEmSED/INgW/rLgCZ46xpiDPY1FfTVWzPKEIFvVetmHLYWTlFsNsldAnrgPuvTXB2yGRj3OYgs919Y3D7vdEbufQLI9Ffa2qpr3OmjUL27dvx7x587Bjxw4kJycjIyMDr776Kt5//30cPnzY/hyDwYB+/frhnXfeQfv27eu/Sfm3gPUkggPKIWm7AkFTPPVyyE/0qjYFn+vqG4k5h1NY1FcTk9AZACCsAmknWdR7y7mMfPxj22FUyhLUajVmT7odKhWnwJFrjAYW9U7jByyR23UJCYW6alu7Uhb1tZEkCdnZ2Th06BDGjx+P3r1ts67uv/9+fPDBBwgLC8Onn36Kt99+276FlF6vR8+ePdGjR496ry/kHIiyj2DQW6DRKJCML0KS2JCXXFO9qD+657QXI/FBzDmcwqK+mrbtWsPYNgSKzJF6b1EUgRXrf4bVKlCpAOPvHYyYDuw8S64L0fcHYPtyqKiCRX1jsPs9kfvp1BrEhoRCVgFpJfmoVOT6n+Sn2rZti4iICOzZswcAYLVaIcsyWrdujd/97neIjY3Frbfeam9s1VBCCIiSpVBJZbY96QNGQ9LVv/6eqD4xPTsgINi2N3rK3tPc4aIRmHM4h0V9NZIkIbZ3ZwhZoOBiEYryi70dkt/ZtPM4Tp67CLMsIapdGzxyb6K3Q6IWQqMyIkjXEwBQVnkCVqXIyxERkb+LM0ZAkQCrUJBeWuDtcJolRVGgVqsxYMAAfPvtt9i5cyc0Gg3UajUAwGg04rrrrsOYMWPs5zeY5SfAshNBARWQ1GGQQp7xxEsgP6RWqxA/MAYAcOliMTLO5no5ImrpWNRfJYbN8rwmr6AUa/+5D1YFUISE5ybdDr2OGzSQ+1xZVy9QVMEu+ETkXd1M4ZAvry47U8Kkv0r1UU2VSgVJkjBr1izccsstmDRpEl544QVs3rwZH3zwAV577TV07doVGo0GQgiHrafqvIdSClGyDDqtFTqtFZIxGZLK6KmXRH4ovtp+9Ue5rp48jEX9VWJ7R0EoVUV9ppej8S8ffb0L5eZKWGQJ99zaC/17dPJ2SNTChOivTKss5rr6huP6NiKPiDOGA1Xr6tksz65qK7njx49j3bp1WL16NTIyMjBnzhy8+eab+N///ofXXnsNmzZtwn333YeHH37Y4XkNIUpXQxK5CAqoAPS3AfrhHnkt5L96DareLI/r6huMOYdTOAx6FYdmeScueDka/7HnyFnsPnIOZquE1sYgTBtzs7dDohbIsVkeR+obypV1av68vo2oPuyAfy2r1QqNRoOvv/4aK1asQKtWrZCXl4f33nsPH3/8MUaMGIERI0bg9OnT6NSpk31kXpZl+5T8+ghLClDxHQIDzFCpAyAZ53FPenK7bn06Q6NTw2qR2SyvEZhzOIcj9VeJiu8ESZKgyOyA31TKyi348KtdkAUgCwlPP3wrTMEB3g6LWiCdOgwGTTQAoMR8GLJS4d2AfAm/MSdyu8gAI4xag62oL2FRL4SARqNBaWkpXnrpJTz66KNYu3Ytxo4dizZt2qBLly625nZCIDY2Flqt1l7UN7igFxaI0rehUVth0FdCCp4BSd2Abe+IGkln0CKuTxQAIPNcLvKzC70ckQ9hztFoLOqvYgjUo8N1kVBkBRm/ZEKW2Y3W0z7buB/5hWWwWCVc3zsatw/p7u2QqAWrWlcvUIkSy/+8HA0R+TNJkhB3eV19rrkERRb//qKxarT8u+++Q7du3TBy5EicO3cOb7/9NpKTkxEUFIQdO3Zg9uzZ9u3rGj3CXrYesJ5FUGAFoOkFBD7s7pdBZMet7aipsKivQUzvKAirgMVsRc45Nq7xpJPncrDx52OwyBL0ei2enTiMU+DIoxym4HNru4bh+jYij+l2uQM+AJxlszwAQLt27WCxWAAAL7/8MoYOHYpbb70VAKDVanHy5ElUVlY2+rrCmg5RtgYBegs0agmS6WVIUsNG+ImcEV+9qN/Lor5BmHM4hUV9DWIToqDItndFGjvge4zVKuODL36GrABWBZiSdAPah5u8HRa1cFc64LNZXkNxz1giz4kzhduL+tMl+d4Nppno2rUrAODxxx/H4cOH8eKLL9p/9u6776JXr17o2LFjo/b+tu1J/w5UKjMCDGYgcAIkbU+3x05UXc8BMfbBqhR2wG8Q5hzOYVFfg5iEzoAAhCK4rZ0Hfbc9BeczL8EiS+gWFY5Rwwd4OyTyA3pNZ2jV4QCAIvMBCGH1ckQ+gN+aE3lMnCkCkCTIEnCmmCP1Qgi0b98e9913H3799Vd07doVP//8M3bu3Im5c+fi7NmzmDt3rv3cBqvYDFQeQnBABSRNR0jBT3roFRBdEWQMQExPW8+GM8cyUVJY5uWIfABzDqewqK9BbG9bUwshC6SdZAd8T8jKLcIX/z4IqyIBUGHO5DugUfPtSJ4nSZJ9tF4RpSi1pHo5IiLyZ9cZbV8yKhJwlh3w7aOav//97zF58mRoNBosXLgQf/zjH1FRUYE33ngDWq0WVqu1EXvSF0CUroBeVwmtVoZknA9JFejJl0FkV7W1nRACqfvOeDkaaqm4pV0NIqLDEBBsQKVcyZF6DxBCYMWGn2GulGGRJYwe3g89YiO9HRb5EaN+EPLK/gkAKDLvRbC+t5cjat64vQyR5wRpdOgc1BqZRfk4W5IPRQio/Ly3jKIoUKlUeOihh3DLLbdAURSUl5cjNvbK+mSNpuEprChZDgmFCDSYAcPdkPTcNpeaTq/BXfCPj/8LwNYsb/DQeC9H1Lwx53AOh0ZroFKpEJPQGcIqcDE9H2Ul5d4OqUXZfuBXHDmZCYssIbKtEY8+eKO3QyI/w2Z5jcSpcEQe1c1oW1dfoVQis4zbXqlUKvvU+oiICLRr186hoG8MYdkPmP+DoIAKqNRGSCHPuzNUonpVb5aXwg749WPO4RQW9bWIqdYs78LJTC9H03IUlZbjk292Q1Zse9L/aeIwBBp03g6L/EygthvUUggAoMi8v3HrMv0RP2CJPCrOdKUDvr/sV1/f71137IQjRAVEyTvQaqzQ66yQQp6DpA51+bpEjdEm3Ij20bb33cnD52GusHg5omaOOYdTWNTXIiahMwQ74LvdJ//Yi6JSM8yyhKGJ3XBjP+e+eSdyhSSpYTQMBABYlTyUW/nNORF5T5wpAkKSIOA/zfKqivYDBw7g/fffx8KFC7F9+3b7/vPuIMr+DiiZCAowA9rBQECS265N1Bi9ErsAAKyVMk4cOu/laKglYlFfi+rN8riu3j2O/JKBH/edgkWWEBxowNMP3+btkMiPhVTf2o5T8OvE7WWIPCvOZGuWJ6v8Y6TearXtOvLvf/8bf/rTn3Dw4EEcPXoUU6ZMwdGjR91yD1H5K1C2AYF6M9RqNSTTi24Z/SdyRi9OwW8w5hzOYVFfi5iEzgAAhR3w3cJsqcSK9T9DEYBVkTBtzM0IbR3s7bDIj1Xfr76I+9XXjVPhiDyqU1BrBKi1UCTgTHHL36teo9FAlmXMnz8ff/zjH7FixQqMGzcOERER6N+/PwAgJyfH6esLIUOULIFaXQmD3gIpeCokDWcGkvfED+pi//NR7ldfN+YcTmFRX4vgVkEI7xwKYRVIP5HJNbcu2rDlMLJyi2G2SujdrT3uvTXB2yGRnwvWJ0Al6QGwWV69+AFL5FFqSYXrjGGQJSCzvABl1pa/5vbHH39EREQEHnzwQWRlZSE5ORnPPfccWrdujZSUFCxatAgnT5507uLl3wLWEwgKqICk6QIETXFv8ESN1C6qLdqEGwEAx/afhWyVvRxRM8acwyks6usQ2zsKiqygvKQCeRmXvB2OzzqfeQn/2HYYlbIEtVqNOZPugErFKXDkXSpJh2BdXwCAWU6H2cqGmETkPd2MtmZ5AsD5kpY/Wh8VFQWLxQJJkvDGG29g8ODB+N3vfgcAUKvVSElJgaIojb6ukHMgyj6CQW+BViNDMr0ESWJDXvIuSZLsU/DLS804ncqlveReLOrrEN2rMxRrVbM8TsF3hqIIfPDFT7BaBSoVYPy9gxHTsa23wyICcNXWdpyCXyuubyPyvDhTuL0D/mk/WFcfGRkJk8mEBx54AFu2bMHChQshSRKEEHjrrbdw3XXXoXv37o26phAComQpVFKZbU/6gNGQdAM99AqIGid+MKfgNwRzDuewqK9DbO8o+1QOdsB3zqadx3Hy3EWYZQmd27XBI/cmejskIjuHdfWcgl87ToUj8rg4UwQgSZfX1be8DvhVo+5ZWVkoKipCUFAQnnzySQQEBKBdu3b44osvsGnTJsyePRupqal4+eWXHZ7XIJafAMtO27R7dRikkGc88VKInOLQLG8vm+XVijmHUzTeDqA5i+19pVle+kkW9Y2VV1CKT/+1D1YFUISE2ZNuh17Htxw1HyH6frB9t6mgmCP1tXLl229//tacqDG6GS93wJeAsy1s+r0sy1Cr1UhPT8err76KESNG4Pbbb8cNN9wAAPjuu+/w2WefIT8/H7/73e/w+uuvIyQkxP68hhBKKUTJMui0Vui0VkjGZEgqoydfFlGjRMW1Q5DRgNKiChzdcxpCCO7IUAPmHM5hhVWHjt3aQ6vTQFgVpB1nUd9YH329C2UVlbDIEu65tRf69+jk7ZCIHKhVwQjS9USp5SjKKk+iUi6AVt3K22E1P658++3HH7BEjdFaH4gIQwguWYtwpji3RSX8VYX5rFmz0KFDB1x//fUwGAwAgL59+9qL++zsbERERFzzvIYQZashiVwEBVQA+tsA/XA3vgIi16nVKvQcGIu9/0lFYV4JLpzOQccuEfU/0d8w53AKp9/XQa1RIyq+ExRZIPtsDizmlt+N1l32HjmH3UfOwWyV0NoYhGljbvZ2SEQ1qj4Fv9i8z4uRUHVLly5FdHQ0DAYDEhMTsWfPnlrPTUlJQVJSEqKjoyFJEpYsWVLntV977TVIkoQZM2a4N2giF3UzhUNWAcVWM3IrSr0djltU7R70/fffIzs7GwsWLEBYWBhOnz6N6dOn4/7778fTTz+NsrIyh4K+UfewpADl3yHQYIZKHQDJOK/FfCFCLUuvQVem4B/ZzSn45D4s6usR09vWLE9RBDJOZXs7HJ9QVm7Bqq92QhaALCQ8/fCtMAUHeDssohqxWV4DNPH6tnXr1mHmzJmYN28eDhw4gD59+uDOO++sdd/qsrIyxMbG4rXXXkNkZGSd1967dy8++OAD9O7du/GBEXlYnCnC3izvTEnLWFdfVVyfP38eUVFR0Ov12L59O5YsWYKsrCxMnDgR+/btw759zn2pKoQFovRtaNRWGPSVkIJnQFK3d+dLIHKb+Orr6tksr2ZcU+8UFvX1iOkVBSGzA35jfLZxP/ILy2CxSri+dzRuH9K47rVETSlEf6UzMpvl1Uxy8WisxYsXY8qUKZg4cSJ69uyJ5cuXIzAwEKtXr67x/EGDBmHRokUYPXo09Hp9rdctKSnBuHHjsHLlSrRu3dqJyIg8K84YASFJEADOFLesDvj9+vVDTk4OZs6ciaeeegpdu3bFkiVLMHr0aHTt2hWnTzs5alm2HrCeRVBgBaDpBQQ+7N7Aidzout6dodXbVj8fZbO8GjV1ztFSsKivR1WzPKEIpLMDfr1OnsvBxp+PwSJL0Om0eHbiME6Bo2ZNpw5FgMb2zXmp5ShkpczLETVDbvjWvKioyOEwm8013spisWD//v0YNmyY/TGVSoVhw4Zh586dLr2MJ554AnfddZfDtYmakziTrVmeIgFnWti2dgkJCbj33nsRHh6OmTNnYvr06Wjfvj3OnTuHo0ePom/fvgCuTNdvCGFNhyhbgwC9BRq1BMn0MiSp4evwiZqaTq9BXN8oAEB2Wj4uZhZ4N6DmiCP1TmGjvHrE9rb9wxNWwW3t6mG1ylixfgdkBbAqwOMP3ID24SZvh0VUL6NhMMpLTkPAihLzIZgCbvB2SC1Op06OjTLnzZuH+fPnX3Nebm4uZFm+Zm1tREQEjh8/7vT9P/vsMxw4cAB793I2BjVfMSGh0EoqyCrZp4v6q5v8Xbx4EWFhYXj88cehKApUKtuYUkpKChYsWIDbbrsNffv2bVRzQNue9O9ApTIjwGAGAidB0vb0yOshcqeExC44uts29T5lz6+49b4BXo6IWgIW9fVoHdEKrcJNKCkuQfrJTG+H06x9tz0F5zLyYZEldIsKx6jh/CVFviFEPwjZJZ8BsK2rZ1HvyB3by6SlpcFovLK9VF3T5N0tLS0NTz31FDZv3mzvuE3UHOlUasSEhOLMpWyklV6CRbZCp/a9VK2qOP/666+xbds2pKamIioqCrNmzUL37rYleRcuXMBnn32GVq1a4ZVXXnF4XoOYNwOVhxAcVAFJ0xFS8JOeejlEblV9Xf3RPadZ1F+FW9o5h9PvGyD2crO8orxiFOYWeTucZikrtwhf/PsgrIoEQIU5k++ARs23F/kGNsurhxumwhmNRoejtqI+NDQUarUa2dmOjUmzs7PrbYJXm/379yMnJwf9+/eHRqOBRqPBjz/+iHfeeQcajQayLDt1XSJPqGqWJwsF6aWXvB1Oo8myDJVKhePHj2PhwoVo06YN5s+fjz179mDs2LFYtGgR8vPz0aFDBzz11FOYO3cutFqt/XkNIZQCiJIV0OsqodXKkIzzIakCPfzKiNyjR/9oqFS2L69S9nBd/TU4/d4prLoaIKZX52rN8jgF/2pCCKzcsAPmShkWGXjozn7oEetc8k3kDXp1B+jU7QAAxeaDUESllyNqhprow1Wn02HAgAHYunWr/TFFUbB161YMGTLEqdCHDh2KI0eO4NChQ/Zj4MCBGDduHA4dOtSovbCJPC3OFA758mD1aR+cgl/172n+/Pm46667MHfuXOh0OhgMBkyYMAGffvoppk2bhu+//x6hoaEIDw93eF5DiJLlkFCIQIMZMNwNSc9tc8l3BAYb0CW+IwDg7IlMFBe0jO0r3YoFfaP53pwuL4jpHQWhXCnqe93Ibu7VbT/wKw6fzIBFlhDZ1ohHH7zR2yERNYokSTDqByK37FsoohylllSE6Pt4Oyy/NXPmTIwfPx4DBw7E4MGDsWTJEpSWlmLixIkAgEceeQQdOnTAggULANia66Wmptr/fOHCBRw6dAjBwcHo2rUrQkJC0KtXL4d7BAUFoW3bttc8TuRtccYIQJKgSMJnO+AfP34cRqMRDz9s60T/l7/8Bb///e/x5JNPwmKxYOXKlThy5AhuuukmBAcHN+rawrIfMP8HQYEVUKmNkEKe98RLIPKo+MGx+OVIGgAgZe8ZXH87P4vINSzqG6B6szx2wHdUVFqOT77ZDVmx7Un/zIShCDTovB0WUaMZDYOQW/YtANsUfBb1VzT1+rZRo0bh4sWLmDt3LrKystC3b19s3LjR3jzv/PnzDtN0MzIy0K9fP/t/v/HGG3jjjTdwyy23YNu2bc4FTuQlcSbb+9yXO+CHh4dj2LBhMJlM9lk3999/PwBg8ODBCAwMRFJSEoKDgyHLcoNH6YWogCh5B1qNFXqdFVLIs5DUoR57HUSe0mtwLL7+8EcAtin4LOqv4Jp657Cob4Conh2hUklQZAXpJ1nUV/e3b/eiqNQMsyxhaGI3/KZ/F2+HROSUEP2VdfXFFXsB42QvRtPMuDKtzcnnTZs2DdOmTavxZ1cX6tHR0Y3aBqumaxA1F+GGYLTSBaDcWuazRX2bNm3wwAMPQKVSITAwEBaLxd6kcvfu3Th27BimTp0KoJHT7sv+DiiZCAo2A9rBQMADHomfyNPiB1Vrlrf3Vy9G0gx5IedoCVjUN4DOoEPHuPa4cDoTGacyIVtlqDVcg3nklwxs23sKFllCcKABTz98m7dDInJaoPY6aFQmWJVCFJn3QQgFksS2IwC/NSdqSpIkoZsxHAfKzyLfXIoCSxla6Zp3E7iq0XZFUSBJEgoKCtC6dWsAtu0oL126hAkTJiAqKgrbt2/Hp59+CgAO29vVR1SeBso2INBghlqthmR6seGd8omamVahIejYJRzpv+bgl8NpqCi3wBDAma4Acw5nMWNtoJgEW7O8SouMrLM53g7H68yWSqxY/zMUAVgVCU+MvgmhrRu3Lo6oOZEkFUL0AwEAVuUSyiv5zTkReUdVB3wAOFOc791g6mG1Wu0F/euvv45Ro0bhySefxIwZM5CdnY3Y2Fh89tln6NGjB1q1aoU333wTvXr1alxBL2SIkregVlfCoLdACn4ckia2/icSNWO9Lo/Wy1YFJw6e83I05OtY1DdQTEIUFHbAt/tyy2Fk5RbDbJXQu1t73Hdbb2+HROQyo7761nZ7vBhJM8PtZYiaVPWi/mwznYJfWlqKvLw8aDS2SZ/PPPMMduzYgT59+uCmm25CRkYGhg0bhk8//RSxsbFYtGgRXnrpJdxxxx0A0LhR9vJvAesJBAVUQNJ0AYIe9cRLImpSDvvV7+ZAgh1zDqdw+n0DxfaOAgQgFIG0Exm4/q4B3g7Ja85nXsI32w6jUpagVqsxZ9Id9v02iXyZw371FXsRGTLOi9E0H5wKR9S04ozhgCRBlgTOFOd6O5wavf766ygqKsLYsWPRqVMnpKen47XXXkPPnj0BACNHjsSnn36Kjz/+GNdddx0GDhzoMDLf0KJeyDkQZR/BoLdAq5EhmV6CJHGaMvm+XoOv9KE6yv3q7ZhzOIcj9Q1k74AvC1zw42Z5iiKwYv1PsFoFKhXgkXsHI6ZjW2+HReQWQbp4qCRbM6ci814vR9OM8FtzoiZ1nTEcEmwd8E83023tOnbsiMzMTLzzzjvYsGEDgoODodNdKbYjIiIwbtw4qFQq/Oc//3HqHkIIiJKlUElltj3pA0ZB0g1010sg8qqITm3QNtIEADh24CyslbKXI2ommHM4hUV9A4V3DkWgMQCKVfj19PvNu47jxNmLMMsSOrdrg/H3Jno7JCK3UUk6BOtsW6NZ5ExUWC94OSIi8kcBGi2igttAVgHnSvMhC8XbIV1jypQpWLBgATp16oRNmzZhx44d+Oabb2C1Wu3nhIWF4eabb8a5c+cgy04ULJafAMtO27R7dRikkD+58RUQeZckSeh1eQq+udyCX1PSvRwR+TIW9Q0kSZK9WV5exiWUFpV5O6Qml1dQirX/3AerAihCwuxJt0Ov4woOalmqT8EvruBoPQB+a07kBXFG27p6i2JFRlmht8OpUUxMDF599VU8+eSTGDx4MP71r39h8eLFOHz4MADg+PHj+O6773DDDTfYm+k1lFBKIUqWQae1Qqe1QjImQ1IZPfVSiLyiVyKn4F+DOYdTWNQ3Qmy1ZnnpJzO9HE3T++jrXSirqIRFlnDPrb3Qv0cnb4dE5HaOzfJY1ANX1rc5exBR43Uzhdub5TXXKfhVhg0bhrfffhsjRozAzz//jOnTp+Pee+/F4sWLMXLkSIwbZ+tP0tBu9wAgylZDErkICqgA9LcB+uGeCp/Ia6qvq0/Zw2Z5AHMOZ7Gob4SY3lEQ9g74/jUtd++Rc9h95BzMVgmtjUGYNuZmb4dE5BEh+n6QLvcQZVF/Gb81J2py3U0REJIERQLOljTPZnnVtW7dGs888wyef/559O7dGxcuXEBkZCSmTp0KAI0bpbekAOXfIdBghkodAMk4j3vSU4vU+boIBJsCAQApe8806t9Ji8Wcwyks6huherO89BP+M1JfVm7Bqq92QhaALCQ8/fCtMAUHeDssIo9QqwIRpIsHAJRXnkKl3Lz3iG4KkhAuHUTUeHGmCAC2ZnnNfa/66hITE/Hmm29i/Pjx6N+/P4KCgiCEaMSe9BaI0rehUVth0FdCCp4BSd3ew1ETeYdKpUL8oBgAQNGlUqSdyvFyRN7HnMM5LOobIbqXbbq5YhVIP+k/I/WfbdyP/MIyWKwSru8djduHdPd2SEQe5bC1nXmfFyMhIn/VIbAVAtXay0V98x+pr06r1WL69OkYOXJk459cth6wnkVQYAWg6QUEPuz2+IiaE07BJ3dgUd8IQcZAREaHQZEVpJ/M9IspMr+cz8HGn4/BIkvQ6bR4duIwToGjFs9hXT2b5XEqHJEXqCQJ3UzhkCUgq6IIpZUWb4fktAbvSW9NhyhbgwC9BRq1BMn0MiRJ7eHoiLwr/nIHfAA4upfN8phzOIdFfSNVrauvKDUj94LvTIdzhtUq44MvdkBWAKsCPPrADWgfbvJ2WEQeF6K/sg9yMdfVs2kNkZdUdcAHgLMlzbtZnqtse9K/A5XKjACDGQicAEnb09thEXlc114doTdoAQAp7IDPnMNJLOobKTYhCoq1qlley96v/rvtKTiXkQ+LLKFbVDhGDR/g7ZCImoRW3RoB2usAACWWFMhKqZcj8jJ+a07kFXEm/ynqYd4MVB5CcEAFJE1HSMFPejsioiah1WnQvX80ACDnwiXkXLjk3YC8jTmHU1jUN1JM7yj7mya9BRf1WblF+GLTQVgVCYAKcybfAY2abxfyH0b7aL2MYvNBr8ZCRP4pzhQOXO6Af6YFF/VCKYAoWQG9rhJarQzJOB+SKtDbYRE1mfhB1abgc109OYFVWiPF9u4MAFCsCtJOtsyiXgiBlRt2wGyRYZGBh+7shx6xkd4Oi6hJcb/6KzgVjsg7rjOGAwBkCTjtY83yGkOULIeEQgQazIDhbkh6bptL/qVX9XX1u/27qGfO4RwW9Y3UvmskdAYtFFkgvYXuVb/9wK84fDIDFllCZFsjHn3wRm+HRNTkHDrg+3uzPE6FI/IKky4A7QKMlzvg50G0wO2ahGU/YP4PggIqoFIbIYU87+2QiJpc9/7RUF2eEXvU39fVM+dwCov6RlKr1YiK7wQhC2SfzYW53He70dakuLQCn3yzG7Ji25P+mQlDEWjQeTssoian13SA7vLeyCWWg1BEy/q33hj81pzIe+JMEZBVQJlsQU5FsbfDcSshKiBK3oFWY4VeZ4UU8iwkdai3wyJqcgFBenTt1REAkHYqG4X5JV6OyHuYcziHRb0TqprlCSFw4ZdMb4fjVp98uwdFpWaYZQlDE7vhN/271P8kohaqarReEWaUWo56ORoi8kdxxnB7s7wzxS1rXb0o+zugZCIowAxoBwMBD3g7JCKvqT4FP4Vb21Ejsah3Quzlbe0AIL0Fras/8ksGtu09BYssITjQgKcfvs3bIRF5lVE/2P5nv56Cz6lwRF4TZ4qAkCQItKxmeaLyNFC2AYF6M9RqNSTTiw3ez56oJeqVeGUgza+3tmPO4RQW9U6IudwsT8iixWxrZ7ZUYsX6n6EIwKpIeGL0TQhtHeztsIi8ymFdPZvlcRockRd0M9ma5bWkDvhCyBAlb0GtroRBb4EU/DgkTWz9TyRqwRw74PtxUQ/mHM5gUe+EmITLHfBl0WJG6r/cchhZucUwWyX07tYe993W29shEXldgKYLNKo2AIBi834IoXg5Ii8RwrWDiJwWHdwWWpUasgo401I64Jd/C1hPICigApKmCxD0qLcjIvI6Y+sgdL7OttvUqaPpKC81ezkiL2mmOUd+fj7GjRsHo9GIVq1aYdKkSSgpqbv3QUVFBZ544gm0bdsWwcHBSEpKQnZ2tsM5kiRdc3z22WeNjo9FvRNahZnQJrKVfaTe17vRns+8hG+2HUalLEGtVmPOpDugUnEKHJEkSfb96q1KIcoqT3o5IiLyN1qVGl1DwqBIQHpZASyy1dshuUTIORBlH9n2pNfIkEwvQZLYkJcIuLKuXpEVHD9w1rvBkINx48YhJSUFmzdvxnfffYft27fj0Ufr/kLy6aefxrfffosvvvgCP/74IzIyMvB///d/15z30UcfITMz036MHDmy0fGxqHdSTG9bs7ySS6UoyCn0djhOUxSBFet/gtUqUKkAj9w7GDEd23o7LKJmw2gYaP+zv07BZydaIu+KM4VDlgBFCJwvzfd2OE4TQkCULIVKKkNQQAUQMAqSbmD9TyTyE/GDOQW/OeYcx44dw8aNG7Fq1SokJibiN7/5Dd5991189tlnyMioedZ2YWEhPvzwQyxevBi//e1vMWDAAHz00UfYsWMHdu3a5XBuq1atEBkZaT8MBkOjY2RR76TYhM4Qsm0qbtpJ3+2Av3nXcZw4exFmWULndm0w/t5Eb4dE1KyE6K+sqy/212Z5bFpD5FVxpohqHfB9t6iH5SfAstM27V4dBinkT96OiKhZ6TW4WrM8f+2A74aco6ioyOEwm11byrBz5060atUKAwde+RJy2LBhUKlU2L17d43P2b9/PyorKzFs2DD7Y927d0fnzp2xc+dOh3OfeOIJhIaGYvDgwVi9erVTs8BZ1DsppncUhAJAAOknLng7HKfkF5Zi7T/3waoAipAwe9Lt0Os03g6LqFkJ1sVDJQUCAIrM+3x+uY0zJMW1g4hc080YDkgSFAk47aPr6oVSClGyDFqtFTqtFZIxGZLK6O2wiJqV8A6tEd6hNQDg+IGzqLT49nIbZ7gj5+jUqRNMJpP9WLBggUsxZWVlITw83OExjUaDNm3aICsrq9bn6HQ6tGrVyuHxiIgIh+e8+OKL+Pzzz7F582YkJSVh6tSpePfddxsdIys4J1U1yxOyQJqPNsv76KtdKKuohEWWcM8tvdC/Rydvh0TU7EiSBiH6fiis+BkWOQtmazoMWv5bIaKmE2eKAHC5A36pjxb1ZashiVwEB1QA+lsB/XBvh0TULMUPjkXOV/thrqjEqaPp6NE/2tsh+Zy0tDQYjVe+NNTr9TWeN3v2bCxcuLDOax07dsytsV3tz3/+s/3P/fr1Q2lpKRYtWoTp06c36jocqXdS5x4doVKroMgK0n1wW7u9R85h15FzMFsltDYGYtrYm70dElGzZdT7+dZ2nH5P5FWh+iC00QdClnxz+r2wpALl3yHQYIZKHQDJOI970hPVole1re38cr96N+QcRqPR4aitqJ81axaOHTtW5xEbG4vIyEjk5OQ4PNdqtSI/Px+RkZE1XjsyMhIWiwUFBQUOj2dnZ9f6HABITExEenp6o5cMsKh3kk6vRefuHaBYBTJ/zYa10nemx5RVWPDhVzshC0AWEp5++DaYggO8HRZRs+W4X/0eL0biHc2xaQ2RP5EkCXFG27r6AksZLplLvR1SgwlhgShdAo3aCoO+ElLwDEjqDt4Oi6jZiq+2rv7I7l+9GIl3NGXOERYWhu7du9d56HQ6DBkyBAUFBdi/f7/9uf/5z3+gKAoSE2vuRzZgwABotVps3brV/tiJEydw/vx5DBkypNaYDh06hNatW9f6RURtWNS7IKZ3ZwhZwFopI+tMTv1PaCbWbdyPvMIyWKwSru8djduHdPd2SETNWrCuLyRoAQBF/tgsr5nuGUvkT+JM4Vea5ZX40Gh92XrAehZBgRWAphcQ+LC3IyJq1jpfFwFj6yAAQOq+M1AUP2tO0wxzjh49emD48OGYMmUK9uzZg59//hnTpk3D6NGj0b59ewDAhQsX0L17d+zZYxv8MZlMmDRpEmbOnIkffvgB+/fvx8SJEzFkyBBcf/31AIBvv/0Wq1atwtGjR3Hq1Cm8//77ePXVV/Hkk082OkYW9S6ITbBtawcAaT4yBf+X8zn4/qdjsMgSdDotnp04jFPgiOqhVgUgSNcLAFBhPQOLfNHLETUtjtQTeV83YwQUle3z+oyPNMsT1nSIsjUI0FugUUuQTC9DktTeDouoWZMkCfGDYgAAJYVlOHey5kZsLVVzzTnWrFmD7t27Y+jQofjd736H3/zmN1ixYoX955WVlThx4gTKysrsj7311lu4++67kZSUhJtvvhmRkZH48ssv7T/XarVYunQphgwZgr59++KDDz7A4sWLMW/evEbHx6LeBfZmeYpAmg90wLdaZXzwxQ7ICmBVgEcfuAHtw03eDovIJ1Sfgl9csc+LkfiHpUuXIjo6GgaDAYmJifZvvmuSkpKCpKQkREdHQ5IkLFmy5JpzFixYgEGDBiEkJATh4eEYOXIkTpw44cFXQORecSZb52Xbuvo8L0dTP9ue9O9ApTIjwGAGAidA0vb0dlhEPqH6FHy/XFffDLVp0wZr165FcXExCgsLsXr1agQHB9t/Hh0dDSEEbr31VvtjBoMBS5cuRX5+PkpLS/Hll186rKcfPnw4Dh48iOLiYpSUlODQoUP44x//CJWq8SU6i3oXxPSOAmDrgJ/uA3vVf7c9Becy8mGRJXSLCseo4QO8HRKRz/DrZnluaFrTGOvWrcPMmTMxb948HDhwAH369MGdd955TZOaKmVlZYiNjcVrr71Wa/OZH3/8EU888QR27dqFzZs3o7KyEnfccQdKS31nbTL5t67GMKhg29buTEnzL+ph3gxUHrq8J30HSMGNn05K5K96JV4p6o/u8bN19U2cc7QU3NLOBWEd2yK4VRAqzBVIO968R+qzcovwxaaDsCoSABVmT7oDGjW/0yFqKKN+IAAJgECR2b9G6l2Z0ubM8xYvXowpU6Zg4sSJAIDly5fjn//8J1avXo3Zs2dfc/6gQYMwaJDtS5eafg4AGzdudPjvjz/+GOHh4di/fz9uvpm7f1DzZ1BrER3SFmkFF3GuNB9WRYHGidGcpiCUAoiSFdDrKqHTypBM8yGpAr0dFpHP6BrfAYZAHSrKLDi65zSEEH6zXLapc46Wonl+GvgISZLszfIuZReipKB5jvgIIbByww6YLTIsMvDQnf3Qs0vtWykQ0bU0ahMCtd0AAKWWVFiVYi9H1ITc0LSmqKjI4ahtqxaLxYL9+/dj2LBh9sdUKhWGDRuGnTt3uu0lFRYWArBNpyPyFXFGW7O8SkVGRlmBt8OplSj5ABIKEWgwA4a7Ielv8XZIRD5FrVHb96fPyypEdpoPNcd0VTNslOcLWNS7qHqzvPSTzbNZ3n8PnMbhkxmwyBIi2hrx6IM3ejskIp90ZQq+gmLzQa/G4ms6deoEk8lkPxYsWFDjebm5uZBlGREREQ6PR0REICvLPc2CFEXBjBkzcOONN6JXr15uuSZRU4gzRVTrgN88p+ALy37AvBVBARVQqUMghTzv7ZCIfFL84Cv71fvdFHxqNBb1LopJ6AyhXC7qm2EH/OLSCvz1m12QFdue9M9MGIpAg87bYRH5JMdmef6zrt4dnWjT0tJQWFhoP+bMmeO11/PEE0/g6NGj+Oyzz7wWA5EzuhnDISTbuvrTzbADvhAVECXvQKuxQq+zQgp5DpI61NthEfmkXn7aLK+5dr9v7rim3kXVm+U1x23tPvl2D4pKzbDIEoYmdsNN/bvU/yQiqlGIvzbLc6X5zOXnGY1GGI3Gek8PDQ2FWq1Gdna2w+PZ2dm1NsFrjGnTpuG7777D9u3b0bFjR5evR9SU4ky2GSxKM+2AL8rWAEomgoLNgHYwEPCAt0Mi8llx/aKg0aphrZRxdK//FPXuyDn8EUfqXRTTqxMAQLE2v6L+yC8Z2Lb3FCyyhKBAA55++DZvh0Tk0/SaSOg1tn/zxeZDUETN68Jbmqb81lyn02HAgAHYunWr/TFFUbB161YMGTLE6dcghMC0adPw1Vdf4T//+Q9iYmKcvhaRt3QINCFIo2uWRb2oPA2UrUeg3gy1Wg3J9KLfNPYi8gRDgA5dE2xfPqf/moOCXP/o5cOReuewqHdRQHAA2neJgCIruPBLJhRF8XZIAACzpRIr1v8MRQBWRcITo29CaOvg+p9IRHWqWlcvYEGJ+YiXo2mZZs6ciZUrV+Kvf/0rjh07hscffxylpaX2bviPPPKIw/R9i8WCQ4cO4dChQ7BYLLhw4QIOHTqEU6dO2c954okn8Pe//x1r165FSEgIsrKykJWVhfLy8iZ/fUTOkiQJcaYIyBKQYy5GaWXz+GJRCBmi5C2o1ZUw6C2Qgh+HpImt/4lEVKdeg6pNwfen0XpqNBb1bhDTOwrCKmAut+BiWvNY4/bllsPIyi2G2Sqhd7f2uO+23t4OiahF8Mv96hXh2tFIo0aNwhtvvIG5c+eib9++OHToEDZu3Ghvnnf+/HlkZmbaz8/IyEC/fv3Qr18/ZGZm4o033kC/fv0wefJk+znvv/8+CgsLceutt6Jdu3b2Y926da7//RA1oTjjlWZ5p5tLs7zybwHrCdue9JouQNCj3o6IqEVwbJbnJ0V9E+ccLQXX1LtBbEIUfv56DwAg7UQmIqLCvRrP+cxL+GbbYVTKEtRqNeZMugMqFafAEblD9WZ5RRV7ANPjXoymiXhhfdu0adMwbdq0Gn+2bds2h/+Ojo6GqGcbm/p+TuQrupnCr3TAL85FQuv2Xo1HyDkQZR9Br6uEViNDMr0ESWJDXiJ3iB90ZanY0d1+0gGfa+qdwpF6N4hJ6Gx/A6afuODVWBRFYMX6n2C1ClQqwCP3DkZMx7ZejYmoJTFoYqBV2f5NFZv3QwjZyxF5ngQX1rd5O3iiFibOFA5IEmQJOFPi/b2rRclSqKQyBAVUAAGjIOkGejskohYjpFUQouPaAQBOp15AaXGFlyPyPOYczmFR7wZVHfAVq+L1Znmbdx3HibMXYZYldG7XBuPvTfRqPEQtjSRJCDHYklZZlKCs8oSXIyIif9LNaJsNqEjAWS9vayfMPwGWnQg0VEBSh0EK+ZNX4yFqiaqm4CuKwPEDZ7wcDTVXLOrdoF1sOAyBeiiy8Ope9fmFpVj7z32wKoAiJDz3h9uh13GFBZG7Oayr94f96oVw7SAitwnRGtAhsJWtA35JHhQv/RsTSilEyVJotVV70r8ASVX/tpVE1Di9/G1dPXMOp7CodwO1Wo3oXp0grAI5aXmoKPXO1JiPvtqFsopKWGQJ99zSCwN6dvJKHEQtnVE/2P5nf2iWx+1liJqXOFM4ZBVQLlciu7zIKzGIstWQRC6CAyoA/a2AYYRX4iBq6eIHX+mA7w9FPXMO57Cod5OYhCgosoAQAhdOZTX5/fcePYddR87BbJXQ2hiIaWNvbvIYiPxFkK4H1JJti8is/F04ePAgdu/ejUOHDqGkpMTL0XmAcPEgIrfqZqzeLK/pO+ALSypQ/h0CDBao1AGQjPO4Jz2Rh4S1a4XITrZePicOnUN+XgEOHTrUcvMO5hxO4dxsN4lJ6Awh295J6Scy0KVPdJPdu6zCgg+/3AlZALKQMOP3t8EUHNBk9yfyN8eOncC7iyvx849ZOPfrGQjR3/4zSZIQFxeH22+/HY899hh69uzpxUiJqCWKM0VASBIEBM6U5OGGiKbbE14IC0TpEmjUVgToLZCCZ0FSd2iy+xP5o9Auevzn8DYUyhcQGrbYYUcX5h0EsKh3m9jLzfKELJB2vGk74K/buB95hWWwWCVc3zsad9zQvUnvT+Qvzpw5g6lTp2Ljxo0IDw9DUtIEDHp+EHr27InAwECUlZUhNTUVe/fuxbp16/Duu+9i+PDhWLZsGWJiYuq/QTMlCQHJyXVqzj6PiGoXZ4oAAMgq4HRJEzfLK1sPWM8iKKQC0PQCAh9u2vsT+ZHqeUfbtqEY+9CDGDSoZecdzDmcw6LeTWISOgMAFFkg7WTTNcv75XwOvv/pGCyyBJ1Oi2cnDuMUOCIPWLVqFWbMmIHQ0FCsWbMGDzzwAHS6a/diTkxMxMSJE7FkyRKsX78ec+bMQUJCApYsWYLJkyd7IXI3UC4fzj6XiNwqKqgN9CoNFKkSZ4ubbls7YU2HKFsDg94CjVqCZHoZksRUksgT/DbvYM7hFK6pdxNj2xCEdmgDYRVIP5nhMC3GU6xWGSu+2AFZAawKMCXpBrQPN3n8vkT+5pVXXsGUKVMwZswYHDlyBGPHjq3xg7U6nU6HsWPH4ujRoxgzZgymTJmCV155pYkidq+qb82dPYjIvTQqFboaw6BIQEZZASqslR6/pxACouQdqFRmBBrMQOB4SFpO8yXyBH/OO5hzOIdfr7pRTO8o7N9yCKWF5biUXYA2ka09er/vtqfgbEY+LLKEblHhGD1igEfvR+SPVq1aheTkZLz00ktITk5u9PNDQkKwcuVKdO7cGcnJyYiMjMSkSZM8EKkHudJ8xn8/X4k8Ks4YjmP5GVAgcK403z4l32PMm4HKQwgKqoCk7gApeLpn70fkp/w+72DO4RSO1LtRTK8rzfLSPLxffXZeEb7YdBBWRQKgwuxJd0Cj5v+dRO505swZzJgxA5MnT77mg3Xbtm2QJKnGY9euXddcKzk5GZMnT8ZTTz2FM2fONNVLIKIWKs4U0WQd8IVSAFGyAjptJXRaGZJpPiRVoEfvSeSPmHeQszhS70axvaMgFAACSD+egT63xHvkPkIIrFy/A2aLDIssYdTwfujZJdIj9yLyZ1OnTkVoaCgWL15c6znTp0/HoEGDHB7r2rXrNedJkoQ333wTmzZtwtSpU/H999+7PV6PEcJ2OPtcInK7OFM4IElQJFsHfE8SJR9AQiGCAsyA4S5I+ls8ej8if8W8A8w5nMSi3o1ie1dvlue5Dvj/PXAa/zuZAYssIaKtEY8+cKPH7kXkr1JTU7Fx40asWbMGISEhtZ5300034YEHHmjQNY1GIxYsWIBx48bh2LFj6NGjh7vC9ShJ2A5nn0tE7lc13V6RgLMeLOqFZT9g3oqgwAqo1CGQQl7w2L2I/BnzDhvmHM7hfG036hjXHhqtGsKqIP1kpkfuUVxagb9+swuyYtuT/pkJQxEUUHfjDCJqvOXLlyM8PLxBH5zFxcWwWq0Num5SUhLCw8Px/vvvuxpi06n61tzZg4jcro0+CGH6YMgScLo41yMNeoWogCh5B1qNFXqdFVLIc5DUoW6/DxEx77BjzuEUFvVupNVp0blHRyiyQObpHFgs7u9G+7fv9qCo1AyLLOG3g7vhpv5d3H4PIgI2b96MpKSkervNTpw4EUajEQaDAbfddhv27dtX5/l6vR5JSUnYsmWLO8MlIj/UzRQORQKKKiuQby5z+/VF2RpAybRNu9cOAgIaNjpIRI3HvINcwaLezWISbM3yZKuMrNPZbr32kV8y8MOeU7DIEoICDZj5yG1uvT4R2RQXF+PEiRPXrFmrTqfTISkpCW+//Ta++eYbvPzyyzhy5AhuuukmHDx4sM7rDxw4EMePH0dJSYm7Q/cISXHtICLPiDOFQ76cyZ0pyXXrtUXlaaBsPQL1ZqjVakimFyFJklvvQUQ2zDuuYM7hHBb1bhaTEAXFerkD/nH3dcC3WKxYuWEHFAFYFQlPjL4Joa2D3XZ9IrIRQuDULwcghEDPnrXvwXzDDTdg/fr1+MMf/oB7770Xs2fPxq5duyBJEubMmVPnPeLj4233OXXK3eF7BqfCETVLccYICEmCAHDajR3whZAhSpZAra6EQW+BFPw4JA1nBhK5mxACRXnF+OFf25l3VGHO4RQ2ynOzqmZ5QhFId+O2dl9u/R8yLxbBbJXQu1t73Hdbb7ddm8hfCCEAcQmQs2yHkgkhZwFy5uX/tj1ekVUEAAgMbNyWTV27dsV9992HL7/8ErIsQ61W13heQEAAAMBsNrv2gpoK94wlapYcm+Xlu+/C5d8C1uMICq6ApIkFgh5137WJ/IQQAiUFpbiYloeLabm4mJ5v+98LeZcfy0Nueh7M5RYUCtuXcsw7wJzDSSzq3SymdxQAQFgF0n9xT1F/PvMSvv7hMCplCWq1GrMn3Q6VilPgiKqzFeyFDgW6cCjWL/8Z9X+g6XW2f19lZY1fo9qpUydYLBaUlpbCaDTWeE55ebntPnp9o69PRFSlS0go1PZt7dwz/V7IFyHKPoJeVwmtRoZkegmSxIa8RNUJIVBaWIaL6XnVivY8XEy3FepVRXtFWcOKaBVsxTjzDnIWi3o3a9uuNYxtQ1BWVoa0E653wFcUgRXrf4bVKlCpSPjD/YMR25GdZ8m/2Ar2IvvoOuSsKyPsSiYgZ9sKd1Hu2o2kEEAdia7d2kKS/o7U1FQkJiY26hKnT5+GwWBAcHDty2NSUlIgSVKN+8o2R5IQkJyc0ubs84iofjq1BrEhoTh7KQfnS/JRqcjQqmoeqWsoUbIUKqkMQQEVQMAoSLra1/gStVSlRWW2wrxa0Z6bnoec9Csj7OUlFS7dIyDYgLBObRHasS1MEUHY8/etzDvAnMNZLOrdTJIkxCR0xtEdx1CQU4ii/GIY29S+12R9tuw6gRNnc2CWJXRu1wbj723cP3Si5s5WsJdUK9AvF+z20fVMQMkGhIudnaUgQN0OUEUC6khI9j+3A9SRgCoSksr2gWgEEBe3F3v37sXEiRNrvNzFixcRFhbm8Nj//vc//OMf/8CIESOgUtXesmTfvn3o3r17nR/AzYor69T8+AOWqCl0M4bjdEEOrEJBemkBYkLaOn0tYf4JsOxAYGAFJHUopJBn3BgpUfNQVlx+VbGej5y0XORWmxZfVuzaIIEhUI+wTm1tR8dQhHZsg/BOoQjtaHssvFNbBBoDHZpP/m3vSuYdAHMOJ7Go94CYhM44vD0VAJB+IgM9h8Q5dZ38wlKs+edeWBVAERKe+8Pt0Ov4fxn5FqGUOBTootradVvBngWIUtduIgVWK9DbAaoIW9GujgRUtseqCvaGuv3227Fu3TosWbKkxu1lRo0ahYCAANxwww0IDw9HamoqVqxYgcDAQLz22mu1XtdsNmPDhg0YNWpUo1+m1wgAznaU9d/PV6ImEWeKwL+kowBsHfCdLeqFUgpRshRabdWe9MmQVCZ3hkrkceWlFfaR9JxqI+z2Ij49D6WFrg0S6AN09hH2sE5tEd7xSrEedvl/g1sFNXq3COYdlzHncAorRA+I7R0FodjeVeknMp0u6j/6ahfKKiphkSXcc0svDOjZyZ1hErlMKKVXpr9fHmkX1ZrQQc6yjcK7Qgqwj67bCvZ2kNQR1Ubd2wFSiNu3Wnrsscfw7rvvYv369Rg7duw1Px85ciTWrFmDxYsXo6ioCGFhYfi///s/zJs3r87pbRs2bEBOTg4ef/xxt8ZLRP4pzhgOcXld/dnifKCdc9cRZashiVwEB1QA+lsBwwi3xknkqooys71Yz62+lr3aCHtJgWuDBDqDFqEdbSPpoR2rivRQe7Ee1qktQloHe2R7R+Yd5AoW9R4QW71Z3skLTl1j79Fz2HXkHMxWCa2NgZg29mZ3hkhUL6GUOTaYq6nxnCh28S56h+nvULe7PC0+4sqou2T0yt7IPXv2xPDhw/H888/jnnvuQUiI4zKa6dOnY/r06Y26ZlFREebMmYPhw4ejR48e7gzXo7i+jaj5qt4B/0yxc83yhCUVKP8OAQEWqNQGSMZ53JOempS53IyL6fn2Yj2n+gj75ceK810bJNDqtQjr2ObKqHqHywV7tRF2Y1v3DxI0FPMOG+YczmFR7wFR8Z0gSRIUWSDtZOOb5ZVVWPDhlzshC0AWEmb8/jaYggM8ECn5KyHKHbZ1u7KOPfPK46LQxbvoaijYq6bDXy7apVbNOnFctmwZEhISMHPmTKxcudKlawkhMGvWLOTl5WHZsmVuirCJCLiwvs2tkRDRVSIDjDBqDTBby3G6pPF71QthgShdAo3aigC9BVLwHEjqDh6IlPyVpcKC3Av51zSeqxphz03PQ2Gua4MEGq3acQr8VSPsoR3bolWYdwYJGoN5B5hzOIlFvQcYAvVo3zUSWWnZuHAyo859I2uybuN+5BWWwWKVcH3vaNxxQ3cPRkstjRAV1abDZ121jr1qSnyBi3fRVluvXkvjOal1s//wrE9MTAyWLFmCKVOmICoqCsnJyU5dRwiBl19+GatWrcKqVasQExPj5kg9jE1riJotSZLQzRiOQxXnkGsuQZGlAkadoeEXKFsPWM8iKKQC0PQCAh/2XLDU4ljMlci7kF/n1m4FF4tcuodGq0Zoh5pH2KumypvCjHU2ivMVzDvAnMNJLOo9JLZ3Z2SeyYLFbEXOuVy0i41o0PN+OZ+D7386BossQafT4tmJw3y+MCL3EcJy1b7rmRD2pnNVU+IvuXgXrW0kvVqBLjl0iW8HqNr4zfty8uTJyM7ORnJyMs6dO4fFixdfMyWuLkVFRZg1axZWrVqFV155BZMmTfJgtETkj+JMEThw8RwA4GxJLnq36dig5wlrOkTZGhj0FmjUEiTTy5AkpoZkU2mpRF7GpWu3drtwZV37pWzXZvWp1CqEdmhzzQh79XXtrSNMLaJgbyjmHeQM/ub2kJiEKPz3y90AgLQTGQ0q6q1WGSu+2AFZAawK8FjSDWgfzs6z/sJWsGc7dIYX1afDK1mA0viplY40l9erX2k8Jzk0oYsEVG0hSf7z4dkQL7zwAiIiIjBjxgxs2rQJCxYswAMPPFBjd9oqVd1m58yZg7y8PKxatcp3P1gVAM5+h+NsB1siarA4UziUy/9GT5fkN6ioF0JAlLwDlcqMQIMZCPwDJG1PD0dKzYW10mor2Kvtu55zeZS9aoT9UnahbdtZJ6lUEtq2b2NvMBfaoS3Cq42wh3WyFeyNmc3qL/w672DO4RQW9R4S2zsKEIBQBNJPZmDwiH71Pue77Sk4m5EPiyyhW1Q4Ro8Y0ASRUlMQotKxYLc3navWeE5xrsHRFWrHgl0VWW1bt6qivS0kiR+ezpg8eTKGDh2KqVOnYty4cXj66aeRlJSEgQMHIj4+HgEBASgvL0dKSgr27dtn7zY7fPhwLFu2zLemvl2FTWuImrc4UwQgSZAlgbPFDfzy17wZqDyEoKAKSOoOkIIb14CLmi/ZKiMv85LD1m62pnO59lH3/MwClwv2Nu1aX5kC37GqUL/SeK5NZCuoNcw5nOWveQdzDuewqPcQewd82VbU1yc7rwhfbDoIqyIBUGH2pDugUXO01BcIYQWUnFq6xF/e7k25CNe6d6gAVbhD4znHfdgjAFUYC3YPi4mJwffff4/U1FQsX74cW7ZswfLlyx0SI0mS0L17d4waNQqPP/64z3SbrRPXtxE1a9cZwwE0vAO+UAogSlZAp62ETitDMs2HpAr0dJjkBrIsIz+zwGGE/WJaLnKqjbDnZ16Cojj/u1eSJLSObIXwaiPsYZ1Cr2zz1qkt2rZrzYK9Cfhl3sGcwyks6j0kIjoMhiA9rLIVacfrLuqFEFi5fgfMFhkWWcKo4f3Qs0tkE0VKdbEV7BevrFdXLneJr9aEzjbC7sp8HwlQhdn3YLc1nas2HV7dDlCFcp1jM9KzZ0+88847AICSkhKcOnUKZrMZer0eXbt2RXBwsJcjdDN+wBI1a0EaHToFtUZWUT7OluRDEQKqOvqeiJIPIKEQQQFmwHAXJP0tTRgt1UaWZVzKLqxWrFdt6XZlhD0v4xIU2bU5xm0iW12ZAl+9U/zlEfa27VtDo2XO0Zz4Vd7BnMMp/BfrISqVCjEJnXHywK+4mJ6HspJyBNayLd1/D5zG/05mwCJLiGhrxKMP3NjE0fonIeQrBXttXeKVHLinYL96W7fqjefCIElad70samLBwcHo27evt8NocZYuXYpFixYhKysLffr0wbvvvovBgwfXeG5KSgrmzp2L/fv349y5c3jrrbcwY8YMl65J5GvijOHIKM5HhVKJzLJCdAhqVeN5wrIfMG9FYIAZKnUIpJAXmjZQP6UoCgpyCi/vwX5lhP3ihXzb/6bZCnbZKrt0n1bhJoR1utxkrqpLfMc29qK9bfvW0OqYc/gy5h1UExb1HhSbEIXje0/BKirxw/c/IjI2DDqdDjExMfZv1IpLK/DJP3ZBVmx70j8zYSiCAmpvgkENI4RiG0G3j6hfnhJfNR1ezrxcsLv24QlVqGOXePvoetUIexgkif9/ko9r4m/N161bh5kzZ2L58uVITEzEkiVLcOedd+LEiRMIDw+/5vyysjLExsbiwQcfxNNPP+2WaxL5mjhTBLZmHIdcYcbWvTsRHxJ+Tc4hRAVEyTvQaqww6CshhcyHpA71cuS+T1EUFF4sqlasO46w56bnIfdCPqyVLhbsYcaa92KvGmHv0AY6PQt28nEcqXcKi3oPSU1NxZYT/8JuaTuK8wux8fEv7D+TJAldu3bFrbfeCn1ELxSWmGGRJfx2cDfc1L+LF6P2DbaCPe9ygX65YK+2xZttDXs2AKtrN1K1vbJe3d4lvnrjuQgW7OQfmrgT7eLFizFlyhRMnDgRALB8+XL885//xOrVqzF79uxrzh80aBAGDRoEADX+3JlrEvmS1NRUbH1jFdK2bEFZeg4OXbXetirneOShEMR1ykRQsBnQDgICHvBi1L5BCIHC3KLL27lVbe2Wi9wL+bZu8Wl5yLuQj0qLazmHsW2IvUt81T7soR3bXOkW36ENdAbmHOQH2P3eKSzq3ezMmTOYOnUqNm7ciPCwcIybPAaDBg1Cz549ERgYiLKyMqSmpmLv3r1Yv34DLl5ciTYduqP7b0Zh5iO3eTt8r7MV7JcuF+yZ1Qr26uvYswFUunYjqfXlAt1WtEuX17JfWcceAUnSu+U1Efk6d3SiLSoqcnhcr9dDr7/235jFYsH+/fsxZ84c+2MqlQrDhg3Dzp07nYrBE9ckag4cco7wcIxPSqo159iwYT1WrryI228x4v3XwxHb/0VIday79wdCCBTlFVfbg/3aEfaL6fmoNLuWc4S0Cb48qm4bUbftwW4r2qumx+sDmHMQAex+7ywW9W60atUqzJgxA6GhoVizZk2t+0kmJiZi4sSJWLJkCdavX49nn30OB/+xCF8P64jJkyd7IfKmIYQAxKUrBbqcWUPBngXXC/ZW1Qr0dpAuj7Q7TJNnwU7UpDp16uTw3/PmzcP8+fOvOS83NxeyLCMiIsLh8YiICBw/ftype3vimkTe5mzOMWfOs+jz23QsWfIDJk9uubMDhRAovlTisK1b1Qj7xbRc+1R5S4VrOUdwqyCHbd3CqhXr4Z1sU+IDggxuelVERDVjUe8mr7zyCpKTkzF58mQsXrwYISEh9T5Hp9Nh7NixuOeee/D0009jypQpyM7Oxgsv+F7TGlvBXlDLtm7VGs/B4tqNJJPDiLqkrtrOrdqou1RzQ0IicpIb1relpaXBaDTaH65plJ6IGoY5h0BJQWm1Yv1y4Z6ei9x0W9Gem56PijKzS/cJMgVeM8Lu0HiuYxsE1NIEmYicxDX1TmFR7warVq1CcnIyXnrpJSQnJzv8rKSkBIsWLcLu3buxZ88eXLp0CR999BEmTJhgPyckJASrVq1CVFQUkpOTERkZiUmTJjXxq6idrWAvrGNbt6oR9grXbiQZa+gSf2VNO1SR3EeXyBsUAUhOflBe3ivZaDQ6FPW1CQ0NhVqtRnZ2tsPj2dnZiIx0bqtPT1yTyFv8IecoKypzaDqXc7lIr761W0WpawV7YEiAw7ZuV0+HD+sUisAQFuxETc4NOYc/YlHvojNnzmDGjBmYPHnyNR+ugG3a54svvojOnTujT58+2LZtW63XSk5Oxvnz5/HUU0/ht7/9LWJiYjwYuY2tYC922Hf92m3dsgBR7tqNpOBqU+Crd4m/MtIuqYLc86KIyL2a8FtznU6HAQMGYOvWrRg5ciQAW2fprVu3Ytq0aU6F4IlrEnmDr+ccAFBaVHbNCPvVW7uVl7g2SGAI0l/pCt/h8kj7VVu7BRk5SEDULHGk3iks6l00depUhIaGYvHixTX+vF27dsjMzERkZCT27dtn79BcE0mS8Oabb2LTpk2YOnUqvv/+e5fjE0rx5cI886qCvdpIuyhz7SZS0FX7rldNi682TV4V7PJrISL/MHPmTIwfPx4DBw7E4MGDsWTJEpSWlto71z/yyCPo0KEDFixYAMDWCC81NdX+5wsXLuDQoUMIDg5G165dG3RNIl/Q3HOO8pJyx23dqjWey023dYsvK3JtkMAQqL8ywn711m6Xi/YgU6DfNwEkIv/Cot4Fqamp2LhxI9asWVPreja9Xt+o6Z1GoxELFizAuHHjcOzYMfTo0aPWc4VS4lCgi+rT4atG2kVpo1+XAynwqn3XI23T4quNtEuq+tfyEZEvc+FbczT+eaNGjcLFixcxd+5cZGVloW/fvti4caO90d358+ehUqns52dkZKBfv372/37jjTfwxhtv4JZbbrGPVNZ3TaLmzts5R3lpheMe7GmOI+y56fkoKXAt59AZtA77rl9drId2bIOQ1sEs2IlatKbNOVoKFvUuWL58OcLDw/HAA+7d5zUpKQlPP/00li19De+8+Wi1dexXNZ4TJS7eyXDVvuuX17Hb17K3A6QQfngS+TsvTIWbNm1arVPjr55SHB0dbVtK5MI1iZo7T+ccixa8gScnzKhxhP1iWi6KL7lWsGv12ivFeqe2CO3QFuGdHPdjD2nDgp3I73H6vVNY1Ltg8+bNSEpKqnELGVfo9XokJSVh6+a/Qlxydg9l/VUFe/V17JdH2iUTPzyJqH6KgNPffvtx0xoid/J0zrFm1WdI+3uRU9fQ6jQ1ToevKtZDO7aBKdTInIOI6secwyks6p1UXFyMEydO4Nlnn/XI9QcOHIjly99HSamC4CDVVT/VVZsOH3F5hL16wR4JSK354UlERNQCNEXO8f77y2GFFRrJMTXUaNX2DvFVI+xhnRy7xZtCQxyWxBARUdNiUe+kX3/9FUII9OzZ0yPXj4+PhxDAqax70K/vgCuj7up2LNiJqGkJxXY4+1wicklT5ByAwE2PDEC/Af0dusW3CjexYCeipsOcwyks6p1kNtv2Rw0M9MyWKAEBtr1RKzWjIQUleuQeREQNwvVtRF7VVDnHXVNvR2Iicw4i8iLmHE5hUe8kvV4PACgrc3E7uFqUl5c73IeIyGu4vo3Iq5hzEJHfYM7hFM6nclLXrl0hSZJ9b2R3S0lJgSRJ9j2WiYiIyD8x5yAiorpwpN5JwcHBiIuLw969ezFx4sQ6z33vvfdQUFCAjIwMAMC3336L9PR0AMCTTz4Jk8l0zXP27duH7t27Izg42P3BExE1BqfCEXkVcw4i8hvMOZwiiYZs7ks1mj59OtatW4e0tLQ6t5iJjo7GuXPnavzZmTNnEB0d7fCY2WxG586dMWrUKLzzzjvuDJmIqMGKiopgMpkwrN0foVE5t42WVbFgS+YHKCwshNFodHOERP6DOQcRtWTNPefIz8/Hk08+iW+//RYqlQpJSUl4++236/wydMWKFVi7di0OHDiA4uJiXLp0Ca1atXL5ujXh9HsXPPbYY8jJycH69evrPO/s2bMQQtR4XP3hCgAbNmxATk4OHn/8cQ9FTkTUCFXfmjt7EJHLmHMQkV9opjnHuHHjkJKSgs2bN+O7777D9u3b8eijj9b5nLKyMgwfPhzPP/+8W69bE47Uu2jEiBE4duwYjhw5gpCQEJevV1RUhISEBPTs2RPff/+9GyIkInKO/Vvz8MmufWues4oj9URuwJyDiFqq5pxzHDt2DD179sTevXsxcOBAAMDGjRvxu9/9Dunp6Wjfvn2dz9+2bRtuu+22a0bqXb1udRypd9GyZcuQm5uLmTNnunwtIQRmzZqFvLw8LFu2zA3RERERUUvBnIOIqH5FRUUOR9W2oM7auXMnWrVqZS+8AWDYsGFQqVTYvXt3s7gui3oXxcTEYMmSJVi1ahVefvllp68jhMDLL7+MVatW4e2330ZMTIwboyQickEznQpH5G+YcxBRi+eGnKNTp04wmUz2Y8GCBS6FlJWVhfDwcIfHNBoN2rRpg6ysrGZxXXa/d4PJkycjOzsbycnJOHfuHBYvXtyoaXFFRUWYNWsWVq1ahVdeeQWTJk3yYLRERI3ETrREzQZzDiJq0dyQc6SlpTlMv9fr9TWePnv2bCxcuLDOSx47dsy5WJoYi3o3eeGFFxAREYEZM2Zg06ZNWLBgAR544IE6O9SazWZs2LABc+bMQV5eHlatWsUPVyJqfhQBwMkPWIVFPZG7MecgohbLDTmH0Whs0Jr6WbNmYcKECXWeExsbi8jISOTk5Dg8brVakZ+fj8jISOdiBdx6XRb1bjR58mQMHToUU6dOxbhx4/D0008jKSkJAwcORHx8PAICAlBeXo6UlBTs27fP3nF2+PDhWLZsGae/ERERUYMw5yAick1YWBjCwsLqPW/IkCEoKCjA/v37MWDAAADAf/7zHyiKgsTERKfv787rsvu9h6SmpmL58uXYsmULjh8/jup/zZIkoXv37hg2bBgef/xx9OjRw4uREhHVrKoT7dDW413qRLv10l/Z/Z7Ig5hzEJGva+45x4gRI5CdnY3ly5ejsrISEydOxMCBA7F27VoAwIULFzB06FB88sknGDx4MADbmvmsrCzs27cPU6ZMwfbt2xESEoLOnTujTZs2DbpuQ3Gk3kN69uyJd955BwBQUlKCU6dOwWw2Q6/Xo2vXrggODvZyhEREDSSE89Po+b0xkccx5yCiFqOZ5hxr1qzBtGnTMHToUKhUKiQlJdl/7wJAZWUlTpw4gbKyMvtjy5cvx1/+8hf7f998880AgI8++sg+7b++6zYUR+qJiKhG9m/NTQ9DIzn5rbmwYGvh3zhST0RERLVizuEabmlHRERERERE5KM4/Z6IiOqmKICkOPdc4eTziIiIyP8w53AKi3oiIqqbcGF7Ga7wIiIiooZizuEUFvVERFQnoSgQTn5rLvz4W3MiIiJqHOYczuGaeiIiIiIiIiIfxZF6IiKqG6fCERERUVNgzuEUFvVERFQ3RQASP2CJiIjIw5hzOIVFPRER1U0IAM52ovXfD1giIiJqJOYcTuGaeiIiIiIiIiIfxZF6IiKqk1AEhJNT4YQff2tOREREjcOcwzks6omIqG5CgfNT4fx3exkiIiJqJOYcTmFRT0REdeK35kRERNQUmHM4h0U9ERHVjd+aExERUVNgzuEUFvVERFQnKyqd3jLWikr3BkNEREQtFnMO57CoJyKiGul0OkRGRuKnrH+5dJ3IyEjodDo3RUVEREQtDXMO10jCnxcfEBFRnSoqKmCxWFy6hk6ng8FgcFNERERE1BIx53Aei3oiIiIiIiIiH6XydgBERERERERE5BwW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFPREREREREZGPYlFPRERERERE5KNY1BMRERERERH5KBb1RERERERERD6KRT0RERERERGRj2JRT0REREREROSjWNQTERERERER+SgW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFPREREREREZGPYlFPRERERERE5KNY1BMRERERERH5KBb1RERERERERD6KRT0RERERERGRj2JRT0REREREROSjWNQTERERERER+SgW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFPREREREREZGPYlFPRERERERE5KNY1BMRERERERH5KBb1RERERERERD6KRT0RERERERGRj2JRT0REREREROSjWNQTERERERER+SgW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFvQd8/PHHkCQJZ8+e9XYoHlFSUgKVSoW33nrLq3G8/vrr6N69OxRFadL7Ll++HJ07d4bZbG7wc/bu3YsbbrgBQUFBkCQJhw4d8lyAjdDc3qvz58+HJEneDoOIiGrgjs+M5pBDeCt/qE1LySuaW04BMK8g/9Hii/p7770XgYGBKC4urvWccePGQafTIS8vrwkj811Hjx6FEAK9evXyWgxFRUVYuHAhnnvuOahUTfs2njBhAiwWCz744IMGnV9ZWYkHH3wQ+fn5eOutt/C3v/0NUVFRHo6SiIiam6qiZ9++fQ6PFxYWYvDgwTAYDNi4caOXomsa3s4hassfSkpKMG/ePAwfPhxt2rSBJEn4+OOPmyQm5hVE5KoWX9SPGzcO5eXl+Oqrr2r8eVlZGb755hsMHz4cbdu2dcs9H374YZSXl7fYX7BHjhwBACQkJHgthtWrV8NqtWLMmDFNfm+DwYDx48dj8eLFEELUe/6vv/6Kc+fO4ZlnnsGjjz6K3//+92jdunUTRFq/lv5eJSJq7oqKinDHHXfg8OHD+OqrrzB8+HBvh+RR3s4hassfcnNz8eKLL+LYsWPo06dPk8bUUvIK5hRE3tPii/p7770XISEhWLt2bY0//+abb1BaWopx48a5fK/S0lIAgFqthsFgaLHTfY4cOYLQ0FBERkZ6LYaPPvoI9957LwwGg1fu/9BDD+HcuXP44Ycf6j03JycHANCqVSu33b/qveaqlv5eJSJqzoqLi3HnnXfi0KFD2LBhA0aMGOGW67rrM8ITvJ1D1JY/tGvXDpmZmTh37hwWLVrU5HG1hLyCOQWR97T4oj4gIAD/93//h61bt9p/CVa3du1ahISE4N577wUAnDt3DlOnTkVcXBwCAgLQtm1bPPjgg9esD6pao5OamoqxY8eidevW+M1vfgOg5jVFjb3uqVOnMGHCBLRq1QomkwkTJ05EWVmZw7kXLlzApEmT0L59e+j1esTExODxxx+HxWJxOOcPf/gDIiIioNfrER8fj9WrV9f4d3X8+HGcP3++3r/TI0eOID4+3uGxlStXQqfTYcaMGZBlud5ruOLMmTM4fPgwhg0b5tH71GXAgAFo06YNvvnmmzrPmzBhAm655RYAwIMPPghJknDrrbfaf37w4EGMGDECRqMRwcHBGDp0KHbt2uVwjbrea666+r3amPdfbRr6nvvpp58waNAgGAwGdOnSpc5ph9u2bcPAgQMdzq1pnVxD711cXIwZM2YgOjoaer0e4eHhuP3223HgwIEGvUYiIleVlJRg+PDhOHDgADZs2IC77rrL4ecN/X1W22dEY3+fNyZfuFpD8wfAuzlEXfmDXq/36mCFO/KKhuQUgOfyipry3+aYVzQ0p2jovZlTUHOg8XYATWHcuHH461//is8//xzTpk2zP56fn49///vfGDNmDAICAgDYGo/s2LEDo0ePRseOHXH27Fm8//77uPXWW5GamorAwECHaz/44IO47rrr8Oqrr9Y5Zaqx133ooYcQExODBQsW4MCBA1i1ahXCw8OxcOFCAEBGRgYGDx6MgoICPProo+jevTsuXLiA9evXo6ysDDqdDtnZ2bj++ushSRKmTZuGsLAwfP/995g0aRKKioowY8YMh3v26NEDt9xyC7Zt21bn3+eRI0fs09asVitmzJiBFStWYOnSpZgyZUqdz3WHHTt2AAD69+/v8XvVpX///vj555/rPOePf/wjOnTogFdffRXTp0/HoEGDEBERAQBISUnBTTfdBKPRiGeffRZarRYffPABbr31Vvz4449ITEx0uFZD32vuUN/7rzYNfc8dOXIEd9xxB8LCwjB//nxYrVbMmzfP/ndT3cGDBzF8+HC0a9cOf/nLXyDLMl588UWEhYU5dW8AeOyxx7B+/XpMmzYNPXv2RF5eHn766SccO3bM6+8rImr5SktLMWLECOzduxfr16/H3Xff7fDzxn5+A9d+RlQNZDTk97kz96uuofkD4N0cornkD7VxJa9obE4B+Gde0dCcojH3Zk5BzYLwA1arVbRr104MGTLE4fHly5cLAOLf//63/bGysrJrnr9z504BQHzyySf2x+bNmycAiDFjxlxz/kcffSQAiDNnzjh93T/84Q8O595///2ibdu29v9+5JFHhEqlEnv37r3muoqiCCGEmDRpkmjXrp3Izc11+Pno0aOFyWS6JiYA4pZbbrnmetVlZGQIAGL58uUiLy9P/Pa3vxVt2rQRP/zwQ53Pc6fk5GQBQBQXFzfZPWvy6KOPioCAgHrP++GHHwQA8cUXXzg8PnLkSKHT6cSvv/5qfywjI0OEhISIm2++2f5YXe81V139Xm3o+682DX3PjRw5UhgMBnHu3Dn7OampqUKtVourfy3dc889IjAwUFy4cMH+2C+//CI0Go3DuY15v5tMJvHEE0/U+3qIiNyp6nduVFSU0Gq14uuvv67xvMb8PqvtM6Ixv88ber+a8hshGpY/COH9HKKh+cPevXsFAPHRRx81SVxVXMkrGppTCOG5vKKm90dzyysamlM05t7MKag5aPHT7wHbGp/Ro0dj586dDlOC1q5di4iICAwdOtT+WNWIPWDrLpqXl4euXbuiVatWNU6jeeyxxxoUg6vXvemmm5CXl4eioiIoioKvv/4a99xzDwYOHHjNcyVJghACGzZswD333AMhBHJzc+3HnXfeicLCwmvuK4So91v2w4cP2+8xaNAgZGRkYPfu3Q5Tyj0tLy8PGo0GwcHB1/xs165dkCQJ8+fPd/r6Db1G69atUV5e3uDpY9XJsoxNmzZh5MiRiI2NtT/erl07jB07Fj/99BOKioocntPQ95o7/g7qev/VpqHvOVmW8e9//xsjR45E586d7c/v0aMH7rzzTodryrKMLVu2YOTIkWjfvr398a5duzqsPW3s+71Vq1bYvXs3MjIynP47IiJyVnZ2NgwGAzp16nTNz5z5/AZq/4yo7/e5s/e7OuaGjNJ7O4eoK3/wlMZ8JjubVziTUwD+l1c0NKdozL0B5hTUPPhFUQ/A3givqmFeeno6/vvf/2L06NFQq9X288rLyzF37lx06tQJer0eoaGhCAsLQ0FBAQoLC6+5bkxMTIPu39jrVv+lBMDe1fTSpUu4ePEiioqK6twO5uLFiygoKMCKFSsQFhbmcEycOBEAauwxUJ+qrrXTpk1DREQEdu7cia5duzb6Oi2BuDxVzZmGMBcvXkRZWRni4uKu+VmPHj2gKArS0tIcHm/oe80d6nr/1aah77mLFy+ivLwc11133TXXuPrvIycnB+Xl5TW+x6o/1tj3++uvv46jR4+iU6dOGDx4MObPn4/Tp0/X99dCROQWH3zwAXQ6HYYPH44TJ044/MzZz+/aPiPq+33uqXyhJswh6uZsXuFMTgH4X17R0JyiMfcGmFNQ8+AXa+oBWwOS7t2749NPP8Xzzz+PTz/9FEKIa7reP/nkk/joo48wY8YMDBkyBCaTCZIkYfTo0VAU5ZrrVh+Br0tjr1v9i4bqqn7h16fqmr///e8xfvz4Gs/p3bt3g65V3ZEjRxAVFYUuXbrg6NGjKCkpcWv31YZo27YtrFYriouLERIS4vCz/v37Iy0tDUaj0enrN/Qaly5dQmBgYIPfA65q6H3c8XfgzPuvoe+5mt7vrmrs+/2hhx7CTTfdhK+++gqbNm3CokWLsHDhQnz55Zdu6z5NRFSbnj174l//+heGDh2K22+/HT///LN91N7Zz+/aPiPq+33uqXyhJt7OIerKHzylMZ/JzCsc+UpewZyCmgO/KeoB22j9n//8Zxw+fBhr167Fddddh0GDBjmcs379eowfPx5vvvmm/bGKigoUFBS4dG93XjcsLAxGoxFHjx6t85yQkBDIsuzWLvFHjhxB3759sXLlSgwcOBD3338//vvf/7p9a7kPP/wQ//jHP/DNN9/g+PHjePDBB7Fo0SIMHz4c3bt3B2DrYnt1oqHT6dCxY0eX7t3Qa5w5cwY9evRw6h5hYWEIDAy8ZoQGsHURVqlUNU7LbAh3/B04o6HvOVmWERAQgF9++eWan1399xEeHg6DwYBTp05dc271x5x5v7dr1w5Tp07F1KlTkZOTg/79++OVV17hBzARNYnBgwfj66+/xl133YXbb78d//3vf+0jgZ74/K5NU96vKXIIZ/MHT2nMZ7KzeYUncwqg5eQVDc0pGnPvKswpyNv8Zvo9cGUK/ty5c3Ho0KEa96ZXq9XXfGv47rvvurzFijuvq1KpMHLkSHz77bfYt2/fNT8XQkCtViMpKQkbNmyosfi/ePHiNY/VtyWNLMs4duwYEhISEBYWhi+//BJHjx7F448/fs252dnZuPfeezFs2DCcPXsWn3/+ORITEzFnzpwGvcYjR46gd+/e2LFjB5KSkvDxxx9j+PDhAIAhQ4YAQI2vvSkdOHAAN9xwg1PPVavVuOOOO/DNN9849HnIzs7G2rVr8Zvf/Malb8S9oaHvObVajTvvvBNff/21w/vt2LFj+Pe//33NNYcNG4avv/7aYa3aqVOn8P333zf63oDtfXz1kpfw8HC0b98eZrO5ka+aiMh5Q4cOxaeffopTp05h+PDhKCoqcurz2xXuuF9DtrRraA7hD/lDbZzNK1piTgG4P69oaE7RmHszp6Dmwq9G6mNiYnDDDTfY9wCtqai/++678be//Q0mkwk9e/bEzp07sWXLFrRt29ale7v7uq+++io2bdqEW265BY8++ih69OiBzMxMfPHFF/jpp5/QqlUrvPbaa/jhhx+QmJiIKVOmoGfPnsjPz8eBAwewZcsW5OfnO1yzvi1pfvnlF1RUVCAhIQGAbUnD+++/j4kTJ2LAgAEO2wW++eabeO2111BeXo5x48YhJCQEW7duxapVq7B161aH5oQ1OXLkCCIjI3Hfffdh9+7dDo1fYmNj0atXL2zZsgV/+MMfGvT3JUlSg7fbaYj9+/cjPz8f9913n9PXePnll7F582b85je/wdSpU6HRaPDBBx/AbDbj9ddfd0ucTa2h77m//OUv2LhxI2666SZMnToVVqsV7777LuLj4+2NlKrMnz8fmzZtwo033ojHH38csizjvffeQ69evXDo0KFG37u4uBgdO3bEAw88gD59+iA4OBhbtmzB3r17HWbSEBE1hfvvvx8rV67EH/7wB9x7773YuHFjoz+/XeXq/RqypV1Dcwhv5g/vvfceCgoK7AXft99+i/T0dAC2ZZQmkwmA+3MKwPW8oiXmFID784qG5hQNvTdzCmo2mqrNfnOxdOlSAUAMHjy4xp9funRJTJw4UYSGhorg4GBx5513iuPHj4uoqCgxfvx4+3lVW3RcvHjxmmvUtKWHq9et6Zrnzp0TjzzyiAgLCxN6vV7ExsaKJ554QpjNZvs52dnZ4oknnhCdOnUSWq1WREZGiqFDh4oVK1ZcEzfq2ZLm888/FwBESkqKw+NTp04VWq1W/Pjjj/bHpk2bZv/z+PHjxeeffy6EEOLYsWNi6dKltd6jSlhYmLjpppuEyWRyuG6VxYsXi+Dg4Bq3CrxacXGxACBGjx5d77kN9dxzz4nOnTvbtw+sS21b2gkhxIEDB8Sdd94pgoODRWBgoLjtttvEjh07HM6p673mqtq2tGvI+682DX3P/fjjj2LAgAFCp9OJ2NhYsXz5cvv9r7Z161bRr18/odPpRJcuXcSqVavErFmzhMFgaPS9zWaz+NOf/iT69OkjQkJCRFBQkOjTp49YtmxZA//WiIicU/W7tKbtaN944w0BQNx9992isrKywb9La/u93djf5w25nytb2jU0h/Bm/hAVFSUA1HhUvWZP5BRCuCevaEhOIYTn8oq6trRrTnlFQ3OKhtybOQU1F5IQDey8RtQIc+bMQVJSEnQ6HWbNmoXS0lJ88803WL16NYYMGYKbb7651udmZ2cjOjoaBQUFePHFF7Fnzx5s3rzZ4ZzCwkLExsbi9ddfx6RJk+qM5V//+hfuvvtu/O9//7OPELjCbDYjOjoas2fPxlNPPeXy9cg5I0eOREpKSo1r6IiIyDc1p/yhJu7OKQDmFc0BcwrydX61pp6azrPPPou3334bycnJWLFiBebPn48HH3wQ5eXlDh/IEyZMwIQJExyee+TIEfTo0QN6vR4zZszAjh07sGvXLodzTCYTnn32WSxatKjerqc//PADRo8e7bYP348++gharbbB+7uS68rLyx3++5dffsG//vWvJtvbmIiImkZzyh9q4u6cAmBe0dSYU1BLxJF68qphw4Zh1KhRmDJliv2xt956CwcPHsQnn3wCAHjqqadw6tQp/POf//RWmORl7dq1w4QJExAbG4tz587h/fffh9lsxsGDB2vcl5aIiFo25g/kLOYU1BKxqCevsVqt6N27N/73v/9Bq9V6OxxqxiZOnIgffvgBWVlZ0Ov1GDJkCF599VX079/f26EREVETY/5ArmBOQS0Ri3oiIiIiIiIiH8U19UREREREREQ+ikU9ERERERERkY/SeDsAIiJqvioqKmCxWFy6hk6ng8FgcFNERERE1BIx53Aei3oiIqpRRUUFYqKCkZUju3SdyMhInDlzxi8/ZImIiKh+zDlcw6KeiIhqZLFYkJUj48z+KBhDnFutVVSsIGbAOVgsFr/7gCUiIqKGYc7hGhb1RERUJ2OIyukPWCIiIqKGYs7hHBb1RERUJ1kokJ3c/FQWinuDISIiohaLOYdzWNQTEVGdFAgocO4T1tnnERERkf9hzuEcFvVERFQnBQqc/e7b+WcSERGRv2HO4RwuWCAiIiIiIiLyURypJyKiOslCQBbOTWlz9nlERETkf5hzOIdFPRER1Ynr24iIiKgpMOdwDot6IiKqkwIBmR+wRERE5GHMOZzDNfVEREREREREPooj9UREVCdOhSMiIqKmwJzDOSzqiYioTmxaQ0RERE2BOYdzWNQTEVGdlMuHs88lIiIiagjmHM5hUU9ERHWSXWha4+zziIiIyP8w53AOG+URERERERER+ahmXdSXlJTg0KFD2L17Nw4dOoSSkhJvh0RE5Hdk4dpB5AuYcxAReZ83co6lS5ciOjoaBoMBiYmJ2LNnT63npqSkICkpCdHR0ZAkCUuWLLnmnPnz50OSJIeje/fuzgXXQM1u+n1qaiqWL1+OzZs348SJExDVGh5IkoS4uDjcfvvteOyxx9CzZ08vRkpE5B+4vo1aKuYcRETNS1PnHOvWrcPMmTOxfPlyJCYmYsmSJbjzzjtx4sQJhIeHX3N+WVkZYmNj8eCDD+Lpp5+u9brx8fHYsmWL/b81Gs+W3c1mpP7MmTMYMWIE4uPjsW7dOtx222348MMPsWvXLhw+fBi7du3Chx9+iNtuuw3r1q1DfHw8RowYgTNnzng7dCKiFk2BBNnJQ4Hk7fCJrsGcg4ioeWrqnGPx4sWYMmUKJk6ciJ49e2L58uUIDAzE6tWrazx/0KBBWLRoEUaPHg29Xl/rdTUaDSIjI+1HaGhoo2NrjGZR1K9atQoJCQk4duwY1qxZg7S0NCxbtgwTJ05EYmIiEhISkJiYiIkTJ2LZsmVIS0vDmjVrkJqaioSEBKxatcrbL4GIiIh8AHMOIqKWraioyOEwm801nmexWLB//34MGzbM/phKpcKwYcOwc+dOl2L45Zdf0L59e8TGxmLcuHE4f/68S9erj9eL+ldeeQVTpkzBmDFjcOTIEYwdOxY6na7O5+h0OowdOxZHjx7FmDFjMGXKFLzyyitNFDERkX9RhGsHUXPBnIOIqHlzR87RqVMnmEwm+7FgwYIa75WbmwtZlhEREeHweEREBLKyspx+DYmJifj444+xceNGvP/++zhz5gxuuukmFBcXO33N+nh1Tf2qVauQnJyMl156CcnJyY1+fkhICFauXInOnTsjOTkZkZGRmDRpkgciJSLyX1XT2px9LlFzwJyDiKj5c0fOkZaWBqPRaH+8rmnynjBixAj7n3v37o3ExERERUXh888/99jnhtdG6s+cOYMZM2Zg8uTJ13y47t27F9OmTUN8fDyCgoLQuXNnPPTQQzh58mSN10pOTsbkyZPx1FNPcb0bEZGbObu2zZUPZiJ3Ys5BROQb3JFzGI1Gh6O2oj40NBRqtRrZ2dkOj2dnZyMyMtJtr6lVq1bo1q0bTp065bZrXs1rRf3UqVMRGhqKxYsXX/OzhQsXYsOGDRg6dCjefvttPProo9i+fTv69++Po0ePXnO+JEl488030bZtW0ydOrUpwiciIiIfwZyDiIiuptPpMGDAAGzdutX+mKIo2Lp1K4YMGeK2+5SUlODXX39Fu3bt3HbNq3ll+n1qaio2btyINWvWICQk5Jqfz5w5E2vXrnVY5zZq1CgkJCTgtddew9///vdrnmM0GrFgwQKMGzcOx44dQ48ePTz6GoiI/IUiJCjCuRF3Z59H5C7MOYiIfEdT5xwzZ87E+PHjMXDgQAwePBhLlixBaWkpJk6cCAB45JFH0KFDB/u6fIvFgtTUVPufL1y4gEOHDiE4OBhdu3YFADzzzDO45557EBUVhYyMDMybNw9qtRpjxoxx6nU1hFdG6pcvX47w8HA88MADNf78hhtuuKZxzXXXXYf4+HgcO3as1usmJSUhPDwc77//vlvjJSLyZ5x+T76MOQcRke9o6pxj1KhReOONNzB37lz07dsXhw4dwsaNG+3N886fP4/MzEz7+RkZGejXrx/69euHzMxMvPHGG+jXrx8mT55sPyc9PR1jxoxBXFwcHnroIbRt2xa7du1CWFiY639BtfDKSP3mzZuRlJRUb8fZ6oQQyM7ORnx8fK3n6PV6JCUlYcuWLe4Ik4iIAMhQQXbyO2DZzbEQNRZzDiIi3+GNnGPatGmYNm1ajT/btm2bw39HR0dDiLq39vnss8+cjMR5TT5SX1xcjBMnTmDQoEGNet6aNWtw4cIFjBo1qs7zBg4ciOPHj6OkpMSVMImIiMjHMecgIiJ/0ORF/a+//gohBHr27Nng5xw/fhxPPPEEhgwZgvHjx9d5bnx8PIQQHu0uSETkT8Tl9W3OHIJr6smLmHMQEfkW5hzOafLp92azGQAQGBjYoPOzsrJw1113wWQyYf369VCr1XWeHxAQ4HAfIiJyDfepJ1/FnIOIyLcw53BOkxf1VfsElpWV1XtuYWEhRowYgYKCAvz3v/9F+/bt631OeXm5w32IiMg1slBBFk6ub6t72RmRRzHnICLyLcw5nNPk0++7du0KSZLsWwHUpqKiAvfccw9OnjyJ7777rsFT51JSUiBJkn1LASIiIvJPzDmIiMgfNHlRHxwcjLi4OOzdu7fWc2RZxqhRo7Bz50588cUXGDJkSIOvv2/fPnTv3h3BwcHuCJeIyO8pkKBA5eTh3FS4pUuXIjo6GgaDAYmJidizZ0+t565cuRI33XQTWrdujdatW2PYsGHXnD9hwgRIkuRwDB8+3KnYyHcw5yAi8i3eyDlaAq9saXf77bdj3bp1WLJkSY1bzMyaNQv/+Mc/cM899yA/Px9///vfHX7++9//vsbrms1mbNiwod5utURE1HBNvb5t3bp1mDlzJpYvX47ExEQsWbIEd955J06cOIHw8PBrzt+2bRvGjBmDG264AQaDAQsXLsQdd9yBlJQUdOjQwX7e8OHD8dFHH9n/m1Om/QNzDiIi38E19c6RRH0b7XlAamoq4uPjsWbNGowdO/aan99666348ccfa31+bSGvXbsW48aNQ2pqKnr06OG2eImI/FFRURFMJhO++t91CAqpu2FYbUqLZdzf5xcUFhbCaDQ26DmJiYkYNGgQ3nvvPQCAoijo1KkTnnzyScyePbve58uyjNatW+O9997DI488AsA2Ul9QUICvv/7aqddBvos5BxFR8+etnKOlaPLp9wDQs2dPDB8+HM8//zyKi4uv+fm2bdsghKj1qElRURFmz56N4cOH88OViMiNbFPhnD8A2+/o6kdt3cItFgv279+PYcOG2R9TqVQYNmwYdu7c2aB4y8rKUFlZiTZt2jg8vm3bNoSHhyMuLg6PP/448vLynPwbIV/isZxjDnMOIiJ3c0fO4Y+8UtQDwLJly5Cbm4uZM2e6fC0hBGbOnImsC1kY1OYmVFoq3RAhERG5S6dOnWAymezHggULajwvNzcXsiwjIiLC4fGIiAhkZWU16F7PPfcc2rdv7/DFwPDhw/HJJ59g69atWLhwIX788UeMGDECsiw7/6LIZ3gi58i8mIOYacNRbrW4IUIiIiLneWVNPQDExMRgyZIlmDJlCqKiopCcnOzUdYQQePnll/Hhhx+il34Qdn56EM+mvYi5X8xC64hW7g2aiMgPKVBBdvI7YAW2kc60tDSHqXCeWs/+2muv4bPPPsO2bdtgMBjsj48ePdr+54SEBPTu3RtdunTBtm3bMHToUI/EQs2HJ3KOrtN+h32qbEze/QEW9fs92ge2dnPURET+xx05hz/y2kg9AEyePBkvv/wy/vznP2PKlCk1TourS1FREaZMmYK5c+di3MhHcF2bHtAbtTj683E8MWg2Tuz71UORExH5j6o9Y509AMBoNDoctRX1oaGhUKvVyM7Odng8OzsbkZGRdcb5xhtv4LXXXsOmTZvQu3fvOs+NjY1FaGgoTp061Yi/CfJl7sw5xj/9OK67fTACLMCpwkyM37kUe/OYcxARucodOYc/8vorf+GFF7By5Up8+umn6NWrF9auXQuLpe6pbGazGWvXrkVCQgI+++wzLFmyBG+vWow5a6ajTYdW0Ju0yM3Mx8yb/4wtf9/eRK+EiKhlcn5rGdvRGDqdDgMGDMDWrVuv3F9RsHXr1jq3Gnv99dfx0ksvYePGjRg4cGC990lPT0deXh7atWvXqPjIt7kr53jzhZewoO8YtNe3RoAFKKkow/R9H+Gzsz/Xug6fiIjq15Q5R0vile73NTlz5gymTp2KjRs3Ijw8HElJSRg4cCDi4+MREBCA8vJypKSkYN++fdiwYQNycnIwdOhQvP7664iKirJfp+BiId6bvhqnDpxBZakVsllB0tN3Y8rC30Otca6TIhGRP6rqRLv2UC8EOtmJtqxYxti+RxvViXbdunUYP348PvjgAwwePBhLlizB559/juPHjyMiIgKPPPIIOnToYF+Xv3DhQsydOxdr167FjTfeaL9OcHAwgoODUVJSgr/85S9ISkpCZGQkfv31Vzz77LMoLi7GkSNHuLWdH3JXzlFaWYElx/+Fg5fOwqwVsGqAu9r3x+z4+6BXa734ComIfIu3co6WotkU9VVSU1OxfPlybNmyBcePH3f4xluChFaBbZA09n784Q9/QLdu3Wq8vkwuBgAAt1JJREFURqWlEmte2oBtn++AXCGjskxG/2EJeOHTp2FsG9JUL4WIyKdVfcD+7WCCSx+wD/c70ugP2Pfeew+LFi1CVlYW+vbti3feeQeJiYkAbFuQRUdH4+OPPwYAREdH49y5c9dcY968eZg/fz7Ky8sxcuRIHDx4EAUFBWjfvj3uuOMOvPTSS9c05CP/UlfOAUmCsVMYHrj9HkyeNKnWnEMWCj47+zO+StsLq1rArAV6tuqIhf3GIcJgaqJXQkTk27yZc7QEza6or66kpASnTp2C2WzG8qc/wfl9mQg0BuCt7S82qAneD5/9jL+/tB6VFVZYiisRGR2Ov3z1LGJ7R9X7XCIif1f1AfvxwT4ufcBO6Pc/v/yAJd9SPedYfW47DqizEazS4/X+4xAbXP+XPz/nHMfSXzahQlSiQgu0NgRjYb9x6NOaOQcRUX2Yc7imWS88CA4ORt++fZGYmIghNyZCrdj+D047kdGg5982+kY898k0tIowQm/SIvv8RTx1wwvYvr5hex0TERGgCJVLB5EvqJ5z3DToekiBOgDAudLcBj3/xvDueKXPaEToTAiwAAXlJXh8zyp8lbbHk2ETEbUozDmc4zOvPKZ3FIQCQADpJxtW1ANAtwFdMG/DM4jp3Rl6kxaV1kq89NBirH5hLRRF8VzARERE5JO6hkQCEqBIosFFPQDEBIdjYd+xSDB1QoBFAiplLEj5Gq+lfI1KxerBiImIyJ/5TFFfNWVeyAJpjSjqAaBtu9Z4fs1TuGHkIGiDNdAEqvHpgq8w976FKC0s9US4REQthnx5z1hnDyJf0zXEtn2iogLOl1xs1HONukAk90rCXR36QV8pQVcJfHl+D6bu/RB55sZto0dE5G+YczjHZ155p+4doNaoocgK0hs4/b46nUGHKa/9HmNm3w9doAa6EA12/+sAnrz+eaSduOCBiImIWgYFgCwkpw7OhyJf1FYXjNa6IChSw6ffV6dRqTGxy214Iu5OBCoaGCzA4fxzGL9zGVIL0z0QMRFRy8Ccwzk+U9Tr9Fp0imsPxSqQ+Ws2Ki2Vjb6GJEm4c+JtmPXh4wgJC4bepEX6qUxMS5yDXd/t90DURES+j3vGkr+RJAldgiOgqIDCyjJcsjg3q++2iHi82PshhGmCYTADuWWF+OPuFfg+46CbIyYiahmYczjHp155TO/OELKAtVJG9pkcp68Tf0N3zFv/DDr36AC9UYuKcjPm3rcQa17ZgGa8GQARERE1ka4h7aBItj+nOTFaX+U6Yzss7P979AhpD4NFgmyxYt7hL7Dk+L9gVWQ3RUtERP7Mp4r62IQoKFZb0Z12ItOla4V3CsULn87AwBF9oQvRQG1Q4eM/f4aXRi1GeUm5O8IlImoRZKFy6SDyRdeFREKoACEBZ10o6gGgtS4I83s/iDsiEuzr7Nee+QlP7f8YBZYyN0VMROT7mHM4x6deeUxVszxFIO2k6+vgDUEGPLFkIpKevhvaQA10wRr8d/0uPHVjMjJPZ7t8fSKilkCB5NJB5IvszfIkgfOljWuWVxOtSoM/drsdj3YdCr2sgsEC7M39FRN2LsUvxa4NVBARtRTMOZzjU0V99Q746Sfd8wEoSRLueewOzFg+BUFtAqE3aXE2JQ1PDHoOB7Ycdss9iIh8Gb81J38UExwOFSRbB3wXR+qru6N9H/yl94Noow5EgBnIKr2ESbuWY2vWEbfdg4jIVzHncI5PvfLQDm0Q3CoIilUg7bh7O9b3ubUX5n4xC+2vi4DepEVpSRnmDH8Z6xd/y3X2REREfsag1qJTUFsoEpBWlufW9e89TB2xsN84dA2KhMEiodJSiTmHPsWyk5ugCH/u30xERM7wqaJekiR7s7xL2YUoueTePebbxUbgz5/PRN/fxkMXooVKp8IHz3yChePfhbnc7NZ7ERH5Cu4ZS/6qa0gkFAmoVGRklRe49dqhBiNe6vMQbgnrAYPFts7+49PbMOvA31BSWeHWexER+QrmHM7xuVdevVle+snG71dfn8CQQExfNgX3PHYHNIFqaIM12Pr3/+Lpm+ciJ8190++IiHyFIiSXDiJf1TUkEsrlTOmcG9bVX02v1uLJuOEYH3sLdFYJBjPwc84JTNy1DOdK3H8/IqLmjjmHc3yvqO8dBaF4rqgHAJVKhaSn78YTb09EYCsD9CYtTh08jScGzcaR/x7zyD2JiJorxYVvzP15z1jyfdeFtAMkW7O8c25cV1+dJEm4p+MA/DkhCSa1AQFmIK04FxN2LcN/c4575J5ERM0Vcw7n+Nwrj6nWLC/thGeK+iqDhvfDnz97GuFRodCbdCjKL8Kfhv4F3y7f5NH7EhE1J4pQuXQQ+aquwZc74Lu5WV5NereOwsK+4xAdGAaDBagwm/HMgb9h9a8/sLcPEfkN5hzO8blXHh3fEQBszfI8XNQDQMe4Dpi34RnE39gNOqMW0Ai8M3UllvzxA1RaKj1+fyIiIvKOdgGtEKTWQ5E8M/3+ahEBrfBqn9G4IbQbDBYJmkqB5b9sxpxDa1FmZW8fIiKqmc8V9QHBAWjfJQKKrODCL5mQZfd1o61NcKsgzFz5OIZP/C20gRpogzT458oteOa3f0Fe5iWP35+opSopKcGhQ4ewe/duHDp0CCUlJd4OiWogQ3LpIPJVkiShS0gEhARcNBejtNLzhbVBo8PM7ndjTPSN0Fsl6C3Af7JSMHnXB7hQlu/x+xO1VMw5fANzDuf4XFEP2KbgC6uAudyCi2l5TXJPtUaN0bNH4tHXH0aAUQe9UYvUnSfwxKDncHzPL00SA1FLkJqaiunTp6NHjx4wGo3o168frr/+evTr1w9GoxE9evTA9OnTkZqa6u1Q6TJOhSN/Vr1Z3vmypmleJ0kSkjonYnb8SIRIegRYgF+LsjB+51LsyT3VJDEQtQTMOXwPcw7n+OQrj02IgiJXNcvLbNJ733DfIMxZOwNtO7aGoZUOl3IKMPOWedj0121NGgeRrzlz5gxGjBiB+Ph4rFu3Drfddhs+/PBD7Nq1C4cPH8auXbvw4Ycf4rbbbsO6desQHx+PESNG4MyZM94O3e/JcOWbcyLfVrWtnZDgsWZ5tRnQNhav9RmLjoY2CLAApRXlmL7vI6w58xPX2RPVgTmH72LO4RyfLOpjekcBAoAA0k9caPr79+qMeRueQbeBsdAZtVAgY9HEpVj61GpYK61NHg9Rc7dq1SokJCTg2LFjWLNmDdLS0rBs2TJMnDgRiYmJSEhIQGJiIiZOnIhly5YhLS0Na9asQWpqKhISErBq1SpvvwQi8lNVHfCFBzvg16VDUBss6DMWA1t3gcEiQW0VePvEvzD/yBeokNnbh+hqzDnIH/lmUZ/QGQCgWJUmaZZXE1OoEX/6+An8dsxvoA3SQBukxtfvfo85w19GYW6RV2Iiao5eeeUVTJkyBWPGjMGRI0cwduxY6HS6Op+j0+kwduxYHD16FGPGjMGUKVPwyiuvNFHEdDVOhSN/1iU4AgCgSMD5JmiWV5MgrR7Pxd+L/+s0GLpK2zr77y8cwqO7VyC7vMArMRE1R8w5fB9zDuf45CtvFxsOQ6AeiiyQ7qWiHgC0Oi0emf8QJr40GvpgHXRGLQ5tS8G0wbPx6//Oei0uouZi1apVSE5OxksvvYSVK1ciJCSkxvNeeeUVSJKEXr16OTweEhKClStX4sUXX0RycjI+/PDDpgibriILlUsHkS8L1hrQztDq8rZ2eVCE4pU4VJIKY2N+g1k97kIQdAiwACcKLmD8zqU4mM8pw0TMOVoG5hzO8clXrlarEd2rE4RVIPt8LipKK7wazy0P3YDnPnkSbdqZoDdpkZ2Wi6dueAHb1v3s1biIvOnMmTOYMWMGJk+ejOTk5FrPS09Px6uvvoqgoKBaz0lOTsbkyZPx1FNPcb2bFwhIUJw8hB93oqWWo2pdfblswcUK787GGxIWh1f7jkakzoQAC1BQXoqpez/E+vO7uM6e/BZzjpaDOYdzfLKoB4CYas3yLpzK8nI0wHX9YzFvwyx06RsNvUkLq2zFK2OW4MM5a5pk2z2i5mbq1KkIDQ3F4sWL6zzvmWeewfXXX4+BAwfWeo4kSXjzzTfRtm1bTJ061d2hEhHVqXoHfG+sq79aVFAYFvYdhz6mKARYJEiVCl5P/QcWpHwNi8LePuR/mHOQK5YuXYro6GgYDAYkJiZiz549tZ6bkpKCpKQkREdHQ5IkLFmyxOVruoPPFvWxvaMgqjrge3EKfnWtI1pj9t+fxG/+LxHaYA00gWp8tvBr/PnehSgpKPV2eERNJjU1FRs3bsSrr75a6/Q3ANi+fTvWr19f6y/E6oxGIxYsWICNGzfi2LFjboyW6sOpcOTvuoZEQlQ1y2uibe3qE6ILwPO97sc9HQdAf3md/ddpezF1zyrkenk2AVFTYs7RsjR1zrFu3TrMnDkT8+bNw4EDB9CnTx/ceeedyMnJqfH8srIyxMbG4rXXXkNkZKRbrukOPpttVTXLE7JA2vGm74BfG51eh0mvjsW4F5KgC9JCF6LB3o0HMS1xDs6lpnk7PKImsXz5coSHh+OBBx6o9RxZlvHkk09i8uTJSEhIaNB1k5KSEB4ejvfff99doVIDKEJy6SDyddeF2BI3W7M874/UV9Go1BgfewuejBuOQKGBwQIcuXQe43cuQ0oBcw7yD8w5WpamzjkWL16MKVOmYOLEiejZsyeWL1+OwMBArF69usbzBw0ahEWLFmH06NHQ6/VuuaY7+HxRr8gCaSebx0h9FUmScPsjt+BPq6fCGB4CvUmLjNNZmD7kBez4Zq+3wyPyuM2bNyMpKanOjrPLly/HuXPn8NJLLzX4unq9HklJSdiyZYs7wqQGkqFy6SDydR0D20Kn0kBRNY/p91e7JaInXuozGmHaEASYgbzyIvxxz0p8d+GAt0Mj8jjmHC2LO3KOoqIih8NsNtd4L4vFgv3792PYsGH2x1QqFYYNG4adO3c6Fb8nrtkQPpttGduGILRDGwirrQN+c2wO0+P6bpi3/hl07tkBepMWZrMZ8+5/HX978Qsoine65xJ5WnFxMU6cOIFBgwbVek5eXh7mzp2LP//5zwgLC2vU9QcOHIjjx4+jpKTE1VCJiBpEo1IjNjgcigRkll2CWbZ4O6RrdAmJwMJ+49DD2AEGiwTFYsWLR9bjzWPfwqqwtw+1TMw5qCadOnWCyWSyHwsWLKjxvNzcXMiyjIiICIfHIyIikJXlXM82T1yzIXy2qAeAmN5RUGQFpUXluJRd4O1wahTWsS1e+PRpJP6un22dfYAan8z/HC8++CbKisu9HR6R2/36668QQqBnz561npOcnIw2bdrgySefbPT14+PjIYTAqVOnXAmTGoHT74muNMsTANLK8r0dTo1a64IwL+EB3BnZG/pKCbpKYN3ZnXhy30cosLC3D7U8zDlaHnfkHGlpaSgsLLQfc+bM8fKr8jyfLupjEzrbm+WlNZNmeTUxBOrx2OIJeHDWvdAGaqAL0eDnr/bgqRtewIVTmd4Oj8itqqY4BQYG1vjzX375BStWrMD06dORkZGBs2fP4uzZs6ioqEBlZSXOnj2L/PzaE+aAgACH+5DnKVC5dBC1BFXb2gHNa1391bQqDR69bhgeu24YDLIaBguwP+80xu9YipNFzTdXInIGc46Wxx05h9FodDhqW/seGhoKtVqN7Oxsh8ezs7NrbYJXH09csyF8OtuKSYiCUAAIIP148/6gkiQJdz06DE+v+COC2wRBb9Li3LF0TBs8B/s2/c/b4RG5TdUvzrKyshp/fuHCBSiKgunTpyMmJsZ+7N69GydPnkRMTAxefPHFWq9fXl7ucB/yPFlILh1ELUHXkEhAAhSVaJbr6q82rF1v/KX3g2irCUaAGcguK8CkXR9gc+Zhb4dG5DbMOVqepsw5dDodBgwYgK1bt9ofUxQFW7duxZAhQ5yK3xPXbAiNx67cBGJ7V2+W13w64Nel9809MXf9LLwzdSUyTmWjrKQML/zuFUx+7fd4YNY9kCQmwOTbunbtCkmSkJqaisTExGt+3qtXL3z11VfXPJ6cnIzi4mK8/fbb6NKlS63XT0lJgSRJ6Nq1q1vjJiKqS9fgKx3wz5V6blsid+pu6oCF/cZiUeo/8EtJNixKJV7432c4UZSBx7vdAbXk02M7RMw5yGUzZ87E+PHjMXDgQAwePBhLlixBaWkpJk6cCAB45JFH0KFDB/u6fIvFgtTUVPufL1y4gEOHDiE4ONj+Pqnvmp7g00V9x7j20GjVEFYF6Sd8Zxp7ZHQ4kj+fiZXP/g0H/5+9+46vqj4fOP75nruyF4QEZCUEZYUhIKC4Kq2orWKROnDxU2xFHICtC9E66rZqFakojhZHHbVqKw6so7IEpIYNykiABLLIvut8f3/cJJDKSG5ucm7ufd6v13kZT84597lAcr/POd/n+S5ei6/Gz3O/+wtb12xjxnO/ISZO7gaKjishIYHjjjuOb7755pC/vDp37syECRN+tL9h3dhDfe9gK1eupF+/fiQkJIQgWtEcramNl5p6ESnSXAmkOROo9FaxvboYrXWHuBHfyZXIPYN/xXNbF/N50XoMrXnlhy/ZWlnIvUMuJNERa3WIQgRNxhyRp73HHBdeeCH79u1jzpw5FBYWMnToUBYtWtTY6G7nzp0YxoEboLt372bYsGGN///oo4/y6KOPcuqpp/L5558365ptoUPfonU4HfTs3x3Tr9mzbS8ej9fqkJotLiGW65++mgnTx2OPs+FIsPPZq/9hxsl3UrRjn9XhCdEqP/3pT3n77bfxeELbIdrtdvP22283WSZEtD2tDcwgN6079MeMEE30rW+WV+Wt61CN55w2B9cdeyb/l30aLr9BjAeW7NvMlUvn8kNV0dEvIEQYkzFHZLFizDF9+nR27NiB2+1m+fLlTWZ9fP7557z00kuN/9+7d2+01j/aGhL65lyzLXT40VbW4ECzPL/PT+EPHeuDyTAMJlx/Ntc/fRXxqbG4kh18/99tXDfyFv77xTqrwxMiaL/5zW/Yu3cvb731VrPP+fzzz1m7du0Rj3n77bfZu3cv1157bWtDFC3gR7VqEyJSHNwsb0dN+NfVH0wpxdndj+fOQRNJtsUS64ZdVSVctXQeXxSttzo8IYImY47IImOO4HT8pH5QL0xffQf8MG+WdzjDfzqE2W/MJDMrHVeyk8ryKm756b3845lFaK2tDk+IFut/bAJn/iSD22+/hcrKypBcs6Kigttuu43x48fTv3//kFxTNI+pW7PEjNXRCxE6OYmZaAO06hjN8g4lN7UnDw2dTFZcF2I8UOdx89tv/8rzWxdjatPq8IRosf7HdebMM7rJmCNCyJgjOB0+qW9olqdNTUEYL2t3NN37dmXOW7MYdHI/nEkOsGuevv4FHr/6WTzujlNWIIR2f4Eu+SXPPBBLcXEhM2bMaP01tWbWrFmUlJQwd+7cEEQphBAtl5N4ULO8qo5bKpcRm8z9Qy7kpM7HEeNROLzw3NbF3LrmVap9snSX6Di0Z3VgzPEHp4w5RFTr8El91uBeAGifJn9zx03qAeKT45nx3K85++ozcMTZccTbWfTiv7n59Lso3n34NTSFCAdam+iqueiya0BXkNXTweP3HssLL7zAfffd14rrau677z6ef/55nnzySbKyskIYtWiOYGvbGjYhIkXv+HRsysA06LBP6hvE2J3M6HcOk7PG4vIpXB74vHA9Vy17lvzqEqvDE+KItNbomoXo0svA3BsYc9yTJWOOCCBjjuB0+HfeqWsqSZ0SMf2ags0dpwP+4dhsNn712/P49WNXEJvswpXkYMPyLVw38lbWL9tsdXhCHJI2K9Hl16GrngDq5z65xjH1xuXcd9993HnnnUydOrXF0+IqKiq45pprmDNnDvfffz9XXXVVyGMXR2eiWrUJESlcNgc94ztjKiioKcFn+q0OqVWUUpzf4wRuH3Q+ScpFrAe2VezlyqXPsHSfjDlEeNK6Dl1xG7ri90D9bFbnKKbeuFTGHBFAxhzB6fBJvVKK7PpmeeV791NRGppaGquN+flw7nhtBp17phGT4qR8Xzk3n3YXixZ8ZnVoQjShfVvRJReAe3H9HoVKmIFKeRplJHDHHXcwf/58XnvtNQYNGsSrr7561A61brebV199ldzcXF577TWef/55br/99rZ/M+KQ/Fq1ahMikvRNCHTA92uT3bVlVocTEsPSsnhw6GR6xqQR64Eadx0zVr3MX7Z9Kb19RFjR/l3okkug9p0DO+P+D5X6IsrWScYcEUDGHMHp8Ek9QO9BPRub5XXkuvr/1WtAd+56+2b6jcrBmeTAVCaPXf0sT1//Aj6vz+rwhEDXfYQumQT+bYEdKhmVOh+VcC1KHfj1cvXVV5OXl8eAAQOYPHkyPXr0YNq0aSxYsIDly5fz3XffsXz5chYsWMC0adPo2bMnkydPZsCAAeTl5cndciFE2GjSAb+qY0/BP1i3uFTuH3oJI9P6EONR2HyaP21axJ3fvUGdP7RLhQkRDO1egi7+Jfjqu9arWFTy4xhJt6KUvfE4GXOIaGQ/+iHhL3twL7TZkNTvYcCY4yyOKHSS0hK5ecE0Xn/g73y68CsMu59/PLOIbWt3cuffZpKSnmx1iCIKae1HV/0Rqp87sNN+HCrlGZS95yHPycrK4sMPP2T9+vXMmzePTz/9lHnz5jV5CqQUZOfEMPGCX3L99NnScTZMtKZOLZrr20Rk6pOYCQpMpdlZvQ/oZ3VIIRNvd/G7Aefy5o5lvLlzGYap+Xj3d+yoLubhYZPpGptqdYgiCmmtoeYFdOWjQP0KDbYegTGH49A/f80ac6BIcqRw5llncveDc2TMESZkzBGciEnqob5Z3qZdFkcTenaHnUvnTKLngO785fd/Q9l8fPfleq4beSt3v/Nb+h6fbXWIIoposwxdPgs8/zmwM+YXqKR7UUbcUc8fMGAATz31FABVVVVs3boVt9tNje9fxHWaT1y8QdeU0+mcKB+u4cIksFRMsOcKEUn6NnTANzreWvXNYSiDC3ufSK+EdJ7etAjD42Fz+W6uWPIMDw67hOPTZMwh2o82q9EVt0Pdhwd2Ok9BpTyGMo7+YOtwY468Lzbw6u3vY9cOzsw9VxL6MCJjjuBExO2MXgN7oJQKNMvb0vGb5R3OKReM4Za/3EBatxRcyQ727Sphxsl38tlr/zn6yUKEgPauR5dMPCiht6ESb0clP9qshP5/JSQkMHToUEaNGsXokb8iLj7wK6navSKEUYvW0q1oWKOj+ANWRKaMmGQS7DGYCrZXd9xl7Y5mdOe+/GHoxXR1pRDrgYq6Gq77ZgFv7lgqdfaiXWjfdnTphU0T+vjrUKnPNSuh/18HjznOv/Rc7MoBwNr/bAxVyCIEZMwRnIhI6mPiXBzTNxPTb7Jr8278/o7djfZIcoZmcddbs8g5PgtXsgOf38cDk59k/u/+EtHvW1hP1/4DXXIh+AsCO4w0VOpLqPgrUar1v0RjHP0wVCIANe4VMmgUQoQlpVSgrt6AUncVVd46q0NqMz3jO/PQ0MkMTelNrEehvCaPbHif+9a+g8eU3j6i7ei6fwceIvjqV2FQ8aiUuRiJNzbp2ROsTt3S6NYnA4BN33yPp076RoiOLSKSegisV699Go/bx94dkTcd7mCpGSnc8pfrOeWC0TgS7DjibPzt0fe445wHqCyrsjo8EWG09mJW3Ife/1vAHdjpGIzq9C7KNSpkr6OUjTjXCAB8ZjEe37aQXVu0jqlVqzYhIk3fg5vldfD16o8mwRHD7YPO57zuI3B5A+vZv1+wit8sn8++ugqrwxMRRmsTXfUndPmvQdevaGXrg+r0NipmXEhfa9BJgXp8r8fHppXfh/TaIngy5ghO5CT1g3pi+gNP9vIjqAP+4TidDqbcdzGXzZmEM8GJM9HOqk/+y/QTbmX7unyrwxMRQvv3oUuvgJpXDuyMnYRKexVlywz568UfdJOg2r085NcXwWloWhPsJkSkyUnMRCvQCnZE8BT8BjZlcFn2Kdx43NnEaQcxHlhXns8VS58hr3yn1eGJCKHNCnT5teiqPx3Y6ToT1elNlD30vRwGjT3QZE+m4IcPGXMEJ2LeefbgXqBBmzqilrU7EqUUZ0w+md++OI2UjCRcyQ72bN/LDWNu5+t3pSZZtI72rEGXnA/elfV7HKikezGS70cpZ5u8ZrzrhMavpa4+fMhdcyGa6pMQ6ICvlWZnhD+pP9jJGf24b+iFZDiSiHVDaW0lv1k+n38UrDz6yUIcgfZuQZdcAO5/1+8xUAmzUClPoYyENnnN3IOS+jxJ6sOGjDmCE1lJPaD9moIt0ZHUN+h3Ql/uevtmeg/qgSvZgcfj4e5fPsLLd72BaZpWhyc6GK01uuZ1dOlkMPcGdhoZqLSFqLgL2/S1Y51DULiAQF29EEKEoz6JgVpcM0qe1B8sOyGDh4ZdwsCkHsR4FNrr5/617/DI+vfwmdLbR7ScrvsQXToJ/NsDO1QKKvV5VMKvQ9Kz53C65WSSmhFouLd+6Wb8fhkzi44rYpL6jN7pxCbEYPo1+RujK6mHQMOP21+9idE/Px5Hgh17rI2/3vsWd//yEaoraqwOT3QQWrvRFXegK+YA3sBOx0hUp7+jnEPb/PUN5SLWFXgdj38HXn9hm7+mOLpgu9A2bEJEmni7i2Ni0/AbsLOmBFNHVzKQ7IxnTu5Ezuo6BJdX4fTCmzuWMf2bBZR5pLePaB6tfZiVj6DLbwRdP1a19w/Uz7vGtvnrK6Uap+DXVNSy7bsdbf6a4uhkzBGciEnqDcMgK7cn2qfZV1BCTVWt1SG1O1esk18/egUX/u48nPF2nIl2lr63khvG3E7B5ui70SFaRvv3oEsvgdq3DuyMuwKV9hLK1rnd4oh3yhT8cCNT4YT4sZz6Znluv5e9dfutDqfd2Q0bV+ecwbXH/pRYv40YD3xbuo0rlsxl4/5dVocnwpw2S9FlV0H1/AM7Y85FdXodZe/RbnE0NMsDmYIfLmTMEZyISeqhabO8XZsjd736I1FKcdZVZ3DTc78hsVM8rmQH+Zt2M33Ubaz48FurwxNhSruX19fP59XviUElP4KRdAeqfh3X9tK0rl6a5YUD+YAV4sf6JmbS0JNpexTV1f+vMzJz+f2QX9HZnkCMG/bWlDN1+XN8tPu/VocmwpT2rkMXTwTP0vo9dlTibFTyIygV266xHFxXv/ZrSerDgYw5ghNZSf3gXugo6oB/JINP7s+ct2bRo183XMkOamvqmP3zB3j9wb/L+t+ikdYaXf0iuuxKMEsDO23dA3fKY8+zJKbAsnaBX01SVy+ECFd9EjPqO+BHV7O8QzkuqRsPDZvMcQldifEo/B4vd373Bk9t+hB/lJUmiCPTte+gSy4Cs342h9EZlfYyKv7yNq2fP5yswb2ISwrcSFj7n40yRhYdVkQl9U2a5cl0czJ6deGON2Yw/GeDcSbascUYvHD7q/zhkieora6zOjxhMW3WoPfPQlc+ANQ3N3KORXV6B+UYYFlcNiORmPrXr/NuxG+WWxaLCJC75kL8WE5iVyA6m+UdSporgd8P+RVnZAxqrLP/6w9fcdPKl9nvkd4+0U5rD2bF79H7bwXcgZ2OoYExh3OkZXHZbAYDxhwLQFnRfnZtic6ZvuFExhzBiaikPiu3JwCmP3qWtTua2PgYrnvq/zj/hrOxx9pwJtj5/I0l3DR2NoXb91odnrCI9u1El14IdR8c2Bn/G1TqfJSRYllcjaE0TsHXVLtlqSSryQesED/WPS4Nl+HANGBHlD+pb+A07Fzb96dcnfMTXH6DGA8sL97ClGVz+b5SGp9GK+3fiy69HGoWHtgZezEq7a8oW6Z1gdWTpe3Ci4w5ghNRSX1CSjxdenZG+zT5m3bLFJp6hmFw3nXjuWHu1cSnxuFKdrAtbwfXjbyVNf9ea3V4op1p9xfokl+Cb1Ngh4pHpTyNkTgTpWzWBldP6urDiyb4brTyW1hEKpsy6JOYgamgqLacOp/H6pDCglKK8d2GclfuBaTa4oh1w+6qUv5v2Tz+XbTO6vBEO9Oe1YExh3d1/R4HKukPGMm/RymnpbE1GHRwXb0k9ZaTMUdwIiqph8DTetNvUltVR8nuMqvDCSvHnzGY2W/OJLNPF1zJTqr2V3HLz+7l70/9S26ARAGtTXTVXHTZNaArAjttWahOb6JifmZtcP8jzjWq8Wupq7ee3DUX4tByEjMxjcAgNL+mxOpwwsrAlB48NGwyfeIziPEoPB4Pt3y7kOe2fEq0LQEYjbTW6JqF6NLLwKyfGWpkojq9hoq7wNrg/sdxI/rgcAWaAkuzPOvJmCM4EZjU98L0NTTLkyVV/tcxfTKZ8+YsBp82AGeSA+WAuTe9yCP/9wyeOnnKEKm0WYkuvw5d9QQ03Md0nRFYC9aeY2Voh+SwpeO0ZwNQ6/kO04y+JSqFEOEvJyHwpB6krv5Q0mOSuG/IrxibfhwxHoXDC89//xm/+3YhVT7p7ROptHajK25DV/we8AZ2OkehOv0d5RhsaWyH4oxxctzIPgDs+WEvJbtLLY5IiJaLuKQ+e3CvQM6ipQP+4cQnxXHjs1M555pxOOLsOBLsfPLyF8w67S6Kd8mThkijfVvRJReAe3H9HoVKmIFKeQZlJFga25E0TMHXeKnxyHKMVpK75kIcWk5iJigwDS119Yfhsjm56bizuSz7FFw+hcsDXxZt4Kqlz8qfWQTS/t3okouh9p0DO+OmoFJfRNk6WRfYUUhdffiQMUdwIjCpP9Asb5d0wD8sm83GpFnnMu2PVxKXHIMr2cHGb7YybcQtrFuyyerwRIjouo/QJZPAvy2wQyWhUp9DJVyLUuH94x9/0BT8apmCbyn5gBXi0HISA02+Ah3wJUE9HKUU53Ufwe2DzidZuYj1wPbKfUxZOpev98mYI1Jo91J08fnga+jXFINKfhwj6TaUslsa29FIXX34kDFHcMJ7VB+E7sd2w+G0o32mPKlvhhPOPp47Xr+JLr06EZPiZH9JBTeffhf/mv+p1aGJVtDaj1n5GLr8etDVgZ324wJLx7hOtTa4Zjq4WZ7U1VtLPmCFOLQUZzzpriRMA3bW7JP+NEcxLC2LB4dOpldsJ2I9UOuuY+aqV3j5hy/kz64D01qjq19Al00BXd/PytYD1elvqNifWxtcMw0YcyyGEfi8kqTeWjLmCE7EJfU2u42eA7pj+jWF2/bicUud+NH07NedOW/dTP8Tj8WZ5EAbmj/++s88NW0+Xo/X6vBEC2mzDF02Far/fGBnzM9RaW+g7D2tC6yFHLae2G0ZANR4VqG1z+KIRHt65pln6N27NzExMYwaNYoVKw5/Y2f+/PmcfPLJpKamkpqayrhx4350vNaaOXPm0LVrV2JjYxk3bhxbtmxp67chokBOYiamgiqvm1JPldXhhL2ucancP+QSRnXKIcajsHs1z2z+iDv++zq1soJAh6PNavT+m9CVDwH1DRCdpwQeIjj6HfHccBKfFBco4QW2rc2nqrza4oiEaJmIS+ohUFdv+jSmqdm9tcjqcDqExNQEbn7+Wn56+ak44u044m28P+9jbvnpvZQVlVsdnmgm7V2PLpkInv/U77GhEm9HJT+GMuIsja2llFLEOwNT8E1dTa1XlkKyitaqVVtLvfHGG8ycOZO77rqL1atXM2TIEM4880z27t17yOM///xzLr74Yv7973+zdOlSevTowc9+9jN27TrQLPXhhx/mqaeeYt68eSxfvpz4+HjOPPNM6uqkWZdonYZl7UCa5TVXnN3Jzf1/wYW9xuCsr7P/dE8eVy//M7trZOWijkL7dqBLL4S6Dw/sjJ+GSv0zyki2LrAgNUzB11pLKaqF2nvMESkiMqnPyu2F9ksH/Jay2W1MvmMiVz84mZhEF64kB3n/2cB1I29l86rvrQ5PHIWu/Qe65ELwFwR2GGmo1JdQ8VeiVMf8JSdT8MNDsOvFNmwAFRUVTTa3233Y13v88ceZOnUqU6ZMYcCAAcybN4+4uDgWLFhwyOMXLlzItGnTGDp0KP369eP555/HNE0WLw40h9Ra88QTTzB79mzOO+88Bg8ezCuvvMLu3bt59913Q/7nJaJL38RMtAFaSbO8ljCUwaReY7hl4HkkEqiz37p/D1csfYZvSmTMEe503b8D68/7Ngd2qHhUylyMxJtQymZtcEGSuvrwEIoxRzSKyKS+oVmeNjUFm/dYHE3HM/b8Udy28AbSjknBleygeE8pM06+k0//+qXVoYlD0NqLWXEfev9vgfpEyTEY1eld1EHN5jqiuIOS+mr3cgsjiW6hqG/r0aMHycnJjdsDDzxwyNfyeDysWrWKcePGNe4zDINx48axdOnSZsVbU1OD1+slLS0NgG3btlFYWNjkmsnJyYwaNarZ1xTicKRZXuuM7NSHB4ZeTDdXKrEeqKyr4YaVL/L69q+lzj4MaW2iq55Gl/8GdGVgp61PYIncmHFHPjnMSQf88CA19cGJ0KQ+UBOjfZoCeVIflOzBvbnr7ZvpOyIbV7IDv/bz0OV/Yt6sl/H7/FaHJ+pp/z506RVQ88qBnbGTUGkLUbZM6wILkRhHPwwVmMJX7V4hA7wOLD8/n/379zdut9122yGPKy4uxu/3k5GR0WR/RkYGhYWFzXqtW265hW7dujUm8Q3nteaaQhxO7/h0bMoINMuTpD4o3eM78dDQSzg+JYtYj0J5TR7f+E/uyXsbt196+4QLbVaiy6ehq54isH404PoZqtObKHu2pbGFQmpGCsf0DYydNq/8Hnet9HgQHUdEJvWpGSmkpCdh+jX5m+RJfbBS0pP53cvTOfVXYwJ19nE23v7jB9x+9v1UlFRaHV7U05416JLzwbuyfo8DlXQPRvL9KOWyNLZQUcog3jUCAL9Zitu31eKIolMo6tuSkpKabC5X2/wbffDBB3n99df5+9//TkxMTJu8hhAHcxh2suK7YCooqCnBa0pTz2DEO2K4ddAEzu8+Epc3UGf/z12r+c2K+eyt2291eFFPe7cEeva4P6vfY6ASZqFS/oQyEiyNLZQGnRR4Wu/z+tm4QpqpWkFq6oMTkUk9QFZ9s7yKkkr2F1dYHU6H5XQ6mHLvxVzx+wtxJjhxJjlYvTiP6064lW15O6wOL2rpmtfRpZPBrG8cZmQEns7HXWRtYG2gaV29TMG3QntOhevcuTM2m42ioqZNTouKisjMPPLsk0cffZQHH3yQjz/+mMGDBzfubzgvmGsK0Rx9EjMwDTC1ZldtqdXhdFg2ZTA5+2Rm9DubOBzEemB9eQGXL3mG/5bJmMMquu5DdOkk8G8P7FApqNTnUQm/7rA9ew5HpuBbT6bfBydik/rs3J4HNcuT9epb6/SLTuKWV6aTkpGEK9lB0c593HDiHXz19jKrQ4sqWrsx99+BrpgD1E9JdIxAdfo7yjnUytDaTNxBfQGqpVmeJdrzrrnT6WT48OGNTe6AxqZ3Y8aMOex5Dz/8MPfeey+LFi1ixIgRTb6XlZVFZmZmk2tWVFSwfPnyI15TiOZqWNYOYEeVTMFvrZO69OP+IReR4Uwm1g3ldVVcu+J5/p4vnwHtSWsfZuUj6PIbQdcEdtr7B+rnXWOtDa6NSLM868mT+uBEbFKfNbgX2gwk9QWbJakPhWOH9+Gut28ma3BPXMkOvF4v90x6jBdnv4ZpmlaHF/G0fw+69BKoffPAzrgrUGkvo2ydrQusjcU6BzeWE0hSHx1mzpzJ/Pnzefnll9mwYQPXXnst1dXVTJkyBYDLL7+8SU3+Qw89xJ133smCBQvo3bs3hYWFFBYWUlUVWDNcKcVNN93Efffdx3vvvUdeXh6XX3453bp1Y8KECVa8RRFh+iZmggJTaVnWLkSyErrw0NBLyE3uQYxHgdfPA+ve5cF170qJQzvQZim67Gqonn9gZ8y5qE6vo+w9rAusjXXNziCtayoAG5ZtkT5SosOI2KT+4GZ58qQ+dDp1TeX2hTdy4oSROBLs2GNtvPqHd7hrwsNU76+2OryIpd3L6+vn8+r3xKCSH8FIugOlHJbG1tYM5STOeTwAXn8BHp/8PLc33YppcMHcNb/wwgt59NFHmTNnDkOHDmXNmjUsWrSosdHdzp072bPnQL+UZ599Fo/HwwUXXEDXrl0bt0cffbTxmN/97ndcf/31XHPNNYwcOZKqqioWLVokdfciJBo74Buws7rE4mgiR5IzjtmDJvLzbsNweRVOL7yzcwXTvnmBErf09mkr2rsOXTwRPEvq99hRibNRyY+gVKylsbU1pRS5Jwee1tdW1fH9mu3WBhSF2nvMESkiNqnv2f8YDENh+k0KJKkPKWeMk6kPXsrFt56PM96OM9HOsn+u4vrRt5Mvqw2ElNYaXf0iuuxKMOvrNG3dA3fKY8+zNLb2JHX11tKA1kFuQb7m9OnT2bFjB263m+XLlzNq1IEyjM8//5yXXnqp8f+3b98e+Fn5n+3uu+9uPEYpxT333ENhYSF1dXV8+umnHHvssUFGJ0RT6a4kkhyxmAp2ypP6kLIbNqb0OZ3rjjuTONNOjAe+K93BFUvnsn5/gdXhRRxd+3d0yUVg1o/njE6BGYHxl0dc/fzh5J4kdfVWsmLMEQkiNql3xbo45thumD7N7q17ZPpMiCmlOHPK6cx64VoS0xNwJTso2LKH6aNuY/k/V1kdXkTQZg16/yx05QNA/b9f59hALZtjgKWxtTepq7eWiWrVJkSkU0rRNzET04BSTzUVnhqrQ4o4p2cM5J7BvyLdnkCMG4pr9vPr5c/x4e5vrQ4tImjtwaz4PXr/LYA7sNMxtL5nz0hLY2tvTerqv5akvr3JmCM4EZvUA2QPDjTL83r8FG7fa3U4EWngif24662b6dn/GFzJDupq3dx57kMsvP9tWVO8FbRvJ7r0Qqj74MDO+F+jUuejjFTrArNInHM4YAMkqRdChKc+CQc1y5P16ttE36SuPHT8pfRP7EaMR+H3+Ljruzd5YuO/8Jny8CZY2r8XXXoF1Cw8sDP2IlTaX1G26FshpPegHiSkxAOw9utNMp6NAs888wy9e/cmJiaGUaNGsWLFkceab775Jv369SMmJobc3Fz+9a9/Nfn+lVdeiVKqyTZ+/Pi2fAuRndRn5fbC9EuzvLbWpUdn7njtJkacNRRnoh1bjMFLd77OvRc+Tm1VrdXhdTja/QW65Jfg2xTYoeJRKX/CSJyFUjZrg7OIzYgn1jEIALdvEz5/mcURRRfpRCvE0eUkZqIVaJmC36ZSnfHcNXgSP83Ibayzf3Xbf7hp1cuUywyJFtOe1YExh7dhlqUDlXQ/RvI9KOW0NDarGIbBwBMD5Vn791VIb6521t5jjjfeeIOZM2dy1113sXr1aoYMGcKZZ57J3r2HfiC8ZMkSLr74Yq666iq+/fZbJkyYwIQJE1i7dm2T48aPH8+ePXsat9deey2oP4/miuikPntwL9CgTU3+RvmBbEsx8TFc98QUJs74OY44O84EO1+9tYwbT5rNnh+Kjn4BgdYmumouuuwa0BWBnbYsVKc3UTFnWhtcGIg7uK7e842FkUQfWTNWiKNr6ICvlWZHjTTLa0tOw85vjv0p1+ScgctvEOOBFcVbuXLpM2yp3HP0C4hA75GaV9Gll4FZn7wYmai0V1Fxk6wNLgzI0nbWae8xx+OPP87UqVOZMmUKAwYMYN68ecTFxbFgwYJDHv/kk08yfvx4fvvb39K/f3/uvfdejj/+eJ5++ukmx7lcLjIzMxu31NS2nWkb0Ul9Vm5PALRfy5P6dqCU4he/+Rk3zZtKfFocrmQH29flc90Jt7L60++sDi+sabMKXX4duuoJGtt8uM4I1M/bc6wMLWwc3CyvWprltaugG9bUb0JEg+yEDBQKUyHL2rWTn3Ubwu8HTyLNFkesGwqry7hq2TwWF+Yd/eQoprUbXXE7uuJuwBvY6RxVXz8/xMLIwsegkySpt0ooxhwVFRVNNrfbfcjX8ng8rFq1inHjxjXuMwyDcePGsXTp0kOes3Tp0ibHA5x55pk/Ov7zzz+nS5cuHHfccVx77bWUlLTtzd6ITuozeqUTlxiLKcvatashpw1izpuz6NY3A1eyg+rKam4bfx9v//EDqUs6BO3bii6ZCO7F9XsUKuEmVMozKCPB0tjCSdOkXurq25NMvxfi6GLtTrrHpeE3IL+6BL82rQ4pKvRP7s5DwyaTE59JjEfh9Xi5bc1rzN38Mab8HfyI9u9Gl1wMtW8f2Bl3JSr1RZStk3WBhZljR/TBGRNYMjhPmuW1q1CMOXr06EFycnLj9sADDxzytYqLi/H7/Y1L5jbIyMigsLDwkOcUFhYe9fjx48fzyiuvsHjxYh566CG++OILzjrrLPz+tuv9EdFJvVKKrPpmeSW7y6iukFqr9tI1O4M7/zaToT8ZiDPRgeE0mDfrZR6+8mnctYe+WxaNdN1H6JJJ4N8W2KGSUKnPoRKmoVRE/3i2mN3WCVf9rIVaTx6mKT/PQojwkpMYaJbnMX0U1u63Opyo0TkmiXuH/IpT0/sT41E4vPDSD58za/VfqPLWWR1e2NDupeji88HXUPsbg0p+HCPpdpSyWxpbuHE47fQ7ITDmKNq+j7350vyyI8nPz2f//v2N22233daur3/RRRdx7rnnkpuby4QJE/jggw/45ptv+Pzzz9vsNSM+a8g+qFneri1SZ9We4hLjuGHuVH7xm59hj7PhSLDz6V++ZOapd0X9L0et/ZiVj6HLrwddHdhpPw7V6R2U61RrgwtjB+rqfdR4VlsaSzSRJ/VCNE9O/bJ2ADurZdWd9uSyObj+uPFckX0qLp/C5YGv925iyrK57KiK7nIIrTW6+gV02RTQ9Y1mbT1Qnf6Giv25tcGFMamrt0YoxhxJSUlNNpfLdcjX6ty5MzabjaKipv2/ioqKyMw89MoPmZmZLToeIDs7m86dO7N169aW/FG0SMQn9VmDe6Hrk3ppltf+DMNg4oyfc92TU4hLicGV7GDL6u+5buStrP3PBqvDs4Q2y9BlU6H6zwd2xvwclfYGyt7TusA6AKmrt4Y0yhOieXIObpYny9q1O6UUv+g+nDtzJ5JixBDrhp2VxVy5bC5f7Y3OpEybNej9M9CVDwH15QjOkwM9exz9jnhutJOk3hrtOeZwOp0MHz6cxYsXN+4zTZPFixczZsyYQ54zZsyYJscDfPLJJ4c9HqCgoICSkhK6du3aovhaIvKT+oOa5UldvXVGjh/Gna/PoEuvzriSnVSUVnDzT37P+/M+tjq0dqW96wP1857/1O+xoRJvQyU/hjLiLI2tI4h3jWr8Wurq2480yhOiefomBp7UBJrlSVJvlcGpvXho6GR6x6UT64E6t5ubV/+FBd//O6p6+2jfDnTpr6DuoDW046cFyvyMFMvi6igGjD4WwwgkiVJX337ae8wxc+ZM5s+fz8svv8yGDRu49tprqa6uZsqUKQBcfvnlTabv33jjjSxatIjHHnuMjRs3cvfdd7Ny5UqmT58OQFVVFb/97W9ZtmwZ27dvZ/HixZx33nnk5ORw5pltt5pV5Cf1g3oAYPo0BZt3WRxNdOt+3DHc9dbNDDzpWJxJDrBpnpo2nyd+/We8Hq/V4bU5XfsPdMlF4C8I7DDSUKkvoeKnoJQ8zWwOh607DlvgLmeNZzVaR/6/GyFEx9EtNpVYmxPTgJ2S1FsqIzaF+4dcxJhOxxLjUdi9mnlbPuG2Na9R44v83j667t+B9ed9mwM7VDwq5RmMxJtQymZtcB1EXGIsfYZmAbBjXQEVJZUWRyTawoUXXsijjz7KnDlzGDp0KGvWrGHRokWNzfB27tzJnj0HSrhPPPFEXn31VZ577jmGDBnCW2+9xbvvvsugQYMAsNlsfPfdd5x77rkce+yxXHXVVQwfPpyvvvrqsGUAoRDxXTHik+PJ7J1OcWEpBZv3YJomhhHx9zLCVkJqPDPnX8ubj77Pohc/w7Cb/HP+p2xbl89db80iLbNt13C0gtbewLS3mlcO7HTkolKeRtnabhpOJFJKEecaxf6ad9G6llpPHnGu460OK+IF7n4Hd+Mpih6KCYGhDPokZLDRnU9R3X5qfB7i7E6rw4pasXYns/r/nHfyV/D69q8xtOazwrXsrC7mkeMv5Zi4NKtDDDmtTaiei676E41L5NqyUanPoOx9LI2tI8o9uR9bVv8AwLolmxjzixEWRxT5rBhzTJ8+vfFJ+/86VHO7SZMmMWnSpEMeHxsby0cffRRcIK0QFdlt1uBemH6Tumo3xbtLrQ4n6tnsNi66dQLXPHwZsUlOXEkO1i/dxHUjb2XTN23XQMIK2l+MLr2yaUIfewEq7VVJ6IMkU/DbnzTKE6L5mjbLk6f1VlNKMbHnKG4dOIFE5SLWA99XFHLF0mdYURxhYw6zEl0+DV31FI0JvetnqE5vSUIfpIPr6vOkrr5dyJgjOFGR1Gfn9sL0BX65FUizvLBx4nkjue3Vm+jUPRVXsoPSojJmnDKHj1/+3OrQQkJ71qBLJoD3m/o9DlTSPRjJf0Cptpt+E+lkvfr2p1u5CRFNGpa1A9hZHd1d18PJ8E7ZPDjkErrHpBHrgeq6Wm5Y+SILt/0nIurstXdLoGeP+7P6PQqVMAuV8ieUkWBpbB3ZoJOkWV57kzFHcKIiqc/K7dn4Ny3N8sJL1qCe3PX2zRw3sg/OJAcmfh6Z8gxzb3oRv89vdXhB0zWvo0sng1m/pJHRBZW2EBV3kbWBRQCXvS+2+gY/NZ4VgamGQggRJho64JuGZmeNPKkPJ8fEp/HAkEsYkdqHGI/C5tM8uelf3J33JnX+jtujRdctQpdOAv/2wA6Vgkp9AZXwa+nZ00op6Un06NcNgC2rt1FbXWdxREIcWnQk9YN7AWD6TPI3S1IfbpI7J/Hbl67jJxePxRFvxxFn4+9P/Ytbx9/H/uIKq8NrEa3dmPvvQFfMAeoHCI4RqE7vopxDrQwtYihlEOcMPK33m+W4fVssjijyyVQ4IZovRzrgh7V4h4tbBp7LL3ucgNMbWM/+w11ruGb5cxTVllsdXoto7cOsfARdfgPomsBOe//AcnWusdYGF0Eantb7fX42roisko1wJGOO4ERFUn9MTibOGAfarynYJB3ww5HD6eDyu3/FlHsvwpXoxJnkYM2/1zL9hFv5/r/brQ6vWbR/T+DpfO2bB3bGXY5Kexll62xdYBFIpuC3M5kLJ0SzJTli6RKTjGnAjup9ETG1O9IYyuCSrLHM6n8O8TiJ9cCm8l1csfQZvi3dZnV4zaLNUnTZ1VA9/8DOmHNRnV5H2XtYF1gEypX16tuXjDmCEhVJvc1uo9fAHph+zd4dxbhrPVaHJA7j1F+dyO9evp7UzCRcyQ6K8ou58cQ7+PyNr60O7Yi0ezm65Hzwfle/JwaV/AhG0myUclgaWyRqmtQvtzCSKNGaO+ZRfNdcRK++9XX1NT4PxW5ZBitcjUk/jj8MvYhMZzKxHiivrWbaNy/w9s7lYX0zRnvXoYsngmdJ/R47KnE2KvkRlIq1NLZINEiS+vYlY46gREVSDwea5ZmmZtfWQqvDEUdw7PBs7n7nZvoM7Y0r2YHP7+P+i5/ghdsW4veHV5291hpd/SK67Eow61dWsHUP3CmPPc/S2CJZrDO3ceBSI0/qhRBhJifhQAd8mYIf3nrFp/Pg0MkMSe5FrEehvCYPrf8HD6x7F4/pszq8H9G1f0eXXARm/cxTo1NgRmD85VI/30YyeqXTuXtg+cP1y7bg84bfvwshoiapz8rtifbXd8CXKfhhLzUjlVv/ej1jfzkKR4Ide5yN1x96lzvPfYiq8mqrwwNAmzXo/TejKx8A6m82OMcGatkcAyyNLdIp5SDOGVif3uvfjcdXYHFEkS2wZmzwmxDRJicxk8BDIy0d8DuAJGcstw86n190H46rvs7+3fxvmLbieYrrwqO3j9YezIrfo/ffArgDOx1DUJ3+jnKOtDS2SKeUapyC765xs/Xb7dYGFOFkzBGc6Enq65vlab+WDvgdhNPl5Ko/XMLkOybijHfgTLTzzaJvmT7qNnZssDaJ076d6NILoe79Azvjf41KnY8yUq0LLIo0nYK/zMJIIp80rRGiZaRZXsdjN2xckX0q1x83njhtJ8YDeWU7uWLpXNaV51sam/bvQ5deATULD+yMvSiwqo4t07rAosjBS9vl/WeDhZFEPhlzBCdqkvrswT2BQFJfIB3wOwylFD+9/FR+u2AaSV0ScSU72P1DITeMvp0l731z9Au0Ae3+El3yS/Btqg8yHpXyJ4zEWShlsySmaBTvGtX4tTTLa2MNdWrBbkJEmV7xnbErW6BZXo08qe9ITs0YwL1DLiLdkUiMG0pqK/j1ivl8sGu1JfFoz7f1PXtW1e9xoJLux0i+B6WclsQUjQaN7d/4tdTVtzEZcwQlapL6lPRk0jJTMOuf1IdzAxTxY/1HH8tdb91MzwHH4EpyUFfn5q4JD/PXe9/CNJu/TnlVVRVr1qxh+fLlrFmzhqqqqmafq7WJrnoWXTYVdP10PFsWqtObqJgzW/qWRCsFpt/bAamrF0KEF7thIyuhC6aC3TVleDrwGujRqE9iBg8Nm8yApGOI8ShMj4978t7isQ3v4zOb39undWMOja55FV16KZh7AzuNTFTaq6i4SS19S6KVeg04hsTUeADWfr2pRWNPIdpD1CT1EJiCb/o0VWXVlO8Ljxop0Xzp3Ttxx2szGHXOMJyJduyxNl6+6w3u/dXj1FTWHva89evXc8MNN9C/f3+SkpIYNmwYo0ePZtiwYSQlJdG/f39uuOEG1q9ff9hraLMKXX4duuqPNK6X4ToD1ektlD0nxO9UNIdhxBHrHASA27cVn7/E4ogil9S3CdFyOYmBZnmm1hTUllodjmihVGc8d+VewJmZg3F5FU4vvLF9KdevfJFyz+F7+4RkzKHd6Irb0RV3A/U3hBwn1NfPDwnp+xTNYxgGA+un4FeWVrFzg/Tnaisy5ghOVCX12bk90f7AnTWpq++YYuJc/ObxK5k061wccXaciXb+885ybjzxDnZ/33RVg23btnHWWWcxcOBA3njjDU4//XReeOEFli1bxnfffceyZct44YUXOP3003njjTcYOHAgZ511Ftu2NV2jVvu2oksmgntx/R6FSrgJlfIMykhsp3cuDkWm4LcTWTNWiBZrWNYOYKfU1XdIDsPONX3H8Zu+44jx24jxwKqSH7hi6Vw2V+xpcmzIxhz+3eiSi6H27QM7465Epb2EsnVqj7ctDiP3ZFnarl3ImCMoUZXUZ+X2QpuAlg74HZlSinOuGceMP/+ahLR4XMkOdmwo4LqRt7Ly4/8C8Pzzz5Obm8uGDRtYuHAh+fn5zJ07lylTpjBq1Chyc3MZNWoUU6ZMYe7cueTn57Nw4ULWr19Pbm4uzz//PAC67mN0ySTw13/oqiRU6nOohGkoFVU/PmFJkvr2IU1rhGi5nMRMUGAqLc3yOrhxXQfz+8GT6GRPINYNRdVlXLVsHp/s+Q4I4ZjDvRRdfD741ta/cgwq+TGMpNtRym7RuxcNmjbLk6S+rciYIzhRlZVkHdQsL1+a5XV4g08dwJy3ZnHMsZm4kh3UVNdwx9n3c/FZlzJ16lQuvvhi8vLyuOSSS3A6j9xMxul0cskll7B27Vouvvhipk6dyn1zzkKXTwddP83Ofhyq0zso16nt8O5Ec8QdtIyP1NW3MbljLkSLNHbAN2BHlTTL6+j6JR/DQ8Mu4diETGI8Cr/Hyx3/fZ1fzLgiNGOOu85Hl00BXRY4yNYD1elvqNhftMO7E83R9/gsXHEuANZ+LUl9m5IxR4tFVVLfs393DJuB6TcpkOn3ESGzdxdm/20mw8YNwpnoYJexjdcXLeTee+9l/vz5JCa2bHp8YmIi8+fP55577uHOexfxwqv7A9+I+Tkq7Q2UvWcbvAsRLLstFZf9OABqvWvxm4evcxRCiPbUyZlAiiNOlrWLIJ1cidwz+Fec3mUALq+i9J9r+OCJV0Iz5rjnXV54tT6hd56M6vQ2ytHvyBcQ7crusNN/VKCP0r78Eop2yM06ET6iKql3uhz07HcMpk+z5/sifF6f1SGJEIhLiOX6p6/mpMnD2Wx+x1VXXcXs2bObHLNu3TomTZpEdnY2cXFxdO7cmVNOOYX333//kNecPXs2V111FTPmlLK95GpU8mMoI6493o5ooQPr1fup8aw64rEiODIVToiWU0o1Nsvb7605YnM10XE4bQ6uO/ZMfuE6jp0vfBbyMce2fb8KlPkZKe3wbkRLDRorU/Dbmow5ghNVST0EpuBrv8bn9VO4ba/V4YgQMQyDT9f9i67HZPLHP/7xR9/fsWMHlZWVXHHFFTz55JPceeedAJx77rk899xzPzpeKcXjjz9Op05due7mf6NU9P6SCHcHknqocS+3MJIIJk1rhAhKTmJXaZYXgZRS/OvxV+jaJSPkY47pv1uFUrY2fw8iOLljpVlem5MxR1CirutG1qBe/Pu1r4FAB/zux3azOCIRCps2bWLx4sUsXLjwkNPfzj77bM4+++wm+6ZPn87w4cN5/PHHueaaa350TlJSEg888CCTJ09mw4YN9O/fv83iF8GLk2Z57UDVb8GeK0R06puYiTZA10/BH5zay+qQRAjImCN69RvVF5vdht/nl7r6NiNjjmBE3ZP67IZmeaYmXzrgR4yXXnqJLl26cMEFFzT7HJvNRo8ePSgvLz/sMRMnTqRLly48++yzIYhStAWnvRsOW3cAajyrMbXH4oiEECKgsVme0uyolvrbSCFjjugVGx9DzrDeAOzcsIv9xRXWBiREvahL6rMGB+6Sa7+mYPOeoxwtOorPP/+ciRMnHrXjbHV1NcXFxXz//ff88Y9/5MMPP+SMM8447PEul4uJEyfy6aefhjpkEUINU/C1dlPrybM4mggkU+GECEpWQhcMFKYh0+8jiYw5oluTKfhfb7IwkgglY46gRF1Sn969Ewkp8Zg+LR3wI0RlZSVbt25l5MiRRz121qxZpKenk5OTw80338z555/P008/fcRzRowYwcaNG6mqqgpVyCLEmtbVL7MwkgglH7BCBCXG5qBHfCdMBfk1JfhMv9UhiVaSMYcYNPZAaUTeVxssjCRCyZgjKFGX1CulGpvllRaWU1Uu3Wg7uu3bt6O1ZsCAAUc99qabbuKTTz7h5Zdf5qyzzsLv9+PxHHm69sCBA9Fas3Xr1lCFLEJM6urbmFat24SIYjmJmZgKvKafwtpyq8MRrSRjDjHopOMav5ZmeW1AxhxBibqkHiBrUE9MX+BWTsFmeVrf0TV8QMbFHX3JuX79+jFu3Dguv/xyPvjgA6qqqvjFL36B1oe/tRcbGwuA2+0OTcAi5Fz2HGxGGgDV7pVobVockRBCBDQsawdIXX0EkDGHSOqUSK8BgV4+W9dsp7aqzuKIhIjSpD57cC+0WZ/UyxT8Dq+hpq2mpqbF515wwQV88803bN68+bDH1NbWAoFaNxGelFLEuwJTIU29nzqv3DkPJa1btwkRzfomdgXV0CxP6uo7OhlzCIBBJwXq6k2/yfplh//7FC0nY47gRGVSf3CzvHxJ6ju8rKwslFKsX7++xec2fHju37//sMesW7cOpRQ5OTlBxyjaXrxrdOPXNTIFP7Skvk2IoPVJyACQZnkRQsYcAiD3ZFmvvs3ImCMo0ZnUD+oBgOnT5EsH/A4vISGBnJwcvvnmm8Mes3fv3h/t83q9vPLKK8TGxh6xNm7lypX069ePhISEkMQr2kbcQc3ypK4+xKS+TYigdY1NId7mql+rXqbfd3Qy5hAAg8ZKUt9mZMwRFLvVAVghNiGWbn0yKNq1j12bd2OaJoYRlfc3IsZpp53G22+/zRNPPHHIJWZ+/etfU1FRwSmnnMIxxxxDYWEhCxcuZOPGjTz22GOH/fB0u928/fbbXHjhhW39FkQrxToGYqh4TF1NtWc5WmuUit5f7kKI8GAogz6JGax372Sfu5Jqr5t4h0yt7shkzCG69OhMRq/OFO0oZsPyLXg9PhzOqEyrRJiI2kw2K7cn2qdx13rYly/T4Tq6K6+8kr179/LWW28d8vsXXnghhmHw7LPPcu211/L444/TvXt3/vGPfzBz5szDXvftt99m7969XHvttW0VuggRpezEOYcD4PMX4fXvtDiiyKF06zYhot3BzfLya2TM0dHJmEPAgbp6T52XLat+sDiayCFjjuBEcVLfC9Mf+JvP3yRT8Du64447jjPOOIPbb7+dysrKH33/oosu4pNPPqGwsBCv10tpaSmffPIJ55577mGvWVFRwW233cb48ePp37//YY8T4UOm4LcRqW8TolUalrXTCrbLFPwOT8YcAv5nCv7XMgU/ZGTMEZSoTeqzB/dq/Msv2LTL6nBECDz88MMUFxczY8aMVl9La82sWbMoKSlh7ty5IYhOtIf4Jkn9cgsjiTBS3yZEq+QkZoICLR3wI4aMOUTu2AM3X/Kkrj50ZMwRlKhN6hs64Js+kwJplhcRevXqxX333ccLL7zAfffdF/R1tNbcd999PP/88zz55JNkZWWFMErRluKcw1A4AHlSL4QIHzkJmQCYCnbKk/qIIGMO0aNfN5I7JwKwfskmTNO0OCIRzaK2o0PX7C7ExLnw+X3ky5P6iHHZZZexb98+7rzzTrZv384f//hHEhMTm31+RUUFs2bN4vnnn+f+++/nqquuasNoRagZRiyxzsHUeFbh8f2A178Phy3d6rA6vtZMaYviqXBCNEhwxNA1JoViXzk7q0ukkWeEkDFHdFNKMfCkfiz5xzdUllWzY10BWbk9rQ6r45MxR1Ci9km9zWaj18DuaJ9m784S6qrrrA5JhMjMmTM59/LreOUvf6X/gAG8+uqreDyeI57jdrt59dVXyc3N5bXXXuP555/n9ttvb6eIRSgdXFcv69WHiNS3CdFqDXX1tX4Pe+sqrA5HhMjMmTOZef+lLHztFQYM6i9jjijT0CwPZAp+yMiYIyhRm9TDgWZ5Wmt2bS20OhwRImu3FVIa35v+E2dRZ09m8uTJ9OjRg2nTprFgwQKWL1/Od999x/Lly1mwYAHTpk2jZ8+eTJ48mQEDBpCXlyd3yzuweNeoxq+lrj5E5ANWiFY7uAP+TumAHzHKPAVk/bScW948gZReHhlzRJncsQcn9RssjCSCyJgjKFE7/R4CzfJ0fQf8gk276TOkt7UBiVbzeH08+94S/FphS+zM0wv+yuAMJ/PmzePTTz9l3rx5aH3gJ14pRb9+/bjwwgu59tprpeNsBIh3jQAUoKWuPlRa03wmipvWCHGwnMTM+h8lzfbqvYzs1MfqkEQraW3yzb4FaMNHeraD5995kMS9o2XMEUVyhvUmJt5FXbWbtf/ZKKU1oSBjjqBEfVIPoP2agk27LY5GhMLbX+Wxq3g/btNgUFYmk04djM0weOqppwCoqqpi69atuN1uXC4XOTk5JCQkWBy1CCWbkUKM4zjqvBup867Hb1ZiM5pf4yiEEG0hJ/HgZnnypD4SbKn8N/vcW7DFeUhxdmd42qXYOztlzBFFbHYb/Ucfy7eL8yjZXUbhtr10zc6wOiwRhaI6qW9oZmH6NfmbJanv6PL3lvH2l9/h1QqbYWP2peOwGU0rTBISEhg6dKg1AYp2E+caRZ13I2BS415JYuzpVofUoSkd2II9VwgBPeI64TTsmIZPlrWLADW+MtaUvoHh9KHsJqdlzsJuOJscI2OO6JA7th/fLs4DAnX1ktS3jow5ghPVNfVJnRLp1C0V7dPkb9rVZIqU6FhMUzP3vaV4/BqPqbjsZ8M5trt0PY9WTevqZQp+q0l9mxCtZjdsZCd0wVSwp6YMt99rdUiiFVaW/AWfrkE5vfRLGs8xcUOtDklYJPfkA3X1a6VZXutZMOZ45pln6N27NzExMYwaNYoVK448dnzzzTfp168fMTEx5Obm8q9//avpW9CaOXPm0LVrV2JjYxk3bhxbtmwJLrhmiuqkHgJT8E2/pnp/LWVF5VaHI4L06erNbNhRhMdUdE9PYeo5o60OSVgo/qAO+NUeSeqFEOGhoVmeBgpqSq0OJ+K11cOagupV5Fd/g4rxEudI4cQuv2mT1xEdQ78T+mJ32ABY+7Uk9R3NG2+8wcyZM7nrrrtYvXo1Q4YM4cwzz2Tv3r2HPH7JkiVcfPHFXHXVVXz77bdMmDCBCRMmsHbt2sZjHn74YZ566inmzZvH8uXLiY+P58wzz6Suru1WW4v6pD4rtxfabwKQL3X1HVJpZTUvfbQSn1b4teKOyWcQ44zqypKo57Bl4rQFembUutdgarfFEQkhxIFl7QB2VO+zNpgI9L9JfFs0LPOYtXxT8grK7sdw+Dmpy3XE2JJD/jqi43DFOjl2eDYABZv3yEPCDubxxx9n6tSpTJkyhQEDBjBv3jzi4uJYsGDBIY9/8sknGT9+PL/97W/p378/9957L8cffzxPP/00EPg99MQTTzB79mzOO+88Bg8ezCuvvMLu3bt599132+x9RH1Snz24F9oENBRs2mN1OCIIL/zrG6rrvLhNxTmj+zOqfy+rQxJhoGG9eo2bWs9/LY6mY1McqHFr8WZ18EKEkZyETFBgGlrq6kPs4K7jX3zxBbfeeiuPPfYYb7311mGfuAXju9K3qPGXYsR46RE3gr6JZ4Ts2qLjGnTQ0nZrv95kYSQdXyjGHBUVFU02t/vQD3c8Hg+rVq1i3LhxjfsMw2DcuHEsXbr0kOcsXbq0yfEAZ555ZuPx27Zto7CwsMkxycnJjBo16rDXDAVJ6gcfaJZXsHmXxdGIllq5KZ+v127DYypS4mOZecEpVockwkSTKfhSV986DcvLBLsJIYCmHfB3VIcu0RRgmoFZl08//TQPPPAASiny8vJ48MEH2bZtW0heo7juezZVfILh8uKwOTklY4YsXyaA/0nqpa6+dUIw5ujRowfJycmN2wMPPHDIlyouLsbv95OR0bS5YUZGBoWFhYc8p7Cw8IjHN/y3JdcMhaifo9z9uG7Y7Da0z5Tp9x1MrdvDnz9Yil8rfFoxc9KppCbGWR2WCBNNm+UtB6ZbF0xH15qGd9IoT4hGaa4E0pwJVHqr2FFdLGtah4jWGpvNxq5du3jhhReYO3cuY8aM4dFHH6Wuro4TTjgBn8/H9u3byc7OxjBa/kzLr32sKF6AsvlRDh8jO19FsrNbG7wb0RENPPE4lFJorcmTpL51QjDmyM/PJykpqXG3y+VqdVjhLuqf1DucDnr2PwbTr9nzw148HulG21G8tngN+8qrcZuKE/r14JzR/a0OSYQRpz0Lu9EZgBr3SrT2WxyREEJA3/pmeZXeOsq9NVaHExEabox8/fXX9O/fnzFjxrB8+XJeffVVbr/9dpRSrFq1ipdffpmCgoKgXmNT+SLKPDsxYjx0junD4NQLQvkWRAeXmJpA74E9APjhv9uprpCfbSslJSU12Q6X1Hfu3BmbzUZRUVGT/UVFRWRmZh7ynMzMzCMe3/DfllwzFKI+qYf6unq/xu/zU/hD0dFPEJbbuquYD5atx2MaOB12bp88Tp52iCaUUo119aaurF+3XgRFlrQTImSkWV7byc7OxusNPJx56KGHuPDCCxk8eDAAVVVVrFmzhoSEhBZft9JTRF753wNr0tvgtIybsamon+wq/kfDFHzT1GxY1rbLl0W0dhxzOJ1Ohg8fzuLFixv3mabJ4sWLGTNmzCHPGTNmTJPjAT755JPG47OyssjMzGxyTEVFBcuXLz/sNUNBknoCHfBNX+BfgTTLC38+v8ncfyzBp8GrYeo5o+nZJcXqsEQYalpXv9zCSDq2oBvW1G9CiAP6JGaiDdBKmuWFWvfu3amsrOSMM85g//793HLLLQDU1NTw2GOPccYZZ5CWltZYf98cWmu+KXkJv3KjXF4Gp/6SjNh+Rz9RRJ2D6+plCn7w2nvMMXPmTObPn8/LL7/Mhg0buPbaa6murmbKlCkAXH755dx2222Nx994440sWrSIxx57jI0bN3L33XezcuVKpk8PlHkqpbjpppu47777eO+998jLy+Pyyy+nW7duTJgwIRR/RIckST0HmuVpU1OwSZrlhbsPlq3nhz0luP2KnG6duexnw60OSYSpg+vqa6RZXvAseFL/zDPP0Lt3b2JiYhg1ahQrVhz+72/dunVMnDiR3r17o5TiiSee+NExd999N0qpJlu/fjIwF+2v78HN8qrkSX1rNCxht3PnTjweD5mZmdx///1069YNn8/Hiy++yIsvvsiMGTNwOBzcdNNNQMuWuttevYQ9tWsxYjwkONI5ofP/tcVbEREgV5rlhUY7jzkuvPBCHn30UebMmcPQoUNZs2YNixYtamx0t3PnTvbsOfDQ98QTT+TVV1/lueeeY8iQIbz11lu8++67DBo0qPGY3/3ud1x//fVcc801jBw5kqqqKhYtWkRMTEzLA2wmmTsEZOXWJ/U+Tf5maZYXzorKKnlt8bd4tUIrxR2XjsNhs1kdlghTMY4BGCoBU1dR7V4uTak6iDfeeIOZM2cyb948Ro0axRNPPMGZZ57Jpk2b6NKly4+Or6mpITs7m0mTJjFjxozDXnfgwIF8+umnjf9vt8tHoGh/vePTsSkD0zDlSX0rKaX473//yz333MOkSZM4/fTTGT58ODfddBMffvghf/nLX3C5XJx55pmNT9p8Pl+zf/bd/kpWl7yKcvhRdpNTM27CaUhDXnFonY9JIzOrC4Xb9rJxxVY8bi9Ol8PqsEQzTJ8+vfFJ+//6/PPPf7Rv0qRJTJo06bDXU0pxzz33cM8994QqxKOSEQ3QqVsaiWkJ1NbWki/T78OW1po/v7+MOq8fj6n41WlDGNJHOs+Kw1PKRpxrOFV1X+Az9+HxbcPlyLY6rI6nnbvfP/7440ydOrVx6tu8efP45z//yYIFC7j11lt/dPzIkSMZOXIkwCG/38But7dpkxohmsNlc9AzvjP53r3sqinBZ/qxG3JzuiVM02zsYL9//342b97Mo48+yvLly7nkkksYMWIEw4cPZ/bs2ZSVlZGamtp4bktu5q0ueQ23WYER66VPwqn0Tjgx5O9FRJZBJ/WjcNtevG4vm7/5vsmUfNFMsuJOUGT6PYG7KQ3N8sr37qeyrMrqkMQh/CdvG6u3FOA2FekpCUyfcJLVIYkOoOnSdjIFPxihqG+rqKhosrnd7kO+lsfjYdWqVYwbN65xn2EYjBs3jqVLl7bqfWzZsoVu3bqRnZ3N5MmT2blzZ6uuJ0Sw+iYEOuD7tMnu2jKrw+mw7rvvPv7+979z4YUXMm3aNNasWcNtt93G/Pnz+eGHHwCaJPQtUVS7nh+qvkK5PLjscYzNkGVRxdEdPAU/72uZgh8M6eMTHEnq62Xl9jyoWZ5MwQ83VTVuXvjXCvxa4deKWy76CQmxkb/mpGg9qasPAa1atwE9evQgOTm5cXvggQcO+VLFxcX4/f7GWrYGGRkZFBYWBv0WRo0axUsvvcSiRYt49tln2bZtGyeffDKVlZVBX1OIYPU5uAN+lUzBbynDMNixYwdvvvkmU6dOZfbs2fzf//0fH330EWPGjOGxxx7jT3/6E5999hkej6fF1/eZHpYXv4iymRhOP6PTryHe3rkN3omINLknS119q4VgzBGNZPp9vezBvdBmIKnP37Sb/qOPtTgicbCXP15JeXUdblNx+tA+/GRYjtUhiQ4i1jkEhRONh2qPdMC3Sn5+PklJSY3/f7g1Y9vKWWed1fj14MGDGTVqFL169eJvf/sbV111VbvGIkROYiYoMJVmZ/U+QKboNlfD1Ps9e/aQkpLS2Mne7Xbjcrm49957+f7771mxYgXfffcdv/vd7zjzzDNb9Brr9r9Hpa8QW5yHzJiBDEz+eVu8FRGBjunblZQuyZTv3c+6JZvw+01sNnmGKtqe/Curd3CzPOmAH17Wbivkk1WbcZuKuBgXv7vodKtDEh2IoWKIdQ4FwOPbgddfZG1AHVEIOtEmJSU12Q6X1Hfu3BmbzUZRUdO/p6KiopDWw6ekpHDssceydevWkF1TiOZq7IBvwI4aeVJ/NKZpsn79eoDGWvpevXphGAbffPMNELhR6PP5ABg7dix33XUXp556Kr/97W/Jz89v9muVewpYX/YBhtOLzWbjtMxZKCXDZdE8SikGjT0OgJqKWrbnSZlXi1mw4k4kkN9S9XoN7IFSCtOvyd8szfLChcfr49n3luDXCp9WXDfhJDJSE60OS3QwTderlyn4LdWe9W1Op5Phw4ezePHixn2mabJ48WLGjBkTsvdUVVXF999/T9euXUN2TSGaKyMmmQR7TGBZu2pZ1u5o5s+fz1133cXrr79OcXHgJkjXrl25/PLLefDBB7nzzjvxeDwYhkFRURFvvfUWtbW1XH311aSlpVFeXt6s19HaZMW+BWjDh3L6GNbpYtJcWW34zkQkyj1J1qtvDampD44k9fVi42PolpOJ6TfZtXk3fr/f6pAE8PZXeewq3o/bVAzKymTSqYOtDkl0QAcn9TVumYLfYu1813zmzJnMnz+fl19+mQ0bNnDttddSXV3d2A3/8ssvb1yeCgLN9dasWcOaNWvweDzs2rWLNWvWNHkKf/PNN/PFF1+wfft2lixZwvnnn4/NZuPiiy9ueYBCtJJSipzEQLO8EncVVd46q0MKayNGjCAzM5O//e1vPPnkk3z11VcATJkyhYcffphly5YxYsQILrroIi6++GLS09M577zzMAwDrfVhG3P+ry2V/2afewtGjIcUZ3eGp13alm9LRKhBY/s3fr1WmuW1nDypD4rU1B8ke3BP9mwrxOP2sW9nMZlZGUc/SbSZ/L1lvP3ld3i1wmbYmH3pOGyG3IcSLRfnGgEoQMuT+mC05u53EOddeOGF7Nu3jzlz5lBYWMjQoUNZtGhRY/O8nTt3Nk7BBdi9ezfDhg1r/P9HH32URx99lFNPPbVxfdmCggIuvvhiSkpKSE9PZ+zYsSxbtoz09PQg35gQrZOTmMF/S7YDsKO6mIEp3a0NKIwNHz6c4cOH89JLL/HPf/6TLVu2sHnzZs455xzOO+88xo4dyxdffMHmzZsZPnw4I0aMAODhhx+mZ8+ejf9/JDW+MtaUvoHh9KHsJqdlzsRuONv6rYkIlD2kF3GJsdRU1rL2PxvRWqNU9DZwa7F2HnNECknqD5KV24uv3gk8xcvftFuSeguZpubZ95bi8Ws8pmLK+OEc210G3yI4NiOJGMcA6rzrqPNuwG/ux2YkWx2WOILp06czffqhl5BqSNQb9O7dG62P/En++uuvhyo0IUIiJyGzsVnzjup9ktQfht/vx2azNX5tmia7du1i7ty55OXl8Ytf/IKTTz6ZX/7yl43n7N+/n4ULF5KXl8fLL7/crNdZVfJXfLoGw+mlX9J4jokbdvSThDgEm81gwJhjWfnxfyktLGf390UckxO6njBCHIo89jxIVm5P0KBNTb4sa2epT1dvZv2OIjymont6ClPPGW11SKKDOzAFX1PtXmlpLB2OTIUTIuRyEruCAq00O6ulWd7hNMzKmTVrFl9++SV33XUXS5YsYfbs2ezevZs//OEPPPvss3z33XeN58TExDBs2DCeeuopunXrdtTXKKhexc7qFagYL3GOFE7s8ps2ez8iOgwaK0vbBU3GHEGRpP4g2YN7AaD9moLNktRbpayyhpc+Womvfk36OyafQYxTJpWI1pH16ltBPmCFCLk+iYHZgNIs78iUUhQVFbFmzRquuOIKBg8O9NY5//zz+fOf/0x6ejqvvfYaTz75ZOOqGS6XiwEDBtC/f/8jXRoAj1nLNyWvoOx+DIefk7pMI8YmM7lE60hS3woy5giKJPUHyczqQky8K9ABf6Mk9VZ54cMVVNd5cZuKc0b3Z1T/XlaHJCJAnHTAD5p0ohUi9OLtLo6JTcNvwM6aEkxtWh1S2OrUqRMZGRmsWBH43e3z+fD7/aSmpnL22WeTnZ3Naaed1th3oyXyyt6mxl+KEeOlR9wI+iaOC3X4Igr1G9kHR/0DqTxpltciMuYIjiT1BzEMg6zcnmifZl9BCbXV0o22va3clM9/8rbhMRUp8bHMvOAUq0MSEcJh64LT3huAWs8aTLPW2oCEEFGvT2IGpgK338veuv1WhxOWTNPEZrMxfPhw3n//fZYuXYrdbm+ss09KSqJv376NK1mYZvNvjhTXfc/G/R9juLw4bE5OyZghDc1ESDhjnBw7og8Au7cWUrKnzOKIRKSTpP5/ZOf2wvQHbvPskin47arW7eHPHyxtXJN+xqRTSE2MszosEUEapuBrvNR41lgbjBAi6vVNzETXj8S2S119o4MbXxqGgVKKWbNmceqpp3LVVVdxxx138Mknn/DnP/+ZBx98kJycHOx2O1rrJitjHIlf+1hRvABl86McPkZ2uoJk59Hr74VoLpmCL9qTJPX/I2twL3R9Up+/aY/F0USX1z9bw77yatymYuRxPfj56AFWhyQiTJzz4PXqZQp+s0l9mxBtIiexoQO+NMs7WMPT8o0bN/LGG2+wYMECdu/ezW233cZjjz3Gf//7Xx588EE+/vhjzjvvPC677LIm5zXHpv0fUebZiRHjpXNMHwanTWqT9yKiV64k9cGRMUdQpPvY/8jK7QkEmuXlb9plcTTRY+uuYt5fuh6PaeB02Lnj0nEyBU6EXPzBdfUeSeqbqzV1atFc3ybE0eQkdgUCzfJ2SrM8IFAvb7fbeffdd3nuuedISUmhpKSEp59+mpdeeomzzjqLs846ix9++IEePXo0Ppk/eOm7o6n0FJFX9k5gTXqb5rSMm7EpGRKL0Bow5liUUmityZOkvtlkzBEceVL/PxqSetOvKZBl7dqFz28y9x9L8Gnwarj67NH07JJidVgiAjntvbEbgUZKNe6VaO2zOCIhRDTrHpeGy3BgGjL9HgLT7u12O9XV1dx7771cc801vPrqq1xyySWkpaXRp08ftNZorcnOzsbhcDQm9c1N6LXWfFPyEn7lRrm85KacT0Zsv6OfKEQLJaTEN66stS1vJ1Xl1RZHJCKZJPX/IzE1gfQendA+TcHmPU3qukTb+Oey9fywpwS3X5HTrTOX/2y41SGJCKWUanxab+pq6rzrLY6oA5FpcEKEnE0Zjc3yimrLqfN5rA7JUg0z9D744AOOPfZYJkyYwI4dO3jyySeZPXs28fHxLFmyhFtvvbVx+bqWzurbXr2UPbVrMWI8JDjSGZV+VcjfhxANGurqtdasX7rZ4mg6EBlztJgk9YeQPbgXpt+kprKWUulW2aaKyip5dfG3eLVCK8Udl47DYW/e3XYhgiFL2wVB6tuEaDN9EjIwjcCPSn5NidXhhIWuXbvi8QRucNx3332cccYZnHbaaQA4HA42b96M1+tt8XXd/kpWlyxEOfwou8mpGTfhNKQhr2g7B9fVyxT8ZpIxR1AkqT+ErNxemL6GZnkyBb+taK358wfLqPP68ZiKC04ZwpA+0nlWtK2GDvgA1e7lFkbScciasUK0nb6JmZj1D5t3SF09ADk5OQBce+21fPfdd9xzzz2N3/vTn/7EoEGD6N69e4tnU64ueQ23WYHh8pKdcAq9E04MadxC/C/pgN9yMuYIjiT1h5CV27Pxbo8k9W3nP3nbWL25ALepSE9JYPr5J1kdkogCMY7jMFQSEHhSLyU2Qggr5SRmggLT0Oyskbp6rTXdunXjvPPO4/vvvycnJ4evv/6apUuXMmfOHLZv386cOXMaj22uotr1/FD1FcrlwWWP4+SM69vqLQjRKC0zhW45mQBsXvk9nrroLrERbUeS+kNoaGoRaJYnHfDbQlWNmxf+tQK/Vvi14paLfkJirMvqsEQUUMpGvGsEAH6zBI/vB4sj6gBkKpwQbSYnMTDgNxXskGZ5jTXyl156KVdffTV2u52HHnqIX//619TV1fHoo4/icDjw+XzNXpPeZ3pYXvwiymZiOP2MTr+GeHvntnwbQjTKPSnwtN7r8bHxm+8tjqYDkDFHUGT9jkPofmxXHE472mdSsFnWqm8LL3+8kvLqOtym4vShffjJsByrQxJRJM51ApV1nwGBKfguRx+LIwpvsryMEG0nxRlPuiuJcl8FO6r3obWO+iVdTdPEMAx+9atfceqpp2KaJrW1tWRnZzceY7c3fwi7bv97VPoKscV5yIwZyMDkn7dF2EIc0qCx/fjo5c+BwBT8wSf3tzagMCdjjuDIk/pDsDvs9BzQHdOv2bNtLx63TJUJpbXbCvlk1WbcpiIuxsXvLjrd6pBElGlaVy/N8o5K7poL0aYaOuBXed2UeqqsDsdyhmE0Tq3PyMiga9euTRL6lij3FLC+7AMMpxebzcZpmbNQSoa/ov1IXX0LyZgjKPJb7TCyBwea5Zl+kz3f77U6nIjh8fp49r0l+LXCpxXXTTiJjNREq8MSUSbWORhFoNxDknohhNVyorBZ3tHq4UMxW0FrkxX7FqANH8rpY1ini0lzZbX6ukK0RLc+GaRlpgCwfulm/D6/tQGJiCRJ/WFkDeqJ9jd0wJe6+lB5+6s8dhXvx20qBmVlMunUwVaHJKKQoVzEuYYC4PXvxOuThphHJHfNhWhTfRMz0QZopaOmrr4haV+9ejXPPvssDz30EF9++WXj+vOhsKXy3+xzb8GI8ZDi7M7wtEtDdm0hmksp1fi0vqaylu//u8PiiMKcjDmCIkn9YWTVN8vTppYO+CGSv7eMd77Kw6sVNsPG7EvHYWtmkxshQi1OpuA3mywvI0TbOrhZ3s4oSOp9Ph8AH330Eb/97W/59ttvWbt2LVOnTmXt2rUheY0aXxlrSt/AcPpQdpPTMmdiN5whubYQLTXoJJmC31wy5giOZFSHkT24JwDaJx3wQ8E0Nc++txS3z8RjKi772XCO7Z5udVgiisU7T2j8WpL6o5C75kK0qd7x6diUgWlERwd8u92O3+/n7rvv5te//jXPPfcckydPJiMjg+OPPx6AvXtbV/q4quSv+HQNyumlX9J4jokbForQhQhK7sF19V9LUn9EMuYIiiT1h5GakUJKelJgWTvpgN9qn67ezPodRXhMRff0FKaeM9rqkESUi3MNp+FXYLVnubXBhDv5gBWiTTkMO73j0zEVFNSU4DV9VofU5r744gsyMjKYNGkShYWFzJ49m1tuuYXU1FTWrVvHI488wubNm4O6dkH1KnZWr0DFeIlzpHBil9+EOHohWqZ3bk/ikmIByPvPxqP2lIhqMuYIiiT1h6GUIqu+Wd7+4kr2F1dYHVKHVVZZw8sfr8RXvyb9HZPPIMYpqykKa9mMRGIdgwBwezfh85dZHJEQIprlJGZiGmBqza7aUqvDaXO9evXC4/GglOLRRx/lhBNO4OyzzwbAZrOxbt06TNNs8XU9Zi3flLyCsvsxHH5O6jKNGFtyqMMXokVsNqNxCv7+fRXywFCEnCT1R3Bws7yCzVJXH6wXPlxBVa0Xt6k4Z3R/RvXvZXVIQgCB9eob1HhWWhhJeJP6NiHaXpMO+FWRPwU/MzOT5ORkLrjgAj799FMeeughlFJorfnjH/9I37596dev39Ev9D/yyt6mxl+KEeOlR9wI+iaOa4PohWg5WdqueWTMERxJ6o8ga3AvtBn41yHN8oKzalMB/8nbhsdUpMTHMvOCU6wOSYhG8a6D6+plCv5hyVQ4Idpc38RMUGAqHZHN8hqeuhcWFlJRUUF8fDzXX389sbGxdO3alTfffJOPP/6YW2+9lfXr13Pfffc1Oa85iuu+Z+P+jzFcXhw2J6dkzAjJ0nhChELuQc3y8iSpPzwZcwRF5kAfwcHN8iSpb7lat4c//3Np45r0MyadQmpinNVhCdGoaVIvzfIOpzV3v6P5rrkQLdHYAT8Cm+X5/X5sNhsFBQX84Q9/4KyzzuKnP/0pJ554IgAffPABr7/+OqWlpZx99tk8/PDDJCYmNp7XrNfQPlYUL0DZ/CiHj5Gd/o9kZ7e2fFtCtEjfEdk4XA68bq80yzsCGXMER5L6I+g1oDuGoTD9Jrtk+n2Lvf7ZGvaWVeE2DUYe14Ofjx5gdUhCNGG3dcZl74Pb9z21nu8wzVoMI9bqsIQQUSjdlUSSI5Zaby07q/dZHU5INSTms2bN4phjjmH06NHExMQAMHTo0MbkvqioiIyMjB+d1xyb9n9EmWcntngvnWP6MDhtUgjfgRCt53Q56HdCDnlfbaBw216Kd5XS+Zg0q8MSEUKm3x+BK9bFMcd2w/Rpdm0pxO/zWx1Sh/H97mLeX7oej2ngdNi549JxMgVOhKUDdfU+ajyrLY0lbMlUOCHanFKKnIRAs7xSTzUVnhqrQwqJhi7fH374IUVFRTzwwAOkp6fzww8/cMMNN3D++eczY8YMampqmiT0LVHpKSKv7J3AmvQ2zWkZN2NT8txKhJ+D6+plCv5hyJgjKJLUH0VWbqBZntfjo3BHZN05bys+v8kz/1iCT4NXw9Vnj6ZnlxSrwxLikOJdoxq/lin4hyEfsEK0iybN8iJkCn7DDf2dO3fSq1cvXC4XX375JU888QSFhYVMmTKFlStXsnJlcM1KtdZ8U/ISfuVGubzkppxPRmzLG+wJ0R5ypVne0cmYIyiS1B9Fdm4vzIYO+Jt2WRxNx/DPZev5YXcJbr8ip1tnLv/ZcKtDEuKwDq6rr5Gk/pBUKzchRPPkJGaiFWgF+RGS1DcYNmwYe/fuZebMmdx4443k5OTwxBNPcNFFF5GTk8MPP/wQ1HW3Vy9lT+1ajBgPCY50RqVfFeLIhQid/qP7YhiBT0ZJ6g9NxhzBkaT+KLIG9wQN2tTkb5S6+qMpKqvk1cXf4tUKrRR3XDoOh735NXFCtDeHrQd2W6BBVY1nFVp7LY5ICBGtGjrga6XZXhNZSX1ubi7nnnsuXbp0YebMmdxwww1069aNHTt2sHbtWoYOHQocmK7fHG5/JatLFqIcfpTd5NSMm3Aa0pBXhK/4pDiyh/QGYPu6fCpKq6wNSEQMKTg6iuzBvQDQfk3BFknqj0RrzZ8/WEad14/HVEw6dQhD+kjnWRHelFLEu0axv+YfmLqGWs9a4lzDrA4rvLRmSlsUT4UToqWyEzJQKEyl2dGBm+VprZv00dm3bx/p6elce+21mKaJYQSeKa1bt44HHniA008/naFDh/7ovKNZXfIabrMCI9ZLdsIp9E44MeTvRYhQyx3bj63fbkNrzbolmxjzc5nR2oSMOYIiT+qPIqNXOnGJsZg+TcGmPVaHE9b+k7eN1ZsLcJuK9JQEpp9/ktUhCdEs8U5Z2u5IGpaXCXYTQjRPrN1J97g0/AbkV5fg181foz2cNDxtf/fdd7npppuYPHkyU6dOZePGjY0J/a5du3j99ddJSUnh/vvvb3JecxTVrueHqq9QLg8uexwnZ1wf+jciRBsYJHX1RxSuY47S0lImT55MUlISKSkpXHXVVVRVHXmmRV1dHddddx2dOnUiISGBiRMnUlRU1PT9KvWj7fXXX29xfJLUH4VSit71zfKKd5VSUxkZ3WhDrarGzQsfrsCvFX6tuOWin5AY67I6LCGapUldvUeS+h+RpjVCtJuGZnke00dh7X6rw2kxv9+PYRhs3LiRhx56iLS0NO6++25WrFjBJZdcwiOPPEJpaSnHHHMMN954I3PmzMHhcDSe1xw+08Py4hdRNhPD6Wd0+jXE2zu38TsTIjQGnXRc49eS1B9CmI45Jk+ezLp16/jkk0/44IMP+PLLL7nmmmuOeM6MGTN4//33efPNN/niiy/YvXs3v/zlL3903IsvvsiePXsatwkTJrQ4PknqmyE7t+eBZnmb5Wn9obz88UrKq+pwm4rThvThJ8NyrA5JiGZzOY7DZiQDgSf1uoM+HRNCdHw5iYFl7YAOuV59w9ryd999N+eccw5z5szB6XQSExPDlVdeyWuvvcb06dP58MMP6dy5M126dGlyXnOs2/8elb5CjBgPmTEDGZj88zZ5L0K0hdSMFLof2xWAzat+oK7GbXFEkaeioqLJ5na37s94w4YNLFq0iOeff55Ro0YxduxY/vSnP/H666+ze/ehy7P379/PCy+8wOOPP85PfvIThg8fzosvvsiSJUtYtmxZk2NTUlLIzMxs3GJiYlocoyT1zZA9uBe6PqmXZnk/tm57IZ+s2ozbVMS6nNxy8elWhyREiyhlEFc/Bd9vluH2bbU4ojAUZnfMhYhUOQc1y9vZQTvgb9y4kaSkJC677DIAfv/733PppZdyww03cMkll7Bq1Sp+97vfHXXq6qGUewpYX/YBhtOLzWbjtMxZKCXDWdGx5I7tD4Df52fjChlz/Egrxxw9evQgOTm5cXvggQdaFc7SpUtJSUlhxIgRjfvGjRuHYRgsX778kOesWrUKr9fLuHHjGvf169ePnj17snTp0ibHXnfddXTu3JkTTjiBBQsWtKgUqYE0ymuGrIOb5W2WpP5gHq+Pue8txa8VPq2Yef5YMlITrQ5LiBaLd51AZd0nQOBpfYzjWIsjCh+tqVOTmnohWqZvYmA1DlPB9g74pB6gS5cujBs3juTkZBYvXgzA+eefD8AJJ5xAXFwcEydOJCEhAb/f3+yn9FqbrNi3AG34MJw+hnW6jDRXVpu9DyHayqCx/fhwwWdAYAr+0NMGWhxR+AjFmCM/P5+kpKTG/S5X60qCCwsLG2cVNbDb7aSlpVFYWHjYc5xOJykpKU32Z2RkNDnnnnvu4Sc/+QlxcXF8/PHHTJs2jaqqKm644YYWxShJfTNkDeoBgOnT5EtS38Q7X+Wxa185HtNgUFYmk04dbHVIQgSl6Xr1y+mUcKmF0YQZ6UQrRLvpFptKrM2J3/B02Cf1aWlpXHDBBRiGQVxcHB6Pp3E66fLly9mwYQPTpk0DWjbtfkvlv9nn3oItzkOKszvD0+T3tOiYDm6Wlyd19U2FYMyRlJTUJKk/nFtvvZWHHnroiMds2LAhyGCa584772z8etiwYVRXV/PII49IUt8W4pPjyeiVTklRKbs27WmyHEs0K9hXzttf5eHVCsOwMfvScdjkz0V0UDHOXJSKQes66YAvhLCMoQz6JGSw0Z1PUd1+anwe4uxOq8M6ooan7aZpopSivLyc1NRUIPBUqqysjCuvvJJevXrx5Zdf8tprrwG0aDxV4ytjTekbGE4fym5yWuZM7EZ4/7kIcTiZvdPpfEwaxbtK2bBsM36fH5u9+Te4RGjMmjWLK6+88ojHZGdnk5mZyd69e5vs9/l8lJaWkpmZecjzMjMz8Xg8lJeXN3laX1RUdNhzAEaNGsW9996L2+1u0QwDSeqbKWtwT/YtKqa2uo7i3aV06R7dXVZNUzP3H0tw+0w8pmLK+OEc2z3d6rCECJqhnMQ5j6favQSvfxce3y6c9mOsDissyPR7IdpXTmIm68vyAcivKea4pG4WR3R4Pp8Pu92OaZo8/PDDrF69GqfTSefOnbntttvIzs7m9ddf59lnn8XpdPLYY48xaNCgFj8gWVXyV3y6BsPppV/SeI6JG9aG70qItqWUYtDYfnz+xhLqqt1s/XY7x43sY3VYYaE9xxzp6emkpx89fxkzZgzl5eWsWrWK4cOHA/DZZ59hmiajRo065DnDhw/H4XCwePFiJk6cCMCmTZvYuXMnY8aMOexrrVmzhtTU1BaXDMhj1WbKzu2F6avvgC/N8lj87WbW7yjCYyq6d05h6jmjrQ5JiFY7eAp+tfvQjU+iUpguLyNEpGpY1g4I2yn41dXVlJSUYLcHng/dfPPNLFmyhCFDhnDyySeze/duxo0bx2uvvUZ2djaPPPII9957Lz/72c+AQFLTXAXVq9lZvQIV4yXWkcyJXX7TJu9JiPY06CSZgn9IYTjm6N+/P+PHj2fq1KmsWLGCr7/+munTp3PRRRfRrVvgpuuuXbvo168fK1YEZnsmJydz1VVXMXPmTP7973+zatUqpkyZwpgxYxg9OpA3vf/++zz//POsXbuWrVu38uyzz/KHP/yB66+/vsUxypP6Zsoe3KvxH0vB5j0cPy56a8fLKmt46aOV+OrXpL998hnEOOWfkuj44l0H7rbWuFeQGv/jtUSjkTypF6J9NXTANw3NjjBtlvfwww9TUVHBJZdcQo8ePSgoKODBBx9kwIABAEyYMIHXXnuNl156ib59+zJixIgmT+abm9R7zFpWlryCsvsxHH7GdrmOGFtym7wnIdpT7kF19Wu/3sgFM86xMJrwEa5jjoULFzJ9+nTOOOMMDMNg4sSJPPXUU43f93q9bNq0iZqamsZ9f/zjHxuPdbvdnHnmmcydO7fx+w6Hg2eeeYYZM2agtSYnJ4fHH3+cqVOntjg+ycSaqaEDvukzo75Z3oIPv6Gq1ovbVJwzuj+jB/SyOiQhQiLWeTxgA/xSV38waZQnRLvKOagD/o4wfVLfvXt3Fi9ezFNPPcXo0aNJSEjA6TxQ456RkcHkyZP56KOP+Oyzz5osBdUSeWVvU+0vwRbvpUfcCPomjjv6SUJ0AL0GdicxNZ7KsmrWfb0RrXWLZrBErDAdc6SlpfHqq68e9vu9e/f+0VJ0MTExPPPMMzzzzDOHPGf8+PGMHz8+JPHJ9PtmOiYnE4fLEVjWbtMuq8OxzKpNBXyV9wMeU5ESH8vMC06xOiQhQsZmxBPrHASA27cZn7/U4oiEENEoyRFLl5hkTAN2VO8Las3itjZ16lQeeOABevTowccff8ySJUv4xz/+gc/nazwmPT2dU045hR07duD3+1v8GsV1P7Bx/8cYLi8Om5NTMmZI0iMihmEYDDjxOAD2F1eSL+W9ohUkqW8mm91G74HdMf2aou37cNd6rA6p3dV5vPz5nwfWpJ8x6RRSE+OsDkuIkIp3HpiCL0/r64VhfZsQka5vfV19jc9DsbvS6nAOKSsrq7H+84QTTuBf//oXjz/+ON999x0AGzdu5IMPPuDEE09s7I7fXH7tY0XxCyibH+XwMbLTFSQ7w7dhoBDBOHgK/ndfte3SaR2GjDmCIkl9C2QNDjTLM03Nrq2FVofT7l77bA17y6pwm4qRx/Xg56MHWB2SECEX12S9eknq4UB9W7CbEKLlchIyMetHaeHaLK/BuHHjePLJJznrrLP4+uuvueGGGzj33HN5/PHHmTBhApMnTwZoUbf7Tfs/osyzEyPGS+eYPgxOm9RW4QthmYOb5a2VZnmAjDmCJUl9C2Tn9kL76zvgR1ld/fe7i3l/yTo8poHDbueOyWfIFDgRkZp0wPdIB3xA7poLYYGcxEy0Aq3Ct1newVJTU7n55pu5/fbbGTx4MLt27SIzM5Np06YBtOgpfZVnL3ll7wTWpLdpTsuYhU1JGygRefoOz8YVG+hFsfZrSeoBGXMESZL6Fmholheoq4+epN7nN3nmH0vwafBqmHrOaHpmpFodlhBtwm5Lw2XvC0CtZy1+s9riiIQQ0SgnMQMI72Z5hzJq1Cgee+wxrrjiCo4//nji4+PRWjf7Kb3WmhUlL+FXbpTLS27K+WTE9m/jqIWwhsNpp98JOQDs3VnM3p0d52ddhBdJ6lsgK7cnEEjqo6kD/j+Xb+CH3SW4/Yqcbp25/GfDrQ5JiDZ1YGk7P7We1ZbGEg6U1q3ahBAt1ys+HbuyBZrl1YT/k/qDORwObrjhBiZMmNDic7dXL2VPbR5GjIcERzqj0q8KfYBChJHckw/ctJL16mXMESxJ6lsgtUsyqRnJmH5N/sZdYdmNNtSKyip59dPVeLVCK8Udl47DYbdZHZYQberguvpqt0zBl6lwQrQ/u2EjK6ELpoLdNWV4TN/RTwpTzS3Xc/urWF2yEOXwo+wmp2TciNOQhrwisg0aK3X1TciYIyiS1LdQQ7O8qrJqyvdVWB1Om9Ja89wHy6nz+vGYigtOGcKQPtJ5VkS+A0/qpQM+SNMaIaySkxholmdqza6aEqvDaXOrS1/DbVZguLxkJ5xCVsJJVockRJvrP6ovhi2QkkldvYw5giVJfQsFmuUFmr0UbN5jcTRt6+u121i1OR+3qUhPSWD6+fLhKqKD034MDtsxANR4VmPq6FvCUghhvYZl7aBj1dUHo6h2PT9UfolyeXDZ4zg543qrQxKiXcQmxNB3WBYAO9YXUFESnktYivAmSX0LZQ/uhTYBDQWbdlkdTpupqnHz/L9W4NcKv1b87sLTSYx1WR2WEO2moQu+1nXUefIsjsZiMhVOCEv0ScgABabSEZ3U+0wPy4tfRNlMDKef0Z2nEm/vbHVYQrSbJlPwv95kYSRhQMYcQZGkvoWipVneyx+vpLyqDrepOG1IH34yLMfqkIRoV3EyBb+RTIUTwhp9EzMBAs3yqjpWs7yWWL//PSp9hRgxHjJjBjIw5RdWhyREu2paV7/BwkisJ2OO4EhS30I9+x+DYTMw/Sb5GyPzSf267YV8smozblMR63Jyy8Wny5r0Iuo0Wa8+ypN6uWsuhDU6uRJJccR1uGXtWqLcU8C6sg8wnF5sNhunZc5CKRmeiugy6KTjGr+O+g74MuYIivzWbCFnjJMex3XD9Gn2fF+Ez9txu9EeisfrY+57SzFR+LRi+oSTyEhNtDosIdqdy94Xm5EKQI1nBVqbFkckhIg2SqnGZnn7vTWUe6qtDimktDZZsW8B2vChnD6GpV1EmivL6rCEaHfJnZPo2T/Qy2frt9upra6zOCLR0UhSH4Sswb3Qfo3P66dwe2RNh3vnqzx27SvH7VcM6p3JpNOGWB2SEJZQSjU+rfeb+3F7N1sckXVkKpwQ1slJ7NrYLG9nhD2t31r5b/a5t2DEeEhxdmd4p8usDkkIyww6KTAF3+/zs3H5FoujsY6MOYIjSX0QsnN7YfoD/2ryN0VOXX3BvnLe/ioPr1YYho3Zl43DZsg/ERG94pwHTcH3RPEUfJkKJ4RlchIz0AboCJuCX+Mr49vSNzCcPpTd5LTMmdgNp9VhCWGZg+vqo3oKvow5giIZWxCyB/cEDdrUEdMB3zQ1c/+xBI/PxGMqLv3p8RzbPd3qsISwVNO6+uUWRmI9uWMuhDVyGprlKc2O6siZHbiq5K/4dA3K6aVf0niOiRtmdUhCWCr34KT+qyhO6pExRzAkqQ9Ckw74EfKkfvG3m1m/owi3qejeOYWpPx9tdUhCWC7WOQilYoFAUq91lH9iCCHaXXZCFwwUphE50+8Lqlezs3oFKsZLrCOZE7v8xuqQhLBcRq900nt0AmDj8i14PZHVt0u0LUnqg5DeozPxyXGYPk1BBCT1ZVU1vPTRSnz1a9LfPvkMYp0Oq8MSwnJKOYhzDgfA5y/E68+3OCKLaN26TQgRtBibkx7xnTAVFNSU4DP9VofUKh6zlpUlr6DsfgyHn7FdriPGlmx1WEKEhYa6eneth62rt1kcjUVkzBEUSeqDoJQiu75ZXmlhOdX7O3Y32gX/+oaqWi9uU3H2qH6MHtDL6pCECBvxsl69NK0RwmI5iZmYCjymn8LacqvDaZW8srep9pdgxHjpETeCvonjrA5JiLCRe3L/xq/zvo7OKfgy5giOJPVBysrtiekL/MvJ37zH4miCt2pzAV/l/YDHVCTHxzJr0qlWhyREWJG6eixpWvPMM8/Qu3dvYmJiGDVqFCtWHP6Gyrp165g4cSK9e/dGKcUTTzzR6msKEU5yEgLL2gEduq6+uO4HNu3/BMPlxWFzckrGDJRSVoclRNg4uK5+bbQ2y7NgzBEJJKkPUvbgXmgz8C+nozbLq/N4+fMHS/HrwJr0MyedQmpinNVhCRFW4pzHowiUo9RE65N6s3VbS73xxhvMnDmTu+66i9WrVzNkyBDOPPNM9u7de8jja2pqyM7O5sEHHyQzMzMk1xQinOQkZoJqaJbXMevq/drHiuIXwOZDOXyM7HQFyc5uVoclRFjp2f8YkjolArDu642YZhAfoh1ce485IoUk9UGKhGZ5r322hr1lVbhNxcjjevDz0QOsDkmIsGMYscQ4cwFw+77H5++YA+qO5PHHH2fq1KlMmTKFAQMGMG/ePOLi4liwYMEhjx85ciSPPPIIF110ES6XKyTXFCKcNHbA78DN8jbt/4gyz06MGC+dY7IZnDbJ6pCECDtKKQaedBwAlWXV7FjfMR8civYnSX2Qeg8KJPWmT5O/qeNNv/9+dzHvL1mHxzRw2O3cMfkMmQInxGE0nYIfhU/rQzAVrqKiosnmdrsP+VIej4dVq1YxbtyBOlvDMBg3bhxLly4NKvy2uKYQ7alrbArxNldgrfqajpfUV3n2klf2TmBNepvmtIybsSm71WEJEZaaTsHfYGEkFpHp90GRpD5IcYmxdM3OwPSb7Nqyu0NNj/H5Teb+Ywk+DV4NU88ZTc+MVKvDEiJsRXuzvFA0renRowfJycmN2wMPPHDI1youLsbv95ORkdFkf0ZGBoWFhUHF3xbXFKI9GcqgT2IGpoJ9dRVUew99Uywcaa1ZUfISfuVGubzkppxPRmz/o58oRJRq6IAPsDYKm+VJo7zgyG3SVsge3JOinXtx13jYV1BCRs90q0Nqln8u38D3u0tw+w36dOvM5T8bbnVIQoS1OOeIxq+jsq6+NcvE1J+Xn59PUlJS4+7DTZMXQhxaTmIma0t3ApBfU0y/5GMsjqh5tlcvZU9tHrY4DwmOdEalX2V1SEKEtZxhvXHFuXDXuMn7z0a01tE1mzYEY45oJE/qWyErtxemv6FZXseoqy8qq+LVT1fj1QqtFLMvHYfDbrM6LCHCmt2WissRqHGr9a7Fb1ZZHFHHk5SU1GQ7XFLfuXNnbDYbRUVFTfYXFRUdtgne0bTFNYVobw3L2mkF2ztIB3y3v4rVJQtRDj/KbnJKxo04DWnIK8SR2B12BozuC0BxQSlFOzrGz7uwliT1rZCV27OxfqMjNMvTWvPcP5dR5/XjMRUXnDKEIX2k86wQzRHvbJiCb1LjWWVpLO2tPafCOZ1Ohg8fzuLFixv3mabJ4sWLGTNmTFDxt8U1hWhvDR3wdQfqgL+69DXcZgWGy0t2wilkJZxkdUhCdAiDonhpO5l+HxxJ6lshe3AvAEyf2SGe1H+9dhurNuXjNhWdkxOYfr58uArRXFHdLK+dm9bMnDmT+fPn8/LLL7NhwwauvfZaqqurmTJlCgCXX345t912W+PxHo+HNWvWsGbNGjweD7t27WLNmjVs3bq12dcUItzlJNR3wFewswM8qS+q3cAPlV+iXB5c9jhOzrje6pCE6DAOTurzoiypl0Z5wZGa+lbo2icDV6wTv99PfpivVV9V4+b5f63ArxV+rbjlotNJjJWaViGa6+Ckvsa9zMJI2l9r7n4Hc96FF17Ivn37mDNnDoWFhQwdOpRFixY1NrrbuXMnhnHgnvTu3bsZNmxY4/8/+uijPProo5x66ql8/vnnzbqmEOEuwRFD15gUin3l7KwuCes6W5/pYUXxiyibieH0M7rzVOLtna0OS4gOo/+ovtjsNvw+f9Ql9e095ogUktS3gs1mo/egHmz97zb27iyhrsZNTFx4JsqvfLKK8qo63KbitCF9+MmwHKtDEqJDcdi74bD1wOvPp8a9BlO7MVR4/rxHgunTpzN9+vRDfq8hUW/Qu3dvdDOa4xzpmkJ0BDmJmeytLqfW72FvXQUZsclWh3RI6/e/R4VvD7Y4D5kxAxmY8gurQxKiQ4mJc9H3+Cw2rthKwabdlO3dT2qX8Px5F+FBpt+3UkOzPK01u7eG53r167YX8vHKTbhNRazLye8uOj1s7+4LEc4antZr3NR6vrM4mnbU0Ik22E0IERJ9EjMx60duO8N0vfpyTwHryj7AcHqx2QxOzZyFUjLcFKKlDp6Cv+7rTRZG0s5kzBEU+S3bSlm5PdH1HfDzN4ZfUu/x+pj73lJMFD6tmD7hJDLTEq0OS4gOqWld/XILI2lf0rRGiPDQNzETXd8sb3v1XqvD+RGtTVYUL0AbPpTTx7C0i+nkyrI6LCE6pNwmdfUbLIykfcmYIzgy/b6VGprlab+mIAzr6v/+n7Xs2leO228wqHcmk04bYnVIQnRY8a7RjV9H1Xr1rWk+E8UfsEKEWk7iwc3ywu9J/dbKf7Ovbgu2OA8pzu4M73SZ1SEJ0WENPOngDvjR9KQeGXMEQZ7Ut1JWbk8ATL8mf3N4dcAv2FfOW19+h1crDMPG7MvGYTPkr1yIYDnt2diNQLOnavdKtPZbHJEQIpr0iOuE07BjGuGX1Nf4yvi29A0Mpw9lNzktcyZ2w2l1WEJ0WElpCfQe2AOA79dso6ay1uKIRDiTDK+Vkjsn0albKtoXSOqb06ypPZim5tn3luDxmXhMxaU/PZ5ju6dbHZYQHZpSijjXSABMXUGdNzrunMtUOCHCg92wkZ3QBVPB7poy3H6v1SE1WlXyV3y6BuX00i9pPMfEDTv6SUKII2qoqzdNzfplmy2Opn3ImCM4ktSHQPbgQLO86vIayveWWx0OAJ99u4V124twm4runVOY+vPRRz9JCHFU8a5RjV9HTV29qVu3CSFCpk9CoFmeBgpqSq0OB4CC6tXsrF6BivES60jmxC6/sTokISLCwXX1a6NlaTsZcwRFkvoQyBrUE+03gfBolldWVcOLH32Dr35N+tsnn0Gs02F1WEJEhKbr1UdJXb1u5SaECJmcxEzM+gVsdlTvszYYwGPWsrLkFZTdj+HwM7bLdcTYkq0OS4iIMCgak3oZcwRFkvoQyBrcC20CGvI3WV9Xv+Bf31BV68VtKs4e1Y/RA3pZHZIQESPGMQBDxQNQ7V4RNiU3Qojo0DcxExSYSrMjDOrq88reptpfghHjpUfcCPomjrM6JCEiRnr3TmT0DpTPblyxFY87fEpuRHiRpD4EGjrgm35NwWZrO+Cv2lzAV3k/4DEVyfGxzJp0qqXxCBFplLIT5xoBgM8swuPfYXFEbU/Rivo2q4MXIsI0dsA3YKfFT+qL635g0/5PMFxeHDYnp2TMQCn5qRcilHLru+B76rxsWfWDxdG0vXAdc5SWljJ58mSSkpJISUnhqquuoqqq6ojnPPfcc5x22mkkJSWhlKK8vDwk1z0USepDoEe/btjsNrTfpGCzddPv6zxe/vzBUvw6sCb9zEmnkJoYZ1k8QkSqeGeUTcHXunWbECJk0lwJpDkTMBVsr95n2Wwhv/axovgFsPlQDh8jO11BsrObJbEIEcmaTMH/Ogqm4IfpmGPy5MmsW7eOTz75hA8++IAvv/ySa6655ojn1NTUMH78eG6//faQXvdQJKkPAYfTQc/+x2D6NLu/L8LrsWZqzGufrWFvWRVuUzHyuB78fPQAS+IQItLFHVRXHw3N8qQTrRDhJScx0Cyv0ltHubfGkhg27f+IMs9OjBgvnWOyGZw2yZI4hIh00VZXH45jjg0bNrBo0SKef/55Ro0axdixY/nTn/7E66+/zu7dhy+9vummm7j11lsZPfrQDcuDve6hSFIfIlm5PdF+jd/np/CHve3++t/vLub9JevwmAYOu507Jp8hU+CEaCNxzqEoAs0n95YuYc2aNSxfvpw1a9YENWUq7EnTGiHCitXN8qo8e8kreyewJr1Nc1rGzdiUvd3jECIa9DiuG8npSQCs/XoT+/dXRPa4IwRjjoqKiiab2+1uVUhLly4lJSWFESNGNO4bN24chmGwfHnwD3dCeV1J6kMkK7cXpi/wL6m9m+X5/CZz/7EEnwavhqnnjKZnRmq7xiBENNm4cRuP/F4x4ScljDh2GcOGDWP06NEMGzaMpKQk+vfvzw033MD69eutDlUIEYFyEjPRBmhFuzfL01qzouQl/MqNcnnJTTmfjNj+7RqDENFEKUWX3GQ2+lfzWcW7pKamyLjjKHr06EFycnLj9sADD7TqeoWFhXTp0qXJPrvdTlpaGoWFhWFxXbmtGiINzfK0qSnYtAsY2W6v/c/lG/h+dwluv0Gfbp25/GfD2+21hYgm27ZtY9q0aSxatIguXTozceIURt4+kgEDBhAXF0dNTQ3r16/nm2++4Y033uBPf/oT48ePZ+7cuWRlZVkdftCU1qgg69SCPU8IcXh9G5rlKc3OqvZ9Ur+9eil7avOwxXlIcKQzKv2qdn19IaJJ47jj40V0SuvM5AsvYuTIyB53hGLMkZ+fT1JSUuN+l8t1yONvvfVWHnrooSNec8OGDUHF0t4kqQ+R7ME9AdB+TcGW9muWV1RWxWuLv8WrFVopZl86Dofd1m6vL0S0eP7557npppvo3LkzCxcu5IILLsDpdP7ouFGjRjFlyhSeeOIJ3nrrLW677TZyc3N54oknuPrqqy2IPATM+i3Yc4UQIdU7Ph2bMjANs12f1Lv9VawuWYhy+FF2k1MybsRpSENeIdpC1I47QjDmSEpKapLUH86sWbO48sorj3hMdnY2mZmZ7N3btLza5/NRWlpKZmZmkMES0uvK9PsQ6dQtjcS0BEyfbrfp91prnvvnMmo9Pjym4oJThjCkj3SeFSLU7r//fqZOncrFF19MXl4el1xyySE/WA/mdDq55JJLWLt2LRdffDFTp07l/vvvb6eIQ6vhrnmwmxAitFw2Bz3jOmEqKKgpwWf62+V1V5e+htuswHB5yU44hayEk9rldYWINtE87mjPMUd6ejr9+vU74uZ0OhkzZgzl5eWsWrWq8dzPPvsM0zQZNWpU0O81lNeVpD5ElFKNzfLKivZTWdb2TSu+XruNVZvycZuKzskJTD9fPlyFCLXnn3+e2bNnc++99zJ//nwSExNbdH5iYiLz58/nnnvuYfbs2bzwwgttFKkQIpo0dMD3aZPdtWVt/npFtRv4ofJLlMuDyx7HyRnXt/lrChGNZNwRfvr378/48eOZOnUqK1as4Ouvv2b69OlcdNFFdOsWeKC6a9cu+vXrx4oVB5Y6LiwsZM2aNWzduhWAvLw81qxZQ2lpabOv21yS1IdQ9kHN8gra+Gl9VY2b5/+1Ar9W+LXilotOJzH20PUiQojgbNu2jZtuuomrr76a2bNnN/ne559/jlLqkNuyZct+dK3Zs2dz9dVXc+ONN7Jt27b2eguhId3vhQg7OYldD3TAr2rbKfg+08OK4hdRNhPD6Wd056nE2zu36WsKEY1k3EHYjjkWLlxIv379OOOMMzj77LMZO3Yszz33XOP3vV4vmzZtoqbmwDKj8+bNY9iwYUydOhWAU045hWHDhvHee+81+7rNJTX1IZQ1uBfaPNABv//oY9vstV75ZBXlVXW4TcVpQ/rwk2E5bfZaQkSradOm0blzZx5//PHDHnPDDTcwcmTTxpg5OT/+eVRK8dhjj/Hxxx8zbdo0Pvzww5DH22a0DmzBniuECLmcxExQ9c3yavYB/Y56TrDW73+PCt8ebHEeMmMGMjDlF232WkJEMxl3ELZjjrS0NF599dXDfr93797o/3n9u+++m7vvvrtV120uSepDqEmzvM1t96R+3fZCPl65CbdpEOty8ruLTpc16YUIsfXr17No0SIWLlx4xKlvJ598MhdccEGzrpmUlMQDDzzA5MmT2bBhA/37d4xloJQObMGeK4QIvcYO+EbbLmtX7ilgXdkHGC4vNpvBqZmzUEomegoRajLuCJAxR3Dkt3II9RrYA6UUpq/tknqP18ez7y/FROHTiukTTiIzrWW1NkKIo5s3bx5dunRp1gdnZWUlPp+vWdedOHEiXbp04dlnn21tiEKIKJYRk0yCPQZTwY7qtlnWTmuTFcUL0IYP5fQxLO1iOrk65jJZQoQ7GXeI1pCkPoRi42Po2icD029SsHkPfn/ou9H+/T9rKdhbjtuvGNQ7k0mnDQn5awgh4JNPPmHixIlH7TY7ZcoUkpKSiImJ4fTTT2flypVHPN7lcjFx4kQ+/fTTUIbbthqmwgW7CSFCTilFn8QMTANK3FVUeetC/hpbK//NvrotGDEeUpzdGd7pspC/hhAiQMYd9WTMERRJ6kMse3AvtE/jqfOyb2dop8MV7CvnrS+/w6sVyjCYfdk4bIb8FQoRapWVlWzatOlHNWsHczqdTJw4kSeffJJ//OMf3HfffeTl5XHyySfz7bffHvH6I0aMYOPGjVRVtf0qGaGgzNZtQoi20TcxE93QLC/EU/BrfGV8W/oGhtOHspucmjEDu3HkZEMIERwZdxwgY47gSEYYYtm5vTD9B5rlhYppap59bwken4nHVFz20+Ec2z09ZNcXQhzw/fffo7VmwIABhz3mxBNP5K233uL//u//OPfcc7n11ltZtmwZSiluu+22I15/4MCBaK0blzgJe3LXXIiwlJOQialAt8EU/FUlf8Wna1BOL/2SxtM9/viQXl8IccCWLVtk3NFAxhxBkUZ5IZY1uGfjkgoFm/cwcvywkFz3s2+3sG57EW7ToHvnFKb+fHRIritENNLaBLMY/HvALAR/Ifqgr2v3bAIgLi6uRdfNycnhvPPO45133sHv92Oz2Q55XGxsLABut7t1b0QIEdVyEruCAq00+SF8Ul9QvZqd1SswYr3EOpI5sctvQnZtIaKNaZrs31fBvoIS9uXXbwUl7CsopriglH35xWzN3wLIuEMET5L6EMse3AsA02dSsGlXSK5ZVlXDix99g69+TfrbJ59BrNMRkmsLEWkCCXtJfYK+J5CwH/Q1/kIwi4DDN5hxOQIfegevNdpcPXr0wOP5//buPLip+9wb+PdItuRF8ibJlsEGTJxim70hcUh5Awm0cdrJvNyYjtM4t4WLnQTehmJ4SwK4SRvWTqYMIanrgCe5zVy2FmbyprmBsqTc3HvxBUzSlthACmGxwZvkRV4lyzrvH1os2UbY50hev58ZDY58dM5PmZDzPOf5/Z6fDW1tbYiKiur3mI6ODud11OpBn39YyNn7dfw+NCcKuge0CQAAhwDcDFClvsvRiTLzhxBCuqEI7cZ3DP8HYcrogJybaKwRRRHNJktPol5pRn2lCaY7DairdCbtpiozumz+m9q5C8yMO8CYQyIm9QFmTIlHWKQa9m47Kq9WB+ScH3x6Aa0dXbA6BHw/Mw2PZkwOyHmJRhtRFAFHA+BwJ+jVroS9xqvqXgugS9Z1Uh+IhyBUoqKiApmZmYP67DfffIOwsDBoNJp7HlNeXg5BEPrdV3YkEkQRgsQpbVI/R0T3FxmixoTwWNTZG3G73QyH6IBC5nZzf288irZuM5SRXUiKmIdvRS0J0GiJRhdRFGExt/itsNdXNaDLKi/m0MZpkDwhEee/Os24A4w5pGJSH2AKhQJTZkzCP768jrpKEzraOhEeGSb5fBe/rsLnl76BzaFAdGQ41v9wYQBHSzRyiKIIiI09CbpPwl7Tk8jLTNghxADKROdLYYSgNHp+dr6fgChBjWnT0nHhwgWsWLGi39PU19fDYPDta/G3v/0NH3/8MZ5++mko/DSxLCsrQ1pamt8b8IgiZ53aOL7BEg2FVK0Rta2NsHZ3oa6zGcbwWMnnMnV+g6vNJ6AI60KoUoWFCQUQBCGAoyUaGURRREtjK+orzTBVmVHnVWF3J+umKjOsHTZZ19HGRkKfpIMhWQdDkh4G98/JOhiSdNAn6RAW4ayel6afZNwBMOaQiEl9EEydOQlXy5yNKO58fRepc6dKOk+nrQvvfVKKbtG5J33BsscRqx3cWhuikcCZsDe5kvVawFHtXMPeXeNZx+5M2GWu9RJiAKXR+VIkuhJ258/u9wVhYA/Zvvvd7+Lw4cPYvXt3v9vL5OTkIDw8HI899hji4+NRUVGBvXv3IiIiAjt37rznea1WK44ePYqcnByp35KIyONBrRH/WXsZAHCzzSQ5qXeI3Thveh9Q2iGE2jFP9y+IVk0I5FCJhoQoimhtavMk6yZXpb3Oq8JuqmpAZ7u8mCMyOsKVoOthmBgHQ7Ie+iQd4l1Ju35iHMI14QM+H+MOkoNJfRCkzJoM0dUBv+rraslJ/cHP/oq6xlZYHQrMm5aMZ+bfuyMm0XBxJuzNPlPgRZ/p8O6EXeYeykKUq5JudFXY3dV1d6U9AYIicA+9Xn75Zbzzzjs4cuQInn/++T6/X7p0Kfbv349du3bBYrHAYDDg2WefxRtvvOF3etvRo0dRV1eHVatWBWysQScCkLpNzPh9aE40JFJd29qJgojbbSY8qn9Q0nmuNP8ZjbZbUEZ2QR82FbPjfhjgkRIFRltzm2+y7krS66ucFfb6ShM62+Ql7BFR4T1V9V4Vdn2Ss8oeoR14wj4QjDtcGHNIwqQ+CNzN8sRuEZUSm+Vdv2vCn86Ww+ZQIDQkBIW5izkFjoacM2Fv8UrQq50Ju3fjOUcNIHbIu5Cg9STrULoq7F7VdSiMEBSRgflSA5SRkYGsrCxs2rQJzzzzDLRarc/v16xZgzVr1gzqnBaLBRs3bkRWVhbS09MDOdyg4vo2opErVZsIwNks77bEZnmttjpcajzq3JNeKWJRwv+FUmCISEOvzdLep8JeX2lC/Z2eCnt7i7yYI1wT1m+F3ZDsrLLrk3SIjBr6mbGMO5wYc0jD/2MHQcrMSQAAR7eIKgnN8uzdDhT9v7Owi0CXCKz+QSYmJUhfI0d0L6KjxWu9unfC7lVpFwffidWHEOmqpDvXqws+69fdCfvIXONVVFSEmTNnYt26ddi3b5+sc4miiPXr18NsNqOoqChAIxwiImSsbwvoSIiol6SIOKgVoXAounBTwrZ2oijivPlf0S1YoVB3YWbMPyEhfHQE/zS6dLR29ErWfRvP1VWa0G6Rl7CHRai91qzroU+KQ3yvpD0iKmLEFsoYd4Axh0RM6oNAG6uBIUmHRlMTKq/ehSiKg/qfx6fnLuP6XTOs3Qo8MEGPn3xvXhBHS2OV6Gj1SdBFn+nw7oS9Td5FhAivBN01Bd6TrDvfG6kJ+0CkpKRg9+7dyM/Px+TJk1FYWCjpPKIoYuvWrSgpKUFJSQlSUlICPNIgY9MaohFLKSgwVROPf9juoLajCZ12G8JC+q7HvZdbbf+D6o5LUEbYoAk1INOQF8TR0ljV0dbpNR3enbj3VNjrK81oa5ZXJFCHq3qmvyfrEJ+k92pC5/xTExM5YhP2gWDcAcYcEjGpD5KUWZNgPumcItRQ3QjdhLgBfa62sRUHTn+JLlGAKAgofGEJQkOUQR4tjTaio61Pgu7beK4aEFvlXUQI77VmPRGCMsGr6m4EBO2ovnkORF5eHmpra1FYWIhbt25h165dfabE+WOxWLB+/XqUlJRg27ZtWLlyZRBHS0TjUarWiKtNdyACqGw348GoxAF9ztrdiovmf4MQ2g0hxIHHE34GVQB7k9DY0NludSbpfrZ2a2mUVyRQhYV6NZnTQ++aFu+9ll0bqxnzMQfAuIOkYVIfJFNnTsb5Y18CAKq+vjugpF4URez99/9Bh80Om0PADxfOwuwH2Hl2vBHFjp716q6p8X0az4kWmVdRe01/d/4puCrtnqq7EDUubp4DsXnzZiQkJGDt2rU4ceIEduzYgWXLlvXbndbN3W1248aNMJvNKCkpGb03VgcAqf8pSG12Q0QD9qDWCIfr7+itdtOAk/ovGg7C6rBAEd6FqZr/hRTNd4I4ShqJrB1W1zZu3km7c2u3OleFvaVBXpEgVB0KQ1Jc/1u7uf6M0o39IsFgjOu4gzGHJEzqgyRl1mTXmhCg8mo1Zi+acd/PnC2/iYtXK2F1KKCP1uCn/7Qg+AOlISWKnV7Vdef2bqJXEzpnwt4s8yoqn/Xqvo3nXEm7EMOb5yDl5eVh8eLFWL16NXJzc1FQUIDs7GzMmzcP06dPR3h4ODo6OlBeXo6ysjJPt9msrCwUFRWNrqlvvbBpDdHIlqo1AgLgUIgDbpZX23EZ37R8DkWYDeqQCCyIfyXIo6ShZrN23bfC3mxqkXWNkFCl7xT4JF2fCnu0nkUCKcZr3MGYQxom9UHi7oDvGGAH/NZ2K/b9+zl0iwK6RQGvPvcEtOHqYA+TAkgUrT7Vdec69lrPz86EvUnmVUL77rveu/GcEMubZ5CkpKTg2LFjqKioQHFxMU6dOoXi4mLnLgEugiAgLS0NOTk5WLVq1ajpNusX17cRjWipWiMAZwf8WwNolmd32HDe9AEEpQMKVTce1edDE2oI9jApgGzWLpjvOivs7m7x7gq7ew17U728WX0hoUroJ/ZfYXdPlY82REGhUAToW1Fv4zLuYMwhCZP6IEn6ViJCQpUQ7Q5UXb173+M/PHkRTa2dsDoELJw9FU/Ovfd+kzT0RNHmu169uwaiq9Lu/OdqQGyUeZVQZyXdK0EXfLrEJwKKOCbsI0BGRgb27NkDAGhtbcW1a9dgtVqhVquRmpoKjWb0NgckotEnRhUJvVqL5q4W3Gqrv2+D3ormj2GxV0MZYUNC2HRMj3lmCEdL92PvssN0p8ErWXc1nvPah72xVt6sPoVS4Vq37lthdyfr+iQdYhOimbCPEIw76H6Y1AdJSGgIJmUk4daVSlTfqIPN1gWVKrTfYytu1eJE2VVYHQqEq1V49bknmbgNIWfCXuvbKd6TvLsq7Q6zzKuEuNar9zSeE3ya0BkBhQ6CwJvnaKPRaDBnzpzhHkZw8ak50YiXqjXiQnsLWm1WNNhaoVP331iryVaF8sZPoFB3QalUYJFxPe89Q8jeZUdDdaPP1m51vSrsjbXNPpXYwVIoFdBNiO2pqk/UIT5Z79M5PjYhGkolGzGPRmM+7mDMIQmT+iCaOmsybnx1Gza7FWeO/wd0E2OhUqmQkpLieaJm67Kj6OOzcECAXRSwbul3YIwbeIdL8k8UuwBHXc/0d+8u8e617I7B7+vrS+mbsCuMXtu6uZN2PYMmGr14gyUa8VK1Rpyr+wfsHTZ8duG/MTXc0CfmEEUHzpveh6iwQ6GyY27cC9CpR+e625Go294Nc3Vj363dvCvsNU1wOGQk7AoBcYmxPVPgk9yJut5TdY8zxkDJnZNotGLMIQmT+iCpqKjAmet/xjnhv9HS0Izj//JHz+8EQUBqaioWLVqEhPRHUVXXBGu3AjOmGPHDRbOHcdSjiyjaXQm797ZuvbrEO+rh7FgolQJQxPs0nvPdhz0BUBggCLx50hjGTrREI1pFRQVO/+ZDVJz6DK2V9fivXutt3THHE8vSUB/7DygjbIhRTcRDuheGcdSjS3d3Nxprmnwq7L33YW+obpSVsAuCgLjEGJ8KuyFZ75kOb0jWQZcYy4SdxjbGHJIwqQ+wGzduYPXq1Th+/DgMhnjk5v0IDz/8MDIyMhAREYH29nZUVFTgwoULzi6V+/YhdlIakhYsQ+EL/wwl1y4BcCfspp716p6EvacJnbPCLudvrwJQGHpt6+Y1Hd5TYedfEyIiGnm8Y474+Hj8c3a235hj3759yPiOATm/mor//eg6hCjYkBdwJey1zV7Jek+XeHeF3Xy3EY5u6TGHIAiITYjumQLv3SneVWHXTYhFSChjDiIaPEGUs2iHfJSUlGDt2rXQ6/XYvn37ffeTtNlsOHLkCDa8+irMZjPe2bMHeXl5Qzji4SGK3c4KuldneNHThM5daa8H0C3jKoJXwu69rZt34zkDBKH/PgdEBFgsFkRHR2PJt9YhRCkt+Ld3W3Hq611obm5GVFRUgEdINH5JjTle3bgBZrMJe3a/Oy5iDofDgaa65j77sHtX2M13G9FtlxNzADHxzoQ93qvC7r0Pu25CLELv0VuJiBhzyMXHgQGybds2FBYWIi8vD7t27YJWe/918SqVCs8//zyeeeYZFBQUID8/H7W1tdi8efMQjDg4RNHRU2F3Jemi93T47mrnlHlZCTsAhd63S7ynuu6usBsgCPcObohoELi+jWhEYczh5HA40Fxv8bsPu+lOA+xdMhN2Q1T/e7G7K+wT46BSM2EnCgjGHJIwqQ+AkpISFBYWYsuWLSgsLPT5XWtrK9566y2cO3cO58+fR2NjIz744AMsX77cc4xWq0VJSQkmT56MwsJCGI1GrFy5coi/xf05E3Zzr23den52To2vBWCXdyGFrme9uqdLvHfjuQQm7ERDySECgsQbpYz1pUTU1/iJOUQ0myx9KuymOw3ObvFVzi3fumzyYo4ondaZnCfrYJjo3tYtrqdb/MQ4qMIYcxANGcYckjCpl+nGjRtYu3Yt8vLy+txcAcBkMuHNN9/EpEmTMHv2bJw5c+ae5yosLMTt27fxs5/9DE8++SRSUoauI60oioCjoWe9uidh9248VwugS96FhFhXgu5M2gVFYj8JO9f4ERER9TaWYg6LucVvhb2+qgFdVnkxhzZO45n+bnB1iffZ2i0pDupwxhxENPoxqZdp9erV0Ov12LVrV7+/T0xMRHV1NYxGI8rKyvDwww/f81yCIOA3v/kNTpw4gdWrV+PYsWMBGaMoioDY2JOge/Zh9248VwP5CXuM1/T3RAiuSru7CR2URibsRKMRp8IRjQijJeZoaWxFvatLfJ1Xhd2drJuqzLB22GRdRxMT2W+F3d0tXjcxDuGRYQH5TkQ0hBhzSMKkXoaKigocP34c+/fvv+d6NrVaDaPROOBzRkVFYceOHcjNzcXly5eRnp7u93hnwt7U/z7s3lPjIe/mCSHaK2F3b+uW4ErYXVV3IVzeNYhohJJxg5W1pSQRuY2UmKO1qc0rWXcl7t5r2Ksa0NluHdR36y0yOqJPhd2QrIfBlbQbkuIQrmHMQTQ2MeaQgkm9DMXFxYiPj8eyZcsCet7s7GwUFBSgqKgIe97e4n8f9u4aAJ3yLihE9dMlvmdNOxRGCIqIgHw3IhqF+NScaNgNRcyxc+tOn33Y3WvX66tMninynW3yEvYIbbjPtm7xXhV2dxIfoWXCTjRuMeaQhEm9DCdPnkR2drbfLWSkUKvVyM7OxukTH0Cs+7O8kwkar33XvbvE96xjFxSRgRk4ERERBUWwY45/23cAV35bI+tcYZFqT3Ie31+FPVmHyCgWCYiIAo1JvUQtLS24evUqNmzYEJTzz5s3D8XFv0NrmwOaSEX/BwmRfRN098+eCrsmKOMjonHEIULylLZx3ImWKFCGIub43e+KYYcdIUL/oWFYhLqnwt57azdX0h4ZHQFBEIIyRiIaJxhzSMKkXqLr169DFEVkZGQE5fzTp0+HKALXqjIwZ850V8Ju9Kq6J0JQ3H9fWiIi2USH8yX1s0Qky1DEHICISY8kYHr6jD7JuiFZB01MJBN2Igo+xhySMKmXyGp1rimLiAjONLLwcOd6sq6wzVBEZwblGkREA8L1bUTDaqhijtV7ViAzkzEHEQ0jxhySMKmXSK12bs3W3t4elPN3dHT4XIeIaNhwKhzRsGLMQUTjBmMOSe6xWJvuJzU1FYIgoKKiIijnLy8vhyAISE1NDcr5iYiIaHRgzEFERP6wUi+RRqPBtGnTcOHCBaxYscLvse+++y6amppw9+5dAMCf/vQnVFVVAQBeeeUVREdH9/lMWVkZ0tLSoNGw0R0RDTNOhSMaVow5iGjcYMwhiSCK4/jby7RmzRocPnwYlZWVfreYmTJlCm7dutXv727cuIEpU6b4vGe1WjFp0iTk5ORgz549gRwyEdGAWSwWREdHY0niSwhRSNtGy+6w4VT1e2hubkZUVFSAR0g0fjDmIKKxjDGHPJx+L8PLL7+Muro6HDlyxO9xN2/ehCiK/b5631wB4OjRo6irq8OqVauCNHIiokFwPzWX+iIi2RhzENG4wJhDEib1MmRkZCArKwubNm1CS0tLQM5psViwceNGZGVlIT09PSDnJCIiotGNMQcR0fBpaGhAbm4uoqKiEBMTg5UrV6K1tdXvZ/bu3YtFixYhKioKgiCgqampzzFTpkyBIAg+r507dw56fEzqZSoqKoLJZMK6detkn0sURaxfvx5msxlFRUUBGB0RUQA4HPJeRBQQjDmIaMwboTFHbm4uysvLcfLkSXzyySf4/PPP8eKLL/r9THt7u+dhrD9vvvkmqqurPa9XXnll0ONjUi9TSkoKdu/ejZKSEmzdulXyeURRxNatW1FSUoK3334bKSkpARwlEZEMwzAV7re//S2mTJmCsLAwZGZm4vz5836P/+Mf/4i0tDSEhYVh5syZ+PTTT31+v3z58j5PwrOysiSNjWi4MOYgojEvADGHxWLxeVmtVllDunz5Mo4fP46SkhJkZmZiwYIFeOedd3Do0CFPU9L+rF27Fq+99hoeffRRv+fXarUwGo2eV2Rk5KDHyKQ+APLy8rB161b84he/QH5+/qCnxVksFrz44ot4/fXXsW3bNqxcuTJIIyUikmCIk/rDhw9j3bp1eOONN/DFF19g9uzZeOqpp1BXV9fv8WfPnsWPfvQjrFy5El9++SWWLl2KpUuX4quvvvI5Lisry+dJ+MGDByX96yAaTow5iGhMC0DMkZycjOjoaM9rx44dsoZUWlqKmJgYzJs3z/PekiVLoFAocO7cOVnnBoCdO3dCp9Nh7ty5eOutt2C32wd9Dib1AbJ582bs27cPBw8exIwZM3DgwAHYbDa/n7FarThw4ABmzpyJgwcPoqSk5L7TM4iIxrpdu3YhPz8fK1asQEZGBoqLixEREYH333+/3+PffvttZGVl4ec//znS09OxZcsWfPvb38a7777rc5xarfZ5Eh4bGzsUX4co4BhzEBHdW2VlJZqbmz2vjRs3yjpfTU0N4uPjfd4LCQlBXFwcampqZJ17zZo1OHToEP7yl7/gpZdewvbt27Fhw4ZBn4f71AdQXl4eFi9ejNWrVyM3NxcFBQXIzs7GvHnzMH36dISHh6OjowPl5eUoKyvzdJzNyspCUVERp78R0cjkEAFI7Cjr6JkK502tVkOtVvc53Gaz4eLFiz43YIVCgSVLlqC0tLTfS5SWlvZZY/zUU0/ho48+8nnvzJkziI+PR2xsLJ588kls3boVOp1OyrciGnaMOYhoTApAzBEVFTWgLe1ee+01/PrXv/Z7zOXLl6WNZYC845dZs2ZBpVLhpZdewo4dO/qNk+6FSX2ApaSk4NixY6ioqEBxcTFOnTqF4uJiiF5TUAVBQFpaGnJycrBq1Sp2nCWiEU0UHRBFac1n3J9LTk72ef+NN97AL3/5yz7Hm0wmdHd3IyEhwef9hIQEXLlypd9r1NTU9Hu899PzrKwsPPvss0hJScH169exadMmPP300ygtLYVSqZTy1YiGHWMOIhprAhFzDNT69euxfPlyv8dMnToVRqOxzxJAu92OhoYGGI3GwQ7Tr8zMTNjtdty8eRPTpk0b8OeY1AdJRkYG9uzZAwBobW3FtWvXYLVaoVarkZqaCo1GM8wjJCIaIFH0PP2W9Fk4p8J5PzUfzNPnQHjuuec8P8+cOROzZs3CAw88gDNnzmDx4sVDOhaiQGPMQURjRgBijoEyGAwwGAz3PW7+/PloamrCxYsX8dBDDwEAPvvsMzgcDmRmZkoa6r389a9/hUKh6DPd/36Y1A8BjUaDOXPmDPcwiIiGzUCnwun1eiiVStTW1vq8X1tbe8+n4UajcVDHA84n73q9HteuXWNST2MKYw4iosBKT09HVlYW8vPzUVxcjK6uLvz0pz/Fc889hwkTJgAA7ty5g8WLF+PDDz/EI488AsA5k7CmpgbXrl0DAFy6dAlarRaTJk1CXFwcSktLce7cOTzxxBPQarUoLS1FQUEBXnjhhUH3/WGjPCIi8m8Iu9+rVCo89NBDOH36tOc9h8OB06dPY/78+f1+Zv78+T7HA8DJkyfveTwAVFVVwWw2IzExcVDjIyIioiAahm10B2L//v1IS0vD4sWL8f3vfx8LFizA3r17Pb/v6urC1atX0d7e7nmvuLgYc+fORX5+PgDg8ccfx9y5c/Hxxx8DcM5aPHToEBYuXIjp06dj27ZtKCgo8DnvQAmiGMRvT0REo5bFYkF0dDQWa3MRIqgkncMu2nC6ZT+am5sHVKkHnFva/eQnP8F7772HRx55BLt378Yf/vAHXLlyBQkJCfjxj3+MiRMneraoOXv2LBYuXIidO3fiBz/4AQ4dOoTt27fjiy++wIwZM9Da2opf/epXyM7OhtFoxPXr17Fhwwa0tLTg0qVLQ74UgIiIiHwNV8wxVnD6PRER+SfK6EQr4blxTk4O6uvr8frrr6OmpgZz5szB8ePHPc3wbt++DYWiZ6LZY489hgMHDqCwsBCbNm3Cgw8+iI8++ggzZswAACiVSvz973/H73//ezQ1NWHChAn43ve+hy1btjChJyIiGkmGOOYYK1ipJyKifnmemmuel/fUvPXAuHxqTkRERAPDmEMeVuqJiMgv0eGAKAzN9jJEREQ0fjHmkIZJPRER+cepcERERDQUGHNIwqSeiIj8c4iAwBssERERBRljDkmY1BMRkX+iCEDilLZxfIMlIiKiQWLMIQn3qSciIiIiIiIapVipJyIiv0SHCFHiVDhusEJEREQDxZhDGib1RETkn+iA9Klw47cTLREREQ0SYw5JmNQTEZFffGpOREREQ4ExhzRcU09EREREREQ0SrFST0REftlFq+QpbXZ0BXg0RERENFYx5pCGST0REfVLpVLBaDTiv2o+lXUeo9EIlUoVoFERERHRWMOYQx5BHM+LD4iIyK/Ozk7YbDZZ51CpVAgLCwvQiIiIiGgsYswhHZN6IiIiIiIiolGKjfKIiIiIiIiIRikm9URERERERESjFJN6IiIiIiIiolGKST0RERERERHRKMWknoiIiIiIiGiUYlJPRERERERENEoxqSciIiIiIiIapf4/Q6H6xvvz17MAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -715,7 +706,7 @@ "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", "# shade the area of the triangle\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", @@ -725,7 +716,7 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", " vmin=values_32.min(), vmax=values_32.max(), \n", " **options)\n", "# add a label at the base edge \n", @@ -738,7 +729,7 @@ "\n", "\n", "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -747,7 +738,7 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", " vmin=values_inf.min(), vmax=values_inf.max(),\n", " **options)\n", "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", @@ -781,7 +772,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -836,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -864,27 +855,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "xs (shape = (3, 1)):\n", - "[[3]\n", - " [5]\n", - " [4]]\n", + "xs (shape = torch.Size([3, 1])):\n", + "tensor([[3],\n", + " [3],\n", + " [0]], dtype=torch.int32)\n", "\n", - "emedding (shape = (3, 6)):\n", - "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 -1.29344481e-01\n", - " 5.15670639e-02 1.39200889e-01]\n", - " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 -1.59503941e-16\n", - " -6.37403964e-02 7.76266537e-16]\n", - " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 7.99392856e-02\n", - " -8.34372621e-02 9.36873407e-17]]\n", + "emedding (shape = torch.Size([3, 6])):\n", + "tensor([[ 0.1403, -0.1369, 0.0665, -0.1392, 0.1293, 0.0516],\n", + " [ 0.1403, -0.1369, 0.0665, -0.1392, 0.1293, 0.0516],\n", + " [ 0.1403, 0.1369, 0.0665, -0.1392, -0.1293, 0.0516]])\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(1.7523e-08)\n" ] } ], @@ -924,7 +912,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -932,9 +920,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-0.12815855 0.03939647]\n", - " [-0.35448662 0.8352028 ]\n", - " [-0.08106564 -0.25947495]]\n" + "tensor([[ 0.0428, 0.2322],\n", + " [ 0.0428, 0.2322],\n", + " [-0.1651, -0.2720]])\n" ] } ], @@ -965,12 +953,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -997,7 +985,7 @@ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", "\n", "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", " vmin=vmin, vmax=vmax, **options)\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -1007,7 +995,7 @@ "\n", "\n", "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", " vmin=vmin, vmax=vmax, **options)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", diff --git a/notebooks/backends/PyTorch_Graph.ipynb b/notebooks/backends/PyTorch_Graph.ipynb index 1565d772..a863e868 100644 --- a/notebooks/backends/PyTorch_Graph.ipynb +++ b/notebooks/backends/PyTorch_Graph.ipynb @@ -88,7 +88,21 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# current path \n", + "import os \n", + "import sys\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n", + "# add the first parent path\n", + "sys.path.append(os.path.dirname(os.path.dirname(os.getcwd())))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -147,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "id": "PM1H-As8-KF7" }, @@ -165,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -181,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -194,7 +208,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -224,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -256,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -278,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -319,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -357,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -388,7 +402,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -405,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -464,7 +478,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -481,7 +495,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -500,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -509,6 +523,27 @@ "variance_inf = kernel.K_diag(params_inf, other_points)" ] }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.4853, 1.0858, 1.0858, 1.0858, 1.0858, 1.0858, 1.0858],\n", + " dtype=torch.float64)" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "variance_32" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -520,12 +555,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -617,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -668,7 +703,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -696,7 +731,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -753,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -794,12 +829,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edge.py index ef04e81b..1296283f 100644 --- a/tests/spaces/test_graph_edge.py +++ b/tests/spaces/test_graph_edge.py @@ -1,23 +1,14 @@ -# current path -import os -import sys -sys.path.append(os.path.dirname(os.getcwd())) -# add the first parent path -sys.path.append(os.path.dirname(os.path.dirname(os.getcwd()))) - import warnings import jax import lab as B import numpy as np import scipy.sparse as sp -# import tensorflow as tf import torch from geometric_kernels.jax import * # noqa from geometric_kernels.kernels import MaternKarhunenLoeveKernel from geometric_kernels.spaces.graph_edge import GraphEdge -# from geometric_kernels.tensorflow import * # noqa from geometric_kernels.torch import * # noqa warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") @@ -184,7 +175,6 @@ def test_graphs_torch_cuda(): B2 = torch.tensor(B2).cuda() m = B1.shape[1] sc = GraphEdge(B1,B2) - # normed_graph = Graph(adj, normalize_laplacian=True) # fails due to bug in lab K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) params = K_cons.init_params() From 8404385cc15ca465a3758f1edc451fd2e4593bf6 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Mon, 29 Jul 2024 14:11:09 +0200 Subject: [PATCH 04/30] Notebook renames --- notebooks/{EdgeSpaceGraph.ipynb => GraphEdges.ipynb} | 0 .../{EdgeSpaceSimplicialComplex.ipynb => SimplicialComplex.ipynb} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename notebooks/{EdgeSpaceGraph.ipynb => GraphEdges.ipynb} (100%) rename notebooks/{EdgeSpaceSimplicialComplex.ipynb => SimplicialComplex.ipynb} (100%) diff --git a/notebooks/EdgeSpaceGraph.ipynb b/notebooks/GraphEdges.ipynb similarity index 100% rename from notebooks/EdgeSpaceGraph.ipynb rename to notebooks/GraphEdges.ipynb diff --git a/notebooks/EdgeSpaceSimplicialComplex.ipynb b/notebooks/SimplicialComplex.ipynb similarity index 100% rename from notebooks/EdgeSpaceSimplicialComplex.ipynb rename to notebooks/SimplicialComplex.ipynb From 600601a2acdae1220ff3256b95a4ecdf82df0983 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 30 Jul 2024 21:39:51 +0200 Subject: [PATCH 05/30] Some refactoring --- geometric_kernels/spaces/graph_edge.py | 180 +++++++++++++------------ tests/spaces/test_graph_edge.py | 48 +++---- 2 files changed, 112 insertions(+), 116 deletions(-) diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index f84179cb..730d98ed 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -3,16 +3,11 @@ """ import lab as B -import numpy as np -from beartype.typing import Dict, Tuple +from beartype.typing import Dict, Tuple, Optional from geometric_kernels.lab_extras import ( - degree, dtype_integer, eigenpairs, - reciprocal_no_nan, - set_value, - take_along_axis, ) from geometric_kernels.spaces.base import DiscreteSpectrumSpace @@ -34,22 +29,22 @@ class GraphEdge(DiscreteSpectrumSpace): .. note:: A tutorial on how to use this space is available in the :doc:`EdgeSpaceGraph.ipynb ` notebook. - + :param incidence_matrix: An n x m dimensional matrix where n is the number of nodes and m is the number of edges. incidence_matrix[i, e] is -1 if node i is the start node of edge e, 1 if node i is the end node of edge e. - - Note that the -1s and 1s in the incidence matrix do not necessarily mean that the graph is directed. Instead, they are used to allow oriented computations along edges. - - :param edge_triangle_incidence_matrix: optional + + Note that the -1s and 1s in the incidence matrix do not necessarily mean that the graph is directed. Instead, they are used to allow oriented computations along edges. + + :param triangle_incidence_matrix: optional An m x t dimensional matrix where m is the number of edges and t is the number of triangles. - edge_triangle_incidence_matrix[e, t] is -1 if edge e is anti-aligned with triangle t, 1 if edge e is aligned with triangle t, 0 otherwise. - - :param edge_laplacian: - An m x m dimensional matrix where m is the number of edges. - edge_laplcian is computed as - incidence_matrix.T @ incidence_matrix, if edge_triangle_incidence_matrix is None - incidence_matrix.T @ incidence_matrix + edge_triangle_incidence_matrix @ edge_triangle_incidence_matrix.T, if edge_triangle_incidence_matrix is not None + triangle_incidence_matrix[e, t] is -1 if edge e is anti-aligned with triangle t, 1 if edge e is aligned with triangle t, 0 otherwise. + + .. note: + The Laplacian is an m x m dimensional matrix where m is the number of + edges which is computed as + incidence_matrix.T @ incidence_matrix, if triangle_incidence_matrix is None + incidence_matrix.T @ incidence_matrix + triangle_incidence_matrix @ triangle_incidence_matrix.T, if triangle_incidence_matrix is not None .. admonition:: Citation @@ -57,29 +52,51 @@ class GraphEdge(DiscreteSpectrumSpace): citing :cite:t:`yang2024`. """ - def __init__(self, incidence_matrix: B.Numeric, edge_triangle_incidence_matrix=None): # type: ignore + def __init__( + self, incidence_matrix: B.Int, triangle_incidence_matrix: Optional[B.Int] = None + ): self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - self.incidence_matrix = incidence_matrix - if edge_triangle_incidence_matrix is not None: - self.edge_triangle_incidence_matrix = edge_triangle_incidence_matrix + self._checks(incidence_matrix, triangle_incidence_matrix) + + self.num_vertices, self.num_edges = incidence_matrix.shape + if triangle_incidence_matrix is None: + self.num_triangles = 0 else: - self.edge_triangle_incidence_matrix = None + self.num_triangles = triangle_incidence_matrix.shape[1] - self._checks(incidence_matrix, self.edge_triangle_incidence_matrix) - self._set_laplacian(incidence_matrix) # type: ignore - + self._set_laplacian(incidence_matrix, triangle_incidence_matrix) @staticmethod - def _checks(incidence, edge_triangle_incidence_matrix=None): + def _checks(incidence_matrix, triangle_incidence_matrix): """ - Checks if 'incidence' has dimension n x m and if each column has two non-zero entries. + Checks if `incidence_matrix` and `triangle_incidence_matrix` are of + appropriate structure. """ - nnz = np.count_nonzero(incidence, axis=0) - assert np.all(nnz == 2), "Each column of the incidence matrix should have exactly two non-zero entries." - if edge_triangle_incidence_matrix is not None: - nnz2 = np.count_nonzero(edge_triangle_incidence_matrix, axis=0) - assert np.all(nnz2 == 3), "Each column of the edge triangle incidence matrix should have exactly 3 non-zero entries." + assert B.rank(incidence_matrix) == 2, "Incidence matrix must be a 2-dim tensor." + + assert B.all( + B.sum(incidence_matrix == 1, axis=0) == 1 + ), "Each column of the incidence matrix must contain 1 exactly once." + assert B.all( + B.sum(incidence_matrix == -1, axis=0) == 1 + ), "Each column of the incidence matrix must contain -1 exactly once." + + if triangle_incidence_matrix is not None: + assert ( + B.rank(triangle_incidence_matrix) == 2 + ), "Triangle incidence matrix matrix must be a 2-dim tensor." + + num_edges = B.shape(incidence_matrix)[1] + assert B.shape(triangle_incidence_matrix)[0] == num_edges, ( + "The first dimension of the triangle incidence matrix must" + " be equal to the second dimension of the incidence matrix." + ) + + assert B.all(B.sum(triangle_incidence_matrix != 0, axis=0) == 3), ( + "Each column of the edge triangle incidence matrix must" + " have exactly 3 non-zero entries." + ) @property def dimension(self) -> int: @@ -89,52 +106,22 @@ def dimension(self) -> int: """ return 0 # this is needed for the kernel math to work out - @property - def num_vertices(self) -> int: - """ - Number of vertices in the graph. - """ - return self.incidence_matrix.shape[0] - - @property - def num_edges(self) -> int: - """ - Number of edges in the graph. - """ - return self.incidence_matrix.shape[1] - - @property - def num_triangles(self) -> int: - """ - Number of triangles in the graph. - """ - if self.edge_triangle_incidence_matrix is None: - return 0 - else: - return self.edge_triangle_incidence_matrix.shape[1] - - def _set_laplacian(self, incidence_matrix): + def _set_laplacian(self, incidence_matrix, triangle_incidence_matrix): """ Construct the appropriate graph Laplacian from the adjacency matrix. """ - if self.edge_triangle_incidence_matrix is None: - self._edge_laplacian = incidence_matrix.T @ incidence_matrix - else: - self._down_edge_laplacian = incidence_matrix.T @ incidence_matrix - self._up_edge_laplacian = self.edge_triangle_incidence_matrix @ self.edge_triangle_incidence_matrix.T - self._edge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian - - - @property - def edge_laplacian(self): - """ - Return the Edge Laplacian - """ - if self.edge_triangle_incidence_matrix is None: - return self._edge_laplacian + self._down_edge_laplacian = incidence_matrix.T @ incidence_matrix + + if triangle_incidence_matrix is None: + self._up_edge_laplacian = B.zeros( + B.dtype(self._down_edge_laplacian), *B.shape(self._down_edge_laplacian) + ) else: - return self._edge_laplacian, self._down_edge_laplacian, self._up_edge_laplacian - + self._up_edge_laplacian = B.matmul( + triangle_incidence_matrix, triangle_incidence_matrix, tr_b=True + ) + + self._edge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian def get_eigensystem(self, num, hgc_order=False): """ @@ -144,28 +131,43 @@ def get_eigensystem(self, num, hgc_order=False): :param num: Number of eigenpairs to return. Performs the computation at the first call. Afterwards, fetches the result from cache. - + :param hgc_order: If True, the eigenmodes are organized according to the Harmonic, Gradient and Curl eigenvalues from small to big. - + :return: - A tuple of eigenvectors [n, num], eigenvalues [num, 1]. + A tuple of eigenvectors [m, num], eigenvalues [num, 1]. """ eps = 1e-6 if num not in self.cache: evals, evecs = eigenpairs(self._edge_laplacian, num) - if self.edge_triangle_incidence_matrix is not None and hgc_order: + if self.num_triangles > 0 and hgc_order: # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian total_var = [] total_div = [] total_curl = [] num_eigemodes = len(evals) for i in range(num_eigemodes): - total_var.append(B.matmul(evecs[:, i].reshape(1,-1), B.matmul(self._edge_laplacian, evecs[:, i]))) - total_div.append(B.matmul(evecs[:, i].reshape(1,-1), B.matmul(self._down_edge_laplacian,evecs[:, i]))) - total_curl.append(B.matmul(evecs[:, i].reshape(1,-1), B.matmul(self._up_edge_laplacian,evecs[:, i]))) - + total_var.append( + B.matmul( + evecs[:, i].reshape(1, -1), + B.matmul(self._edge_laplacian, evecs[:, i]), + ) + ) + total_div.append( + B.matmul( + evecs[:, i].reshape(1, -1), + B.matmul(self._down_edge_laplacian, evecs[:, i]), + ) + ) + total_curl.append( + B.matmul( + evecs[:, i].reshape(1, -1), + B.matmul(self._up_edge_laplacian, evecs[:, i]), + ) + ) + harm_evecs, grad_evecs, curl_evecs = [], [], [] for i in range(num_eigemodes): if total_var[i] < eps: @@ -174,14 +176,15 @@ def get_eigensystem(self, num, hgc_order=False): grad_evecs.append(i) elif total_curl[i] > eps: curl_evecs.append(i) - + reorder_indices = harm_evecs + grad_evecs + curl_evecs - assert len(reorder_indices) == num_eigemodes, "The eigenmodes are not correctly organized" + assert ( + len(reorder_indices) == num_eigemodes + ), "The eigenmodes are not correctly organized" evals = B.take(evals, reorder_indices, axis=0) evecs = B.take(evecs, reorder_indices, axis=1) - self.cache[num] = (evecs, evals[:, None]) return self.cache[num] @@ -203,7 +206,7 @@ def get_eigenvectors(self, num: int) -> B.Numeric: Number of eigenvectors to return. :return: - Array of eigenvectors, with shape [n, num]. + Array of eigenvectors, with shape [m, num]. """ return self.get_eigensystem(num)[0] @@ -227,9 +230,8 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: return self.get_eigenvalues(num) def random(self, key, number): - num_edges = B.shape(self._edge_laplacian)[0] key, random_edges = B.randint( - key, dtype_integer(key), number, 1, lower=0, upper=num_edges + key, dtype_integer(key), number, 1, lower=0, upper=self.num_edges ) return key, random_edges diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edge.py index 1296283f..91c73339 100644 --- a/tests/spaces/test_graph_edge.py +++ b/tests/spaces/test_graph_edge.py @@ -14,21 +14,24 @@ warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") B1 = np.array( -[[-1, -1, -1, 0, 0, 0], - [ 1, 0, 0, -1, 0, 0], - [ 0, 1, 0, 1, -1, 0], - [ 0, 0, 1, 0, 0, -1], - [ 0, 0, 0, 0, 1, 1], - ] + [ + [-1, -1, -1, 0, 0, 0], + [1, 0, 0, -1, 0, 0], + [0, 1, 0, 1, -1, 0], + [0, 0, 1, 0, 0, -1], + [0, 0, 0, 0, 1, 1], + ] ).astype(np.float64) B2 = np.array( - [[ 1], - [-1], - [ 0], - [ 1], - [ 0], - [ 0],] + [ + [1], + [-1], + [0], + [1], + [0], + [0], + ] ).astype(np.float64) @@ -36,25 +39,18 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): ############################################## # Inits - m= B1.shape[1] - B1 = B.cast(B.dtype(B1), B1) - B2 = B.cast(B.dtype(B2), B2) + m = B1.shape[1] sc = GraphEdge(B1, B2) ############################################## # Laplacian computation - L = B.matmul(B.transpose(B1), B1) + B.matmul(B2, B2.T) - comparison = sc.edge_laplacian[0] == (L) - + L = B.matmul(B1, B1, tr_a=True) + B.matmul(B2, B2, tr_b=True) + comparison = sc._edge_laplacian == L if sp.issparse(comparison): comparison = comparison.toarray() - if isinstance(comparison, np.matrix): # bug with lab? - assert comparison.all(), "Laplacian does not match." - else: - assert B.all(comparison), "Laplacian does not match." - + assert B.all(comparison), "Laplacian does not match." ############################################## # Eigendecomposition checks @@ -81,7 +77,6 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol ) - ############################################## # Kernel init checks @@ -161,6 +156,7 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): def test_graphs_numpy(): run_tests_with_adj(B1, B2) + def test_graphs_torch(): run_tests_with_adj(torch.tensor(B1), torch.tensor(B2)) @@ -171,10 +167,8 @@ def test_graphs_jax(): def test_graphs_torch_cuda(): if torch.cuda.is_available(): - B1 = torch.tensor(B1).cuda() - B2 = torch.tensor(B2).cuda() m = B1.shape[1] - sc = GraphEdge(B1,B2) + sc = GraphEdge(torch.tensor(B1).cuda(), torch.tensor(B2).cuda()) K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) params = K_cons.init_params() From 5c6d0e5f68e8c115d940da3f0b767c17eaee6211 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Wed, 9 Oct 2024 19:27:52 +0200 Subject: [PATCH 06/30] updates from last discussion --- geometric_kernels/feature_maps/__init__.py | 4 +- .../feature_maps/deterministic.py | 78 +- geometric_kernels/kernels/__init__.py | 5 +- geometric_kernels/kernels/karhunen_loeve.py | 135 ++ geometric_kernels/kernels/matern_kernel.py | 33 +- geometric_kernels/sampling/samplers.py | 12 +- geometric_kernels/spaces/__init__.py | 1 + geometric_kernels/spaces/graph_edge.py | 265 +++- notebooks/GraphEdges.ipynb | 917 ------------ notebooks/SimplicialComplex.ipynb | 455 ++++-- notebooks/backends/JAX_EdgeSpaceGraph.ipynb | 930 ------------ .../JAX_EdgeSpaceSimplicialComplex.ipynb | 1085 -------------- .../backends/JAX_SimplicialComplex.ipynb | 1280 ++++++++++++++++ .../backends/PyTorch_EdgeSpaceGraph.ipynb | 940 ------------ .../PyTorch_EdgeSpaceSimplicialComplex.ipynb | 1075 -------------- .../backends/PyTorch_SimplicialComplex.ipynb | 1285 +++++++++++++++++ tests/spaces/test_graph.py | 220 --- tests/spaces/test_graph_edge.py | 78 +- 18 files changed, 3385 insertions(+), 5413 deletions(-) delete mode 100644 notebooks/GraphEdges.ipynb delete mode 100644 notebooks/backends/JAX_EdgeSpaceGraph.ipynb delete mode 100644 notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb create mode 100644 notebooks/backends/JAX_SimplicialComplex.ipynb delete mode 100644 notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb delete mode 100644 notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb create mode 100644 notebooks/backends/PyTorch_SimplicialComplex.ipynb delete mode 100644 tests/spaces/test_graph.py diff --git a/geometric_kernels/feature_maps/__init__.py b/geometric_kernels/feature_maps/__init__.py index fe84abf5..a0083cd7 100644 --- a/geometric_kernels/feature_maps/__init__.py +++ b/geometric_kernels/feature_maps/__init__.py @@ -7,7 +7,9 @@ # noqa: F401 from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.feature_maps.deterministic import DeterministicFeatureMapCompact +from geometric_kernels.feature_maps.deterministic import ( + DeterministicFeatureMapCompact, DeterministicFeatureMapCompact_HodgeCompositional +) from geometric_kernels.feature_maps.random_phase import ( RandomPhaseFeatureMapCompact, RandomPhaseFeatureMapNoncompact, diff --git a/geometric_kernels/feature_maps/deterministic.py b/geometric_kernels/feature_maps/deterministic.py index 873a57d0..739cbca3 100644 --- a/geometric_kernels/feature_maps/deterministic.py +++ b/geometric_kernels/feature_maps/deterministic.py @@ -9,7 +9,10 @@ from beartype.typing import Dict, Optional, Tuple from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.karhunen_loeve import ( + MaternKarhunenLoeveKernel, + MaternKarhunenLoeveKernel_HodgeCompositionEdge + ) from geometric_kernels.spaces import DiscreteSpectrumSpace @@ -66,11 +69,11 @@ def __call__( nu=params["nu"], lengthscale=params["lengthscale"], ) + normalize = normalize or (normalize is None and self.kernel.normalize) if normalize: normalizer = B.sum(spectrum) spectrum = spectrum / normalizer - weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] eigenfunctions = self.kernel.eigenfunctions(X, **params) # [N, M] @@ -78,3 +81,74 @@ def __call__( B.dtype(params["lengthscale"]), weights ) # [N, M] return None, features + + +class DeterministicFeatureMapCompact_HodgeCompositional(FeatureMap): + r""" + Deterministic feature map for :class:`~.spaces.GraphEdge`\ s + for which the actual eigenpairs are explicitly available. + + Note: We obtain the embedding by Hodge subspace. + """ + def __init__(self, space: DiscreteSpectrumSpace, num_levels: int): + self.space = space + self.num_levels = num_levels + self.kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge(space, num_levels) + + def __call__( + self, + X: B.Numeric, + params: Dict[str, B.Numeric], + normalize: Optional[bool] = None, + hodge_type: Optional[str] = None, + **kwargs, + ) -> Tuple[None, B.Numeric]: + """ + :param X: + [N, ...] points in the space to evaluate the map on. + :param params: + Parameters of the kernel (length scale and smoothness). + :param normalize: + Normalize to have unit average variance (if omitted + or None, follows the standard behavior of + :class:`~.kernels.MaternKarhunenLoeveKernel`). + :param hodge_type: + The type of Hodge embedding to compute. + :param ``**kwargs``: + Unused. + + :return: + `Tuple(None, features)` where `features` is an [N, O] array, N + is the number of inputs and O is the dimension of the feature map. + + .. note:: + The first element of the returned tuple is the simple None and + should be ignored. It is only there to support the abstract + interface: for some other subclasses of :class:`FeatureMap`, this + first element may be an updated random key. + """ + self.repeated_eigenvalues = self.space.get_eigenvalues_by_type(self.kernel.num_levels, hodge_type) + + if hodge_type == 'harmonic': + hodge_kernel = self.kernel.harmonic_kernel + elif hodge_type == 'gradient': + hodge_kernel = self.kernel.gradient_kernel + elif hodge_type == 'curl': + hodge_kernel = self.kernel.curl_kernel + + spectrum = hodge_kernel._spectrum( + self.repeated_eigenvalues, + nu=params["nu"], + lengthscale=params["lengthscale"], + ) + normalize = normalize or (normalize is None and self.kernel.normalize) + if normalize: + normalizer = B.sum(spectrum) + spectrum = spectrum / normalizer + + weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] + eigenfunctions = hodge_kernel.eigenfunctions(X, **params) # [N, M] + features = B.cast(B.dtype(params["lengthscale"]), eigenfunctions) * B.cast( + B.dtype(params["lengthscale"]), weights + ) # [N, M] + return None, features \ No newline at end of file diff --git a/geometric_kernels/kernels/__init__.py b/geometric_kernels/kernels/__init__.py index ffd5b815..b3021a0b 100644 --- a/geometric_kernels/kernels/__init__.py +++ b/geometric_kernels/kernels/__init__.py @@ -9,7 +9,10 @@ # noqa: F401 from geometric_kernels.kernels.base import BaseGeometricKernel from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel -from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.karhunen_loeve import ( + MaternKarhunenLoeveKernel, + MaternKarhunenLoeveKernel_HodgeCompositionEdge + ) from geometric_kernels.kernels.matern_kernel import ( MaternGeometricKernel, default_feature_map, diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index 5157f30a..c5d075f9 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -186,6 +186,7 @@ def eigenvalues( ) ) return spectral_values / normalizer + return spectral_values def K( @@ -217,3 +218,137 @@ def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: return B.real(K_diag) else: return K_diag + + +class MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type(MaternKarhunenLoeveKernel): + def __init__(self, hodge_type, + space: DiscreteSpectrumSpace, + num_levels: int, + normalize: bool = True,): + assert hodge_type in ['harmonic', 'gradient', 'curl'] + self.hodge_type = hodge_type + super().__init__(space, num_levels, normalize) + self._eigenvalues_laplacian = self.space.get_eigenvalues_by_type(self.num_levels, self.hodge_type) + self._eigenfunctions = self.space.get_eigenfunctions_by_type(self.num_levels, self.hodge_type) + + +class MaternKarhunenLoeveKernel_HodgeCompositionEdge(BaseGeometricKernel): + r""" + This class approximates Hodge-compositional Edge Matérn kernel by its truncated Mercer decomposition, together with the Hodge decomposition, + in terms of the eigenfunctions & eigenvalues of the Laplacian on the space. + + .. math:: k(x, x') = k_{\text{harmonic}}(x, x') + k_{\text{gradient}}(x, x') + k_{\text{curl}}(x, x') + + where $k_{\text{harmonic}}(x, x')$, $k_{\text{gradient}}(x, x')$ and $k_{\text{curl}}(x, x')$ are the Hodge kernels of the compositional kernel with respect to the harmonic, gradient and curl spaces, respectively. + + """ + def __init__(self, space: DiscreteSpectrumSpace, num_levels: int, normalize: bool = True): + super().__init__(space) + self.num_levels = num_levels + self.harmonic_kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type('harmonic', space, num_levels, normalize) + self.gradient_kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type('gradient', space, num_levels, normalize) + self.curl_kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type('curl', space, num_levels, normalize) + self.normalize = normalize + + @property + def space(self) -> DiscreteSpectrumSpace: + """ + The space on which the kernel is defined. + """ + self._space: DiscreteSpectrumSpace + return self._space + + def init_params(self) -> Dict[str, B.NPNumeric]: + """ + Initializes the dict of the trainable parameters of the kernel. + + Returns 'dict(harmonic=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), + gradient=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), + curl=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0]))'. + + This dict can be modified and is passed around into such methods as + :meth:`~.K` or :meth:`~.K_diag`, as the `params` argument. + + .. note:: + The values in the returned dict are always of the NumPy array type. + Thus, if you want to use some other backend for internal + computations when calling :meth:`~.K` or :meth:`~.K_diag`, you + need to replace the values with the analogs typed as arrays of + the desired backend. + """ + params = dict(harmonic=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), + gradient=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), + curl=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])) + ) + + return params + + def eigenvalues( + self, params: Dict[str, B.Numeric], normalize: Optional[bool] = None + ) -> B.Numeric: + """ + Eigenvalues of the kernel. + + :param params: + Parameters of the kernel. Must contain keys `"lengthscale"` and + `"nu"`. The shapes of `params["lengthscale"]` and `params["nu"]` + are `(1,)`. + :param normalize: + Whether to normalize kernel to have unit average variance. + If None, uses `self.normalize` to decide. + + Defaults to None. + + :return: + An [L, 1]-shaped array. + """ + assert "harmonic" in params + assert "gradient" in params + assert "curl" in params + assert params["harmonic"]["lengthscale"].shape == (1,) + assert params["gradient"]["lengthscale"].shape == (1,) + assert params["curl"]["lengthscale"].shape == (1,) + assert params["harmonic"]["nu"].shape == (1,) + assert params["gradient"]["nu"].shape == (1,) + assert params["curl"]["nu"].shape == (1,) + + spectral_values_harmonic = self.harmonic_kernel.eigenvalues( + params=params["harmonic"], normalize=normalize + ) + spectral_values_gradient = self.gradient_kernel.eigenvalues( + params=params["gradient"], normalize=normalize + ) + spectral_values_curl = self.curl_kernel.eigenvalues( + params=params["curl"], normalize=normalize + ) + spectral_values = {'harmonic': spectral_values_harmonic, 'gradient': spectral_values_gradient, 'curl': spectral_values_curl} + return spectral_values + + def K(self, params, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs) -> B.Numeric: + assert "harmonic" in params + assert "gradient" in params + assert "curl" in params + assert params["harmonic"]["lengthscale"].shape == (1,) + assert params["gradient"]["lengthscale"].shape == (1,) + assert params["curl"]["lengthscale"].shape == (1,) + assert params["harmonic"]["nu"].shape == (1,) + assert params["gradient"]["nu"].shape == (1,) + assert params["curl"]["nu"].shape == (1,) + + return self.harmonic_kernel.K(params['harmonic'], X, X2, **kwargs) + self.gradient_kernel.K(params['gradient'], X, X2, **kwargs) + self.curl_kernel.K(params['curl'], X, X2, **kwargs) + + def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: + assert "harmonic" in params + assert "gradient" in params + assert "curl" in params + assert params["harmonic"]["lengthscale"].shape == (1,) + assert params["gradient"]["lengthscale"].shape == (1,) + assert params["curl"]["lengthscale"].shape == (1,) + assert params["harmonic"]["nu"].shape == (1,) + assert params["gradient"]["nu"].shape == (1,) + assert params["curl"]["nu"].shape == (1,) + + return self.harmonic_kernel.K_diag(params['harmonic'], X, **kwargs) + self.gradient_kernel.K_diag(params['gradient'], X, **kwargs) + self.curl_kernel.K_diag(params['curl'], X, **kwargs) + + + \ No newline at end of file diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index dadf0013..1462e081 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -11,6 +11,7 @@ from geometric_kernels.feature_maps import ( DeterministicFeatureMapCompact, + DeterministicFeatureMapCompact_HodgeCompositional, RandomPhaseFeatureMapCompact, RandomPhaseFeatureMapNoncompact, RejectionSamplingFeatureMapHyperbolic, @@ -18,11 +19,15 @@ ) from geometric_kernels.kernels.base import BaseGeometricKernel from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel -from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.karhunen_loeve import ( + MaternKarhunenLoeveKernel, + MaternKarhunenLoeveKernel_HodgeCompositionEdge + ) from geometric_kernels.spaces import ( CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, + GraphEdge, Hyperbolic, Hypersphere, Mesh, @@ -82,6 +87,11 @@ def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): else: return DeterministicFeatureMapCompact(kernel.space, kernel.num_levels) +@overload +def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel_HodgeCompositionEdge): + "For Hodge-compositional edge kernels ONLY" + assert isinstance(kernel.space, GraphEdge) + return DeterministicFeatureMapCompact_HodgeCompositional(kernel.space, kernel.num_levels) @overload def feature_map_from_kernel(kernel: MaternFeatureMapKernel): @@ -139,6 +149,7 @@ def feature_map_from_space(space: DiscreteSpectrumSpace, num: int): space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES ) else: + return DeterministicFeatureMapCompact(space, num) @@ -199,6 +210,10 @@ def default_num(space: DiscreteSpectrumSpace) -> int: return min( MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) + elif isinstance(space, GraphEdge): + return min( + MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges + ) else: return MaternGeometricKernel._DEFAULT_NUM_LEVELS @@ -262,6 +277,7 @@ def __new__( num: int = None, normalize: bool = True, return_feature_map: bool = False, + use_hodge_composition: bool = None, **kwargs, ): r""" @@ -308,6 +324,12 @@ def __new__( from Gaussian processes) along with the kernel. Default is False. + + :param use_hodge_composition: + If `True`, use the Hodge compositional kernel on the + edges of a graph or a simplicial complex. This is only relevant for the :class:`~.spaces.GraphEdge` + space. + :param ``**kwargs``: Any additional keyword arguments to be passed to the kernel (like `key`). @@ -321,7 +343,13 @@ def __new__( kernel: BaseGeometricKernel if isinstance(space, DiscreteSpectrumSpace): num = num or default_num(space) - kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) + if isinstance(space, GraphEdge): + if use_hodge_composition: + kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge(space, num, normalize=normalize) + else: + kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) + else: + kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: feature_map = default_feature_map(kernel=kernel) @@ -349,3 +377,4 @@ def __new__( return kernel, feature_map else: return kernel + \ No newline at end of file diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index afc6ec24..72928f1d 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -21,6 +21,7 @@ def sample_at( params: Dict[str, B.Numeric], key: B.RandomState = None, normalize: bool = None, + hodge_type: Optional[str] = None, ) -> Tuple[B.RandomState, B.Numeric]: r""" Given a `feature_map` $\phi_{\nu, \kappa}: X \to \mathbb{R}^n$, where @@ -60,6 +61,10 @@ def sample_at( Passed down to `feature_map` directly. Controls whether to force the average variance of the Gaussian process to be around 1 or not. If None, follows the standard behavior, typically same as normalize=True. + + Defaults to None. + :param hodge_type: + The type of Hodge component to sample. Only used when using Hodge-compositional edge kernels Defaults to None. @@ -71,8 +76,11 @@ def sample_at( if key is None: key = B.global_random_state(B.dtype(X)) - _context, features = feature_map(X, params, key=key, normalize=normalize) # [N, M] - + if hodge_type is None: + _context, features = feature_map(X, params, key=key, normalize=normalize) # [N, M] + else: + _context, features = feature_map(X, params, key=key, normalize=normalize, hodge_type=hodge_type) + if _context is not None: key = _context diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index c3447798..29a40814 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -10,6 +10,7 @@ ) from geometric_kernels.spaces.circle import Circle from geometric_kernels.spaces.graph import Graph +from geometric_kernels.spaces.graph_edge import GraphEdge from geometric_kernels.spaces.hyperbolic import Hyperbolic from geometric_kernels.spaces.hypersphere import Hypersphere from geometric_kernels.spaces.lie_groups import CompactMatrixLieGroup diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index 730d98ed..4ebc2125 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -3,11 +3,17 @@ """ import lab as B +import numpy as np +import networkx as nx from beartype.typing import Dict, Tuple, Optional from geometric_kernels.lab_extras import ( + degree, dtype_integer, eigenpairs, + reciprocal_no_nan, + set_value, + take_along_axis, ) from geometric_kernels.spaces.base import DiscreteSpectrumSpace @@ -29,22 +35,15 @@ class GraphEdge(DiscreteSpectrumSpace): .. note:: A tutorial on how to use this space is available in the :doc:`EdgeSpaceGraph.ipynb ` notebook. - - :param incidence_matrix: - An n x m dimensional matrix where n is the number of nodes and m is the number of edges. - incidence_matrix[i, e] is -1 if node i is the start node of edge e, 1 if node i is the end node of edge e. - - Note that the -1s and 1s in the incidence matrix do not necessarily mean that the graph is directed. Instead, they are used to allow oriented computations along edges. - - :param triangle_incidence_matrix: optional - An m x t dimensional matrix where m is the number of edges and t is the number of triangles. - triangle_incidence_matrix[e, t] is -1 if edge e is anti-aligned with triangle t, 1 if edge e is aligned with triangle t, 0 otherwise. - - .. note: - The Laplacian is an m x m dimensional matrix where m is the number of - edges which is computed as - incidence_matrix.T @ incidence_matrix, if triangle_incidence_matrix is None - incidence_matrix.T @ incidence_matrix + triangle_incidence_matrix @ triangle_incidence_matrix.T, if triangle_incidence_matrix is not None + + :param G: + A networkx graph object. + + :param triangle_list: + A list of triangles in the graph. If not provided, all triangles in the graph are considered as 2-simplices. + + :param sc_lifting: + If True, we lift the graph to a simplicial 2-complex using either the provided triangle list or all the triangles in the graph. This acts also a flag to compute the triangle incidence matrix. Defaults to False. .. admonition:: Citation @@ -52,47 +51,49 @@ class GraphEdge(DiscreteSpectrumSpace): citing :cite:t:`yang2024`. """ - def __init__( - self, incidence_matrix: B.Int, triangle_incidence_matrix: Optional[B.Int] = None - ): + def __init__(self, G, triangle_list=None, sc_lifting=False): # type: ignore + self.G = G self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - self._checks(incidence_matrix, triangle_incidence_matrix) - - self.num_vertices, self.num_edges = incidence_matrix.shape - if triangle_incidence_matrix is None: - self.num_triangles = 0 + self.incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray() # "obtain the oriented incidence matrix" + if sc_lifting is not False: + if triangle_list is None: + print("No list of triangles is provided, we consider all triangles in the graph as 2-simplices.") + self.triangles = self.triangles_all_clique() + self.triangle_incidence_matrix = self.triangles_to_B2() + else: + self.triangles = triangle_list + self.triangle_incidence_matrix = self.triangles_to_B2() else: - self.num_triangles = triangle_incidence_matrix.shape[1] + self.triangle_incidence_matrix = None - self._set_laplacian(incidence_matrix, triangle_incidence_matrix) + self._checks(self.incidence_matrix, self.triangle_incidence_matrix) + self._set_laplacian() # type: ignore + self.num_vertices, self.num_edges = self.incidence_matrix.shape + self.num_triangles = self.triangle_incidence_matrix.shape[1] if self.triangle_incidence_matrix is not None else 0 + @staticmethod - def _checks(incidence_matrix, triangle_incidence_matrix): + def _checks(incidence_matrix, triangle_incidence_matrix=None): """ Checks if `incidence_matrix` and `triangle_incidence_matrix` are of appropriate structure. """ - assert B.rank(incidence_matrix) == 2, "Incidence matrix must be a 2-dim tensor." - assert B.all( B.sum(incidence_matrix == 1, axis=0) == 1 ), "Each column of the incidence matrix must contain 1 exactly once." assert B.all( B.sum(incidence_matrix == -1, axis=0) == 1 ), "Each column of the incidence matrix must contain -1 exactly once." - if triangle_incidence_matrix is not None: assert ( B.rank(triangle_incidence_matrix) == 2 ), "Triangle incidence matrix matrix must be a 2-dim tensor." - num_edges = B.shape(incidence_matrix)[1] assert B.shape(triangle_incidence_matrix)[0] == num_edges, ( "The first dimension of the triangle incidence matrix must" " be equal to the second dimension of the incidence matrix." ) - assert B.all(B.sum(triangle_incidence_matrix != 0, axis=0) == 3), ( "Each column of the edge triangle incidence matrix must" " have exactly 3 non-zero entries." @@ -105,25 +106,106 @@ def dimension(self) -> int: 0. """ return 0 # this is needed for the kernel math to work out - - def _set_laplacian(self, incidence_matrix, triangle_incidence_matrix): + + def sc_simplices(self): + """return the nodes, edges and triangles in the graph""" + print('----Simplicial 2-complex summary---') + print('nodes: ', list(self.G.nodes)) + print('edges: ', list(self.G.edges)) + print('triangles: ', self.triangles) + return None + + def _set_laplacian(self): """ Construct the appropriate graph Laplacian from the adjacency matrix. """ - self._down_edge_laplacian = incidence_matrix.T @ incidence_matrix - - if triangle_incidence_matrix is None: + self._down_edge_laplacian = self.incidence_matrix.T @ self.incidence_matrix + if self.triangle_incidence_matrix is None: self._up_edge_laplacian = B.zeros( B.dtype(self._down_edge_laplacian), *B.shape(self._down_edge_laplacian) ) else: self._up_edge_laplacian = B.matmul( - triangle_incidence_matrix, triangle_incidence_matrix, tr_b=True + self.triangle_incidence_matrix, self.triangle_incidence_matrix, tr_b=True ) - self._edge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian + + @property + def incidence_matrices(self): + """ + Return the incidence matrix + """ + if self.triangle_incidence_matrix is None: + return self.incidence_matrix + else: + return self.incidence_matrix, self.triangle_incidence_matrix + + @property + def edge_laplacian(self): + """ + Return the Edge Laplacian + """ + if self.triangle_incidence_matrix is None: + return self._edge_laplacian + else: + return self._edge_laplacian, self._down_edge_laplacian, self._up_edge_laplacian + + def triangles_all_clique(self) -> list: + """ + Get a list of triangles in the graph. + + Returns: + list: List of triangles. + """ + cliques = nx.enumerate_all_cliques(self.G) + triangle_vertices = [x for x in cliques if len(x) == 3] + # sort the triangles + triangle_vertices = [sorted(tri) for tri in triangle_vertices] + return triangle_vertices + + def triangles_to_B2(self) -> np.ndarray: + """ + Create the B2 matrix (edge-triangle) from the triangles. + + The `triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph. + + The entry `triangle_incidence_matrix[e, t]` is + - `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$, + - `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and + - `0` otherwise. + + Args: + triangles (list): List of triangles. + edges (list): List of edges. - def get_eigensystem(self, num, hgc_order=False): + Returns: + np.ndarray: B2 matrix. + """ + edges = list(self.G.edges) + triangles = self.triangles + B2 = np.zeros((len(edges), len(triangles))) + for j, triangle in enumerate(triangles): + a, b, c = triangle + try: + index_a = edges.index((a, b)) + except ValueError: + index_a = edges.index((b, a)) + try: + index_b = edges.index((b, c)) + except ValueError: + index_b = edges.index((c, b)) + try: + index_c = edges.index((a, c)) + except ValueError: + index_c = edges.index((c, a)) + + B2[index_a, j] = 1 + B2[index_c, j] = -1 + B2[index_b, j] = 1 + + return B2 + + def get_eigensystem(self, num): """ Returns the first `num` eigenvalues and eigenvectors of the Hodge Laplacian. Caches the solution to prevent re-computing the same values. @@ -131,18 +213,17 @@ def get_eigensystem(self, num, hgc_order=False): :param num: Number of eigenpairs to return. Performs the computation at the first call. Afterwards, fetches the result from cache. - - :param hgc_order: - If True, the eigenmodes are organized according to the Harmonic, Gradient and Curl eigenvalues from small to big. - - + :return: - A tuple of eigenvectors [m, num], eigenvalues [num, 1]. + A tuple of eigenvectors [n, num], eigenvalues [num, 1]. """ eps = 1e-6 if num not in self.cache: evals, evecs = eigenpairs(self._edge_laplacian, num) - if self.num_triangles > 0 and hgc_order: + # make a dictionary of the eigenvalues and eigenvectors where the keys are the indices of the eigenvalues, and add another value which indicates the type of the eigenbasis (harmonic, gradient, curl) + self.hodge_eigenbasis = {} + # add keys to the dictionary + if self.triangle_incidence_matrix is not None: # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian total_var = [] total_div = [] @@ -167,25 +248,20 @@ def get_eigensystem(self, num, hgc_order=False): B.matmul(self._up_edge_laplacian, evecs[:, i]), ) ) - - harm_evecs, grad_evecs, curl_evecs = [], [], [] + for i in range(num_eigemodes): if total_var[i] < eps: - harm_evecs.append(i) + # harm_evecs.append(i) + hodge_type = 'harmonic' elif total_div[i] > eps: - grad_evecs.append(i) + # grad_evecs.append(i) + hodge_type = 'gradient' elif total_curl[i] > eps: - curl_evecs.append(i) - - reorder_indices = harm_evecs + grad_evecs + curl_evecs - assert ( - len(reorder_indices) == num_eigemodes - ), "The eigenmodes are not correctly organized" - - evals = B.take(evals, reorder_indices, axis=0) - evecs = B.take(evecs, reorder_indices, axis=1) - - self.cache[num] = (evecs, evals[:, None]) + # curl_evecs.append(i) + hodge_type = 'curl' + self.hodge_eigenbasis[i] = {'eval': evals[i], 'evec': evecs[:, i], 'type': hodge_type} + + self.cache[num] = self.hodge_eigenbasis return self.cache[num] @@ -206,9 +282,9 @@ def get_eigenvectors(self, num: int) -> B.Numeric: Number of eigenvectors to return. :return: - Array of eigenvectors, with shape [m, num]. + Array of eigenvectors, with shape [n, num]. """ - return self.get_eigensystem(num)[0] + return np.array([entry['evec'] for entry in self.get_eigensystem(num).values()]).T def get_eigenvalues(self, num: int) -> B.Numeric: """ @@ -218,7 +294,63 @@ def get_eigenvalues(self, num: int) -> B.Numeric: :return: Array of eigenvalues, with shape [num, 1]. """ - return self.get_eigensystem(num)[1] + return np.array([entry['eval'] for entry in self.get_eigensystem(num).values()])[:,None] + + def get_eigenbasis_type(self, num: int): + """ + :param num: + Number of eigenvalues to return. + + :return: + Array of strings, with shape [num, 1]. + """ + return [entry['type'] for entry in self.get_eigensystem(num).values()] + + # get particular type of eigenbasis + def get_eigenfunctions_by_type(self, num: int, hodge_type: str) -> Eigenfunctions: + """ + Returns the :class:`~.EigenfunctionsFromEigenvectors` object with + `num` levels (i.e., in this case, `num` eigenpairs) of a particular type. + + :param num: + Number of levels. + :param hodge_type: + The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. + + :return: + EigenfunctionsFromEigenvectors object. + """ + eigenfunctions = EigenfunctionsFromEigenvectors(self.get_eigenvectors_by_type(num, hodge_type)) + return eigenfunctions + + def get_eigenvectors_by_type(self, num: int, hodge_type: str) -> B.Numeric: + """ + :param num: + Number of eigenvectors to return. + :param hodge_type: + The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. + + :return: + Array of eigenvectors, with shape [n, num]. + """ + assert hodge_type in ['harmonic', 'gradient', 'curl'] #"The hodge type should be either 'harmonic', 'gradient', or 'curl'." + eigenbasis = self.get_eigensystem(num) + return np.array([entry['evec'] for entry in eigenbasis.values() if entry['type'] == hodge_type]).T + + def get_eigenvalues_by_type(self, num: int, hodge_type: str) -> B.Numeric: + """ + :param num: + Number of eigenvalues to return. + :param hodge_type: + The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. + + :return: + Array of eigenvalues, with shape [num, 1]. + """ + assert hodge_type in ['harmonic', 'gradient', 'curl'] # "The hodge type should be either 'harmonic', 'gradient', or 'curl'." + eigenbasis = self.get_eigensystem(num) + return np.array([entry['eval'] for entry in eigenbasis.values() if entry['type'] == hodge_type])[:,None] + def get_repeated_eigenvalues(self, num: int) -> B.Numeric: """ @@ -230,8 +362,9 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: return self.get_eigenvalues(num) def random(self, key, number): + num_edges = B.shape(self._edge_laplacian)[0] key, random_edges = B.randint( - key, dtype_integer(key), number, 1, lower=0, upper=self.num_edges + key, dtype_integer(key), number, 1, lower=0, upper=num_edges, ) return key, random_edges diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb deleted file mode 100644 index 013c424d..00000000 --- a/notebooks/GraphEdges.ipynb +++ /dev/null @@ -1,917 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on (Oriented) Graphs\n", - "This notebook shows how to define and evaluate kernels on the edge space of an oriented simple graph.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **numpy** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" - ] - } - ], - "source": [ - "# Import a backend, we use numpy in this example.\n", - "import numpy as np\n", - "\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "# import geometric_kernels.torch\n", - "# import geometric_kernels.jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of the graph.\n", - "\n", - "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. The entry `incidence_matrix[i, j]` is `-1` if node `i` is the source of edge `j`, `1` if node `i` is the target of edge `j`, and `0` otherwise. \n", - "\n", - "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations.\n", - "\n", - "This space essentially contains the Edge-Laplacian matrix, which is the Laplacian matrix of the edge space of the graph. In the general case, it is the Hodge-Laplacian matrix of the edge space of a simplicial 2-complex.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "YJXKhf4y-tgV" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", - "\n", - "\n", - "edge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n" - ] - } - ], - "source": [ - "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", - "edge_graph = GraphEdge(incidence_matrix)\n", - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('incidence matrix:\\n', incidence_matrix)\n", - "print('\\n')\n", - "print('edge Laplacian:\\n', edge_graph.edge_laplacian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `edge_graph` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "kernel = MaternGeometricKernel(edge_graph)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "params[\"lengthscale\"] = np.array([2.0])\n", - "params_32 = params.copy()\n", - "params_inf = params.copy()\n", - "del params\n", - "params_32[\"nu\"] = np.array([3/2])\n", - "params_inf[\"nu\"] = np.array([np.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on our graph.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n" - ] - } - ], - "source": [ - "key = np.random.RandomState(1234)\n", - "\n", - "key, xs = edge_graph.random(key, 3)\n", - "\n", - "print(xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = np.min([np.min(kernel_mat_32), np.min(kernel_mat_inf)])\n", - "maxmax = np.max([np.max(kernel_mat_32), np.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = 1 # choosing a fixed edge for kernel visualization\n", - "other_edges = np.arange(edge_graph.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "values_32 = kernel.K(params_32, np.array([[base_edge]]),\n", - " other_edges).flatten()\n", - "values_inf = kernel.K(params_inf, np.array([[base_edge]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "variance_32 = kernel.K_diag(params_32, other_edges)\n", - "variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.18,\n", - "Variance in the edge (1,3) is 0.20,\n", - "The average variance is 0.17.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % np.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = (3, 1)):\n", - "[[3]\n", - " [5]\n", - " [4]]\n", - "\n", - "emedding (shape = (3, 6)):\n", - "[[-4.17448397e-02 3.83051484e-01 1.08504235e-01 -5.26867410e-02\n", - " 1.02519158e-01 -4.08723427e-02]\n", - " [ 3.28045722e-01 -6.11498784e-02 2.26833021e-16 -1.70497875e-01\n", - " -9.57952499e-17 5.05209940e-02]\n", - " [-3.28045722e-01 6.11498784e-02 1.75563540e-01 -3.25621967e-02\n", - " -6.33603240e-02 6.61328397e-02]]\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.163336342344337e-17\n" - ] - } - ], - "source": [ - "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", - "\n", - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - "\n", - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", - "\n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "[[ 0.36024923 -0.21070873]\n", - " [-0.02141462 -0.21293585]\n", - " [-0.14648103 0.75575338]]\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = np.random.RandomState(seed=1234)\n", - "\n", - "# new random state is returned along with the samples\n", - "key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = np.random.RandomState(seed=1234)\n", - "key, samples = sample_paths(other_edges, params_32, key=key)\n", - "\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", - " vmin=vmin, vmax=vmax, **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", - " vmin=vmin, vmax=vmax, **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/SimplicialComplex.ipynb b/notebooks/SimplicialComplex.ipynb index 4d4ce37f..22432895 100644 --- a/notebooks/SimplicialComplex.ipynb +++ b/notebooks/SimplicialComplex.ipynb @@ -23,7 +23,9 @@ "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "The graph **must be** undirected.\n", + "\n", + "We construct the simplicial 2-complex by adding triangles to the graph. The triangles can be provided by users. If not provided, we look for all the 2-cliques in the graph and add them to the simplicial 2-complex.\n", "\n", "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", "\n", @@ -252,83 +254,99 @@ "source": [ "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", "\n", - "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. \n", + "The `G` parameter is a 'networkx.classes.graph.Graph' object, from which we build the node-to-edge incidence matrix.\n", + "\n", + "The 'triangle_list' parameter is a list of tuples, where each tuple is a triangle in the graph. If provided, this will be used to construct a simplicial 2-complex.\n", "\n", - "The entry `incidence_matrix[i, e]` is \n", - "- `-1` if node `i` is the source of edge `e`, \n", - "- `1` if node `i` is the target of edge `e`, and \n", - "- `0` otherwise. \n", + "The 'sc_lifting' parameter is a boolean that determines if to build a simplicial 2-complex. \n", + "- If True and 'triangle_list' is not None, the edge space of a simplicial 2-complex will be built based on the provided triangles. \n", + "- If True and 'triangle_list' is None, the edge space of a simplicial 2-complex with all the 2-cliques as 2-simplices will be built. \n", + "- If False and no 'triangle_list' provided, the edge space of the graph will be built.\n", "\n", - "The `edge_triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph.\n", + "\n", "\n", - "The entry `edge_triangle_incidence_matrix[e, t]` is\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the Simplicial 2-Complex " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----Simplicial 2-complex summary---\n", + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], "source": [ - "def triangles_to_B2(striangles: list, edges: list) -> np.ndarray:\n", - " \"\"\"\n", - " Create the B2 matrix (edge-triangle) from the triangles.\n", - "\n", - " Args:\n", - " triangles (list): List of triangles.\n", - " edges (list): List of edges.\n", - "\n", - " Returns:\n", - " np.ndarray: B2 matrix.\n", - " \"\"\"\n", - " B2 = np.zeros((len(edges), len(triangles)))\n", - " for j, triangle in enumerate(triangles):\n", - " a, b, c = triangle\n", - " try:\n", - " index_a = edges.index((a, b))\n", - " except ValueError:\n", - " index_a = edges.index((b, a))\n", - " try:\n", - " index_b = edges.index((b, c))\n", - " except ValueError:\n", - " index_b = edges.index((c, b))\n", - " try:\n", - " index_c = edges.index((a, c))\n", - " except ValueError:\n", - " index_c = edges.index((c, a))\n", - "\n", - " B2[index_a, j] = 1\n", - " B2[index_c, j] = -1\n", - " B2[index_b, j] = 1\n", - "\n", - " return B2" + "sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True)\n", + "sc.sc_simplices()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the incidence matrices" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "YJXKhf4y-tgV" - }, + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.],\n", + " [-1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sc.triangle_incidence_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "incidence matrix:\n", + "node-to-edge incidence matrix:\n", " [[-1. -1. -1. 0. 0. 0.]\n", " [ 1. 0. 0. -1. 0. 0.]\n", " [ 0. 1. 0. 1. -1. 0.]\n", " [ 0. 0. 1. 0. 0. -1.]\n", " [ 0. 0. 0. 0. 1. 1.]]\n", - "\n", - "\n", - "edge triangle incidence matrix:\n", + "edge-to-triangle incidence matrix:\n", " [[ 1.]\n", " [-1.]\n", " [ 0.]\n", @@ -339,23 +357,20 @@ } ], "source": [ - "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", - "edge_triangle_incidence_matrix = triangles_to_B2(triangles, list(G.edges))\n", - "print('incidence matrix:\\n', incidence_matrix)\n", - "print('\\n')\n", - "print('edge triangle incidence matrix:\\n', edge_triangle_incidence_matrix)\n" + "print('node-to-edge incidence matrix:\\n', sc.incidence_matrices[0])\n", + "print('edge-to-triangle incidence matrix:\\n', sc.incidence_matrices[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Define the Simplicial 2-Complex " + "Check the computed Laplacians" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -391,7 +406,6 @@ } ], "source": [ - "sc = GraphEdge(incidence_matrix, edge_triangle_incidence_matrix)\n", "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", "print('\\n')\n", "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", @@ -420,13 +434,77 @@ "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "kernel = MaternGeometricKernel(sc)" + "use_hodge_composition=True\n", + "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the eigenbasis and their types being either gradient, curl or harmonic" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "eval: 0.00\n", + "evec: [0.17 0.35 -0.52 0.17 0.52 -0.52]\n", + "type: harmonic\n", + "\n", + "eval: 1.38\n", + "evec: [0.37 -0.00 -0.60 -0.37 -0.60 -0.00]\n", + "type: gradient\n", + "\n", + "eval: 2.38\n", + "evec: [0.24 0.48 -0.15 0.24 0.15 0.78]\n", + "type: gradient\n", + "\n", + "eval: 3.00\n", + "evec: [0.58 -0.58 -0.00 0.58 0.00 0.00]\n", + "type: curl\n", + "\n", + "eval: 3.62\n", + "evec: [0.60 -0.00 0.37 -0.60 0.37 -0.00]\n", + "type: gradient\n", + "\n", + "eval: 4.62\n", + "evec: [0.28 0.56 0.45 0.28 -0.45 -0.35]\n", + "type: gradient\n", + "\n" + ] + } + ], + "source": [ + "for entry in sc.hodge_eigenbasis.values():\n", + " if 'eval' in entry:\n", + " print(f\"eval: {entry['eval']:.2f}\")\n", + " if 'evec' in entry:\n", + " formatted_evec = np.array2string(entry['evec'], formatter={'float_kind': lambda x: f\"{x:.2f}\"})\n", + " print(f\"evec: {formatted_evec}\")\n", + " if 'type' in entry:\n", + " print(f\"type: {entry['type']}\")\n", + " \n", + " print() " ] }, { @@ -444,14 +522,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + "params: {'harmonic': {'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'nu': array([inf]), 'lengthscale': array([1.])}}\n" ] } ], @@ -471,18 +549,36 @@ "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: for the Hodge-compositional kernel, we need to specify the parameters for each Hodge subspace. " + ] + }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "params[\"lengthscale\"] = np.array([2.0])\n", - "params_32 = params.copy()\n", - "params_inf = params.copy()\n", - "del params\n", - "params_32[\"nu\"] = np.array([3/2])\n", - "params_inf[\"nu\"] = np.array([np.inf])" + "import copy\n", + "\n", + "if use_hodge_composition:\n", + " params[\"harmonic\"][\"lengthscale\"], params[\"gradient\"][\"lengthscale\"], params[\"curl\"][\"lengthscale\"] = np.array([0.5]), np.array([2.0]), np.array([1.0])\n", + " params_hodge_1 = copy.deepcopy(params)\n", + " params_hodge_2 = copy.deepcopy(params)\n", + " del params\n", + " params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = np.array([3/2]), np.array([3/2]), np.array([3/2])\n", + " params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = np.array([np.inf]), np.array([np.inf]), np.array([np.inf])\n", + "\n", + "else:\n", + " params[\"lengthscale\"] = np.array([2.0])\n", + " params_32 = params.copy()\n", + " params_inf = params.copy()\n", + " del params\n", + " params_32[\"nu\"] = np.array([3/2])\n", + " params_inf[\"nu\"] = np.array([np.inf])" ] }, { @@ -492,6 +588,49 @@ "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check the eigenvalues of the kernels" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eigenvalues for the first set of parameters:\n", + "{'harmonic': array([[0.02405626]]), 'gradient': array([[0.32123998],\n", + " [0.18041575],\n", + " [0.10953956],\n", + " [0.0804039 ]]), 'curl': array([[0.06804138]])}\n", + "\n", + "Eigenvalues for the second set of parameters:\n", + "{'harmonic': array([[1.]]), 'gradient': array([[6.30433923e-02],\n", + " [8.53199536e-03],\n", + " [7.20137798e-04],\n", + " [9.74600529e-05]]), 'curl': array([[0.22313016]])}\n" + ] + } + ], + "source": [ + "if use_hodge_composition:\n", + " # Evaluate the eigenvalues for the first set of parameters\n", + " eigenvalues_hodge_1 = kernel.eigenvalues(params_hodge_1, normalize=False)\n", + " # Evaluate the eigenvalues for the second set of parameters\n", + " eigenvalues_hodge_2 = kernel.eigenvalues(params_hodge_2, normalize=False)\n", + " # Print the results\n", + " print(\"Eigenvalues for the first set of parameters:\")\n", + " print(eigenvalues_hodge_1)\n", + " print(\"\\nEigenvalues for the second set of parameters:\")\n", + " print(eigenvalues_hodge_2)\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -509,7 +648,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -539,12 +678,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + "if use_hodge_composition:\n", + " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs, normalize=False)\n", + " kernel_mat_inf = kernel.K(params_hodge_2, xs, xs, normalize=False)\n", + "else:\n", + " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + " kernel_mat_inf = kernel.K(params_inf, xs, xs)" ] }, { @@ -556,12 +699,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAEJCAYAAABcycfyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAamElEQVR4nO3da2wU573H8d+sie1wzNo4gB2owccl5XIIl9jFck8LNDjYgJKQQAKUi7FceBE5vZg2N1XAEaJA4iJyQUW0QNrUnKCStidC1IhAXBpqxRRKFAhBKkmLC1pf5IC52+zMeUHY1GDDzNrr3cf5fqJHqmefmXn2xaa//J9n5rEcx3EEAABgCF+0BwAAAOAF4QUAABiF8AIAAIxCeAEAAEYhvAAAAKMQXgAAgFEILwAAwCiEFwAAYBTCCwAAMArhJQasWLFClmWpsbEx2kMB0A264jdfVVUly7JUVVUV1vl1dXWaNWuW7rnnHlmWpfXr14c9FqC7EV56iDNnzmj+/PkaNmyY+vTpo5SUFI0fP16/+tWvdPMOEL/73e80e/ZsZWVlqXfv3ho2bJiWLl2qs2fPRmfwALrdD3/4Q+3evVvPP/+83njjDRUWFkZ7SIBrvaI9AHSNxsZG/etf/9KsWbM0ePBgtba2as+ePVq0aJFOnDihn/70p6G+S5Ys0cCBAzV//nwNHjxYH374oV577TXt2rVLhw8f1t133x3FbwLAjQkTJujy5cuKj48P6/x9+/bp0Ucf1Y9+9KMuHhkQeYSXHmL06NG3lI9LS0v18MMP65VXXtHKlSsVFxcnSdqxY4cmTZrUpm92draKiopUUVGh7373u900agDh8vl8SkxMDPv8+vp6paSkdN2AgG7EtFGM+uc//6mhQ4dq1KhRqqurC/s6mZmZunTpklpaWkLHbg4ukvTYY49Jko4fPx72vQCEz+tvvr01L5MmTdKoUaP00Ucf6dvf/rZ69+6tQYMG6cUXXwz1ef3112VZlhzH0YYNG2RZlizLisRXQgRcuXJFzc3NntqVK1eiPewuR+UlBp08eVIPPvigUlNTtWfPHvXr18/1uZcvX9bFixd14cIF/elPf9LWrVuVl5d3x6mgQCAgSZ7uBaBrdOY3f7PPPvtMhYWFevzxx/Xkk09qx44devbZZ3X//fdr6tSpmjBhgt544w0tWLBADz30kBYuXNiF3wSRdOXKFf3nkCQF6oOezktPT9enn37aqUpdrCG8xJiPP/5YkydP1qBBg7R792717dvX0/kvv/yynn/++dDfkydP1tatW+943tq1axUXF6dZs2Z5HjOA8HX2N3+zM2fO6Ne//rUWLFggSSopKdGQIUO0efNmTZ06VVlZWcrKytKCBQv0ta99TfPnz++Kr4Fu0NLSokB9UJ8eGiJ/H3cTJ83nbf1n9j/V0tJCeEFkHD16VLNnz9bQoUP1xz/+UX6/3/M15s6dq5ycHDU0NGjnzp2qq6vT5cuXb3vOtm3btHnzZj3zzDO67777wh0+AI+64jd/s6SkpDaBJD4+XuPHj9cnn3zS6WsjNvxH0vXmRtC5cx8TseYlhjz88MPq06ePdu/eHfa/xIYMGaL8/HzNnTtXFRUVysrKUn5+focB5s9//rNKSkpUUFCgVatWdWb4ADzqit/8zb7yla/csoalb9+++uyzz7rk+og+W46n1hMRXmLIzJkzdfLkSVVUVHTZNWfNmqXa2lrt37//ls8++OADPfLIIxo1apR27NihXr0oxAHdKRK/+RtPFd7s5vc9wVy2x396Iv7fKoa89NJL6tWrl5566in16dNH3/nOdzp9zRsVl3PnzrU5fvLkSRUWFmrAgAHatWuXkpJc1iABdJlI/ObR8wUdR0GXYdRtP9MQXmKIZVnatGmTzp8/r6KiIiUlJemRRx5xdW5DQ4P69+9/y/HNmzfLsiw98MADoWOBQEBTpkyRz+fT7t272z0PQOR15jePLy8v00E9ddqI8BJjfD6ffvOb32jGjBl68skntWvXLj344IN3PG/VqlU6cOCACgsLNXjwYDU1Nemtt97SwYMH9fTTT2vo0KGhvoWFhfrkk0/0zDPP6L333tN7770X+iwtLU0PPfRQRL4bgFuF+5vHl5ctR0HCC2LNXXfdpR07dmjq1Kl69NFH9c477yg3N/e250yfPl0nT57Uli1b1NDQoMTERI0ePVpbt25VUVFRm74ffPCBJLV5cdUNEydOJLwA3Syc3zy+vFodW60uM0mr0zPXvFgOq7gAAIh5zc3NSk5O1sfH09TH5Xtezp+3NXxEnc6dO9dlT7TFAiovAAAYJOhh2shtP9MQXmLc5cuXb3lS6Gapqalh7ywLILbwm8edBB33L5/rqS+pI7zEuO3bt6u4uPi2fd599912N1sEYB5+87gT+/Pmtm9PRHiJcQUFBdqzZ89t+4wZM6abRgMg0vjN405sWQrK3U7gtst+piG8xLh7771X9957b7SHAaCb8JvHndjO9ea2b09EeAEAwCBBD5UXt/1MQ3gBAMAghBcP4eW//m95JMdhrgMp0R5BTLLzbv+0xJfZ8cdWRHsIrgz55a0vMYR0z/v8N197fI83RnsIMeuvU3/apdezHUu243LNi8t+puFXCACAQai8EF4AADBKUD4F5e4Nu8EIjyVaCC8AABjE8TBt5DBtBAAAoo1pI8ILAABGCTo+BR2X00a85wUAAERbq3xqVZzLvj0T4QUAAIN4q7z0zNIL4QUAAIPYslzvWcTeRgAAIOpsD49K26LyAgAAooxpI8ILAABGseWTTeUFAACYIuhYCrp8+ZzbfqZxF90AAEBMuLE9gNsWjg0bNigzM1OJiYnKzc1VTU1Nh31/8Ytf6Fvf+pb69u2rvn37Kj8//7b9uwLhBQAAg9iOz1Pzavv27SorK9Py5ct1+PBhjRkzRgUFBaqvr2+3f1VVlebOnat3331X1dXVysjI0JQpU3T69OnOftUOEV4AADBIpCsv69at0+LFi1VcXKyRI0dq48aN6t27t7Zs2dJu/4qKCj311FMaO3ashg8frl/+8peybVt79+7t7FftEOEFAACD2Ppi3cudmv35Oc3NzW3a1atX2712S0uLDh06pPz8/NAxn8+n/Px8VVdXuxrfpUuX1NraqtTU1E5+044RXgAAMMiNp43cNknKyMhQcnJyqK1evbrdazc2NioYDCotLa3N8bS0NAUCAVfje/bZZzVw4MA2Aair8bQRAAAG8fael+v9amtr5ff7Q8cTEhIiMrY1a9bozTffVFVVlRITEyNyD4nwAgCAUcLZHsDv97cJLx3p16+f4uLiVFdX1+Z4XV2d0tPTb3tueXm51qxZo3feeUejR492Nb5wMW0EAIBBWpxenpoX8fHxys7ObrPY9sbi27y8vA7Pe/HFF7Vy5UpVVlYqJycn7O/mFpUXAAAMYjuWbJcvn3Pb79+VlZWpqKhIOTk5Gj9+vNavX6+LFy+quLhYkrRw4UINGjQotG5m7dq1WrZsmbZt26bMzMzQ2pikpCQlJSV5vr8bhBcAAAzibWNG7xMss2fPVkNDg5YtW6ZAIKCxY8eqsrIytIj31KlT8vm+uO7Pf/5ztbS0aNasWW2us3z5cq1YscLz/d0gvAAAYBAvL58L5yV1klRaWqrS0tJ2P6uqqmrz9z/+8Y+w7tEZhBcAAAwSlKWgywW7bvuZhvACAIBBuqPyEusILwAAGCQo9xWVYGSHEjWEFwAADELlhfACAIBRwnnDbk9DeAEAwCCOhzfsOizYBQAA0UblhfACAIBRIv2GXRMQXgAAMEjQwxt23fYzDeEFAACDUHkhvAAAYBRbPtd7FoWzt5EJCC8AABgk6FgKuqyouO1nGsILAAAGCdpxumbHuexrR3g00UF4AQDAIGzMSHgBAMAotuN+Ia7tRHgwUUJ4AQDAIOxtRHgBAMAotoftAdz2Mw3hBQAAg/C0EeEFAACjMG1EeAEAwCi2PLxhl2kjAAAQbY6HNS8O4QUAAEQbexsRXgAAMAprXggvAAAYhcoL4QUAAKPwnhfCCwAARqHyQngBAMAo12yfLNvdWpZrLvuZhvACAIBBqLwQXgAAMIoj92tZeuim0oQXAABMQuWF8AIAgFEIL4QXAACMQnghvAAAYBTCC+EFAACjOI4lx2UocdvPNIQXAAAMwht2pZ759hoAAHqoG9NGbls4NmzYoMzMTCUmJio3N1c1NTUd9j127JhmzpypzMxMWZal9evXh/nN3CO8AABgkBvTRm6bV9u3b1dZWZmWL1+uw4cPa8yYMSooKFB9fX27/S9duqSsrCytWbNG6enpnf16rhBeAAAwSKQrL+vWrdPixYtVXFyskSNHauPGjerdu7e2bNnSbv+vf/3reumllzRnzhwlJCR09uu5QngBAMAg4VRempub27SrV6+2e+2WlhYdOnRI+fn5oWM+n0/5+fmqrq7ulu/nBuEFAACDOB6qLjfCS0ZGhpKTk0Nt9erV7V67sbFRwWBQaWlpbY6npaUpEAhE/Lu5xdNGAAAYxJHkuNy06Ea32tpa+f3+0PHumt6JFMILAAAGsWXJ8viotN/vbxNeOtKvXz/FxcWprq6uzfG6urpuW4zrBtNGAAAYJGj7PDUv4uPjlZ2drb1794aO2batvXv3Ki8vr6u/StiovAAAYBDH8TBt5LLfvysrK1NRUZFycnI0fvx4rV+/XhcvXlRxcbEkaeHChRo0aFBo3UxLS4s++uij0P8+ffq0jhw5oqSkJA0dOtT7AFwgvAAAYJBIbw8we/ZsNTQ0aNmyZQoEAho7dqwqKytDi3hPnToln++Lis6ZM2c0bty40N/l5eUqLy/XxIkTVVVV5fn+bhBeAAAwSHfsbVRaWqrS0tJ2P7s5kGRmZsoJp8TTCe7Dy4GUyI3CYBufei3aQ4hJ/zOvONpDiF2PRXsA7tzzPv9t057KFeXRHkJMmpfx39EeQuyyu/hyjiWLXaUBAIApIr3mxQSEFwAADHI9vLidNorwYKKE8AIAgEG6Y81LrCO8AABgEEdfvDnXTd+eiPACAIBBqLwQXgAAMAulF8ILAABG8VB5EZUXAAAQbTwqTXgBAMAorHkhvAAAYBTHtuTYLsOLy36mIbwAAGASFuwSXgAAMAnTRoQXAADM00MrKm4RXgAAMAiVF8ILAABmYc0L4QUAALNYnze3fXsewgsAACah8kJ4AQDAKIQXwgsAAEZxLPd7FrFgFwAARBt7GxFeAAAwC9NGhBcAAIzCtBHhBQAAk1jO9ea2b09EeAEAwCRMGxFeAAAwCtNGhBcAAIxif97c9u2BCC8AAJiEaSPCCwAARmHaiPACAIBJeNqI8AIAgFmYNpIv2gMAAADwgsoLAAAGseRh2iiiI4kewgsAACZhwS7TRgAAGMXx2MKwYcMGZWZmKjExUbm5uaqpqblt/9/+9rcaPny4EhMTdf/992vXrl3h3dglwgsAACaJcHjZvn27ysrKtHz5ch0+fFhjxoxRQUGB6uvr2+3/l7/8RXPnzlVJSYn+9re/acaMGZoxY4aOHj0azrdzhfACAIBBbjwq7bZ5tW7dOi1evFjFxcUaOXKkNm7cqN69e2vLli3t9n/55ZdVWFioH//4xxoxYoRWrlypBx54QK+99lonv2nHCC8AAJgkjMpLc3Nzm3b16tV2L93S0qJDhw4pPz8/dMzn8yk/P1/V1dXtnlNdXd2mvyQVFBR02L8rEF4AADBJGOElIyNDycnJobZ69ep2L93Y2KhgMKi0tLQ2x9PS0hQIBNo9JxAIeOrfFXjaCAAAg4Tzht3a2lr5/f7Q8YSEhAiMrPsQXgAAMIltXW9u+0ry+/1twktH+vXrp7i4ONXV1bU5XldXp/T09HbPSU9P99S/KzBtBACAQSK5YDc+Pl7Z2dnau3dv6Jht29q7d6/y8vLaPScvL69Nf0nas2dPh/27ApUXAABMEuG9jcrKylRUVKScnByNHz9e69ev18WLF1VcXCxJWrhwoQYNGhRaN/P9739fEydO1M9+9jNNnz5db775pv76179q06ZN3m/uEuEFAACTeKmohBFeZs+erYaGBi1btkyBQEBjx45VZWVlaFHuqVOn5PN9MXHzjW98Q9u2bdNPfvITvfDCC7rvvvv0hz/8QaNGjfJ+c5cILwAAmKQbdpUuLS1VaWlpu59VVVXdcuyJJ57QE088Ed7NwkB4AQDAJN0QXmId4QUAAIOE86h0T8PTRgAAwChUXgAAMAnTRoQXAABMwrQR4QUAAPP00FDiFuEFAACTMG1EeAEAwCRMGxFeAAAwC5UXwgsAACah8kJ4AQDALFReCC8AAJjEsq83t317IsILAAAmofJCeAEAwCiEF8ILAAAmYcEu4QUAALNQeSG8AABgEiovhBcAAMxC5YXwAgCAUQgvhBcAAExifd7c9u2JCC8AAJiEygvhBQAAk7Bgl/ACAIBZqLwQXgAAME4PDSVuEV4AADAI00aEFwAAzMK0kfvwYuedi+Q4jPU/84qjPYSY9PL//jzaQ4hhP4n2AFzxPd4Y7SHEpHkZ/x3tIcSk3WeORHsIXxqWfb257dsTUXkBAMAgTBsRXgAAMAvTRoQXAACMQnghvAAAYBKmjQgvAACYhcoL4QUAAJNYjiPLcZdK3PYzDeEFAACTUHmRL9oDAAAA7t1Y8+K2RUpTU5PmzZsnv9+vlJQUlZSU6MKFC7c9Z9OmTZo0aZL8fr8sy9LZs2fDujfhBQAAkzgeW4TMmzdPx44d0549e7Rz507t379fS5Ysue05ly5dUmFhoV544YVO3ZtpIwAADBILTxsdP35clZWVOnjwoHJyciRJr776qqZNm6by8nINHDiw3fN+8IMfSJKqqqo6dX8qLwAAmCQGKi/V1dVKSUkJBRdJys/Pl8/n0/vvvx+Zm/4bKi8AABgknMpLc3Nzm+MJCQlKSEgIewyBQEADBgxoc6xXr15KTU1VIBAI+7puUXkBAMAkYVReMjIylJycHGqrV69u99LPPfecLMu6bfv4448j/Q3viMoLAACG8bqWpba2Vn6/P/R3R1WXpUuXatGiRbe9VlZWltLT01VfX9/m+LVr19TU1KT09HRvgwsD4QUAAINYtiPLdvmSus/7+f3+NuGlI/3791f//v3v2C8vL09nz57VoUOHlJ2dLUnat2+fbNtWbm6uq7F1BtNGAACYJAYW7I4YMUKFhYVavHixampqdODAAZWWlmrOnDmhJ41Onz6t4cOHq6amJnReIBDQkSNH9Pe//12S9OGHH+rIkSNqamrydH/CCwAABrFsby1SKioqNHz4cE2ePFnTpk3TN7/5TW3atCn0eWtrq06cOKFLly6Fjm3cuFHjxo3T4sWLJUkTJkzQuHHj9Pbbb3u6N9NGAACYJEa2B0hNTdW2bds6/DwzM1POTXsrrVixQitWrOj0vQkvAAAYJBZeUhdthBcAAEziONeb2749EOEFAACDUHkhvAAAYJYYWfMSTYQXAAAMQuWF8AIAgFlY80J4AQDAJFReCC8AAJiFNS+EFwAATELlhfACAIBZbOd6c9u3ByK8AABgEMtxv2cRlRcAABB9PG1EeAEAwCSseSG8AABgFp42IrwAAGASy3FkuZwOctvPNIQXAABMYn/e3PbtgQgvAAAYhMoL4QUAALOw5oXwAgCAUXhUmvACAIBJeFSa8AIAgFmovBBeAAAwiWV72B6Ap40AAEDUUXkhvAAAYBSeNiK8AABgEt7zQngBAMAsTBsRXgAAMIllO7KCLisvNuEFAABEmyMPlZeIjiRqCC8AAJiEaSPCCwAARrElWR769kCEFwAADMLTRoQXAADMwrQR4QUAAKMQXggvAAAYhfBCeAEAwCgs2JUv2gMAAADu3Viw67ZFSlNTk+bNmye/36+UlBSVlJTowoULt+3/9NNPa9iwYbr77rs1ePBgfe9739O5c+c835vwAgCASW5MG7ltETJv3jwdO3ZMe/bs0c6dO7V//34tWbKkw/5nzpzRmTNnVF5erqNHj+r1119XZWWlSkpKPN+baSMAAExiO5LlMpREaHuA48ePq7KyUgcPHlROTo4k6dVXX9W0adNUXl6ugQMH3nLOqFGj9NZbb4X+/upXv6pVq1Zp/vz5unbtmnr1ch9JqLwAAGCSMCovzc3NbdrVq1c7NYTq6mqlpKSEgosk5efny+fz6f3333d9nXPnzsnv93sKLhLhBQAAw3gJLtfDS0ZGhpKTk0Nt9erVnRpBIBDQgAED2hzr1auXUlNTFQgEXF2jsbFRK1euvO1UU0eYNgIAwCRhPCpdW1srv98fOpyQkNBu9+eee05r16697SWPHz/u7t630dzcrOnTp2vkyJFasWKF5/MJLwAAmCQYlJygu7729X5+v79NeOnI0qVLtWjRotv2ycrKUnp6uurr69scv3btmpqampSenn7b88+fP6/CwkL16dNHv//973XXXXfdcVw3I7wAAGCSCL6krn///urfv/8d++Xl5ens2bM6dOiQsrOzJUn79u2TbdvKzc3t8Lzm5mYVFBQoISFBb7/9thITEz2N7wbWvAAAYBLb8dYiYMSIESosLNTixYtVU1OjAwcOqLS0VHPmzAk9aXT69GkNHz5cNTU1kq4HlylTpujixYvavHmzmpubFQgEFAgEFAy6rCR9jsoLAAAmiZHtASoqKlRaWqrJkyfL5/Np5syZeuWVV0Kft7a26sSJE7p06ZIk6fDhw6EnkYYOHdrmWp9++qkyMzNd35vwAgCASRx5CC+RG0Zqaqq2bdvW4eeZmZly/m2ckyZNavN3ZxBeAAAwSYxUXqKJ8AIAgElsW653XLR75s6MhBcAAExC5YXwAgCAUQgvhBcAAIxif/Haf3d9ex7L6aqlvwAAIGKam5uVnJysyX2L1MsX7+qca3aL9n72q9AGiD0FlRcAAEzieHj5XA+tTxBeAAAwieNh2ojwAgAAos62JcvlI9AOj0oDAIBoo/JCeAEAwCROMCjHcreRoeN42/DQFIQXAABMYjuSReUFAACYwnHkensAwgsAAIg2x3bkuKy89NRXuRFeAAAwieNhY0aeNgIAANFG5YXwAgCAUa45V11XVK6pNcKjiQ7CCwAABoiPj1d6erreC+zydF56erri493thWQKNmYEAMAQV65cUUtLi6dz4uPjlZiYGKERRQfhBQAAGMUX7QEAAAB4QXgBAABGIbwAAACjEF4AAIBRCC8AAMAohBcAAGAUwgsAADDK/wO5OGt5a9RvIwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -598,6 +741,31 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[ 0.50937497, -0.05318978, 0.15397211],\n", + " [-0.05318978, 0.44513908, -0.22424068],\n", + " [ 0.15397211, -0.22424068, 0.49229617]]),\n", + " array([[ 0.49452715, -0.0689119 , 0.28746792],\n", + " [-0.0689119 , 0.34449472, -0.25884074],\n", + " [ 0.28746792, -0.25884074, 0.59206623]]))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_mat_32, kernel_mat_inf" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -615,11 +783,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ - "base_edge = 1 # choosing a fixed edge for kernel visualization\n", + "base_edge = (1,2)\n", + "base_edge_idx = list(G.edges).index(base_edge)\n", "other_edges = np.arange(sc.num_edges)[:, None]\n", "edges = [e for e in G.edges()]" ] @@ -633,14 +802,18 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ - "values_32 = kernel.K(params_32, np.array([[base_edge]]),\n", - " other_edges).flatten()\n", - "values_inf = kernel.K(params_inf, np.array([[base_edge]]),\n", - " other_edges).flatten()" + "if use_hodge_composition:\n", + " values_32 = kernel.K(params_hodge_1, np.array([[base_edge_idx]]), other_edges).flatten()\n", + " values_inf = kernel.K(params_hodge_2, np.array([[base_edge_idx]]), other_edges).flatten()\n", + "else:\n", + " values_32 = kernel.K(params_32, np.array([[base_edge_idx]]),\n", + " other_edges).flatten()\n", + " values_inf = kernel.K(params_inf, np.array([[base_edge_idx]]),\n", + " other_edges).flatten()" ] }, { @@ -652,13 +825,17 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# Get prior variances k(*, *) for * in nodes:\n", - "variance_32 = kernel.K_diag(params_32, other_edges)\n", - "variance_inf = kernel.K_diag(params_inf, other_edges)" + "if use_hodge_composition:\n", + " variance_32 = kernel.K_diag(params_hodge_1, other_edges)\n", + " variance_inf = kernel.K_diag(params_hodge_2, other_edges)\n", + "else:\n", + " variance_32 = kernel.K_diag(params_32, other_edges)\n", + " variance_inf = kernel.K_diag(params_inf, other_edges)" ] }, { @@ -672,7 +849,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -685,7 +862,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -702,7 +879,7 @@ "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=variance_32,\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", "# shade the area of the triangle\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", @@ -712,20 +889,20 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=values_32,\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", " vmin=values_32.min(), vmax=values_32.max(), \n", " **options)\n", "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", "\n", "\n", "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=variance_inf,\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -734,15 +911,15 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=values_inf,\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", " vmin=values_inf.min(), vmax=values_inf.max(),\n", " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", "\n", "\n", "plt.show()" @@ -768,16 +945,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Variance in the edge (1,2) is 0.08,\n", - "Variance in the edge (1,3) is 0.13,\n", - "The average variance is 0.17.\n" + "Variance in the edge (1,2) is 0.51,\n", + "Variance in the edge (1,3) is 0.55,\n", + "The average variance is 0.50.\n" ] } ], @@ -823,7 +1000,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -851,7 +1028,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -863,29 +1040,43 @@ " [5]\n", " [4]]\n", "\n", - "emedding (shape = (3, 6)):\n", - "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 1.39200889e-01\n", - " -1.29344481e-01 5.15670639e-02]\n", - " [-4.21011953e-01 -5.75989046e-16 2.15110617e-01 7.76266537e-16\n", - " -1.59503941e-16 -6.37403964e-02]\n", - " [ 4.21011953e-01 -2.21501771e-01 4.10824721e-02 9.36873407e-17\n", - " 7.99392856e-02 -8.34372621e-02]]\n", + "harmonic emedding (shape = (3, 1)):\n", + "[[ 0.17407766]\n", + " [-0.52223297]\n", + " [ 0.52223297]]\n", + "gradient emedding (shape = (3, 4)):\n", + "[[-2.53358943e-01 1.23024295e-01 -2.39383702e-01 9.54375058e-02]\n", + " [-1.06600907e-15 3.98114982e-01 -2.95201183e-16 -1.17967245e-01]\n", + " [-4.09943381e-01 7.60331958e-02 1.47947264e-01 -1.54421128e-01]]\n", + "curl emedding (shape = (3, 1)):\n", + "[[5.77350269e-01]\n", + " [3.21964677e-15]\n", + " [3.88578059e-16]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.046035655711836e-17\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 8.355534721610419e-17\n" ] } ], "source": [ - "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", - "\n", "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", "print('')\n", - "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - "\n", - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", "\n", + "if use_hodge_composition:\n", + " _, harmonic_embedding = feature_map(xs, params_hodge_1['harmonic'], hodge_type='harmonic') \n", + " _, gradient_embedding = feature_map(xs, params_hodge_1['gradient'],hodge_type='gradient')\n", + " _, curl_embedding = feature_map(xs, params_hodge_1['curl'], hodge_type='curl')\n", + " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + " kernel_mat_32_alt = np.matmul(harmonic_embedding, harmonic_embedding.T) + np.matmul(gradient_embedding, gradient_embedding.T) + np.matmul(curl_embedding, curl_embedding.T) \n", + " print('harmonic emedding (shape = %s):\\n%s' % (harmonic_embedding.shape, harmonic_embedding))\n", + " print('gradient emedding (shape = %s):\\n%s' % (gradient_embedding.shape, gradient_embedding))\n", + " print('curl emedding (shape = %s):\\n%s' % (curl_embedding.shape, curl_embedding))\n", + "else:\n", + " # xs are random points from above\n", + " _, embedding = feature_map(xs, params_32, normalize=True)\n", + " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + " kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + " print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + " \n", "print('')\n", "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" ] @@ -911,7 +1102,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -919,9 +1110,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-0.00094174 0.18726061]\n", - " [-0.42678986 0.62902614]\n", - " [-0.24317193 -0.6577591 ]]\n" + "[[ 0.09012729 0.49207089]\n", + " [-0.53492781 1.23972299]\n", + " [-0.27116852 -0.17419733]]\n" ] } ], @@ -935,7 +1126,13 @@ "key = np.random.RandomState(seed=1234)\n", "\n", "# new random state is returned along with the samples\n", - "key, samples = sample_paths(xs, params_32, key=key)\n", + "if use_hodge_composition:\n", + " key, samples_harmonic = sample_paths(xs, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", + " key, samples_gradient = sample_paths(xs, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", + " key, samples_curl = sample_paths(xs, params_hodge_1['curl'], key=key, hodge_type='curl')\n", + " samples = samples_harmonic + samples_gradient + samples_curl\n", + "else:\n", + " key, samples = sample_paths(xs, params_32, key=key)\n", "\n", "print('Two samples evaluated at the xs are:')\n", "print(samples)" @@ -951,12 +1148,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/UAAAGeCAYAAADVFyFJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADQJ0lEQVR4nOzdd3xT5ffA8c9N0nS3jLbMtnQALWVvVAS0CIgDBQXBhYAKLsQJAg6mi+FAphuUn+BWUED0q7Jllb03LZTVQdu0yf39kTa0EEpH2ptx3q9XXqa39yYnmPSeJ/d5zlFUVVURQgghhBBCCCGEy9FpHYAQQgghhBBCCCHKRgb1QgghhBBCCCGEi5JBvRBCCCGEEEII4aJkUC+EEEIIIYQQQrgoGdQLIYQQQgghhBAuSgb1QgghhBBCCCGEi5JBvRBCCCGEEEII4aJkUC+EEEIIIYQQQrgoGdQLIYQQQgghhBAuSgb1QgghhBBCCCGEi5JBvRBCCCGEEEII4aI8alD/6aefoigKhw4d0jqUCmWxWBg/fjwxMTF4eXkRExPDW2+9RVxcHBaLpdhjZ86cSUREBDk5OSV+vvXr13Pdddfh7++Poihs3ry5nK/AMZzt//drr72Goihah1Em9t5Trqakn4HyyMjIQKfTMXXq1Ap7jvIoy+dbCFE2znYOqiiSc1g52/9vyTm0JTmH5ByVrUyD+qSkJPr06UNkZCQ+Pj7UqVOHrl278v777zs6PpeyZcsWFEVh9+7dAEydOpV69epdsV9GRgavvvoq3bt3p1q1aiiKwqeffuqwOGbMmMHYsWO5++67+fjjj5k6dSpvvvkmL730Ejpd8f/LH374YUwmE7NmzSrRc+Xm5nLPPfdw9uxZpk6dyhdffEFkZKQjXoZwIpe/p0r6/iitgwcP8uSTT9KgQQP8/Pzw8/OjUaNGPPHEE2zdurXIvgUJVMHNx8eHBg0a8OSTT5KSklJk37S0tKt+BnJycnjppZeoXbs2vr6+tGvXjmXLlpUp/m3btqGqKo0bNy7T8RWttJ9vIZyB5Bz2lTTnWL9+PU8++SQJCQn4+/sTERHBvffey549exwSh+QcwtEk5ygZyTlEEWop/fvvv6rRaFRjY2PVcePGqXPmzFHHjh2r3nLLLWpMTExpH65SffLJJyqgHjx4sEIef9asWWq1atVUi8Wiqqqq3nPPPWrfvn2v2O/gwYMqoEZERKidO3dWAfWTTz5xWBwtW7ZUb7nlFtvPU6dOVYOCgtSsrKwSHf/iiy+qkZGRttdRnJ07d6qAOmfOnDLHW1Hy8vLUrKysEr2OyvDqq6+qZfjIOYXL31MV4aefflL9/PzUoKAgdejQoerMmTPV2bNnqyNGjFDr1aunKoqiHjp0yLZ/wef5jTfeUL/44gt1zpw56kMPPaTqdDo1KipKzczMtO1b3GegX79+qsFgUJ9//nl11qxZaocOHVSDwaD+/fffpX4Ns2fPVgH15MmTZftHqASl+XwLoTXJOa6upDlH79691Zo1a6pPPfWUOmfOHHXcuHFqjRo1VH9/fzUpKanccUjOYSU5h+NIzlEyknOIwkr9ab/11lvV0NBQ9dy5c1f8LiUlxRExVZiKPsEOGjRI7d69u+3nunXrqlOmTLliv+zsbNsHcP369Q4d1GdlZal6vV4dP368bVvTpk3V+++/v8SPsWHDBhVQV6xYcc19//rrLxVQv/nmmzLFa09GRobDHsuZuOoJ1t57ytH27dun+vv7q/Hx8eqJEyeu+H1ubq46ffp09ciRI7ZtBZ/n9evXF9l3xIgRKqAuWLDAtu1qn4G1a9eqgPr222/btmVlZakxMTFqhw4dSv06nnrqKTUkJKTUx1Wm0ny+hdCa5BxXV9Kc499//1VzcnKKbNuzZ4/q7e2tDhgwoFwxSM7hvCTnuDrJOSqP5ByVp9TT7/fv309CQgJVqlS54ndhYWG2+4cPH2bYsGE0bNgQX19fqlevzj333HPFWqOCNT979uzh/vvvJzg4mNDQUMaMGYOqqhw9epQ777yToKAgatasybvvvmv3+F27dnHvvfcSFBRE9erVeeaZZ8jOzi7Razp+/DiPPPIINWrUwNvbm4SEBD7++OMSHXvu3DlSU1NJTU1l7dq1NG7cmNTUVLZv386xY8eoX78+qampZGRk2I7x9vamZs2aJXp8gF27dnHkyJFr7jdo0CB8fX0xm82MHj0aRVGoVasWW7duJTExscTP16pVK6pVq8YPP/xQ7H4PP/wwnTp1AuCee+5BURQ6d+5s+/2mTZvo0aMHQUFBBAQEcPPNN7NmzZoij1Hw/2/Hjh3079+fqlWrcsMNN5Q41uJcvr6t4Ln27dvHww8/TJUqVQgODmbgwIFcvHixRI9Z0vfKP//8Q5s2bfDx8SEmJqbYqUd//vknrVu3LrKvvbVwJX3u9PR0hg8fTr169fD29iYsLIyuXbuycePGEr3Gwuy9pzp06FDqx7mWt956i8zMTD755BNq1ap1xe8NBgNPP/004eHh13ysm266CbBOqyv479U+A4sWLUKv1/Poo4/atvn4+DBo0CBWr17N0aNHS/U6kpKSSEhIKLJtzpw5GI1Ghg8fjtlsLtXjVYSSfr6FcAaScxRVlpzjuuuuw2g0Fnmc+vXrk5CQwM6dO694Dsk5ykZyDsk5Cv4rOcclknNUHkNpD4iMjGT16tVs27at2DUc69evZ9WqVfTr14+6dety6NAhPvroIzp37syOHTvw8/Mrsn/fvn2Jj49n8uTJ/PLLL4wfP55q1aoxa9YsbrrpJt58803mz5/P888/T5s2bbjxxhuLHH/vvfdSr149Jk2axJo1a3jvvfc4d+4cn3/+ebGvJyUlhfbt26MoCk8++SShoaEsWbKEQYMGkZaWxvDhw4s9vkWLFhw+fNj287Zt23jnnXdsP99+++0APPTQQ2VeNx8fH0+nTp34888/i91vwIABeHl5MWvWLKZPn061atXYv38/r732Gi1btizVc7Zs2ZJ///232H0ee+wx6tSpw8SJE3n66adp06YNNWrUAGD79u107NiRoKAgXnzxRVtcnTt35q+//qJdu3ZFHuuee+6hfv36TJw4EVVVSxVrad17771ERUUxadIkNm7cyNy5cwkLC+PNN98s9riSvleSkpK45ZZbCA0N5bXXXiMvL49XX33V9m9T2KZNm+jevTu1atXi9ddfx2w288YbbxAaGlqm5wZ4/PHHWbRoEU8++SSNGjXizJkz/PPPP+zcubPU7wN776mKWL/4888/Exsbe8X7oiz2798PQPXq1QFYtWoVgN3XvmnTJho0aEBQUFCR7W3btgVg8+bNJTqpF0hKSuK+++4DIC8vj+HDhzN79mw+/PBDhgwZUvoXU0FK8vkWwhlIzlGUo3IOVVVJSUm5YkAAknM4muQcJSc5h+QcohxKe2n/999/V/V6varX69UOHTqoL774ovrbb7+pJpOpyH4XL1684tjVq1ergPr555/bthVMD3r00Udt2/Ly8tS6deuqiqKokydPtm0/d+6c6uvrqz700ENXHH/HHXcUea5hw4apgLplyxbbNntT4QYNGqTWqlVLTU1NLXJ8v3791ODgYLuvo7B//vlHXbZsmTpmzBjVYDCoS5YsUZctW6b26NFDbd26tbps2TJ12bJl6vbt2+0eX5Lp94DaqVOnYuMoMGrUKNXf3181m82qqqrq6NGjVUBNT08v0fEFHn30UdXX1/ea+61cudLuVLhevXqpRqNR3b9/v23biRMn1MDAQPXGG2+0bSv4/3ffffeVKr6SuPz/d8FzPfLII0X2u+uuu9Tq1atf8/FK+l7p1auX6uPjox4+fNi2z44dO1S9Xn/FVLjbb79d9fPzU48fP27btnfvXtVgMBTZtzTv0+DgYPWJJ5645uspqcvfU4524cIFFVB79ep1xe/OnTunnj592nYr/DoL/v8uX75cPX36tHr06FH166+/VqtXr676+vqqx44dU1W1+M9AQkKCetNNN12xffv27Sqgzpw5s8Sv48SJE7Zjzpw5o950001qtWrV1JUrV5b4MSpLST/fQmhNco6iyptzFPjiiy9UQJ03b94Vv5Oco2wk53AMyTlKRnIOcblST7/v2rUrq1ev5o477mDLli289dZbdOvWjTp16vDjjz/a9vP19bXdz83N5cyZM8TGxlKlShW7U3IGDx5su6/X62ndujWqqjJo0CDb9ipVqtCwYUMOHDhwxfFPPPFEkZ+feuopAH799dervhZVVVm8eDG33347qqraprSlpqbSrVs3Lly4cM3pQ9dffz2JiYlkZGTQpk0bunfvTmJiIkeOHOG2224jMTGRxMREGjVqVOzjFEdV1Wt+Y15g69atJCQk2KptnjlzBoPBQEBAwBX7rlmzBkVReO211674XdWqVcnKyirxFLHCzGYzv//+O7169SI6Otq2vVatWvTv359//vmHtLS0Isc8/vjjJXrs4mIuqcufq2PHjpw5c+aKmAor6XvFbDbz22+/0atXLyIiImzHx8fH061btyKPaTabWb58Ob169aJ27dq27bGxsfTo0aPUz12gSpUqrF27lhMnTpT536iwy99TV7Ny5UreeustZsyYwa5du674/apVqzh27NgV2wv+3e29Rzt37kxoaKjt9uGHH16xT2JiIqGhoYSHh9OvXz8CAgL47rvvqFOnDlD8ZyArKwtvb+8rtvv4+Nh+X1IFlXIVRaFNmzacOHGCtWvXFpke6izK8/kWojJJzlGUI3KOXbt28cQTT9ChQwceeughu3FKznHtmEtKco7SkZyjZCTnEJcr9fR7gDZt2vDtt99iMpnYsmUL3333HVOnTqVPnz5s3ryZRo0akZWVxaRJk/jkk084fvx4kelNFy5cuOIxC/8xAggODsbHx4eQkJArtp85c+aK4+vXr1/k55iYGHQ6XbH9Qk+fPs358+eZPXs2s2fPtrvPqVOnrnr8hQsXyM3NBWDFihXcdNNNpKamcvbsWbZv38748eNJTU3Fy8uL4ODgqz6OI23ZsuWKP+RlUfD/qyw9Tk+fPs3Fixdp2LDhFb+Lj4/HYrFw9OjRItP+oqKiyh5sKV3+XqtatSpgXat4+ZSoAiV9r5w+fZqsrKwr3o8ADRs2LJLwnTp1iqysLGJjY6/Yt/C20r5P33rrLR566CHCw8Np1aoVt956Kw8++GCRZKc0rvWeOn36NHfddRerVq0iLCyMs2fPkpubS8uWLenZsydhYWH8888/fPvtt+zYseOK4wMDAwGKrAEtMGvWLNLT00lJSeH++++3+/wffvghDRo0wGAwUKNGDRo2bHjNZKCAr6+v3f6pBWtjCw8UriUpKQmAJ598ktatW/Prr79esQ740Ucf5aeffiIzM5PIyEgmTpxomy5bYPPmzQwcOJAWLVqwfPlyzp8/T6NGjZg6darD1haW5/MtRGWTnMPKETlHcnIyPXv2JDg42La+tzwk57g2yTlKR3KOkpGcQ1yuTIP6AkajkTZt2tCmTRsaNGjAwIED+eabb3j11Vd56qmn+OSTTxg+fDgdOnQgODgYRVHo168fFovliseyd2K52smm8Mn6akryximI4/7777f7bTVA06ZNr3r8nXfeyV9//WX7eevWrUybNs3281133QVQorVpjnD+/HmOHj1KkyZNbNuqV69OXl4e6enptj9kBVq2bMnRo0ftnlTOnTuHn59fqf7AlEdJn6e4mEuqLO+rkr5X7L23y6u079N7772Xjh078t133/H777/z9ttv8+abb/Ltt98W+Ta+JOy9py63e/duIiMjWbBgAREREWRnZ7NkyRIWLFjAjBkzyMrK4oYbbuCvv/6ym0wEBwdTq1Yttm3bdsXvCta7FZcot23bltatW1/198V9BmrVqsXx48evOObkyZMARa5mXEtSUhKRkZHExMSwbds2MjIyrjjBjhgxgvfffx9vb2/Wr19PYmIiBw4csK3FA1i6dCmJiYkEBgbyzz//ULduXf7v//6P22+/nUOHDtn99r+0KvvzLYQjSM5RvpzjwoUL9OjRg/Pnz/P333+X6u+bPZJzlIzkHCUnOYfkHKLsyjWoL6zgDV7wxly0aBEPPfRQkcqx2dnZnD9/3lFPWcTevXuLfPO6b98+LBYL9erVu+oxoaGhBAYGYjabS1WptcC7777LuXPnWL16Na+//jo///wzBoOB999/n+PHjzN58mTg0reyFa1gKk7hP7ZxcXGAtRrn5cmC0Wikbt26dh/r4MGDxMfHlymO0NBQ/Pz82L179xW/27VrFzqdrlSFQAorLuaKVNL3itlsxtfXl717917xu8v/PcLCwvDx8WHfvn1X7Ft4W1nep7Vq1WLYsGEMGzaMU6dO0bJlSyZMmFDqE6y999Tl2rZtW6R6sI+PD3fddZctwSyJnj17MnfuXNatW2crGOMoxX0GmjdvzsqVK0lLSyuStK1du9b2+5JKSkqiefPmzJkzh9atW3PXXXfx999/26bVFY4FrIMAk8nE8ePHrzjBTp48mfbt29u29evXjxEjRrB7925atWp11RjmzZvHjz/+yA8//MCuXbu45557ePvtt+nevXuR/crz+RbCGUjOUbqcIzs7m9tvv509e/awfPnyci0JLCA5R8WRnENyjmuRnENcrtRr6leuXGn328WCKT4F05/0ev0V+73//vsV1l7h8nUv77//PkCxf1D0ej29e/dm8eLFdr+xO336dLHP2apVKxITE8nLy6Nx48a2tW0pKSm2dW2JiYnFfiBKoqTtZbZs2QIU/WNYMHVmw4YNpXrOjRs3ct1115XqmAJ6vZ5bbrmFH374oci3nSkpKSxYsIAbbrihXN96a6Gk7xW9Xk+3bt34/vvvi/w/27lzJ7/99tsVj5mYmMj3339fZC3avn37WLJkSamfG6wn+MunmoaFhVG7dm27U76uxd576nKXt0oqixdffBE/Pz8eeeQRUlJSrvh9Sa6UXU1xn4E+ffpgNpuLTDHMycnhk08+oV27diVOBM1mMzt37qRJkyaEhoby7bffsm3bNoYOHXrFvsOGDcPX15c2bdpw0003FbkikZ6ezu7du69IMvbu3cvZs2ftXnUoLCkpiaZNm7Jq1Sp69+7Np59+esXJFcr3+RaiMknOcUlZcw6z2Uzfvn1ZvXo133zzzTWn1ErOoT3JOSTnKI7kHMKeUl+pf+qpp7h48SJ33XUXcXFxmEwmVq1axcKFC6lXrx4DBw4E4LbbbuOLL74gODiYRo0asXr1apYvX17k2yFHOnjwIHfccQfdu3dn9erVfPnll/Tv359mzZoVe9zkyZNZuXIl7dq1Y8iQITRq1IizZ8+yceNGli9fztmzZ6/53P/++6/tzZqdnc2mTZsYNWpUscd88MEHnD9/3vaH9aeffrIV9HjqqaeKrIcraXuZrVu3UqdOHapVq2bbFh0dTePGjVm+fDmPPPLINV8LwH///cfZs2e58847S7S/PePHj2fZsmXccMMNDBs2DIPBwKxZs8jJyeGtt94q8+NqqaTvlddff52lS5fSsWNHhg0bRl5eHu+//z4JCQm2b6ELvPbaa/z+++9cf/31DB06FLPZzAcffEDjxo3ZvHlzqZ87PT2dunXr0qdPH5o1a0ZAQADLly9n/fr1Ra5gKYpS5vdURahfvz4LFizgvvvuo2HDhgwYMIBmzZqhqioHDx5kwYIF6HS6Ml0xKe4z0K5dO+655x5GjhzJqVOniI2N5bPPPuPQoUPMmzevyL7F/Zvt3buX7Oxs28myVatWfPTRRwwcOJBWrVrx5JNP2vadMWMG77//Pn/++Sfbtm0rMm13xYoVdOrUqcj6vKysLO6//35Gjhx5zdocSUlJ1KxZkzvvvJO1a9faXdPoiM+3EJVFco4rlTbneO655/jxxx+5/fbbOXv2LF9++WWR31++dlhyDucgOUfFkZzDSnION1PacvlLlixRH3nkETUuLk4NCAhQjUajGhsbqz711FNqSkqKbb9z586pAwcOVENCQtSAgAC1W7du6q5du9TIyEi77WFOnz5d5Hkeeugh1d/f/4rn79Spk5qQkHDF8Tt27FD79OmjBgYGqlWrVlWffPJJNSsrq8ix9trLqKqqpqSkqE888YQaHh6uenl5qTVr1lRvvvlmdfbs2df898jLy1MDAgLUL774QlVVa7sZQD116lSxx0VGRqqA3dvl8VHC9jJt27ZVe/ToccX2KVOmqAEBAddslVPgpZdeUiMiIlSLxXLNfa/WXkZVVXXjxo1qt27d1ICAANXPz0/t0qWLumrVqiL7XO3/vyNcrb3M5c91tfeFPSV9r/z1119qq1atVKPRqEZHR6szZ860Pf/lVqxYobZo0UI1Go1qTEyMOnfuXPW5555TfXx8Sv3cOTk56gsvvKA2a9ZMDQwMVP39/dVmzZqpM2bMsO2Tnp6uAmq/fv2u+Xqv9p6qKPv27VOHDh2qxsbGqj4+Pqqvr68aFxenPv744+rmzZuL7Fvw/239+vXXfNziPgNZWVnq888/r9asWVP19vZW27Rpoy5durTIPtf6N/u///s/FbiijdSwYcNULy8v9a+//rJ73G233ab+8ssvtp8fe+yxIu0tTSaT2rNnT7V///4l+jyGhoaqHTt2VIODg6/6nKX5fAuhNck5iipLztGpU6er5hv2zkmSc5SN5ByScxSQnOMSyTkqT6kH9c6mIv9Au4vz58+r1apVU+fOnXvNfbOzs9WaNWuq06ZNq4TIxNXceeedamxsbIU89i+//KIqiqJu3bq1Qh7fGZXmM2BPRf2bde/eXZ0+fbrt56ioKPXEiROqqqqq2WxW+/btq952221qbm7uNR8rOTlZ9fHxUbOzs9VRo0apiYmJV+wjn28hykdyjmuTnMP1SM7hWJJzWMnnu3KVek29cD3BwcG8+OKLvP3229eslPrJJ5/g5eVV4h6uovwu70u6d+9efv311wrrNbpy5Ur69etXbHVZd1Oaz4A9jvg3u3DhAgsWLCAjI4O8vDy++eYbVq5cyY033ghY17EGBQVRq1YtAB577DFOnjzJN998g8Fw5Uqphx9+mIcfftj2c1JSEvHx8Xh7ezN8+HBWrVrFmjVrihwjn28hREWTnMO5Sc5R8STnsJLPd+VSVLUc1SCcwGuvvcbrr7/O6dOnr+gvK4QrqFWrFg8//DDR0dEcPnyYjz76iJycHDZt2mS396xwTWlpadx5551s2rQJVVWJjY3llVde4e677wZg2rRpJCcnM3nyZA4fPky9evXw8fEp0g5pyZIldOzYEYDExET69u3LkCFDAJg6dSqbNm3i888/B+CZZ55h3759/PLLL5X8SoVwX5JzCFcnOYdnkJzD8zispZ0Qomy6d+/OV199RXJyMt7e3nTo0IGJEyfKydXNBAUFsXLlyqv+funSpbz88ssAREZGFlt9Ny8vjxMnThT51vzZZ58tss/06dPLF7AQQgi3IzmHZ5Ccw/O4/JV6IYRwB2+99RbPPvssXl5eWocihBBCCDcmOYf7kUG9EEIIIYQQQgjhoqRQnhBCCCGEEEII4aJkTb0QQogyy87OxmQylftxjEYjPj4+DohICCGEEO5Ico6rk0G9EEKIMsnOziYqMoDkU+ZyP1bNmjU5ePCg251khRBCCFF+knMUTwb1QgghysRkMpF8yszh/+oRFFj21Vxp6RYiWx3CZDK51QlWCCGEEI4hOUfxZFAvhBCiXAICFQIClTIfb6HsxwohhBDCc0jOYZ8M6oUQQpSLWbVgLkcfFbNqcVwwQgghhHBbknPYJ9XvhRBCuKQPP/yQevXq4ePjQ7t27Vi3bl2x+58/f54nnniCWrVq4e3tTYMGDfj1118rKVohhBBCuCpnzznkSr0QQohysaBioexfm5fl2IULFzJixAhmzpxJu3btmDZtGt26dWP37t2EhYVdsb/JZKJr166EhYWxaNEi6tSpw+HDh6lSpUqZ4xZCCCFE5ZKcwz5FVdVyTGAQQgjhqdLS0ggODubE7rrlLlpTu+ExLly4QFBQUImOadeuHW3atOGDDz4AwGKxEB4ezlNPPcXLL798xf4zZ87k7bffZteuXXh5eZU5ViGEEEJUPsk5iifT74UQQrgUk8nEf//9R2Jiom2bTqcjMTGR1atX2z3mxx9/pEOHDjzxxBPUqFGDxo0bM3HiRMzm8rfGEUIIIYR7cpWcQ6bfCyGEKBezqmIux6SvgmPT0tKKbPf29sbb2/uK/VNTUzGbzdSoUaPI9ho1arBr1y67z3HgwAH++OMPBgwYwK+//sq+ffsYNmwYubm5vPrqq2WOXQghhBCVR3IO++RKvRBCiHIpWN9WnhtAeHg4wcHBttukSZMcF6PFQlhYGLNnz6ZVq1b07duXV155hZkzZzrsOYQQQghRsSTnsE+u1AshhHAKR48eLbK+zd435gAhISHo9XpSUlKKbE9JSaFmzZp2j6lVqxZeXl7o9Xrbtvj4eJKTkzGZTBiNRge8AiGEEEK4AnfLOeRKvRBCiHKxoGIux63gW/OgoKAit6udYI1GI61atWLFihWXYrBYWLFiBR06dLB7zPXXX8++ffuwWC71p92zZw+1atWSAb0QQgjhIiTnsE8G9UIIIcrFUVPhSmPEiBHMmTOHzz77jJ07dzJ06FAyMzMZOHAgAA8++CAjR4607T906FDOnj3LM888w549e/jll1+YOHEiTzzxhMP+HYQQQghRsSTnsE+m3wshhCgXRxWtKY2+ffty+vRpxo4dS3JyMs2bN2fp0qW2QjZHjhxBp7v0vXV4eDi//fYbzz77LE2bNqVOnTo888wzvPTSS2WOWwghhBCVS3IO+6RPvRBCiDIp6Bm7Z2cNAsvRMzY93UKD+JRS9YwVQgghhOeQnKN4cqVeCCFEuVjyb+U5XgghhBDiWiTnsE8G9UIIIcqloPhMeY4XQgghhLgWyTnsk0J5QgghhBBCCCGEi5Ir9UIIIcrFrFpv5TleCCGEEOJaJOewz6UH9RkZGezbt4+cnBy8vb2JjY0lICBA67CEEMKjyPo24Qkk5xBCCO1JzmGfyw3qd+zYwcyZM1m2bBm7d++mcPF+RVFo2LAhXbt25fHHH6dRo0YaRiqEEEIIVyY5hxBCCFfgMmvqDx48SI8ePUhISGDhwoV06dKFefPmsWbNGrZu3cqaNWuYN28eXbp0YeHChSQkJNCjRw8OHjyodehCCOHWLCiYy3GzoGj9EoQoQnIOIYRwTpJz2OcSfernzp3L8OHDCQkJYeLEifTp0wej0XjV/U0mE4sWLWLkyJGcOXOGadOmMXjw4EqMWAgh3F9Bz9gN22sQUI6esRnpFlonuF/PWOGaJOcQQgjnIzlH8Zz+Sv2ECRMYMmQI9913H0lJSfTv37/YkyuA0Wikf//+bNu2jfvuu48hQ4YwYcKESopYCCGEEK5Icg4hhBCuyKnX1M+dO5fRo0czbtw4Ro8eXerjAwMDmTNnDhEREYwePZqaNWsyaNCgCohUCCE8V8GUtvIcL4TWJOcQQgjnJzmHfU57pf7gwYMMHz6cwYMHX3FyXb9+PU8++SQJCQn4+/sTERHBvffey549e+w+1ujRoxk8eDDPPPOMrHcTQggHK8/atvKenIVwBMk5hBDCNUjOYZ/Trqnv0aMHO3fuJCkpicDAwCK/69OnD//++y/33HMPTZs2JTk5mQ8++ICMjAzWrFlD48aNr3i8tLQ0mjRpQqNGjViyZEllvQwhhHBbBevb/tlWu9zr225ofMLt1rcJ1yE5hxBCODfJOYrnlIP6HTt2kJCQwPz58+nfv/8Vv1+1ahWtW7cuss5t7969NGnShD59+vDll1/afdwFCxYwYMAAduzYQXx8fIXFL4QQnkBOsMIdSM4hhBDOT3KO4jnl9PuZM2cSFhZGnz597P7+uuuuu6JwTf369UlISGDnzp1XfdzevXsTFhbGRx995NB4hRDCk8lUOOHKJOcQQgjXITmHfU5ZKG/ZsmX07t37mhVnC1NVlZSUFBISEq66j7e3N71792b58uWOCFMIIQRgRoe5HN8Rmx0YixClJTmHEEK4Dsk57HO6K/Xp6ens3r2bNm3alOq4+fPnc/z4cfr27Vvsfq1bt2bXrl1kZGSUJ0whhBBCuDjJOYQQQrgDpxvU79+/H1VVadSoUYmP2bVrF0888QQdOnTgoYceKnbfhIQEVFVl37595Q1VCCEEoKoKlnLcVNU9p8IJ5yc5hxBCuBbJOexzuun3OTk5APj5+ZVo/+TkZHr27ElwcDCLFi1Cr9cXu7+vr2+R5xFCCFE+0jNWuCrJOYQQwrVIzmGf0w3qvb29Abh48eI1971w4QI9evTg/Pnz/P3339SuXfuax2RlZRV5HiGEEEJ4Jsk5hBBCuAOnm34fGxuLoijs2LGj2P2ys7O5/fbb2bNnDz///HOJp85t374dRVGIjY11RLhCCOHxzKqu3DchtCA5hxBCuBbJOexzulcVEBBAw4YNWb9+/VX3MZvN9O3bl9WrV/PNN9/QoUOHEj/+hg0biIuLIyAgwBHhCiGEx7OgYEFXjpt7ToUTzk9yDiGEcC2Sc9jndNPvAbp27crChQuZNm2a3RYzzz33HD/++CO33347Z8+e5csvvyzy+/vvv9/u4+bk5LB48eJrVqsVQghRcrK+TbgyyTmEEMJ1SM5hn6Kqqqp1EJfbsWMHCQkJzJ8/n/79+1/x+86dO/PXX39d9firvaQFCxYwYMAAduzYQXx8vMPiFUIIT5SWlkZwcDA/bo3BP7D4gmHFyUw3c0fT/Vy4cIGgoCAHRijEtUnOIYQQzk9yjuI55aAeoEePHuzcuZOkpCQCAwPL/XhpaWk0adKERo0asWTJEgdEKIQQnq3gBPvdlvrlPsHe1Wyv251gheuQnEMIIZyb5BzFc7o19QVmzJhBamoqI0aMKPdjqarKiBEjOHPmDDNmzHBAdEIIIQpY17eV7yaEliTnEEII1yA5h31OO6iPiopi2rRpzJ07l/Hjx5f5cVRVZfz48cybN4/GDz9ASJ1rt6ARQgghhOeoiJyjyVO9CK4d6sAohRBCCPucslBegcGDB5OSksLo0aM5fPgwU6ZMKdW0uLS0NEaMGMG8efMI7dmdlLgY7vl2IZ/dfjc1/KUSrRBCOIIFHeZyfEdswSlXgQkP48icI2JAJ3I7RvLw6ll80OYhIvxDKjByIYTwHJJz2Oe0V+oLvPLKK8yZM4evvvqKxo0bs2DBAkwmU7HH5OTksGDBApo0acLXX3/NC+PeoMFtPfC3qOxOPcXdixaw9+yZSnoFQgjh3qRnrHAXjsg5xrw5nlb3dcc3B05knmXg6lkknT9aSa9ACCHcm+Qc9jltobzLHTx4kGHDhrF06VLCwsLo3bs3rVu3JiEhAV9fX7Kysti+fTsbNmxg8eLFnDp1iptvvpm33nqLyMhIjlw4z0srf+dEZgYXdQoBPj7MvbUXbWvX1fqlCSGESyooWvP15kb4laNozcV0M/2a73C7ojXCdZU350jNTmfctu84cjGVLCN4GbyY3KIfN4bFaf3ShBDCJUnOUTyXGdQX2LFjBzNnzmT58uXs2rWrSCsZRYH69RvQqVMnBg4cSIMGDYoce+biRUb++Tt7zp3lok5BbzAwveut9IhpcPnTCCGEuIaCE+yCzY3LfYLt33yb251ghesrNudAISYmli43dbabc2TmZjN5x49su3CMbC9Q9QojE+7g7oi2lf0yhBDC5UnOUTyXG9QXlpGRwb59+8hKfQe9+V9CQ4IJrDMHxSv6qsdkmky8/s9K1p88zkVFwaxTGHtDFwY2a1mJkQshhOsrOMF+salJuU+wD7RIcrsTrHAvBTnHwk//4q+lO6hatRovjr+Xxs0jrnqMyZzHB3t+5+9Tu8jxgjwDDI7pwuP1b0ZR3LMCsxBCVATJOYrn0osKAgICaN68Oe3b30DLJkYC/PVgPlzsMf5GIxM6JdItOhY/VcXLovL6PyuZtOovLK77/YYQQgghKlBBztG5c0cCfWti0Bs5ebT4+jxGvYHhcd25M7wV3rlgzIW5+1fyRtK35FrMlRS5EEIId+fU1e9LzBCLTqei06lYzEeu2X3QS6/npfYdCfPz54ttW9BZVGZt2sDJjAzevrkb3nr3+GcRQojKYC5nJVqzm1aiFe4pItrapk61wImjZ6+5v07R8XB0J6obA/lk/18oqsqPxzaSmpPOmy3uw8/gXdEhCyGE25Ccwz6XvlJvY4gBQK8zQ96REh2iKAqPNGvFs22uw0dV8DVb+HHPTh7+6VvScnIqMlohhHArFlVX7psQriIiyjqot1jg5NFzJT7u9roteS7+VnxVAz65sOr0XoasnUtqTnpFhSqEEG5Hcg773ONV6cMBL/R6C1hKNqgvcEeDON7odBMBej3+FpU1x45w73dfk5whJ1khhCiJgm/Ny3MTwlX4B/pQPTQQ1QLHj56hNKWJrg9ryKtN7iZI8cbXBLsvnOCR1bM4nJlagRELIYT7kJzDPrd4VYpiAEM0ep0F8o6hqrmlOv76upG8e3N3qhq983vZn+buxV+x54ycZIUQQghRVER0KBYLZKbnkH7hYqmOTahSl4nN+xLmFZjfy/6ctZf9udJdlBBCCCEKuMWgHrg0qMcM5pOlPjwhtAYfdOtJHf8A/C0qyelp9Pnua9YcP+r4WIUQwo1YALOqlPlm0foFCFFKEVGhqPlv3BOlmIJvO94/hMkt+hHlH4qfCdJzLvLYuo/5K2WngyMVQgj3IjmHfW4zqFcMsdbp93DNCvhXEx5UhQ+63UZc1er4W1Qys7N58MfF/Lx3twMjFUII92JBV+6bEK4kIjqUgln3JSmWZ09170DGN72XJlXC8TVBXm4uz2+cz6Ijax0YqRBCuBfJOexzn1eVXwFfUdQSF8uzp5qvH1MTe9CuVl38LSpqXh5P/f4z87b858BghRBCCOGqIgsq4KtwsoyDegB/L2/GNL6LjqFx+JhAn6cyafuPzNizrFRr9YUQQng29xnU6/Mr4OstqObyTZn3MxoZ3+lmukfH4pvfy37cP38y4d8/pZe9EEJcxqzqyn0TwpWEF6qAf+JY6affF+als/ayvyu8Ncb8Xvbz9v/Ja0mLpZe9EEJcRnIO+9znVRnqAXrruvoyTr8vzEuv58X2HXmwcTN8VBUfi4U5m//jmWW/kGPOK/fjCyGEu7CglPsmhCupUs2f4Cp+Je5Vfy06RceD0TcyOKYLxjwFbxP8fGwTw//7nMw8abMrhBAFJOewz20G9YpiBH2EdV193lFUtfzfbiuKwsBmrXiu7aVe9j/t2cVDP33LhZxsB0QthBBCCFdUUAH/wrlMMjMdkxP0rNuCFxr1tPWyX3N6H0PWzpFe9kIIIYrlNoN6AAwxGHRmwATmFIc97G314xjf6WZbL/u1x45w77cLOSm97IUQQqbCCY8UXqgC/skyVMC/mg6hDXityd0E63zwNcGeCycZuHoWhzJOO+w5hBDCVUnOYZ97vaoiFfAd2++1Q90Ipib2oFp+L/s9Z05z9+IF7JZe9kIID2dGV+6bEK4mMrpwW7szDn3sRlXqMqlZX2p4BeGbA8mZ53hkzSy2nCv/8kIhhHBlknPY51avSilcAd/Bg3qA+JAwPuh2G3X9A/G3qKSkp9Pn269ZLb3shRBCCI8SUbgCfjmL5dlT17+6rZe9rwkysrMYuu5jVqbscPhzCSGEcG1uNajHkF8BX2dBrYBBPUDdoGA+6HYb8dWsvewv5mTz0I+L+Wnvrgp5PiGEcHYWVSn3TQhXYxvUO6hYnj3VvAMY3/RemlaJwCcX8nLzeHHjAv7v8JoKeT4hhHB2knPY52aD+mhAyS+WV3FT1Kr6+jLl5h60r124l/0vzN28ocKeUwghnJWlnNPgLG52KhKeoXpoIH4B3lgs5etVfy3+Xt6MbtyLTmHxtl72b+74ifd3/ya97IUQHkdyDvvc6lUpii/o6+S3tTtSoSc7ay/7RG6Nro+vqmK0qIz/9y/e+Gel9LIXQngUi6or960sPvzwQ+rVq4ePjw/t2rVj3bp1JTru66+/RlEUevXqVabnFQKsHXIi8ovlpZ5KJyfbVGHP5aUz8EzD7twd3sbWy/7TA//j1a2LyLVIm10hhOeQnMM+txrUA2CIQa83g5oFlootYmfQ6Xi+/Q081KS5rZf9x1s28tTvP5OdJydZIYSoKAsXLmTEiBG8+uqrbNy4kWbNmtGtWzdOnTpV7HGHDh3i+eefp2PHjpUUqXBnBW3toGLW1RemKAoPRHdkSOxNtl72vxzfzDMbPicjV9rsCiFERXGFnMP9BvX6WOuVeqiQYnmXUxSFh5u25IV219t62f+ydzcP/rSYC9lykhVCuD8zSrlvpTVlyhSGDBnCwIEDadSoETNnzsTPz4+PP/746nGazQwYMIDXX3+d6Ojo8rxkIQDroP5SBfyKHdQXuLVOc15odBt+qgEfE6xN3c+ja+dyOjutUp5fCCG0JDmHfW43qFcMMej1KihAXsUP6gvcGtuQCZ0SCczvZb/++FHu+e5rTqTLSVaIssjIyGDz5s2sXbuWzZs3k5GRoXVI4iocNRUuLS2tyC0nJ8fu85lMJv777z8SExNt23Q6HYmJiaxevfqqcb7xxhuEhYUxaNAgx/4DCI8VEXWpAv6JYxW3rv5yHULr81rT3lTR5/eyTzvJw6tncTCj+KtGQgj7JOdwHZJz2Od2g3oMsUBBBfzK7efavm44UxNvpbq3tZf93jOp3LX4K3amnq7UOIRwVTt27ODpp58mPj6eoKAgWrRoQfv27WnRogVBQUHEx8fz9NNPs2OHtHRyR+Hh4QQHB9tukyZNsrtfamoqZrOZGjVqFNleo0YNkpOT7R7zzz//MG/ePObMmePwuIXniixUAb8ii+XZEx9ch4nN+lHDaO1lf+rieR5ZM5vN0steiBKRnMOzuVvO4YaD+oK2duYKrYB/NXEhoXzQ7XbCAwIJsKikZqRz73dfs+pY5c0aEMLVHDx4kB49epCQkMDChQvp0qUL8+bNY82aNWzdupU1a9Ywb948unTpwsKFC0lISKBHjx4cPHhQ69AFYKa80+Gsjh49yoULF2y3kSNHOiS+9PR0HnjgAebMmUNISIhDHlMIgLBawXj7eGGpwLZ2xanrX43JzfsR7R+Grwky83vZ/5G8vdJjEcJVSM7h2iTnsM9Qac9USRRdIKouDIP+PKaco6iqiqJUbj/COoFBvN/tNkatXMbOs6lk5eTw0E+Leefm7tzZIL5SYxHC2c2dO5fhw4cTEhLC/Pnz6dOnD0aj8Yr92rVrx8CBA5k2bRqLFi1i5MiRNGnShGnTpjF48GANIhcFylNNtuB4gKCgIIKCgq65f0hICHq9npSUlCLbU1JSqFmz5hX779+/n0OHDnH77bdfes786mYGg4Hdu3cTExNT5viF59LpdITXC+HgvpOcTr6AyZSH0Vi5qVU17wDGNb2Ht3f+zJbzh8kmjxc3fcULjXrSN7JDpcYihLOTnMP1Sc5hn/tdqQcwxFp71atpYDmvSQhVfXyZktiD6+qE42dRIc/MM8t+Zfam9dJXVoh8EyZMYMiQIdx3330kJSXRv39/uyfXwoxGI/3792fbtm3cd999DBkyhAkTJlRSxMIZGI1GWrVqxYoVK2zbLBYLK1asoEOHKwcxcXFxJCUlsXnzZtvtjjvuoEuXLmzevJnw8PDKDF+4mYJieRaLyqkT5zWJwd/Lm1ca30nnsEb4mMCQp/LWjp95b9dSLAWV/ITwcJJziLJwlZzDfQf1lVgB/2p8vbx448abuS2mga2X/cRV/+P1f1ZitshJVni2uXPnMnr0aMaNG8ecOXMIDAy86r4TJkxAURQaN25s2xYYGMicOXN44403GD16NPPmzauMsIUdZlVX7ltpjRgxgjlz5vDZZ5+xc+dOhg4dSmZmJgMHDgTgwQcftE2l8/HxoXHjxkVuVapUITAwkMaNG18zqROiOIXb2h3XYAp+AS+dgacbdqNPRFtbL/vPDv7NWOllL4TkHG5Ecg773G76PVgr4Ot0FmsFfPMRoJlmsRh0Oka0u55QP38+SdqEzqLy6ZaNnMrMZEpiD3wMbvm/QIhiHTx4kOHDhzN48GBGjx5d7L7Hjh1j4sSJ+Pv72/396NGjOXLkCM888ww33XQTUVFRFRGyKIaKgqUMLWIKH19affv25fTp04wdO5bk5GSaN2/O0qVLbYVsjhw5gk7nnt9bC+dSuAL+yUqsgG+PoigMiLqBasZA5u77A0VVWXJ8C2dyMnirRX8CvXw0jU8ILUjO4V4k57BPUd1wLrhqWo96dgDn0/0xG3uhC3hS65AA+HX/Ht5d8y8mVC7qFNrWrsvsW++kio+v1qEJUal69OjBzp07SUpKKvbbcoB+/fpx+vRpzGYzqampbNu27Yp90tLSaNKkCY0aNWLJkiUVFba4TFpaGsHBwby8ugfeAV5lfpycjFwmd1jChQsXSrS+TQhncvRQKoPveh+jD7S9MZZhL96qdUgArE3dx5Sdv5JFHtlGqB9Uk/dbP0Soj3zGhGeRnMM9SM5RPPe8jGGrgG+BvKMaB3PJrTENmNC5KwF6g7WX/Ylj9Pn2a45LL3vhQXbs2MHSpUuZOHHiNU+u//vf/1i0aBHTpk0rdr+goCAmTZrE0qVL2blzpwOjFSWhxVQ4IZxF7bpVMRj01rZ2x85pHY5Nu5BYXm/ahyp6X3xNsC8tmYdXz+JAuvSyF55Dcg73IzmHfW75qhRdNVCqWgf1Gq6pt6d9nbpM7dqDEG8f/C0q+8+e4e7FX7EjVU6ywjPMnDmTsLAw+vTpU+x+ZrOZp556isGDB9OkSZNrPm7v3r0JCwvjo48+clSoooQsqlLumxCuSm/QUyeyOhYVUo6fw5xnvvZBlSQuuDYTm/WlpjG4UC/7WWw6e0jr0ISoFJJzuB/JOexzy0E9kF8B3wyWM6iWDK2jKSKueigfdLuNiICgS73sv13Iv0cPax2aEBVu2bJl9O7d+5qFQmbOnMnhw4cZN25ciR7X29ub3r17s3z5ckeEKUrBjK7cNyFcWUEF/Lw8C6eSnWv2XV3/akxu0Y8Y/xr4muBiTjbD1n/C8pNXTisWwt1IzuF+JOewzz1fFYAhxtrWDiDPua7WA9QODOK9bj1pVD0UP4tKtimHh3/+lu93yzQe4b7S09PZvXs3bdq0KXa/M2fOMHbsWMaMGUNoaGiJH79169bs2rWLjAzn+iJPCOHeIqJCbBXwtS6WZ09Voz/jmt1Diyr18MkFc24eL2/+mq8OrdI6NCEqjOQcwpO47aBeKdLWzjmvgFf18WXKzd25vk6ErZf98OW/MnPjOullL9zS/v37UVWVRo0aFbvf6NGjqVatGk899VSpHj8hIQFVVdm3b195whSlJFPhhKeLiA6D/NP2CQ3b2hXHz2BkZOM76VKol/07O39huvSyF25Kcg73JDmHfe7bT80Qg6KATmfBYj5SjsYHFcvHy4vXb7yJ99av5qd9u9FZYPLqv0nOyGDMDZ3RS0sm4UZycnIA8PPzu+o+e/fuZfbs2UybNo0TJ07YtmdnZ5Obm8uhQ4cICgqiWrVqVxzr6+tb5HlE5bCgw1KO74jLc6wQziAy2np1z2Jx3kE9gJdOz1MNu1HdO5BFR9aiqPD5wb9Jyb7Aa016Y9S7b1ooPI/kHO5Jcg773PNVwaUK+HqLU06/L8yg0/Fs2+sY1LQl3qqKj8XCp1s38sRvP5Odl6t1eEI4jLe3NwAXL1686j7Hjx/HYrHw9NNPExUVZbutXbuWPXv2EBUVxRtvvGH32KysrCLPI4QQlaFOZHV0OiW/Ar7zDuqhoJf99TxePxHvPAVvE/x2YitPbfiM9NxsrcMTwmEk5xCexH2/ktXVACUAgy6X3FznHtSD9SR7f5PmVPfz4921/6KzqCzdv4f7szKZe2sv6WUv3EJsbCyKorBjxw7atWtnd5/GjRvz3XffXbF99OjRpKenM336dGJiYuweu337dhRFITY21qFxi+KZVQVzOaazledYIZyB0WigVt1qJJ88w8lj57BYLOicfKZdt9pNqWr0592dv6KYctlw5gCD187m/dYPEeYTrHV4QpSb5BzuSXIO+9x2UK8oCqohFr1+G+SkoFououiuPv3GWfSIaUB1Xz9e/d8fKOY8/jtxnN7ffs1nt/WmblCQ1uEJUS4BAQE0bNiQ9evXM3DgQLv7hISE0KtXryu2F/SNtfe7Ahs2bCAuLo6AgAAHRCtKqrxr1Nx1fZvwLBHRoZw8fgZTTh5nTqcTWsP5B8ZtQ2J4o2lvJm7/gfOmLPZfSOHh1bN4v/VDxATW0Do8IcpFcg73JDmHfc79NXJ5GWIKFcs7pm0spdC2dl2mdb3V1sv+wNkz3LV4AdtPSy974fq6du3K4sWLMZlMDn3cnJwcFi9eTGJiokMfVwghSqJIBXwnXld/uYbBtZnUvB+1jFXwNcHpixcYtGY2/505qHVoQpSb5BzCU7j1oF4xxF5qa2d2/in4hTWsHsKH3W8nMtDay/5sZgZ9v1vI30cPaR2aEOXy+OOPc+rUKRYtWlSq4/7880+2bbt6X+XFixdz6tQphg4dWt4QRSmpqg5LOW6q6tanIuEhClfAP+7k6+ovV9uvKpNa9CW2UC/7J9Z/wu8nk7QOTYhykZzD/UjOYZ97vqoCtgr4KqqTtrUrTq2AQN67pScJIaH45/eyH/jzd3y7e4fWoQlRZo0aNaJ79+6MHDWK9PR0hzxmWloaI0eOpHv37sTHxzvkMUXJmVHKfRPC1RWugH/y6DmNoym9gl72LatG4ZMLap6ZUZsXsuDgv1qHJkSZFeQco0ZKzuEuJOewz70H9fqCCvhmp6+AfzVVfHx596buXF/X2steyTMzYvkSZvy3VnrZC5d1/8MjOHkimWeffbbcj6WqKs899xxnzpxhxowZDohOCCFKLzwqBMBaAd+Fpt8X5msw8nLCHdwcloB3fi/7d3f9ypSdv0ove+GyHr/vKU4cPyk5h3Brbj6orwP4WNfVu9j0+8J8vLx4veNN3FE/Dl9Vxdui8taafxj7vxWYLXKSFa5DVVUWfLOW2Z9vol7cbcybN4/x48eX6/HGjx/P3LlzmT59OlFRUQ6MVpSURb1UuKZsN61fgRDl5+NrpEatKqgWOHHsrMt+8e6l0/NEw1u4N7I9xlww5sL8Q//yypb/w2TO0zo8IUpl6cd/MGPQZ8Sam0jO4SYk57DPbavfAyiKDtUQg163B8wnUVUTimLUOqwy0et0DG/TgTA/f+Zu+Q/FovJF0mZSMjN575Zb8TF4aR2iEMXKM1uYPnM5P/66GYBa4W2JCvdnzJgxHD58mClTphAYGFjix0tLS+O5555j7ty5TJgwgUGDBlVQ5OJaCtapled4IdxBRHQop0+dJyvTxPmzmVSt7ppVsRVF4b5611HdO4BZe1agqCq/n0jiTE4G77YcQKCXtNkVzk1VVT4d8zULJn4LQB0lippxIZJzuAHJOexzz1dVmCEmv1ieBfJcpwK+PYqiMKBxM17u0BFfFPwsKr8f2MuAHxZxLjtL6/CEuKqLWSZeeeNb24AeYNADN7D050+ZM2cOX331FY0bN2bBggXXrFCbk5PDggULaNKkCV999RVz585l1KhRFfwKRHEsKOW+CeEOwqNCKJilfsJFp+AXdkutprzc+E788cLHBP+dOcigNXNIzjqvdWhCXJUpJ5c3H3zfNqAH6PVUD5Yl/SI5hxuQnMM+tx/UK0Xa2rnuFPzCukXXZ1LnrgQaDPhbVDaePE7vxV9xNO2C1qEJcYXUM+k8/dIC1mw4AIDBoOOV53ryYL/rUBSFwYMHk5SURKNGjRgwYADh4eEMGzaMjz/+mLVr17J161bWrl3Lxx9/zLBhw4iIiGDAgAE0atSIpKQk+bZcCOE0IqNDKZh176rr6i/Xpno0bzTtQ1W9L74mOJCWwsDVs9ibnqx1aEJcIf1cBqN6TGDF/L8B6wWxoVMf5onpj6DX6yXnEG7LraffA2CIQadTURQV1XzEbb6baZPfy37kymWkZmdx8NxZ7lq0gE9vv5vGoTW0Dk8IAA4cOs1Lry3i1GlrxdkAf2/GvdKLls0ii+wXFRXFkiVL2LFjBzNnzmT58uXMnDnzsjWpCkFeVbj73l68+MoLUnHWiZhVBbNa9r+u5TlWCGcSHmWtgF+wrt5dNAiqxeTm/Xhj23eczD5PKmkMXjOHd1sOoHX1aK3DEwKA5EOneKXnRI7sPA6A0ceLkfOf4Ya72hXZryQ5h6JAXH0/7u3Tk2FPvi45hxORnMM+DxjUx1r/ozeT6yZX6gs0qBbCB91u46U/fuNIehrnLmbS97uFfNT9Dm6MqKd1eMLDbdxymNHjvyPzonVqW82wIN58vQ/1IkKuekyjRo147733AMjIyGDfvn3k5OSwcv6//Pb+3xjyDPRLfEBOrk5G1rcJYRVRqK2dO0y/L6yWX1UmNe/LxG3fszcjhSw1myfXf8rrTfvQrXZTrcMTHm73hv2MuX0S51Kss1arhAbxxo8vE9+u/lWPuVrOYbT8TUzYTAL8dSgBN6MESM7hTCTnsM89X1Vh+gjAy7qu3s0G9WDtZf9+t9toHBKGv0Ulx2TikV++Y/Gu7VqHJjzY0hXbeGHsN7YBfcPYGsx49/5iB/SXCwgIoHnz5rRr144ed3fDoFi/g9y5Zm+FxCyEEOUVGORLtZBAl25rV5wqRn/eaHpZL/stC/ny4D9ahyY82Jqf/+P5zq/aBvR1G9Ri+qoJxQ7oL1c452jephcB/tYhkpq7pUJiFsLR3H5QrygGMNSzrqvPO4aqul87lmBvH969uRs3FOpl/9yKpXy4QXrZi8qlqiqfLviXSVN+JS/PWsuiQ9sYpk2+j+rVyl4FukHraHQ663SpnWv3OCRW4TgWytNaxn2L1gjPFBEdgkWF9LRs0s5f1Doch/MxGBmZcAeJNZrgbQKvPJi6awnv7vxFetmLSvfjjN94tdebZF/MAaDxDXFM/3cCtWNqlv1B9dGg5FfGz90iubSTkZzDPrcf1ANgiM0vlpcH5pNaR1MhvA1evNbxJno1iLf1sn977T+M/kt62YvKkZtrZvK0JXwy/1/btl49WzB+9F34+ZavlaRvgC/1GkcAcCjpCFmZ2eV6POFYajmr0KpueoIVnikiKhTVbL1/0o3W1Rdm0OkZ1iCRfpEdMOaCdy4sOLSKkZsXkmPO1To84QEsFguzX/ic95+ciyW/8Xjnvtfx5u9jCKpe8lZ19iiKDrzyl5RYToPFPccOrkpyDvs8Y1CvL2hrB5gPaxtLBdLrdDzduj1DmrfGW1XxtViYv20zjy/9kaxcOcmKipORmcNLry1i6fJttm1DH+nM8KGJGPSO+TMT19ZaH8NiUdmzYb9DHlMIIRwtolAFfHdbV1+Yoij0rdeBJxp0xdusw9sEy09u48n1n5KWK212RcXJycphfL+pfPPuT7ZtfV+8k5Hzn8HoU76LCDZezS7dN212zGMKUYE8YlCvFKqAT577rasvTFEU+ic0ZVSHG2297Jcd2Ef/H77hbJb7TQMU2jt1Oo0nX5jPf5utX5gZvfS89vId9OvdFkVx3Leh8e0b2O7vWrvPYY8ryq9c0+Dyb0K4i4JieaoKJ4+d0ziaipdYqwkjE+7AHy98TbDx7CEGrZktvexFhbiQmsaLXcfx96I1AOh0Cs989CiDJ9+PTue4YY1SaFAv6+qdi+Qc9nnEoL6gAr5eb0F1w2J59nSNjmVyl1sIMnjhb1HZnHyC3ou/5siF81qHJtzInv0pPD7iCw4eTgUgOMiXKRP70qVjnMOfK65QwRtZV+9cCirRlucmhLuIdOMK+FfTqno045reQ1WDH74mOJh2iodXz2RvmvSyF45zfN9Jnr7uFXas2g2Aj783b/z4Mrc91tXxT2YsdKVeBvVORXIO+9zzVV3OEAXorOvqPWRQD9CqVh2mdb2VMB9f/C0qh8+f5e7FX5F0KkXr0IQbWLPhAE+/tIAzZzMBqFOrCjPeGUCTRnUr5Pki4uvgF+QLWCvgS+EaIYQzCq7qT1AVP2uveg8Z1APUD6rJpGZ9qeNdFV8TnMlKZ9Da2aw7I8ulRPltX7Wbpzu8wol91i+KqtWqypS/3qDdrS0r5PkUXbX8DlpA7nZU1VQhzyOEo3jEoF5RjKCPsK6rzzuK6kHVWetXq84H3W6nXlAw/hbV1sv+z8MHtQ5NuLAfl2xm1OuLycqy1mpIiKvNjHfvp26dahX2nDqdjoZtrLNuzp48x+ljZyrsuUTpyFQ4IS5RFIXwqBAsFjh/NpOLmTlah1RpCnrZNwioia8JsnNyeGr9Zyw9IVc6Rdn9b9FqXrj5ddLOpANQLyGc91dPoH7L6Ip9YtsU/BzI212xzyVKTHIO+zxiUA+AIQa9zgzkgNmzrlTXDAjg/Vt60jS0Bv4WFVOuiUG/fMc3O7dd+2AhCrFYVGZ/+hfvfvA75vxqs52ub8DUiX2pEuxX4c9fuOfsrrXSr95ZlKcKbcFNCHcSGR1KwfUDd+xXX5xgox9vNO1D66rR+JiAPDOvbPk/Pj/wt8ywEqWiqirfvPsT4/tOJTfHehGhxc1NmPbPOMIiQiv8+ZUixfLkiylnITmHfR40qI/FUFAB3+I5U/ALBHn78PZN3bgxPBI/i4rObOGFP37j/Q1r5CQrSsSUm8e4t39i/jdrbdv63tWG116+E29vr0qJoci6+jUyqHcW8q25EEVFFBrUn/CAYnmX8zEYeSnhdrrWutTLfvrupbyz8xfMHjRbUpSd2Wzmg6fmMfuFz215ateHOjHhl5H4B/tXThDG5ra7au7mynlOcU2Sc9jnMYN6T6qAfzXeBgNjb+jC3YV62b+79l9G/bmcPOllL4qRlp7Fc6/8H3/8bxdgrTY7fGgiwwZ3QaervD+OhQf1u9bJoF4I4ZwiogpVwD/qmUuFDDo9Q+sncl+9S73svz60mpGbvpZe9qJYWZnZvHb32/w44zfbtgdfvZcXPn4CL2PlXEQAwBAH5LfIy91aec8rRBkYtA6g0hRUwNdZyDMfcdOJF9em1+l4snV7Qv38mbV5AzqLylfbt3D6Ygbv3XIbfl6V+MdSuIQTJ8/z0muLOHLMOoXUx9uLsS/dzvXtYis9lqphwdSMCiP54Cn2bNhPXm4eBi/P+TPmrMr7zbe7fmsuPJetrZ2HFcu7nKIo3BvZgeregXy0ZzmKamFF8nbOmjJ5t+UAgo0Vv2xLuJazyecYc8eb7NlgLbCoN+gZMedxbnmoc6XHoihGVK8EyN0E5kOolnMouqqVHocoSnIO+zzmSj16azENa7E8z7xSX0BRFPolNOWV6zrZetkvP7if/j98wxnpZS8K2bn7JEOf+9I2oK9WxZ/pb/bTZEBfIL699Wq9KTuXg0me/Vl2FjIVToiiQsKC8PP3xmLxjF7113JzzcaMbHwH/hjxNcGm/F72J7Pk30ZccnjnMZ7u8IptQO8X5MvEJa9oMqC3KbyuXq7WOwXJOezzmEG9ovMDXZ38tnaHZR05kBgVw5s3dSPYy9rLfkvyCXov/orD0steAH+v3sszI7/i/AXrFz0RdasxY8r9xNWvpWlc8e0a2O7LunohhDMqqICvWiD1VDo52dIOq1W1aMY160NVgx9+JjiUfpqHV89iT9pJrUMTTmDLn9sZfv1oUg6fBiA0vDrT/hlPy5ubaBpX4WJ5qmmzdoEIcQ0eM6gHrBXw9RZQL4IlVetonELLmrWZ3rUnNXz98LeoHDl/jt6Lv2JLSrLWoQkNLfphA2MmfEdOTh4AzZuEM+Od+6lVI1jjyGRdvTOSb82FuFJEdCgWi7WC98njckUaIDawJpOb97P1sj+blc7gNXNYlyq97D3Z8i//x8vdxpFxPhOAmOb1eG/1RKIaR2gcGXKl3glJzmGf5w3qdWbrfbNM2y0QU7UaH3S7jaigKrZe9v2+X8jKQwe0Dk1UMrPZwvuzV/D+7D8omMyS2Dmet8fdQ2Cgj7bB5YtpXg8vo3Ud/c41ezSORgColK/FjMybEu4oIqpQWzuZgm9T07cKE5v3pWFALWsve1MOT234jF+Pb9Y6NFHJVFVl/vjFvPng++TlWvPzNj1aMOWvNwipXU3j6PLp64AuxHo/dwuqdG/QnOQc9nnUoF4xxKLXq6AAeUe1Dsep1PC39rJvlt/LPjc3l8G/fs//7UjSOjRRSbKzc3l10g8s+uE/27YH+nZg9PO3YXSiYnRGby9iWkQBcGzPSdLOpmsckRBCXMlWLE/17GJ59gQb/Xi9WW/aVsvvZZ9rZszWb/h0//9keaSHyMvNY8qQmXw69mvbtp6PdmXcDy/hF+irYWRFKYpy6Wq9mgbmQ5rGI8TVeNSgvnAFfNV8WONgnE+gtzdv3dSNTuH18LOo6M0WXlz5O9PXr5aTrJs7dz6TZ0d9zd+rrdPZ9TqFF57uxuAHO1pPaE4mvtAU/N3r9mkYiQCZCieEPZGFKuCflEH9FXz0Rl5odDvdajXFOxe8cuH9Pb/x9s6fpZe9m8tMu8jo2yez9OM/bNsGTRrAMx8NQW/QaxiZfUqRKfibNYtDWEnOYZ+HDepjAKxT8D28Av7VeBsMjO3Yhd4NG+GT38t+6rpVjPpzmfSyd1NHj59l2HPz2bHbWqzI19eLya/14bZuza5xpHaKrKtfK4N6rckJVogrhdWqgtHbgMUCJ2T6vV0GnZ7H6t/MgKjrMeZZe9kvPLSGlzZ9Rbb0sndLp4+dYcSNY/nv9y0AeBkNjFownH4v9XLKiwhAkXX1qknW1WtNcg77PGpQr+iCQBdmLZYna+qvSqcoPNm6PUNbtsFbVfG1WPhq+1Ye/fUHLubKSdadbN1+jGHPfcmJ5PMAhFYP4IO3BtC2VZS2gV1DQVs7gJ1rZV29EML56PU6wutZK+CfOnkBkylP65CckqIo9Ilox5MNu+Ft1uGTCyuTdzBs/SecN0mbXXdyYOthnu4wigNbrbNlA6v68+aysXTpd73GkV2DVxOsa3eRK/XCaXnUoB7IL5ZnAfUCquW81tE4tXvjmzD6+s62XvZ/HNrPfd//H6kX5STrDv74306ee2UhaenZAMREhTJjygPERodpHNm11awXRpXQIAB2rd0ry0M0Jt+aC2FfRLS1WJ7FbOHUyfNah+PUbq6ZwKjGvQjI72W/5exhHlkzixMXZZaDO9jw+xae7TiG1OPWpSg1o8KYvmoCTTrGaxzZtSm6ADDkX0zI242qZmkbkIeTnMM+jxzUG/T508hlCv413Vwvukgv+60pJ+m9+CsOnZeTrKtSVZUF36zl9Td/wpRfbbZ1i3q8/1Z/wkICNY6uZBRFIS7/an36uUyO75U+x1qSE6wQ9kVEWdvagVTAL4mW1eoxrtk9VDP442eCI+mpPLxmJrvTTmgdmiiHpR//wSs9J3Ix3ToYjmsby3urJxLesI7GkZWCbQq+GXK3aRqKp5Ocwz6PG9Qrhlh0uvwzrEzBL5GWNWvzXqFe9kcvnKP3t1+xOUUGUq4mz2xhyoxlzPr0L9u2W7s24c3XeuPv561hZKUX17bwFHzpV68lVVXKfRPCHRWtgH9G42hcQ0xgDSY370sdH2sv+3NZGQxZM5c1qVI/xdWoqsono7/i3cEfYTFbc+/re7Xh7T9eo2pYsMbRlU7RYnlbtAtESM5xFR43qMcQi6KAXm9BlUF9iUXn97KPDrb2sj9/8SL3ff9//CG97F3GxSwTr7zxLT/+utm2bdADN/DiM90xOGG12WuJb9/Adn/nGhnUCyGcT+FB/cmjcqW+pGr4VmFis77EBda29bJ/esNn/HJ8k9ahiRIy5eTy5oPvs2Dit7Ztdz19K2O+eQ4fF7uIAIBXc9td1SSDeuF8PG9Qry+ogG+BPGlrVxo1/AN475aeNA+raetlP+TX7/l6h1QCdXapZ9J5+qUFrNlg/RLGYNDxynM9ebDfdc5bbfYaGraJscW+a50M6rVkQSn3TQh3VLtuNfQGHaoFThyTtnalEWz04/WmvWlXPQYfEyi5FsZuXcTH+/+SOipOLv1cBqN6TGDF/L8B65K5oVMfZti0gej1rncRAbB20FL8rfelWJ6mJOewz/MG9bpqoFSxDurlSn2pBRq9eeumW+gccamX/csrlzF13So5yTqpA4dOM/S5L9m7/xQAAf7evDPuXm65KUHjyMrHP8iPyEZ1ATiw5TDZF3M0jshzyfo2IewzeOmpE1EdiwWSj5/DnGfWOiSX4q334oVGt9O9djNbL/sP9/zOmzt+kl72Tir50CmG3zCaLX9uB8Db18iri5/n7md6ahxZ+SiKPr8KPmBJQTUnaxuQB5Ocwz6PG9QrimKtgK83g+UMqiVT65BcjlFvYMwNXbgnLsHWy376+tW8tPJ3cs2SsDiT/zYf5skX5nPqdDoANcOC+PCdAbRoGqFxZI4R1zYWAHOemX0bZSmIEML5RERZK+Dn5VpITUnTOhyXo1d0PBp7E/dH3WDrZf/N4bW8uGmB9LJ3Mrs37OfpDqM4svM4AFVCg3j7j9e4vldbjSNzEFlXL5yYxw3qATDEWnvVg1TALyOdojCsVTuGtmxr62X/fzuSGPLrD2SaTFqHJ4Cly7fxwthvyLxo/f/RMLYGM969n3oRIRpH5jhF1tWvlSJKWtGqaM2HH35IvXr18PHxoV27dqxbt+6q+86ZM4eOHTtStWpVqlatSmJiYrH7C+EoEdGXKuAfl3X1ZaIoCr0j2vJMXHdbL/s/k3cydN3H0sveSaz+aQPPd36VcykXAAhvWJv3Vk8kvl39axzpOpTC6+plUK8ZyTns88hBvWKItU6/BzDLuvryuDe+MWOu74wfOvwsKn8ePsB9P/wfpy/KDAitqKrKpwv+ZdLUXzHnV5u9rm0M09+8j+rVAjSOzrHi2hWugL9Hw0g8mxZT4RYuXMiIESN49dVX2bhxI82aNaNbt26cOnXK7v5//vkn9913HytXrmT16tWEh4dzyy23cPz48fK+fCGKFRkdCvmr005KBfxy6VyjEaOb3GXrZb/13BEeWTOL4xelXoGWfvhwKa/d9ZZtGVyTjvFM+3c8taJraByZgxW+Um/arFkYnk5yDvs8clCPIQZFAZ1OKuA7wk31onnz5m4Eexnxt6gkpSTTe/FXHJRe9pUuN9fM5GlL+GT+v7Ztd93WgvGj78LXx6hhZBUjMqEuPv7WKrq7pK2dR5kyZQpDhgxh4MCBNGrUiJkzZ+Ln58fHH39sd//58+czbNgwmjdvTlxcHHPnzsVisbBixYpKjlx4mvAoawV8iwVOSK/6cmteNZLxl/WyH7h6FjsvyBd0lc1isTDr+c/54Kl5WCzWb64697ueyb+NJqhaoMbROZ6iDwG9tZYPudtQ1TxtAxKVxhVyDg8d1FvX4er1UizPUVrUqMV7XXtS08/ay/7YhfP0XvwVm5Kll31lycjM4aVXF7F0+TbbtmGDOvPM44no9e75Udfr9TRsY/08nz56htQTcrVGC5U9Fc5kMvHff/+RmJho26bT6UhMTGT16tUleoyLFy+Sm5tLtWrVSvXcQpRW3cjq6HQKqgVOHpW/UY4QHViDyc37UdenmrWXfXYGj66dy6rT8uVuZcnJymF8v6ksmvKTbVu/l3ox8sunMbrhRQQb29X6bMiTGYJakJzDPvfM9K9FVwMUf6mA72DRVavywS23ExNcFX+LyoWsi9z3w/+x4tB+rUNzeymn0njyhfn8t8W6nMTopef1kXfS9+62LtuyrqQKr9eTq/XaUMs5Da7gBJuWllbklpNjv6NBamoqZrOZGjWKTu2sUaMGycklq0j80ksvUbt27SInaSEqgrePFzXrVM2/Un8Wi0WqtjtCDd9gJjXrS3xQHXxNkGMyMfy/z/np2EatQ3N7509f4MXEN/h70RoAdHodw2c+yqBJA9Dp3HtooUixPM1JzmGfe3/yrqKgAr5BbwZzCqolS+uQ3EaYvz/Tb7mVFjWsvezzcnMZ8usPLNguvewryp79KQx97gsOHk4FIDjIl6kT+9H5hoYaR1Y5iqyrXyODelcWHh5OcHCw7TZp0qQKeZ7Jkyfz9ddf89133+Hj41MhzyFEYQUV8E05eZw9naF1OG4j0OjLa03upl31WFsv+9eSFvPx/j+lzW4FObb3JM9cP5odq61XqX38vRn348v0fLSrxpFVksLF8mRdvUtzt5zDUGGP7OwMseh12wAVzMdA5z7VObUWaPTmzS63MHn136w8fJBs1cKoP5eRnJHOs22vc/srx5Vpzfr9vDb5R7KyrW196tSuwluv9aFuHc+ZUlx4UL9rnQzqtaAC5cmfCw49evQoQUFBtu3e3t529w8JCUGv15OSklJke0pKCjVr1iz2ud555x0mT57M8uXLadq0admDFqIUIqJDWfv3bsB6tT6kRtA1jhAlZe1lfxsf7/+TX49vRlHhwz3LSM66wIuNbsOg02sdotvYvmo3Y+98k7Qz1ja51WpVZcLPI4ltEaVxZJXIKx7wAnLlSr1GJOewzyOv1EN+BXy9VMCvKEa9gdHXd6ZvXGNbL/v3NqzhxT9+k172DvLjks2MeuNb24A+Ia42M96536MG9ADVa1UlLL9N3571+zHnyfursllQyn0DCAoKKnK72gnWaDTSqlWrIgVnCgrQdOjQ4apxvvXWW4wbN46lS5fSunVrx/4jCFGMiOhQWxJ6QirgO5xe0TE4pgsPRne09rI3weIj63hx0wKyzNJm1xH++mY1L9z8um1AX69xOO+vnuBZA3pAUbzzB/aA+QCq5YK2AXkgyTns89hBPfqCCvgqqvmo1tG4JZ2i8HirtjzRqh0++b3sv9m5jcG/fi+97MvBYlGZ/elfvPvB75jzq812ur4hUyf2pUqwn8bRaSO+vfVqffbFHA5tl89zZdOiZ+yIESOYM2cOn332GTt37mTo0KFkZmYycOBAAB588EFGjhxp2//NN99kzJgxfPzxx9SrV4/k5GSSk5PJyJCp0KLiRURfqoB/UirgVwhFUbgrvA3D43rgY9Hjkwt/pexi6LqPOWeSNrtlpaoq37z7E+P7TiE3x3oRoWViE6b9PY6wiFCNo9NIkXX1SdrF4aEk57DPcwf1hhgA9Doz5MmV+orUJy6BV2/ogp9i7WX/1+GD9P1+Iacy5SRbWqbcPMa9/RPzv1lr29bv7ja89vIdeHt7aRiZtuLayrp6T9O3b1/eeecdxo4dS/Pmzdm8eTNLly61FbI5cuQIJ09e6r7x0UcfYTKZ6NOnD7Vq1bLd3nnnHa1egvAg4fWss4lUC5yQCvgVqlONeMYU6mW/7dxRHlk9i2PSy77UzGYzHzw1j9kvfG7bdsvDnRn/80j8g/01jExbSqF19eRu1ioMUYlcIedQVA+tJKKqZtSUFmRmqWTnRaOrZr/PoHCcLSnJjP5rORdyTVzUKdQNrsJnt99NdBXPmi5eVmnpWbwy7ju2bj8GgE6n8PRjN3PXbS01jkx721ftZvgNowHo9nAXnv94mMYReYa0tDSCg4Np/H8voPezP22tJMwXc9h279tcuHChyPo2IdzJAz2mcPbMBYKqevP+/EelvkwFO5hxinFJ33E2L5MsL6jq4897rR8iPriO1qG5hKzMbCb2n8aan/6zbXvwtXu5f0wfj3/vqnlHUFPzq5h7d0JXdY62AXkIyTmK57FX6hVFD4ao/LZ2J1FVmQ5e0ZrVqMl7XXtSy88ff4vK8fxe9huTT2gdmtM7cfI8Tzw/3zag9/H2Yvzou2RAny+2RT0MXtZiSDvXSt/Yyqaq5b8J4e7Co0OxWOBiZg7nz13UOhy3FxUQxuQW/QjP72V/PjuTIWvnsuq0nCOu5WzyOZ7v8pptQK836Hnhkyd4YOw9Hj+gB0AfDkpV633TFum0UMkk57DPYwf1gLUCvt4CmCHvuNbReISoqlX54JbbiK1SDX+LSlpWFv1/+IZlB/dpHZrT2rn7JEOf+5Ijx6xTB6tV8Wf6m/24vl2sxpE5D29fb6Kb1QPgyM7jZJyXpR1CCOcSmd/WDuCkTMGvFGE+wUxs1pdG+b3sTSYTw//7gh+P/Xftgz3U4Z3HeLrDK+zZsB8AvyBfJi55hVse6qxtYE5EURQw5q+rV8+D+Yim8QgBHj6oVwwx1iv1ABb5QFaWUH9/pne9lZY1all72ZtyeWzJj3y5TVqDXO7v1Xt5ZuRXnL9gvaoTGV6dGVPuJ65+LY0jcz7xhVrb7V4vXxJVJi2K1gjhasKjQy5VwD8mg/rKUtDLvkP1+rZe9q8nfcucfX/IFdbLbPlzO8OvH03K4dMAhIZXZ9o/42l5cxONI3M+sq5eO5Jz2OfRg3oMMeh0KoqiQp4M6itTgNHI5C63cHNkNH6qisFsYfRfy3lnzT9yks236IcNjJnwHTk5eQA0bxLOh28PoFaNYI0jc05F+tWvlUF9ZZITrBDXFhkdBliL5cmV+spl1HvxXKOe9KzTAu9cMObCzL0rmLD9e/Is0gYVYPmX/+PlbuNsM91iW0Tx3uqJRDWO0DgyJ1WoAr4qg/pKJTmHfQatA9CUwTp9Wa+3kGc+jHv+L3ZeRr2eUdd3ItTPn693JqFY4IP/1nIyM4PJnbvipddrHaImzGYLM+atZNEPl6YHdu3ciBeHd8fo5dkf2eIUtLUDWVcvhHA+4VHWCvgWqYCvCb2iY1BMZ0K8A/nswP9QVPjuyAZSs9OZ1Lwfvgaj1iFqQlVVFkz4lk/Hfm3b1vbWFoz++ll8A3w1jMzJeTUFFEAFk8w0Fdrz7Cv1+gjAgEFvBulVrwmdovBYyzY8VaiX/eKd23jkl+/I8MBe9tnZubw66YciA/oH+3Xgled7yoD+GmrH1CSoeiAAu9bulRkflciiKuW+CeHugoL9qFo9wHqlXqbfa0JRFHqFt2Z43K22XvZ/n9rNY+vmcS7H82qx5OXmMWXIzCID+p6PduWN71+SAf01KLpA0Edbf8jbhapmaxuQB5Gcwz6PHtQrihcY6lnX1ecdRVXztA7JY90dl8CrHS/1sv/7yCH6fudZvezPnc/k2VFf8/dqa591vU7hxae7M+iBjlJttgQURSEuv3jghdR0Th5I0TgizyGVaIUomYjoUCwqpJ3PIv2CVMDXSqcacdZe9oq1l/2O88cYuGYWRzPPaB1apclMu8jo2yez9OM/bNsGT76fZz4agt7gmTMlS83YPP9OHuTu0DISjyI5h30ePagHQB+bXywvD8zJWkfj0TpFRPHOTd2p6uWNv0Vlx+kU7l68gP3n3P+KxpFjZxj23Hx27D4JgJ+vkTdf70PPbk01jsy1xLUtvK5+r4aRCCHElSKiL1XAP3HsnLbBeLimVSOY2KwvIQZ/fE1wLOMMA9fMYvv5Y1qHVuFOHzvDiBvH8t/v1mnjXkYDr3w1nL4v3ikXEUpBKbSuXorlCa3JoN4Qk9/WDmlJ4QSa1qjJ+7fcSu38XvYn0i7Qe/FX/HfSfVsObtl2lCeen8+J5PMAhFYP4P23+tOmZZS2gbmg+PYNbPd3rpFBfWWxfvNdnqI1Wr8CISpHRFSIbVCfLFPwNVcvIJRJLe4jwrc6via4kJ3Jo+vm8s+p3VqHVmH2bznE0x1GcWDrYQACqwXw1vKxdO57vcaRuaAixfJkXX1lkZzDPo8f1CtFKuAf1jocAURWqcoH3W6jfn4v+/TsLPr/sIjfDrjfIO2P/+3kuVf+j7R061qsmKhQZkx5gNj8KsmidOLaxtru71rnfu8XZyWVaIUomYiCCvgqHJdieU4hzCeIic360jioLr4myDXlMmLjl3x/dIPWoTnc+t82M+LGsaQet773akXXYPq/42l8Q7zGkbkoQ31Q8msPSLG8SiM5h30eP6i3VcDXWVDNMqh3FiF+1l72rfJ72Ztzcxm69Ce+SNqsdWgOoaoqC75Zy+tv/kRunrWdTpuW9Xj/rf6EhQRqHJ3rCqjiT3hcHQD2bTqIKdvzii1qQXXATQhPEBkdClgr4J88KtPvnUWAlw9jm9zFdSENbL3sx237jtl7V7hN0dUl81Yw+rZJXEzPAqxtYKevmkB4wzoaR+a6FMUAhibWHywnUM2ntA3IQ0jOYZ8M6g1RgM46BV8q4DsVf6ORSV1uoWu9GFsv+zH/W8Gbq/926ZNsntnClA9/Z9anf9m29bylCZNf7Y2/n7eGkbmHgmJ5eblm9m0+pG0wQghRSJVq/gQE+aJa4IRMv3cqRr0Xz8Xfyu11W9p62c/a9wfjt7l2L3tVVflk9FdMGTITi9m69uP6u9ry9opXqRoWrHF0bsBYeF29XK0X2vH4Qb2ieIM+3DaoVwsWuwmnYNTrGXndjdzXqCk+qoq3ReWjjet4bsVSTGbXO8levJjDqDe+5ccll/7wD36gIy883R2DVJt1iPh2l9bV75J19ZVCpsIJUTKKohCZXyzvXGoGFzNztA5JFKJTdDwS05mHYzrhlQfeJvj+6AZGbPySrDzXm/llysll8gPvsWDit7Ztdz/TkzH/NwIfuYjgEIqsq690knPY5/GDegAMseh1ZlCzwXJa62jEZRRF4dEWrXmmdXtbL/tvd23nkZ+/Jd3kOglR6pl0nn75K9ZuOACAwaBj9PM9eaBfB6k260Dx7S5VwN8p6+orh8yFE6LEIqJDsRQUyzsuU/Cd0Z11WzGiUC/7f0/t4bF1czmbk6F1aCWWfi6Dkd3H88eCfwBrLjVs2kCGTn0YvV4uIjiMl1ypr3SSc9glg3oAQ3R+WztA1tU7rV4NG/HajTfhr+jxt6j8e/Qwfb9bSEqm859kDxw6zdDnvmTvfut6qwB/b94Zdy9duyRoHJn7iWoSgbevEYBda/ZoHI0QQhRVuAL+CSmW57Q61ohjbJO7CVS883vZH3eZXvYnD6bwzPWj2fqXtXe6t6+RVxc/z11P36pxZO5H0dcAXS3rD7lJqKrrzSIV7kEG9YBiiEWvV0FBKuA7uRvD6/HOzZd62e88fYq7Fy1g31nnPcn+t/kwT74wn1On0wGoWSOYD9+5nxZNIzSOzD3pDXoatI4BIPnQac6lnNc2IE9Q3mlwbjoVTgh7ClfAl0G9c2tSNZwJze8l1BCAbw4czzjLwDWz2HbeeWsw7d6wn6c7vMLRXdZWwFXCgnln5Wtc36utxpG5MWNz63/Vi5AnMwQrnOQcdsmgHsBgHQAYdGZUKZbn9JqE1eC9brdSyz8Af4vKyfQ0en/7NRucsJf90uXbeGHsN2RetK7Fa1i/JjPeGUC9iOoaR+beikzBXysn2Ipm7RlbvpsQniIiKgQA1QInpVie06vnH8rkFvcR6Rdi62X/2Lp5/O/ULq1Du8LqnzbwfOdXOX/qAgDhDWvz3qoJxLWtf40jRXkoXk0v/SBT8Cuc5Bz2yaAeQB9t/Y/eAnlHNA5GlERkcFU+vKUnDapae9lnZGcx4IdFLHWSXvaqqvLpgn+ZNPVXzPnVZq9rG8P0yf2oXi1A4+jcX1zhQb0UyxNCOJHQmsH4+hmxWORKvasI8QlkYrN7aRJ8qZf9c/99ybdH12sdms0PHy7ltbveIvuitdZQkxvjmfbveGpF19A4Mg/g1dx2V4rlCa3IoB5QdAGgq21dV28+7NLt0jxJdT9/piXeSpuatS/1sl/yI59t3aRpXLm5ZiZPW8In8/+1bbvrtpaMH30Xvj5GDSPzHPHtLw3qd0mxvAonlWiFKDlFUQiPslbAT01Jx5STq3VIogT8vXwY0/hurg9piI8JdHkqE7Z9z8y9yzXNGy0WC7Oe/5wPnpqHxWKNo8t91zP5tzEEVQvULC6P4pUAGKz3ZVBf4STnsE8G9QUMMdYr9WomWOSbc1fhbzQyoXNXbomy9rL3sqi8+vcfTFr1PywanGQzMnN46dVFLF2+DQBFgWGDu/DM4zej18vHrbKE1KlOSJ1qAOxetw+zC7Y/dCkFa9TKcxPCg0REhWCxWGd1SQV812HUGxgR34M76ray9bKfs28lbyR9S64GvexzsnIY328qi6b8ZNvW7+W7ePmLpzF6e1V6PJ5KUXzAEGf9IW8fqsX5Czi7NMk57JJRRgFDjFTAd1FGvZ6XO9zIgIRmtl72szatZ8TyJZXayz7lVBpPvjCf/7ZY3z9Go4HXR95J37vaSMs6DRRcrc/KyObITuertyCE8FwR+b3qAY7LFHyXolN0DIzpxCMxnTDmKXib4MdjG3lu45dczKu8NrvnT1/gxcQ3+HvRGmtceh3DZz7KoIn90ekkva90xoJ19SrkbtU0FOGZ5FOfTzHEotNZ8ivgy7p6V6MoCoObt+KZNh3wVcHXYuH73TsY+PO3pOVU/El2z/4Uhj73BQcPpwIQHOTL1Il96XR9wwp/bmFf4cJAsq6+YknRGiFKJ7JQBfyTx+RKvSu6vW4rRsQX7WX/6Nq5nKmEXvbH9p7kmetHs2O1tW2rb4AP4358mZ6Pdq3w5xb2KYXW1csU/IolOYd9MqgvYIhBUUCvs0gFfBfWq0E8rxfqZb/q6GHuLUUv+4yMDDZv3szatWvZvHkzGRnXPm7N+v08/eICzpzNBKBO7SrMePd+GsfXKddrEeUT376B7f4uqYBfsVQH3ITwIOGFKuBLsTzXdUNYQ15t0pug/F72uy6cYODqWRzOTC3R8WXJObav2s0z173CiX3JAFSrVZUp/3uDtj1alOu1iHLyama7K8XyKpjkHHbJoL5Afls7vc4svepd3A3hkbyb2J2qRmsv+92p1l72e6/Sy37Hjh08/fTTxMfHExQURIsWLWjfvj0tWrQgKCiI+Ph4nn76aXbs2HHFsT8u2cyoN74lK9ta6CghrjYz3rmfurWrVuhrFNdWv1U0uvw6BjvX7tE4GvcmRWuEKJ2adariZTRY29rJoN6lNa5al4nN+xLmFYhvDpzIPMvA1bNIOmd/1md5co6/vlnNCze/TtqZdADqNQ7n/dUTiG0eVaGvUZSAvh4owdb7uZul6HYFkpzDPhnU51N0VUAXai2WZ5FBvatrHFqD92/pSe0ivey/Yt2JY7Z9Dh48SI8ePUhISGDhwoV06dKFefPmsWbNGrZu3cqaNWuYN28eXbp0YeHChSQkJNCjRw8OHjyIxaIy65O/ePeD3zHnV5vtdH1Dpk7sS5VgP61etijEx8+b6KaRABzefoyL6VkaRySEEFZ6vY7wetZieSknL5Cbm6d1SKIcIvxDmNS8H/X8Q/AzQXrORR5b9zH/S9lp26c8OYeqqnzzzo+M7zuF3PxuCS0TmzDt73GERYRq9bJFIYqiQEG/estZkFm/opIZtA7AqRhi0Os2gOUCquW8daAvXFZEcBU+uOU2Rv75O3vOnSUzO5v7f1zE9K63cnzl/xg+fDghISHMnz+fPn36YDRe2W6uXbt2DBw4kGnTprFo0SJGjhxJkyZNuKnbw1zIjrDt1+/uNjw2sDM6nXt+++eq4tvVZ98ma0K0e/0+WtzUROuQ3JdclBCiVCKiQji0LxmL2cKpkxeoE1Fd65BEOYT4BDKhaV8m7/iRbReOkq3m8tzG+byccAfnft9arpzj9ja9Sf3rom2/Wx7uzPCZj+JllAr3zkQxNkc1/W39IXcrGCKKP0CUneQcV5Ar9YUVtLUDKZbnJqr7+TE18Vba1qqDv0XFkptH/+HPMGTIEO677z6SkpLo37+/3ZNrYUajkf79+7Nt2zb69evHT99+yJF9f6DTKQwf2pWhg7rIgN4JxbUr1K9+7T4NI3FvMhVOiNKLiA7Fkp9yyBR89+Dv5c2YxnfRMTTO1sv+qTEvMmTIEPr161fmnOPrPz/noGq96v/ga/fy/LxhMqB3RkXW1W/WLg43JzmHfTKoL0QxxBZqayfTZtyFv9HIhE6JdIuOJXvVGs7/vJRx48YxZ84cAgMDAdi+fTv33HMP0dHR+Pn5ERISwo033shPP/1U5LECAwOZO3cub7zxBof2/Eb7pnncdZsUp3FWBW3tQNbVCyGcS0ShCvgnjsmg3l0Y9QaGx3WnV3hrzi3ZzMnP/2LcuHHMnTu3XDnHfrbTZGAUD4y9R9rkOquC6fcgFfBFpZNBfWH6/Ar4eguqWa7UuxMvvZ5+tSJI/eFXBg0axOjRo4v8/vDhw6Snp/PQQw8xffp0xowZA8Add9zB7Nmzr3i80aNHM2jQIN6fPoGDBw9WymsQpVenfi0CqvgD1gr4UrimgkglWiFKLaKgAr4qV+rdjU7R0VkfydHPVjo055i9cIbkHE5M0VUBfX7RwtwdqKpJ03jcluQcdimqZLk2qjkV9fR1pGf6YqItuiqTtQ5JOFDfvn3Zt28fSUlJtm/Li2M2m2nVqhXZ2dns2rXrit+npaXRpEkTGjVqxJIlSyoiZOEAI3uMZ8Nv1m/MvzjwITXrhWkckftIS0sjODiY8JmvofP1KfPjWLKyOfr4a1y4cIGgoCAHRiiE88rNzePO6yag01uIjK3OG9MHaB2ScCDJOTyT5fyLkP09AEq1b1CMzYo/QJSY5BzFkyv1hemqgxJsnYIvV+rdyu7du1mxYgUTJ04s0ckVQK/XEx4ezvnz5+3+PigoiEmTJrF06VJ27txpdx+hvbi2hdfVS796IYRz8PIyUDu8GhYLJJ84j9ls0Tok4SCSc3iuIoN4WVcvKpEM6gtRFCW/WJ4ZLKmolkytQxIO8umnnxIWFkafPn2K3S8zM5PU1FT279/P1KlTWbJkCTfffPNV9+/duzdhYWF89NFHjg5ZOEh8+wa2+zvXyKC+QshUOCHKJCIqFNUCeSYzqSkXtA5HOIjkHB7Mq7ntrirr6iuG5Bx2SUu7yxli0es3W+/nHQVjnKbhCMf4888/6d279zUrzj733HPMmjULAJ1Ox913380HH3xw1f29vb3p3bs3y5cvd2i8wnHi2sba7u9aJ4P6ClHek6SbnmCFuJbI6FD+XWm96nri6Dlq1K6qcUTCESTn8GCGBoAPkC1X6iuK5Bx2yZX6yyiGmEIV8GUKvjtIT09n3759tGnT5pr7Dh8+nGXLlvHZZ5/Ro0cPzGYzJlPxhU5at27Nrl27yMjIcFTIwoGCqgdSp34tAPZuPEiuKVfjiIQQwio8OtSWYJ6UCvhuQXIOz6YoXuCVYP3BfAzVfEbbgITHkEH95QyxKArodBZUy2GtoxEOcOjQIVRVpVGjRtfcNy4ujsTERB588EF+/vlnMjIyuP3224utmp6QkICqquzbJ33QnVVcO+vV+tycXA5skc+1w6lK+W9CeKDI6FAALBY4IRXw3YLkHKLwFHxpbVcBJOewSwb1lzNYk3+93gJ5cqXeHRR86+3n51fqY/v06cP69evZs+fqPc59fX0ByMnJKVuAosLFt5N19RVJVct/E8IT1Y0MQVEUVBnUuw3JOUThYnmyrt7xJOewTwb1l9PVBMVfKuC7kYI1bRcvXiz1sVlZWQBcuHD1AkYF+3h7e5chOlEZ4toVqoAv6+odT4rWCFEm3j5e1KxTBYsFTh47V+wVWuEaJOcQRa/Ub9YqCvclOYddMqi/jLUCfnT+oD4ZVc3WOiRRTlFRUSiKwo4dO666z6lTp67Ylpuby+eff46vr2+x0+i2b9+OoijExsZedR+hreimERh9vADYuebqV0CEEKKyRURbK+DnZOdy9nS61uGIcpKcQyj6mqALs/6QuxVVNWsbkPAIUv3eHn0sBv12QIW8Y+AlfzhdWUBAALGxsaxfv56BAwfa3eexxx4jLS2NG2+8kTp16pCcnMz8+fPZtWsX7777LgEBAVd9/A0bNhAXF1fsPkJbXkYvYltGs2PVbk7sT+FCahrBIUFah+U+yrtGzU3XtwlREhHRoaz72/pl4/GjZ6keJn+bXJnkHAKwXq3P+R3UTMg7AF71r3mIKCHJOeySK/V2KIYY65p6kCn4bqJz584sXrz4qlVl+/bti06n46OPPmLo0KFMmTKFunXr8sMPPzBixIirPm5OTg6LFy8mMTGxokIXDhJfeAr+WpmC70iKWv6bEJ4qIirUtsYzWSrguwXJOYTidWldvRTLcyzJOeyTQb09tgr4KqpZKmW7g4cffphTp06xaNEiu7/v168fy5YtIzk5mdzcXM6ePcuyZcu44447in3cxYsXc+rUKYYOHVoRYQsHKjyol2J5QghnEZFfAV+1WK/UC9cnOYfA2Nx2V5V19aISyKDenoIK+Doz5B3VOBjhCA0bNuTmm29m1KhRpKc7Zs1iWloaI0eOpHv37sTHxzvkMUXFiW9faFAvxfIcS4rWCFFmEVGX2tolHzuncTTCESTnEBgSAL31vlypdyzJOeySQb09+jqA0ToFX67Uu4233nqL1NRUnn322XI/lqqqPPfcc5w5c4YZM2Y4IDpR0ULDQ6hWswpgnX5vsVi0DcidSM9YIcrMz9+bkBpBtiv1UgHfPUjO4dkUnR8Y8tvp5u1FtWRoG5A7kZzDLhnU26Eo+kIV8E+gqvbXRAnXEhkZyfjx45k3bx7jx48v8+Ooqsr48eOZO3cu06dPJyoqyoFRioqiKIrtav3FtCyO7j6hcURCCGEVGR2KxQIXM3K4cL70rdCE85GcQ2BbV2+B3G2ahiLcnwzqr8YQm18szwzmk1pHIxzkgQceYNSoUYwZM4bBgweXelpcWloajz76KGPHjmXChAkMGjSogiIVFSGurayrrxAyFU6Iciloawdw8qhMwXcXknN4NqVIv3qZgu8wknPYJYP6q1AMMdYr9SBT8N3MI08MJfrhe/hs/pfEJzRiwYIFV61QWyAnJ4cFCxbQpEkTvvrqK+bOncuoUaMqKWLhKPHtG9juSwV8B5ITrBDlUrgC/oljZ7QNRjjUsKeeIn5Afz778kviG0nO4VGMTW13pVieA0nOYZf0qb8aQyw6nYqiqJB3BLy1Dkg4yic7/sPvuhbUiK+H93d/MGDAAJ599ll69+5N69atSUhIwNfXl6ysLLZv386GDRtsFWe7d+/OjBkzZPqbi2rQOhqdTsFiUdm5do/W4QghBFCoAr4KJ6UCvltZuG0bXs1bUCsyEpb+JjmHJ9FHgxIIajrkbkVVVRTFPddzC+3JlfqrMcQAoNdbUKVXvds4cOEsPx/aSY5OIbh2LVav+JPt27fTt29f/vzzTwYPHkz79u1p1qwZ7du3Z/Dgwfz555/07duXHTt2sGTJEjm5ujDfAF/qNY4A4FDSEbIyszWOyE1o9K35hx9+SL169fDx8aFdu3asW7eu2P2/+eYb4uLi8PHxoUmTJvz6669le2IhHMxWAd8MJ6QCvttIyczk621JmBTwCQtj5bJlknN4EEXRgVf+1XrLabBILR+HkJzDLrlSfzX6CMCAXmchT6bfuwVVVflw62ryUDHpFJ5p2p4wvwDCGjXivffeAyAjI4N9+/aRk5ODt7c3sbGxBAQEaBy5cKS4trEc2HoYi0Vlz4b9NOuUoHVIrq+81WTLcOzChQsZMWIEM2fOpF27dkybNo1u3bqxe/duwsLCrth/1apV3HfffUyaNInbbruNBQsW0KtXLzZu3Ejjxo3LHrsQDhBUxY8q1fzJSM+UK/VuZO6GDeSYzeQoCg83a0ZMtWpQrZrkHJ7EqzmY/rXeN20B3zqahuMWJOewS67UX4WiGEEfiUFvhrxjqKpZ65BEOf178jAbTx8nW6cQHliFQY3aXLFPQEAAzZs3p127djRv3lxOrm6o6Lr6fRpG4j4Utfy30poyZQpDhgxh4MCBNGrUiJkzZ+Ln58fHH39sd//p06fTvXt3XnjhBeLj4xk3bhwtW7bkgw8+KOerF8IxIqJDsahw4dxFMtKztA5HlNP2lBT+OHCAbEWhqq8vz7TvcMU+knO4P8VL1tU7muQc9smgvji2Ynm5YE7WOhpRDiZzHh8lrSFPUcjTKYxq3QUfg0xU8URx7QpVwJd19U4lLS2tyC0nJ8fufiaTif/++4/ExETbNp1OR2JiIqtXr7Z7zOrVq4vsD9CtW7er7i9EZYuIKlQBX6bguzSLqvLhurWYFchVFIZfdx3BPj5ahyW0YGx26X7uVu3iEFdwt5xDBvXFsbW1A2RdvUv7dv92TmSmka2HdjXC6R7Z4NoHCbcUEV8HvyBfwNrWTlXL8JWtKMpB69vCw8MJDg623SZNmmT36VJTUzGbzdSoUaPI9ho1apCcbP8L2OTk5FLtL0RlK9zW7sRRqYDvypbv38/u1DNkKwoNqlfnviZNr32QcEuKrlr+kl4gdxuqWnznA1ECknPYJZcqi6EUqYB/GLyvnDolnN/Z7It8sWsjJp2CqiiMbXuzVB/1YDqdjri2sWxcnsTZk+c4fewMYeEhWoclgKNHjxIUFGT72dtb2o4IzxFZqAL+CVlX77IumkzM+W8DuQqYFYXRnTpj0Mk1NI/m1Tz/4qAJ8naDVxOtIxK4X84hf2WKY4gGQK+TCviu7OPt68nMyyVHB/0aNCOheo1rHyTcWlzbS1PwpV+98wgKCipyu9oJNiQkBL1eT0pKSpHtKSkp1KxZ0+4xNWvWLNX+QlS28IIK+BaZfu/Kvk5K4szFLLIVhcToGG6IjNQ6JKExxavQFHzTZs3iEEW5W84hg/riGKIBxToFXyrgu6Q951L59fBucvQKAUZvnmvRUeuQhBMoXCxv5xoZ1JeXQjmL1pTy+YxGI61atWLFihW2bRaLhRUrVtChg/0ZVR06dCiyP8CyZcuuur8Qla1aSAABgT6oFjhxVAb1rig5PZ3/274NkwIGvZ6RN96odUjCGRRaV6/mbtEwEPcgOYd9Mv2+GIrig6oPR69PhtxjqKoq07ZdSEELO7MCJgWeb3YdIb7+WoclnEBcu1jb/V3rZFBfbhq0lxkxYgQPPfQQrVu3pm3btkybNo3MzEwGDhwIwIMPPkidOnVsa+SeeeYZOnXqxLvvvkvPnj35+uuv2bBhA7Nnzy573EI4kKIoRESHsnv7Uc6eTifroglfP6PWYYlSmL1hAzkWCzmKwpAWLYiqWlXrkIQzMMQBRsAEMqgvP8k57JJB/bUYYtDrjoOaBZZToJep267if8cPsvXMSbL1CpFBVXkovpXWIQknUSU0mFrRNTh5IIU9G/aTl5uHwUv+HLqSvn37cvr0acaOHUtycjLNmzdn6dKltsI0R44cQVdoHet1113HggULGD16NKNGjaJ+/fp8//330qNeOJWIqFB2Jh0F4OTxc0TXl5zDVWxNTuavQ4fI0SlU9/PjiXbttQ5JOAlFMaJ6JUDuJjAfRrWcQ9HJFz6uxBVyDslir8UQi173p/W++YgM6l1ETl4eM7ettbWwe6XNTXjr5e0uLolrF8vJAymYsnM5mHSE+i2jtQ7JdRWqJlvm48vgySef5Mknn7T7uz///POKbffccw/33HNP2Z5MiEpQuAL+ySNnZVDvIswWS5EWdiOuu54gFy+6JRzMq5l1UA/Wq/XenTUNx6VJzmGXrKm/BsUQg16fvwAjT4rluYpF+5JIvphOth6urxVJ1/DYax8kPEp8O1lX7zAOai8jhKeLKFwB/5hUwHcVv+3by74zZ8lWFOJDQ7lXZgCJyxQulqeaZAp+uUjOYZcM6q9FH2P9j86CKsXyXEJqViZf7t5Mjk4BnY4x0sJO2BHXrlAFfFlXL4RwAhH5FfBVC5yUtnYuIdNk4uONG20t7MZ06oxeWtiJyxmbX7ov6+pFBZC/OtdisA7qDXoz5B3VOBhREnO3ryfLbG1h179Bc+KqhmodknBCMc3r4WW0LsnYuWaPxtG4tnJVoc2/CSEgtGYQPr5GLBY4LlfqXcL8rVs5m5VNtqLQLTaW9uHhWocknJGuNuhCrPdzt6IWrLMRpSY5h30yqL8GRRcAuprodRYwH0FV3fSd4CZ2nTvFb0f2kK1XCPL2YUSLG7QOSTgpo7cXMS2iADi25yRpZ9M1jsiFyVQ4IRxCp9MRXi8E1QJnUtIw5eRqHZIoxvG0NL7dsR2TouBlMDCyo7SwE/YpimJdVw+gpoH5oLYBuTLJOeySQX1JGGKtverVdLCc0zoacRWqqvLB1tWYFYVcBZ5pdj3VfPy0Dks4sfhCU/B3r9unYSQuTk6wQjhMQbE8i0Ul+fh5rcMRxZi1YX1+Czt4pGVLIqpU0Tok4cQKr6uXKfjlIDmHXTKoLwlDrPVKPYCsq3daK47tZ/uZFLJ1EB1cnQfjW2odknByRdbVr5VBvRBCe5HRoVjyU44Tsq7eaW06eYJ/Dx8hW1EI9Q9gWNt2WocknJ1Xc9tdKZYnHE0G9SWgGKLR6SxSAd+JZeflMjtpLbmKglmnMKbtTXjp9FqHJZxcfPtLg/qda2VdfVnJ+jYhHCc86lIF/JOyrt4pmS0WZqxdh1mBPEXh+RuuJ8Bo1Dos4ey8GmMdTAC5m7WMxKVJzmGfDOpLwhCLouRXwLfIoN4ZLdy7ldPZmWTroVOdKLrUjdE6JOECatYLo0poEAC71u6VmhllpSrlvwkhAOuVerBWwD9xVJb8OaNf9+zhwLlzZCkKjcNq0LtRgtYhCReg6ALAkN9ON28PquWitgG5Ksk57JJBfUkYCtrameVKvRM6dTGDr/dsJUenoNPpGNPmJq1DEi5CURTi8q/Wp5/L5PjekxpHJITwdDXrVMHLaJC2dk4qIyeHTzZtxKSARVEY07kzOmmbK0rKq2n+HTPkbdc0FOFeZFBfAoquKuiqW4vlmWVQ72zmbF9na2H3QFxLYquEaB2ScCFxbQtNwV8j/erLRIrWCOEweoOeupHVsaiQknyevFyz1iGJQr7YsoXzOTnkKAq3NWhImzp1tA5JuBCl0Lp6KZZXRpJz2CWD+pIqKJZnOYdqSdM6GpFv+5kUlh/dR7ZeoYqPL8ObX691SMLFxLdvYLu/c60M6stC1rcJ4VgRUdYK+OY8C6eSL2gdjsh39MIFvtu5gxxFwWgw8FLHjlqHJFxNoQr4qmmzdnG4MMk57JNBfUkZYqxX6kGm4DsJS+EWdjqFEc07UsXbV+uwhItp2CbG2j8W2CXF8oQQTiAiOhRL/gV6KZbnPGauX0+uqmICHm3dmjpBQVqHJFyNIQYUf+t9uVIvHEgG9SWk6GMKtbWTQb0zWH50L7vOnSJbBw2qhNC/YXOtQxIuyD/Ij8hGdQE4sPUI2RdzNI7IBclUOCEcKiL6UgV8aWvnHDYcP8aao0fJVhRqBgbyWJu2WockXJCi6MGrifUHSwqqOVnbgFyR5Bx2yaC+pAoq4OstqDKo19zFXBNztq0v0sLOoJO3syibuLaxAJjzzOzbeEDjaFxQeafBuekJVoiykkG9c8mzWJixbj15+S3sXrzhBvy8vLQOS7gqWVdfPpJz2CWjoJIyWJN+vc4i0++dwNd7tpCa38IuMTyWjrWjtA5JuLCi6+r3aRiJEEJAnYhq6PQ6awV8mX6vuZ937+Lw+fNkKwrNa9bkjrh4rUMSLkyRdfWiAsigvqR0IaAEWQf15sNaR+PRkjPTWbg3iRydgkGv55U2XbQOSbi4uHaFKuDLuvrSk6lwQjiUl5eB2uHVsFjg5LFzmM0WrUPyWGk52Xy6aZOthd3Yzl2khZ0on0KDerlSXwaSc9glg/oSUhTFWgFfbwbLaVRLptYheaxZ29aSbckjRwcPx7ciKqia1iEJFxeZUBcff28AdkkF/NKTE6wQDhcZba2An2syk3pKuu5o5fNNm0gzmchRFHrFxdO8Vi2tQxIuTtGHgN5ay4fcbahqrrYBuRrJOeySQX1pGKILFcs7qm0sHmpr6kn+PH6AHL1CdV9/nmomLexE+en1ehq2sS6xOX30DKknZLpraUh7GSEcLzwqBEt+yiFT8LVx6Nw5fti1ixxFwcfLixc73qB1SMJd2K7WZ0OeXEwoDck57JNBfSkohthLbe2kWF6lu7yF3XMtOhJk9NY6LOEm4gtNwZer9UIIrUVGh9muKJ04ek7bYDyQqqp8tH4deYAJeLxNW2oGBGodlnATSpFieZu1CkO4ERnUl0Z+BXydTirga2Hp4d3sPZ9Ktg7iq4bRt35TrUMSbqRIsbw1MqgXQmiroAK+xQInpQJ+pVtz7Bgbjp8gW1GoHRTEkNattA5JuJMixfJkXb0oP4PWAbgUQwxgbWtnkQr4lSrTZGLu9g22FnZj296MXlrYCQeKaxdru79rnQzqS6W8a9TcdCqcEOVRN7I6iqKgWlROyPT7SmUym5m5fp2thd3LHW/ExyAt7IQDeTUCvIBcuVJfWpJz2CWjotLQ1QLFL78CvgzqK9OXuzdxLuci2XroHtmADrUitA5JuJlqNatSI9J6ZWzP+v2Y88waRySE8GQ+vkZq1K5ibWt39Cyq6qaZqBP6YddOjl1II1tRaF27Dj0bNLj2QUKUgqIYwSu/NaL5IKrlgrYBCZcng/pSUBQd6POL5ZlPoqo5WofkEY5nXGDx/m3k6BS89AZGtZYWdqJiFFytz76Yw6HtUgyzpKRojRAVIyI6FIsFsrNyOZuaoXU4HuFcVhZfbN6CSQFVURjTubO1A5IQjlZkXf1WzcJwNZJz2CeD+tIyxGDQmwEV8o5pHY1HmJm0jhyLmRwdDEpoQ0RgFa1DEm4qvp2sqy8zaS0jhMNFRIWgSgX8SvXp5k1k5Fpb2PVOSKBJjRpahyTclCL96stOco4ryKC+lKQCfuXaeOo4/5w8SLZeIdQvgCeattc6JOHG4qQCvhDCiUREh1Ew6/6EFMurcPvPnuWX3bvJURT8jEZeuF5a2IkKVKRY3mbt4hBuQQb1pWWrgK9KBfwKZrZY+DC/hV2eTuGFljcS4CUt7ETFiW1RD4OXHoCda/doHI0LKc835m7+zbkQ5RGZXwFftciV+oqmqioz1q21tbAb1rYdof7+Wocl3Jk+HJSq1vu5W6VuRklJzmGXDOpLq6ACvs4MeYc1Dsa9/XJoNwfSzpKthybVa9IntonWIQk35+3rTXSzegAc2XmcjPOZ2gbkImR9mxAVI7xeCGBtaydX6ivWv0eOsPlkMjmKQnhwFR5p2VLrkISbUxQFjM2tP6jnwSzjipKQnMM+GdSXlr4uYLROwZcr9RUm3ZTDxzvWk6tTMCvWFnY6KVQjKkF8oSn4u9fv0zASIYSn8w/0ISQsCDV/UC9X8iqGKS+PWYVa2I288Ua8DdL1WVS8ouvqN2sWh3B9MqgvJUUxgCEqvwL+cVQ1V+uQ3NIXuzZy3pRNtg5uqxdHmxp1tQ5JeIii6+plUF8iMhVOiApTUAE/Mz2H9AsXtQ7HLX27Ywcn0jPIVhTa161Lt9hYrUMSnqLwunopllcyknPYJYP6sjDEWAf1mMF8Quto3M7R9PN8u387OToFo8GLkdLCTlSi+PaXBvWyrr5kZCqcEBWncAX8E0fPaRuMGzp78SLzk7ZiUgCdjjGdu0gLO1F5vJoC+e83kwzqS0JyDvtkUF8GUgG/Yn2UtIZc1YJJB481bkudgCCtQxIepHZMTYKqBwLWCvgy3bUE5FtzISpMRHSoVMCvQB9v2khmbi45ikLfxo2JDw3VOiThQRRdoK1eF3m7UNVsbQNyBZJz2CWD+rIwxKDTqSiKCnkyqHek9SnHWJ18hGy9Qk3/QB5v3E7rkISHURSFuHbWqZcXUtM5eSBF44iEEJ4sIiq/Ar4KJ2VQ71B7z5xhyZ69ZCsK/t7ePHvd9VqHJDyRbQp+HuRu1zQU4bpkUF8WemvCr9dbpK2dA+VZLHyYtMrWwu6lVp3x8zJqHZbwQHFtC03BXyP96q9JvjUXosJE5Le1s1jghLS1cxhVVflw7VrMCuQCT7dvT4ifn9ZhCQ9UtFieTMG/Jsk57JJBfVkYIgF9frE8aT/hKD8d3MHhtPNk6aF5SC3ujG6kdUjCQ8W3b2C7v2utDOqvRda3CVFxgqv6E1zVH9Us0+8d6X+HDpGUkkKOolCvalUebN5C65CEp5JieaUiOYd9MqgvA0Uxgj7Cuq4+7xiqatY6JJeXZsrm053/YdIpWBSFV9slSgs7oZm4tpcqH0uxPCGE1iKiQrCocOHcRTIzZM1teZny8pi1Yb2thd0rN3bCqNdrHZbwVIb6oOTPEpFieaKMZFBfVoZYDDozYAKzrLktr892buSCKYccHdwVnUCL0NpahyQ8WEAVf8Lj6gCwf/MhTNkmjSNycjIVTogKFREdWqgCvlytL69vdmwnOSOTbEXhhohIboqO1jok4cGs7bIbW3+wnEA1n9I2IGcnOYddMqgvqyIV8GUKfnkcSjvH9wesLex8vIy81KqT1iH9f3v3Hh5lfecP//2973tyPpEzhwRyKCQBBOQQRBQU20V33e4uPquV7q4sYJW1FmXbisa2T61199mWtVqRarR9+hRb++Cv/XW7K1Xrur1qIQGRg4SEM0nIiZyPc7y/vz9mMpmRSSBzumcy79d1zZXJYe755Log8/nM9/v9fIjczfLsNgfOfnzB4GgiHF9giUJqNov6oOkcGsIbx50j7ISioGrNGo6wI+PF8Vz9dWPO4ROLej8Jrw74TUaHE7WklNh9/ADsUsKqAA8vrER+cqrRYRGhvNLzXP1ZAyMholhX4NkBn83yAvLakY8wYrfDIgTuv+EGzM3ONjokIgjTYvd9aTtqWBwUvVjU+0tzdcBXdEiu1PvtYFsTDnU0w6wKzEhJw4PzVxgdEhEAoLzSowM+z9VPiE1riEJrtqsDvtS5Uh+I+itX8M7ZczALgbSEBGy/aZXRIRE5eXXAP25cHFGAOYdvLOr9pRUBEM4t+Bxr5xerw4GXTxyE3TXC7omla5GgmYwOiwgAULSwEPGJzpGK7IB/DdwKRxRSmTmpSE5JgK4Dbc09RocTlaSU2F1b6x5h95WVN2FaYqLRYREBAISaCyiuflK2E2zCPRHmHD6xqPeTEImAOtM11q4RUk7RfyEh9OvzJ9E02AuzCizLnYm7i8qNDonITdVUzF1WAgBou3gFPe29xgZERDFLCIHComxIHejsGIB5hM07J+v9CxdwsqMDZiFQkpWFLy5adO0HEYXT6Ll6OQzYuZhAk8OiPhBaKVTVAcgRQL9idDRRpccygp+eOuIeYfeNFevYqIYijvcWfL7Ajodb4YhCr7A4B7qrWV4rV+snxWyz4dXDh2ATgMM1ws7EEXYUYYTXFvyjhsUR6Zhz+MaiPhBaqXOlHgAcbJY3GT+uO4xBuxUWBbindAFuyJ5udEhEVynzLOoPsqgfF7fCEYWc51g7FvWT8+Ynn6BjaBhmIbBmzhysLSoyOiSiq3kU9ZLn6sfHnMMnFvUBEGoJVFUCAoCdzfKu17neLvznxXpYFIEkUzy+duMao0Mi8ql85VhRX1/Lon5cfIElCrlCjw74LU1dBkcTPdqHhvCLT07AKgBVVVG1Zq3RIRH5ZpoPQHPe50r9+Jhz+MSiPhDsgD9pUkq8dOIg7HCOsNt2w0rkJqUYHRaRT9kzs5AzKwsA0FB7Fg4HG9cQkTEKS9gB3x/Vhw/D4nDAIgS+uGgRSjIzjQ6JyCchEgCtzPmJ/RykPmBsQBRVWNQHQisGAKiKA7CzA/71+GPLRXx85TLMikBBagY2Vyw3OiSiCZVVOt+8Gxk0o/HUZYOjiUwiCDcimlhufjriE0zQdW6/v14n29vx/vnzMAuBaYmJ+MrKm4wOiWhio83yIDnabhzMOXxjUR8AoaQCSh40lR3wr4fVYceeT2rcI+yeXHYbEjTN6LCIJlReOdd9n+fqxxHBW+G6u7uxceNGpKWlISMjA5s3b8bg4OCEP//lL38Z8+bNQ2JiIgoLC/Hoo4+ir68vdEESXQdFUVDg6oB/pa0PVqvN6JAimi4lXqqtcY6wEwLbV61CekKC0WERTUhwXv21MefwiUV9oLRS56x6OQDovUZHE9HeOnsSLUP9MKtAZV4B1s+ee+0HERnMs1ke59VHn40bN+LkyZN499138dvf/hZ/+MMf8OCDD4778y0tLWhpacH3vvc9fPLJJ/jJT36C/fv3Y/PmzWGMmsi32a5mebou0X651+hwItp7586hobMLZiEwNysLX1h4g9EhEV2babH7ruS5+qhjZM7BZdJAaSVQlQPO+45GQJ1mbDwRqts8jJ81OEfYSY6woyjymaXFUFQFukPHqZrTRocTkQIdEROq8TKnTp3C/v37cejQISxbtgwA8OKLL+Kuu+7C9773PcyYMeOqxyxYsABvvfWW+/OSkhI8++yz+OIXvwi73Q6Nu4vIQAVFY2PtWpp7UOBqnkfehq1WvPrRYfcIu6o1a6EpXMeiKKDOBkQGIHsB61FIKZkvfwpzDt/4Fy5AQiuFoujOAxpsljeu108ewpDdBosC3Dd3EeZn5RkdEtF1SUiKR/ENswEAl042Y3hgxOCIIlCEboU7cOAAMjIy3C+uAHDHHXdAURTU1NRc93X6+vqQlpbGgp4MN7t4rAN+Kzvgj+sXJ06ga3gEZiFwR3EJVs+ebXRIRNdFCAGYXLtKZA9HZvvCnMMnFvWB0kogxGgHfDbL8+V0Tyf+61IDLKpASlw8diy5xeiQiCal3LUFX0qJhkNnDY5m6urv7/e6WSyWgK7X1taG3Nxcr69pmobMzEy0tbVd1zU6OzvxzDPPTLh9jihcCos9O+CzWZ4vbQMD+OXJT2AVgKaq2HnrrUaHRDQpwt0sD4DtmHGBTHFTLedgUR8orQQAO+CPR0qJl44fgEMAVgF8edEqZCcmGx0W0aR4n6tnUe9TEN4xLygoQHp6uvv23HPP+XyqJ554AkKICW/19fUB/0r9/f348z//c1RUVOBb3/pWwNcjCtT0mdNgMqmQ7IA/rlcOH4ZF12ERAg8sWYKiaTwWSVHG61w9i3qfmHNchXsJAySUTEglE6o6CFhZ1H/aHy5fwPGuVphVgTlpmXigfNm1H0QUYcpXjhX1PFd/tWCdb2tqakJaWpr76/Hx8T5/fseOHXjggQcmvGZxcTHy8/PR0dHh9XW73Y7u7m7k5+dP+PiBgQGsX78eqamp+NWvfgWTyXTtX4QoxFRNxczZWWi61IH2lh447A6ommp0WBHjeFsb/ufiRVgUgaykJPxT5UqjQyKaPJNHU0c2y7sKcw7fWNQHg1oKVTkC6N2Q+oBz1B3BYvceYffU8tsQpzL5oOgz8zPTkZKRjMHeIdTXnGHjmhBJS0vzeoEdT05ODnJyrt0g7KabbkJvby8++ugjLF26FADw/vvvQ9d1VFZWjvu4/v5+/Nmf/Rni4+Pxm9/8Bgkcg0URpLA4B40XOmC36+ho68f0WVyJBgCHrnuNsNtx881IGydJJ4pkQkmHVIsAxwXAdgpSWiFEnNFhTTlTLefg9vtg0EqcY+0AbsH3sO/sCbQND8CsAqunz8YdBaVGh0TkF0VRUFbp/Pfb096H9ktXDI4owkRo05ry8nKsX78eW7duRW1tLT788EM88sgjuO+++9xdaC9fvoyysjLU1tYCcL64fu5zn8PQ0BBee+019Pf3o62tDW1tbXA4HKEJlGgSCotyoLv+KbY0dRsbTAT53dkzONvVjREhUJ6Tg/9r/gKjQyLyn3tevQ2w1RkaSsRhzuETi/ogEFoJVMVV1LMDPgCgc2QIP2s4CosiAEXB0xxhR1GubAXn1Y9ndCtcILdQ2bt3L8rKyrBu3TrcddddWL16NV555RX39202GxoaGjA8PAwAOHLkCGpqanDixAmUlpZi+vTp7ltTE7sQk/EKPTrgt7ADPgBgyGrFa0eOwCYAXQh8Y+1aqBxhR1FMxC0e+4Tn6r0w5/CN2++DQSuFEICi6NAdTWDpClSfPIQRhw0WTeDv5i3GvGmcpUvRrXzlXPf9UwfPYO29NxsYTYQJ9J3vEL7AZmZm4o033hj3+3PmzIGUYwGsXbvW63OiSOM11o7N8gAAPzt+DD0jZpgVgfWln0HlrAKjQyIKjHulHpC2oxD4BwODiTDMOXzi25jBMNoBX9UBO1fq63s68LvG0zCrAmnxCXhs8WqjQyIKWNmKseMjbJZHREaZUZgFRRHODvjcfo/L/f34VV0drELApGkcYUdTgzYXgOtsNVfq6TqwqA8GJRcQqdAUHYjxWfVSSvzw+AE4hIBNANsXr0ZmQpLRYREFLC0rFTM/Mx0AcPbji7BabAZHFDkieSsc0VQTF6dhRkEmdB1ovdwDXdeNDslQPzpU6xphB2y+cSkK0tONDokoYEKYAJOrL4SjGdLBozajmHP4xqI+CIQQrmZ5DkDvgNSHjQ7JML9vPoeTXe0wK0BJRhb+rmyJ0SERBc1oszybxYbzxy4aG0wkidCmNURTVUFRDqQOWC12dF0ZMDocwxxpacGHjU0wC4Gc5BQ8vGKF0SERBY/HFnyu1ntgzuETi/pg0Uo9muXFZjMls92GV07UwCYEHIpA1fLbYVI4wo6mjvLKsXP19TVnDYyEiGJZYXEORhfoY7UDvl3Xsbu2FnYB2IXAV1evRkocx37R1OHZLE9yXj1dA4v6IBGeY+1idAv+L84cxxXzEMwqsHZmMW6bVWJ0SERBVVY51gGf5+o98F1zorCaXZzj/n8Tq0X9f50+jQs9PTALgYV5efibigqjQyIKLq7U+8acwyd2vw8WrcTVAV9CdzTGXAf89uFB/KLhGCyKgKqoqFp+u9EhEQVd8Q2FiEswwWq2caydh0DPqE3V821EoVJY5OyAr+ux2QF/0GLBTz4+AqtrhN3Ta9ZC4dhcmmKEmg+p5AF6O2A7DikdEII7YJlz+MaV+mBRnWdtVdUB2GNvpf7Vk7Uw63ZYFODvypagNCPL6JCIgs4UZ0LpjcUAgJZz7ei90mdwREQUiwqKsgEAUo/NlfqfHjuKXosFFiHwF/PmYdnMmUaHRBQao6v1cgiwnzc2FopoLOqDRZ0BiETnuXpHbI21+6SrHb9vOguzKjAtIQnbOcKOprByjy34DbU8Vw+AW+GIwiwhMQ55MzLcY+2CNec4GjT19uLXp07BIgTiTSZ8ffUtRodEFDKe5+rBc/VOzDl8YlEfJEIogFrsKurbIKXV6JDCQpcSL42OsFMEHl+yGunxCUaHRRQynkX9qYPcgg8AQsqAb0Q0OYVFzmZ5I8NW9HYPGR1O2Lx8+BBsUsIKYOvSZZiZlmZ0SESh43GuXvJcPQDmHONhUR9M7mZ5OmBvNjqasHi38QzqezpgVoB5Gdn4wtzFRodEFFLlKz2K+loW9URkjMJi51g7ALgcI1vwDzU3o6apGWYhkJ+aii8tX250SEShpc0H4DpHz6KeJsCiPoiE11i7qX+ufthmxasnD7lH2D29Yh00hf+kaGrLKchGZn4GAKC+5gz00blSsYxb4YjCbnZxDkYXnNpioKi36zp2HxobYfe11bcgyWQyOiyikBJKEqC5xunaz0Dqg8YGFAmYc/jECiyYtBIoioSiSMgYOFf/89PH0OUaYXdHQSlWz5hjdEhEISeEcK/WD/ePoKmhxeCIjDfaiTaQGxFNToGrA77UY2Ol/rcN9Wjs7YNZCCyZPh2fLyszOiSi8DAtdt3RAdsnRkYSEZhz+MaiPpg0Vwd8Zep3wG8dGsCbZ47Doghoqoqnlt9mdEhEYVNWOdd9n+fqwXfNiQxQWOzsgK+7muVNZf0WM37y8cfuEXbfWLsWgiPsKEYIr3n1Rw2LI2Iw5/CJRX0wqQUATM5z9XqT0dGE1Cuf1MCiO2BRgE3ly1CUlml0SERh49ksj/PqicgIKamJyMpJdXbAb57aRf1PP/4Y/VYrLELgr8vLsSh/utEhEYVPHJvl0bWxqA8iITRAK3Keq7c3Q0qb0SGFxLErrfjg8nlYVIGsxGQ8smiV0SERhdXcZcVQFOcq0ama0wZHYzxuhSMyRkFRDnQJDPSb0d87bHQ4IXGxpwf/u74eFiGQYDLhq6s5NpdijFoEiFTnfduxmBph6QtzDt9Y1AebVuJqlmcHHK1GRxN0Dl33GmH3zzfegrS4eKPDIgqrxJREzFlQCAC4eKIRI0NmgyMyGLfCERlidnEOpMN5v2UKbsGXUuLlQ7WwA7ACeHjFCuSnpBodFlFYCaGMjbbTOwE9xnv5MOfwiUV9sKmjY+0wJTvg/+7SaZzp64RZBcqn5eJvS28wOiQiQ4xuwdd1idOHzxkcDRHFooKibHcH/Km4Bf9gczMOX26BWQjMTE/HlqVLjQ6JyBie5+qtRw0LgyIXi/ogE1opFEVCCDnlmuUNWa2ornONsBMC36xcB5Uj7ChGlXmdqz9rYCTG41Y4ImPMLs4FAEgJtDT1GBxNcFkdDuzxGGH3xOpbkKBxhB3FJsFz9W7MOXzTjA5gyhntgK/qsDsaMZV6s/6s4WP0WEZg1gTunD0XK/MLjQ6JyDCjY+0AnqsPeDvbFH2BJQq1wmLnWDtdn3rb7/93/Sk09/XDrAgsnzkTd82de+0HEU1VJo+dsTFe1DPn8I3LrMGmzQGgOM/VT6Ht95cH+/DWuU9gUQRMqoYnl3GEHcW2grKZSEpLBOAcaxfrjWuIKPwyMpORlpE05Trg94yM4P87egxWAUgh8PQajrCj2CaUTECd7fzEdhJSWo0NiCIOi/ogEyIOUGc7z9XbGyFHO9hEuT0nxkbYbZm/HAWpGUaHRGQoRVFQtsK5M6e7tQdXmrsMjshY3AZHZIzCohzoOtDbPYShKdK08ydHP8agzTnC7p7587EgL8/okIiM5z5XbwXs9YaGYjTmHFdjUR8KWglUxQHACjjajY4mYEc6LuOPrRdhVgVyklKw7YaVRodEFBHKVnBePQDngd5Ab0Tkl8LiHEhXf97WKXCu/lx3N/6zoQEWIZAcH49/vpkj7IgAQHg1y4vhLfjMOXxiUR8KWgm0KdIB3+4xws6uCHztxjVIMXGEHREAlK8cO+N56mDsFvVsWkNknMLi7LGiPsq34Espsbu2xj3CbtuKFchJTjY6LKLIELfYfTeWm+Ux5/CNRX0IeHXAj/Ki/j8v1uN8fzfMKrAwKx8bShcYHRJRxCirLHXfr6+N3aKeiIxT6NUBP7qL+g8bG3G0tQ0WIVCQnoFNS240OiSiyKHNAxDnvB/DRT35xqI+FEY74Cs6pKPJ4GD8N2C14Md1h2FTnCPsvrFiHRQ2qiFyy8hJx/Ri51nP04fPwW6zGxyRQWQQbkTkl9muDvhSB1qjuKi32u34kccIu5233op4jUOaiEYJEQeYXItrjkuQevT+fw8Icw6fWNSHglrk/KDqgP2SwcH476f1R9BrNcOsAH8xpwzL82YZHRJRxBldrbeabbhwIrp35vhL6IHfiMg/WTmpSEqOd461i+Lt9/+rrg4tA4MwC4GVs2bhz0pLr/0goljjNdruuHFxGIg5h28s6kNAKEmAOss11u5SVI66ahzowa/OnYRFEYjTTNjJEXZEPpVX8lw9ERlHCOFultfZPgCLOfpGXXUPD2PvieOwCgCKgqfX3sYRdkQ+CNNi930Zy83y6Cos6kNFK4GqOgA5AuidRkczaS+fqIFN6rAqwJcWrMDMlDSjQyKKSGWVYx3wT9WcNjASA3ErHJGhCoudY+0AoPVy9HXAf/3jIxiy2WARAvcuWIDynByjQyKKTHEeHfBj9Vw9cw6fWNSHilriXKkHoq5ZXm17Ew62NcKsCuQnp+KhBZVGh0QUsUoWz4EpznnuM1bH2rETLZGxCouyo3as3ZmuLrx9+gzMrhF2j6262eiQiCKXMgNQXG962Y5Byim6l3wCzDl8Y1EfIkIrhapKQACwR09Rb9Md2O0xwu7rS9ciyRRndFhEESsu3oSSJc4+Gs2nW9HfPWBwREQUazw74F+OomZ5Ukq8VFMDhwBsAB5duRLZSUlGh0UUsYQQY+fq5QDguGBsQBQxWNSHilYCYLQDfvQU9f9x4RQuDfRiRAUWZ0/H54srjA6JKOKVe2zBb6g9a2AkBpEy8BsR+a2wKBuAswN+WxQ1y/vDxYs40d4OsxCYM20a/n7xEqNDIop4nufqEYvn6plz+MSiPlTcRb0jajrg91nM+EndR7AqAroQ+GblHRxhR3QdvM7Vx2CzPG6FIzJW7vQMxCeYnB3wo2Sl3mK34UeHD8EuAIcQeOrWNYhTVaPDIop8prFz9TIGz9Uz5/CNRX2ICCUNUHKdY+2iZKX+p/VH0G+zwKIAf108H0tyZhgdElFUKF85VtTX18ZeUU9ExlJVBQVznOfqO1r7YLXajQ7pmvadrEPb4BDMQmB14WzcXlxsdEhE0cG0AO4SznbUyEgogrCoDyWtBJqqA7IfUu81OpoJXezvwa/PO0fYJZji8PWla4wOiShq5M/JRUaOc0JEfc2ZqBxjGRB2oiUyXIGrWZ6uS3S09hodzoQ6h4bwhmuEnVAUVK1ZwxF2RNdJKCmA5lpMsDdA6sPGBhRuzDl8YlEfSlrpWAf8CG6WJ6XE7uMHYJcSVgV4eGEl8pNTjQ6LKGoIIVDmWq0f6BnC5TOtBkcUXtwKR2Q8z7F2kb4Fv/qjjzBit8MiBO6/4QbMzc42OiSi6OLegq8D9pOGhhJuzDl8Y1EfQkIrhaLozg74jsg9V3+wrQmHOpphVgVmpqTjwfkrjA6JKOqUrYjhc/VsWkNkuNkeHfAjuaivv9KBd8+dg1kIpCckYPtNq4wOiSjqCI9z9bAeNSwOQzDn8IlFfShpJRAisjvgWx0OvHziIOyuEXZPLFuLBM1kdFhEUad85Vz3/VMxOq+eiIxT4NEBvzVCO+BLKfFSba1zhJ0Q+MpNN2FaYqLRYRFFH48O+LHYLI+uphkdwJSmlQJwFvWOCN1+/+vzJ9E02AuzJrA8dxb+Yk6Z0SERRaV5y0sghICUEvU1p40OJ6wC3c42VbfCEYXTjFmZ0DQVUnegpanH6HB8+v2F86jruAKzIlCamYmNNyy69oOI6GpaMSCSATkUc83ymHP4xpX6EBJKJiCmOc/VR+BKfY9lBD89dQRWRUAKgW+sWMdGNUR+Sk5LwuyKWQCA88cbYR62GBxRGLFpDZHhNJOKmbOzoEugvaUHDrvD6JC8jNhsqD58GLbREXZr1sDEEXZEfhFCBUw3OD/ROyAdbcYGFE7MOXxiUR9qWglU1QHoXZD6oNHRePlx3WEM2q2wKMA9pQuxMDvf6JCIotrovHqH3YGzR84bHA0RxZpCVwd8u03HlfZ+o8Px8uYnJ9AxNAyzEFhbVIQ1c4qMDokounmeq4+x1Xq6Gov6UNNKnbPqgYjqgH+utwv/ebEeFkUgyRSPr954q9EhEUW98kqPZnk1Zw2MJLzYiZYoMkRqB/z2oSG8+cknsApAVVVU3brG6JCIop7wPFdvjZ1z9cw5fGNRH2LCc6xdhGzBl1LipRMHYYdzhN0/3XATcpNSjA6LKOqVr/Qs6mPoXL0uA78RUcAKi3PdW0tbI6iof/XwIVgcDliEwN8tWozizEyjQyKKfrG6Us+cwycW9aHm6oCvKDpkhIy1+2PLRXx85TLMikBBagb+sWKZ0SERTQmFFbOQmJIAAKhnB3wiCrNCVwd8XQdaIqQD/ift7fjv8xdgFgLTEhPx6MqVRodENCUINQtQnb18YDsJKW3GBkSGYlEfaloJADi34EfA9nurw449n9S4R9g9tfw2JGgcgkAUDKqqYt5y5//5K01d6GyJjKQ65Ni0higizJqdBUURkHpkbL/XpcTu2hr3CLvHVt2M9IQEo8MimjrcW/DNgD1Gdggy5/CJRX2oKXmASIam6IDeZHQ0eOvsSbQM9cOsAivzC/FnhXOv/SAium5lK8a24MfKar1AgOfbjP4FiKaIuHgT8mdOg64Drc090EcP2BvkvXPn0NDZBbMQmJuVhfsWLjQ0HqKpRnhtwY+Nc/XMOXxjUR9iQghXszwH4GiD1EcMi6XbPIyfNThH2EFROMKOKATKV469UXbqYGwU9UQUOQqLcyB1wGqxo+vKgGFxDFutePWjsRF2T6+9DZrCtJMoqLya5R01LAwyHv+6hoNXszzjVutfO3kIQ3YbLApw72duQEVmrmGxEE1VZZWl7vv1tTFS1EsZ+C1Euru7sXHjRqSlpSEjIwObN2/G4OD1jReVUuLOO++EEAK//vWvQxYjUTDNdhX1gLHN8n5x4gS6hkdgFgKfLSnBzYWFhsVCNGWZygGYnPdjZKWeOYdvLOrDQGglY2PtDOqAf7qnE29faoBFFUiJi8eOJbcYEgfRVJeZPw15s3MAAKcPnYPD7jA4otCL5PEyGzduxMmTJ/Huu+/it7/9Lf7whz/gwQcfvK7HPv/889zNRFGnoCjHnbMa1SyvbWAAvzzpHGGnqSp23sqxuUShIEQcYKpwfuK4AKn3GRtQGDDn8I1FfTioox3wJaQBRb2UEi8d/xMcArAK4NFFNyM7MTnscRDFitHVevOwBRdPGt9LI+QitGnNqVOnsH//flRXV6OyshKrV6/Giy++iF/84hdoaWmZ8LFHjx7F97//fbz++uuhCY4oRGYXO99U1HWgtanHkBheOXwYFl2HRQhsWnIj5mRMMyQOopjgda7+uHFxhAtzDp9Y1IeD5kzwVcUB2MM/1u5/Ll/A8a42jCgCRemZ+IfypWGPgSiWlFeOnas/8sFxHD16FDU1NTh69Oh1b8OiwB04cAAZGRlYtmxsbOcdd9wBRVFQU1Mz7uOGh4dx//3346WXXkJ+fn44QiUKmgLXWDujOuAfb2vD/1y8CIsQyEpOxj9VVoY9BqJYIjzO1Q/21DDnMIjROQdnmYWDOhNAAlRVh80e3lU7i92GPScOwi4EHIrAU8tvR5yqhjUGolhjyhVokEfRZ+rE7x97C9Lj/JYQAvPmzcNnP/tZPPTQQ6ioqDAw0uAQUkIEcEZt9LH9/f1eX4+Pj0d8fLzf121ra0NurnfvEE3TkJmZiba2tnEf99hjj2HVqlX4/Oc/7/dzExklMSkeufnp6O7qQ0tzD6SUYTtG4tB1vOQxwu6fV92M1AD+DxPRtdWdScCeFzrw3h9saDj7NeYc1/F4YOrlHFypDwMhFEArdjbLc7RASmvYnvv/P3sC7SODMKvALTPmYN2skrA9N1GsuXDhAu688058/ot/geHMXmzc8gW89tprOHjwII4fP46DBw/itddew2233YY333wT8+fPx5133okLFy4YHXpg9CDcABQUFCA9Pd19e+6553w+3RNPPAEhxIS3+vp6v36V3/zmN3j//ffx/PPP+/V4okhQWJwDXQdGhizo7R4K2/P+7uwZnO3qxogQqMjJwT3z54ftuYlizWjOsWDRZ/HL/9Bw2x3/wJwjhnMOrtSHi1YKVW0AoAP2y4CpKORP2TkyhL0Nx2BRBISi4Onlt7PpE1GIVFdXY/v27cjOzsbevXtxzz33IC4u7qqfq6ysxKZNm/D8889j37592LlzJxYuXIjnn38eW7ZsMSDyyNHU1IS0tDT35+O9Y75jxw488MADE16ruLgY+fn56Ojo8Pq63W5Hd3f3uFvc3n//fZw7dw4ZGRleX9+wYQNuueUWfPDBB9f8PYiMVlicg48OnAXgnFc/LSsl5M85ZLXitSNHYBOALgS+sfY2qBxhRxQSzDkCN9VyDhb1YSK0Eo+xdo1hKepfPXkIIw4bLJrA389bgrnTckL+nESx6Nlnn0VVVRW2bNmCXbt2ITU19ZqPiYuLw/3334+7774bjz/+OLZu3Yr29nY89dRTYYg4uIK1FS4tLc3rBXY8OTk5yMm59t+zm266Cb29vfjoo4+wdKmzl8j7778PXddROc453yeeeOKqRGfhwoX493//d9x9993XfE6iSFDo2QG/qQsViwpC/pw/O34MPSNmmBWBOz/zGayYNSvkz0kUi5hzMOfwhW+hhotWAkWREEJCOkLfLO9UdzveaTwNsyqQHp+IxxavDvlzEsWi6upqVFVV4ZlnnsGrr77qfnH94IMPxt2mdfDgQffjU1NT8eqrr+Lb3/42qqqq8Nprrxn1q/gvQjvRlpeXY/369di6dStqa2vx4Ycf4pFHHsF9992HGTNmAAAuX76MsrIy1NbWAgDy8/OxYMECrxsAFBYWoqgo9G/GEgVDoasDfria5V3u78ev6upgFQImTcPOWzjCjigUmHOAOcc4uFIfLq4O+JrqgC3EY+2klPjh8QNwCAGbIrB98c2YlpAY0uckikUXLlzA9u3bsWXLFlRVVfn8mUcffRTLly/3+lppaelVP1dVVYXGxkZ85Stfwe23384CMkj27t2LRx55BOvWrYOiKNiwYQNeeOEF9/dtNhsaGhowPDxsYJREwVXoOdauOfRj7X50qNY9wm7b0qWYlZ4e8uckijXMOSKfkTkHi/pwUQsBmJwd8ENc1P+++RzqujtgVgVK07PwxbIlIX0+oli1bds2ZGdnY9euXeP+zC233IJ77rnnmtcSQuD73/8+3nnnHWzbtg1vv/12MEMNLSmBALbCBfTYa8jMzMQbb7wx7vfnzJnj1SnYl2t9nyjSpKYlIjM7Bf19gyFfqT/S0oIPG5tgVgRyU1Lw8PIVIX0+oljFnMOFOYdP3H4fJkJogDbHea7e3gwp7SF5nhGbFa+cqIHNNcKuavntMCkcYUcUbHV1ddi/fz+++93vXvM828DAAOz2a/+fT0tLw3PPPYf9+/fj1KlTwQo15IQM/EZEwVVYnANdAgN9IxjoC81OFLuuY3dtLewCsAuBr968Gsk+mnURUWCYc4xhzuEbi/pwUkeb5dkBx/jzCgPxizMncMU8BLMK3DarGGtnFYfkeYhi3Z49e5Cbm3vNd8Q3bdqEtLQ0JCQk4LbbbsPhw4cn/PkNGzYgNzcXL7/8cjDDJaIYU1CUA+lw3m8J0Rb8/zp9Ghd6emAWAjfk5eGvp8AMbKJIxJyDroXb78NJK4Gq/s5533EJ0ILbGbZ9eBBvnnaOsFMVFVXLbw/q9YlozLvvvosNGzb4HCEDODvNbtiwAXfddReys7NRV1eH733ve7jlllvwpz/9CUuW+D4WEx8fjw0bNuC9994LZfjBFcFb4Yhi1ezisQ74rU1dmDd/ZlCvP2ix4CcfH4HVNcLu6bW3QeHYXKKQYM7hgTmHT1ypDyOhlbo74MMe/A74r3xSA7Nuh0UB/r78RpSkZwX9OYjIubWtoaHhqmY0nlatWoV9+/bhH//xH/GXf/mXeOKJJ3Dw4EEIIbBz584Jr79s2TLU19djcHAw2KGHhNADvxFRcLk74EugpSn4K/U/PXYUvRYLLELg7nnzsNTV3ZmIgos5hzfmHL6xqA8nrQQAoKo6ZJCb5X3S1Yb3m8/BrApMS0jCVxbdHNTrE9GYc+fOQUqJikluNS0tLcXnP/95/Pd//zccDse4Pzd//nxIKXH27NlAQw2P0XfNA7kRUVAVFoWuA35Tby9+feoULEIg3mTC1znCjihkmHN8CnMOn7j9Ppy0IgAKVEWH3dEUtMvqUuKHx8ZG2D2+5BakxycE7fpEsc5qsaHzcg/aGjvR0dSFP314AACQlJQ06WsVFBTAarViaGgIaWlpPn8mMdE5gtJisfgfNBHFtIzMZKSmJ2JkZCToHfBfPnwINilhFQKPLluGGddo3EVE10+XdgzZOzBga8OgrQ3H2v8EgDkHTYxFfRgJEQ+pFkJVWwBrI6TUIUTgmyXeaTyNht4rMKsC8zKy8YW5i4IQLVHsMA9bcKW5G+2NXWhv7kJ7Yxc6mlwfm7vQ3dbnNWKk394FAH7NGT1//jwSEhKQkpIy7s+MjIwAcJ51iwrSdQvk8UQUVEIIFBbnoP5EI3q6BjE8ZEFScuB/Uw41N6OmqRlmRWB6aiq+tGz8LcFEdDW7bsGQvR0DtnYM2loxaG/HgOvjoK0Nw/ZOSIztEW80O7fFM+dwYc7hE4v6cNNKoCpNACyAowPQ8gO63LDNiuqTh90j7J5esQ6awlMVRJ6G+kfQ0TxWqLd7FOztjV3o6xyY1PWS1DQICNTV1aGystLnz1y5cgU5OTleXzt27Bh+85vf4M4774Qywf/TkydPQgiB0tLSScVlFCElRADb2QJ5LBGNr7AoB3XHnMf92pp7UDwvsJzD5nBg9yGPEXarb0GiyRSMUImmDJs+gkFb21ixbmvHoN35ccDWihHH5HbO5BYmQggw53BhzuEbi/pw00qgKu877+uXAAT2AvvG6WPoMg/BrAncUVCK1TPmBBwiUTSRUmKwb9h7db2pC+1NnWhv6kZ7YycGe/2f0TwtNw15BVnILchCXuHox2xsfOhDHDp0CJs2bfL5uHvvvReJiYlYtWoVcnNzUVdXh1deeQVJSUn4l3/5lwmf8/DhwygrK5vwnXUiomspLM6BdC34XW7qDrio/21DAxp7+2BWBJZMn47Pl5UFIUqi6GJ1DGLA7twaP2hr87o/aG+D2dHn97UT1HSkaNORYspDqmk6UrQ8pMyYjhfm/gNzDpoQi/owE1opVHW0A34jEOf7Hbfr0TrUj1+eOQ6LIqCpKp5aflsQIyWKDFJK9HUOjK2uNzlX2j0L+OFBs1/XFkIgKz8duYXZyCvIRF5hNnJnjRXvubMyEZ/oe3zMnX9+J9588008//zzPkfM/NVf/RX27t2LXbt2ob+/Hzk5Ofibv/kbfPOb35zw3XCLxYK33noL9957r1+/kyE4XoYoIs326IDf2tQV0LX6zGb85OOP3SPsvrF2LQRH2NEUI6WERe93FuuuIv3TxbtV979LfJKahRRTPlJMeVcX76Z8mJREn49b/7m7mHOMYs7hE4v6cBvtgO9qlhfIy+GPTtTCojtg0QQeLF+GorTM4MRIFEa6rqOnvd9ZtDd1osO1uu7+2NwNy4jVr2srqoKcmdPcq+x5s5yr7LmuAj57xjSY4vz7M/jQQw/hxRdfxL59+3D//fdf9f1HH30Ujz766KSv+9Zbb6GjowMPP/ywX3EZQgIIZETM1Hx9JTJcgasDvtSBlgA74P/06McYsFlhEQJ/XV6ORfnTgxEiUVhJKTHi6PE+y25r9yrebXLEr2sLKEjSspFiykeqlu8q3vORouUj1ZSPZC0XmuLfuXXmHB6Yc/jEoj7c1GLnB1WHPYBZ9UevtOB/Ws7DogpkJSbjkUWrghUhUVA57A50tfV6n2X3WG2/0twNm9Xu17U1k+pcUS/I8toin+f6mJWfAVVTg/wbOVVUVGD9+vV48skncffddyM1CN2f+/v7sXPnTqxfvx7l5eVBiJKIYllOXhoSk+Jgs1vRGkAH/As9PfhNfT0sQiDBZMJXV68OYpREwSOljmF7FwZcZ9h9Fe8O6d9CgYCKFFMuUjTvYj3FNFa0KyI0pRVzDroWFvVhJpRkSGUmVOUKYGuElHLS29ccuo6Xjo+NsPvnG29BWlyUdKykKcdmtaOzpcdrdd2zg/yVyz3QHf69pRqfGIfcWZnu1fVPr7hPy0ubsPlLqO3evRsLFy7E448/jldffTWga0kpsWPHDnR1dWH37t1BijA82LSGKDKNdsA/W38ZnR0DsJitiE/wfaRoPFJK7DlUCzsAK4DHV6xAfgpH2JExnOPerlzdiM7dPb4dOvxbKFBFHJK1XI/t8N7b45O0bCgiNAsF14M5hxNzDt9Y1BtBK4aqtgNyCNC7ADV7Ug/ff+k0zvZ1wawJlE/Lxd+W3hCiQIkAy4gVHc3d6GgaW2H3XHHvau31Gvc2GUkpCd4N6D612p6enRrRZzaLiorw/PPPY+vWrZg9ezaqqqr8uo6UEt/5zndQXV2N6upqFBUVBTnSEJMI8Hxb0CIhok8pLMrB6brLkFKiraUXs4tzJ/X4g83NOHy5BWZFYGZ6OrYsXRqiSIkAh27FoL3D+yy7x9n2IXsnJBx+XVsTCT7Psqe6ivdENTMoo6ZDhTmHC3MOn1jUG0Erhap86LzvuDSpon7IasVrdYecI+yEwDcr10HlCDsKwMig2bkVvnn0LLv3Fvmejn6/r52SkYQ8VxO63E+dZ88ryEJKRlJEF+3XY8uWLWhvb0dVVRUuXbqEXbt2TWpbXH9/P3bs2IHq6mo8++yz2Lx5cwijJaJY49kBv6Wpe1JFvdXhwMu1Ne4Rdk+svgUJGkfYkf/susVdoHsW6wOuAn7Y0QV/qy6TkuzzLLvzfh4S1AzmHMw5piwW9QYQWgkURQcEAHsTEHf973r/rOEIeiwjMGsCd86ei5X5haELlKaEwb7hsRV2z7Fvri3y/d3+d3FNz051rrLP8j7L7uwcn4XkNN9dXKeap556Cnl5edi+fTveeecdPPfcc7jnnnt8dqgdNdpxdufOnejq6kJ1dXX0vriyEy1RxCos8uiAP8lmeb8+dQqX+wdgVgSWz5yJu+bODUWINIVY9WHXCvunzrK7usebHf43bIxX0twF+2jxnuoq3lNM+YhXY+NYCHMO5hy+sKg3glYKIZwd8B2OxuvugN882Id95z6BRREwqRqeXMYRdrFOSon+7sGxs+w+xr0N9fvXxRUAMvPTkVfgubqe6frcOe4tIZm9HEZt2bIF69atw7Zt27Bx40Y89thj2LBhA5YtW4b58+cjMTERIyMjOHnyJA4fPuzuOLt+/Xrs3r07+ra/edKBgEZ5BNLFlogmVFjs0QF/Es3yekZG8LNjx2AVgBQCT6/hCLtYJ6WEVR90FehjZ9kH7K4z7bZ2WHT/d/clqpmf2h4/VrCnmPIRpyQF8beJbsw5Anz8FMSi3gjusXYOOCbRAf9HJ2pg1XVYNIFt85ejIDUjRAFSpJBSoqej/6rVdeequ3Pcm3nI4te1FUUge8bYuDfP+ex5BVnImZmJuARus5yMoqIivP3226irq8OePXvw3nvvYc+ePV49B4QQKCsrw7333ouHH354SnScZdMaosiVNyMDcfEapG6fVFH/448/xqBrhN098+djQV5eCKOkSCClhNnR62N7vGvF3d4Omz7k59WFc9ybxxn2VFfxnuI62+7vuLdYxZzD/8dPRSzqDSCUdEglB6raB1gbr+sxRzou44+tF2FWBXKSUrDthpUhjpLCweHQ0d3We9XqentjF9qbnfdtFj+7uGoqcmdlOlfZPVbbR4v47OkZ0Ez8ExAKFRUVeOGFFwAAg4ODOHv2LCwWC+Lj41FaWoqUlBSDIySiWKGqCmbNzsal823oaO2DzWaH6Rp/+891d+O/TjfAIgSS4+PxzzdzhN1UIKWOEUe3+/z6oL3N6/6grR12afbr2gIqkrUcrwZ0KR7Fe7IpF6rgQkEoMOcggEW9cbQSqMphQO+D1HshlIxxf9TuMcLOrgh87cY1SDHx3cxoYLfZ0dna61Gsu8a+NTk/djR3w2H3r4urKV5zr6p7nWV3fZ6ZnwFVZRNFo6WkpGDx4sVGhxFaPN9GFNEKi3Nw8WwbdIeO9tY+zCrMGvdnpZTYXVvjHmG3fcUK5CQnhy1W8p8uHRi2d7rPr7u7x4/et7dDlza/rq1Ac62qf7oBnfNjspYdshntdP2Yc1zn46cg/u8zilYKTa113rc3AnEZ4/7of16sx/n+bpg1gRuy8rGhdEF4YqRrslpsuNLc7d2EzrXq3tHUhc6WHui6f388EpLj3TPa83xskc/ISTV0RjuRG19giSLa7OIc6K5zpK1N3RMW9R82NuJoaxssikBhRgY2LbkxTFHStejSjkHb6Li3VgzY2jHoOts+YGvDkL3D73FvqojzLtY9i3ctH0laVkSPe6MYwpzDJxb1BnF3wAcARxMA37PmB6wW/LjuMGyKc4TdN1asg8JGNWFjHrY4V9SbutDe1In2pm6v1fbutj6/r52cluhxht21Pb5gbOxbWmYKmxIREVHACjw64E90rt5qt+NHh2rdI+x23nor4jWmiuFi1y0Ysrc7i3XP7vF2Z/f4YXsnpJ9dvkwi0Ws7vOdZ9hRTPhLVacw5iKIY/1IbRXV1wFd1OByXxm3i+NP6I+i1mmHWBO4uKseyvFlhDXOqG+ofcTef8xr75vpaX+eA39dOy0y5ugGda+xbbkEWUtLZxZWmCL5rThTRZhd7jLWboKj/X3V1aBkYhFkRuKmgAJ8rKQ1XiDHBpo/42BI/dq59xHH9jQw/LU5J8XmWfbR4j1dSWbTT1MCcwycW9UbRnC+UIyM2NNQfgT3+I8TFxaGoqMjd0KJxoAe/OncSFkUgXjPhiaVrDQw4+kgpMdg7PNYpfnSV3aOD/GDvsN/Xn5ab5i7Qx4r2bOeW+YIsJKYkBPG3IYpgHC9DFNFmFGRC1RTYbGYcP34cH32Ue1XO0T08jL0njsMqACgKqjjCbtKsjkHfZ9ldxbvZ4f/uvgQ1w+dZdmfxno84lc3QKEYw5/CJRb0B6urq8PLLL+O937Wi4ewgpDwJ4NcAnKMnSktLsXbtWvQsKoUtTodVFXh0wQrMTEkzNO5II6VEX+eAu0Dv8DGjfXjQzy6uQiBreobX6rpnAZ8zMxPxiXFB/o2IiIiCa3TcVe3ZfejubYOExC/f/jcA3jmHvOEGDNlssAiB+xYsRHlOjsGRRxYpJSx6v8eot7Gz7KMj4Kz6oN/XT1Kzrj7L7i7e82BSEoP42xDRVMOiPowuXLiAbdu2Yf/+/cjNzcWGDX+Hr+1cjoqKCiQlJWF4eBh1dXU4dOgQ9r31Fq682oGUhfNQ8uAX8NCCSqPDDztd19HT3o/2xk60N3uPe+to6kJHczcsI1a/rq2oCnJmjs1oz5s1dpY9rzAb2TOmwRTH/x5E14MzY4kiz6dzjr/9wgYsXz5RzvEqUsvLMPO++/D4qlVGhx92UkqMOHq8z7J/qhGdXY74dW0BBUlatsf2eO/iPVnL5Yx2ouvEnMM3IeUU/c0iTHV1NbZv347s7Gx897vfxT333IO4uPFXeq1WK/bt24evPfF1dHd144Uf/ABbtmwJY8Sh57A70Nna632W3WO1/UpzN2xW/2a0m+I05Li2wXtuj893fczKz4CqqUH+jYhiS39/P9LT03HHZx6DpvqfkNodFrx35t/R19eHtDTuSCIKlN85x9e/jq7ubrw4BXMOXTowYu8aZ3t8OwbtbXBI/xYKBFSkmHKR4jrD7nm2PdWUh2Qtl+PeiALEnGNi/AsTBs8++yyqqqqwZcsW7Nq1C6mpqdd8TFxcHO6//37cfffdeOyxx7B161a0t7fjqaeeCkPEwWGz2nHlcrfX6nq7RwHf2dID3eHfwZb4xDj3uLfR1XVn93jn+LdpeWkc90ZERDEnVnMOXdoxZL/isT3eu3gfsnVAh38LBaqIQ7KWe3UjOtfnSVo2FMGFAiIyDov6EKuurkZVVRWeeeYZVFVVeX1vcHAQ//Zv/4aamhrU1taip6cHP/7xj/HAAw+4fyY1NRXV1dWYPXs2qqqqkJ+fj82bN4f5t/DNMmJFR7NH0d7sbEjX3tSNjsZOdLX1wd+NIEkpCcgdPcvu7iA/NvYtPZtdXIkihi4BEcCmL50bxoiCYSrnHA7dikF7h7vp3KeL9yF7p98z2jWRcPVZdlM+Ul3N6Jzj3rhQQBQRmHP4xKI+hC5cuIDt27djy5YtV724AkBnZye+/e1vo7CwEIsWLcIHH3ww7rWqqqrQ2NiIr3zlK7j99ttRVFQUwsidRgbN7pX1jk81oGtv6kJPR7/f107JSEJeYTbyXKvr3h3knePeWLQTRQmOlyEyXLTnHHbd7DrLPrrC3ur1+bCjC4B/fytMSrK7QP908Z5qyke8ks6cgyhaMOfwiUV9CG3btg3Z2dnYtWuXz+9Pnz4dra2tyM/Px+HDh7F8+fJxryWEwPe//32888472LZtG95+++2A4xvsG3YX6l5j35qcH/u7/e/imp6d6jWjPc+jaM+dlYXkNHZxJZo6AnyB9TNRJ6IxkZ5zWPVhZ6Fua/NuROfaHm929Ph97Xgl3edZ9hTX5/HqtY8gEFG0YM7hC4v6EKmrq8P+/fuxd+/ecc+zxcfHIz8//7qvmZaWhueeew4bN27EqVOnUF5ePu7PSinR3z141Vl2z9X2oX7/urgCcI57m+W9up7n+jxnViYSktjFlYiIKBwiIeew6oPOQt3zLLvH9niLPjDp32tUopqJFFPeVY3oUl1n201Kkt/XJiKaCljUh8iePXuQm5uLe+65J6jX3bBhAx577DHs3r0b/3fVd65aXXeeaXcW8JZhP8e9KQLZM8bGvXkW7/mF2cieOQ1x8aag/l5EFMW4FY7IUOHIOf6ff//2VWfZ3Vvl7W2w6cN+PotwjnvTPn2WfWylnePeiMiNOYdPLOpD5N1338WGDRsmHCHjj/j4eGzYsAE/q/45zuw1+3UNzaQiZ2bmVQX76Mfs6RnQTPynQUTXSZcIaDvbFG1aQxQuoc45frX/p1j05aN+XUNARbKW4z6/nqLle91PNuVCFVwoIKLrxJzDJ1ZuITAwMICGhgZ87WtfC8n1ly1bhj0v74E9wQbNxwuhKV5zFukF3mfZnQ3pMpGZnwFVZRdXIiKiaBeWnGPPyzAPOZCQfPXYNgWaa4U9z7t7vKt4T9ayOaOdiCjE+Fc2BM6dOwcpJSoqKkJy/fnz50NComh5LhYtWoS8Au8V94ycVM5oJ6LwkbrzFsjjicgvYck5JCA6SlC2eJHzTLvrbHuKaTqS1EyOeyOi8GHO4ROL+hCwWCwAgKSk0DRuSUx0do7f8swGVFZWhuQ5iIiuG8+3ERkmXDnHsoxHUJnHnIOIDMacwye+tRoC8fHOhi7Dw/42jZnYyMiI1/MQERFRbGLOQURELOpDoLS0FEII1NXVheT6J0+ehBACpaWlIbk+EdGk6DLwGxH5hTkHEcUU5hw+cft9CKSkpGDevHk4dOgQNm3aNOHP/vCHP0Rvby9aWloAAP/xH/+B5uZmAMCXv/xlpKenX/WYw4cPo6ysDCkpKcEPnohosrgVjsgwzDmIKKYw5/BJSDlFfzODPfroo3jzzTfR1NQ04YiZOXPm4NKlSz6/d+HCBcyZM8fraxaLBYWFhbj33nvxwgsvBDNkIqJJ6e/vR3p6Ou6Y8aWA5kjbdQvea/kR+vr6kJaWFsQIiWIDcw4imuqYc0yM2+9D5KGHHkJHRwf27ds34c9dvHgRUkqft0+/uALAW2+9hY6ODjz88MMhipyIaJIkxt459+tm9C9AFN2YcxBRzGDO4ROL+hCpqKjA+vXr8eSTT2JgYCAo1+zv78fOnTuxfv16lJeXB+WaREQBC+jFNcBtdETEnIOIYgdzDp9Y1IfQ7t270dnZiccffzzga0kpsWPHDnR1dWH37t1BiI6IKEh0PfAbEQWEOQcRxQTmHD6xqA+hoqIiPP/886iursZ3vvMdv68jpcR3vvMdVFdX4wc/+AGKioqCGCURERFFO+YcRESxi93vQ2zLli1ob29HVVUVLl26hF27diE1NfW6H9/f348dO3aguroazz77LDZv3hzCaImI/MBOtEQRgTkHEU15zDl84kp9GDz11FN49dVX8fOf/xwLFizAG2+8AavVOuFjLBYL3njjDSxcuBA///nPUV1djSeffDJMERMRTQLPtxFFDOYcRDSlMefwiUV9mGzZsgUnTpxARUUFNm7ciIKCAmzbtg2vv/46ampqcPz4cdTU1OD111/Htm3bUFhYiI0bN6KiogInTpzgu+VERH7o7u7Gxo0bkZaWhoyMDGzevBmDg4PXfNyBAwdw++23Izk5GWlpabj11lsxMjIShoiJAsecg4go/IzMObj9PoyKiorw9ttvo66uDnv27MF7772HPXv2QHq8YySEQFlZGe699148/PDD7DhLRJFPlwhoRoweunfNN27ciNbWVrz77ruw2WzYtGkTHnzwQbzxxhvjPubAgQNYv349du7ciRdffBGapuHYsWNQFL4PTtGDOQcRTUnMOXwSUk7RPQhRYnBwEGfPnoXFYkF8fDxKS0uRkpJidFhERNfU39+P9PR0rJv2D9CUOL+vY9et+H3P/4u+vj6kpaUFLb5Tp06hoqIChw4dwrJlywAA+/fvx1133YXm5mbMmDHD5+NWrlyJz372s3jmmWeCFgtRJGDOQUTRijnHxLjsYLCUlBQsXrwYlZWVWLx4MV9ciShm9ff3e90sFktA1ztw4AAyMjLcL64AcMcdd0BRFNTU1Ph8TEdHB2pqapCbm4tVq1YhLy8Pa9aswR//+MeAYiGKBMw5iIicplrOwaKeiIgCI6VzO5u/N9eGsYKCAqSnp7tvzz33XEBhtbW1ITc31+trmqYhMzMTbW1tPh9z/vx5AMC3vvUtbN26Ffv378eNN96IdevW4cyZMwHFQ0RERAFizuETz9QTEVFgZIDn21wvsE1NTV5b4eLj433++BNPPIF//dd/nfCSp06d8isUXdcBAF/60pewadMmAMCSJUvw+9//Hq+//nrAL/pEREQUAOYcPrGoJyKiiJCWlnZd59t27NiBBx54YMKfKS4uRn5+Pjo6Ory+brfb0d3djfz8fJ+Pmz59OgCgoqLC6+vl5eVobGy8ZmxEREQU+aZazsGinoiIAqPrgND9f7yc3GNzcnKQk5NzzZ+76aab0Nvbi48++ghLly4FALz//vvQdR2VlZU+HzNnzhzMmDEDDQ0NXl8/ffo07rzzzknFSUREREHGnMMnnqknIqLASBn4LQTKy8uxfv16bN26FbW1tfjwww/xyCOP4L777nN3ob18+TLKyspQW1sLwDni66tf/SpeeOEF7Nu3D2fPnsXTTz+N+vp6zu4mIiIyGnMOn7hST0REAZG6DhnAu+Zyku+aT8bevXvxyCOPYN26dVAUBRs2bMALL7zg/r7NZkNDQwOGh4fdX9u+fTvMZjMee+wxdHd3Y9GiRXj33XdRUlISsjiJiIjo2phz+MY59URE5JfRmbG3J90HTQQwM1Za8f7wL4I+M5aIiIimBuYcE+NKPRERBSZInWiJiIiIJsScwycW9UREFBhdAoIvsERERBRizDl8YqM8IiIiIiIioijFlXoiIgqMlAACGS8zNd81JyIioiBjzuETi3oiIgqI1CVkAFvh2K+ViIiIrgdzDt+4/Z6IiIiIiIgoSnGlnoiIAiN1BLYVLnQzY4mIiGgKYc7hE4t6IiIKCLfCERERUTgw5/CN2++JiIiIiIiIohRX6omIKCB2aQloO5sdtiBGQ0RERFMVcw7fWNQTEZFf4uLikJ+fjz+2/VfA18rPz0dcXFwQoiIiIqKphjnHxIScqgcLiIgo5MxmM6xWa8DXiYuLQ0JCQhAiIiIioqmIOcf4WNQTERERERERRSk2yiMiIiIiIiKKUizqiYiIiIiIiKIUi3oiIiIiIiKiKMWinoiIiIiIiChKsagnIiIiIiIiilIs6omIiIiIiIiiFIt6IiIiIiIioij1fwBSDaYhujCozQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -967,7 +1164,13 @@ ], "source": [ "key = np.random.RandomState(seed=1234)\n", - "key, samples = sample_paths(other_edges, params_32, key=key)\n", + "if use_hodge_composition:\n", + " key, samples_harmonic = sample_paths(other_edges, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", + " key, samples_gradient = sample_paths(other_edges, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", + " key, samples_curl = sample_paths(other_edges, params_hodge_1['curl'], key=key, hodge_type='curl')\n", + " samples = samples_harmonic + samples_gradient + samples_curl\n", + "else:\n", + " key, samples = sample_paths(other_edges, params_32, key=key)\n", "\n", "sample1 = samples[:, 0]\n", "sample2 = samples[:, 1]\n", diff --git a/notebooks/backends/JAX_EdgeSpaceGraph.ipynb b/notebooks/backends/JAX_EdgeSpaceGraph.ipynb deleted file mode 100644 index 01269466..00000000 --- a/notebooks/backends/JAX_EdgeSpaceGraph.ipynb +++ /dev/null @@ -1,930 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on (Oriented) Graphs\n", - "This notebook shows how to define and evaluate kernels on the edge space of an oriented simple graph.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **numpy** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): JAX backend enabled.\n" - ] - } - ], - "source": [ - "# Import a backend, we use jax in this example.\n", - "import numpy as np\n", - "import jax\n", - "import jax.numpy as jnp\n", - "from jax.random import PRNGKey\n", - "jax.config.update(\"jax_enable_x64\", True) # enable float64 in JAX\n", - "\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "# import geometric_kernels.torch\n", - "from geometric_kernels import jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of the graph.\n", - "\n", - "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. The entry `incidence_matrix[i, j]` is `-1` if node `i` is the source of edge `j`, `1` if node `i` is the target of edge `j`, and `0` otherwise. \n", - "\n", - "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations.\n", - "\n", - "This space essentially contains the Edge-Laplacian matrix, which is the Laplacian matrix of the edge space of the graph. In the general case, it is the Hodge-Laplacian matrix of the edge space of a simplicial 2-complex.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "YJXKhf4y-tgV" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", - "\n", - "\n", - "edge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n" - ] - } - ], - "source": [ - "incidence_matrix = jnp.array(nx.incidence_matrix(G, oriented=True).toarray())\n", - "edge_graph = GraphEdge(incidence_matrix)\n", - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('incidence matrix:\\n', incidence_matrix)\n", - "print('\\n')\n", - "print('edge Laplacian:\\n', edge_graph.edge_laplacian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `edge_graph` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "kernel = MaternGeometricKernel(edge_graph)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "params[\"lengthscale\"] = jnp.array([2.0])\n", - "params_32 = params.copy()\n", - "params_inf = params.copy()\n", - "del params\n", - "params_32[\"nu\"] = jnp.array([3/2])\n", - "params_inf[\"nu\"] = jnp.array([jnp.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on our graph.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0]\n", - " [1]\n", - " [2]]\n" - ] - } - ], - "source": [ - "key = PRNGKey(1234)\n", - "\n", - "key, xs = edge_graph.random(key, 3)\n", - "\n", - "print(xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = min([jnp.min(kernel_mat_32), jnp.min(kernel_mat_inf)])\n", - "maxmax = max([jnp.max(kernel_mat_32), jnp.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = 1 # choosing a fixed edge for kernel visualization\n", - "other_edges = jnp.arange(edge_graph.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "values_32 = kernel.K(params_32, jnp.array([[base_edge]]),\n", - " other_edges).flatten()\n", - "values_inf = kernel.K(params_inf, jnp.array([[base_edge]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "variance_32 = kernel.K_diag(params_32, other_edges)\n", - "variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.18,\n", - "Variance in the edge (1,3) is 0.20,\n", - "The average variance is 0.17.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % jnp.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = (3, 1)):\n", - "[[0]\n", - " [1]\n", - " [2]]\n", - "\n", - "emedding (shape = (3, 6)):\n", - "[[ 3.68915277e-01 1.11232141e-01 -1.08504235e-01 5.26867410e-02\n", - " -1.02519158e-01 4.08723427e-02]\n", - " [-3.68915277e-01 2.22464283e-01 -7.78347676e-17 1.05373482e-01\n", - " -1.00770134e-19 8.17446854e-02]\n", - " [ 0.00000000e+00 -3.33696424e-01 1.75563540e-01 -3.25621967e-02\n", - " -6.33603240e-02 6.61328397e-02]]\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 6.245004513516506e-17\n" - ] - } - ], - "source": [ - "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", - "\n", - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - "\n", - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_32_alt = jnp.matmul(embedding, embedding.T)\n", - "\n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', jnp.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "[[-0.02020849 0.12888007]\n", - " [-1.36094681 0.04504047]\n", - " [ 1.03439484 -0.46260735]]\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = PRNGKey(1234)\n", - "\n", - "# new random state is returned along with the samples\n", - "key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = PRNGKey(1234)\n", - "key, samples = sample_paths(other_edges, params_32, key=key)\n", - "\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb b/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb deleted file mode 100644 index d17f3b7b..00000000 --- a/notebooks/backends/JAX_EdgeSpaceSimplicialComplex.ipynb +++ /dev/null @@ -1,1085 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", - "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **numpy** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): JAX backend enabled.\n" - ] - } - ], - "source": [ - "# Import a backend, we use jax in this example.\n", - "import numpy as np\n", - "import jax\n", - "import jax.numpy as jnp\n", - "from jax.random import PRNGKey\n", - "jax.config.update(\"jax_enable_x64\", True) # enable float64 in JAX\n", - "\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "# import geometric_kernels.torch\n", - "from geometric_kernels import jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the triangle set " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "triangles = [(1,2,3)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "# shade the area of the triangle\n", - "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the sets of nodes, edges and triangles. \n", - "\n", - "**Note that**: \n", - "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", - "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], - "source": [ - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('triangles:', triangles)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", - "\n", - "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. \n", - "\n", - "The entry `incidence_matrix[i, e]` is \n", - "- `-1` if node `i` is the source of edge `e`, \n", - "- `1` if node `i` is the target of edge `e`, and \n", - "- `0` otherwise. \n", - "\n", - "The `edge_triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph.\n", - "\n", - "The entry `edge_triangle_incidence_matrix[e, t]` is\n", - "- `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$,\n", - "- `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and\n", - "- `0` otherwise.\n", - "\n", - "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def triangles_to_B2(striangles: list, edges: list) -> np.ndarray:\n", - " \"\"\"\n", - " Create the B2 matrix (edge-triangle) from the triangles.\n", - "\n", - " Args:\n", - " triangles (list): List of triangles.\n", - " edges (list): List of edges.\n", - "\n", - " Returns:\n", - " np.ndarray: B2 matrix.\n", - " \"\"\"\n", - " B2 = np.zeros((len(edges), len(triangles)))\n", - " for j, triangle in enumerate(triangles):\n", - " a, b, c = triangle\n", - " try:\n", - " index_a = edges.index((a, b))\n", - " except ValueError:\n", - " index_a = edges.index((b, a))\n", - " try:\n", - " index_b = edges.index((b, c))\n", - " except ValueError:\n", - " index_b = edges.index((c, b))\n", - " try:\n", - " index_c = edges.index((a, c))\n", - " except ValueError:\n", - " index_c = edges.index((c, a))\n", - "\n", - " B2[index_a, j] = 1\n", - " B2[index_c, j] = -1\n", - " B2[index_b, j] = 1\n", - "\n", - " return B2" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "YJXKhf4y-tgV" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", - "\n", - "\n", - "edge triangle incidence matrix:\n", - " [[ 1.]\n", - " [-1.]\n", - " [ 0.]\n", - " [ 1.]\n", - " [ 0.]\n", - " [ 0.]]\n" - ] - } - ], - "source": [ - "incidence_matrix = jnp.array(nx.incidence_matrix(G, oriented=True).toarray())\n", - "edge_triangle_incidence_matrix = jnp.array(triangles_to_B2(triangles, list(G.edges)))\n", - "print('incidence matrix:\\n', incidence_matrix)\n", - "print('\\n')\n", - "print('edge triangle incidence matrix:\\n', edge_triangle_incidence_matrix)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the Simplicial 2-Complex " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hodge Laplacian:\n", - " [[ 3. 0. 1. 0. 0. 0.]\n", - " [ 0. 3. 1. 0. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [ 0. 0. 0. 3. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Down Hodge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Up Hodge Laplacian:\n", - " [[ 1. -1. 0. 1. 0. 0.]\n", - " [-1. 1. -0. -1. -0. -0.]\n", - " [ 0. -0. 0. 0. 0. 0.]\n", - " [ 1. -1. 0. 1. 0. 0.]\n", - " [ 0. -0. 0. 0. 0. 0.]\n", - " [ 0. -0. 0. 0. 0. 0.]]\n" - ] - } - ], - "source": [ - "sc = GraphEdge(incidence_matrix, edge_triangle_incidence_matrix)\n", - "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", - "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", - "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "kernel = MaternGeometricKernel(sc)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "params[\"lengthscale\"] = jnp.array([2.0])\n", - "params_32 = params.copy()\n", - "params_inf = params.copy()\n", - "del params\n", - "params_32[\"nu\"] = jnp.array([3/2])\n", - "params_inf[\"nu\"] = jnp.array([jnp.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on our graph.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0]\n", - " [1]\n", - " [2]]\n" - ] - } - ], - "source": [ - "key = PRNGKey(1234)\n", - "\n", - "key, xs = sc.random(key, 3)\n", - "\n", - "print(xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = min([jnp.min(kernel_mat_32), jnp.min(kernel_mat_inf)])\n", - "maxmax = max([jnp.max(kernel_mat_32), jnp.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = 1 # choosing a fixed edge for kernel visualization\n", - "other_edges = jnp.arange(sc.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "values_32 = kernel.K(params_32, jnp.array([[base_edge]]),\n", - " other_edges).flatten()\n", - "values_inf = kernel.K(params_inf, jnp.array([[base_edge]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "variance_32 = kernel.K_diag(params_32, other_edges)\n", - "variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "# shade the area of the triangle\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.08,\n", - "Variance in the edge (1,3) is 0.13,\n", - "The average variance is 0.17.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % jnp.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = (3, 1)):\n", - "[[0]\n", - " [1]\n", - " [2]]\n", - "\n", - "emedding (shape = (3, 6)):\n", - "[[ 1.40337318e-01 -1.36895623e-01 6.64728362e-02 1.39200889e-01\n", - " 1.29344481e-01 5.15670639e-02]\n", - " [ 2.80674635e-01 1.02621639e-17 1.32945672e-01 -1.39200889e-01\n", - " 1.74707239e-17 1.03134128e-01]\n", - " [-4.21011953e-01 2.21501771e-01 -4.10824721e-02 -7.22120964e-17\n", - " 7.99392856e-02 8.34372621e-02]]\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.277421474636178e-17\n" - ] - } - ], - "source": [ - "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", - "\n", - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - "\n", - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_32_alt = jnp.matmul(embedding, embedding.T)\n", - "\n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', jnp.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "[[ 0.24385954 -0.46621535]\n", - " [ 0.61691489 -0.26225356]\n", - " [-1.16522011 0.33173476]]\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = PRNGKey(1234)\n", - "\n", - "# new random state is returned along with the samples\n", - "key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = PRNGKey(seed=1234)\n", - "key, samples = sample_paths(other_edges, params_32, key=key)\n", - "\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/backends/JAX_SimplicialComplex.ipynb b/notebooks/backends/JAX_SimplicialComplex.ipynb new file mode 100644 index 00000000..89b101b8 --- /dev/null +++ b/notebooks/backends/JAX_SimplicialComplex.ipynb @@ -0,0 +1,1280 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", + "\n", + "We construct the simplicial 2-complex by adding triangles to the graph. The triangles can be provided by users. If not provided, we look for all the 2-cliques in the graph and add them to the simplicial 2-complex.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **JAX** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): JAX backend enabled.\n" + ] + } + ], + "source": [ + "# Import a backend, we use jax in this example.\n", + "import numpy as np\n", + "import jax\n", + "import jax.numpy as jnp\n", + "from jax.random import PRNGKey\n", + "jax.config.update(\"jax_enable_x64\", True) # enable float64 in JAX\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "from geometric_kernels import jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the triangle set " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "triangles = [(1,2,3)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "# shade the area of the triangle\n", + "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the sets of nodes, edges and triangles. \n", + "\n", + "**Note that**: \n", + "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", + "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('triangles:', triangles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", + "\n", + "The `G` parameter is a 'networkx.classes.graph.Graph' object, from which we build the node-to-edge incidence matrix.\n", + "\n", + "The 'triangle_list' parameter is a list of tuples, where each tuple is a triangle in the graph. If provided, this will be used to construct a simplicial 2-complex.\n", + "\n", + "The 'sc_lifting' parameter is a boolean that determines if to build a simplicial 2-complex. \n", + "- If True and 'triangle_list' is not None, the edge space of a simplicial 2-complex will be built based on the provided triangles. \n", + "- If True and 'triangle_list' is None, the edge space of a simplicial 2-complex with all the 2-cliques as 2-simplices will be built. \n", + "- If False and no 'triangle_list' provided, the edge space of the graph will be built.\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the Simplicial 2-Complex " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----Simplicial 2-complex summary---\n", + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True)\n", + "sc.sc_simplices()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the incidence matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.],\n", + " [-1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sc.triangle_incidence_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "node-to-edge incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "edge-to-triangle incidence matrix:\n", + " [[ 1.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 1.]\n", + " [ 0.]\n", + " [ 0.]]\n" + ] + } + ], + "source": [ + "print('node-to-edge incidence matrix:\\n', sc.incidence_matrices[0])\n", + "print('edge-to-triangle incidence matrix:\\n', sc.incidence_matrices[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the computed Laplacians" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hodge Laplacian:\n", + " [[ 3. 0. 1. 0. 0. 0.]\n", + " [ 0. 3. 1. 0. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [ 0. 0. 0. 3. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Down Hodge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Up Hodge Laplacian:\n", + " [[ 1. -1. 0. 1. 0. 0.]\n", + " [-1. 1. 0. -1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 1. -1. 0. 1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('\\n')\n", + "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('\\n')\n", + "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "use_hodge_composition=True\n", + "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the eigenbasis and their types being either gradient, curl or harmonic" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "eval: 0.00\n", + "evec: [0.17 0.35 -0.52 0.17 0.52 -0.52]\n", + "type: harmonic\n", + "\n", + "eval: 1.38\n", + "evec: [0.37 -0.00 -0.60 -0.37 -0.60 -0.00]\n", + "type: gradient\n", + "\n", + "eval: 2.38\n", + "evec: [0.24 0.48 -0.15 0.24 0.15 0.78]\n", + "type: gradient\n", + "\n", + "eval: 3.00\n", + "evec: [0.58 -0.58 -0.00 0.58 0.00 0.00]\n", + "type: curl\n", + "\n", + "eval: 3.62\n", + "evec: [0.60 -0.00 0.37 -0.60 0.37 -0.00]\n", + "type: gradient\n", + "\n", + "eval: 4.62\n", + "evec: [0.28 0.56 0.45 0.28 -0.45 -0.35]\n", + "type: gradient\n", + "\n" + ] + } + ], + "source": [ + "for entry in sc.hodge_eigenbasis.values():\n", + " if 'eval' in entry:\n", + " print(f\"eval: {entry['eval']:.2f}\")\n", + " if 'evec' in entry:\n", + " formatted_evec = np.array2string(entry['evec'], formatter={'float_kind': lambda x: f\"{x:.2f}\"})\n", + " print(f\"evec: {formatted_evec}\")\n", + " if 'type' in entry:\n", + " print(f\"type: {entry['type']}\")\n", + " \n", + " print() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'harmonic': {'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'nu': array([inf]), 'lengthscale': array([1.])}}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "if use_hodge_composition:\n", + " params[\"harmonic\"][\"lengthscale\"], params[\"gradient\"][\"lengthscale\"], params[\"curl\"][\"lengthscale\"] = jnp.array([0.5]), jnp.array([2.0]), jnp.array([1.0])\n", + " params_hodge_1 = copy.deepcopy(params)\n", + " params_hodge_2 = copy.deepcopy(params)\n", + " del params\n", + " params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = jnp.array([3/2]), jnp.array([3/2]), jnp.array([3/2])\n", + " params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = jnp.array([np.inf]), jnp.array([np.inf]), jnp.array([np.inf])\n", + "\n", + "else:\n", + " params[\"lengthscale\"] = jnp.array([2.0])\n", + " params_32 = params.copy()\n", + " params_inf = params.copy()\n", + " del params\n", + " params_32[\"nu\"] = jnp.array([3/2])\n", + " params_inf[\"nu\"] = jnp.array([np.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check the eigenvalues of the kernels" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eigenvalues for the first set of parameters:\n", + "{'harmonic': Array([[0.02405626]], dtype=float64), 'gradient': Array([[0.32123998],\n", + " [0.18041575],\n", + " [0.10953956],\n", + " [0.0804039 ]], dtype=float64), 'curl': Array([[0.06804138]], dtype=float64)}\n", + "\n", + "Eigenvalues for the second set of parameters:\n", + "{'harmonic': Array([[1.]], dtype=float64), 'gradient': Array([[6.30433923e-02],\n", + " [8.53199536e-03],\n", + " [7.20137798e-04],\n", + " [9.74600529e-05]], dtype=float64), 'curl': Array([[0.22313016]], dtype=float64)}\n" + ] + } + ], + "source": [ + "if use_hodge_composition:\n", + " # Evaluate the eigenvalues for the first set of parameters\n", + " eigenvalues_hodge_1 = kernel.eigenvalues(params_hodge_1, normalize=False)\n", + " # Evaluate the eigenvalues for the second set of parameters\n", + " eigenvalues_hodge_2 = kernel.eigenvalues(params_hodge_2, normalize=False)\n", + " # Print the results\n", + " print(\"Eigenvalues for the first set of parameters:\")\n", + " print(eigenvalues_hodge_1)\n", + " print(\"\\nEigenvalues for the second set of parameters:\")\n", + " print(eigenvalues_hodge_2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0]\n", + " [1]\n", + " [2]]\n" + ] + } + ], + "source": [ + "key = PRNGKey(1234)\n", + "\n", + "key, xs = sc.random(key, 3)\n", + "\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "if use_hodge_composition:\n", + " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs, normalize=False)\n", + " kernel_mat_inf = kernel.K(params_hodge_2, xs, xs, normalize=False)\n", + "else:\n", + " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + " kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = min([jnp.min(kernel_mat_32), jnp.min(kernel_mat_inf)])\n", + "maxmax = max([jnp.max(kernel_mat_32), jnp.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array([[ 0.50937497, -0.22424068, -0.15397211],\n", + " [-0.22424068, 0.55151863, -0.17105091],\n", + " [-0.15397211, -0.17105091, 0.49229617]], dtype=float64),\n", + " Array([[ 0.49452715, -0.25884074, -0.28746792],\n", + " [-0.25884074, 0.48231852, -0.18992884],\n", + " [-0.28746792, -0.18992884, 0.59206623]], dtype=float64))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_mat_32, kernel_mat_inf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = (1,2)\n", + "base_edge_idx = list(G.edges).index(base_edge)\n", + "other_edges = jnp.arange(sc.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "if use_hodge_composition:\n", + " values_32 = kernel.K(params_hodge_1, jnp.array([[base_edge_idx]]), other_edges).flatten()\n", + " values_inf = kernel.K(params_hodge_2, jnp.array([[base_edge_idx]]), other_edges).flatten()\n", + "else:\n", + " values_32 = kernel.K(params_32, jnp.array([[base_edge_idx]]),\n", + " other_edges).flatten()\n", + " values_inf = kernel.K(params_inf, jnp.array([[base_edge_idx]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "if use_hodge_composition:\n", + " variance_32 = kernel.K_diag(params_hodge_1, other_edges)\n", + " variance_inf = kernel.K_diag(params_hodge_2, other_edges)\n", + "else:\n", + " variance_32 = kernel.K_diag(params_32, other_edges)\n", + " variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+wAAAMQCAYAAAC9ie/qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVhUZfvA8e+ZGYZhR2UR9wUFQVxyQS1bLbXSLDXXSlMrzcpse/M1K7VsNfuVprlkb2lZ2m5aalqZSy6ZiIqi4A64sS+znd8f6CQBijBwmOH+XNe5kjNnuQ8NM/dzzvPcj6KqqooQQgghhBBCCCGqFZ3WAQghhBBCCCGEEKI4abALIYQQQgghhBDVkDTYhRBCCCGEEEKIakga7EIIIYQQQgghRDUkDXYhhBBCCCGEEKIakga7EEIIIYQQQghRDUmDXQghhBBCCCGEqIakwS6EEEIIIYQQQlRD0mAXQgghhBBCCCGqIWmwCyGEEEIIIYQQ1ZA02IUQQgghhBBCiGpIGuxOsHjxYhRFITk5WetQKkV2djY6nY533nlH61Cu6I033iAyMhK73V6l5507dy6NGjWioKCgzPts27aNbt264ePjg6Io7Nq1q/ICLKPq+F5+6aWXUBRF6zCEEKLGccZ3gqvkEFrlDyVxl5wCql9eITmFcEVu12Dv27cv3t7eZGVllbrNsGHDMBqNnD17tgojc1179uxBVVVat26tdSiXlZmZyeuvv85zzz2HTle1b+0RI0ZgNpuZN29emba3WCwMHDiQc+fO8c477/DJJ5/QuHHjSo5SCCFEVbrYWNm+fXuR9RkZGXTu3BmTycTq1as1iq5quEIOUVr+UFBQwHPPPUe9evXw8vIiNjaWNWvWVHo8klMIIS7ldg32YcOGkZeXx9dff13i67m5uXz77bf06tWLOnXqOOWc9913H3l5eW774RgXFwdATEyMxpFc3qJFi7BarQwZMqTKz20ymXjggQeYOXMmqqpecftDhw5x5MgRnn76aR566CGGDx9OrVq1qiDSy3P397IQQmgtMzOT2267jd27d/P111/Tq1cvrUOqVK6QQ5SWP4wYMYKZM2cybNgw3n33XfR6PbfffjsbN26s1HjcJacAySuEcAa3a7D37dsXPz8/li5dWuLr3377LTk5OQwbNqzC58rJyQFAr9djMpnctotNXFwcQUFB1K1bV+tQLuujjz6ib9++mEwmTc5/7733cuTIEdavX3/FbdPS0gAIDAx02vkvvh8rwt3fy0IIoaWsrCx69uzJrl27WLFiBb1793bKcZ3x+V9ZXCGHKCl/+PPPP/n888+ZMWMGb775Jg899BC//PILjRs35tlnn630mNwhpwDJK4RwBrdrsHt5eXHPPfewbt06xwfYpZYuXYqfnx99+/YF4MiRI4wbN46IiAi8vLyoU6cOAwcOLDbW5uKYl7179zJ06FBq1arFddddB5Q8Pudqj5uYmMiIESMIDAwkICCAkSNHkpubW2TbEydOMGrUKOrVq4enpydNmzZl7NixmM3mIts8+OCDhIaG4unpSXR0NIsWLSrxd7V//36OHj16xd9pXFwc0dHRRdbNnz8fo9HIhAkTsNlsVzxGZUtKSmL37t306NFDsxg6dOhA7dq1+fbbby+73YgRI7jhhhsAGDhwIIqicOONNwLw119/0bt3b/z9/fH19eWWW25hy5YtxY5xufdjRZT0Xr6a92hpyvq+3LhxI506dcJkMtG8efNSuwNu2LCBjh07FtmutHFpZTl3VlYWEyZMoEmTJnh6ehISEsKtt97Kzp07y3R9QghxJdnZ2fTq1YudO3eyYsUK7rjjjiKvl/VzsrTP/6v9rL6afOHfypo/QPXPIUrLH5YvX45er+ehhx5yrDOZTIwaNYrNmzdz7NixSo3LGTkFlC2vqKycAornFdUxpwDJK0T1ZtA6gMowbNgwPv74Y7744gvGjx/vWH/u3Dl++uknhgwZgpeXF1BYpGPTpk0MHjyYBg0akJyczAcffMCNN97I3r178fb2LnLsgQMH0qJFC1599dXLdlO62uPee++9NG3alBkzZrBz504WLFhASEgIr7/+OgAnT56kc+fOpKen89BDDxEZGcmJEydYvnw5ubm5GI1GUlNT6dKlC4qiMH78eIKDg1m1ahWjRo0iMzOTCRMmFDlnq1atuOGGG9iwYcNlf59xcXGObmJWq5UJEybw4YcfMnv2bMaMGXPZfavKpk2bALjmmms0jeOaa67hjz/+uOw2Dz/8MPXr1+fVV1/l8ccfp1OnToSGhhIfH0/37t3x9/fn2WefxcPDg3nz5nHjjTfy66+/EhsbW+xYZX0/OsOV3qOlKev7Mi4ujttuu43g4GBeeuklrFYrL774IqGhoUWO99dff9GrVy/CwsJ4+eWXsdlsTJ06leDg4HKf+5FHHmH58uWMHz+eqKgozp49y8aNG9m3b5/m7ykhhOvLycmhd+/ebNu2jeXLl3PnnXcWef1qv7+h+Of/xYcUZfmsLs/5LlXW/AGqfw5RWv7w119/0bJlS/z9/Yus79y5MwC7du2iYcOGlRpbRXIK4KrzipqYU4DkFcIFqG7IarWqYWFhateuXYusnzt3rgqoP/30k2Ndbm5usf03b96sAur//vc/x7oXX3xRBdQhQ4YU2/6jjz5SATUpKancx33wwQeLbHv33XerderUcfx8//33qzqdTt22bVux49rtdlVVVXXUqFFqWFiYeubMmSKvDx48WA0ICCgWE6DecMMNxY53qZMnT6qAOnfuXPXs2bPqzTffrNauXVtdv379ZferapMnT1YBNSsrS9M4HnroIdXLy+uK261fv14F1C+//NKxrl+/fqrRaFQPHTrkWHfy5EnVz89Pvf7664vsf7n3Y0WU9F4u63u0NGV9X/br1081mUzqkSNHHNvs3btX1ev16qUfVX369FG9vb3VEydOONYdPHhQNRgM6r8/0sp67oCAAPXRRx+94rUIIcTVuPiZ2rhxY9XDw0P95ptvStzuar6/S/v8v5rP6rKer6TvBFUtW/6gqq6RQ5SWP0RHR6s333xzse3j4+Md11TZKpJTqGrZ84rKyilUtfh7qLrlFKoqeYWo/tyuSzwUjpcZPHgwmzdvLtK1d+nSpYSGhnLLLbc41l180g6FVTbPnj1LeHg4gYGBJXZbeeSRR8oUQ0WP2717d86ePUtmZiZ2u51vvvmGPn360LFjx2L7KoqCqqqsWLGCPn36oKoqZ86ccSw9e/YkIyOj2HlVVb3i3fHdu3c7ztGpUydOnjzJ1q1bi3S3qg7Onj2LwWDA19e3yPotW7agKAovvfRSuY99NceoVasWeXl5Ze7WdZHNZuPnn3+mX79+NGvWzLE+LCyMoUOHsnHjRjIzM4vtV9b3ozN+D5d7j5amrO9Lm83GTz/9RL9+/WjUqJFj/1atWtGzZ0/HzzabjbVr19KvXz/q1avnWB8eHl5sLOjV/E0EBgaydetWTp48We7fjxBClCY1NRWTyVTiE9nyfH9D6Z//V/qsLu/5/h1zWZ6uu0IOUVr+kJeXh6enZ7HtL45zz8vLK/c5y/qdXN6cAsqXV9S0nAIkrxCuwS0b7ICjqNzF4nPHjx/n999/Z/Dgwej1esd2eXl5TJkyhYYNG+Lp6UlQUBDBwcGkp6eTkZFR7LhNmzYt0/mv9riXfqAAjuqe58+f5/Tp02RmZl52SpTTp0+Tnp7Ohx9+SHBwcJFl5MiRACWO6b+Si9Vdx48fT2hoKJs3byY8PLzYdg899BBhYWH4+/sTExPD999/X2ybXbt20b59ex588EEaNWqEv78/Xbp0YfPmzVcdV3WlXuhCdrXFVU6fPk1ubi4RERHFXmvVqhV2u73E8XJlfT86w+Xeo6Up6/vy9OnT5OXl0aJFi2LHuPR3kpaWRl5eXonvwX+vu5q/iTfeeIM9e/bQsGFDOnfuzEsvvcThw4fL8msRQogrmjdvHkajkV69epGQkFDktfJ+f5f2+X+lz+rKyhdKUpYcorrmD15eXiXOg56fn+94vbKVN6eA8uUVNS2nuLi95BWiunPLMexQWKwjMjKSzz77jEmTJvHZZ5+hqmqx6vCPPfYYH330ERMmTKBr164EBASgKAqDBw/GbrcXO25ZP6Cv9riX3kS41MUP6yu5eMzhw4fzwAMPlLhNmzZtynSsS8XFxdG4cWOaN2/Onj17yM7OLrEK6cSJE3nvvffw9PRk27Zt9OjRg8OHDxeZOm/16tX06NEDPz8/Nm7cSIMGDfjiiy/o06cPycnJxe5uX406depgtVrJysrCz8/Psf6aa67h2LFjxcagXY2rOcb58+fx9vauki9yKPv70Rm/h/K8R8v6vizpb6KiruZv4t5776V79+58/fXX/Pzzz7z55pu8/vrrfPXVV06r4iyEqLmioqL48ccfueWWW7j11lv5448/HE/by/v9Xdrn/5U+qysrXyhJWXKI6po/hIWFceLEiWLbnzp1CqDI09irVdbvZMkpitIyp7ia84PkFcK53LbBDoVP2V944QV2797N0qVLadGiBZ06dSqyzfLly3nggQd4++23Hevy8/NJT0+v0Lmdedzg4GD8/f3Zs2fPZbfx8/PDZrM5tVJ6XFwc7dq1Y/78+XTs2JG7776b33//vdjUaZGRkY5/K4qC2WzmxIkTxb5wX3vtNbp06eJYN3jwYCZOnEhCQgIdOnQoNY6FCxfy3Xff8e2337J//34GDhzIm2++6Zi/9uL5k5KSiiQaRqORBg0aVOh3cDXHSEpKolWrVld9juDgYLy9vYs9eYHCarw6na5CxW2c8Xsoj7K+L202G15eXhw8eLDYa5f+TkJCQjCZTCQmJhbb7t/rrvZvIiwsjHHjxjFu3DjS0tK45ppreOWVV+SLVQjhFJ07d+abb77hjjvu4NZbb+X33393PJ2rjO/v0lTl+cqSQ1R2/gCXzyFKyx/atWvH+vXryczMLNIw3bp1q+P18irrd3J5cwqo3LzCXXIKkLxCuAa37RIP/3SLnzJlCrt27Spx7nW9Xl/sbt57771X4WlGnHlcnU5Hv379+P7779m+fXux11VVRa/X079/f1asWFFiw/706dPF1l1pWhabzca+ffuIiYkhODiYr776ij179jB27NgStx83bhxeXl506tSJm2++mZiYGMdrWVlZJCQkOKqrXnTw4EHOnTtXYlekS8XFxdGmTRs2bdpE//79Wbx4saOxDtC1a1eAEn8/VWnnzp1069btqvfT6/XcdtttfPvtt0XqLqSmprJ06VKuu+66Ct3J1kpZ35d6vZ6ePXvyzTffFHlP7tu3j59++qnI8Xr06ME333xTZFxYYmIiq1atKte5bTZbsWEqISEh1KtXr8TukEIIUV633HILn332GYmJifTq1YvMzMxyfX9XhDPOV5Zp3a4mh6jM/AEun0OUlj8MGDAAm83Ghx9+6FhXUFDARx99RGxsbKVXiIfy5xTgnnmFs3OKi9tKXiGqO7d+wt60aVO6devmmMOypAb7nXfeySeffEJAQABRUVFs3ryZtWvXFrmzWx7OPu6rr77Kzz//zA033MBDDz1Eq1atOHXqFF9++SUbN24kMDCQ1157jfXr1xMbG8uYMWOIiori3Llz7Ny5k7Vr13Lu3Lkix7zStCwHDx4kPz/f8cXZoUMHPvjgA0aOHEmHDh2KTJkHMGfOHN577z02bNjAnj17ioy5WrduHTfccAM63T/3iPLy8hg+fDjPP/88AQEBl73+uLg46taty1133cXWrVuLFFABaNasGa1bt2bt2rU8+OCDV/x9QuGd/LJOS1MWO3bs4Ny5c9x1113l2n/69OmsWbOG6667jnHjxmEwGJg3bx4FBQW88cYbTolRC2V9X7788susXr2a7t27M27cOKxWK++99x7R0dGOwkVQOIfrzz//zLXXXsvYsWOx2Wy8//77tG7dml27dl31ubOysmjQoAEDBgygbdu2+Pr6snbtWrZt21akh4wQQjjD3Xffzfz583nwwQfp27ev4+nx1Xx/V1RFz1eWad2uJoeozPwBLp9DlJY/xMbGMnDgQJ5//nnS0tIIDw/n448/Jjk5mYULFxY7R3XLKcA98wpn5xQgeYVwAVVVjl4rs2fPVgG1c+fOJb5+/vx5deTIkWpQUJDq6+ur9uzZU92/f7/auHFj9YEHHnBsd3EaitOnTxc7RknTnlT0uCUd88iRI+r999+vBgcHq56enmqzZs3URx99VC0oKHBsk5qaqj766KNqw4YNVQ8PD7Vu3brqLbfcon744YfF4uYK07J88cUXKqDGx8cXWT9u3DjVw8ND/fXXX0vd984771RXrlzp+Pnhhx9WP/roI8fPZrNZveOOO9ShQ4c6pqW7nODgYLV79+5qQEBAqeedOXOm6uvrW+KUev+WlZWlAurgwYOvuG1ZPffcc2qjRo3KdD2lTcGyc+dOtWfPnqqvr6/q7e2t3nTTTeqmTZuK7X+592NFXG5at7K8R0tT1vflr7/+qnbo0EE1Go1qs2bN1Llz5zrOf6l169ap7du3V41Go9q8eXN1wYIF6lNPPaWaTKarPndBQYH6zDPPqG3btlX9/PxUHx8ftW3btuqcOXPK+FsTQoiSXfycLGlK1rfeeksF1DvvvFO1WCxl/pws7TP5aj+ry3K+ikzrVt4cwtn5g6peOYcoLX/Iy8tTn376abVu3bqqp6en2qlTJ3X16tXF9q+uOYWqli2vqKycQlVLn9atOuUUqip5haje3L7BLrTRq1cv9d1333X83LRpU/XkyZOqqqqqzWZTBw0a5EhSriQlJUU1mUxqfn6+OmnSJLVHjx4lbpeenq7Wrl1bXbBgwRWPuXLlSlVRFHX37t1lvKLLy8/PV+vWravOmjXLKccTV++uu+5Sw8PDtQ5DCCFEBTgzf1DVsuUQV5M/lERyCvckeYWoLtx6DLuoGhkZGSxdupTs7GysVitffvkl69ev5/rrrwcKx7r5+/sTFhYGwMMPP+zozm8wFB2VMWLECEaMGFFkXVxcHK1atcLT05MJEyawadMmtmzZUiyOgIAAnn32Wd58880rVghdv349gwcPLjJOriI++ugjPDw8yjyHqaiYf89/e/DgQX788cdqNbevEEKIy3Nm/gDlzyGuJn8oieQUrk/yClGdKapaxnnDhChFZmYmd911F3/99ReqqhIeHs5///tf7rnnHgBmzZpFSkoKr732GkeOHKFJkyaYTKYiU3qsWrWK7t2706NHDwYNGsSYMWMcr73zzjv89ddf/O9//wPgiSeeIDExkZUrV1bthYpqIywsjBEjRtCsWTOOHDnCBx98QEFBAX/99VeJ864KIYSofpyZPwCSQ4hyk7xCVGfSYBeVrlevXvznP/+54l1Kq9VKmzZt+Pvvv/Hw8Kia4IRLGjlyJOvXryclJQVPT0+6du3Kq6++yjXXXKN1aEIIIZykrPkDSA4hKkbyClGdSYNdVLo33niDJ598Ur5AhRBCCFFmkj8IIYQ02IUQQgghhBBCiGpJis4JIYQQQgghhBDVUPESm0IIIcQF+fn5mM3mCh3DaDRiMpmcFJEQQggh3JHkHCWTBrsQQogS5efn07SxLylptgodp27duiQlJbndF6gQQgghnEPLnGP27Nm8+eabpKSk0LZtW9577z06d+5c4raLFy9m5MiRRdZ5enqSn59fobgvRxrsQgghSmQ2m0lJs5G0ozH+fuUbQZWZZadphyOYzWZpsAshhBCiRFrlHMuWLWPixInMnTuX2NhYZs2aRc+ePUlISCAkJKTEffz9/UlISHD8rChKueItK2mwCyGEuCwf38KlPGxS1lQIIYQQZVTVOcfMmTMZM2aM46n53LlzWblyJYsWLeI///lPifsoikLdunXLF2Q5SNE5IYQQQgghhBBuITMzs8hSUFBQ4nZms5kdO3bQo0cPxzqdTkePHj3YvHlzqcfPzs6mcePGNGzYkLvuuov4+HinX8OlpMEuhBDisuyoFVqEEEIIIcrCGTlHw4YNCQgIcCwzZswo8VxnzpzBZrMRGhpaZH1oaCgpKSkl7hMREcGiRYv49ttv+fTTT7Hb7XTr1o3jx4879xdxCekSL4QQ4rLs2LFXYF8hhBBCiLJwRs5x7Ngx/P39Hes9PT2dEFmhrl270rVrV8fP3bp1o1WrVsybN49p06Y57TyXkga7EEKIy7KpKja1fE/Ky7ufEEIIIWoeZ+Qc/v7+RRrspQkKCkKv15OamlpkfWpqapnHqHt4eNC+fXsSExOvPuAyki7xQgghhBBCCCFqFKPRSIcOHVi3bp1jnd1uZ926dUWeol+OzWYjLi6OsLCwygpTnrALIYS4vIqMRZcx7EIIIYQoq6rOOSZOnMgDDzxAx44d6dy5M7NmzSInJ8dRNf7++++nfv36jnHwU6dOpUuXLoSHh5Oens6bb77JkSNHGD16dLliLgtpsAshhLgsOyo2abALIYQQopJVdc4xaNAgTp8+zZQpU0hJSaFdu3asXr3aUYju6NGj6HT/dEo/f/48Y8aMISUlhVq1atGhQwc2bdpEVFRUuWIuC0VVZYChEEKI4jIzMwkICODQ/rr4+ZVvBFVWlp3mkSlkZGSUaTyZEEIIIWoeyTlKJ2PYhRBCCCGEEEKIaki6xAshhLgsqRIvhBBCiKogOUdx0mAXQghxWfYLS3n3FUIIIYQoC8k5ipMGuxBCiMuyVaAATHn3E0IIIUTNIzlHcTKGXQghhBBCCCGEqIaq9RP27OxsEhMTKSgowNPTk/DwcHx9fbUOSwghahSbWriUd18hXIHkHEIIoT3JOYqrdg32vXv3MnfuXNasWUNCQgKXzjqnKAoRERHceuutPPLII5U6350QQohCMp5MuCvJOYQQonqRnKO4atMlPikpid69exMdHc2yZcu46aabWLhwIVu2bGH37t1s2bKFhQsXctNNN7Fs2TKio6Pp3bs3SUlJWocuhBBuzY6CrZyLHUXr8IUoRnIOIYSoniTnKE5RVe3r3y9YsIAJEyYQFBTEq6++yoABAzAajaVubzabWb58Oc8//zxnz55l1qxZjB49ugojFkII95eZmUlAQADb40Px9Svf/d3sLDsdo1PJyMjA39/fyREKcfUk5xBCiOpHco7Saf6E/ZVXXmHMmDEMGTKEuLg4hg4detkvTgCj0cjQoUPZs2cPQ4YMYcyYMbzyyitVFLEQQgghXJHkHEIIIVyNpmPYFyxYwOTJk5k2bRqTJ0++6v39/PyYP38+jRo1YvLkydStW5dRo0ZVQqRCCFFzXexqVt59hagOJOcQQojqT3KO4jR7wp6UlMSECRMYPXp0sS/Obdu2MX78eKKjo/Hx8aFRo0bce++9HDhwoMRjTZ48mdGjR/PEE0/I+DIhhHCy8o4lq8iXrhDOJDmHEEK4Bsk5itNsDHvv3r3Zt28fcXFx+Pn5FXltwIAB/PHHHwwcOJA2bdqQkpLC+++/T3Z2Nlu2bKF169bFjpeZmUlMTAxRUVGsWrWqqi5DCCHc1sXxZBv31KvQeLLrWp90u/FkwrVIziGEENWb5Byl06TBvnfvXqKjo1myZAlDhw4t9vqmTZvo2LFjkXFlBw8eJCYmhgEDBvDpp5+WeNylS5cybNgw9u7dS6tWrSotfiGEqAnky1O4A8k5hBCi+pOco3SadImfO3cuISEhDBgwoMTXu3XrVqwITIsWLYiOjmbfvn2lHrd///6EhITwwQcfODVeIYSoyaR7mnBlknMIIYTrkJyjOE0a7GvWrKF///5XrMx6KVVVSU1NJSgoqNRtPD096d+/P2vXrnVGmEIIIQAbugotQmhJcg4hhHAdknMUV+VXlZWVRUJCAp06dbqq/ZYsWcKJEycYNGjQZbfr2LEj+/fvJzs7uyJhCiGEuEBVFezlXFTVPe92C9cgOYcQQrgWyTmKq/IG+6FDh1BVlaioqDLvs3//fh599FG6du3KAw88cNlto6OjUVWVxMTEioYqhBBCCBcmOYcQQghXV+XzsBcUFADg7e1dpu1TUlK44447CAgIYPny5ej1+stu7+XlVeQ8QgghKkbmRBWuSnIOIYRwLZJzFFflDXZPT08AcnNzr7htRkYGvXv3Jj09nd9//5169epdcZ+8vLwi5xFCCFExNlWHTS1fhyybJhOHClFIcg4hhHAtknMUV+Vd4sPDw1EUhb179152u/z8fPr06cOBAwf44YcfytydLT4+HkVRCA8Pd0a4QghR49lRsKMr5+Ked7uFa5CcQwghXIvkHMVVeYPd19eXiIgItm3bVuo2NpuNQYMGsXnzZr788ku6du1a5uNv376dyMhIfH19nRGuEEIIDcyePZsmTZpgMpmIjY3lzz//LHXbxYsXoyhKkcVkMpW6/SOPPIKiKMyaNasSIhfVieQcQgghXF2Vd4kHuPXWW1m2bBmzZs0qcZqVp556iu+++44+ffpw7tw5Pv300yKvDx8+vMTjFhQUsGLFiitWdRVCCFF2VT2ebNmyZUycOJG5c+cSGxvLrFmz6NmzJwkJCYSEhJS4j7+/PwkJCY6fFaXk83799dds2bKlTN2dhXuQnEMIIVyHjGEvTpMG+yOPPMJ7773H8uXLGTp0aLHXd+3aBcD333/P999/X+z10r48V6xYQVpaGmPHjnVqvEIIUZNVbDzZ1Q8omzlzJmPGjGHkyJEAzJ07l5UrV7Jo0SL+85//lLiPoijUrVv3ssc9ceIEjz32GD/99BN33HHHVcclXJPkHEII4TqqOudwBZrMLh8VFUWvXr2YNGkSWVlZxV7fsGEDqqqWupQkMzOT5/7zH27r2ZNWrVpV9iUIIUSNUTierPwLFH5GX7qUVlXbbDazY8cOevTo4Vin0+no0aMHmzdvLjXG7OxsGjduTMOGDbnrrruIj48veg12O/fddx/PPPMM0dHRTvitCFdRmTnHrT1vk5xDCCGcyBk5h7vRpMEOMGfOHM6cOcPEiRMrfCxVVZk4cSIpp9Ng2E2cys10QoRCCCGcpWHDhgQEBDiWGTNmlLjdmTNnsNlshIaGFlkfGhpKSkpKiftERESwaNEivv32Wz799FPsdjvdunXj+PHjjm1ef/11DAYDjz/+uPMuSriMSsk5zqTh8WBHjuacdkKEQgghRMk06RIP0LRpU2bNmsWYMWNo3LgxkydPLtdxVFVl+vTpLFy4kAaj7+Kw0czdaxcyu9sAOgQ1dHLUQghR89jRYSvn/V07hU8ojx07hr+/v2O9M6fB6tq1a5FCYd26daNVq1bMmzePadOmsWPHDt5991127txZ6th24d4qI+eIePR2zvnZeXDLHKa2GUS34EgnRy2EEDWPM3IOd6NZgx1g9OjRpKamMnnyZI4cOcLMmTPx8/Mr8/6ZmZlMnDiRhQsXMvapCSR1bcypvCzOq9kM3/AJL7bvxeDm11TiFQghhPtzxngyf3//Ig320gQFBaHX60lNTS2yPjU19Ypj1C/y8PCgffv2JCYmAvD777+TlpZGo0aN/onLZuOpp55i1qxZJCcnl/FqhCtzZs7x+LMTSb+lHsfyzpKn5vPUzv8xtsVt3Nf0BrkpJIQQFSBj2IvTrEv8Rf/973+ZP38+n332Ga1bt2bp0qWYzebL7lNQUMDSpUuJiYnh888/Z9asWUx7fjLvdxvANbXr420FLDYm7/iRKTt+xGyzVc3FCCGEGyr/fKiFy9UwGo106NCBdevW/XN+u51169aVebotm81GXFwcYWFhANx3333s3r2bXbt2OZZ69erxzDPP8NNPP11VfMK1OSvnmPLsJKa3HUrn2uF4mhUMFpU5B39i8u7PyLNe/nhCCCFKV5U5h6tQ1NIqqlSxpKQkxo0bx+rVqwkJCaF///507NiR6OhovLy8yMvLIz4+nu3btzsqs95yyy288cYbNG7c2HEcq93Oh/s38VXybix6yNdDx+BGvN+tP0EmmSdVCCHKKjMzk4CAAD75KwZvP325jpGbZeO+9nFkZGSU6Qk7FE7r9sADDzBv3jw6d+7MrFmz+OKLL9i/fz+hoaHcf//91K9f3zEOfurUqXTp0oXw8HDS09N58803+eabb9ixYwdRUVElnqNJkyZMmDCBCRMmlOu6hGtzVs5hV+18dWwry45swqZXKfCAFv5hvN7+Pup51dLwCoUQwrVolXO4Ak27xF+qadOmrFq1ir179zJ37lzWrl3L3Llzi1ZoVRT86ocyqG9fHnzwQVq2bFnsOAadjnFR1xHuH8Q7e35FZ7Wx4/RR+q1ZyAfXDiSmtsy9K4QQ1dmgQYM4ffo0U6ZMISUlhXbt2rF69WpHIbqjR4+i0/1zF/38+fOMGTOGlJQUatWqRYcOHdi0aVOpjXUhypJzKAq0aOZL374DePDBh0rMOXSKjgGNutLYJ5j3ElahKzCTmHGKkZvf55W2Q+lYp3lVXpYQQgg3VG2esJckOzubxMRECgoKeHvfb/xFBr56TxbfMJQGPoFX3H//+VRe+ms1pwtyyDUUjmuc3uF27m7SpvKDF0IIF3fxbvfiv9pW6G73iPZ/u93dbuF+Ls05PMyLaBK6HpvdDyVgJoqx9RX3P55zljf2fcOp/HQKPFQw6HisZW8GNb5WxrULIcQVSM5Rumrd0d/X15d27doRGxvLtR07g1dhVeGkrHNl2j+yVihzug0gJrAuPlawmy088+d3vLJrDVa7vTJDF0IIt2FXdRVahHAFl+Yc7TvcQIAfoAC2pDLt38CnDjPaDuOawKZ4mhUUi51ZCSuZtmc5BTZLpcYuhBDuQnKO4lzmqiICQ1AVBVWBw5lnyrxfbZMPb3S+izsaRGGygsmq8lHCFh78bSnnC3IrMWIhhHAPtgtTrJR3EcLlGCJQFNDr7KjWsjXYAXw8TDwb3Y+7G3TGaFHwNMOPJ3Yy9s8PScvPqMSAhRDCPUjOUZzLXFVkQOHYRbsCSVlnr2pfo17PkzE3MqH19XjZdXhbYXNqEvesXcT+9NQrH0AIIYQQNYehcLy6XmeDq2iwA+gVHUObdufJyDvwxgOTGfalH2fE5vf5+3xyJQQrhBDCnblMg72hTyBeeg9sChzOLluX+H+7s1Fr3oztS5DBCx8LnMg6z8B1i1l1bJ+ToxVCCPdhB2yqUq5FBh8JV6To/EBXH4PeDrbDqOrVv5O7BUcyvc0Q6hoD8DIrpOdn8+i2BXxz7M9KiFgIIdyDFjnH7NmzadKkCSaTidjYWP78s2yf059//jmKotCvX79ynrlsXKbBrtfpaBkQjF2BUzkZ5FrKN89pTO16vH/tACL8g/GxgsVs5rHNK3g7bj326lt/TwghNCNzoooaySMCvd4Gah7Yytcbr4lvCDPaDiPGvyGmAgUsNl7b+zWv7/0Gi93q5ICFEML1VXXOsWzZMiZOnMiLL77Izp07adu2LT179iQtLe2y+yUnJ/P000/TvXv38l5qmblUJhUREIJNARU4kn2+3McJ9fLjndh+9KjXEi8reFpVPtj3Bw9vXEaWOd95AQshhBuwqboKLUK4JENE4RN2AFtyuQ/jb/RmUuv+3F6vPUaLgtEMXx/dyvhtCzlbkOWcWIUQwk1Udc4xc+ZMxowZw8iRI4mKimLu3Ll4e3uzaNGi0mO02Rg2bBgvv/wyzZo1q8jllolLZVIRASHYL8yMcjir7IXnSuJp8OC5NrfwSOS1mOwK3haVDScP0n/dRxzOvLox8kIIIYRwL4ohAp1ORVFUsB6u0LEMOj0jm9/Moy174qUaMJlh9/lkRm6Zzb6M406KWAghBBROEXfpUlBQUOJ2ZrOZHTt20KNHD8c6nU5Hjx492Lx5c6nHnzp1KiEhIYwaNcrpsZfEtRrsgSGgKOUqPFcSRVEY0KwtMzrdSS2DCR8LJGee4Z51i/jl5EEnRCyEEK7PjlKhRQiX5HGh8JzejlrGqd2u5MbQ1rwcM4gggx+mAoUzuRk8/Oc8Vp3c6ZTjCyGEq3NGztGwYUMCAgIcy4wZM0o815kzZ7DZbISGhhZZHxoaSkpKSon7bNy4kYULFzJ//nznXvhluFaDPSAEKKwUf6iMc7GXRYeghrzftT/NfevgY4H8gnwe3riMOXs3osq4diFEDSdd4kWNpG8CGDHobRV+wn6pFv5hvNZ+OK386mEqULCbrbwc9yWz9v+A1W5z2nmEEMIVOSPnOHbsGBkZGY7l+eefd0psWVlZ3HfffcyfP5+goCCnHLMsDFV2Jieo5elNqJcf522ZJGefRVVVFMU5T2/q+QTwbte7eXP3en5LOUSBXmXmng3Ep6fwRqe++HgYnXIeIYRwNRWZ29Rd50QV7k9RDKiGFuh1B8B2ElUtQFE8nXLsWkYfpsQMZNGh9axN2Y1OVfk8+Q8Ss1J4pe0QAow+TjmPEEK4GmfkHP7+/vj7+19x+6CgIPR6PampRQuLpqamUrdu3WLbHzp0iOTkZPr06eNYZ7cX1joxGAwkJCTQvHnzcsV+OS6XSUVeGMeeZS7gdH6OU4/tZTDyQvvbGNkyFpMNvCwqPx3bx72/LOZoBYrcCSGEEMIFeUQUPmHHDtYjzj20zsDDLW7lofAeeNp0mMyw/ewhRm6ZzcGsU049lxBCiOKMRiMdOnRg3bp1jnV2u51169bRtWvXYttHRkYSFxfHrl27HEvfvn256aab2LVrFw0bNqyUOF2uwR4RGIrtwkN1Z4xj/zdFURgW3oFpHW4nQG/ExwIH01O5e+1C/kh1Xpc4IYRwFXZVqdAihKtSDBHoL1aKtzpnHPu/3RrWlhdj7qWW3gevAoWUnPOM2foBv6TEVcr5hBCiOqvqnGPixInMnz+fjz/+mH379jF27FhycnIYOXIkAPfff7+jS73JZKJ169ZFlsDAQPz8/GjdujVGY+X0yHa9BntAMKqigFLxSvGX0yW0Ce937U9j70B8LJCTn8fI3z5jYcIWGdcuhKhR7Be6p5VnkXnYhUsztERRnFt4riStAhrwWrthNPcJxVSgYDFbmPT3Uj44+BN21V5p5xVCiOqmqnOOQYMG8dZbbzFlyhTatWvHrl27WL16taMQ3dGjRzl1StteTy41hh0gMqDwl2dTIMmJhedK0tC3Fu937c+M3evYkpZMgWpnxt9r2Zuewisd7sBk8KjU8wshRHVgV3XYy1k8rrz7CVEtGCIB0Ovs2JxYeK4kQSZ/prYZxPzENfyatg+rQeXjwxtIzDrFyzGD8fUwVer5hRCiOtAi5xg/fjzjx48v8bUNGzZcdt/FixeX65xXw+UyqaZ+dfDQ6Zw2tduV+Bg9mdqhN8OaX4OntXBc+7fJcQxe/z9O5mZU+vmFEEIIoQ1FXwd0Qej1NrAmVXoPO0+9B4+27M0DTW/EaNVhKoA/0hIYtXUOR3JOV+q5hRBCVE8u12A36vU09wvCpsCx7HTMNmuln1OnKIyM6MIL7XvipzPgY4X4cye5e80itp0+WunnF8JdZWdns2vXLrZu3cquXbvIzs7WOiRRAhtKhRYhXJohAoPeDmoG2Cu/AK2iKNzZoAP/bd0ff50JrwKFo1mneXDLbDam7av08wvhriTncA2ScxTncg12gIjAwkrxVtXOsZz0KjvvDWHNebdLf+qb/PGxQHpeNvdt+JSliTuqLAYhXN3evXt5/PHHadWqFf7+/rRv354uXbrQvn17/P39adWqFY8//jh79+7VOlRxwcXuaeVdhHBphgj0ugvzo1fiOPZ/a1OrMa+1G05jryC8zAr5BQU889cnLDr0i9TSEaKMJOdwPZJzFOeSVxUREOKoFH84s/IKz5WkmX8dZncbQMc6DfC2gM5qY8rOVUzevpKCKnjaL4SrSkpKonfv3kRHR7Ns2TJuuukmFi5cyJYtW9i9ezdbtmxh4cKF3HTTTSxbtozo6Gh69+5NUlLVJciiZDYqcsdbCNemeLREr1dRFBUqeRz7v4V6BfJK2yF0rdMST7OCwaLyYeIaJv29lFxrQZXGIoQrkZzDdUnOUZyLNthDQVFQFTicXbmF50ribzTxSsc7Gdi0HZ5WMFlVPj+0k/s2fEpaXlaVxyNEdbdgwQJiYmLYt28fS5Ys4dixY8yZM4eRI0cSGxtLTEwMsbGxjBw5kjlz5nDs2DGWLFnC3r17iYmJYcGCBVpfQo0md7tFjXZJ4Tm1ihvsACaDkScj72RIk2sxWnV4mmF9yh7GbJ3Lidyqz4GEqO4k53BtknMU55JXFRkYAhRWij+cWfmF50pi0Ol4uFU3/tP2FnzQ422Fv84c4+61i/j77AlNYhKiOnrllVcYM2YMQ4YMIS4ujqFDh15xnkqj0cjQoUPZs2cPQ4YMYcyYMbzyyitVFLEQQlzC0BzQF87HXoVd4i+lKAr3NOzCc9H98FM88SpQOJyZwsjN7/Pn2URNYhKiOpKcQ7gjl2ywh5h8qWX0wq5AchVUir+cHvUjmBV7N3WNPvhY4ExOJkPW/4+vkv/WNC4hqoMFCxYwefJkpk2bxvz58/Hz8ytxu1deeQVFUWjdunWR9X5+fsyfP5+pU6cyefJkFi5cWBVhi3+xqboKLUK4MkXxBENTDHobWI+iqhbNYulQuxmvth1GA6/aeJkVcgrymLB9EUuTf5dx7aLGk5zDPUjOUZxLXpWiKEQEFo5jP1uQy/mCXE3jaRkYwpxrB9AmMAxvK6gWK8/++T3T/voJi91dR1MIcXlJSUlMmDCB0aNHM3ny5FK3O378OK+++io+Pj6lbjN58mRGjx7NE088IePLNKCiYC/norppxVZRwxgiCp+wYwWrtr3o6nvX5pU2Q+lQqxmeZgW9VeX/En7k5bgvyLdpdzNBCC1JzuE+JOcoziUb7FBYeM5+IfrkLO3HcNXy9OH1zn3p0zAa04Vx7R8f+JORvy3lnMY3FITQwrhx4wgKCmLmzJmX3e7pp5+mS5cudOzYsdRtFEXh7bffpk6dOowbN87ZoYorkLvdoqZTDC3R6+yFP2jULf5SPh6ePBt1F/c0jMXDouBphtUnd/HIn/NIzUvXOjwhqpzkHO5Dco7iXPaqIgJCsAMocFjjbvEXGfV6nmh9A0+2vgFvVYe3FbamJnPP2oXsS0/VOjwhqszevXtZvXo1r776aqld0gB+++03li9fzqxZs654TH9/f2bMmMHq1avZt0/mIhZCVCFDJDqdik6notqqvvBcSXSKjiFNrmNi5J34YMRkhoT0E4zYMptd57W/qSBEVZGcQ7g7l22wRwYWVoq3KZBUTRrsF93RKJq3Yu8i2MMbHwuczEpn4LqPWHk0XuvQhKgSc+fOJSQkhAEDBpS6jc1m47HHHmP06NHExMSU6bj9+/cnJCSEDz74wFmhijKwq0qFFiFcnkcEAHq9DazVqzHcNTiC6W2HEGYMxMuskJGXzaPbFrDi6BYZ1y5qBMk53IvkHMW5bIO9hX8wCmCvhg12gOhaYczuNoBWASH4WMFmtvDElq95c/cv2Ox2rcMTolKtWbOG/v37X7Yy69y5czly5AjTpk0r83E9PT3p378/a9eudUaYooxs6Cq0COHydGGg+GHQ2atdgx2gsU8wM9oOIyagESazgmKx8+a+b3lt79eY7VatwxOiUknO4V4k5yjOZa/Ky+BBE7/ahQ327HPVshEc7OXLzNh+9KwfgckKnlaVefv+4KGNy8g052sdnhCVIisri4SEBDp16lTqNmfPnmXKlCm88MILBAcHX9XxO3bsyP79+8nOzq5oqKKM5G63qOkURblQeM4G9tOo9iytQyrGz+jFpOh76FO/I0aLgtEM3x7bxqPbFnCmIFPr8ISoFJJzuB/JOYpz2QY7QMuAwkrxZpuNk7kZWodTIqPewNMxN/Noq+vwsit4W+G3U4ncs3YRBzNOax2eEE536NAhVFUlKiqq1G0mT55M7dq1eeyxx676+NHR0aiqSmKizD0shKhCHhEY9BceDlTDp+wABp2e+5vdwPiWvfFWDZjMsOf8EUZunk18+jGtwxPC6STnEDWBSzfYIwNCsF+4kVJdCs+VRFEU7m7ahtc696G2wYSPBY5mnmXAuo9YcyJB6/CEcKqCggIAvL29S3z94MGDfPjhhzz++OOcPHmS5ORkkpOTyc/Px2KxkJyczLlzpc/84OXlVeQ8ovLZ0VVoEcIdKIYIdDo7KIC1ehSeK80NoVFMazOEYA8/vAoUzuZlMnbbh6w8sUPr0IRwKsk53I/kHMW59FVFBoaiKgqqAoczq2+D/aL2dRowu9sAwv2C8LFCgbmAsX98yXvxv2GXwjDCTXh6egKQm1vydIYnTpzAbrfz+OOP07RpU8eydetWDhw4QNOmTZk6dWqpx8/LyytyHlH5bKpSoUUIt2CIQFFAr7OjVoOp3a6kmV8oM9oNJ9KvPqYCBbvZyrQ9y5m573usdpvW4QnhFJJzuB/JOYozaB1ARUQEhAAXCs9lV/8GO0Bdb39mdenH23Eb2HAqEbNe5d3439iXnsobnfvi6yEfCMK1hYeHoygKe/fuJTY2ttjrrVu35uuvvy62fvLkyWRlZfHuu+/SvHnzUo8fHx+PoiiEh4c7NW5RuoqMC3PX8WSiBjK0KPyP3obNmqxtLGVUy+jDlJgBLD68gZ9P/Y1OVfniyCYOZafwStuhBBp9tA5RiAqRnMP9SM5RnEs32Bv4BOJjMGK1FpCUVXp3lurGy2Dkv+1uJdw/iIUJW9CpKj8f309S1jk+uHYgTfxqax2iEOXm6+tLREQE27ZtY+TIkcVeDwoKol+/fsXWX5wXtaTXLrV9+3YiIyPx9fV1QrRCCFE2is4XVd8QvT4VLMmoqh1Fqf4dFT10BsaE96CpTwgLD61DZ7ex4+xhRmx+nzfa30dL/3pahyhEuUnOIWqC6v9Ncxk6RaFFQDB2BU7lZpJjMWsdUpkpisLg5tfwSsc7CdAb8bHAoYw07lm7iN9TDmkdnhAVcuutt7JixQrMZuf+TRYUFLBixQp69Ojh1OOKy1NVHfZyLqrq0l8zQhRliMCgs4GaB7YUraO5Kj3C2vBizL3U0fviVaCQlpvOmK1zWXNqt9ahCVEhknO4F8k5inP5q4q8UCkeINlFusVfqnNII2Z3G0ATn1r4WCC3II9Rv3/Ogv2bUWVcu3BRjzzyCGlpaSxfvrzM+2zYsIE9e/ZcdpsVK1aQlpbG2LFjKxqiuAo2lAotQrgNQwT6i5XibdW78FxJIgPqM6P9MFr41sVUoGAzW3hh92fMPrAam1r9pscVoiwk53AvknMU5/IN9oiA0H8qxbtA4bmSNPAJ5L2u/eka0gQvCxisdl7bvY6ntn5DntWidXhCXLVTek8CI6N57j//ISvLOfMVZ2Zm8vzzz9OrVy9atWrllGOKsrGrFZkXVevohXAexSMCnU5FUdRqO7XbldTx9OPlmHu5MSS6cL52C3xy+Fee3vkxWZY8rcMT4qrlGfwJbtZacg43ITlHcS7fYI8MDAFFKSw8V42ndrsSHw8jL1/Tm/vCO+JpBS+LyndH9jDol485kZOudXhClIldVfm/DZsY98V31Ordj5S0NJ588skKH1dVVZ566inOnj3LnDlznBCpEEKUgyGi8D96G6qLNtgBjHoPxrXsychmN+Jp02Eyw+bTB3hwy2ySslO1Dk+IMlFVlaXrdvLIrOUEx95FSqrkHMI9uXyDvUileBcqPFcSnaLwQMvOvHRNL/x1HvhYYd/5U/Rbu4itaUe0Dk+Iy8rIy+eRz79l9u9bAfCoVYfrR45h4cKFTJ8+vdzHVVWV6dOns2DBAt59912aNm3qrJBFGZV3LNnFRQi3oW8EmAq7xbvA1G6XoygKt9fvwOToAQTovPAqUDiRfZZRWz7gt7S9WocnxGXlmS1MXrSat778FZtdxdO/DtfePVJyDjcgOUdxLn9V/kYTYd7+2HRwOPusW4z7vq5uM97t2p8GXgH4WCAzL4cHfl3CJwe3u8X1CfeTkHqGAQuX8mtiYQKrUxSeuaU7a+f8H9OnT+eFF15gzJgxV91VLTMzk4ceeogpU6bwyiuvMGrUqMoIX1yBHaVCixDuQlH04NECg94GtpOodtfvQt66ViNmtB9OU+9gTGaFAnMBz/71CQsT12GXce2iGjp+Op2Rbyxj1bb9jnUjenZk3dLZknO4Ack5inP5BjsUFp6zK5BjMZOW55yxK1pr6leb2V3707FOQ7wtoLPaePmv1Ty//QcKbFatwxPCYeWeBAZ99BlHz2cAEOhlYuHQuxndrSOKovDf//6X+fPn89lnn9G6dWuWLl16xUquBQUFLF26lJiYGD777DMWLFjApEmTquJyRAlsqlKhRQi3YohAr7MDKljdo/dbqCmAaW0G0y0oAk+zgocF5h9ay/O7lpJjLdA6PCEc/ohPZviMpRw4fhoAL08P3nzoTh6/uzt6nU5yDjcgOUdxLj0P+0URASFsOHkQgMNZZwn19tc4IufwM5p4teMdLDqwlWWH/0Knqiw/vIvEzDPM7jaAUC8/rUMUNZjVbuftdRtZtGWHY11U3RDeG3gnDQIDimw7evRobrnlFsaNG8ewYcN48skn6d+/Px07diQ6OhovLy/y8vKIj49n+/btjsqsvXr1Ys6cOdIlTWMV6Wbmrt3TRM2lFKsUH6lpPM5iMhiZEHEHTX1CWJq8EZ1q59fUeMbknuH1dsNp6BOkdYiiBlNVlUWrtzHnuz+42Nm0UUggMx/pS7N6dYpsKzmHa5Ocozi3aLBHBoaiKgooKoezztE11H3+0PQ6HWMiu9Lcvw5vx61HZ7Xx95nj3L1mIbOvHUD7Og20DlHUQOdycpnw1Y9sTT7mWNevTStevr0HJo+SP1aaNm3KqlWr2Lt3L3PnzmXt2rXMnTv3X8M8FPw9Arnjzt688MpkqcwqhKh+DBEoCuj1dmy2JLfqgKkoCv0adqaxTxDvJvxIdkEBSWoqD26ZzbS2Q+gS1FLrEEUNlJ1XwIsf/8z6XYmOdTe0acbUkb3w8/IscZ8y5RyKgl9AKLfcchuvTpskOYeottyiwX6x8JzNxSvFX87N9VrS0KcWL+5cRWp+NmfVLIau/4Sp1/RmYLN2WocnapC4kyk89uUPnMosHH5i0OmYdNsNDO3YFkW5cuoaFRXF//3f/wGQnZ1NYmIiBQUF7Pwpji9eXInBauD29nfLF2c1YqdwupTy7iuEW/EobLTqdTZs1mRtY6kk7Ws349W2w3hz3zcczztHrprPxB2LGdeyF8OadC/TZ70QzpCUco6n5n5PckphYWlFgUfu7Mqo3rHodOXPOQ4cOsPcT/9Cb/Dk+h7tJeeoRiTnKM4t+g008auNh06PXSnsEu+uWgQEM7vbANrWqoe3FbBYeX77D7y8czUWu03r8EQNsHzXHoYu/sLRWA/29eZ/9w9gWKd25UrgfH19adeuHbGxsfQb3geDUngPMW7jPqfGLSpGrUDxF9VNvzxFzaXoaoMuBIPeDtYkty0GW8+7Fq+0HUrHWs3xNCvorSrvH1jFi7uXkW+7/JhgIZxh/a5E7n/tM0dj3c/bk3fH9WPMHV3K1Fj/t0tzjnv69cDDaAJg997jTo1bVIzkHMW5RYPdQ6cn3D8ImwLHc9Ixu3FRtlqe3rzeuQ/9GrXGZAWTVeWTg9t44NclnM3P0To84abMNhsv/riO/36/BrOt8OZQ+wZhrBg9jA4N6zvlHHWbhlCnXi0A9m0+gM0qN6GqC7uqVGgRwu1cHMeuZoL9jNbRVBpvgyfPRPVlYKOueFgUPM3w86m/eWjrPE7lndc6POGmbHY773/zB0/N/Z6c/MKbQ+H1g/jkP0O5LsY5w159vD1p3iQYgMNHTpOVne+U44qKk5yjOLdosENhpXibAnZVJTnbtedjvxIPnZ7x0dfzVMxNeKt6vK2wLe0Id69dyJ7zp7QOT7iZ1Kxs7v/fl3y+Y7dj3ZAObfjf/QMJ9fN12nkURSGme2GXtLzsfBJ3JTvt2EII4VQeEeh1F24quvh87FeiU3Tc27gbT7fqiy9GTGY4mHGSkZtns/PcYa3DE24mIyefJ2Z/y6LVfzrW3daxJR8/O5hGIYFOPVeb6MI6UKoKe/adcOqxhXAmt2mwRwSGYr9wUyU5y70b7Bf1btiKt2PvIsTDGx8LpGRnMPiXj/n+6B6tQxNuYvvRE9wzfwl/HS+8EWTU63m1z228dPstGPV6p5+v9XX/jCHb87t0i68uLlZsLe8ihLsprBSvoigqWNy7wX5RbFALXmk7lHrGQLzMCpn5OTy2fSHLj25222EBomodOH6a4TOWsCk+GQC9TmHigOuZMep2vDw9nH6+tlH/FG7+W7rFVxuScxTnNlcVGRACioLq5uPY/y2qVl1mXzuQqMBQfKxgM1t4css3vP73Omx2u9bhCRelqiqfbtvFA58s50xOLgBh/n4sHXEv/dtFV9p5Lz5hBxnHXp1I9zQh/sUQARRWilfd/An7pRr6BDGj3XDaBjTGZFZQLHbe2vcdr8Z/hdnuvsMRReVb9ed+Rrz+OSfOZAIQ6OvFnCf6M7xHh0orctjmkgb77nhpsFcXknMU5zYN9ppQKb40QSYf3u58F73qR2KygqdVZf7+TYz6/XMyzHlahydcTL7Fyn+++4lpq9djvXDTp0uThnw1eigx9epW6rmbtG6Ib6APAPEb98tTm2qivMVfLi5CuB1DM8CAXmd3+y7x/+brYeL51vfQt35HjBYFoxm+P76dcX9+yOn8TK3DEy7GYrPx1hcb+O+iVeRbCm/6RDUOZcmkoXSKaFip565dy4cGF2rn7E9MoaDAUqnnE2UjOUdxbtNgDzL5UNvTG5sChzNrVoMdwKg38FTMTYyP6o63XYe3Ff5IOcTdaxdxIOO01uEJF3E8PYMhi5fxze5/nm4/2LUDC4fdQ20f70o/v06nI/rawidX6aczOZZwstLPKYQQV0tRjGBohkFvA+tRVLVmVU3XKzrua3YDT0TcjrfqgckM8enHGLnlffakH9U6POEizmbmMG7WVyz95S/Hur7doln49L2E1favkhguPmW3Wu3sO5hSJecU4mq5TYNdURQiA0Kw6+C8OY/zBTWvYrqiKPRrEsPrnftQx+CFjwWOZ55j4LqPWHMiQevwRDW36fAR+i9Yyt6UNAC8PAy8c8/tPNfjegy6qvuokHHs1Y90TxOiBBcrxWMDa83sTntdSCumtR1MqIc/XgUK5/KyGPvnh3x3fJvWoYlqbk9SCsNeXcqOg4V/Owa9jklDb+bF+27F08NQZXG0jb5kHLt0i68WtMg5Zs+eTZMmTTCZTMTGxvLnn3+Wuu1XX31Fx44dCQwMxMfHh3bt2vHJJ5+U93LLxG0a7FC08NzhGlJ4riRt69RndrcBtPALwscKBQUFjP3jS97d8yt26WIs/kVVVeZv2saopV+Tnlc4rUmjWgF88eAQbo+OqPJ4ZBx79SMNdiGKUwwRhU/YAWw1t1p6M99QZrQbRpR/A0wFCqrFxqvxX/HW3m+x2mV6TlHc1xvjGPX2F6SlZwMQFODD/KcGMuD6tpU2Xr00baL+mZpW5mOvHqo651i2bBkTJ07kxRdfZOfOnbRt25aePXuSlpZW4va1a9fmv//9L5s3b2b37t2MHDmSkSNH8tNPP1X00kvlVg32yIAQ7IoCNbRb/KVCvf2Y1eVubg5rgdeFce3v7f2dcX98SZalQOvwRDWRXWDmiRUreWvdRsfNnBtbNGXF6KG0DAnSJKaWHZthNBVWg437TRrs1YE02IUogUckikdrdN63gS5U62g0FWD04YXWA+hVr51jXPvyo1t4bPtCzpuztQ5PVBNmi5XpS9Yy7dO1WKyFN3Pahddj6aRhtG1WT5OY6tUNpE7twto5e/afwGqTgs1aq+qcY+bMmYwZM4aRI0cSFRXF3Llz8fb2ZtGiRSVuf+ONN3L33XfTqlUrmjdvzhNPPEGbNm3YuHFjRS+9VG7VYC9SeC67ZjfYAUwGD55v24OHIrtisit4WVTWnkhgwLqPalxhPlFc0tnzDFr0GT/tO+hYN/76Lnww6C78TSbN4vIwehAZ2wKA1COnSTt2RrNYhHaupnva4sWLURSlyGK65D1ssVh47rnniImJwcfHh3r16nH//fdz8qTUSBAVYOyOLugrDAH/AY9WV97ezRl0ekY1v4WxLW7Dy67HZIZd55IYuXk2+zNljuuaLvV8FqNnfslXv8c51g26sR3zJgwgKMBHs7gURXGMY8/Ls5B4uOSnqsK1ZGZmFlkKCkp+WGk2m9mxYwc9evRwrNPpdPTo0YPNmzdf8TyqqrJu3ToSEhK4/vrrnRb/v7lVgz3cPwidomCXJ+wOiqJwb7P2vNLxDgL1nvhYICnjNPesXcSvpxK1Dk9oZF3CIQYsXErimcKhI76eRj4Y1JfHbuiKroq7o5UkRsaxVyvVvXsagL+/P6dOnXIsR44ccbyWm5vLzp07eeGFF9i5cydfffUVCQkJ9O3bt1y/DyEAR9ddDw8PFKXqxtxWdzfXjeGlNoOoY/DFVKCQlpvOw1vn8fOpXVqHJjSy4+Bxhr26lD1JhUXdPD30TB3Rk+cG34SHQa9xdP+a3k26xWvOGTlHw4YNCQgIcCwzZswo8VxnzpzBZrMRGlq0l1RoaCgpKaUXIczIyMDX1xej0cgdd9zBe++9x6233uq8X8K/uFWD3WTwoKlvbWwKHMk+75iSSkCn4Ea8360/zXxq42OBvIJ8Rv/+OXP3/SFTZ9UgdlXl/zZsYtwX35FdUFjVODyoNstHDeXmls01ju4fMddfMo5dGuyaUyn/NCvl+XS52u5pUNh4qlu3rmO59Ms3ICCANWvWcO+99xIREUGXLl14//332bFjB0ePSkVrUTF6vfYNjuqmpX89Xms3nAjfupgKFGxmC1N2L+O9hFXYVMnNagpVVfnsl78Y+84KzmXlAhBW259Fzwzizi5RGkf3j3ZSeK5acUbOcezYMTIyMhzL888/79QY/fz82LVrF9u2beOVV15h4sSJbNiwwannuJRbNdjhn8JzFruNE7kZWodTrTTwCeTdrvdwXUhTvCzgYVV5K249E7Z8Ta61Zk1JUxNl5ufzyOffMvv3rY51PVu14ItRQ2hap5aGkRUX1bUlOn3hx9Oejfs1jkY44253ZXdPy87OpnHjxjRs2JC77rqL+Pj4y15TRkYGiqIQGBh49b8QIS5hMMjT9ZLU9vTlxTaDuDm0deG4dgssSfqNiTsWk2HO1To8UcnyzBYmf7SaN7/Y4HiAFhvZiCWThtKqUfWq+dC0cTC+Pp4AxO07IQ+yNOaMnMPf37/I4unpWeK5goKC0Ov1pKamFlmfmppK3bp1S41Rp9MRHh5Ou3bteOqppxgwYECpT/Gdwe0a7IWF5wr/nZQpY1//zcfDyJRrejGiRWc8beBlUVl5NJ5Bv3zM8Zx0rcMTlSQh9Qz9Fyzl18QkAHSKwtO3XMe7/e/Ax2jUOLrivHy9CG/fFIDk+GNkns3SOCJRUZXZPS0iIoJFixbx7bff8umnn2K32+nWrRvHj5f8pCQ/P5/nnnuOIUOG4O9fNXP9Cvelu4ppL81mM8nJyaxfv57FixdXXlDVhFFn4JEWtzGq+c142nSYzLD1zEFGbZnNoSyZ89pdnTiTwYNvLmPVn//ccB/RsyPvP343gb5eGkZWMp1OIaZVYbX49Ixcjp6ouTNN1TRGo5EOHTqwbt06xzq73c66devo2rVrmY9jt9tLfRDhDG53W7hlQAiqoqAqKoezznIjLbQOqdrRKQrDW3SkmX8dXvt7LTqLhf3nU7h7zUL+r1t/uoY00TpE4UQ/xicw6fufybNYAQj0MvHOPbfTrVljjSO7vJjrIjmw/RAAe/7YT7e+nTSOqOaqSLX3i/sdO3asSOO4tLvd5dG1a9ciX6zdunWjVatWzJs3j2nTphXZ1mKxcO+996KqKh988IHTYhA1l6Io6PV6bLaiU5idP3+e5ORkDh8+zIkTJzh69CgnT54kPz8fRVGwWq307duX2rVraxR51VAUhV712tPQO4h39n9PekEeJ9VzjN76AS/G3MuNodFahyicaFN8MpMW/khmbmHjxcvTg5fvv40eHVpqHNnltYluwObthdMz7o4/TuMGdTSOqOZyRs5xNSZOnMgDDzxAx44d6dy5M7NmzSInJ4eRI0cCcP/991O/fn3Hg4YZM2bQsWNHmjdvTkFBAT/++COffPJJpeYUbtdgjwz8p1J8TZ6LvSy6hTblvW4DeHHHjxzPzSBTzWXEr0uY1PZW7m/RqcrnwhTOZbXbeXvdRhZt2eFYF1U3hPcG3kmDwAANIyub1t1bsWLWSqCw8Jw02LXjjC/Pi93SrqS83dMu5eHhQfv27UlMLFpY82Jj/ciRI/zyyy/ydF04jcFgcDTYX3vtNfbs2UN6ejo2mw0vLy9SU1M5c+YMvXr1on379jRo0IDAwEB8fLSrjl3VogMbMqPdcN7c+y1JOWkUqGb+s+tTRjW/mVHNb0GnuF2nzxpFVVU++mkbs7/9g4s9yhuFBDLzkb40q1f9G7//LjzXp2dbDaOp2aq6wT5o0CBOnz7NlClTSElJoV27dqxevdrR0+/o0aNFelLl5OQwbtw4jh8/jpeXF5GRkXz66acMGjSoXDGXhds12Ot7B+BjMGK1FnA4S7rEX0lj31q833UAr/69hj9PH6VAtTNt18/sTU9haofb8dS73VukRjiXk8uTX/3IluRjjnX92rTi5dt7YPJwjf+nra+LdPw7Tsaxa6oqvzwv7Z7Wr1+/wmNc6J42fvz4Mh3DZrMRFxfH7bff7lh3sbF+8OBB1q9fT5061T+BFK7j4hN2vV5Po0aNWLVqFSaTiYEDB9KyZUvq1q3L1q1b2bp1Ky1btqRbt25ah6yJYJM/09oOYu7BNWw8vR+LQWXhoV84kHmKl9rci49BuylFRfnl5JuZsvgn1u/65ybpDW2aMXVkL/y8nNebqjJFhtfFaDRgNlv5O16mIdRSVTfYAcaPH19qjvHvYnLTp09n+vTp5TpPeblG5n4VFEUhMjCE3anHSMvLJsdcgI/RNT4stOJr9GRah9v56MBWPj/8F3q7yoqkv0nMPMPsbgOo6y1PoVxJ3MkUHvvyB05lFo77Nuh0TLrtBoZ2bOtSvSYCgwNoGFmfY/tPcHDHYfJy8vHykWROC6qqoJbzS7A8+11t97SpU6fSpUsXwsPDSU9P58033+TIkSOMHj0aKGysDxgwgJ07d/LDDz9gs9kc4+Fr166NsRrWcRCuxWAwOJ7ARERE0Lp1a0aPHk379u0d27Rs2ZIzZ87w4Ycf0q1bN8xmc41873nqjTwecTtNfUNYkvQ7OtXO72n7GLXlA95oP5xGPsFahyiuQlLKOZ6a+z3JKYW9WhUFHrmzK6N6x6LTuU7O4eGhJ6plGLv2HCMlLYO0M1mEBPlpHVaNVNU5hytwy/5HEQGh2C78/zqcLfOxl4Vep2N0ZFcmt78NX8WAjxV2nz3B3WsXsfPMsSsfQFQLK3bFM3TxF47GerCvNx/fN4Bhndq5VGP9opgLT9ltVhv7tx7UOBpRVQYNGsRbb73FlClTaNeuHbt27SrWPe3UqVOO7c+fP8+YMWNo1aoVt99+O5mZmWzatImoqMJpg06cOMF3333H8ePHadeuHWFhYY5l06ZNmlyjcC+XTu2Wl5fH0aNHizTWL/Lw8CAvL8/x75pKURT6NujE863vxl8x4VWgcCQrjQe3zGHT6QStwxNltH5XIve/9pmjse7r5cm74/ox5o4uLtVYv6hIt3iZ3k1UI27aYL9QKV6Bw1nSYL8aN4aF827Xewjz9MPHAudysxi24RM+P7RT69DEZZhtNl76cR2Tvv8Z84VxlO0bhLFi9DA6NqqvcXTl17r7P/Ox7/ldusVrpbzzoV5cymP8+PEcOXKEgoICtm7dSmxsrOO1DRs2FKmw/c477zi2TUlJYeXKlUUaS02aNEFV1RKXG2+8sby/FiEcdDqd4wl78+bNOXbsGKtXryYzM5Pc3FzS0tL47LPPWLhwIX369AFwyZuoztauVlNmtB1GI686eJkV8gryeWrnx/zv8AaZWqsas9ntzP72D56a+z05+YXTAofXq8Onzw/lupimGkdXfm2i/8mXdu+VBrtWtMg5qju36xIPFwrPKQp2RSUpUwrPXa3m/kHMvnYA0//6iV3nTpKv2pi840f2pqcyud1tGC95kiC0l5qVzRPLf+Cv4/88cRzSoQ2Tet7o8v+vYi5psMdt3KdhJDWbFuPJhHA1BoMBi8VCWFgYQ4cOZdKkSXTs2BG9Xk9ycjLZ2dmMGDGCYcOGaR1qtRLmXYvpbYcy+8Aq/jybiMWgMufgTxzIOsV/o/vjZah5wwaqs4ycfP67aBWb4pMd627r2JIX77sNL0/X7jXSOqI+Op2C3a7ytzTYNSM5R3Fu2WBv6V84/smmSJf48go0ejGjUx/m79/MV8m70asqSxO3czAjjfe69SfI5Kt1iALYfvQEE1b8wOnsXACMej0v3X4L/du5xzQ5oY2DCW5Qh9PHz7Jv8wGsFisGFyma505kPJkQV6bX67FYLAA8++yz3Hjjjfzwww9kZmZy11130bVrV6KiouTJegm8DUaeatWHr45tZdmRTehUlbWndnMk5zSvt7+Pel61tA5RAAeOn+bpud9z/EwGUDhN8BP3dGd4j2vc4n3t7W2kRbMQEhJTSTpyhozMPAL8q9+88e5Oco7i3DLz9TOaaOATQFpmOslZZ7GrKjo3+CCpah46PeOiriPcP4h39vyKzmpj++mj9FuzkLnX3kvr2mFah1hjqarK0u1/8+rPv2K12wEI8/fjvYF3ElOvbFNfuQJFUWjdPZL1n/1Bfm4BB3cm0Sq2hdZhCSFEMQZD0ZSqc+fOdO7cudh2Fxv1NXkMe0l0io4BjbrS2CeY9xJWoSswk5hxipGb3+eVtkPpWKe51iHWaKu37Wfq/9aQb7ECEOjrxWujb6dzZCONI3OuNlENSEgsnFY0bt8JrosN1zgiIdx0DDsUFp6zK5BrtZCam6l1OC7ttgaRvBPbj1CjDz4WSMvJZND6j/n2SJzWodVI+RYr//nuJ6auXu9orHdp0pCvRg91q8b6RTHXXTqOXbrFa+Fi97TyLkLUBPp/DUGyWCysXr2aN954gy+//BKAtLQ0Fi9ezOrVq4HCKQtFUZ3qhPNq26HUMwXiZVbIys/liR2LWHbkDxnXrgGLzcbbX/7KpIWrHI31qMahLJk01O0a61B8PnZR9STnKM6NG+zBUineiSJrhTKn2wBaB9bFxwp2s4Wntn7Lq7vWOBqNovKdSM9k6OJlfLP7n4brg107sHDYPdT28dYwssrTWsaxa+5i97TyLkLUBJc22K1WKx9++CFPPPEEf/zxB3PmzGHRokWEhIQQHBzMggULACk8V5oGPnWY0XYY7QObYDIrKBY77+z/gWl7llNgs2gdXo1xLjOXcbO+Ysm6fwoP9+0WzcKn7yWstntO+dsm6pLCc1IpXhOScxTnvg32wFBURUFVkMJzTlLb5MObnftye4MoTFYwWVUWJWxh1O+fkV6Qp3V4bm/T4SPcs2AJ8SlpAHh5GHjnntt5rsf1GHRu+6dM46gG+NUurJmwZ+N+eSKlAbUCd7rd9ctTiH9TFMXRaLfb7Xz55Ze8+OKLfPvtt4wdO5bPP/8ci8XC9ddfz9GjR8nKypIG+2X4eJh4Lvpu+jXohNGi4GmGH0/sZOy2D0nLz9A6PLe3JymFYTOWsONgYaPVoNcxaejNvHjfrXi6cS2ZWoE+NGpQG4CEQ6nkXaiCL6qO5BzFuW2WHxkQAoBdpnZzKqPewMSYG3ki+nq87Dq8rbAp5TB3r11IQnqa1uG5JVVVmb9pG6OWfk16Xj4AjWoF8MWDQ7g9OkLj6CqfTqej9YX52LPOZXN03wmNIxJCiJLp9XpUVcVoNJKfn094eOH41969e5OXl0diYiKenp7Url2b5ORkAOnmfRl6RcewptfzZOQdeOOByQz70o8zYvP77D5/ROvw3NY3f+xh1NtfkHo+G4CgAB/mPzWQAde3rRE3mdpe6BZvs9nZm3DqClsLUfnctsHe2Lc2nnoDdgWSpMHudH0at+aN2L4EGbzwscCJrPMM/OUjVh+XLsvOlGM2M2HFSt5atxH7haTuhvCmrBg9lJYhQRpHV3UuHcceJ+PYq5wKqGo5F62DF6IKGQwGRy+gm2++mfXr15OYmIifnx8NGjTg77//5pNPPiEkJISAgABAusWXRbfgSKa3GUKohz9eBQrp+dmM2zafb479qXVobsVssTJ9yVqmfrIGi9UGQLvm9VgyaShtm9XTOLqq0yZaxrFrSXKO4ty2wW7Q6WjhXziO/URuBvlWGfPkbG1q1+P9awcQ4R+MjxXMBWbGb1rBzLj1jsalKL+ks+e5d+FnrN530LFu/PVdmDv4LvxNJg0jq3qXjmPfI+PYq5wdpUKLEDWFXq9Hd2GI0tNPP82hQ4cYO3YsTz31FHv37uXFF19k4cKFDBs2jEaNGsnT9avQxDeE19oNp7V/Q0wFClhsvLb3a97Y+w0Wu1Xr8Fxe2vlsxsxczle//1NQeNCN7Zj35ACCA2rWVL5SeE5bknMU57YNdijsFm9TwK6qHMmWceyVIdTLj3di+9GjXku8rOBpVZmz7w8e3vgFWeZ8rcNzWb8cOMSAhUtJPFP4vvX1NPLBoL48dkPXGjlFYYtrmmLy9gTkCbsWpACMEGVjMBgcjfBdu3bx66+/4uvry7lz57j//vv54IMP+O2337jzzjux2+3ydP0q+Ru9+W/r/txerz1Gi4LRDF8d3cpj2xdytiBL6/Bc1o6Dxxn66hLikgq7f3t66Jk6oifPDb4JD4P+Cnu7n7oh/gQH+QEQv/8U1gu9DUTVkJyjOPetGgG0DAjBfrFSfNY5IgJDtQ3ITXkaPHiuzS2E+wXzYcIm9BaVDScP0H/dR8y99l6a+dfROkSXYVdV3v91M7N/3+pYFx5Um/fv7UvTOrU0jExbBg8DkV1asOuXPZw+dpbUI6cJbRysdVhCCFGETqdzjGO/9tprWbt2LSEhIXh4eDievAPk5OTg4+OjYaSuy6DTM7L5zTT1DeHDxLXozFb+PpfMyC2zeb3dcFoFNLjyQQRQWD/h8/W7eGf5b44Zf8Jq+/PWI3fSqlHNzZkVRaFtVAPW/raP/AILBw6nEdUyTOuwRA3m3k/YA0NAUWQcexVQFIUBzdoyo9Od1DKY8LFAcuYZ7lm3iPUnD175AILM/Hwe+fzbIo31nq1asOzBITW6sX6RjGPXjsyJKkTZXawU7+npSb169Th//ryjsX78+HGeeeYZnnnmGf744w+sVunKXV43hrbm5ZhBBBn8MBUonMnN4JE/57Hq5F9ah+YS8swWXli8mje/2OBorMdGNuLTSUNrdGP9IpneTTuScxTn1g32iEsqxUuDvWp0CGrI+13709y3Dj4WyC/I56GNy5izd6OM1buMA2ln6L9gKb8mJgGgUxSevuU63u1/B76eRo2jqx6KjGOXBnuVKnfxlwuLEDWJwfBP58Vly5bx3nvvcfr0aQBef/11UlJS8PDwYPr06Wzfvh1Apqsspxb+YbzWfjiRfvUwFSjYzFZejvuCd/evxGqXbsylOXEmgwffXMaPW/c71o3o2ZH3H7+bWr5eGkZWfUjhOe1IzlGcWzfY65h8CDb5YrswtZs0GKtGPZ8AZnW5m+tDm+NlAQ+rysw9G3hs81fkWGQ+y3/7MT6Bexd9xtHzhfPKBnqZWDj0bsZ06yTjGy/RqksL9BfG0sVJ4bkqJePJhCg7vV6PzVbYWDxw4AAeHh7Url2b3Nxc0tPT6dmzJ++++y4RERH88ssvgDTYK6KW0YcpMQPpUTemcFy7BT5L3siTOxeTYc7ROrxqZ/PeIwx7dQkJxwpvInl5evDGmDt4/O7u6HVu3Sy4Kk0aBuHnW1jgN27vCex2aUNUFck5inP7v8yIgBDsOsgw53OuIFfrcGoMbw8jL7S/jZEtYzHZwMuisvrYXu79ZTHHss9rHV61YLXbeX3Nbzz51Y/kWQq7RUbVDWHF6KF0a9ZY4+iqHy8fEy2uaQrA0X0nSD+doXFEQghR3KVP2ENCQjh69Ch6vZ7U1FT8/PwIDAwEIDw8nH37Cm8+ys3ZijHqDDzc4jbGhPfA06bDZIZtZxIZuWU2iVkpWodXLaiqyqLVfzL+va/IzC0AoFFIIJ88N4QeHVpqHF31o9MpxFzoFp+RlceR49JTV2inRjTYbY7Cc/LHVpUURWFYeAemdridAL0RHwscTE/l7rWL2JSapHV4mjqXk8uoJV+xaMsOx7p+bVrx2YhBNAgM0DCy6q31dZdO77b/MlsKZ5K73UKUnV6vdzTAr7nmGo4ePcrBgwc5ceIEcXFxxMTEoKoqderUoV69eo59RMXdFtaWF2PupZbeB68ChZSc84zZ+gG/pOzROjRN5eSbeebDH3j/mz8cXYavb9OMT54fSrN6Uhi4NG0vnd5NxrFXGck5inP7BntkYAiqooCMY9dM19AmvNe1P429A/GxQHZ+LiN+W8qihK01cphC3MkU+i9cypbkYwAYdDqm9LqJ1/r2xOTh1hM3VFiMjGPXhBSAEaLsFEVxPGVv27Yt7du354knnuC1114jPDycBg0aoCgK4eHhjBgxQttg3VCrgAa81m4YzX1CMRUomM1mJv29hLkHf8au1ryhB8kp57jvtc/45a9EABQFxvbpysxH+uLn5alxdNXbpfOx/y3j2KuM5BzFuX3r4GLhuYvj2IU2GvnW4v2u/Zmxey1b0o5QoNp59e817E1PYXqH2zEZPLQOsUqs2BXPSz+uw3xhfGOwrzez+t9Jx0b1r7CnAGh9XaTj33HyhL3KVKSQSw28JycEBoMBs9mMl5cX06ZNY8GCBdjtdgYPHux4mt6pUyeNo3RfQSZ/prYZxIcH1/Db6X1YDSqLD6/nYNYpXo4ZhK+HSesQq8SGXYd4YfFqcvIL6wf5enny6oO9uS6mqcaRuYaWzUPxNBooMFvlCXsVkpyjOLdvsDf3D0KvKNgVlaSsc1qHU6P5GD2Z2uF2Pj6wlSWHdqK3q3yTvJtDmWeYfe0A6nm7b1dws83Gqz9t4LMdux3r2jcI490BdxLq56thZK7Fv44fTaIbkhx/jMS/ksjLzsNLKtpWusIvz/LdtXbXL08hLufSLu4mk4nx48cD8Ntvv/H111/j4eFBy5YtiYiIIDg4WKsw3Zqn3oPxEb1p6hvKJ0m/orPb+SNtP6O2zuGN9vfR2Md9f+82u515P2xhwY//TBMbXq8Obz3Sl0YhgdoF5mI8PPRER9Zj5+6jpJ3JIiUtg7oh7purVheScxTn9g12T72BZn5BJJ9P42j2OSx2Gx46GSumFZ2iMDKiC838g3krbh06q5U9505y95pFzO7Wn47BjbQO0elSs7J5YvkP/HX8lGPdkA5tmNTzRowybvGqtb4ukuT4Y9htdvZuPkCHW9tqHZIQQhTx7zHpqampvP766+zatQuAnJwcateuTbNmzZgwYQItWrTAbrc75msXzqEoCnc26EAjnyDe2f89SkEBR9XTPLhlNi/HDOK6kFZXPoiLyczJ57+LVvFHfLJj3W0dWzJl+K14m2Sa2KvVJqoBO3cfBQrHsUuDXWihRnwzRAQEY1fAYrdzPCdd63AEcENYc97t0p/6Jn98LJCel819v37KZ4d2XHlnF7L96An6L1jiaKwb9Xpe7XMbL91+izTWy+nScexxMo69SkgBGCGuzqWV4gFWrFjB9u3bmTp1KnfeeSctW7Zk1apVeHl58eabbwLUyJouVaVNrca81m44jb2C8DIr5BcU8Mxfn/DRofVu9Xs/cPw0w2csdTTWdYrCk/2vZ8ao26WxXk5to2Uce1WTnKO4mtFgDwzFfrFSfKaMY68umvnX4f1u/elQuz7eFsBi44Udq5i8faVjjLerUlWVJdt28cAnyzmdXTidYJi/H0tH3Ev/dtEaR+faWneXSvFVTa3gIkRNc+kT9tOnT7NmzRoeffRRrrvuOm644QYOHToEwJgxY9i+fXuxfYTzhXoFMr3tELrWaYGnWcFgUZmX+DP//XspudYCrcOrsJ+2JTDijc85fqZwytNAXy/mPHEP993aQaYNrICoiDD0+sLm0u69JzSOpmaQnKO4GtFgjwworBSvSuG5aifA6MWrnfowoGlbTFYwWVU+P7ST+379hNN52VqHVy75FivPf/czU1evx2ovrEjbpUlDvho9lJh6dTWOzvWFNAwitHHh2MN9Ww5gMVs0jsj9yd1uIa7exafsderU4ciRI3Tp0gWAevXqkZeXh9lsxmaz4e/vz/nz57UMtcbwMhh5MrIPgxtfi9Gqw9MMv6TsYczWuZzIdc06R1abnZnLf+X5hT+Sb7YCENU4lCWThtI50v2GGVY1L5ORls1DAThy7CzpmbkaR+T+JOcorkY02CMC/6kUn5ztmh/I7syg0/FIq2t5rs3NeKt6vK2w8/Qx+q1dyO5zJ7UO76qcSM9k6OJlfL17r2Pdg107sHDYPdT28dYwMvfSunthtXhzvoWDOw5rHI0QQhSn1+sd49L9/f1JTCycVis4OBg/Pz+2bt3KokWLuP766zGZakbV8upAURT6N+rCc1F34ad44lWgcDgzhZFb3ufPs4lah3dVzmXmMu7dFXy6dqdjXd9u0Sx8+l7CavtrGJl7aRP1z0w+cfKUXWigRjTYw7z88fcwYVfgcOYZrcMRpbi1QSSzuvSjrtEHHwucyclk8C8f83Xy7ivvXA1sOnyEexYsIT4lDQAvDwPv3HM7z/W4HoMUEnKqmOsuHccu3eIrnfRPE+Kq6fV6x/jo7t2788MPP3DkyBEMBgPR0dGMHj2agwcPMnDgQLy8ZLaLqtahTnNeaTOUBl618TIr5OTnMWH7Ij5L3ugS49rjk1MYNmMJ2w8Ujqs26HU8P+RmXrzvVjw93L6mdJUqMh+7TO9W+STnKKZGtCIURSEiIBibAqfzc8g052sdkihFRGAoc64dQJvAMLytoFqsPPPnd0z/62dH9/LqRlVV5m/axqilX5OeV/jealQrgGUjh3B7dITG0bmnouPYpfBcpatI1zQ37Z4mxJUYDAbH2OEBAwbQvHlzsrMLh3qNGjWKN998ky+//JKYmBgtw6zRGvjU4ZU2Q+lQqymeZgW9VeXdhJVM3fMl+bbqO9zqmz/28OBbX5B6vvD9FBTgw/yJAxl4Q1sZr14JLm2w75bCc5VPco5iakSDHS4UnrtwtUkyjr1aq+Xpw+ud+9KnYbRjXPviA1sZ+dtSzhVUr7FDOWYzE1as5K11G7FfuCN/Q3hTVoweSkRokMbRua9GkfUJCPIDCgvP2avpzRx3UTgnavkXIWoivV7vmKatbdu2jB8/nujowqKjHTp0oG/fvhiNRvn80piPhyfPRvXjnoaxeFgUPM2w6sRfPPLnPFLz0rUOrwizxcorS9Yy9ZM1WKyFxXnbNa/HkklDadu8nsbRua8Afy+aNKwDwMFDqeTmmTWOyL1JzlFcjWmwRwaEYAdQpMHuCox6PU+0voEnW9+At6rD2wpbUpO4Z+1C9qWnah0eAMlnz3Pvws9Yve+gY92j3WOZO/gu/GU8YqVSFIXW1xWOY89OzyF5zzGNIxJCiKJ0Ol2p86pf+hRU5l7Xnk7RMaTJdUyMvBMfjJjMkJB+ghFbZrPrfJLW4QGQdj6bMTOXs+L3OMe6QTe2Y96TAwgO8NUwspqhzYXp3Wx2lfj9rlVfSbi+GvMtEREYAopSOI49SwrPuYo7GkXzZuxdBHl44WOBk1np3LtuMSuP7b3yzpXolwOH6L9wKYlnCt9Lvp5GPhjUl8dv7IZOuqNVidbXyXzsVUUqtgpRPjJVm2vpGhzB9LZDqGsMwMuskJGXzaPbFvDVsa2axrXz4HGGzVhCXNIpADw99Lz8wG08N/gmPAzyHqsK0i2+6kjOUVyNabC39P+nUrxM7eZaWtcKY063gUQGhOBjBavZzBObv+Kt3b9gq+KuhHZV5f82bGLssu/ILijsEhUeVJvlo4Zyc8vmVRpLTRcj49irzsVxYeVdhKihSmqwq6parKiZKxQ5qyka+wTzWtthxPg3xGRWUCx23tj7Da/Ff43Fbq3SWFRV5bNf/uKRd1Zw9sJ0YmG1/Vn0zCD6dI2u0lhqurbR0mCvMpJzFFNjykj6eBhp6BNIauZ5krPOYldVeRLqQoK9fHknth+z4n/l5+MJ6FSVufv+YH9GGjNj++FvLFsX9OzsbBITEykoKMDT05Pw8HB8fcvWlSwzP59nvlnNhoP/dI/r2aoFr/a5DV9PY7muS5RfePummHw8yc8pIO73faiqKsV2KklFxoVJO0TUZBfnYr/o359T6enpeHt7YzQa5TOsGvEzejOpdX+WJP/ODyd2oLOrfHPsTw5lp/Jau2HU8fQr03EqknPkmS28umQdK7f+c0M6NrIRr46+nVq+MqtAVQsN9ic02J/U05nEJ5zCYrHh4SG9GyqD5BzF1ZgGO0BkYCgns86Tb7VyMjeDBj6BWockroJRb+CZmJsJ9wtm3v4/0Ksqv548SP91i/jg2nsJ9y+5yNvevXuZO3cua9asISEhociTDEVRiIiI4NZbb+WRRx4hKiqqxGMcSDvD+C+/58i5dAB0isLEm69ldNeOkmBpRG/QE9Utgp1rdnP25HlSktIIaxaqdVhCCOHw7yfsiqKQmZnJxx9/TFxcHHa7nUaNGtGqVSsGDhyoUZSiJAadngea3UgTn2DmJa5BZ7ay5/wRRmx+n9fbDycqoGGJ+zkj5zhxJoOn531PwrHTjnUjenbk0buuRS81DzTTNroBP2/Yi9lsJeFQCq0j6195JyGcoEb91UcEhGC/0LZKknHsLklRFO5p2obXOvWhtsGEjwWOZJyl/9pFrDt5oMi2SUlJ9O7dm+joaJYtW8ZNN93EwoUL2bJlC7t372bLli0sXLiQm266iWXLlhEdHU3v3r1JSipaYObH+ATuXfSZo7Ee6GViwdC7GdOtkzTWNRYj49irhsyJKkS5/LvBfu7cOZ544glWrlyJzWZj27ZtmEwmFi5cyNy5czWKUlzODaHRTGszmGAPP0wFCmfzMnnkzw9ZeWJHke2clXNs3nuE4TOWOhrrXp4evDHmDh6/u7s01jVWZBy7zMdeeTTIOWbPnk2TJk0wmUzExsby559/lrrt/Pnz6d69O7Vq1aJWrVr06NHjsts7Q436y48MDEFVFFSpFO/y2gc14P2u/Qn3C8LHCgXmAh7e+AXvx/+OXVVZsGABMTEx7Nu3jyVLlnDs2DHmzJnDyJEjiY2NJSYmhtjYWEaOHMmcOXM4duwYS5YsYe/evcTExLBgwQKsdjuvr/2NJ7/6kTxL4bi1qLohrBg9lGubNdb4NyCg6Dh2abBXHikAI0T5KIpSpNG+YcMGjh49yrvvvsuUKVPQ6/U8++yzTJ8+ncWLF5ORkaFhtKI0zf3qMqPdcFr51cdUoGA3W5m2Zznv7Pseq93mlJxDVVU+Wv0nj733NRk5+QA0Cgnkf88NpkeHlhr/BgT8UykeYPfeExpG4t6qOudYtmwZEydO5MUXX2Tnzp20bduWnj17kpaWVuL2GzZsYMiQIaxfv57NmzfTsGFDbrvtNk6cqLz3RM1qsAcUdpe1K5CUKQ12VxfmE8CsLv24sW44XhbwtKrMiv+Vrg8PZcyYMQwZMoS4uDiGDh2K0Xj5MeZGo5GhQ4eyZ88ehgwZwpgxY+g0aBiLNv9zB71fm1Z8NmIQDQIDKvvSRBlFxoZjuDCGTArPVTJ5ui5Euej1eke36K+++or+/fsTERFBvXr18PLyYufOnXTs2BEfHx/27Sv8HJMidNVPLaMPU2IGcFtYW4wWBaMFlh3ZxLWP9ndKznF9v/t575s/sF/4f399m2Z88vxQmtcrebifqHqNG9QmwL+wfkDcvhPY7fJ3WmkqmHNkZmYWWQoKCko91cyZMxkzZgwjR44kKiqKuXPn4u3tzaJFi0rcfsmSJYwbN4527doRGRnJggULsNvtrFu3zgkXXrIa1WBv6BOISW8orBSfLQ12d+BlMPLfdrcyOqILnjbI+3k7f87/nGnTpjF//nz8/MpWGOYiPz8/5s+fz9SpU9m1/HMydmzBoNPxQq+beK1vT0weNarsQ7Xn6eVJy46F1fmPHzjF+dR0bQMSQoh/MRgM2C/MaGKz2RyNOQ8PDxo0aMDRo0c5f/48Xl5e5ObmahmquAIPnYEx4T14OPxWTDY953/4mz/nfuuUnGPjd59ydv8WFAUe6dOVmY/0xc/Ls5KuRJSHoii0iSoct56VnU/S0TMaRyRK07BhQwICAhzLjBkzStzObDazY8cOevTo4Vin0+no0aMHmzdvLtO5cnNzsVgs1K5d2ymxl6RGNdj1Oh0tL4xjP5mTQa7FrHVIwgkURWFw82t4rG47Ti9ZzahRo5g8eXKRbeLj4xk4cCDNmjXD29uboKAgrr/+er7//vsSjzl58mRGjRrF2dXf8eoNnRneqZ2MV6+mLp2Pfc/G/RpG4r6kS7wQ5XfpE/Z27dqxd+9erNbCYVYtW7bk888LbzI3a9aMbt26Acj3TTXXI6wNYwK7kbToF6fmHKc2f8ezfa/hoTu6oNPJe6A6kvnYK58zco5jx46RkZHhWJ5//vkSz3XmzBlsNhuhoUWLFoeGhpKSklKmeJ977jnq1atXpNHvbDWqwQ6FhedsSmGviSPZ57UORzjRktffJSy0Lu+8806x144cOUJWVhYPPPAA7777Li+88AIAffv25cMPPyy2vaIozJw5k3qhIcx9ZWqlxy7KT8axVwEpOidEuRkMBnQXioXddNNNHDt2jGXLlgEQGxtLQkIC2dnZjBkzBpOpbFOUCu3NmzaTeiHOzTnC6oaw+P9eq/TYRfkVGccuhecqhxNyDn9//yKLp2fl9FZ57bXX+Pzzz/n6668r9fO7xvXvjby0Unz2WVrVkmmg3EFCQgLr1q1jyZIlJXZJu/3227n99tuLrBs/fjwdOnRg5syZPPTQQ8X28ff3Z8aMGQwbNox9+/bRqlWrYtsI7UVfG4GiKKiqKuPYK41yYSnvvkLUXDqdzvGUvW3btjzxxBPUqVMHKGzAf/311zRp0gQoPk+7qJ4k56i5WjQLxcvkQV6+hd17j8vfbKWoupwjKCgIvV5PampqkfWpqanUrVv3svu+9dZbvPbaa6xdu5Y2bdpcdaRXo+Y9YQ8MAUXBrsBhKTznNhYvXkxISAgDBgwo8z56vZ6GDRuSnp5e6jb9+/cnJCSEDz74wAlRisrgV8uXJq0L58M9tCuZnEwZA+p08oRdiAq5WCne09OT6667ztEYS05OZufOncyfP5/vvvsOm82mZZiijCTnqLkMeh3REfUAOH02m1OpMrOD01VhzmE0GunQoUORgnEXC8h17dq11P3eeOMNpk2bxurVq+nYsePVnbQcatwT9oiAEKCwUvxhmdrNbWzYsIH+/ftfsTJrTk4OeXl5ZGRk8N1337Fq1SoGDRpU6vaenp7079+ftWvXOjtk4UStr2tFUtxR7HaVvZsS6NSrvdYhCSGEg8FgcIxbB9i8eTPTpk3j0KFD1KlTh4CAAPLy8li/fj1PPPEETZo0wW63O7rSi+pFco6arU10A7b/fQSAv+OPU69uoLYBiQqZOHEiDzzwAB07dqRz587MmjWLnJwcRo4cCcD9999P/fr1HYXrXn/9daZMmcLSpUtp0qSJY6y7r68vvr6+lRJjjfsmqOXpTaiXHzZdYZd4mTrF9WVlZZGYmEinTp2uuO1TTz1FcHAw4eHhPP3009x99928//77l92nY8eO7N+/n+zsbGeFLJxMxrFXMnnCLkSFXDoX+/Hjx3nvvfdo3Lgxq1atYtOmTaxatYoXX3yR5ORkvvzyS4AiDXxRfUjOIaTwXCWr4pxj0KBBvPXWW0yZMoV27dqxa9cuVq9e7ShEd/ToUU6dOuXY/oMPPsBsNjNgwADCwsIcy1tvvVXuS76SGveEHQqfsm/KySTLXMDp/BxCvCrnboioGsnJyaiqSlRU1BW3nTBhAgMGDODkyZN88cUX2Gw2zObLzxYQHR2NqqokJibSrl07J0UtnCmme6Tj31IpvhKoSuFS3n2FqOEuTu2m0+nYuXMnp0+fZvr06TRr1gyr1Yper+emm27iyJEj/PzzzwCOp7cyRrZ6kZxDREWEYTDosFrt0mCvDBrkHOPHj2f8+PElvrZhw4YiPycnJ5frHBVR456wQ2HhOduF/5/J0i3e5V388vP29r7itpGRkfTo0YP777+fH374gezsbPr06XPZnhZeXl4AFBQUOCdg4XRB9etQt2nhcJf9fyZiLrBoHJF7UdWKLULUdJc+YQ8KCiI3N5dmzZoBhY35iw3yY8eOcddddzn+vWXLFmmsVzOScwiTpwcRzQufvh47cZ5z53M0jsi9SM5RXI1ssEcEhqAqCsg4drdw8SlEbu7VFxsbMGAA27Zt48CBA6Vuk5eXB1BpU0II54i5vrBbvKXAwoFtiRpHI4QQ/1AUBYOhsFNj+/btufnmm3njjTewWCycO3eOHTt28Pbbb/Pdd9+xbt06hg8fzoQJE3j55Zela3Q1IzmHAGgT3dDx79375Cm7qFw1tks8gE2BJGmwu7ymTZuiKAp79+4lNjb2qva9+MWYkVF6lc/4+HgURSE8PLxCcYrKFXNdK9Z8/CsAcb/vp/V1MiWO01RkLLqb3u0W4moZDAbMZjNeXl4EBgayZMkSli1bRmBgIB4eHmRmZtK8eXP8/f1p2rQpdevWJTAwUJ6wVzOScwiAttEN+OyrPwHYHX+CG7tFaByRG5Gco5ga2WBv5heEQdFhV2zyhN0N+Pr6Eh4ezrZt2xwVHf8tLS2NkJCQIussFgv/+9//8PLyuuxYtO3btxMZGVlplR+FcxQpPLdxH0O4W8No3IyMYReiwvR6vWMcu91up02bNjRo0ICwsDDq169P/fr1qV27NrVr16ZWrVpahytKITmHAIhpVR9FKeyCLePYnUxyjmJqZIPdqNfT3D+Iw+dSOZadjtlmw3jJ+DLhem688UZWrFjBrFmzSpxm5eGHHyYzM5Prr7+e+vXrk5KSwpIlS9i/fz9vv/12qV+MBQUFrFix4rLTsIjqoX6LMAJDAkhPyyD+j/3YbLYi40ZF+Slq4VLefYUQOLrEAwwfPhybzUZISEipU4OpqoqqqjK1WzUkOYfw8zXRtFEQh4+cITEpjZzcAny8ZRiDM0jOUVyN/RaICAjBroBVtXM857zW4YgKGjFiBGlpaSxfvrzE1wcNGoROp+ODDz5g7NixzJw5kwYNGvDtt98yceLEUo+7YsUK0tLSGDt2bGWFLpxEURRHtfjczDyS4o5qHJEQQvxDr9c7Gt9hYWE0aNAAo9HIxo0bmTFjBmPHjuWhhx7ik08+cVSGl8Z69SQ5h4DC+dgB7HaV+P0nNY5GuLMa+00QGfhPpXjpFu/6IiIiuOWWW5g0aRJZWVnFXh88eDBr1qwhJSXFUeRnzZo19O3bt9RjZmZm8vzzz9OrVy9atZLx0K7g0nHre36X6d2cRuZhF6LC9Ho9VquVzMxMAM6fP8+IESMYNWoUGzduxGg04u/vz/z58/nPf/6jcbTiciTnEABtL5mP/W/pFu88knMUU2Mb7BEBIaAoqAoczjqndTjCCd544w3OnDnDk08+WeFjqarKU089xdmzZ5kzZ44TohNV4d/j2IWTXBxPVt5FCIGqqqxcuZIdO3YA8Mknn3Dy5Em++eYbVq5cybvvvstbb73F9OnT+emnnzh16pTGEYvLkZxDXHzCDrA7XhrsTiM5RzE1u8FOYaX4w1lnNI5GOEPjxo2ZPn06CxcuZPr06eU+jqqqTJ8+nQULFvDuu+/StGlTJ0YpKlOzto3x9iucw3bP7/suO9etuApyt1uIClMUhXnz5nHmTGHO8fPPP3PvvffSqlUrbDYbeXl52O12rr/+eho3bkxycjKAfI5VU5JziOA6foSFBgCw78ApzBarxhG5Cck5iqmxDfZQLz8CjV7YFUjKlC7x7uK+++5j0qRJvPDCC4wePbrErmqXk5mZyUMPPcSUKVN45ZVXGDVqVCVFKiqDXq8nqltLAM6lpHPyUIrGEQkhxD+8vLwcXeJr167tmMtbr9fj5eWFTqdj5cqVtGnThsaNG2sZqigDyTlEmwvd4s0WGwkHJecQlaPGNtgVRSEioHAc+9mCXNLNeVqHJJzkySefZOYr3fj8s49p3boVS5cuxWw2X3afgoICli5dSkxMDJ999hkLFixg0qRJVRSxcKZLx7HH/Sbd4p1Cg7vds2fPpkmTJphMJmJjY/nzzz9L3Xbx4sUoilJkMZlMRS9BVZkyZQphYWF4eXnRo0cPDh48WL7ghCin7t27s27dOtLS0njzzTc5f/48b7/9NocPH2bNmjW8/vrrvP7663zxxRfMnTsXALvdrnHU4nImTpzIXV0G8L/Fn9AqUnKOmqbtJd3i/5Zu8c4hT9iLqZHTul0UGRjCtrRkAJKyztK+ToPL7yBcQ/5PDL8nn943NGLClEyGDRvGk08+Sf/+/enYsSPR0dF4eXmRl5dHfHw827dvd1Rm7dWrF3PmzJEuaS7s3+PYez14s4bRuImKfAmWY79ly5YxceJE5s6dS2xsLLNmzaJnz54kJCQUm9v4In9/fxISEhw/K0rRcWxvvPEG//d//8fHH39M06ZNeeGFF+jZsyd79+4t1rgXorIMGjSI3bt3M3DgQKKiojh48CCnTp3iww8/JCgoiFq1ahETE8Odd95JZGThrBcyPWX19vev8dgOGumi70HiuTjJOWqYNv8qPDdcw1jcRhXnHK6gRjfYWwaEYAdQICnznDTY3YBqO4+aMx9Po4WWzfWs+vEr9h2qw9y5c1m7di1z584tMh5QURQiIyMZNGgQY8eOlcqsbiCyczgeRgMWs5U9v8sTdqeoSCGXC/td7AZ8kaenJ56eJc9ZO3PmTMaMGcPIkSMBmDt3LitXrmTRokWlVs9WFIW6deuWHIKqMmvWLCZPnsxdd90FwP/+9z9CQ0P55ptvGDx4cLkuTYir1bp1a1577TU+/PBDzp8/zy233EJISAj16tWjfv361KlTB19fX4xGI15eXlqHK64gPyefT17+ErvFjqfFm48//oT6HYIl56hBGtavRa0Ab85n5LJn3wlsNjt6fY3twOwcTsg53E2NbrBHXqgUb1dUKTznJtSceShk4m0qAFMfFM/uREXB//3f/wGQnZ1NYmIiBQUFeHp6Eh4ejq+vr8ZRC2cymoy07NSc+D8SOHkolbOnzlMnrJbWYdV4DRs2LPLziy++yEsvvVRsO7PZzI4dO3j++ecd63Q6HT169GDz5s2lHj87O5vGjRtjt9u55pprePXVV4mOjgYgKSmJlJQUevTo4dg+ICCA2NhYNm/eLA12UaXq16/P5MmTsdlsFBQUYDKZ0Ol05ObmkpGRgaIo0lh3EV+/t4ozJ85hybHS/pYYegy/HkVRJOeoQRRFISaqPr9tPkhOrpnDR07Tolmo1mEJN1OjG+wtAoJRKKwUnyRzsbs81bwNCn7Bxzsfnd4fxa/4eDBfX1/atWtX9cGJKhXTPYr4Pwq7R+/5fR833NtN44hcm6IWLuXdF+DYsWP4+/s71pf2dP3MmTPYbDZCQ4smPKGhoezfv7/EfSIiIli0aBFt2rQhIyODt956i27duhEfH0+DBg1ISUlxHOPfx7z4mhBVxWAwkJ+fj16vx9vbG4BNmzbx5ZdfcvbsWdLS0ggMDOSxxx7j2muv1ThaUZqkPUdZ8/EGLLlWPIwePPHBmGJDcSTnqBnaRjfkt82FNVF27z0hDfYKckbO4W5qdJ8Nb4ORxr61sSuQnH0OmxR2cVmqPQ81+z08DFY8jVYUv/+g6OtoHZbQSJFx7NItvuKcUADG39+/yFJag708unbtyv3330+7du244YYb+OqrrwgODmbevHlOO4cQzqLX69Hr9Y5icitWrODhhx/mzJkzpKamUr9+fe655x5mzpzJ119/DYDNZtMyZPEvNquNj6d8js1ix5Zv574pA6kfHqZ1WEIjMh+7k0nRuWJqdIMdICKwsFJ8gc3GqbwMrcMR5aTmfQr2FHy88sEYC173aB2S0FB0t5aOJx1xG6XB7kqCgoLQ6/WkpqYWWZ+amlrqGPV/8/DwoH379iQmJgI49qvIMYVwlotF5HQ6HampqXz//fcMHTqUTz75hPvuuw+9Xs+9997LLbfcwtKlSzWOVpRkzSe/khx/HHO2laYxjRjwVB+tQxIaCm8SjLeXESgsPHdp3QIhnEEa7AEh2C/0YDqUeU7bYES5qJZEyP0Kb88C9HoPFP+pxbqliZrFJ8CHZm0L5zBO2n2U7PQcjSNybQr/dFG76uUqz2U0GunQoQPr1q1zrLPb7axbt46uXbuW6Rg2m424uDjCwgqfeDVt2pS6desWOWZmZiZbt24t8zGFcJZLq75nZ2dz7Ngxhg0bBkCDBg2Ij48HIDY2lpMnTxbbR2jr9PGzfP3uj1jzbWCHCfMexuBRo0eY1nh6vY7WkfUAOHc+hxOn0rUNyMVVZc7hKmp8gz0yIARVUVAVSJLCcy5HVW2o2e+g11sweZpRfMehGGR6FAExF+ZjV1WV+E0JV9haVCcTJ05k/vz5fPzxx+zbt4+xY8eSk5PjqBp///33FylKN3XqVH7++WcOHz7Mzp07GT58OEeOHGH06NFAYVGgCRMmMH36dL777jvi4uK4//77qVevHv369dPiEkUNpiiKowHesGFDUlNT8fDwAKBly5bk5eUBsHv3blq2bEl+fr5msYqiVFXlk6lfkp9TgDXXRt9xPYnq0lLrsEQ1UKRb/F7pFi+cq8bfEowILJzT167AYSk853ryvgPrQXx981A8wsFntNYRiWqidfdWfPP+KqCw8Fzs7ddoHJELq+IpVgYNGsTp06eZMmUKKSkptGvXjtWrVzuKxh09ehSd7p/7zefPn2fMmDGkpKRQq1YtOnTowKZNm4iKinJs8+yzz5KTk8NDDz1Eeno61113HatXr5Y52IUmDAYDVqsVo9FIw4YN2bp1K3369CE4OBiTycTQoUOJj4/n9ddfl/doNfLnqp3s/nUvlhwrQfVrM/KVIVqHJKqJS+dj3x1/nNt7xGgYjYuTad2KqfEN9oY+tfA2eGCzmknKki7xrkS1paLmLsbkacZgsKP4T0NRjFqHJaqJmO6Rjn/LOPYKqkghl3LuN378eMaPH1/iaxs2bCjy8zvvvMM777xz2eMpisLUqVOZOnVq+QISwokuFp3T6/Xccccd/Prrr7Rp04ZmzZrRp08fDh8+zJw5c6RKfDWSk5HDkulfYTPbsVtUxr83Ch9/b63DEtVEq5ZheBj0WKw2/pYn7BWjQc5R3dX4BrtOUWgZEEJ8wXFO5WaSYzHj4yGNvupOVVXU7PfRKbmFc657DUExdtA6LFGN1K5bi3rhdTmZmMKBbYcw55sxmuRvu1zky1MIp7pYKR5g2LBhpKamEhgYCMCDDz6IqqpSELGa+eKt78g8k4Ulx8q1d3fm2n6dtQ5JVCOeRgORLeoSt+8EJ06lc/Z8NnVq+WodlmuSnKOYGj+GHQoLz9ku9KBIzpan7C7B/DuYt+LjlY+iD0bxe0rriEQ1dHEcu8VsZf+fiRpHI4QQhQyGf56X1KpVi8jISGrXrg1AaGioNNarmf3bEvn1i81Ycq14+3ox/v8e1DokUQ0V7RZ/QsNIhLuRBjtFK8VL4bnqT7Vno2bPwehhxehhRfF/AUXnr3VYohpqLfOxO0W5q7VeWIQQRel0OpnNxEWYzRY+nvI5dquKrcDOg68OJah+Ha3DEtWQFJ5zDsk5iqvxXeIBIgNDQFGwKyqHM6XwXHWn5ixCUc8WzrnueTN49tQ6JFFNFRnHLg328pPuaUI4ncFgwGKxaB2GuIIfP1zLqcNpWLKttOrSgjsfuVXrkEQ11TqyHooCqgp/xx/TOhzXJTlHMfKEncIn7FBYKV4Kz1VvqjkO8n/A21SATu+F4j9FnlKIUtVrXpfadQMB2LspAZvVpm1Arkqt4CKEcFBVFVW1FJnpQFRPJw6lsHLez1jzbOh0Op6c97Cj9oAQ/+bna6J5k2AADiWfJitbpmQsF8k5ipFvCyDA6EWYtz82HRzOPouquun/bRenqmbUnP/DoLdh8rSg+D6Joq+ndViiGlMUxdEtPi87n0N/J2sbkBCixlMUBfJ/Qpc7A/v5x1DteVqHJEpgt9v535RlmPOsWPNsDHy6L01jGmsdlqjmLo5jV1XYs/+kxtEIdyEN9gsiL4xjz7GYScvL1jocUZLcL8F2BB/vfDC0Bu/hWkckXEDMJePY9/y+X8NIXJeMJxPCuVTzJgzmFWBNAOsRrcMRJfh9+VYSth/CkmOlXvNQhr/QX+uQhAv4f/buPLypMm0D+H2yp0tSoBsge6WlrAqIMK4jCs4MigMMAooioIKoiNvg4C7iggxuiIDbOOIGrp/CCCiOjIAggoUCCrTI1pYWaJu0zXLO+/2RtjakLWmWniS9f9d1LmpyliedTPM8Oe/7vH17dqj9+eddnMceCOYcvliwV+tep1P8gXLOY480wn0IouIdmA1O6LQSJOsTkCQOS6Mzq1uwcz32AAkpuI2IvEi6TGi1iuc/5Dx1gyEfp46X4oNnP4HsUKC4Be5cfAuMZqPaYVEU6NOzfe3PbDwXIOYcPliwV8tKSoWQJEBiwR5pPGuuvwCNxgmzyQHET4Kkz1Y7LIoSnXt1QLw1DgCw87vdnPISCM4nIwotXSYkCdBqFQgW7BHn3Sc/gr20Eq4KNy6feDHOvay32iFRlGjTKgHt2yYBAPb8WgCH061uQNGIOYcPFuzVMq1pAABZAvJZsEeWqq8A1w4kmKsg6c6CFD9D7Ygoimi1WvT8QyYA4NTxMhz+hXPKiEhl+u4AAK1GBtws2CPJjm93YfOXP8Fld8PSOhG3zJ+odkgUZfpWz2N3uWXs/uWYytFQLGDBXq1LYmvoNVoovMMeUYR8EsK+BEaDC3q9DMnyKCRNnNphUZTpfUHd9dg5j72pOJ+MKLQkTWtAk+oZFu/O48ifCFFlr8Lbj34IxaVAdiq49bkbYE22qB0WRRmuxx4c5hy+WLBX02u0yLAkQ5aAw/ZTcMocwhIJhP1VSChDnMkBmEZAMl6odkgUhXrVbTzHeexNx+FpRKGny4ROqwCiDFCK1Y6GAHz84ioUHzkBl92Ncy7rjaHXX6R2SBSFajrFA2w8FxDmHD5YsNeRWd14ThYCB20n1Q6nxRPOrYDja8Sbq6DRWiAlPqB2SBSlug/oBr1RDwDI+Y4Fe5MF8013jH54EgVNn+kZEg8Acr6qoRCQv+sQ1ry1Hu4KGXqDHne+MtWzBB9RE7Vvm4TWreIBeJZ2k2VF5YiiDHMOHyzY66hZ2g0A8jgsXlVCqYSwvQC9zg2jwQ0p8X5I2jZqh0VRymDUI2tQBgCgIK8IxUf4/28iUpenU7yAJAnAxXnsapLdMt588F3ILgXuKhnXPTgG7TPaqh0WRSlJkmrnsVdUOrEv/7jKEdGZvPzyy+jcuTNMJhMGDRqEH374ocF9d+3ahVGjRqFz586QJAkLFy4Me3ws2OvITEoFJAmC89hVJyr/DSgFiDdXAYZBgJnrn1JwOI89CByeRhR6Ok8zTE+n+AMqB9OyrXn7W+TvOgynzY3OvTpgzD0j1A6JopzXPHYOi2+aZs453n//fcyaNQsPP/wwtm3bhr59+2LYsGEoKiqqd/+Kigp07doVTz31FNLT05t+wQCwYK8jq06neN5hV49w7QMqPkKc0QGtVg/J8hiHpVHQ6s5j57D4JmLBThR6uq4AdNBqFK7FrqLjh0vw8fNfQq6SAQW4a8mt0Ol1aodFUa5PNtdjD1gz5xwLFizA1KlTMWnSJGRnZ2Px4sWIi4vD66+/Xu/+AwcOxLPPPotrr70WRqOx6RcMAAv2OpJN8WhtjIPMO+yqEUKGsP0TWq0LJqMTUsI0SLouaodFMSB7cHdoNJ4vfnK+y1U5mujCjq1EoSdJBkDXFTqtDLh/gxBOtUNqcYQQePuxD1Fld8BVIWPEtCuQfX53tcOiGNC1Uwri4wwAgB27DnMliCYIRc5RVlbmtTkcjnqv5XQ68eOPP2Lo0KG1j2k0GgwdOhQbN25sjpfrFxbsdUiShExrKhQNcNJRiZMOu9ohtTyVnwHuX5FgroSkzwDip6odEcWIeEscuvXrDADI33kIZSfK1Q2IiEiX6VnaDTLg5l245vbDqm34+dtcuOxuJLdvjZueHK92SBQjtFoNevXw3GU/VVqBQ0dOqhxRy9KhQwdYrdbabd68efXuV1xcDFmWkZaW5vV4WloaCgoKmiNUv7BgP01mncZzB8pPqBtMCyPkQoiKN2EyOqHTKZAsj3vuQBCFSK8689h3/W+vipEQEXkaz+m0NZ3iOSy+OdlL7XjniY+gOBUoLoEZL05GvCVO7bAohvTN5nrsajl06BBKS0trt9mzZ6sdUlBYsJ8mKykViiQBEnCgjMPim4sQAsL2EjRShWfNdfO1kAz91Q6LYkzvuuuxcx67/ziHnSg89JmQJECjUSBYsDerD+Z/hrLicjjtbvxh5ED8YeR5aodEMaZu47kdbDznvxDkHBaLxWtraK55cnIytFotCgsLvR4vLCxstoZy/mDBfpq6jefybSzYm43zO8C5GfHmKkjaFEiJ96gdEcUgr8ZzG1iw+4tz2InCpE6neLjYKb657NmyD99+sBGuCjfiEsy47YXJaodEMSjr7HQY9FoAvMPeFM2ZcxgMBvTv3x/r1q2rfUxRFKxbtw6DBw8O8SsLHAv202RYkqGRJChsPNdshGKDsL0Cg94Ng94NyfIgJI1F7bAoBrVKtaJDZjsAwC9bD6Cqov4mJFQP3l0nCj1NGiBZoWOn+GbjdLrw1kPvQXELyA4FNz05HilntVE7LIpBBr0OPbq3BQAcKyzF8RL2zvFbM+Ycs2bNwtKlS/HWW29h9+7dmDZtGux2OyZNmgQAmDhxoteQeqfTie3bt2P79u1wOp04cuQItm/fjn379gX4Ys+MBftpTDo9Oie09txhLz8Jt6KoHVLME/bXIYliz5rrxksB4zC1Q6IYVjOPXXbL2LP5V5WjIaKWTJKk6sZzMqCUQCilaocU875cshbHDhTBZXMja9DZ+Mutl6sdEsUwrsce+caOHYv58+fjoYceQr9+/bB9+3asXr26thHdb7/9hmPHjtXuf/ToUZxzzjk455xzcOzYMcyfPx/nnHMOpkyZErYYWbDXo6bxnEuRcaSCH57hJJw7gar/Q5zJAY3WDMnyMNdcp7DqzfXYm45z2InCR58Jnbb65oA7X9VQYt2R/QX44tWv4K6UodFocNert0Cr1aodFsWwuo3ndnBYvH9UyDlmzJiBgwcPwuFwYPPmzRg0aFDtc+vXr8ebb75Z+9+dO3f29N46bVu/fn1gF/cDC/Z6eBrPeX7OKytWN5gYJoQTwv48dFoZJqMLUsJdkLTt1A6LYlyvC7Nqf97Jeex+4Rx2ovCRdJnQaBRAAuDmsPhwURQF/3rofTgr3XBXyhhzz1Xo2qeT2mFRjOuZ1Q4ajaeo4B12/zDn8MWCvR6Z1jQISYKQgDzOYw+fig8B+SDi46oAXS8g7jq1I6IWIL1zKpLbtwYA5G78BbJbVjmiKMA77ETho/N0itdqFAiZjefC5bsVm7F363647G6065aG6x4cpXZI1ALExxmR0SUVAJD3WzHKbVUqRxQFmHP4YMFej6wkz/+xZAk4YONa7OEg3IchKpbDbHBCp5UgWZ+AJHFYGoWfJEm13eKr7A7s+4l3tIhIRboMAJJnPXY3C/ZwOHW8FB88+wlkhwLFLXDnKzfDaK5/mSeiUOtTPSxeCCBn9xGVo6FoxIK9Hu3jrIjXGTyd4rkWe8h51lx/HhqNA2aTA4ifBEmfrXZY1IL0voDz2JuCw9OIwkfSxAPajp6l3dwHIQRH/YTau09+BHtpJVwVblw+8WKcO7SP2iFRC9KnZ/van7ke+5kx5/DFgr0ekiTVNp4rrCyH3cmln0Kq6ivAtQMJ5ipIurMgxc9QOyJqYXpzHnvTcHgaUXjpMqHTyAAcgHzsjLuT/3Z8uwubv/wJLrsbltaJuGX+RLVDohamT486neLZeO7MmHP4YMHegKykVMjVjecO2HiXPVSEfBLCvgRGgwt6vQzJ8ggkTZzaYVEL06lnByS2igcA5Hy3BwqXb2wcPzyJwkrSZ3rusANcjz2EquxVePvRD6G4FMhOBbc+dwOsyRa1w6IWpnWreHRo3woAsOfXAlQ5XCpHFOGYc/hgwd6ATGuap1O8BOSVcx57qAj7q5BQhjiTAzCNgGS8SO2QqAXSaDTo+QfPXfayknIc2sM5ZUSkIl13aDQCkiQgOI89ZD5+cRWKj5yAy+7GOZf1xtDrmXOQOmrmscuygty9HEVDTcOCvQFZSamAJEFhp/iQEc6tgONrxJuroNFaICU+oHZI1IL18prHvkfFSCIf55MRhZnO8wWip/Ec77CHQv6uQ1jz1nq4K2ToDXrc+cpUSJKkdljUQvXJ5rB4fzHn8MWCvQHdLSkAqjvFs2APmhBVELYXoNe5YTS4ISXeD0nbRu2wqAXjPPYm4PA0ovDSdgAks2dYPIfEB012y3jzwXchuxS4q2Rc9+AYtM9oq3ZY1IL17VmnYGfjucYx5/DBgr0BiQYT2sdZa++wKyJG3wHNRFT8G1AKEG+uAgyDADPXPyV1nd2/K4xmAwB2ij8jfngShZUkaQBdd88ddvkYhFKhdkhRbc3b3yJ/12E4bW507tUBY+4ZoXZI1MK1TbMipU0CAGDX3qNwy+yd0yDmHD5YsDciM8nTKb7C7UJhRZna4UQt4doHVKxEnNEBrVYHyfIoh6WR6vQGPXqcfzYAoOi3YhT9dlzliIioRdPVaTznPqhuLFHs+OESfPz8l5CrZEAB7lpyK3R6ndphUQsnSVLtsPjKKhd+PVCockQUTViwNyLL+nun+DwbG88FQggZwvZPaLUumIxOSAnTIem6qh0WEQDOY/cX55MRhZ+k6w6tpqZTPBvPBUIIgbcf+xBVdgdcFTJGTLsC2ed3VzssIgBAHw6L9wtzDl8s2BuRmZQGIUkQbDwXuMrPAfevSDBXQtJnAPFT1Y6IqFbvC+sW7BwW3yAOTyMKP30WJAnQahUIzmMPyA+rtuHnb3PhsstIbt8aNz05Xu2QiGqx8ZyfmHP44BihRmRaUwEAigTsL2PB3lRCLoSoeAMmoxM6nQLJ8hgkyaB2WES1epx/NjRaDRRZYeO5RgTzrXWsfttNFHI6z51grUaG7OId9qayl9qxfO5HUJwKFJeC2164CfGWOLXDIqrVpWMyEhNMKLdV4efcIxBCcIpoPZhz+OId9kZ0TmgNg0bLpd0CIISAsL0MjVThWXPdfC0kwwC1wyLyYk4w4+xzuwAADuYeRllJucoRRSh+200UdpImCdCkQ6dVADkfgs1um+SD+Z+h9Hg5nHY3/jByIC64ZpDaIRF50Wgk9O7RHgBQWlaJg4c53bZezDl8sGBvhE6jwdnWFMgScKSiFA63S+2QoodzA+DchHhzFSRtCqTEe9SOiKhedeex79zAeexEpCJ9JrRaGRA2QGEjTH/t3bof336wEa4KN+ISzLjthclqh0RUrz7Z7Wt/5jx28hcL9jOoaTynCIGDtpNqhxMVhGKDsC2CQe+GQe+GZHkQksaidlhE9eI8dj/w226i5qHr7rnDDgBuDov3h9PpwpsPvgfFLSA7FNz05HiknNVG7bCI6uXVeI7z2OvHnMMHC/YzyLSmQameXnLAxmHx/hD21yGJYs+a68ZLAeMwtUMialCvC7Jqf+Y89vpJQW5E5B9JlwWNRkCSBOBm4zl/fLlkLY4dKITL5kbWoLPxl1svVzskogZldkuH0eBpIcaCvX7MOXyxYD+DzKQUQJKgSMABNp47I+HcCVT9H+JMDmi0ZkiWh9lQgyKaNdmCjtVzyn758QAqbZUqRxSB+G03UfPQZQJgp3h/HT1QiC9e/QruShkajQZ3vXoLtFqt2mERNUiv1yI7sy0AoKCoDIXHy1SOKAIx5/DBgv0MsqxpAMDGc34Qwglhfx46rQyT0QUp4S5I2nZqh0V0Rr2r57ErsoLdm35VORoiarF0XQDoodPKgJyvdjQRTVEUvPXge3BWuuGulDHmnqvQtU8ntcMiOqO6y7vt4Dx28gML9jNoY4pHsikesgQcKD/Brq2NqfgQkA8iPq4K0PUC4q5TOyIiv/TiPPZG1SyxEuhGRP6RJD2g6watRgHchyCEU+2QItZ3KzZj79b9cNndaNctDdc9OErtkIj8wvXYG8ecwxcLdj9kWlOhaIBSZyVOOirUDiciCfdhiIrlMBuc0GklSNYnIEkclkbRoW7jOc5jrweHpxE1H12m5w47ZMD9m9rRRKRTx0vxwbOfQHYoUNwCd75yM4xmo9phEfmlZ1Y7aDWe6aLsFF8P5hw+WLD7IcuaBrmm8RyHxfvwrLn+PDQaB8wmBxA/CZI+W+2wiPyW1ikFqR2TAQC7N/0Kl5NLOPrgBydRs5D0mdDWdIrnPPZ6vTvvY9hLK+GqcOPyiRfj3KF91A6JyG9xZgPO7uaZcpt/qASlZeyd44M5hxcW7H7ITEqBkCRAYsFer6qvANcOJJirIOnOghQ/Q+2IiJqs5i67o9KJX7cxSSYilegyIUmARqNAcGk3Hzu+3YXNX2yDy+6GpXUibpk/Ue2QiJqMw+KpKViw+yGzuvGczILdh5BPQtiXwmhwQa+XIVkegaSJUzssoibrdUGdYfGcx+6F88mImlF1p3idVgHc+erGEmGq7FV4+9EPobgUyE4Ftz53A6zJFrXDImqyvlyPvUHMOXyxYPdDhiUZ2uql3fLKT6gdTkQR9lchoRRxJgdgGgHJeJHaIREFpPeFv6/HnsN57N44n4yo+WhSAKkVtFqZQ+JP8/GLq1B85ARcdjfOuaw3hl7PnIOiU+/s9rU//5x7RMVIIhBzDh8s2P1g1OrQJbENZAn4zXYSLkVWO6SIIJxbAcfXiDdXQaO1QEp8QO2QiALWscdZsLRJBADs2rAHiqKoHFHk4LfdRM1HkiRAn+npFK+cgJBPqh1SRMjfdQhr3loPd4UMvUGPO1+Z6vldEUWhJEscOnVoAwD4ZX8hKqu4IkQN5hy+WLD7KcuaCkUCXIqMw/ZStcNRnRBVELYXoNe5YTS4ISXeD0nbRu2wiAImSRJ6XeC5y15+0o6DHKJGRGrRZXqGxAO8yw5Adst488F3IbsUuKtkXPfgGLTPaKt2WERB6VN9l12WFeTuPaZyNBTJWLD7qXt1wQ4AeeXF6gYTAUTFvwGlAPHmKsAwCDBz/VOKfpzH3gAVhqe9/PLL6Ny5M0wmEwYNGoQffvjBr+Pee+89SJKEkSNHej1us9kwY8YMnHXWWTCbzcjOzsbixYsDC44ozCRddad4CYCbBfuat79F/q7DcNrc6NyrA8bcM0LtkIiC1rdO47kdXN7tdxwS74MFu5+yktIgJAlCAg6UtezGc8K1D6hYiTijA1qtDpLlUQ5Lo5jAeez1a+7hae+//z5mzZqFhx9+GNu2bUPfvn0xbNgwFBUVNXpcfn4+7rnnHlx44YU+z82aNQurV6/Gv//9b+zevRszZ87EjBkz8NlnnzU9QKJw01c3ntPIEC38DvvxwyX4+PkvIVfJgALcteRW6PQ6tcMiClofNp6rF4fE+2LB7qcsayoAT6f4PFvLbTwnhAxhWwit1gWT0QkpYTokXVe1wyIKiYxzusAUZwQA5Px3N4SI0b/8TdXM33YvWLAAU6dOxaRJk2rvhMfFxeH1119v8BhZljFhwgQ8+uij6NrV92/S999/jxtuuAGXXHIJOnfujJtvvhl9+/b1+849UbPSZQDQeO6yt+A77EIIvP3Yh6iyO+CqkDFi2hXIPr+72mERhUR6qhWpydW9c/YchcvFHlkAeIe9HizY/dQ2zoJEvbG6U3wLvsNe+Tng/gUJ5kpI+gwgfqraERGFjE6vQ4/BnmSw+MgJFOQ3fkeX/FdWVua1ORyOevdzOp348ccfMXTo0NrHNBoNhg4dio0bNzZ4/sceewypqamYPHlyvc8PGTIEn332GY4cOQIhBL755hv88ssvuOKKK4J7YURhIElmQNupumA/CCHcaoekih9WbcPP3+bCZZeR3L41bnpyvNohEYVUzV12h9ONX/YXqhwNRSoW7H6SJAlZ1lTIElBUaUO5s0rtkJqdkIsgKt6AyeiETqdAsjwGSTKoHRZRSPX2mse+R8VIIkgIvu3u0KEDrFZr7TZv3rx6L1VcXAxZlpGWlub1eFpaGgoKCuo9ZsOGDXjttdewdOnSBl/Ciy++iOzsbJx11lkwGAwYPnw4Xn75ZVx0EZeFogily4ROIwNwAvJRtaNpdvZSO5bP/QiKU4HiUnDbCzch3hKndlhEIVV3HjuHxVfjHXYfLNiboLs1FUr1byzP1rLusgshIGwvQSNVeNZcN18LyTBA7bCIQq5X3XnsbDwHIDTzyQ4dOoTS0tLabfbs2SGJrby8HNdffz2WLl2K5OTkBvd78cUXsWnTJnz22Wf48ccf8dxzz+G2227D2rVrQxIHUahJ+urGc0CLHBb/wfzPUHq8HE67G38YORAXXDNI7ZCIQq7uPPYdLNgBcA57fdi1owmyklKhAEB147k+rdurHVLzcW4AnJsQH18FSZsCKfEetSMiCose53eHVqeF7Jaxk43nPIL51rr6OIvFAovFcsbdk5OTodVqUVjoPTSwsLAQ6enpPvvv378f+fn5GDHi967RiuIpcnQ6Hfbu3Yt27drhgQcewMcff4w///nPAIA+ffpg+/btmD9/vtfwe6KIocuERiOg0Qgo8gFIuFjtiJrN3q378e0HG+GqcCMuwYzbXqh/qgtRtOt0VhtYEk0oK69CTu4RKIqARtPCGzmHIOeINbzD3gSZ1jRAkqBIwIHyltN4Tih2CNsiGPRuGPRuSJY5kDRnTryJopEpzojuAzxNyw7tPYqTRaUqR6Q+SYigtqYwGAzo378/1q1bV/uYoihYt24dBg8e7LN/VlYWcnJysH379trtqquuwqWXXort27ejQ4cOcLlccLlc0Gi8P/K0Wm1tcU8UcXSeTvFarQy489WNpRk5nS68+eB7UNwCskPBpLnjkHJWG7XDIgoLjUZCn+ph8eW2KuQf4tLRzZlz1GjqUrIffvghsrKyYDKZ0Lt3b3z55ZcBXddfLNiboLs1BUBNp/iWMyRe2F+HJIo9a64bLwWMw9UOiSisvOaxb+A89uY2a9YsLF26FG+99RZ2796NadOmwW63Y9KkSQCAiRMn1g6pN5lM6NWrl9eWlJSExMRE9OrVCwaDARaLBRdffDHuvfderF+/Hnl5eXjzzTfxr3/9C9dcc42aL5WoYdr2gBQPrUYBWtDSbl8uWYtjBwrhsruRNehsjJjGxpAU2/rUncfO9dibXVOXkv3+++8xbtw4TJ48GT/99BNGjhyJkSNHYufOnWGLkQV7EyTojegQnwRFAvLLS6C0gCWfhHMnUPU54kwOaLRmSJaHueY6xbxeF9ZtPMdh8c3dAGbs2LGYP38+HnroIfTr1w/bt2/H6tWraxvR/fbbbzh27FiTzvnee+9h4MCBmDBhArKzs/HUU09h7ty5uPXWW5seIFEzkCQNoOsOnVYG5AIIxa52SGF39EAhvnj1K7grZWgkDe569RZotVq1wyIKK+/12I+oGEmEiPClZJ9//nkMHz4c9957L3r06IHHH38c5557Ll566aWmX9xPnMPeRJnWVBwtP4lKlxvHKkrRPj5J7ZDCRggnhP156LQyTEYXpIR7IWnbqR0WUdj1/ENm7c85nMceVCOXQI+bMWMGZsyYUe9z69evb/TYN9980+ex9PR0vPHGG4EFQ6QWXSa02h2en915gKGXuvGEkaIoeOvB9+CsdMNdKePa+0eia59OaodFFHbdu6bCZNSjyuHCjtzDEEK06Jtjocg5ysrKvB43Go0wGo0++9csJVu3Ee6ZlpLduHEjZs2a5fXYsGHD8MknnwQWtB94h72JspJSoVT/fygv1uexV6wA5IOIj6sCdL2AuOvVjoioWVhaJ6Jzrw4AgP0/5aGivFLliFTGJVaIVCHpMz1D4iXE/LD471Zsxt6t++Gyu9GuWxque2i02iERNQudToueWW0BAMeLy1FQVHaGI2JcCHKOcC4lW1BQ0KT9Q4EFexNlWtMgJAlCAg6Ux+48duE+DFHxDswGJ3RaCZL1CUgSh6VRy1Ezj11RBHI3/qJyNETUIukyIUmAVqNAxHDjuVPHS/HBs59AdihQ3AJ3vnIzjGbfu2FEsaoP12MPqXAtJasWFuxNlJWUCgBQJCAvRgt2z5rrL0CjccBscgBxN0LSZ6sdFlGz4jz233FNVCKV1HSK18iA+4DKwYTPu/M+hr20Eq4KN4ZefxHOHdpH7ZCImhUbz/0uFDlHzVKyNVt9w+GBpi8lC3im2DVl/1Bgwd5EHeNbwaTVeTrFx2jBjqo1gGs7EsxVkHRnQUq4Xe2IiJpd7zoFe4ufx84h8USqkDSJgKYddFoFkA9AxGCz2x3f7sLmL7bBZXfD0joRt8yfqHZIRM2uZ1Y7aLWesmxHS7/D3ow5R1OXkgWAwYMHe+0PAGvWrGlw/1Bgwd5EWo0G3a2eeexH7KWodDvVDimkhHwSwr4ERoMLer0MyfIIJE2c2mERNbuUs9ogvbNnKcc9m3+F0+FSOSL18A47kYr0mZ612EUlIBeeef8oUlXhwNuPfgjFpUB2Krj1uRuQlGJVOyyiZmcy6pHZrXollMMncKq0QuWI1NPcOUdTlpIFgDvvvBOrV6/Gc889hz179uCRRx7B1q1bG2yUGwos2APQ3ZoCWfJ8iXOw/KTa4YSUsL8KCaWIMzkA018gGS9SOyQi1dQMi3dWufDrj7E7HJWIIpgu03OHHYi5xnOfvLAKxUdOwGV345zLemPo9cw5qOXyXt6thd9lb0ZNXUp2yJAhWL58OZYsWYK+fftixYoV+OSTT9CrV/hW8WDBHoAsa1ptp/gDttgZFi+cPwKOrxFvroJGa4GU+IDaIRGpqqbxHADk/DdXxUhUxiHxRKqRdJnQaAQkSXiWdosR+bsO4au3voG7QobeoMedr0xt0UtZEdWdx76jJc9jVyHnmDFjBg4ePAiHw4HNmzdj0KBBtc+tX7/eZ7nYMWPGYO/evXA4HNi5cyf+9Kc/BXZhP7FgD0BmUiogSTHVeE6IKgjb89Dr3DAa3JAS74ekTVY7LCJV9eI89locDk+kEn114zmtAiHHxkgf2S3jzQffhexS4K6Scd2DY9A+o63aYRGpqneP9rU/t/Q77Mw5vLFgD0Cm9fdO8QfKYqRgr/g3oBQg3uwA9OcB5lFqh0Skug6Z7ZCUYgEA7PrfXsiyrHJEKhEiuI2IAqftDMAAnVaOmTvsa9/+L/J3HYbT5kbnXh0w5p4RaodEpDqrxYwuHT03y349UISKitjqk+U35hw+WLAHoLUxDmnmRMgaIM92Iuq7tgrXfqBiJeKMDmi1WkjWxzgsjQiAJEm1d9ntpRXI33lI5YiIqKWRJB2gy4BWowDyEQjhUDukoBw/XIKPnv8CcpUMKMBdr94CnV6ndlhEEaFv9Tx2RRHYufeIytFQpGDBHqDu1hQoElDmrEJxlV3tcAImhAxh+ye0WhdMRiekhOmQdF3VDosoYnjNY2+h67GzSzyRynSZnjvsUAD3QbWjCZgQAm8/9iGq7A64KmSMmHYFsgdnqh0WUcTwXo+9ZRbszDl8sWAPUJY1DXL1Teionsde+Tng/gUJ5kpIum5A/FS1IyKKKL0uzKr9eWdLncfOpnNEqpL0mdDWdIp356saSzC2rPoJP3+bC5ddRpt2rXDTk+PVDokoorBTPJhz1IMFe4Ayk1IhJAmQgANRWrALuQii4g2YjE7odAok6+OQJIPaYRFFlG59O8OcYAIA5Hy3J+qnwARCUoLbiChIukxIEqDRRG/jOXupHe/MXQnFqUBxKZjx4mTEW+LUDosooqQmJyI91QoAyP3lGJwut8oRNT/mHL5YsAcoq7rxnCwBeeUnVI6m6YQQELaXoJEqPGuum6+FZBigdlhEEUer0yJ7iGfI5oljJ3HsQKHKERFRi6PzjPTRaZWobTz3wfzPUHq8HE67G38YORAXXDPozAcRtUB9e3q6xTudbuzdx5yDWLAHrGtiMnSSJnqXdnNuAJybEG+ugqRNgZR4j9oREUWsFj+PncPTiFQladsAmjbQamXAfSDqRvrs3bof336wEa4KN+ISzLjthclqh0QUsbzmsbfEYfHMOXywYA+QQatFV0sbyBLwm+0knFG03JNQ7BC2RTDo3TDo3ZAscyBpLGqHRRSxvOaxt8CCnQ1giCKALtNzh12UAspJtaPxm9PpwpsPvgfhFpAdCibNHYeUs9qoHRZRxPKax76r5RXszDl8sWAPQpY1FYoEuIWCw/bo+fAU9tchiWLEm6sA46WAcbjaIRFFtKzzMqDTawEAORv2qByNCrgmKpH6dJnQaqpvDsjRMyz+yyVrcexAIZx2N7IGnY0R065QOySiiNaxfWskWT39HXJ2H4GitLDPUeYcPliwByGzTqf4aGk8J5y7gKrPEWdyQKM1Q7I8zDXXic7AaDai+8AMAMCRX4/hREH0fEEXCvy2m0h9nk7xApAAuKOj8dzRA4X44tWv4K6UoZE0uOvVW6DVatUOiyiiSZKE3j0889htdgfyDh5XOaLmxZzDFwv2IGQlpQKSBBEljeeEcELYn4dOK8NkdEFKmAlJ207tsIiiQu8L6i7v1gLvshORumoaz2lkiChoPKcoCt568D04q9xwV8oYc/cIdO3TSe2wiKJC3zrD4ne0xHns5IUFexAy63SKj4o77BUrADkf8XFVgK4XEHe92hERRY3eF9ZpPPffFjaPnQ1giNSn6wZA61mPPQqGxH+3YjP2bt0Pl82Ndt3ScN1Do9UOiShq1G08t6OlzWNnzuGDBXsQ0syJsBpMUdEpXrgPQ1S8A7PBCZ1WgmR9ApLEYWlE/ur5h6za6SM5G1pWwc7haUTqkyQjoO0MnVYG3AchhEvtkBp06ngpPnj2E8gOBYpb4M5XbobRbFQ7LKKokdE1FWazHoCnU3y0rQwRDOYcvliwB0GSJGRaUyFLQHGVHaeclWqHVC/PmusvQKNxwGxyAHE3QtJnqx0WUVRJSIpHl94dAQAHdhyEvdSuckTNiA1giCKDPtNzhx1uwH1E7Wga9O68j2EvrYSrwo2h11+Ec4f2UTskoqii02rQM9MzbbXkhB1HC06pG1BzYs7hgwV7kLKsaVCqf4sRe5e9ag3g2o4EcxUk3VmQEm5XOyKiqNSreh67EAK7vv9F5WiIqKWRdJnQahTPf0TosPgd3+7C5i+2wWV3w9I6EbfMn6h2SERRqa/XeuyR+wUdhR8L9iBlJqVCAQAJyC+LvMZzQj4JYV8Co8EFvV6GZHkEkiZO7bCIolKfi34fmZLTgtZj5/A0ogihy4JGI6DRCIgILNirKhx4+9EPobgUyE4Ft8yfiKQUq9phEUWlvr061P7ckuaxM+fwpVM7gGiXZfV0ilckEZGN54T9VUgoRZzJAZj+Asl4kdohEUWtXnUaz+1sSfPYg2nkEqMfnkSq0HcHAGi1MpQI7BT/yQurUHzkBFx2N/r9sRcun3ix2iERRa0eZ6dDp9PA7Vbwc0vqFM+cwwfvsAfpbGsKJFR3irdFVsEunD8Cjq8Rb66CRmuBlPiA2iERRbU2bVuhXbc0AMDeH/bBWeVUOaLmwW+7iSKEph0gJUCnUSJuLfb8XYfw1VvfwF0hQ2/QY+bim2sbdRJR0xmNemRlpAMADh89iZKTNpUjah7MOXyxYA9SnM6AjgmtoEhAfnkJZEVROyQAgBBVELbnode5YTS4ISXeB0mbrHZYRFGv5i67y+nG3i37VY6GiFoSSZIAXSa0WhlQjkMo5WqHBACQ3TLefPBdyC4F7ioZE+aMRvuMtmqHRRT1+tRZjz2H89hbLBbsIZBlTYMsAQ5ZxrHKUrXDAQCIin8DSgHizQ5Afx5g5vqnRKHQ+4I667G3lHnsighuI6LQqe0UDyBChsWvffu/yN91GE6bG517dcCYe0aoHRJRTKjbeG5HSxkWz5zDBwv2EMhMSoVSPerrQLn6jeeEaz9QsRJxRge0Wi0k62MclkYUIi1yHrsIciOikJF0WZ5O8RIiomA/frgEHz3/BeQqGVCAu169BXqDXu2wiGJCrx7tUZPC/9xSGs8x5/DBgj0EsqypEJIEIQEHytSdxy6EDGH7J7RaF0xGJ6SEaZB0XVWNiSiWtM9IR6s0T9fjXd/vhSzLKkcUfhKCmE+mdvBEsUbXHZIEaDWK6p3ihRB4+7EPUWV3wFUh4y+3XoHswZmqxkQUSxITTOjaKQUAsD//OOwVDpUjCj/mHL5YsIdAd2sqAECRImAt9srPAfcvSDBXQtJ1A+JvVjceohgjSVLtXfaKskrk/fybyhERUYui83SK12ll1e+wb1n1E37+Nhcuu4w27Vph8pPjVI2HKBb1qR4WrygCO3cfVTkaUgML9hDomNAKZq3e0ylexYJdyEUQFW/AZHRCp1MgWR+HJBlUi4coVrW4eexCBLcRUchImgRAe5ZnHrucDyHUaXZrL7XjnbkroTgVKC4FM16cjHhrvCqxEMWyuo3nWsTybsw5fLBgDwGNJKG71TOP/VhFGeyu5l/qSQgBYXsJGqnCs+a6eSwkw4Bmj4OoJeh9Yd2CPVfFSJoHl1ghijC6TGg1MiAqAblAlRA+mP8ZSo+Xw2l3Y8jVA3HBNYNUiYMo1nk1ntt1SMVImgdzDl86tQOIFVlJqcgp9nzrddB2Atmt0ps3AOcGwLkJ8fFVkLQpkBLvbd7rE7UgXfp0RJzFjIqySvz0bQ5++uknOJ1OGI1GZGRkICEhQe0QQyuYRi4x+uFJpCpdFnTarz0/y3mArl2zXn7v1v349oONcFW4YY43YcaLk5v1+kQtSXKbBLRLt+JoQSl2/1KAkhOncOi3fDgcjtjMO5hz+GDBHiKZ1t87xeeVlzRrwS4UO4RtEQx6Nwx6NyTLHEgaS7Ndn6il2bt3L44k/YpfK/ag/HgpPjn3X7XPSZKEzMxMXH755bj11luRnZ2tYqREFIskfXdoNAKSJDzz2I1/aLZrO50uvPngexBuAdmh4KZnxyPlrDbNdn2ilii9tYLv1n6K8hP7kZJ8D0Sdod/MO2IfC/YQybSmApIERRLNPo9d2F+HJIoRb64CjJcAxuHNen2iliIvLw/Tp0/H6tWrkZKcgglTxmHgwIHIzs5GXFwcKioqkJubiy1btuD999/Hiy++iOHDh2PRokXo0qWL2uEHTBICUoDzwgI9jogaofN0YtdpZbjcB5q1M/KXS9bi2IFCOO1uZA06GyOmXdGMVydqWermHW3aJOO68WNiPu9gzuGLBXuIZNbpFN+cS7sJ5y6g6nPEmR3QaM2QLA9zzXWiMFi2bBlmzpyJ5ORkvPPOOxg9ejQMBt+mjoMGDcKkSZOwcOFCrFixArNnz0bv3r2xcOFCTJkyRYXIQ0Cp3gI9lohCS9sJgBFarQJXM3aKP3qgEF+8+hXclTI0kgZ3vXoLtFpts12fqCVpsXkHcw4fbDoXIklGM9LNiZA1wAFbiddQlXARwglhfx46rQyT0QUpYSYkbfuwX5eopZk7dy6mTp2KcePGIScnB+PHj6/3Q7Mug8GA8ePHY+fOnRg3bhymTp2KuXPnNlPEoVXzbXegGxGFliRpAd3Z0GoUQD4KIarCfk1FUfDWg+/BWeWGu1LGmLtHoGufTmG/LlFL1JLzDuYcvniHPYSyktKwwe7pEl9UZUOaOTG8F6xYAbjzEZ9YBeh6AXHXh/d6RC3QsmXLMGfOHDz++OOYM2dOk49PTEzE0qVL0bFjR8yZMwfp6emYPDnKGjSxAQxR5NFnQafNBSAAdz6gzwrr5b5bsRl7t+6Hy+ZGu25puO6h0WG9HlFL1eLzDuYcPniHPYQyramQaxrPhXlYvHAfhqh4B2ajEzqtBMn6hOcbdyIKmby8PMycORNTpkzx+dBcv349JEmqd9u0aZPPuebMmYMpU6bgzjvvRF5e8w1hJaLYJOkyPWuxA57Gc2FUWlyGD579BLJDgeIWuPOVm2E0G8N6TaKWiHkH1Yd32EMo05oKIUmAJHDAVoLz0zqH5TqeNddfgEbjgNnkAOImQ9KzIyRRqE2fPh3JyclYsGBBg/vccccdGDhwoNdjGRkZPvtJkoTnnnsOX331FaZPn45Vq1aFPN6wEcKzBXosEYWerjskCdBqFchyXlgbzy1/8iPYSyvhqnBj6PUX4dyhfcJ4NaKWi3kHmHPUgwV7CGUleRrPyVKY77BXrQFc25EQXwVJdxakhNvDdy2iFio3NxerV6/GO++8g8TEhqe3XHjhhRg92r+hoRaLBfPmzcOECROwe/du9OjRI1ThhpUkPFugxxJRGOg9neK1GhlyGO+w//xtLjZ/sQ0uuxuW1om4Zf7EsF2LqCVj3uHBnMMXh8SHUJfENtBrNJ5O8WFa2k0opyDsS2A0uKDXy5Asj0DSxIXlWkQt2eLFi5GamurXh2J5eTncbrdf5x01ahRSU1PxyiuvBBti86n5tjvQjYhCTtK0BjSpnmHx7rywNLutqnDgX49+AMWlQHYquGX+RCSlWEN+HSJi3lErQnOOEydOYMKECbBYLEhKSsLkyZNhs9kaPWbJkiW45JJLYLFYIEkSTp06FdC1WbCHkF6jRYYlBbIEHLafglP27/9ITSFsiyGhFHEmB2D6CyTjRSG/BhEBa9aswahRo87YlXXSpEmwWCwwmUy49NJLsXXr1kb3NxqNGDVqFNauXRvKcImoJdJlQqdVAFEGKKG/UfDJC6tQfOQEXHY3+v2xFy6feHHIr0FEHsw7ItuECROwa9curFmzBv/3f/+H//73v7j55psbPaaiogLDhw/HAw88ENS1WbCHWE3jOVkI/GY7GdJzC+ePgONrxJuroNFaICUG9z8+EdWvvLwce/fu9ZkjVpfBYMCoUaPw/PPP49NPP8UTTzyBnJwcXHjhhfjpp58aPf+AAQOwZ8+eM34zGykkJbiNiMJEnwmtRvb8LId2WHz+rkP46q1v4K6QoTfoMXPxzZCkcM6UJ2q5mHf8LhJzjt27d2P16tVYtmwZBg0ahAsuuAAvvvgi3nvvPRw9erTB42bOnIm///3vOP/884O6Puewh1imNRVKTaf48hJkWFNCcl4hqiBsz0Ovc8NocENKvA+SNjkk5yai37kVBZt3/AwhBLKzG27mOGTIEAwZMqT2v6+66iqMHj0affr0wezZs7F69eoGj+3ZsyeEENi3bx/69esXyvDDgw1giCKSpOsOrVZAkgTgygMMDSf7TSG7Zbz50HuQXQrcVTImPfE3tM9oG5JzE9HvZFnBqeJyfLf+e+YdNUKQc5SVlXk9bDQaYTQGvrLFxo0bkZSUhAEDBtQ+NnToUGg0GmzevBnXXHNNwOf2Bwv2EMtMSgUkCUISOFB+ImTnFRX/BpQCxCc4AP15gJnrnxI1lawoKLZV4FhZOQrKylFQZkNBeTmOlf7+8/FyO2y/5QMA4uKa1h8iIyMDV199NT766CPIsgyttv6lFs1mMwDA4XAE9XqaDddEJYpMuprGcwrc8oGQdYpf+/Z/kb/zEJw2Nzr36oAx94wI0ZmJWg5FUXCqxIbjx0pRfOwUigtKcbzuv8dOoaSoDLJbwamqYwCYdwAISc7RoUMHr4cffvhhPPLIIwGHVFBQgNTUVK/HdDodWrdujYKCgoDP6y8W7CGWZf29U/yB8uKQnFO49gMVKxFnckCr1UKyPsZhaUSnUYRAsc2OgjKbd0FeVl793zYUldsg+/GtraTz/GmsqKhochwdOnSA0+mE3W6HxWKpd5/KykoACOrbXiIi6LoB0EGrVeAO0ZD44iMn8NHzX0CukgEFuOvVW6A36ENybqJYoSgKSk/Ya4vvmkK8+NgpT4FecAolhWVwu2S/zqeRPIU2847QOHTokNfvoqHX/fe//x1PP/10o+favXt3SGMLBAv2EEsxJaCVMQ52tx15IbjDLoQMYfsntFoXTEYnpIQ7IOm6hiBSouihCIESe0VtEV63ID9WVo7CMhsKy21wK8FNXmoTH4f0xAS06dgOry2WkJubi0GDBjXpHAcOHIDJZEJCQkKD++zatQuSJNW7bmokkoSAFODwtECPI6IzkyQDhK4rdNo8OJyHIIQTktR4w6rGCCHw9mMfosrugKtCxohpw5A9ODOEERNFPiGEpxivU4jXFOE1/xYXlPpdjDfE0ioOyelJSE63wtKmHzY+8zbzDoQm57BYLA1+eVHX3XffjRtvvLHRfbp27Yr09HQUFRV5Pe52u3HixAmkp6cHFGtTsGAPMUmSkGVNxZaKPJxwVOCkowKtjEEsu1b5OeD+BQkJlZB03YD4xrsREkUbIQROVFR6ivDSchSU2zxD1Mt/vzteVGaDK8hivFWcGW0tiUhLTEBbayLaWhKQlphY+3NqYgKMut//JG546hFs2bIFkyZNqvd8x48fR0qKd4+KHTt24LPPPsOVV14Jjabhnp5bt25FVlZWox+uEYVz2Ikily4TWu1+AG7AfRjQB/6l/pZVP2HH+l1w2WW0adcKk58cF7o4iSKAEAJlJyt+L77rG6peUAqXM7iVnhKT4pCcbkVKW09Bntw2CSltrUhO//1fo8l75MqyT59g3gE0a86RkpLi8zutz+DBg3Hq1Cn8+OOP6N+/PwDg66+/hqIoTf6CJRAs2MMg05qKzYWeoWl55ScCLtiFXARR8QZMRid0OgWS9fGgvjknam5CCJysqKz/rni5rXaouksO7lvqJLMJ6RZP4Z1uSazeEqof8xTpJn3T/txdfvnleP/997Fw4cJ6l1gZO3YszGYzhgwZgtTUVOTm5mLJkiWIi4vDU0891eB5HQ4HVq5cibFjxzb5dapGAAj0+xLW60RhJem6Q6f93PMfcl7ABbu91I535q6E4lSguBTMeHEy4q3xIYyUKLyEELCVVnoV33WHqhcXlKK4oBSOKldQ10mwmJFcp/j2KsrTPY+b4pqerzPvqBaBOUePHj0wfPhwTJ06FYsXL4bL5cKMGTNw7bXXol27dgCAI0eO4LLLLsO//vUvnHfeeQA8c98LCgqwb98+AEBOTg4SExPRsWNHtG7d2u/rs2APA0+neAmQBA6UleDc5LOafA4hBITtZWikCs+a6+axkAwDznwgUTMRQuBUZVWDw9RrfnYGWYxbTUavIrzt6cW4JQFmfejnV95666148cUXsWLFCowfP97n+ZEjR+Kdd97BggULUFZWhpSUFPz1r3/Fww8/3OiQs5UrV6KoqAjTpk0LecxE1ALpMyFJgEYjoMh5ATee+3D+5yg9Xg6n3Y0hVw/EBdeE/64Rkb+EELCVVXo1bPO+M+4Zqu6oDK4Yj0801XNnPMnrMXN8eOaBM++IbO+88w5mzJiByy67DBqNBqNGjcILL7xQ+7zL5cLevXu9+hAsXrwYjz76aO1/X3TRRQCAN95444xD8euShOB4xVDLOXEU16x9HXEugT+1y8S9fS5r8jmE4zuIsseRGF8Jg7EVpORVkDRnnotBFApCCJRWOaqL7t+bthWc9m+VO7ghYxaTEemJCUi3Jnr+tXiGqNf8nG5JRJyKzY6uvPJK7N69u/Yb0WCVlZWhd+/eyM7OxqpVq0IQYXiVlZXBarXij+f8HTqtKaBzuOUqfP3TUygtLfVrPlmNl19+Gc8++ywKCgrQt29fvPjii7XfWDfmvffew7hx43D11Vfjk08+8Xpu9+7duP/++/Htt9/C7XYjOzsbK1euRMeOHZv6sogihpALII5fhDK7GS6cD03Sk00+x96t+zFvwvNw2d0w6A14LXchUs5qE4ZoiepnL6+sHaJ+/Fgpjhd43xk/fuwUqiqcQV3DHG/0Kr5rhqbXvVselxDYZ12otOS8Q82cI9LxDnsYZFhSoJEkKJIIqPGcUOwQtkUw6N0w6N2QLHNYrFPICCFQ7nDgWKlnGbOCsnIcK7WhsNy7MK90BVeMJxgNtXfA255+hzwxAWmWRCQYI3uKx6JFi9C7d2/MmjULS5cuDepcQgjcfffdKCkpwaJFi0IUYTMRCGI+WdMPef/99zFr1iwsXrwYgwYNwsKFCzFs2DDs3bvXZ1mVuvLz83HPPffgwgsv9Hlu//79uOCCCzB58mQ8+uijsFgs2LVrF0wmdZMzoqBp0gDJCp2mCi5XfpMPdzpdePPB9yDcArJDwU3PjmexTiFlL6/yKb5PnzNeaQ9uuTFTnMFnaLrXnfG2VsQnmkP0isKHeQeaPeeIBizYw8Cs06NzQmscPlWMfNsJuBUFukYaQZxO2F+HJIoRb64CjJcAxuHhC5ZiTnn1nfFjZdVFeGndnz1FeoUzuCFjcQY92tYZku5TkFsSkBADS4d06dIFCxcuxNSpU9GpUyfMmTMnoPMIIfDEE09g2bJlWLZsGbp06RLiSMOsmZvOLViwAFOnTq1tvLN48WJ88cUXeP311/H3v/+93mNkWcaECRPw6KOP4rvvvsOpU6e8nv/HP/6BP/3pT3jmmWdqH+vWrVuTYyOKNJIkQegyodVuAxzFEEopJI3V7+O/XLIWxw4Uwml3I2vQ2Rgx7YowRkuxptLu8Flb/PSh6hW2qqCuYTTrfYalnz5UPT7RFBNLHjPvABvd1oMFe5h0t6biYGkxnG4ZRytK0TGhlV/HCecuoOr/EGd2QKM1Q7I8HBN/gCg0bA5nvfPEfx+6boPdGdyQsTi9/rSmbQk+c8gTTdFfjPtrypQpKCwsxJw5c3Dw4EEsWLCgScPUysrKcPfdd2PZsmWYO3cuJk+eHMZoI1dZWZnXfxuNxnrXRXU6nfjxxx8xe/bs2sc0Gg2GDh2KjRs3Nnj+xx57DKmpqZg8eTK+++47r+cURcEXX3yB++67D8OGDcNPP/2ELl26YPbs2Rg5cmRwL4woEui7Q6fd6vnZnQ8Y+vp12NEDhfji1a/grpShkTS469VboNVqwxcnRZWqCmd1N/W6d8ZLve6W28oqg7qGwairvgPuO1S95t8Eq7lF5cLMO+h0LNjDJMuaiv9IuQCAA+UlfhXsQjgh7M9Dp3XDZHRBSrgXkrZ9uEOlCGF3Or3mh/sW5DaUO4IcMqbTVc8TT0B6YqLPz+mWBFhMxhb1weiPf/zjH0hLS8PMmTPx1VdfYd68eRg9enS9XVxr1HRlnT17NkpKSrBs2bLo/dBUgIA7WVV3eu3QoYPXww8//DAeeeQRn92Li4shyzLS0tK8Hk9LS8OePXvqvcSGDRvw2muvYfv27fU+X1RUBJvNhqeeegpPPPEEnn76aaxevRp//etf8c033+Diiy9u8ssiiiSSLhMajeL5/6k7z6+CXVEUvPXge3BWueGulHHt/SPRtU+n8AdLEaGq0lnbNb1uJ/W6xbmtNLhiXG/Q1bkL/vt88bp3xhOT4phz1KNF5x0hyDliDQv2MMlMSoWQJAhJIK+sGJe0bbh7Y62KFYA7H/GJVYCuFxB3ffgDpWZR6XLhWKn3UmanN3MrqwquGDfqtNVD1KvviicmIt1aM2c8EenWRFhZjAdsypQpuOyyyzB9+nRMmDABd911F0aNGoUBAwagZ8+eMJvNqKysxK5du7B169barqzDhw/HokWLoms42mkkISAFOMys5rhDhw55NYCp7+56IMrLy3H99ddj6dKlSE5OrncfRfF8gl999dW46667AAD9+vXD999/j8WLF7Ngp+iny4IkAVqNAlk+4Feu+92Kzdi7dT9cNjfadk3DdQ+NDnuY1DycDheKj/muLe751/Nz2cmKM5+oETq91muIuvd8cc/P1tbxzDmC0FLzjlDkHLGGBXuYZFk9jZFkCThgO3PjOeE+DFHxDsxGJ3RaCZL1CUgSh6VFgyqXu7b4Lqy+M167znh1kX6qMrj5WwattnaIes2w9JrCvObnVubYmL8Vybp06YJVq1YhNzcXixcvxtq1a7F48WLUXWxDkiRkZWVh7NixmDZtGnr06KFixCESgvlkFovFr46tycnJ0Gq1KCws9Hq8sLAQ6enpPvvv378f+fn5GDFiRO1jNQW6TqfD3r170aFDB+h0OmRnZ3sd26NHD2zYsKHJL4ko4ugyAEjQaWXI7rwz7l5aXIYPnv0EskOB4ha485WpMJpbzlSnaOZ0uGuL7uJ6hqofP3YKZSftQV1Dp9eiTZrFe6h6zRD16rnjllZx0DShPxMFpkXmHZzD7oMFe5i0j09CvM4At9uBvPKSRvf1rLn+AjQaB8wmBxA3GZI+u9FjqHk43G6vu+GF9aw3Hmwxrq8pxhMTTmvc9vvPreJa1vytSJednV279qbNZsO+ffvgcDhgNBqRkZGBhIQElSMMsWb88DQYDOjfvz/WrVtXO79cURSsW7cOM2bM8Nk/KysLOTk5Xo/NmTMH5eXleP7559GhQwcYDAYMHDgQe/fu9drvl19+QadOHAJM0U/SxENoO0KrPQa4DkIIudEv/Zc/+RHspZVwVbgx9PqL0P9y/+a8U3i5nG6UFJb53BmvO1T9VIktqGtodRq0SbM2OlQ9qU0Ci/EI06LyDhbsPliwh4lGktDdmoqdjkMoqCiH3elAvKGBb6+r1gCu7UiIr4KkbQ8p4fbmDbaFcrrd1UPUf2/a9vvccc9jJyqCnL+l0SC1zlJmXgV59XrjrePjoGExHrUSEhLQr18/tcOIKbNmzcINN9yAAQMG4LzzzsPChQtht9tru8ZPnDgR7du3x7x582AymdCrVy+v45OSkgDA6/F7770XY8eOxUUXXYRLL70Uq1evxueff47169c318siCi9dd+g0hwFRBcjHAN1Z9e7287e52PzFNrjsblhaJ+KW+RObOdCWye2SUVJU5tNJvW5RfrI4uGJco9WgTaql9k746UPVU9omwdomAVoti/Foxryj5WHBHkZZ1lTsOH4IcpUDX235Hh1NFhgMBnTp0qX2mzChnIKwL4HR4IJeL0OyPgJJE6dy5NHPKcsoKrfVrjHuWW/cM0S95ucSe5DztzQapCbGV3dSr7O8WWIC0q2ex9qwGKdY0Mzfdo8dOxbHjx/HQw89hIKCAvTr1w+rV6+ubUT322+/NfnuzzXXXIPFixdj3rx5uOOOO5CZmYmVK1figgsuaHJ8RBFJlwmtdi1sdhn5v30NF3r65BxVFQ7869EPoLgUyE4Ft8yfiKQU/5eAo/rJbk8xXl8RXjNU/eTxcq9hzE2l0UhonWrxKr5PX96sVUoii3GKfrzD7kMSwfz1oAbl5uZi5lOP4X/frEfFkSKvN5AkScjIyMAll1yCiaNdyOq0A0mJdmji/gxN0gIVo44OLllGUbnde4h6eTkKSm3Vc8fLUWyrQDBvbK0kITUxoc7SZr8X5DU/J8fHQcshYxTDysrKYLVacVnm3dBpA5vf6pYdWLf3OZSWlvo1h52Imi43NxevvDQba9euxd59FV45a92cI9XVATs+3wPHKSf6XtILz6x5iNOtzkB2yzhxvLxO8e09X7y44BROHi+HogSedUiShNapidVLmXkPVa+5W946JRFaHXsbUexiztEw3mEPsby8PEyfPh2rV69GSmoqbhg1CgMHDkR2djbi4uJQUVGB3NxcbNmyBStXrsDSpcdx+SWJeOXpTuja/wG1w1edW1FwvLoYr295s2Nl5Si22YMqxjWShJSE+Op54vUX5MkJLMaJarBjK1FkqptzpKamYtSoG3Df7PpzjhUrVuL48SKk6tuhh7Y/7nzl5hZfrMuygpPHy38vvusZqn7ieDkUOfC1oiRJQquUxN+L8NOGqCenW9E6xQKdnsU4EcCcoz68wx5Cy5Ytw8yZM5GcnIwnn3zyjOslOp1OrFixArNn34eSkhIsXPgipkyZ0owRNy9ZUXDcZq+3CK/5+bjNDiWIt6QEICUxHumJ1UubWauXNLMkoG31zymJ8dCxGCc6o5pvu4d2nxXUt91rf1kQc992E6kt0JzjvnvvQ0nJCbz40gsxnXMoioJTxTav4vv0oeolRWVBFeMA0Co5od4ivGaoeuuUROgNvD9GdCbMORrGvyAhMnfuXMyZMwdTpkzBggULkJiYeMZjDAYDxo8fjxEjRuCuu+7C1KlTUVhYiH/84x/NEHFoyYqCYntF9ZzxchSU22qL8JoO68fL7ZCDLMaTE+I8jdt81hj3/JySEA+9lt9SE4UU55MRRZSWnnMoioJTJbY6d8Z9h6qXFJZCdgdXjCe1SfBZW7xuE7c2aRYW40ShxpzDB//KhMCyZcswZ84cPP7445gzZ47XczabDc8++yw2b96MH374ASdPnsQbb7yBG2+8sXafxMRELFu2DJ06dcKcOXOQnp6OyZMnN/OraJgiBIptdk8RXlpePWfc83NNYV5UbodbCe6DMTk+zmeeeN1h66mJCTCwGCdqfooApAA/BIOY10lEvmI95xBCoPSEvXaI+vFjpTh+2rrjxQWlcLvkoK5jaRXvNV+87p3x5HQrktOtMBj1IXpVROQ35hw+WLAHKS8vDzNnzsSUKVN8PjgBoLi4GI899hg6duyIvn37NrqE0Jw5c/Dbb7/hzjvvxB//+Ed06dIljJF7KELghL3Caykz7/XGbSgstwVdjLeOM59WhNddbzwBaYkJMOj4diSKSPy2mygiRHvOUVOMn762+On/Bl+Mx1UX3dXri3s1c0tCm3QrjCYW40QRiTmHD1ZIQZo+fTqSk5OxYEH93d3btm2LY8eOIT09HVu3bsXAgQMbPJckSXjuuefw1VdfYfr06Vi1alVQsQkhcKKisroI/32t8WNlNhTWFObldrjk4D4YW8WZa9cYb2v1XW88zZIAI4txIiKioER6zlF+qsK7+D5tqHpxwSk4He6grpNgNXsV36cPVU9Ot8JkbnguPxFRtGEVFYTc3FysXr0a77zzToPzx4xGI9LT0/0+p8Viwbx58zBhwgTs3r0bPXr0qHc/IQROVlZVD0uvLsjrrDFeM3/cGWQxnmQ21RbfNd3Ua9YZrynMTXq+jYhiWxDfdge1pgMR1VA757CVVtYpvquHqh/zHqruqHIF9NpqJFjMXsPS6w5V9/ybBFMci3Gi2Mac43SstIKwePFipKamYvTo0SE976hRo3DXXXfhyecW4Kb7ZnutMf57M7dyONzBFeNWkxFpNUV4bUFec3c8EWmJCYgzcMgYUYvH4WlEqgt3zvH0k/Nx25R7T+uk/vvdckdlcMV4XIKpem1xq08n9Zo743EJphC9KiKKWsw5fLBgD8KaNWswatSoRpdRCYTRaMSoUaPw1kef4IdO2QGdI9FoRFtLQnVBnlBbmNf8nG5JQHyI4yaiGKUIBPytdYw2gCFqbuHOOZa/tQKFG1sHdA5zvNGng/rpTdziE1mME5EfmHP4YMEeoPLycuzduxf33XdfWM4/YMAAvLJ4MRSHAxqj91qE8QaD1xrjp/+cZklEgpHFOBERUSxojpxj8SuL4Vac0Gm88wdTnMGn+PY0cau5Q+65My5JUlhiIyJq6ViwB2j//v0QQiA7O7A74GfSs2dPQAhc0zkdA/v3r157PAFtrYlIOK2AJyIKK6F4tkCPJaKgNEfOISBw0V+7o3//c72GqidYzCzGiaj5MOfwwYI9QA6HAwAQFxcXlvObzWYAwKjePTDonN5huQYRkV84n4xIVc2Vc1wxZgAGDRoUlmsQEfmFOYcPFuwBMlbf5a6oqAjL+SsrK72uQ0SkGs4nI1IVcw4iajGYc/jQqB1AtMrIyIAkScjNzQ3L+Xft2gVJkpCRkRGW8xMREVF0YM5BRNRy8Q57gBISEpCZmYktW7Zg0qRJje770ksv4dSpUzh69CgA4PPPP8fhw4cBALfffjusVqvPMVu3bkVWVhYSEhJCHzwRUVNweBqRqphzEFGLwZzDhyREjL6yZnDHHXfg/fffx6FDhxpdZqVz5844ePBgvc/l5eWhc+fOXo85HA507NgRY8eOxQsvvBDKkImI/FZWVgar1YqhbW/x6RztL7fixNpjr6K0tBQWiyXEERK1HMw5iCiWMedoGIfEB+HWW29FUVERVqxY0eh++fn5EELUu53+wQkAK1euRFFREaZNmxamyImImqDm2+5ANyIKGnMOImoRmHP4YMEehOzsbAwfPhwPPPAAysvLQ3LOsrIyzJ49G8OHD0ePHj1Cck4ioqAoSnAbEQWNOQcRtQjMOXywYA/SokWLUFxcjFmzZgV9LiEE7r77bpSUlGDRokUhiI6IiIhiBXMOIqKWhwV7kLp06YKFCxdi2bJleOKJJwI+jxACTzzxBJYtW4bnn38eXbp0CWGURERB4PA0oojAnIOIYh5zDh/sEh8CU6ZMQWFhIebMmYODBw9iwYIFSExM9Pv4srIy3H333Vi2bBnmzp2LyZMnhzFaIqImYsdWoojBnIOIYhpzDh+8wx4i//jHP7B06VK8++676NWrF5YvXw6n09noMQ6HA8uXL0fv3r3x7rvvYtmyZXjggQeaKWIiIj8pIriNiEKKOQcRxSzmHD64rFuI5eXlYfr06Vi9ejVSU1MxatQoDBgwAD179oTZbEZlZSV27dqFrVu31nZmHT58OBYtWsQhaUQUUWqXWGk9KbglVk68EXNLrBBFAuYcRBQrmHM0jAV7mOTm5mLx4sVYu3Yt9uzZg7q/ZkmSkJWVhaFDh2LatGnszEpEEanmw/OyVjcE9eG57uRbMffhSRRJmHMQUbRjztEwzmEPk+zsbLzwwgsAAJvNhn379sHhcMBoNCIjIwMJCQkqR0hE5CcRxDAzfidMFHbMOYgoZjDn8ME57M0gISEB/fr1w6BBg9CvXz9+cBJRdGHHVqKowZyDiKJahOYcJ06cwIQJE2CxWJCUlITJkyfDZrM1uv/tt9+OzMxMmM1mdOzYEXfccQdKS0ubfG0W7EREREREREQNmDBhAnbt2oU1a9bg//7v//Df//4XN998c4P7Hz16FEePHsX8+fOxc+dOvPnmm1i9enVAK3NwSDwRETVOUQBJCexYEeBxRERE1PJEYM6xe/durF69Glu2bMGAAQMAAC+++CL+9Kc/Yf78+WjXrp3PMb169cLKlStr/7tbt26YO3currvuOrjdbuh0/pfhvMNORESNi9DhaURERBRjQpBzlJWVeW0OhyOokDZu3IikpKTaYh0Ahg4dCo1Gg82bN/t9nppmeE0p1gEW7EREdAZCUYLaiIiIiPwRipyjQ4cOsFqttdu8efOCiqmgoACpqalej+l0OrRu3RoFBQV+naO4uBiPP/54o8PoG8Ih8URERERERBQTDh065LWsm9ForHe/v//973j66acbPdfu3buDjqesrAx//vOfkZ2djUceeaTJx7NgJyKixgkBgEusEBERUZiFIOewWCx+rcN+991348Ybb2x0n65duyI9PR1FRUVej7vdbpw4cQLp6emNHl9eXo7hw4cjMTERH3/8MfR6/RnjOh0LdiIiapwiAIkFOxEREYVZM+YcKSkpSElJOeN+gwcPxqlTp/Djjz+if//+AICvv/4aiqJg0KBBDR5XVlaGYcOGwWg04rPPPoPJZGpSfDU4h52IiBonhKfzakAbC3YiIiLyUwTmHD169MDw4cMxdepU/PDDD/jf//6HGTNm4Nprr63tEH/kyBFkZWXhhx9+AOAp1q+44grY7Xa89tprKCsrQ0FBAQoKCiDLcpOuzzvsRERERERERA145513MGPGDFx22WXQaDQYNWoUXnjhhdrnXS4X9u7di4qKCgDAtm3bajvIZ2RkeJ0rLy8PnTt39vvaLNiJiKhRQhEQAQ5PE7zDTkRERH6K1JyjdevWWL58eYPPd+7c2ev6l1xyScjiYcFORESNEwqAAJdnE1zWjYiIiPzEnMMHC3YiImpUpH7bTURERLGFOYcvFuxERNQ4fttNREREzYE5hw8W7ERE1Cg3XAEvieqGK7TBEBERUcxizuGLBTsREdXLYDAgPT0dGwq+DOo86enpMBgMIYqKiIiIYg1zjoZJIlYH+xMRUdCqqqrgdDqDOofBYIDJZApRRERERBSLmHPUjwU7ERERERERUQTSqB0AEREREREREfliwU5EREREREQUgViwExEREREREUUgFuxEREREREREEYgFOxEREREREVEEYsFOREREREREFIFYsBMRERERERFFIBbsRERERERERBGIBTsRERERERFRBGLBTkRERERERBSBWLATERERERERRSAW7EREREREREQRiAU7ERERERERUQRiwU5EREREREQUgViwExEREREREUUgFuxEREREREREEYgFOxEREREREVEEYsFOREREREREFIFYsBMRERERERFFIBbsRERERERERBGIBTsRERERERFRBGLBTkRERERERBSBWLATERERERERRSAW7EREREREREQRiAU7ERERERERUQRiwU5EREREREQUgViwExEREREREUUgFuxEREREREREEYgFOxEREREREVEEYsFOREREREREFIFYsBMRERERERFFIBbsRERERERERBGIBTsRERERERFRBGLBTkRERERERBSBWLATERERERERRSAW7EREREREREQRiAU7ERERERERUQRiwU5EREREREQUgViwExEREREREUUgFuxEREREREREEYgFOxEREREREVEEYsFOREREREREFIFYsIfBm2++CUmSkJ+fr3YoYWGz2aDRaPDPf/5T1TieeeYZZGVlQVGUZr3u4sWL0bFjRzgcDr+P2bJlC4YMGYL4+HhIkoTt27eHL8AmiLT36iOPPAJJktQOg4iI6hGKz4xIyCHUyh8aEit5RaTlFADzCooNMV+wX3XVVYiLi0N5eXmD+0yYMAEGgwElJSXNGFn02rlzJ4QQ6NWrl2oxlJWV4emnn8b9998PjaZ538Y33ngjnE4nXn31Vb/2d7lcGDNmDE6cOIF//vOfePvtt9GpU6cwR0lERJGmpqDZunWr1+OlpaU477zzYDKZsHr1apWiax5q5xCN5Q8OhwP3338/2rVrB7PZjEGDBmHNmjVhj4l5BRE1JuYL9gkTJqCyshIff/xxvc9XVFTg008/xfDhw9GmTZuQXPP6669HZWVlzP7xzMnJAQD07t1btRhef/11uN1ujBs3rtmvbTKZcMMNN2DBggUQQpxx//379+PgwYO45557cPPNN+O6665Dq1atmiHSM4v19yoRUaQrKyvDFVdcgZ9//hkff/wxhg8frnZIYaV2DtFY/nDjjTdiwYIFmDBhAp5//nlotVr86U9/woYNG8IaU6zkFcwpiMIj5gv2q666ComJiVi+fHm9z3/66aew2+2YMGFC0Ney2+0AAK1WC5PJFLNDcHJycpCcnIz09HTVYnjjjTdw1VVXwWQyqXL9v/3tbzh48CC++eabM+5bVFQEAEhKSgrZ9Wvea8GK9fcqEVEkKy8vx7Bhw7B9+3asXLkSV155ZUjOG6rPiHBQO4doKH/44Ycf8N5772HevHl49tlncfPNN+Prr79Gp06dcN9994U9rljIK5hTEIVHzBfsZrMZf/3rX7Fu3braP3B1LV++HImJibjqqqsAAAcPHsT06dORmZkJs9mMNm3aYMyYMT7zcWrmxOTm5mL8+PFo1aoVLrjgAgD1z+Fp6nn37duHG2+8EUlJSbBarZg0aRIqKiq89j1y5AgmT56Mdu3awWg0okuXLpg2bRqcTqfXPjfddBPS0tJgNBrRs2dPvP766/X+rvbs2YPffvvtjL/TnJwc9OzZ0+uxpUuXwmAwYObMmZBl+YznCEZeXh5+/vlnDB06NKzXaUz//v3RunVrfPrpp43ud+ONN+Liiy8GAIwZMwaSJOGSSy6pff6nn37ClVdeCYvFgoSEBFx22WXYtGmT1zkae68F6/T3alPefw3x9z23YcMGDBw4ECaTCd26dWt0KOD69esxYMAAr33rm5fm77XLy8sxc+ZMdO7cGUajEampqbj88suxbds2v14jEVGwbDYbhg8fjm3btmHlypX485//7PW8v3/PGvqMaOrf86bkC6fzN38A1M0hGssfVqxYAa1Wi5tvvrn2MZPJhMmTJ2Pjxo04dOhQ2OICQpNX+JNTAOHLK+rLfyMxr/A3p/D32swpKNx0agfQHCZMmIC33noLH3zwAWbMmFH7+IkTJ/Cf//wH48aNg9lsBuBp4vH999/j2muvxVlnnYX8/Hy88soruOSSS5Cbm4u4uDivc48ZMwZnn302nnzyyUaHMTX1vH/729/QpUsXzJs3D9u2bcOyZcuQmpqKp59+GgBw9OhRnHfeeTh16hRuvvlmZGVl4ciRI1ixYgUqKipgMBhQWFiI888/H5IkYcaMGUhJScGqVaswefJklJWVYebMmV7X7NGjBy6++GKsX7++0d9nTk5O7VAyt9uNmTNnYsmSJXj55ZcxderURo8Nhe+//x4AcO6554b9Wo0599xz8b///a/RfW655Ra0b98eTz75JO644w4MHDgQaWlpAIBdu3bhwgsvhMViwX333Qe9Xo9XX30Vl1xyCb799lsMGjTI61z+vtdC4Uzvv4b4+57LycnBFVdcgZSUFDzyyCNwu914+OGHa383df30008YPnw42rZti0cffRSyLOOxxx5DSkpKQNcGgFtvvRUrVqzAjBkzkJ2djZKSEmzYsAG7d+9W/X1FRLHPbrfjyiuvxJYtW7BixQr85S9/8Xq+qZ/fgO9nRM1NCn/+ngdyvbr8zR8AdXOIxvKHn376Cd27d4fFYvF6/LzzzgMAbN++HR06dAhrfMHkFU3NKYCWmVf4m1M05drMKSjsRAvgdrtF27ZtxeDBg70eX7x4sQAg/vOf/9Q+VlFR4XP8xo0bBQDxr3/9q/axhx9+WAAQ48aN89n/jTfeEABEXl5ewOe96aabvPa95pprRJs2bWr/e+LEiUKj0YgtW7b4nFdRFCGEEJMnTxZt27YVxcXFXs9fe+21wmq1+sQEQFx88cU+56vr6NGjAoBYvHixKCkpEX/84x9F69atxTfffNPocaE0Z84cAUCUl5c32zXrc/PNNwuz2XzG/b755hsBQHz44Ydej48cOVIYDAaxf//+2seOHj0qEhMTxUUXXVT7WGPvtWCd/l719/3XEH/fcyNHjhQmk0kcPHiwdp/c3Fyh1WrF6X+WRowYIeLi4sSRI0dqH/v111+FTqfz2rcp73er1Spuu+22M74eIqJQqvmb26lTJ6HX68Unn3xS735N+XvW0GdEU/6e+3u9+vIbIfzLH4RQP4doLH/o2bOn+OMf/+jz+K5du2pjDrdg8gp/cwohwpdX1Pf+iLS8wt+coinXZk5B4RbzQ+IBz5yaa6+9Fhs3bvQaprN8+XKkpaXhsssuq32s5k474OnCWVJSgoyMDCQlJdU7tOXWW2/1K4Zgz3vhhReipKQEZWVlUBQFn3zyCUaMGIEBAwb4HCtJEoQQWLlyJUaMGAEhBIqLi2u3YcOGobS01Oe6Qogzfjv+888/115j4MCBOHr0KDZv3uw1zDvcSkpKoNPpkJCQ4PPcpk2bIEkSHnnkkYDP7+85WrVqhcrKSr+HdNUlyzK++uorjBw5El27dq19vG3bthg/fjw2bNiAsrIyr2P8fa+F4nfQ2PuvIf6+52RZxn/+8x+MHDkSHTt2rD2+R48eGDZsmNc5ZVnG2rVrMXLkSLRr16728YyMDK+5nk19vyclJWHz5s04evRowL8jIqJAFRYWwmQy1XvHNpDPb6Dhz4gz/T0P9Hqnx+zP3XW1c4jG8ofKykoYjUafx2vmuldWVgZ0zaZ8JgeaVwSSUwAtL6/wN6doyrUB5hQUfi2iYAdQ21Supvnc4cOH8d133+Haa6+FVqut3a+yshIPPfQQOnToAKPRiOTkZKSkpODUqVMoLS31OW+XLl38un5Tz1v3Dw6A2u6fJ0+exPHjx1FWVtbokijHjx/HqVOnsGTJEqSkpHhtkyZNAoB65/SfSU131xkzZiAtLQ0bN25ERkZGk88TC0T18LFAmqscP34cFRUVyMzM9HmuR48eUBTFZ76cv++1UGjs/dcQf99zx48fR2VlJc4++2yfc5z++ygqKkJlZWW977G6jzX1/f7MM89g586d6NChA8477zw88sgjOHDgwJl+LUREIfHqq6/CYDBg+PDh2Lt3r9dzgX5+N/QZcaa/5+HKF+oTyTmE2Wyudx30qqqq2ufDLdC8IpCcAmh5eYW/OUVTrg0wp6DwaxFz2AFPM4+srCy8++67eOCBB/Duu+9CCOHTHf7222/HG2+8gZkzZ2Lw4MGwWq2QJAnXXnstFEXxOa+/f8Cbet66XyLUVfPH/ExqznndddfhhhtuqHefPn36+HWuunJyctCpUyd069YNO3fuhM1mC2mXUn+0adMGbrcb5eXlSExM9Hru3HPPxaFDh3zmoDWFv+c4efIk4uLimuVDHPD/vRaK30Eg7z9/33P1vd+D1dT3+9/+9jdceOGF+Pjjj/HVV1/h2WefxdNPP42PPvooZF2aiYgakp2djS+//BKXXXYZLr/8cvzvf/+rvdse6Od3Q58RZ/p7Hq58oT5q5xCN5Q9t27bFkSNHfI45duwYAHjdkW2KpnwmM6/wFi15BXMKCrcWU7ADnrvsDz74IH7++WcsX74cZ599NgYOHOi1z4oVK3DDDTfgueeeq32sqqoKp06dCuraoTxvSkoKLBYLdu7c2eg+iYmJkGU5pN3Uc3Jy0K9fPyxduhQDBgzANddcg++++y7ky6u99tpr+Oyzz/Dpp59iz549GDNmDJ599lkMHz4cWVlZADzdXk9PIgwGA84666ygru3vOfLy8tCjR4+ArpGSkoK4uDifOyuAp9uuRqMJuLlNKH4HgfD3PSfLMsxmM3799Vef507/faSmpsJkMmHfvn0++9Z9LJD3e9u2bTF9+nRMnz4dRUVFOPfcczF37lx+uBJRszjvvPPwySef4M9//jMuv/xyfPfdd7V38MLx+d2Q5rxec+QQgeYP/fr1wzfffIOysjKvwnTz5s21zweiKZ/JgeYV4cwpgNjJK/zNKZpy7RrMKSicWsyQeOD3YfEPPfQQtm/fXu/a61qt1ufbvhdffDHoZUZCeV6NRoORI0fi888/x9atW32eF0JAq9Vi1KhRWLlyZb2F/fHjx30eO9OyLLIsY/fu3ejduzdSUlLw0UcfYefOnZg2bZrPvoWFhbjqqqswdOhQ5Ofn44MPPsCgQYMwe/Zsv15jTk4O+vTpg++//x6jRo3Cm2++ieHDhwMABg8eDAD1vvbmtG3bNgwZMiSgY7VaLa644gp8+umnXn0VCgsLsXz5clxwwQVBfZOtBn/fc1qtFsOGDcMnn3zi9X7bvXs3/vOf//icc+jQofjkk0+85obt27cPq1atavK1Ac/7+PRpKKmpqWjXrl29wyGJiMLlsssuw7vvvot9+/Zh+PDhKCsrC+jzOxihuJ4/y7r5m0OolT+MHj0asixjyZIltY85HA688cYbGDRoUNg7xAOB5xWxmFMAoc8r/M0pmnJt5hTUHFrUHfYuXbpgyJAhtWtc1lew/+Uvf8Hbb78Nq9WK7OxsbNy4EWvXrkWbNm2Cunaoz/vkk0/iq6++wsUXX4ybb74ZPXr0wLFjx/Dhhx9iw4YNSEpKwlNPPYVvvvkGgwYNwtSpU5GdnY0TJ05g27ZtWLt2LU6cOOF1zjMty/Lrr7+iqqoKvXv3BuCZZvDKK69g0qRJ6N+/v9eSec899xyeeuopVFZWYsKECUhMTMS6deuwbNkyrFu3zqvRX31ycnKQnp6Oq6++Gps3b/ZqotK1a1f06tULa9euxU033eTX70uSJL+XnPHHjz/+iBMnTuDqq68O+BxPPPEE1qxZgwsuuADTp0+HTqfDq6++CofDgWeeeSYkcTY3f99zjz76KFavXo0LL7wQ06dPh9vtxosvvoiePXvWNiWq8cgjj+Crr77CH/7wB0ybNg2yLOOll15Cr169sH379iZfu7y8HGeddRZGjx6Nvn37IiEhAWvXrsWWLVu8RsAQETWHa665BkuXLsVNN92Eq666CqtXr27y53ewgr2eP8u6+ZtDqJU/DBo0CGPGjMHs2bNRVFSEjIwMvPXWW8jPz8drr73mtW+ocwog+LwiFnMKIPR5hb85hb/XZk5BzaK52tFHipdfflkAEOedd169z588eVJMmjRJJCcni4SEBDFs2DCxZ88e0alTJ3HDDTfU7lezTMXx48d9zlHfshbBnre+cx48eFBMnDhRpKSkCKPRKLp27Spuu+024XA4avcpLCwUt912m+jQoYPQ6/UiPT1dXHbZZWLJkiU+ceMMy7J88MEHAoDYtWuX1+PTp08Xer1efPvtt7WPzZgxo/bnG264QXzwwQdCCCF2794tXn755QavUSMlJUVceOGFwmq1ep23xoIFC0RCQkK9y+Wdrry8XAAQ11577Rn39df9998vOnbsWLuEXmMaWtZNCCG2bdsmhg0bJhISEkRcXJy49NJLxffff++1T2PvtWA1tKybP++/hvj7nvv2229F//79hcFgEF27dhWLFy+uvf7p1q1bJ8455xxhMBhEt27dxLJly8Tdd98tTCZTk6/tcDjEvffeK/r27SsSExNFfHy86Nu3r1i0aJGfvzUiosDU/C2tb0nW+fPnCwDiL3/5i3C5XH7/LW3o73ZT/577c71glnXzN4dQM3+orKwU99xzj0hPTxdGo1EMHDhQrF692mufcOQUQoQmr/AnpxAifHlFY8u6RVJe4W9O4c+1mVNQc5CE8LOLGVETzJ49G6NGjYLBYMDdd98Nu92OTz/9FK+//joGDx6Miy66qMFjCwsL0blzZ5w6dQqPPfYYfvjhB6xZs8Zrn9LSUnTt2hXPPPMMJk+e3GgsX375Jf7yl79gx44dtd/sB8PhcKBz5874+9//jjvvvDPo81FgRo4ciV27dtU7Z42IiKJTJOUP9Ql1TgEwr4gEzCkokrWoOezUfO677z48//zzmDNnDpYsWYJHHnkEY8aMQWVlpdeH7Y033ogbb7zR69icnBz06NEDRqMRM2fOxPfff49NmzZ57WO1WnHffffh2WefPWN30G+++QbXXnttyD5Y33jjDej1er/XL6Xgnb7+7a+//oovv/yy2dbuJSKi5hFJ+UN9Qp1TAMwrmhtzCoo2vMNOqho6dCjGjh2LqVOn1j72z3/+Ez/99BP+9a9/AQDuvPNO7Nu3D1988YVaYZLK2rZtixtvvBFdu3bFwYMH8corr8DhcOCnn36qd91VIiKKbcwfKFDMKSjasGAn1bjdbvTp0wc7duyAXq9XOxyKYJMmTcI333yDgoICGI1GDB48GE8++STOPfdctUMjIqJmxvyBgsGcgqINC3YiIiIiIiKiCMQ57EREREREREQRiAU7ERERERERUQTSqR0AERFFrqqqKjidzqDOYTAYYDKZQhQRERERxSLmHPVjwU5ERPWqqqpCl04JKCiSgzpPeno68vLyYu4DlIiIiEKDOUfDWLATEVG9nE4nCopk5P3YCZbEwGZQlZUr6NL/IJxOZ0x9eBIREVHoMOdoGAt2IiJqlCVRE/CHJxEREZG/mHP4YsFORESNkoUCOcAFQGWhhDYYIiIiilnMOXyxYCciokYpEFAQ2KdnoMcRERFRy8OcwxcLdiIiapQCBYF+Zx34kURERNTSMOfwxQkCRERERERERBGId9iJiKhRshCQRWDDzAI9joiIiFoe5hy+WLATEVGjOJ+MiIiImgNzDl8s2ImIqFEKBGR+eBIREVGYMefwxYKdiIgaxW+7iYiIqDkw5/DFpnNEREREREREEYh32ImIqFFsAENERETNgTmHLxbsRETUKKV6C/RYIiIiIn8w5/DFgp2IiBolB9EAJtDjiIiIqOVhzuGLc9iJiIiIiIiIIlBE32G32WzYt28fHA4HjEYjMjIykJCQoHZYREQtiiw8W6DHEkUD5hxEROpjzuEr4gr23NxcLF68GGvWrMHevXsh6jQPkCQJmZmZuPzyy3HrrbciOztbxUiJiFoGziejWMWcg4gosjDn8BUxQ+Lz8vJw5ZVXomfPnnj//fdx6aWX4rXXXsOmTZvw888/Y9OmTXjttddw6aWX4v3330fPnj1x5ZVXIi8vT+3QiYhimgIJcoCbAknt8Il8MOcgIopMzDl8SUKo3/9+2bJlmDlzJpKTk/Hkk09i9OjRMBgMDe7vdDqxYsUKzJ49GyUlJVi4cCGmTJnSjBETEcW+srIyWK1WbMtNQ0JiYN/v2soVnJtdiNLSUlgslhBHSNR0zDmIiCIPc46GqX6Hfe7cuZg6dSrGjRuHnJwcjB8/vtEPTgAwGAwYP348du7ciXHjxmHq1KmYO3duM0VMRNSyKCK4jShSMOcgIopszDl8qTqHfdmyZZgzZw4ef/xxzJkzp8nHJyYmYunSpejYsSPmzJmD9PR0TJ48OQyREhG1XDVDzQI9ligSMOcgIop8zDl8qXaHPS8vDzNnzsSUKVN8Pji3bNmCGTNmoGfPnoiPj0fHjh3xt7/9Db/88ku955ozZw6mTJmCO++8k/PLiIhCLNC5ZMF86BKFEnMOIqLowJzDl2pz2K+88krs3r0bOTk5SExM9Hpu9OjR+N///ocxY8agT58+KCgowEsvvQSbzYZNmzahV69ePucrKytD7969kZ2djVWrVjXXyyAiilk188m+39U2qPlkQ3oei7n5ZBRdmHMQEUU25hwNU6Vgz83NRc+ePfHOO+9g/PjxPs9///33GDBggNe8sl9//RW9e/fG6NGj8e9//7ve8y5fvhwTJkxAbm4uevToEbb4iYhagpoPzw072wX14XlBr6Mx9+FJ0YM5BxFR5GPO0TBVhsQvXrwYqampGD16dL3PDxkyxKcJzNlnn42ePXti9+7dDZ531KhRSE1NxSuvvBLSeImIWjIOT6NoxpyDiCh6MOfwpUrBvmbNGowaNeqMnVnrEkKgsLAQycnJDe5jNBoxatQorF27NhRhEhERABmaoDYiNTHnICKKHsw5fDX7qyovL8fevXsxcODAJh33zjvv4MiRIxg7dmyj+w0YMAB79uyBzWYLJkwiIiKKcsw5iIgo2jV7wb5//34IIZCdne33MXv27MFtt92GwYMH44Ybbmh03549e0IIgX379gUbKhERARBCghLgJkRsDk+j6MCcg4goujDn8NXs67A7HA4AQFxcnF/7FxQU4M9//jOsVitWrFgBrVbb6P5ms9nrOkREFByuiUrRijkHEVF0Yc7hq9kLdqPRCACoqKg4476lpaW48sorcerUKXz33Xdo167dGY+prKz0ug4REQVHFhrIIrABWbIqC4cSeTDnICKKLsw5fDX7kPiMjAxIkoTc3NxG96uqqsKIESPwyy+/4P/+7//8Hs62a9cuSJKEjIyMUIRLRNTiKZCgQBPgFpvfdlN0YM5BRBRdmHP4avaCPSEhAZmZmdiyZUuD+8iyjLFjx2Ljxo348MMPMXjwYL/Pv3XrVmRlZSEhISEU4RIREVGUYs5BRETRrtmHxAPA5Zdfjvfffx8LFy6sd5mVu+++G5999hlGjBiBEydO4N///rfX89ddd12953U4HFi5cuUZu7oSEZH/OJ+MohlzDiKi6MGcw5ckhGj20f65ubno2bMn3nnnHYwfP97n+UsuuQTffvttg8c3FPLy5csxYcIE5ObmokePHiGLl4ioJSorK4PVasXHO85GfGLjzbcaYi+XcU3fX1FaWgqLxRLiCInOjDkHEVHkY87RMFUKdgC48sorsXv3buTk5CAxMTHo85WVlaFX717omd0Tq1atCkGEREQtW82H58od3YP68BzV95eY+/Ck6BKunCM7OxurV60OQYRERC0bc46GNfsc9hqLFi1CcXExZs2aFfS5hBCYNWsWjhUVoeMtf4VDdocgQiIiIooFYck5jhehy+1DYXdXhSBCIiKi+qlWsHfp0gULFy7EsmXL8MQTTwR8HiEEnnjiCbz22mtIvX44vnYWYPz6f6GgsiyE0RIRtVwKNJAD3BT1PmaIaoUj58iYeily9EW4ZctLOFRxPITREhG1XGrkHC+//DI6d+4Mk8mEQYMG4YcffvDruPfeew+SJGHkyJEBXddfqmZSU6ZMwRNPPIEHH3wQU6dORXl5eZOOLysrw9SpU/HQQw9h3O23oOOl5yHeBeSUHMFf176ObcWHwhQ5EVHLUbMmaqAbUSQIZc5x06xpyBx2HkwOCQfLizD1hxexqXhvmCInImo5mjvneP/99zFr1iw8/PDD2LZtG/r27Ythw4ahqKio0ePy8/Nxzz334MILLwz0pfpN9UzqH//4B5YuXYp3330XvXr1wvLly+F0Ohs9xuFwYPny5ejduzfee+89LFy4EC8+PBf/HPRXpJsSEO8CTlSU47r1b+ODAz810yshIopNga+HyjvsFFlClXM888DjeKLPdehgSobJIaHCUYV7t7+Of+d/02CTOiIiOrPmzjkWLFiAqVOnYtKkScjOzsbixYsRFxeH119/vcFjZFnGhAkT8Oijj6Jr167BvFy/qNZ07nR5eXmYPn06Vq9ejdTUVIwaNQoDBgxAz549YTabUVlZiV27dmHr1q1YuXIlioqKcNlll+GZZ55Bp06das9z0lmBuT99hR0njqJKB7i0EiZ0648H+l0BgyawBgZERC1RTQOY5dt7IS7ABjAV5TLG99sZcw1gKLqFKueodDuwaN+X2HriVzh1Am49cFlaX8zOHgOT1ncJOSIiql8oc45Dhw555RxGoxFGo9Fnf6fTibi4OKxYscJrWPsNN9yAU6dO4dNPP633Og8//DB+/vlnfPzxx7jxxhtx6tQpfPLJJwHF7A9V1mGvT5cuXbBq1Srk5uZi8eLFWLt2LRYvXuz9TbUkwXJWGv521VW46aab0L17d5/ztDLEYd7AEXh1z/f49GAOtELgnX1bsbe0CC8NHo02pvhmfFVERNFPFhJkEeCaqAEeRxRO/uQckgSc3TUBV131N9x005R6cw6zzoi7Mq/GR4c3YuWh/0GrAOsKduA3+3E82Xci2ppbN+fLIiKKeqHIOTp06OD1+MMPP4xHHnnEZ//i4mLIsoy0tDSvx9PS0rBnz556r7Fhwwa89tpr2L59e0AxBiJiCvYa2dnZeOGFFwAANpsN+/btg8PhwLxdX2O31o54rRF3XzoRKaaEBs+h12gxI/tCZFiS8fyu/0LjlvHj8d9wzdrXsOgPY9CrVdvmejlERFGvpplLYMdGxCAuono1lHPona+gc+r3kEUipKSpkPRnN3gOjaTB6A5/QKe4FLz86xeQHC7sE0cx9YcX8Vjv63Bu627N9XKIiKJeKHKO+u6wh0J5eTmuv/56LF26FMnJySE5pz8irmCvKyEhAf369QMADDbbkLvne8AJ5JWVNFqw1xh+Vg90jG+Fx35ajWJnBQrtpbj267cwd8CfcXWn3mGOnogoNihCAyXA5nFKZMy6IjqjujmHsO+EUvY9TpQCcOcBjRTsNQa26Y7HTa2wYM/HOOY4hTJhx10/LcXtZ4/AqA5DIEkcbUJEdCahyDksFotf0/CSk5Oh1WpRWFjo9XhhYSHS09N99t+/fz/y8/MxYsSI36+pKAAAnU6HvXv3olu30H9JGzXdgLKsqRCSBCEBB2wlfh+X3SodLw8Zg57WdMS7AMXlwj0/fIqndqyFu/oXTERERFRLlwVJAjQaBUI+4PdhHeJT8Hif69EvqQtMTgmSS8HCXz7FvNwP4ZBdYQyYiIiaymAwoH///li3bl3tY4qiYN26dRg8eLDP/llZWcjJycH27dtrt6uuugqXXnoptm/f7jMUP1Qi+g57XZnWVACAIgF55f4X7ADQxhSPZ8+7Ci/lfodVh3dDIwRe27sRe0oLsfD8vyLJYA5HyEREMYFD4qnF0WV6/tEqcLrzmnRogt6Me3uMwvsHv8PnRzdDowBfHt2KPHshnuwzESkmazgiJiKKCc2dc8yaNQs33HADBgwYgPPOOw8LFy6E3W7HpEmTAAATJ05E+/btMW/ePJhMJvTq1cvr+KSkJADweTyUouYOe1dLMnSSxlOwlzWtYAcAg1aHu3pdgtuzL0ScokGcG/i+4AD+uvY17C1tfJ09IqKWTMHvTWCaunEcE0UjSZsMaNpAq5WBJtxhr6GVNBjf+WLcfvYIxCk6mBwS9pQewpQfXkDOqfzQB0xEFCOaO+cYO3Ys5s+fj4ceegj9+vXD9u3bsXr16tpGdL/99huOHTsW0tfYVBGzrJs//vLVEhw4UYgEWYNPr5ga8DJtP584gsd/+gonXJWo1AEmvQFPn3cVhp/VI8QRExFFr5olVl7ZNhDmhMAGZFXa3Jh27hYu60ZRRzlxI5z2H1BuN0Nq/T4kbauAzpNnK8Rzez9GsaMMDoOARqfF3VkjMaL9oBBHTEQUvZhzNCxq7rADQHdrChQJcAsFh20nAz5Pn9bt8dKQ0chMTEa8y7MG3+0bV+KfO9ezQRIREREBuu7QamTPzwHcZa/RJSENc3tfj2xLB5icEuCS8fTulXhuz8dwKe4QBUtERLEqqgr2TGsa5OomqweaOI/9dGnmRCwYdA3+2O5smN2A0S2waPcGTPvfByh3OUIQLRFRbJCFJqiNKBpJuixotQKQALgDL9gBwGqIxwPZf8Ow9HNhcEkwOIGPD23EzG1LcdJpC03AREQxgDmHr6h6VVnWVECSoEjAgfITQZ/PpNPj732G4ubMITDJEswugW+O/oLR614P+gsBIqJYoUAKaiOKSvrqxnMaGaKJjefqo9NocWPXobil23CYFB1MTgk/n8zD5M0vYE/Z4aDPT0QUC5hz+Iqqgj0zqW6n+OKQnFOSJIzp2g9zB/wZrbRGxLmA/LJijFr7OtYf2xeSaxARRTN+200tki4DgAZarQLIwRfsNS5J64OHeo1DG10CTA4JxZWnMH3rInx1bFvIrkFEFK2Yc/iKqleVZkpEksEMRQLyQ3CHva4BKR3x4uBR6BbfGnEuoMpZhZs3vIfFu/+HKOrLR0QUcjVLrAS6EUUjSTIC2i7QaWXAfRBChG6++dmJ7TC3z0R0j28Pk0OC7HTjsV3v4cVfPodbkUN2HSKiaMOcw1dUvSpJktDdmgJZAooddpxyVob0/O3jk7Bw8F9xYWpXmF2A3i3w3M5vcOemj1Dhdob0WkRE1LCXX34ZnTt3hslkwqBBg/DDDz80uO+bb74JSZK8NpPJ5LXPjTfe6LPP8OHDw/0yKNrpMz132OEG5CMhPXUrQwLm9BqLS1P7wOiSoHcC7x/8h35B2AAAsbpJREFUDvdufx1lroqQXouIiKJXVBXsgKfxnFIddX4Y5pnH6Qx48JxhuPHs82CUAbNLYNWhXPzt6zdxyB54Z3oiomilCCmoranef/99zJo1Cw8//DC2bduGvn37YtiwYSgqKmrwGIvFgmPHjtVuBw8e9Nln+PDhXvu8++67TY6NWhZJlwmtpnpl3yAbz9XHoNFhardhmNRlKIyKFkanhC0lv2LKDy9gv03ddX+JiNTQ3DlHNIi6gj3Lmorqj86QNJ6rj0aSMCFjAB4790pYNHrEu4BfThXir2tfx/eFoZvHRkQUDZQghqYpAXzMLFiwAFOnTsWkSZOQnZ2NxYsXIy4uDq+//nqDx0iShPT09NotLS3NZx+j0ei1T6tWga2rTS2ILhMajYBGIyBCOI+9LkmScEXbczEneyySNHEwOSQcs5/ArVtexvrCnLBck4goUjV3zhENou5VZSb93ik+ryw0jecaMjitC14YPBodzFbEu4Dyqgrc9N1yvPHLZs5rJ6IWQxGaoDYAKCsr89ocjvqXz3Q6nfjxxx8xdOjQ2sc0Gg2GDh2KjRs3NhijzWZDp06d0KFDB1x99dXYtWuXzz7r169HamoqMjMzMW3aNJSUcDUQOoPqTvFarQyEoFN8Y3pYO2Bu3+vRNS4NZocEp8OJOTlvY+n+/0ARyplPQEQUA0KRc8SaqHtVZ1tSIAGQNUCeLTx32OvqlNAKLw0ejUHJnRDnArRuBU/uWIP7t3yGKtkV9usTEcWCDh06wGq11m7z5s2rd7/i4mLIsuxzhzwtLQ0FBQX1HpOZmYnXX38dn376Kf79739DURQMGTIEhw//vlTW8OHD8a9//Qvr1q3D008/jW+//RZXXnklZJkNvqgRmnaAlACdRgl7wQ4AKUYrHuk1Dn9I7uGZ1+4C3spbh9k73oLdXRX26xMRUeTRqR1AU8XpDOiY0ArHSk8g31YCWSjQSuH93iHBYMRj/a/EW79sxrsHfoJWEfg4/2fsKyvGy0PGoG2cJazXJ4pVNpsN+/btg8PhgNFoREZGBhISEtQOi04jQ4Ic4NqmNccdOnQIFsvvfyuNRmNIYgOAwYMHY/DgwbX/PWTIEPTo0QOvvvoqHn/8cQDAtddeW/t879690adPH3Tr1g3r16/HZZddFrJYKLZIkgShy4RWuwNwFEEoNkia8P6NMmoNuO3sv6BzfBqWH/wWGkXgf8d34+YfXsK8vhPRMT41rNcnilXMOaJDKHKOWBN1d9gBT+M5WQIcsoxjFaXNck2tpMFNmYMxp98VSJB0iHcBO08cxV/XvoYfiw81SwxEsSA3Nxd33HEHevToAYvFgnPOOQfnn38+zjnnHFgsFvTo0QN33HEHcnNz1Q6VqoVieJrFYvHaGirYk5OTodVqUVhY6PV4YWEh0tPT/YpXr9fjnHPOwb59+xrcp2vXrkhOTm50HyIAgK6mUzzC0niuPpIk4S/tz8Pfe4yGRTLB5JDwm60IU394Cd8X726WGIhiAXOO6MMh8b6i8lVlWVOhVH+Bsj9MjecacnHbDCw8/69oZ0pEvAs4WWnD9evfxrv7f2zWOIiiTV5eHq688kr07NkT77//Pi699FK89tpr2LRpE37++Wds2rQJr732Gi699FK8//776NmzJ6688krk5bHRo9pk/P6Nd9O3pjEYDOjfvz/WrVtX+5iiKFi3bp3XXfRG45Vl5OTkoG3btg3uc/jwYZSUlDS6DxEASPrqTvESmmVYfF19WnXB3D7Xo5MpBSaHhCpnFe7f/ib+lfc1e+kQNYI5R/RqzpwjWkRlwZ6ZlAohSRDN0HiuPt0syXhpyGic27o94lwA3DIe2rYKD/74JZxKrL5ViAK3bNky9O7dG7t378Y777yDQ4cOYdGiRZg0aRIGDRqE3r17Y9CgQZg0aRIWLVqEQ4cO4Z133kFubi569+6NZcuWqf0SqBnNmjULS5cuxVtvvYXdu3dj2rRpsNvtmDRpEgBg4sSJmD17du3+jz32GL766iscOHAA27Ztw3XXXYeDBw9iypQpADzDIO+9915s2rQJ+fn5WLduHa6++mpkZGRg2LBhqrxGiiK6TEgSoNUoYesU35g0cys82nsCzmvdHUanBJ1LYMn+1Xgw59+ocNffvJGoJWPOQbEmOgt2q2f+liIB+c18h72G1WDGkwNG4K+d+8DkBkxugff2/4iJ69/G8SqbKjERRaK5c+di6tSpGDduHHJycjB+/HgYDIZGjzEYDBg/fjx27tyJcePGYerUqZg7d24zRUyna+7haWPHjsX8+fPx0EMPoV+/fti+fTtWr15d24jut99+w7Fjv69RffLkSUydOhU9evTAn/70J5SVleH7779HdnY2AECr1eLnn3/GVVddhe7du2Py5Mno378/vvvuu5DOpacYpevu+UcrA+58VUIw6wyYmXkVxnS4EHq3BKNDwvrCHEzb+jKOVqqTBxFFIuYc0Y9D4n1JIgrHVClC4JyPn4HscKKT0YJ/XXydqvGsObwH/9z1Laogo1IHpMZZsGjIGPRp3U7VuIjUtmzZMkydOhWPP/445syZ0+B+c+fOxZw5c9CzZ0/s3LnT5/nHH38cDz30EJYtW4bJkyeHM2Sqo6ysDFarFbM3DocpQR/QOapsLswbvBqlpaVeTeeIooly/I+orChCRVUSpDYfQwpzs9vG/HhiH1765f9QIZxwGAQSjXF4rPcEDGh9tmoxEUUC5hzRjTlHw6LyawiNJOHs6nnsxyrKYHc5VY3n8rOysGDQSKQZ4hHvAo7byzDum7fwcf7PqsZFpKa8vDzMnDkTU6ZMafSD8/Dhw3jyyScRHx/f4D5z5szBlClTcOedd3J+mQoEJCgBbiJGO7ZSC6PLhFYjA6ISkOtfXrC59G+dgcf7XId2xlYwOSTYqipw90+v4YPfvuO8dmqxmHPEDuYcvqKyYAc8jefk6v9NDjbDeuxnkpWUhpeHjEZvazriXYBwuXHfls8wd/tXcCuK2uERNbvp06cjOTkZCxYsaHS/e+65B+effz4GDBjQ4D6SJOG5555DmzZtMH369FCHSkTUOF0mdDWd4lWYx366s+KS8UTv63FOUleYnBIkp4IXfvkcc3M/gEN2qR0eUbNjzkGxLGoL9syk3zvFHyhv/sZz9WltjMfTg67Gnzv0hMkNGN0Cb/6yGTd9txwnHRVqh0fUbHJzc7F69Wo8+eSTSExMbHC///73v1ixYgUWLlx4xnNaLBbMmzcPq1evxu7dXNaoOclCE9RGFO0kfSY0GgFJEs3eKb4h8XoT7unxV1zd/nwY3BIMTgmrj/6I2358BUVVp9QOj6jZMOeILcw5fEXtq8q0pgKSpGrjufoYNFrM7HUx7ux5EeIUDeLcwKbCPPx17WvYc6rwzCcgigGLFy9GamoqRo8e3eA+sizj9ttvx5QpU9C7d2+/zjtq1CikpqbilVdeCVWo5AdFSEFtRFFPl+n5RytDNNNa7P7QShpc2+ki3NH9KsQrOpgcEvaeOozJP7yAHaci44sFonBjzhFbmHP4iu6CHZ5O8fvLS1SOxtdfOvbCM4OuQrLOjHgXcNR2Cn/7+k2sOpSrdmhEYbdmzRqMGjWq0c6sixcvxsGDB/H444/7fV6j0YhRo0Zh7dq1oQiT/CRDE9RGFPW0nQAYodUqgJyvdjQ+Bidn4ZE+E5BmsMLkkFBaacOdPy7BJ4c3qR0aUdgx54gtzDl8Re2rshrMSDcnQtYAebaSiGy00rtVO7w0ZAwyLSmIdwEupxN3bPoIC3K+gSw4r51iU3l5Ofbu3YuBAwc2uE9JSQkeeughPPjgg0hJSWnS+QcMGIA9e/bAZuPyiUTUPCRJC+jOhlajAPIRCFGldkg+OsenYW7v69HL0gkmpwS4ZMzf8xGe2b0SLsWtdnhEYcGcg1qCqC3YASDTmgZZAuwuJ4oidO3zVHMCFgwaiaHtu8NcPa/9lT3/w63/+wBlzsj7wCcK1v79+yGEqF0Duz5z5sxB69atcfvttzf5/D179oQQAvv27QsmTGoCDk8jAqDP9KzFDqHaeuxnkmiIw9+zR+PK9P4wuCQYnMBnhzfjjh+XoMRRrnZ4RCHHnCP2MOfwFdUFe1bdxnNlkTcsvoZRq8d9vS/DrVl/gFmREOcS+Pborxi97nXsK4uMhnlEoeJwOAAAcXFx9T7/66+/YsmSJbjjjjtw9OhR5OfnIz8/H1VVVXC5XMjPz8eJEw33pTCbzV7XofBToAlqI4oFki7TMyQeiJjGc/XRabSY2PUy3NrtTzArepicEnaeyseUH17A7tJDaodHFFLMOWIPcw5fUf2qMq2pEJIEIQH5tsgt2AHPEhGjuvTFkwNGoJXWhDgXcLCsBKPXvY51R39ROzyikDEajQCAior6V0Y4cuQIFEXBHXfcgS5dutRumzdvxi+//IIuXbrgsccea/D8lZWVXteh8JOFFNRGFBN0mZAkQKtVICJgabczuTitFx7uNQ7JukSYHBJKKktx24+vYNXRH9UOjShkmHPEHuYcvnRqBxCMLGsaAE/juQMR2HiuPucmn4UXB4/CIz+txgFbCargwLT/fYA7e16MaT0ugEaKzTcatRwZGRmQJAm5ubkYNGiQz/O9evXCxx9/7PP4nDlzUF5ejueffx7dunVr8Py7du2CJEnIyMgIadzUsGCGmcXq8DRqgfSeTvFajQw5QofEn65bYls80WciFu75BL/YjsCpuDE39338Wn4E08/+M3QardohEgWFOUfsYc7hK6oL9s6JraGXNJAlGXlRUrADQLt4K54//xrMz/kG/y3YD4dWYOGub5F7qhDPnHcV4nUNd7kkinQJCQnIzMzEli1bMGnSJJ/nk5OTMXLkSJ/Ha9ZFre+5urZu3YqsrCwkJCSEIFoiIv9ImtYQmhRotaWA4wCEEJCi4Ev2VoZ4zOk1Fm/lrcO6wh2QFIEPftuA/bYCPNZ7AqyGeLVDJAoYcw5qCaJ6SLxeo0U3SwoUCThsPwWnHD1dUM06A+b0uwI3dR8EkwyYXQJfHd6Nv617AwdtkbOuPFEgLr/8cqxcuRJOpzOk53U4HFi5ciWGDh0a0vNS44TQQAlwEyKqP2aIvOkyodMqgCgDlOi5UaDX6DCl2zBM7noFTIoORqeEH0/sw5QfXsCv5UfVDo8oKMw5YgtzDl9R/6qyklIhS4AsBA7aTqodTpNIkoRx3frjsf5/gkVjQLwL2FdahFFrX8eGwgNqh0cUsFtvvRVFRUVYsWKF38esX78eO3fubHSflStXoqioCNOmTQs2RGoCGVJQG1HM0GVCq5E9P0fBPPbTDU3vhzk9x6K1Ng5mh4SCipOYtuVlrCvcoXZoRAFjzhFbmHP4ivqCPdP6e6f4/CgaFl/X+amd8dKQUegUl4Q4F2BzVGLyf9/Fa3s3ReT68kRn0qO7EcP+mIoHHrgf5eWhWUqorKwMs2fPxvDhw9GjR4+QnJP8o4hglllRO3qi0JH0mdBqBSRJAK7oK9gBIMtyFub2mYhu8ekwOyS4nC48nPMOXt23CrJQ1A6PqMnapJ6Fjl374v77/86cIwYw5/AVEwU7JMnTeC6Kh5J3iG+FFwePwuCUzohzATpZwVM/r8W9P3yKKtmldnhEfhNVayBKRuPleXEoLi7AXXfdFfw5hcDdd9+NkpISLFq0KARREhEFQFfTeE6BkKN3JFwbowUP9xyHC5J7wuiSoHcBb+d/g79vfxPlrkq1wyPy2087f8OUu99Garc/obCwiDkHxaTYKNhR0yk+utc0j9cb8ei5V2J8t/4w/j979x0eVZk9cPz73pn0Din0ThJKIAiIIFhR1LUjoiAqi7iLiw1Xd1UWG/ywInZWkFVZUda6ViwoqyiClNB7EgglgZDeptx7f39MCImhJpPcZOZ8nuc+hJu5d04gybxn3vec1+2pa//v7g3c8P1b7C8rtDo8IU7INHWM4ucxC/4CZimdOwQw64kevPHGG0yfPr0e9zWZPn068+bN44UXXqBz585ejFqcirrWkh05hPAZ9q6A3bMfezNcEl9doC2AO7pfxrhOFxCk2whyKJbnbuX2314iszTH6vCEOCHTNHnvv6u495H3KSgqJzisBX0GXy9jDh8gY47amv1XFRccTkxgKLqCjKLmuSS+Ok0pxicO4h/9RhCh7IS5YHP+Aa757g1WHtptdXhCHJNpFGDm3w6lrx09GXwpE+9ezvTp0/nHP/7BxIkTT3upWlFREbfffjvTpk1jxowZTJgwwcuRi1NhoOp1COErlAoEe2fsNh3cWZimd5tcNTalFJe1GcDfe1xHlBZCsEOxtySX21e+zLJDm60OT4hjKq9w8tisL3jlzaXolWugB6Z24vvP/yljDh9gxZjjlVdeoVOnTgQHBzNo0CBWrlx53Md+9NFHDBgwgOjoaMLCwkhNTWXBggV1/XJPSbNP2JVSJEd76tjzneXkO8qsDskrzmnVldmDR9I2JJIwFxSWl3LL/97hnZ2rpK5dNCmmawvm4ZHg/KnyjIaK+BsqajZKC+Phhx9m7ty5vPvuu/Tu3ZuFCxeetJOrw+Fg4cKFpKSk8O677zJv3jweeuihhv9ixDHppqrXIYRPsSd5Zthxg3uv1dF4RUp0J6b3GUenkDiCHQqH08GD697izfQlGFLXLpqQfQcK+PPfF7Jk2daqc+NGDuKZqdcSGREiYw4f0NhjjkWLFjFlyhQeeeQR1qxZQ9++fRkxYgQHDx485uNbtGjBww8/zPLly1m/fj3jx49n/PjxfP311/X90o9LmT6Q/c1I+4a3t68gzAlPDbySM2LbWR2S1xQ5K5ix7hvW5O7FYQenTXF951Sm9buEIJvd6vCEnzPLP8MsfBio8JxQMajo2aigwbUem5GRwR133MHixYuJj49n5MiRDBgwgF69ehESEkJ5eTmbNm1i1apVVZ1ZL7nkEl599VVZkmaRoqIioqKiGPP9GALDA+t0D2eJk4UXLKSwsJDIyEgvRyhE4zNL/olR/Bx5hRGeNyeDL7Q6JK+p0J3M2fEVK/K24bKbuALg3LjePNxrNKH2IKvDE37u19XpPPb8F5SUOgAICQ5g6t2Xcc5Z3Ws9VsYczY9VY45BgwYxcOBAXn75ZQAMw6B9+/bceeed/P3vfz+le5xxxhn84Q9/4IknnqhT3CfjExmfp1O8Akwyig/7VMIeGRjMjP6X88b2X/kgIw3NNPlP+lp2FOXy8uCRxIdEWB2i8EOm6cIsfgbK3jx60t4bFfMyytbmmNd07tyZr776is2bNzNnzhy+++475syZ87sVI4rIgGiuuvYKHnzk79KZtYmoT12Yr9aTCT8WkIRSoGkmhp7hU0UfwbZA7k66kv/u+5X/7FmGZpj87+BGsspymdn3FtqGtrQ6ROGHDMNkwYe/8sa7P3NkyNChbQtm/O0qOrU/9vfkKY05lCIiuhUjRlzC49NkzNFUeGPMUVRUVON8UFAQQUG133R0Op2sXr2aBx98sOqcpmkMHz6c5cuXn/T5TNPk+++/Z9u2bTz11FN1ivlU+EzCDqBrzb/x3LHYNY0/JQ+ha0RLnt+4FM2tk5abxbXfzeflIdeR2rKt1SEKP2LqhzEL7gZXtfqekJGoyEdR6uQzMD179uTFF18EoKSkhJ07d+JwOPjl49/49Kkl2N12rj7rennhbEIMPNul1PVaIXyKPRkAm03HaKZbu52IUoqr2w2mQ1g8L2/7HOVwkGFmc9vKF3k8ZSwDWyZaHaLwIyWlDma8+BXLVu6sOjf0zG5MvftSwkLrPuZI236AeZ9txhYQxPlXnCljjibEG2OO9u3b1zj/yCOP8Oijj9Z6fG5uLrquk5CQUON8QkICW7durfX4IwoLC2nbti0OhwObzcarr77KRRddVKeYT4VPJOzdIuPQUBjKM8Puq4a3TaJDeAyPrlnMQUcJuWYRY5a+zRP9L2Nkp75Whyf8gOlch1lwJxjZlWcCUJEPQ8iNKHX6v1zDw8NJTU0FIDY4gS+f/h8A63/azLX3/MFLUYv6MuvRyMWUhF34Gi0BVCR2zYHLBxP2I86I6cr0Pjfx3NZP2FdxmFKznPvWvsGfu1/GjR3OqdPvfCFOR2bWYR568hOy9ucDoBTcduNQbho5CE2r35ijW1Ip/1q8C4C1W32jF4Wv8MaYIysrq8aS+GPNrtdHREQEaWlplJSUsGTJEqZMmUKXLl0477zzvPo8R/jEWsUQewCdIlpgKMgsycdt+G6DlMSoeF4Zch0p0a0JdQEuN3//7TOeWPs1LkO3Ojzhw8yy/2DmjTmarGvxqBYLUKFjvDJw69S7PWFRoQBsWrZVmisKIZokpVRl4zkdjFxMw3e3XW0T2pLH+4ylf0xXgp0KzWXy6o4veGLTezh0l9XhCR/2v+Xbuf2Bf1cl6+FhQTz98LXcPOqsOiXrv9cyOox2CdEAbEnPpsIp38++JDIyssZxvIQ9NjYWm81GTk7NrSxzcnJo1arVce+vaRrdunUjNTWV++67j+uuu46ZM2d69Wuo8XwNdudGlhQVj67AZeg+v2d5TFAoT515JVd26EWwG4LdJm/vWMkff1xIno90yRdNh2k6MQr/gVk0Fah8QQs4A9XyI1TgGV57HpvNRq+zkwAoOFRE1rb9Xru3qB/DVPU6hPA5AUnYbZWTA+5MS0NpaGH2YO5LvoZr2g0m0K0IdCq+ObCWSateJbsi3+rwhI/RdYM5C35k6tOfUl7hGXN07RTHvGfGcVb/Ll59rtRkT0mpWzfYvCv7JI8WjaUxxxyBgYH079+fJUuWHH1+w2DJkiUMHly7gfJxYzYMHA7HaT336fCphN2o/D/y5WXxRwRqNu7sdS739j6PEEMj1A0rDmZy7XdvsLlAfukI7zD1bMy8sVC+6OjJ0JtQLd5G2eK9/nwpQ4/WkG38aYvX7y/q5kgDmLoeQvgaZU9C0wxQgNt3l8UfoSmN6zsM457EqwgzAwh2KHYU7uO2FS+Slp9udXjCRxQWlXP/9I9456OjPXKGD0vmtZk30rZ1tNefLzXpaJPqtK37vH5/UTeNPeaYMmUKc+fO5a233mLLli1MmjSJ0tJSxo8fD8DNN99coyndzJkz+fbbb0lPT2fLli0899xzLFiwgJtuuslr/wa/5xM17OBJ2E2lMJVJenEu57buZnVIjeKy9j3pGB7D42u/5rCzjAMlBYz+/k1mDriCyzv0sjo80YyZzt8wC+4C48gbYEGoqMdQIdc22HOmnNOz6uMNy7Zw2cThDfZc4tTVZ6ZcZtiFT7InoxTYNANdT/ebTg2DYpNoHRLDc1s/JsdRSJFZyt1rXufuxCu5pt1gqWsXdbY9PYepT/2XAwc93b1tmuKOW89j1OVnNNj3VWry0YR93TapY28qGnvMMXr0aA4dOsS0adPIzs4mNTWVxYsXVzWi27NnD5p29I2A0tJS7rjjDvbu3UtISAjJycn8+9//ZvTo0XWK+VT4TsIeXdkpXkF6cZ7F0TSuXjGteXnIdTy2djHbCg5SYbq4d8XHbC7I5r6U87EpmeESp840TShbgFn8JOD2nNTaerZsC2jYN4ESB3QhMDgAZ4VLZtiFEE2X3TMpYLfp6H4ww15dh7B4ZvS5mRe3f8aGwkycpsGsbZ+wo3g/9yZfTaDmM0NL0Ui+XrqZp1/7BqfTM+aIjgzh8fuvoF/vDg36vG3jo4iNDiO3oJQNO/bj1g3sNhkz+6PJkyczefLkY35u6dKlNf4+ffp0pk+f3ghRHeUz35VtQ6MJswdiKP9YEv97ccHhzDrzaka0TSbYDUFuk7lbf+H2ZYsodJZbHZ5oJkyzHLPwfszi6VQl64FDULEfNniyDhAQGEDyoO4AZGce4tBe//tZboqMyo6tdT2E8DVKCwNbB2w2A/TdmKZ/NX0NDwjhgR4j+UPrgQS6PHXtn+1byV2r/0muo+jkNxACcLt1Xpj3PdNf+LIqWe/RvRVvPHdzgyfr4Gkg2TfJU8deVuFi555DDf6c4uRkzFGbzyTsmlJVdew55cWUuhqu8L+pCrTZuS/lfP7SYyghhiLUDT8d2MnIJfPZUSS/hMSJme4szMM3QMWnR0+GTUTFzENpLRotjup17Btklr1JkKZzQhyDPQm7poNZAfoBq6NpdHbNxk2dz+cv3f5AiGEn2KnYVLCb21a+yKbCPVaHJ5q4w/ml3PPI+3zwxZqqc5cPT+Gl6TcQHxvRaHFUXxafJtu7NQky5qjNZxJ2ONopHiCjxL+WxR+hlOLqTn14cuAVtLAFE+qCrKI8Ri35F9/t22Z1eKKJMh3LMA9fC+7KBFmFoqJfRIu4H6Uad3lj72HSeK6pkRdPIY7BnuSZYQfQ/WtZfHVD43vxaMoYYu2RBFco8sqKmLzqNb7Y/5vVoYkmatO2/dz21wWs2+xJkAPsNu6fdDF/+8sIggIbd8yRWjnDDpC2TRrPNQUy5qjN5xL2I53i0/1wWXx1qS3b8fKQ6+geEUuYCxwOB5N+eZ+XNv2IIftbi0qmaWKWzMHMnwBm5XaItk6oFu+jgi+xJKaegxOr9ljdsEwS9qZAXjyFqE0FJKFpdlRAZ/z9ZbVLeCv+r884ekS0I9ipMF06Mze/z+xt/8Vt+Fe5gDixT79Zx+Sp75GbVwJAXMtwXpo+misv7mNJPF3axxIe6tmje922vZ4+PsJSMuaozbcS9uh4UMpTx17k3wk7QKvQSGYPuobzWncjpLKu/cXNPzL5lw8o8cOSAVGTaZRgFkzGLJkFVL5ABV2AavkBKqC7ZXGFRoTQtV9nADI3ZlGUV2xZLEIIcVxB56ES1hMYNx8teJjV0VguKjCMh3pdz0Wt+lXWtcMHe37m3rVzyXeWWB2esJjD6eapV77mmde+xe32rEzp27Md854dR6+kNpbFZdM0+iR6nj+/qJw9B/Iti0WI4/GthD3K0yneXxvPHUuwPYCH+l7EbUlnEaRDiMvk231bGfX9v9jtp2UDAkx3Oubh68DxbeUZhQq/CxX9KkqLtDQ2qFnHvulnKeWwmrzbLcSxBKKUDZvNZnUgTUaAZuePXS5iYtcRBBl2gpyKtXnpTFz5EjuK91sdnrBITm4Rdz78Hp9/t6Hq3KjLz2D2Y6NoER1mYWQeNZfFSx271WTMUZtPJewRAcG0DY1C1yCj5LAsa6mklGJ0lzOYMeByom1BhLkgvfAQ1343nx+zd1kdnmhkZsW3mIdHgp7uOaEiUNFzUOGTUU1kC0CpY29aTOretVV+CwtfdWRvaLtdtjH7vQsS+jKt1w20tIUR4lAcLMvnz7+9wnfZaVaHJhrZ2o17uO2+BWzZmQ1AUKCdqXdfxl0TLsBubxpvdvVNqr4fu9SxW03GHLU1jdG5Fx1pPFfmdpFTLktpqxsY14GXBo+kc1gMoS4odZQz8af3eH3rL/Lmhh8wTR2j+HnMgr+AWeo5aU9EtfwIFXy+tcH9Tu+hyVUfr5eE3XLybrcQxycz7MeWGNmWGX1upltYa4IdCrfTxaMbF/Lqji/RTcPq8EQDM02TRZ+u4t5H3qegyLO9cOv4SF57cgwjzutpcXQ19eiSQGCA5+d4rXSKt5yMOWrzyYT9SOM5WRZfW7uwaF44ayRnx3Ui1AV23eCZDd8zZcUnlLtdVocnGohpFGLm3w6lrx09GXwpqsUilL2jdYEdR0x8FO0ra9p2rE6nvLTC4oiEEOLYJGE/vhZBEUzrdQPnxvUmyKUIcMHCzKU8kPYvilxlVocnGkh5hZPHn/+Cl/+1FN3wTAgNTO3EvGfH0b1zvMXR1RYYYKdX19YAHDhUxMHDMuEnmhbfS9ij4zGVwlTSKf54wgICeeSMS7m520CC3J669s/3bGT0D2+yr7TA6vCEl5murZ4t25w/VZ7RUBF/Q0XNRmnW144dT+/KOnbdrbN1xQ6Lo/Fv8m63EMenlDrlpN3pdJKZmckPP/zAm2++2bCBNRGBtgD+1O1Sbul0IUG6jSCnYkXuNm5f+RLpJdlWhye8bN+BAiY9+C7f/bS16txNIwfxzNRriYwIsTCyE+srdexNhow5avO5wqukqATA03hOEvbj05RiXPeBdIlsydPrl6C5XGzNz+aa7+bz0uBrGRTfyeoQhReY5Z9jFj4EVM5QqxhU9GxU0GBL4zoVKcN68NUbSwDY+NNW+l2QYnFE/qs+L4K++uIpRHU2mw1dr7l9WX5+PpmZmaSnp7Nv3z727NnD/v37qaioQCmF2+3myiuvpEWLFhZF3XiUUlzSpj/tQ2N5YfunFDrK2Wce5k+/vcw/et3AOfG9rQ5ReMGvq9N57PkvKCn17EQUEhzAw3ddyrmDEy2O7ORSk9vBf1cAnv3YLx7S4yRXiIYiY47afC5h7xTegkDNhq7csiT+FJyd0IUXzorm0TVfsbe8kCKzlFt+fIeHUy/mpq4DqprqiObFNN2YxU9D2ZtHT9p7o2JeRtms2z7ldKScc/TFUvZjt5a8eApxYna7HafTCcCTTz7Jxo0bKSgoQNd1QkJCyMnJITc3l0suuYR+/frRrl07oqOjCQtruqucGkKv6I5M7zOOWVs/YXfZQRyGk4fWv834zsMZ32U4WhNpfCpOj2GYLPjwV95492eOtETq0LYFM/52FZ3at7Q2uFOU0r0NmlIYpsm6rdJ4zkoy5qjN534z2jWN7pFxGAr2lRbi0KUu+2Q6RbTgpcEjGdiyPaEusLkNHl/7NQ+t+hyH7rY6PHGaTP0wZv74msl6yLWolgubTbIOkNAxjrh2nhf6Lcu343bJ96IQommqPsPeoUMHsrKycLlcjBw5knvuuYd//etfTJ06FV3XSUxMZPjw4QwYMICgoCCLI2988cHRPJYyhsEtk6vq2v+V8R0Pr19AmVv6lTQ3pWUOHn7qv8xbeDRZH3pmN15/emyzSdYBwkICSezkqa/ftTeXwpJyiyMS4iifS9gBEis7xRuY7C7JtzqcZiEiMJjpA/7A6M79CHJDsNvkg4w0xi5dIN32mxHTuQ7z8DXgXFF5JgAV+SgqciZKBVsa2+lSStF7mKdbfEWZg51rMyyOyH+ZpqrXIYSvs9lsaJpnSJWUlETv3r158sknue222zjnnHNITExk3LhxdO3alddffx2gakbeHwXZArkz8Qpu7HAugW6NIIfip4ObuP23V9hblmt1eOIUZWYd5vYH3mHZyp0AKAUTxwxlxt+uIiy0+b0ZVX0/9vXb91sYiX+TMUdtPpmwJ0cf7RQvdeynzqY0bksezEN9LyIcG6FuWH94L9d89wZrD0sDjqbOLHsfM28MGJVNfLR4VIsFqNAxzba0IWVotWXx1RrYiMZV1/1QjxxC+DqbzVb1e7a8vJw9e/bQr1+/Wo8LCAigvLy86mN/ppTiynaDeKDHSCJUMMEOxe7iHG5b+RK/5m6zOjxxEv9bvp3bH/g3e/blARAeFsTTD1/LzaPOQtOa5+/9vslH92NPk+3dLCNjjtp8MmFPiooHpTCUbO1WF+e36c7zg66ldVA4YS7IKytm7NIFvJ+x1urQxDGYphOjcBpm0cNAZQlIwBme/dUDz7A0tvrqPexowr5R6tgtIx1bhTg5u93TFqhr165kZWWxePFiioqKKCsr4+DBg7z77ru88cYbXHHFFQDN9o1Ub0uN6cL0PjfRPjiWYIeizFHOA2nzeSdzKeaRNdaiydB1g3/++yemPv0p5RWeMUfXTnHMe2YcZ/XvYnF09dM38egM+7ptUsduFRlz1OZzTecAkqt1ipeEvW66R8Xx8pDrmLH2G9bl7afCdPPQqi/YlJ/Nw6kXE6DJvrNNgalnYxbcBa60oydDb0JF/B2lAi2Ly1s69mxHREwYxfmlbFy2FcMwqpadCiFEU2K323G73bRu3ZoxY8bw0EMPMWDAAGw2G5mZmZSUlHDrrbcyduxYq0NtclqHtOCJlLG8uvNLVuXtwGk3eW3nl+wo3s/fe15HsK35v575gsKich57/gt+S8usOjd8WDIP3HExIcHN//+oRVQoHVvHsPtAPlsycqhwuAgO8u+VMKJp8MmRb8vgMGKDwtAVpBflyTu0dRQTGMrMgVdwVccUgivr2t/ZuYpb/vcOhytKrQ7P75nO3zz7q1cl60GoqCfRIqf5RLIOoGkavYZ66tiLDheTJZ1bLSH1ZEKcXPW92B944AHmzJlDq1atCAoK4qqrruLll1/mjjvukJn14wixB3Fv0lWMbH82gW5FkEPxXXYak357lexy6UdktR0ZB5l4/4KqZN2mKe784/lMu/cPPpGsH9E3ybMsXtcNNu08YHE0/knGHLX55Aw7eBrPrSwvodBVTr6zjBZB/rV1ircEaDYm9xxGt8hYXtj0I5pbZ9Wh3Vzz3Ru8dvYoesW0tjpEv2OaJpQtwCx+EqjsnK619WzZFtDL0tgaQsrQHvz62WrAU8fesWd7iyPyP7LFihAnVz1hBzjzzDM588wzaz3O5fIsI/b3GvZj0ZTGde3PpmNoHK/s+ALlcLHT3M9tK1/k8ZSbOKNFV6tD9Evf/G8zT7/6DQ6nZ8wRHRnC4/dfQb/eHSyOzPtSk9vy6dINgGc/9v69fO9rbOpkzFGbT86wg6fxnH6k8VyRLIuvr0va9eC5M68iPiCUMBfklBYy+vu3+HTPRqtD8yumWY5ZeD9m8XSqkvXAIajYD30yWQepY28K5N1uIU7uSA37ES6Xi8WLF/P000/z/vvvA3Dw4EHefPNNFi9eDIBhGI0eZ3MwsGUiT6TcRJvAaIIdiqKKUu5dO5cP9vwsqyYbkdut8+Ib3/PE7C+rkvUe3VvxxnM3+2SyDpCaVK3x3DZpPGcFGXPU5rMJe1JUPGblsjPpFO8dPWNa8cqQUfSMSiDMBYbLxX0rPuHJdd+hmzLoaGimOwvz8A1Q8enRk2ETUTHzUFoL6wJrYN3P6ExQiGe53fofN1scjRBCHJtSqqrHhtvt5vXXX+fuu+/m559/5tVXX2X+/PnEx8cTFxfHvHnzqq4Rx9Y+LI4n+oyjb3Qngp0K5TKYvf2/zNz8Pg7dZXV4Pi+voJR7Hnmf9z9fU3Xu8uEpvDT9BuJjIyyMrGG1joskLiYcgA079uN26xZHJIRPJ+yexnO6BhklkrB7S8vgMJ498youbdeDYDcEuU3e2Lac2356jwJnudXh+SzTsQzz8EhwV84wq1BU9AtoEfejlM9WtgAQEBhAj7O6A3Ao6zA5uw9ZHJH/MevRrdVX3+0W4liOzLIbhsH777/PI488wn//+18mTZrEe++9h8vl4pxzzmHPnj0UFxdLwn4S4QEhPNDjOq5oM4hAlyLQqfhy/yruXP1Pch2FVofnszZt28+E+xawbrNnhtlu17h/0kX87S8jCAr07TGHUorUZE+3+AqHm227D1ockf+RMUdtPpuwd4uMxVa1tVue1eH4lECbnXt7n8edPYcRamiEuuHn7F2M/G4+2wvlF5s3maaJWTIHM38CmAWek7ZOqBbvo4IvtTS2xtS7xn7ssiy+sZmAadbxsDp4IRqRzWbDNE0CAwOpqKigW7duAFx66aWUl5ezc+dOgoKCaNGiBZmZmQCyxPskbEpjTKdzubP7FYQadoKdii2Fe5iw4kU2Fuy2Ojyf8+k367hz6iJy80oAiGsZzsvTb+DKi/taHFnj6Vt9Wbw0u210MuaozWcT9iCbnU7hLdEV7C7Jx2XIkhZvUkpxZccUnjrzClraQwh1wd7iPEYt+Rdf791qdXg+wTRKMAvuxCyZRdWvoKDzUS0/QAV0tzS2xpZSvY5dEvZGZ6DqdQjhL2w2W1Vd+gUXXMAPP/zAzp07iYiIoF27dqxbt44FCxYQHx9PVFQUIMviT9WQuB48mjKWuIBIgisU+eXF3Ll6Dp/vW2l1aD7B4XTz1Ctf88xr3+KqXAbet2c75j07jl5JbSyOrnGlJlXfj13q2BubjDlq89mEHTyN5wwFbkNnX6ksnWoIfVq05eUh15EUEUuYC5xOJ5OXf8DsjUsxZNagzkx3OubhUeD4pvKMQoXfhYp+DaVFWhqbFXoMTsRm93Rg3iCN5xqdNIAR4tTY7faqOva//vWv7Nq1i0mTJnHfffexefNmHnnkEd544w3Gjh1Lhw4dZHb9NHUOT2BGyjh6RrYn2KkwXTpPbvmA57Z+jFsmZuosJ7eIO6e+x+ffbag6N+ryM5j92ChaRPvfLktd2sUSGRYMwLpt+zAM+TltTDLmqM2nE/akKE/CDpBenGttMD4sISSCWYOu4YI23QmprGt/ZcsyJv38H4pdDqvDa3bMiu889er6Ls8JFYGKnoMKn4xSPv0je1whYcF0P6MzAHu27KMwt8jiiIQQorYjS+IB0tLS+N///kd4eDh5eXncfPPNvPbaa/z4449cfvnlGIYhs+t1EBUYxkM9r2dEqzMq69rh46zl3LPmdfKdJVaH1+ys3ZjFbfctYMuObACCAu1Mvfsy7ppwAXa77SRX+yZNU/SpXFVQWFLB7v1SWius5dOdI5KiEjCVwlQmGdIpvkEF2wP4e5/hdIuIY9625Wimyff7t3PdkvnMOft6Oke0tDrEJs80dcySl6D01aMn7d1R0a+g7J0si6up6D20B1tX7gRg47KtnH117f2NRcMwTIWSPVGFOCWBgYG43W7OPvtsvvvuO+Lj4wkICKiaeQcoLS0lLMz/Zi69xa7ZuLXLcDqFxfNG+rcop866/AwmrHiR/+t7M8mR7U5+Ez9nmibvf76GV99cil45g9w6PpIZf7+a7p3jLY7OeqlJ7Vi2Jh3wbO/WuZ2MYxuLjDlq8+npuuRozy8cXUFGibw71tCUUozqksqMAX8gxhZEmAsyi3IZuWQ+Sw/stDq8Js00CjHz/1QzWQ++FNXiP5KsV6pexy6N5xpXnZu/VB5C+BObzTMrGRQURJs2bcjPz69K1vfu3cv999/P/fffz88//4zb7bYy1GbvvIQ+/KP3DbS0hRHsUOSWF3DHqlf55sCak1/sxyocLp6Y/SUvzf+hKlkfmNqJuc+Mk2S9UvU69rRt0niuMcmYozafTthbh0QSERCEoSC9SGbYG8uAuA68NHgkXcNaEOqCckcFty97j39u/Vnq9Y7BdG3FPHwtOH+sPKOhIv6GipqN0mQG5ojeQ5OrPt4odeyNSurJhDh1RxJ2gEWLFvHSSy9x6JBnO8qnnnqK7OxsAgICmD59OqtWrQKoalQnTl9iRFv+r+8tJIa1Jdih0J1uHt/0Hi9v/1zq2o9hf3YBf/77Qr798ejr6E0jB/HM1GuJigyxMLKmJalzQtUWduu2SuO5xiRjjtp8OmFXSpEUFY+u4FBFCcXOCqtD8httw6KZPfhahsV3IcQFAW6TZzf8wD2/fkyZ22l1eE2GWf45Zt5o0LM8J1Q0KmY+KmyC1Db+TmTLCDr29Cxz3LEmg/KScosjEkKI2ux2O7ruSRS3b99OQEAALVq0oKysjIKCAkaMGMELL7xAUlIS33//PSAJe33FBIYztfdozo/vQ5BLEeCE93b/yP1p8ylylVkdXpOxYk0Gt93/b3Zlet5ACgkOYPoDV/Knm4Zhs/l0SnDaAuw2endrDUD24WKypXeOsJDP/3RWbzyXUSKz7I0p1B7IP/qN4NbuZxKkQ4jL5MusTYz+/i32lhZYHZ6lTNONUTQTs3AKmJWJp703KvZjVNAQa4Nrwo7sx27oBlt+3WFxNP7Dine7X3nlFTp16kRwcDCDBg1i5crjb9305ptvopSqcQQHB//uazCZNm0arVu3JiQkhOHDh7Njh3wPCe+rPsMeHx/Pnj17sNls5OTkEBERQXR0NADdunVjyxbPLKe8QVt/gZqdiV1HML7zcIIMG0FOxW+Hd3DbyhdJL8m2OjxLGYbJ2+//yv3TP6S4xDN51aFtC15/+ibOHZxocXRNlyyLt4bMsNfmVwl7ujSea3SaUoztNoDHz7iUSC2AMBdsK8jm2u/eYPnBDKvDs4SpH8bMHw9l/zp6MuRaVMuFKFvb418opI7dIoap6nWcrkWLFjFlyhQeeeQR1qxZQ9++fRkxYgQHDx487jWRkZEcOHCg6ti9e3eNzz/99NO8+OKLzJkzhxUrVhAWFsaIESOoqJCVV8K7NE2rStrPOOMM9uzZw44dO9i3bx8bNmwgJSUF0zRp2bIlbdp4OlFXT/JF3SmluLj1GUztOZpoLZRgh+JAaR5/+u1l/ndww8lv4INKyxxMffq/zF24rKq+d+iZ3Xj96bF0ai+N1E6kb/LR5oWyLL7xNPaYoznw+YQ9OToBlMJQkFEsjeesMjihMy8Ovo72IVGEuaCooozxPy7kzR0r/aqu3XStxzx8DThXVJ4JQEU+ioqciVLBJ7xWQMowqWO3QmM3gJk1axYTJ05k/Pjx9OzZkzlz5hAaGsr8+fOPe41SilatWlUdCQkJ1eI3mT17NlOnTuWqq66iT58+vP322+zfv59PPvmkDv8iQpxYQEAAAH379qVfv37cfffdPPnkk3Tr1o127dqhlKJbt27ceuut1gbqo3pEtWdG33F0CU0gxKFwOpw8vH4B83Z9jWH6T/lBZtZhbn/gHX5a4Wn8qxRMHDOUGX+7irDQIIuja/p6d2uNTfMkgDLD3nisaDp3Oqv65s6dy7Bhw4iJiSEmJobhw4ef8PHe4PMJe/fIOAB0DdnazWIdw2N4efB1DIrtSKgLbG6DGWnf8LffPsOh+36nXLPsfczDN4JRuTRPi0e1WIAKHSPLIU9RfIc44jvEArB5+XZcTpfFEYlTVVRUVONwOBzHfJzT6WT16tUMHz686pymaQwfPpzly5cf9/4lJSV07NiR9u3bc9VVV7Fp06aqz2VkZJCdnV3jnlFRUQwaNOiE9xSiro7MmIeEhPDEE09w2WWXcfHFF/PUU09VfW7gwIH06NHjRLcR9RAXFMWjvW/k7Ngenrp2F7yZsYQH171Fqdv3V9b8+OsObn/g3+zZ55msCg8L4umHr+XmUWehaTLmOBWhwYEkdfK8+Zux7zAFxdIPwRed7qq+pUuXcuONN/LDDz+wfPly2rdvz8UXX8y+fQ33po7PJ+zhAUG0C4vGUJBZfBjDj2Zzm6LwwCAe738pN3bpR5DbU9f+ceY6xvzwNgfKfLOhh2k6MQqnYRY9DFQmmAFnoFp+hAo8w9LYmqMjy+KdFS52rE63OBr/4HnXuq71ZJ57tG/fnqioqKpj5syZx3yu3NxcdF2vMUMOkJCQQHb2setQk5KSmD9/Pv/973/597//jWEYDBkyhL17PUsYj1x3OvcUoj7sdnvVx8HBwUyePJm77rqLrVu38s9//pP58+ezbNmyqu7xomEE2QL5S/fLGdvxPALdGkEOxc+HtnD7ypfZU3r8EpvmTNcNXv/3Tzz81H8pr/CMObp0jGXeM+M4q38Xi6NrfvpWq2NfJ7PsjcIbY47Tcbqr+t555x3uuOMOUlNTSU5OZt68eRiGwZIlS+r5lR+f/eQPaf6So+I5UJxPudvNgbJC2oZFWx2SX7MpjT8mDaZrZBzPbvgezeVmQ94+rv3uDV4ech39Y9tbHaLXmHo2ZsFd4Eo7ejL0JlTE31Eq0LK4mrPeQ3uw5J2fANjw01Z6Dk6yOCLfV59GLkeuy8rKIjIysup8UJD3lmMOHjyYwYMHV/19yJAh9OjRg3/+85888cQTXnseIU7V72vSc3JyeOqpp0hLSwOgtLSUFi1a0KVLF+655x66d++OYRhV+7UL71FKcXnbM+kQGseL2z+j2FHBHvMgE1e+zKMpNzI41ndWORQVl/PY81+wcm1m1bnhw5J54I6LCQmWMUddpCa35d2vVgOQtnUf5w7obnFEvs8bY46iopqTgEFBQcccdxxZ1ffggw9WnTuVVX3VlZWV4XK5aNGiRZ1iPhV+8cpQs1O81LE3Fee27sbss66lTXAEYS7ILy9h3NIFvJe+xurQvMJ0/ubZX70qWQ9CRT2JFjlNkvV6kDr2xmfW8wBPU7jqx/ES9tjY2KqO2tXl5OTQqlWrU4o3ICCAfv36sXOnp27zyHX1uacQp+P3CfuHH37IqlWrePzxx7n88stJTEzkq6++IiQkhGeeeQbAr/q5WKFPTGdm9BlHx+A4gh2KCmcFD6S9yYKM733i335nxkFuu//fVcm6TVPc+cfzmXbvHyRZrweZYW983hhzNOSqvt/729/+Rps2bWqU3XmbfyTs0QmYSmEqqWNvarpGxvLykOs4o0VbQl2AW+cfq79k2uovcRq61eHViWmamKVvY+bdAkau56TWBtXyPVTItdYG5wM69GhHVGwEAJt+3ir7F/uYwMBA+vfvX2Np2ZGlZtVn0U9E13U2bNhA69aePXQ7d+5Mq1atatyzqKiIFStWnPI9hTgdSqmqpP3QoUN8++23/OUvf2Ho0KGce+657Nq1C4CJEyeyatUqQDrFN4aEkBgeSxnLmS0SCXIq7C6Tf+5azLQN71CuO60Or86++d9m/vz3hRzIKQQgOjKE5x8bxfVX9JceOfUUHRFK57aebvrbMnMoq2i+3yf+JCsri8LCwqqj+gy6Nz355JO89957fPzxx7W2k/Umv0jYk6PiATyd4oskYW9qogJD+L8BV3Btpz4EuyHYbfLurtXc8r9/k1tRYnV4p8U0yzELH8Asng5UNtILHIyK/QgV0MvS2HyFUoreQz2z7MX5pezelGVxRL6vsfdEnTJlCnPnzuWtt95iy5YtTJo0idLSUsaPHw/AzTffXOPF9/HHH+ebb74hPT2dNWvWcNNNN7F7925uu+02wPM9c8899zB9+nQ+/fRTNmzYwM0330ybNm24+uqrvfJvJMTvHUnAW7Zsye7duznrrLMAaNOmDeXl5TidTnRdJzIykvz8fCtD9Ssh9kDuSbqSUe2HEeBWBDkUP+Ss58+/vcL+8ua1CtPt1nnxje95YvaXOJyeMUePbq2Y99w4+vXuYHF0vuPIfuy6YbJx5wGLo/F93hhzNMaqvmeffZYnn3ySb775hj59+njniz8Ov0jYO4THEGyzoyvZi72psmsak3oM5YGUCwg1bYS6YfWhPVzz3RtsyNtvdXinxHRnYR6+ASr+e/Rk2ERUzBsoreHqWvxR76HV92PfamEkfsIb69NOw+jRo3n22WeZNm0aqamppKWlsXjx4qola3v27OHAgaODpvz8fCZOnEiPHj247LLLKCoq4pdffqFnz55Vj3nggQe48847uf322xk4cCAlJSUsXry4Qd8RF/7NbrdX1aVHRkZWlWjExcURERHBihUrmD9/Puecc458HzYyTWlc234wf02+ljACCXYo0osOMHHli6zO22l1eKckr6CUex55n/c/P1pGePnwFF6acQMJsZEnuFKcLtmPvZE14pijrqv6nn76aZ544gkWL17MgAEDTu9J68AvEnab0ugeGYehYH9ZIeVuWc7SVF3ULplZg64mITCMMBccLC3ixh/e5pPd660O7YRMxzLMwyPBXVlTrUJR0S+gRdyPUn7R27FRHekUD7BB6tgbXn3e6a5j45jJkyeze/duHA4HK1asYNCgQVWfW7p0KW+++WbV359//vmqx2ZnZ/PFF1/Qr1+/GvdTSvH444+TnZ1NRUUF3333HYmJiXWKTYhTYbPZqmqjhw0bxueff87u3bux2+306tWL2267jR07djBq1ChCQkIsjtY/9W/RjSf63ESboBiCHYriijKmrJ3Hf/b81KTr2jdtP8Btf13Aus2e5NFu17h/0kX87S8jCAqUMYe3pVarY5f92BtBI485TndV31NPPcU//vEP5s+fT6dOncjOziY7O5uSkoZbFewXCTt4Gs/pyvPGy+4SWXrWlCVHJ/DKkOtIiWpFmAsMl4v7V37K/6V9i7uJ1SubpolZ8k/M/NvALPCctHVCtXgfFXyppbH5sm79OhMc5lnetPGnLU16YCWE8E92u72qfvi6666ja9euVQO6CRMm8Mwzz/D++++TkpJiZZh+r11oLNNTxtEvugvBToVyGby4/TNmbP4PDt1ldXi1fPrNeu58+D0OHfZ8L8W2COfl6Tdw5cV9LY7Md7WKjaRVS0/vnI07D+ByN88eS+LYTndV32uvvYbT6eS6666jdevWVcezzz7bYDH6zdtwSdEJ1TrFHyY5OuHEFwhLtQgK46lBV/HK5p/4Mmszmmnyr+2/sq0wh9lnXUtMUKjVIWIaJZiFD4Lj66Mng85HRT2D0mQ5WkOy2W30HJzImu82kLsvj+zMg7TuLD/TDcWzJ2rdrxXCH2maVjXL3rdvX/r2PZpQ9e/fv2oZpWznZr2wgGD+2uNa3t/zE//dtwLNgMX7V5NZmsP/9bmZ+OBoq0PE6XLz/OtL+Py7DVXn+vZsx+P3X0GL6DALI/MPfZPbkf3zFhxON9sycujdvY3VIfksK8YckydPZvLkycf83NKlS2v8PTMzs25PUg9+8wqRHBUPSmEoSJfGc81CoGbj3t7ncXevcwg1NELdsDwng2uXzGdrQc7Jb9CATHc65uFRNZJ1FX4nKvo1SdYbSfU69o1Sx96gGrvpnBC+4nid36t37pZkvWmwKY0bOp7LXYlXEmbYCXYothXs5baVL7K+INPS2A7mFjP54fdqJOvX/eEMZj82SpL1RiLL4huPjDlq85tXicTqneKl8VyzcnmH3jw96Epi7SGEuWB/cT7Xf/8mX+21pnbZrFiCefg60D3b8qAiUNH/9CTsym9+pCxXo479J6ljb1BH6sLqegjhp+x2v1nI6DMGxybzaJ+xJARGEexQFJSXcNfqf/LJ3l8tiWftxixu++sCtuzw7AkdFGhn6t2XcfdtF2C3y1aAjSU16WjjubRt0niuQcmYoxa/yS5aBIUSHxyOriCjOE9qXpuZlJg2vDxkFEmRcYS5wOV0ctfyD5m14QeM0/i/LCkpIS0tjRUrVpCWlnZaDSJMU8cofgGzYBKYldfZu6NafogKPv90vyRRT8mDumMP8AxWNkrjuQZ1ZHlaXQ8h/NWxZthN06w1BpExSdPSKSyBGSnj6B3ZkWCnApfOs1s/4pktH+Iy3Kd8n/qNOUz+89lq7n3kP+QXlgHQOj6S154cw4jzep7kauFtndq2ICrcs5vD+m37MQz5mW0oMuaozW8SdvA0njM0KHJVkOsotToccZriQ8KZNehqhrdNJMQNQW6T17b+zJ9+XkSxq+K4123evJm77rqLHj16EBkZSb9+/TjrrLPo168fkZGR9OjRg7vuuovNmzcf9x6mUYiZ/ycofeXoyeBLUS3+g7J38uJXKU5VcGgQ3ft3ASBr237ycwqsDUgIIX7n9zPspmmilKpaEl9QUIDT6UQpJUl7ExMRGMrfe17Hpa36E+hSBDrhv3tXcPea18lzFB/3Om+MOSocLp6Y/SUvzf8BvTIxHJjaibnPjKN753ivf63i5JRS9K1cFl9UWkH63lyLIxL+xL8S9ugE9MqVEpnFedYGI+okyBbAAykX8ufkswkxFKEuk//t38F1S/5F+u9KHTIyMrj00kvp1asXixYt4vzzz+eNN97g119/Zf369fz666+88cYbnH/++SxatIhevXpx6aWXkpGRUeM+pmubZ8s254+VZzRUxN9QUbNRmtSOWSmleh37MqljbzCNvA+7EL7i9zPsSimKiop46aWXuP322/nrX//Kk08+yfvvv1+jrl00DXbNxs1dLuTPXS8jxAgg2KnYkJ/JhJUvsrUoq8ZjvTXm2J9dwKS/L+TbH4+uHLtp5CCemXotUZGy/Z+V+tZYFi917A1Gxhy1+FXCnhwVj6kUpoL0YnlnrLlSSjGyc1/+b8AVxNiCCXVBZlEuI7+bz/f7dwAwb948UlJS2LJlC++88w5ZWVm8+uqrjB8/nkGDBpGSksKgQYMYP348r776KllZWbzzzjts3ryZlJQU5s2bB4BZ/jlm3vWg76l88mhUzHxU2AQZXDUBvaWOvVFIAxgh6kYpVaOpXF5eHnfffTdffPEFuq7z22+/ERwczBtvvMGcOXMsjFScyLkJvXmk943E2iMIdigOlxdyx6rXWHxgNeC9MceKNRncdv+/2Zl5CICQ4ACmP3Alf7ppGDabXw3Zm6TU5KON59ZJHXuDkTFHbX7101+z8ZzMsDd3Z8S246XBI+ka3pJQF1Q4K/jzz4u48u7bmThxIjfeeCMbNmxgzJgxBAYGnvBegYGBjBkzho0bN3LjjTcyceJEpv/jYszCKWCWex5k742K/RgVNKQRvjpxKnqdnVT1sdSxNzB5p1uIOqm+LH7p0qXs2bOHF154gWnTpmGz2XjggQeYPn06b775JoWFhRZGKk6ka0Rrpve5maSwtgQ7FIbTzfRNi7j83nFeGXNcd+OfuX/6hxSXeEr82reJ4Z9Pj+XcwYmN8eWJU5DUMZ7gIM/Pc9rWfVLG0pBkzFGDXyXsXSJaYleaZ2s36RTvE9qERfHCWddwbkJXQlxQ8u0qPntxLk888QRz584lIiLitO4XERHB3Llzefzxx/nH9G95Y2Hl4CnkWlTLhShb2xPfQDSqyBYRdE7pAMCutExKi8osjkgIIWo6shc7wEcffcTIkSNJSkqiTZs2hISEsGbNGgYMGEBYWBhbtnjeeJREoGmKCQxjau/RXJDQl0CX4tBn6/li9r+9Mub48L1/ciBjJQBDz+zG60/fROf2sQ3xZYg6stttpFTuv34ov4QDh4osjkj4C79K2INsdrpEtERXkFWSj9PQrQ5JeEGIPZCpqRdzZXhHDi1YzIQJE5g6dWqNx2zatIlRo0bRpUsXQkNDiY2N5ZxzzuGzzz475j2nTp3KhAkTuHdaHpl5d6AiZ6JUcGN8OeI0HdmP3TBMNi/fbnE0vkmWpwlRd3a7HcMwANB1vWr2NSAggHbt2rFnzx7y8/MJCQmhrEzedGzqAjQ7E7uO4IrAFDLmLvXqmGP3pk+5anhnZvztKsLDghrjyxGnSbZ3a3gy5qjNrxJ2gKToeAwFbtNgb2mB1eEIL1FKsezlt2mTkMDzzz9f6/O7d++muLiYW265hRdeeIF//OMfAFx55ZW8/vrrx7zfrFmzaNmyNX+572upV2/Cqu/HvlHq2BuGNIARos6qz7CnpqayefNm3G7P1mCJiYm89957PPHEE3Tp0oUhQzwlV/Ka0/T995k3aR3v3TFHq1YJLPl8Hpom//9NVWrS0ZWWaVul8VyDkDFHLfaTP8S3JEUl8JnaCEB6US5dIlpaHJHwhm3btrFkyRLeeeedYy5Ju+yyy7jssstqnJs8eTL9+/dn1qxZ3H777bWuiYyMZObMJxk7dixbtmyhR48etR4jrJcyLLnq4w1Sx95AVOVR12uF8F82m62q8dz555/PM888w6JFixg7diyDBg3i888/JzIykjvvvJPgYFnJ1Rw01JjjySdnypijievVrTV2m4ZbN6TxXIORMcfv+d8Me1Q8KCWN53zMm2++SXx8PNddd90pX2Oz2Wjfvj0FBQXHfczIkSOJj4/ntdde80KUoiHEtm1Jq8p9abeu2InT4bI4IiGEqOnIMvi+ffty9913c8YZZwCeBP7jjz/m9ddfJyUlRWrXmwkZc/iv4KAAkjsnALD7QD55hVLGIhqefybsVHaKL5HGc75i6dKljBw58qSdWUtLS8nNzWXXrl08//zzfPXVV1x44YXHfXxQUBAjR47ku+++83bIwouOLIt3OVxsX7XL4mh8kCxPE6JejuzHHhQUxNChQ6tmTzMzM1mzZg1z587l008/Rdelt05zIGMO/9a32rL4ddtlWbzXyZijFr9L2FuFRBAVEOxJ2IskYfcFxcXF7Ny5k4EDB570sffddx9xcXF069aNv/71r1xzzTW8/PLLJ7xmwIABbN26lZKSEm+FLLzsSOM5kDr2BiEvnkLUS/Wt3QCWL1/OZZddxrXXXsuzzz7LRx99xKxZs7j//vvJzMwEqGpUJ5oWGXOI1OSjjefWbZVl8V4nY45a/C5hV0qRFB2PriDXUUqhs9zqkEQ9ZWZmYpomPXv2POlj77nnHr799lveeustLr30UnRdx+l0nvCaXr16YZomO3fu9FbIwsukjr2Bmap+hxB+7sgMO8DevXt56aWX6NixI1999RW//PILX331FY888giZmZm8//77AFWN6UTTImMO0SexTdXHadtkht3rZMxRi98l7OBpPGdUfuWZsh97s3fkxS80NPSkj01OTmb48OHcfPPNfP7555SUlHDFFVecsG4wJCQEAIfD4Z2Ahde1S2xDdHwUAJt+3ibLSoUQTYrNZquaMV+zZg2HDh3i/vvvp0uXLrjdbkzT5Pzzz+eqq65i7dq1wNG6d6lrb1pkzCGiwkPo2i4WgO2ZByktP/GbMELUl58m7HEcWWiWLo3nmr0jg5q67F973XXX8dtvv7F9+/H37y4v96zCCAqSPVGbKqUUvYd6ZtlLC8vI2LDH4oh8i2nW7xDC32maVtUpPjY2lrKyMrp06QJ4lssf2cYtKyuLq666qurjX3/9VbZ4a2JkzCEA+iZ76tgN02TDjv0WR+NbZMxRm58m7AnVOsXLDHtz17lzZ5RSbN68+bSvPfLCWFhYeNzHbNq0CaUU3bp1q3OMouGl1Khj32phJD5I6smEqLeAgAAA+vXrxwUXXMDTTz+Ny+UiLy+P1atX89xzz/Hpp5+yZMkSbrrpJu655x4ee+wxqWVuYmTMIeD3+7FLHbtXyZijFr/bhx2ge1QcCtA1SJeEvdkLDw+nW7du/Pbbb4wfP/6Yjzl48CDx8fE1zrlcLt5++21CQkJOWIu2atUqkpOTCQ8P92rcwrt6/66O/eo7L7UwGh9Tn7owH60nE+J02e12XC4XISEhREdH884777Bo0SKio6MJCAigqKiIrl27EhkZSefOnWnVqhXR0dEyw97EyJhDAKQmVWs8J3Xs3iVjjlr8MmEPswfSITyGA4V57C7JQzcNbMovFxv4jPPOO48PP/yQ2bNnH3OblT/96U8UFRVxzjnn0LZtW7Kzs3nnnXfYunUrzz333HFfGB0OBx9++CGjR49u6C9B1FPXvp0ICQ+mvKSCjT9twTRNGegKIZqMI3XsmqZhGAZ9+vShXbt2tG7dmrZt29K2bVtatGhBixYtiImJsTpccQIy5hDxLSNoHRfJgUNFbNp1AKfLTWCAX6ZVohH47XdWUlQCe4vyqHC7OVBWRLuwaKtDEvVw6623MnfuXD744APGjBlT6/OjR4/mjTfe4LXXXuPw4cNERETQv39/nnrqKa688srj3vfDDz/k4MGDTJo0qSHDF15gs9vodXYSq75eR152Aft3ZdO2W2urw/IJyvQcdb1WCFGzU/xNN92EruvEx8cfdy9v0zQxTbOq9l00HTLmEAD9kttx4NBmnC6dLek5NfZnF3UnY47a/Dhhj+PbvZ7tn9KLD0vC3swlJSVx4YUX8tBDD3HFFVcQERFR4/M33HADN9xww2nds6ioiAcffJBLLrmEHj16nPwCYbneQ3uw6ut1AGz4aask7N5Sn7owH33xFOJ02Wy2quS7deujv5uWLVvGTz/9xJ49e9B1nWHDhnHTTTehlJJVQk2UjDkEQN+ktnz5k6eXwbpteyVh9xYZc9Tit2/bJkUlYCqFKY3nfMbTTz9Nbm4u9957b73vZZom9913H4cPH+bVV1/1QnSiMaQMq954TvZj9xrZE1WIelNKYZomRUVFAOTn53PrrbcyYcIEli1bRmBgIJGRkcydO5e///3vFkcrTkbGHKJ6Hbvsx+5FMuaoxW9n2JOjPc1ADAUZRZKw+4KOHTsyffp07r33Xjp16sTUqVPrdB/TNJk+fTrz5s1j3rx5dO7c2cuRioaSfGY3AgLtuJxuNiyThN1r5N1uIerNNE0+/fRTIiMjOf/881mwYAH79+/nk08+qTGj+uOPP3LXXXdxzz331JiJF02LjDlEh9YxxESGkl9Uxvrt+9ENA5uUsNSfjDlq8dvvqvZhMYTYAtAVZJTIXuy+Yty4cTz00EP84x//4LbbbqO4uPi0ri8qKuL2229n2rRpzJgxgwkTJjRQpKIhBAYHkjiwKwD7d2aTl51vcURCCOGhlOK1114jNzcXgG+++Ybrr7+eHj16oOs65eXlGIbBOeecQ8eOHcnMzAQ8CZ1ommTM4d+UUlXL4EvKHKRn5VockfBVfpuwa0qRGBWPoWB/WSFlbqfVIQkvmTJlChffPYm33vk3PXr1ZOHChTidJ/7/dTgcLFy4kJSUFN59913mzZvHQw891EgRC2+qvh/7BtmP3TtkT1QhvCIkJKRqSXyLFi0oKysDPPXtISEhaJrGF198QZ8+fejYsaOVoYpTNGXKFG66fAJvv7WAHsky5vA3NfZjl2Xx3iFjjlr8dkk8eBrPbcjdC0BmcR49Y1pZHJHwhjU5+zjQswNtH7mb/Pc+Z+zYsdx7772MHDmSAQMG0KtXL0JCQigvL2fTpk2sWrWqqjPrJZdcwquvvipL0pqx3sN6wFOfAJ469nNHDbY2IF8gy9OE8Ipzzz2XJUuWcMUVV/DMM88wZ84cnnvuOa655hp27drFmjVr+OKLL8jJyUEpxeOPP45hGDU6zIumJWv7AUo32RkadTWb836VMYefSU2uVse+dS+jLu5nYTQ+QsYctfh5wp6AUdmbIKPksCTsPsDhdjFr7TJ0BSS05NX33qGfEcicOXP47rvvmDNnTo3lhUopkpOTGT16NJMmTZLOrD6g15CkquZOUsfuJfVp5OKjDWCEqIsbbriBdevWMWrUKHr27MmOHTs4cOAAr7/+OrGxscTExJCSksLll19OcnIygCTrTZiuG7w1/SN0l06gK4znHn2Jfld0kzGHH+nWIY7Q4ADKKlys27YP0zRld4f6kjFHLf6dsEfHg1IYypTGcz5iwdY09pUWUW5XDIhvy41JfdGU4sUXXwSgpKSEnTt34nA4CAoKolu3boSHh1sctfCm8OgwOvfpQPq63aSv201pYSlhUWFWhyWEEPTq1Ytnn32W1157jfz8fC688ELi4+Np06YNbdu2pWXLloSHhxMYGEhISIjV4YqT+OH9X8nYuBdXmUGHpNaMuudSAoMCZMzhR+w2jZTubVixYTe5BaXsO1hIu4Roq8MSPsa/E/aoo53id8nWbs1eemEe721fj0NT2Gw2Zp49Au1373KGh4eTmppqTYCi0aQM7UH6ut2YpsnGn7cx6LIzrA6pWVOm56jrtUKIo9q2bcvUqVPRdR2Hw0FwcDCaplFWVkZhYSFKKUnWm4G87AI+fuVr3A4Dw21y1wu3EBgUUOMxMubwD32T2rFiw27AsyxeEvb6kTFHbX7bdA4gOjCEViER6BpkluRJJ9ZmzDBNnlvzEy4MHBpMShlE9+hYq8MSFpH92L1MGsAI4TU2mw1d17HZbISGhqJpGr/88gsPP/wwf/vb37j++uu54YYb+Pnnn60OVRyHaZq889SnlJc4cZcbXHrrufQenGh1WMIiqcnVG8/ttTASHyFjjlr8OmEHzyy7rqDE5eBQRYnV4Yg6+jR9C5vzDlKuKbpEteCOPtJozJ/1rpawSx27EKIpsdvt2Gw2DMMA4MMPP+RPf/oTubm55OTk0LZtW6699lpmzZrFxx9/DICu61aGLH5nzfebSPvfFlxlOjEJUUx4bJTVIQkL9ezaCrvNk1KlbZVO8cL7JGGv1nguXZbFN0uHykqZt3ElTk2ha4r/O3sEwXa/rvbwey1bx9CmawIA23/bhbNCtm0UQjQNR5rIaZpGTk4On332GWPGjGHBggWMGzcOm83G9ddfz4UXXsjChQstjlb8XllxOQuf+QzdZWK4TCY9NYbw6FCrwxIWCg4MoEcXT+PqvTkFHC4otTgicbpeeeUVOnXqRHBwMIMGDWLlypXHfeymTZsYOXIknTp1QinF7NmzGzw+Sdij4zGVwlSQIQl7s/TSuuWUuF04NLi+ewpntepgdUiiCUgZ1hMAl9PN1pU7LY6meVMcrSk77cPq4IVoYpRSVUl7SUkJWVlZjB07FoB27dqxadMmAAYNGsT+/fsB6RTflHz0ytcUHCzCVaZz5og+DLt6gNUhiSagX/Xt3WRZfL009phj0aJFTJkyhUceeYQ1a9bQt29fRowYwcGDB4/5+LKyMrp06cKTTz5Jq1aNs8OY3yfsydUaz8kMe/OzbF8mP+3PoNymaBESxkMDz7M6JNFE1FgWL3Xs9XNki5W6HkKIGo4k4O3btycnJ4eAAE+zssTERMrLywFYv349iYmJVFRUWBanqGnn+t0sfX8lrnKd4NAg/vLsTbKFlwB+V8cuy+LrxwtjjqKiohqHw+E47tPNmjWLiRMnMn78eHr27MmcOXMIDQ1l/vz5x3z8wIEDeeaZZ7jhhhsICgpqkH+C3/P7hL1zREsClIauILM4z+pwxGkodTp5Yd3PuJXCrSmmDbqA6CDprCs8UoYlV328UerY60cawAjhVTabDdM0CQwMpH379qxYsQJd14mLiyM4OJgxY8Ywe/ZsRo8eTXBwsNXhCjyrtd6e/jG620B3mNwy9RoSOkhzW+GR0r0NR967WScz7PXjhTFH+/btiYqKqjpmzpx5zKdyOp2sXr2a4cOHV53TNI3hw4ezfPnyBvny6sLvE/YAzUbXyFgMBVml+Th1t9UhiVM0f/MqcsvLKLfBOW07c2XnHie/SPiNNl1b0aJVNACbf9kuTZuEEE2G3W6vajr3hz/8gf/973/s3r2bgIAArrjiCsLCwnj11Ve55JJLLI5UHPHNgp/YtzMHV5lO99SOXPmn4Se/SPiNiLBgurWPA2DHnkOUlB1/Rlc0vKysLAoLC6uOBx988JiPy83NRdd1EhISapxPSEggOzu7MUI9JdKZC0+n+B35OeimyZ7SfLpFxlkdkjiJzXk5fLxrExU2RZA9gBmDL5JlaaIGpRS9h/Xgx/eXU1ZcTvq63XQ/o4vVYTVP9Zkplxl2IWqx2WxVy+LHjh1LTk4O0dHRAPzxj3/ENM1Gq40UJ5ezJ5dP536Pu8JAoXH3i7dis/n9nJf4nb7Jbdmx5xCmCeu372dIamerQ2qevDDmiIyMJDIy0lsRWU5+2wBJ0QnolbleRpHUsTd1LkPnuTXLcCtwKpjSbyjtI6KtDks0QSlDpY7dG+rc/KXyEELUZLPZqt5kjomJITk5mRYtWgCemR1J1psO0zRZMOMTXBVu3BUG19xxMd36drQ6LNEEpSYdbTwny+LrrjHHHLGxsdhsNnJycmqcz8nJaVK/hyVhp7LxnFKexnMlUsfe1L2/fSPphXmU2xQ9Wybwx17SoVUcW2+pY/cOqWEXwuuk83vz8Mvna9jy2y5cZTrxHVoy7sGrrA5JNFGpSdUaz22TxnN11ohjjsDAQPr378+SJUuqzhmGwZIlSxg8eHB9vxKvkSXxeJbEg6dTvGzt1rTtKynkra1rcGgKNI2ZQ0Zg1+R9J3FsnVM6EBoZQllRORt+2oppmlI6IYRoEjTNwDQNlJLXsKaqKL+ERbO+QHcaGG6TO2eNIziscbpCi+YnNiacdgnR7M0pYPOubBxON0GBkmo1dVOmTOGWW25hwIABnHnmmcyePZvS0lLGjx8PwM0330zbtm2rGtc5nU42b95c9fG+fftIS0sjPDycbt26NUiM8ioBxAWHExMYii4Je5Nmmiaz1/5MheHGocGtPc6gb1xrq8MSTZjNZqPX2Z5Z9oKDhezbccDiiJopmWEXwqtM1xbsrs8xS17FNKXZbVP1n1lfUlJQjqvc4LzrBjHwoj5WhySauL6Vs+wut86W9KbTtKxZaeQxx+jRo3n22WeZNm0aqamppKWlsXjx4qpGdHv27OHAgaPjx/3799OvXz/69evHgQMHePbZZ+nXrx+33XZbnb/kk5G3ffA0p0qKimNVeSl5jjLyHWXEBIVaHZb4ne+ydrLq4D4qbIo24ZHcd8Ywq0MSzUDK0B789tVaANb/uIV2iW0sjqj5qU8tutSwC1GbWToXrewrqAiF4D9AgDSnamo2Ld/B8i/W4i7XCY8M5U8zb7A6JNEMpCa15YsfNwGwduteUpPbneQK8XtWjDkmT57M5MmTj/m5pUuX1vh7p06dMM3GHdzIDHulpOgEjMp/jQzZj73JKXCU88q6X3Fpnj3XHz/rIsICAq0OSzQDsh+7F5iqfocQogZlT8Juq9xqUs+wNhhRi6PcyYKZn2C4TXSnyW3TrycmPsrqsEQz0De5euM5qWOvExlz1CIJe6WkqHiMytpWWRbf9MzZsJICZwUVGvyhUxLDOzRMjYjwPYkDuxEQFABIp/g6kyXxQniXPRGlQNNMTD3d6mjE73w273sO7c3DVaaTMjSJEeNkRZ84Ne0TomkR5Vmlu377fnTDsDiiZkjGHLVIwl4pubLxnK5Jwt7UrMnZx9e7t1NhU4QHBfPIoAutDkk0I4FBASSf6XmDJzvjILn75OdbCGGxAM/KH5tNB5fMsDclWdsP8PXbP+GuMLDb7dw1+2ZpVipOmVKqanu3sgonO3Yfsjgi4QskYa/ULTIODc/WbhklMqBvKhxuF7PWLkNX4NIUf+9/LvGh4VaHJZqZlGHV92PfamEkzZPswy6El2mtQEVi1wxZEt+E6LrBW9M/QnfpuCsMbvjr5bTvLs1txelJTT66vZssiz99MuaoTRL2SiH2ADqGx2AoyCzOwy1LWJqEf29dx77SIsptigHxbbkxqa/VIYlmqHeNhF2WxZ82WZ4mhFcppcCe5JlhN3IxjSKrQxLA0g9WkLFxL64ygw5JrRl1z6VWhySaoSMz7ABpW/daGEkzJWOOWiRhryYpOgFdgdPQ2V9WaHU4fi+9MI93t6/DoSlsNhszzx6BJsvSRB30HJyIpnm+d6TxXB3U551uH33xFKLeApKw2yonB9yZloYiIC+7gI9eXozb4dlz/a4XbiGwsv+JEKeja4dYwkI8jZHTtu1r9I7izZ6MOWqRhL0aT+M5z8dSx24twzR5bs1PuDBwaDApZRDdo2OtDks0U2GRoXRN7QRA5sYsivNLrA1ICOH3lD0RTTNAAW5pPGe1hU9/RnmJE3e5waW3nkvvwYlWhySaKZum0SfRsyw+v6iMrOx8iyMSzZ0k7NUkR8VjKoWpIF0Sdkt9mrGFzXkHKdcUXaJacEefwVaHJJq53kM9y+JN02TTz9ssjqaZkeVpQnifPRmlwKYZ0ineYqu/38japZtxlenEJEQx4bFRVockmrnUpKN17GlSx356ZMxRiyTs1SRFV3aKVzLDbqVDZaXM27ASp6bQNcWMISMIttutDks0cylSx1538uIphPfZu3v+sOngzrA4GP9VVlzOwqc/Q3eZGC6TSU/eSHh0qNVhiWaub7XGc2lbJWE/LTLmqEUS9mrahkYTZg/0dIqXhN0yL61bTonbhUOD67unMLh1B6tDEj6g99Dkqo+ljv30SMdWIbxPaWFg64DNZoC+G9OUZrdW+OiVryk4WISrTOfMEX0Yds1Aq0MSPqBnl1YEBtgAWLdNGs+dDhlz1CYJezWaUiRW1rFnlxdT6nJYHZLfWbYvk5/2Z1BuU7QICeOhgedZHZLwETEJ0bRL9GzPs33VLhzl8vMthLCYPQm7poNZAfoBq6PxOzvX72bp+ytxlesEhwbxl2dvkj3XhVcEBtjp2aUVAPsOFnJIeueIepCE/XeSouLRjzSeK8mzNhg/U+p08sK6n3ErhVtTTBt0AdFBIVaHJXzIkTp2t0tn64qdFkcjhPB79iTPDDuA1LE3KpfTzdvTP0Z3G+gOk1umXkNCB2luK7ynb7Js7ya8QxL230mWTvGWmb95FbnlZZTb4Jy2nbmyc4+TXyTEaahex77+x80WRtLMWFBP9sorr9CpUyeCg4MZNGgQK1euPKXr3nvvPZRSXH311TXO33rrrSilahyXXHJJ3YITwktUQBKaZqKUiSl17I3qmwU/sW9nDq4yne6pHbnyT8OtDkn4mBqN5yRhP3VSw16LJOy/kxQdD0pJHXsj25J3kI93baLCpgiyBzBj8EWyLE14XfWEXerYT11j15MtWrSIKVOm8Mgjj7BmzRr69u3LiBEjOHjw4Amvy8zM5K9//SvDhg075ucvueQSDhw4UHW8++67px+cEN5kT/L8IY3nGlXOnlw+nfs97goDhcbdL96KzSZDYuFdfbq3Qascy0qn+FMnNey1yW+n30mM9HSKNxRkFEnC3hhchs6za37CrcCpYEq/obSPiLY6LOGDWnWOp2WbGAA2L9+O7tYtjkgcy6xZs5g4cSLjx4+nZ8+ezJkzh9DQUObPn3/ca3RdZ+zYsTz22GN06dLlmI8JCgqiVatWVUdMTExDfQlCnBpbe1AhlY3nJGFvDKZpsmDGJ7gq3LgrDK6542K69e1odVjCB4WFBtGtYxwA6XtzKSqtsDgi0VxJwv47kYHBtAmNRNcgveQwpumjb9U0Ie9v30h6YR7lNkXPlgn8sdcAq0MSPkopVTXLXlHqYOdaGSCfsnouTSsqKqpxOBzHbvrndDpZvXo1w4cfXZ6qaRrDhw9n+fLlxw3v8ccfJz4+ngkTJhz3MUuXLiU+Pp6kpCQmTZrE4cPypqywllI2sHf3zLDrBzCNMqtD8nm/fL6GLb/twlWmE9+hJeMevMrqkIQPO7Is3jRhvcyynzpZDl+DJOzHkBSVgK6gzO0ip7zY6nB82r6SQt7eugaHpkDTmDlkBHZNvi1Fw0kZ1rPqY9mP/RR5oZ6sffv2REVFVR0zZ8485lPl5uai6zoJCQk1zickJJCdnX3Ma5YtW8Ybb7zB3Llzj/slXHLJJbz99tssWbKEp556iv/9739ceuml6LqsshAWq2o8Z4J7j9XR+LSi/BIWzfoC3WlguE3unDWO4LAgq8MSPiy1euM5SdhPjdSw12K3OoCmKDkqnqX7twOeOvZWoZEWR+SbTNNk9tqfKTfcOGyKP/Y4g75xra0OS/i4lGE192O/bsoVFkbTPNSnLuzIdVlZWURGHv1dGhTknUFycXEx48aNY+7cucTGHr/D8w033FD1cUpKCn369KFr164sXbqUCy+80CuxCFEXyp6ETaveKT75hI8XdfefWV9SUlCOq9zgvOsGMfCiPlaHJHxc32qN52Q/9lPjjTGHr5GE/RiSouMxlcJUJukleQxO6Gx1SD7pu6ydrDq4jwqbok14JPedcexGUUJ4U8de7YmICaM4v5SNy7ZimqY0OGwEkZGRNRL244mNjcVms5GTk1PjfE5ODq1atar1+F27dpGZmckVVxx948UwPMmP3W5n27ZtdO3atdZ1Xbp0ITY2lp07d0rCLqxlT0IpsNkMdD0d+W3UMDYt38HyL9biLtcJjwzlTzNvOPlFQtRTy6gwOrSOYc+BfLak51DhdBEcGGB1WKKZkbXHx5AYJY3nGlqho4JX1v2KS/Psuf74WRcRFhBodVjCD2iaRq+zPTNYhbnF7NkqS9ROqhGXpwUGBtK/f3+WLFlSdc4wDJYsWcLgwYNrPT45OZkNGzaQlpZWdVx55ZWcf/75pKWl0b59+2M+z969ezl8+DCtW8uqHmGxgEQAbJoOLumr0RAc5U4WzPwEw22iO01um349MfFRVocl/MSRWXa3brBp57FLu0Q1siS+FknYj6FzeEsCNBu6gvTiXKvD8UmvbVhBgbOCCg3+0CmJ4R26WR2S8CO9h1bb3k3q2E+qsbdYmTJlCnPnzuWtt95iy5YtTJo0idLSUsaPHw/AzTffzIMPPghAcHAwvXv3rnFER0cTERFB7969CQwMpKSkhPvvv59ff/2VzMxMlixZwlVXXUW3bt0YMWKEN/+phDhtSosBLQG7zQA9U5rdNoDP5n3Pob15uMp0UoYmMWKcrOgTjSc16WgduyyLPznZ1q02WRJ/DHZNo3tkHDsOH2BfaSEO3UWQTZaveMuanH18vXs7FTZFeFAwjwyS5aiicVWvY9+wbAt/uP0iC6NpBurzrnUdrhs9ejSHDh1i2rRpZGdnk5qayuLFi6sa0e3ZswftNJpT2mw21q9fz1tvvUVBQQFt2rTh4osv5oknnvBaLb0Q9WJPwmb7GcxiMHLBFmd1RD4ja/sBvn77J9wVBna7nbtm3yxlUKJRpSYfrWNPk1V9J9fIY47mQBL240iKimdr3gEMTPaU5NO9cpm8qB+H28WstcvQFbg0xaP9zyU+NNzqsISf6d6/C0EhgTjKnWz8aavV4TR9Frx4Tp48mcmTJx/zc0uXLj3htW+++WaNv4eEhPD111/XLRAhGkNAEjbtJ8/Herok7F6i6wZvTf8I3aXjrjAY99CVtO8uZTCicbWJiyIuJpxD+SVs3Lkft25gt8ki5+OShL0W+W45juToeIzKN2DTi/OsDcaH/HvrOvaVFlFuUwyIb8uNSX2tDkn4oYDAAJIHdQcgZ/chDmZJ6YsQwjrKnoTNZqKUKXXsXrT0gxVkbNyLq8ygQ1JrRt1zqdUhCT+klKqqYy+rcLFj90GLIxLNjSTsx5EYFQ9KeRrPFUvjOW9IL8zj3e3rcGgKm83GzLNHoMmyNGGR3kOrbe8mdewnJPVkQjQwexLg6RRv6pKwe0NedgEfvby4as/1u164hcAgKW8U1kittr2b7Md+YjLmqE0S9uNIrt4pXhrP1Zthmjy35idcGDg0mJQyiO7Rx98zWYiGljLsaOO59T9Kwn5C0rFViIZl7wwEYLfpIAm7Vyx8+jPKS5y4ygwuvfVceg9OtDok4cf6Jh9tPJe2VRrPnZCMOWqRhP04YoPDaRkUVtkpXpbE19enGVvYnHeQck3RJaoFd/SpvT2TEI2p5+BEtMoaso3LJGE/IXnxFKJBKRUI9i7YNAPcWZim0+qQmrXV329k7dLNuMp0YhKimPDYKKtDEn6ua7tYIkI9TU7Xbdsnu0GciIw5apGE/QSSouIxNChwlpPvKLU6nGYrt7yUeRtW4tQUuqaYMWQEwXbpdyisFRIeQrd+nQHYvXkvRYeLLY5ICOHX7EnYbAaggzvL6miarbLichY+/RmG28RwmUx68kbCo0OtDkv4OU1T9En0LIsvKC4nc79MBopTJwn7CSRHx6NL47l6eyltOSVuFw4Nru+ewuDWHawOSQgAUqrXsS+TbvHHI/VkQjQ8ZU/yLIkHWRZfDx+98jUFB4twluqcOaIPw64ZaHVIQgDQt9r2buukjv24ZMxRmyTsJ5AYFY9Z2RQtvUgaz9XFsn2Z/Lg/g3KbokVIGA8NPM/qkISoknJOz6qPN0jjueOT5WlCNLyAJJQCTTMw3elWR9Ms7Vy/m6Xvr8RVrhMcGsRfnr1J9lwXTUY/qWM/NTLmqEXWJZ/AkcZzugYZJdJ47nSVupy8uO4X3Erh1hTTzryA6KAQq8MSokqNTvFSx35c9XnX2lff7RbC6yo7xdttBk53prWxNEMup5u3p3+M7jbQHSYTHrmGhA7S3FY0HcmdEwgKtONwuqVT/AnImKM2mWE/gW6RcWh4tnaTJfGnb/6m1RwqL6XcBue07cyVXXqc/CIhGlFUbCQdeniWqO1Yk0F5aYXFEQkh/JYWDyra03hOlsSftm8W/MS+nTm4ynS6p3bkqj9daHVIQtQQYLfRq2trALJzi8g5XGRxRKK5kIT9BIJsdjpHtERXsLskH7dhWB1Ss7El7yAf79pIhU0RZA9gxuCLZFmaaJJShnreSNLdOlt+3WFxNE2ULE8TosEppSAgCZtNB+MwplFgdUjNRs6eXD6d+z3uCgOFxt0v3orNbrM6LCFqSa1Wx562VWbZj8mCMccrr7xCp06dCA4OZtCgQaxcufKEj3///fdJTk4mODiYlJQUvvzyy7o98SmShP0kkqPjMRS4DZ29ZQVWh9MsuAydZ9f8hFuBU8G9/c6mfUS01WEJcUy9q+3HvlHq2I9NEnYhGoc9CbutcnLALbPsp8I0TRbM+ARXhRt3hcE1ky6iW9+OVoclxDH1TaqWsMuy+GNr5DHHokWLmDJlCo888ghr1qyhb9++jBgxgoMHDx7z8b/88gs33ngjEyZMYO3atVx99dVcffXVbNy48fSf/BRJwn4SiVGehB0gQxrPnZIPdmwkvTCPcpuiZ8sEJvSSDq2i6UqplrBvkDr2Y1L1PIQQp0bZk9A0w/ODIwn7Kfnl8zVs+W0XrjKd+A4tGffQ1VaHJMRxpXRvg03zvDKu2yaN547FG2OOoqKiGofD4Tju882aNYuJEycyfvx4evbsyZw5cwgNDWX+/PnHfPwLL7zAJZdcwv3330+PHj144oknOOOMM3j55Ze98eUfkyTsJ5FU2SneVJBRLI3nTmZfSSFvbVmDQ1OgacwcMgK7Jt9moulK6BhHXPuWAGz9dQdul9viiIQQfquyU7xd0zGljv2kivJL+M/zX6I7DQy3yZ2zxhEcFmR1WEIcV2hwIImdPE2t0/ceprC43OKIfFP79u2JioqqOmbOnHnMxzmdTlavXs3w4cOrzmmaxvDhw1m+fPkxr1m+fHmNxwOMGDHiuI/3BsmkTqKqU7yC9BJpPHcipmkye+3PlBtuHBrc0uMM+sa1tjosIU7qyCx7RZmDHWtkkFyLLIkXonHYuwMKm80A2drtpP4z60uK88twlRucO/JMBl7Ux+qQhDipvklHt3dbt12WxdfihTFHVlYWhYWFVceDDz54zKfKzc1F13USEhJqnE9ISCA7O/uY12RnZ5/W471BEvaTaBMaRbg9CENBRrEsiT+RJVk7WXVwHxWaok14JPedMdTqkIQ4Jb2HSh37iRzZYqWuhxDi1CgVArZOlQn7bkxTtzqkJmvT8h0s/2It7nKd8MhQ/vzkjVaHJMQpSa1Wx75O6thr8caYIzIyssYRFNS8V95Iwn4SSimSo+PRFRwsL6HEefwaCH9W6Kjg5XW/4tI8e64/ftZFhAc07x8O4T+q17Gv/2mzhZE0UTLDLkTjsSdi13TACfp+q6NpkhzlThbM/ATDbaI7TW6bfj0x8VFWhyXEKaneeG7tVqljr6URxxyxsbHYbDZycnJqnM/JyaFVq1bHvKZVq1an9XhvkIT9FFRvPJdeIrPsx/LahhUUOCuo0OCyTkkM79DN6pCEOGUderQlokU4AJuWbcWQLRyFEBZRAUmeGXYAXZbFH8tn877n0N48XGU6KWcnMmLcMKtDEuKUxUSG0rFNCwC2ZR6kvMJlcUT+KzAwkP79+7NkyZKqc4ZhsGTJEgYPHnzMawYPHlzj8QDffvvtcR/vDZKwn4Kk6p3iZVl8LWty9vH17u1U2BThQcE8OuhCq0MS4rRomkbvockAFOeXsnuzvONdi8yuC9E47ElomommmZjSKb6WrO0H+Prtn3BXGNjtdu6afYtnD3shmpEjy+J13WDjTllJU0sjjjmmTJnC3Llzeeutt9iyZQuTJk2itLSU8ePHA3DzzTfXqIG/++67Wbx4Mc899xxbt27l0UcfZdWqVUyePLmOX+zJScJ+CpKj4kEpDAXpkrDX4HC7mLV2GboCl6b4e/9ziQ8NtzosIU5bitSxH5fUsAvRiOxJANg0XbZ2+x1dN3h7xsfoLh13hcENf72c9onS3FY0P6nVGs/Jfuw1NfaYY/To0Tz77LNMmzaN1NRU0tLSWLx4cVVjuT179nDgwIGqxw8ZMoSFCxfy+uuv07dvXz744AM++eQTevfu7a1/glrsDXZnH9L9SKd4DTKLpVN8df/euo59pUWU2xUD4ttyY1Jfq0MSok5Szqm5H/sVk0ZYGE0TU5/ZcknYhTg9tnagwrDZ3LgkYa9h6QcrSN+QhavMoH1ia0bdc6nVIQlRJ6nJ1TrFS8JekwVjjsmTJx93hnzp0qW1zo0aNYpRo0bV7cnqQGbYT0FEQBDtwqIxFGSWHMYwZQQKkF6Yx7vb1+HQFDabjf8bMgJNlqWJZqpbv84Eh3oaJW78aSum/JxXkRl2IRqPUhrYu2O36aBnYxqlVofUJOTlFPDRy4ur9ly/+4VbCAwKsDosIeqkdVwkCS0jANi4cz9ut+wIcYSMOWqThP0UJUV5OsWXuV1klxVZHY7lDNPkuTU/4cLAocGklEEkxsRaHZYQdWYPsNNjcCIAh/YeJmf3IYsjEkL4LXu1xnPuTEtDaSoWPv0Z5SVOXGUGl956Lr2HJFodkhD1cqRbfIXDzdbMgxZHI5oySdhPUY3Gc9Ipnk8ztrA57yDlmqJLVAvu6NNwnRGFaCzV69g3SB37UY24xYoQApQ9CZt2pFO8LItf/f1G1v6wGVeZTkx8JH989DqrQxKi3qrXsa/bJs1uq8iYoxZJ2E9RclQ8plKY0niO3PJS5m1YiVNT6JpixpARBNulHYJo/noPS676WBrPHSXL04RoZAFJKAU2m4Hp5wl7WXE5C5/+DMNtYrhMJj01hoiYMKvDEqLeUpOP7seetlXq2I+QMUdtkrCfoqRoT6dAQ0FGkX8n7C+lLafE7cKhwfXdUxjcuoPVIQnhFT3OSsRmtwGwYdlWi6NpQuTdbiEaV/VO8S7/3ov941e+oeBgEc5SnTNH9GHYNQOtDkkIr+jUpiWR4cEArNu+D8OQF0xAxhzHIAn7KeoYHkOQZkdX/r0X+8/7M/lxfwblNkWLkDAeGnie1SEJ4TXBoUF0798FgKyt+yg4VGhxREIIf6S0SNBaY7cZoGf4bRPMnet388P7K3CVGwSFBPKXZ2+SPdeFz9A0Rd9Ezyx7UUkFmfv9N78QJyYJ+ymyKY3EqDgMBfvKCqlwu6wOqdGVupy8kPYLbqVwa4ppZ15AdFCI1WEJ4VUpQ6sti5dZdg95t1uIxheQhM2mg1kGhv81pHK73Lw9/WN0t4HuMLhl6rUkdJDmtsK3yLL4Y5AxRy2SsJ+GxMpO8SaQWeJ/+7HP37SaQ+WllNvgnLadubJLj5NfJEQz03vY0e9rqWP3kHoyISxgT/LMsAO4/W9Z/NcLlrFvZw6uMp3uqR256k8XWh2SEF7Xt1rjuTRpPAfImONYJGE/Df7cKX5L3kE+3rWRCpsiyB7AjMEXybI04ZN6n310hn29JOwe8m63EI1O2ZPQNBOlTHBnWB1Oo8rZk8unry/B7TBQpuKuF26t6i8ihC9J7hRPcJCncXPa1r1+W/5Sg4w5apGE/TQkR8eDUhgK0v2o8ZzL0HluzTLcCpwK7u13Nu0joq0OS4gGEdkygk692gOwa20GZcXlFkckhPBLAZ43D/2tU7xpmiyY8QmuCjfucoNr7riY7qkdrQ5LiAZht9vo3a0NAAfzSjiQW2RxRKIpkoT9NCRGxQOeTvGZftR47oMdG9lVeJgKm6JnywQm9JIOrcK39a6sYzcMk83Lt1scjfWUadbrEELUga0jEIDdpvvVDPvyL9aw5bdduMp04ju0ZNxDV1sdkhANqm/S0Tr2dVLHLmOOY5CE/TS0DAojPji8slN8nl8sW9lfWsRbW9bg0BSmpjFzyAjsmnzbCN+WInXsNcnyNCEanVIBYO+GTTNA34tpOq0OqcEV5ZewaNaX6C4Tw21y56xxBIcFWR2WEA0qtVrCLnXsyJjjGCTzOk2JUfEYGhS6KjjsKLM6nAZlmibPr1lGueHGocEtPc6gb1xrq8MSosFVbzy3YZkk7NIARgiL2JM8M+wY4N5tdTQN7j+zvqQ4vwxXmc65I89k4EV9rA5JiAbXu1sbbDZPSpa2TWbYZcxRmyTspympslM8+P5+7EuydrLq4D4qNEWb8EjuO2Oo1SEJ0Sji28fSqlMcAFtX7MDp8L9tHIUQ1lMBSdiOdIr38Tr2Tb/uYPkXa3GX64RHhvLnJ2+0OiQhGkVIcADJnRIA2L0/j/wi354QFKdPEvbTlBwdj6kUpoL04lyrw2kwhY4KXl73Ky7Ns+f642ddRHiALEsT/uPILLuzwsWO1f63pVINsjxNCGvYk1EKNM3A9OE6dke5kwX/9wmG20R3mkx44npi4qOsDkuIRlN9P/Z1/j7LLmOOWiRhP01JUZ53wIzKOnZfNWfjCgqcFVRocFmnJIZ36GZ1SEI0qpSh1ZbF+3kduyxPE8Ii9kTPHzbDp/di/2ze9xzam4erTCfl7ERGjJMVfcK/9K1Rx+7fCbuMOWqThP00dYloiV1plQm7by6JX5Ozj8WZ26mwKcKDgnl00IVWhyREo6tex77R3+vY5d1uIayhxYLWAptN99kl8VnbD/DNgmW4Kwzsdjt3zb4FTZrbCj/TN7H6DLufN56TMUct8hvxNAXZ7HSOaImuYE9JPk5Dtzokr3K43Tyf9jO6Apem+Fv/c4gPDbc6LCEaXfukNkTHRQKw6edtGIZhcURCCH+jlKpsPGeAUYCp51sdklfpusHbMz7G7XTjrjAYfd8faJ8ozW2F/4mKCKFLu5YAbM88SFmF7+8KIU6dJOx1kBQVj6HAbRrsLS2wOhyvemdbGntLCim3KfrHt2VMUqrVIQlhCaUUvSr3Yy8pKCVzY5bFEVlHlqcJYSF7kmdrNwDdt5bFL/1gBekbsnCVGbRPbM31915mdUhCWKZvUjsAdMNkw479FkdjHRlz1CYJex0kRx/tFJ9e5DuN59IL81i4bR0OTWGz2Zg5ZASaUlaHJYRlpI69kixPE8Iyyp7s6RSvAB9qPJeXU8BHr3yN7jQw3CZ3v3ALgUEBVoclhGWq78fu143nZMxRiyTsdZAUlQCVneIzfaTxnGGazFq7DBcGDg3+nDKIxJhYq8MSwlJSx36UvNMthEUCkgCwa7pPdYpf+PRnlBc7cJUZXHrLOfQekmh1SEJYqnqn+LStfpywI2OO35OEvQ6SouIB0BVklPhG47nPMraw6XAO5Zqic1QL/tJnsNUhCWG5bqmdCAkPBmD9j1swTR9+NTgR06zfIYSoO3tXQPPMsvtI47nV329k7Q+bcZXpxMRH8sfHRlkdkhCWS2gZSavYyt45Ow/gdLktjsgiMuaoRRL2OmgVEkFkQDCGgnQf6BSfW17K3A0rcWoKXVP835ARBNvtVoclhOVsdhs9BntmffIO5HMgPcfiiIQQ/kapYLB1wm7TwZ2JaTbvQXxZSQULn/4Mw21iuEwmPTWGiJgwq8MSokk4size4XKzNUPGHMJDEvY6UEqRFOWpY8+tKKXQWW51SPXyUtpyStwuHBqM6p7C4NYdrA5JiCZD6tilAYwQlgs40njODXrzXir78ctfU3CwCGepzsCL+zDsmoFWhyREk5Ga3K7qY3/dj13GHLVJwl5HydHxGJX/epnNeJb95/2Z/Lg/g3KbokVIGA8NOM/qkIRoUlKq17H7acIuDWCEsFZV4zlo1o3ndq7fzQ/vr8BVbhAUEsjk527ybF0nhACgb/XGc/5axy5jjlokYa+jpKh4juzKnNFMG8+Vupy8kPYLbqVwa4ppZ15ATHCI1WEJ0aQkD+qGPcAGwIZlWy2OxhrKqN8hhKgnexKaZqJpJmYzrWN3u9y8Pf1jdLeB7jC4Zeq1JHSQ5rZCVNepTQuiIzxj8fXb92EYPpqBnoCMOWqThL2OjnSKb8517PM3reZQeSnlNhjWphNXdulx8ouE8DNBIUEkDuwGwL4dB8jLzrc4IiGE37F7emnYbDq4m+de7F8vWMa+nTm4ynS69e3IVX+60OqQhGhylFJVs+zFZQ527fWd7aNF3UnCXkfdo+IA0DVIb4ad4rfkHeTjXRupsCmC7AHMGHKxLEsT4jhShiZXfbzRH2fZZXmaENaytQUVhl0zmuWS+Jw9uXz6+hLcDgNlKu5+8VZsdpvVYQnRJFWvY1+3da+FkVhExhy1SMJeR2H2QDqExWAo2F2ch242nzUYLkPnuTXLcCtwKri339l0iIi2Oiwhmqzqdez+2HhOGsAIYS2lFNiTPDPsxkFMo8TqkE6ZaZosmPEJrgo37nKDa+64mO6pHa0OS4gmK7VaHbs/Np6TMUdtkrDXQ1K0p1N8he7mQFmR1eGcsg92bGRX4WEqbIqeLROY0Es6tApxIr3OTq5ageKfM+ym7IkqhNWaaeO55V+sYctvu3CV6cR3aMm4h662OiQhmrTuHeMJDQ4AYN22fZj+9joqY45aJGGvh+SoeIzKVeTNpfHc/tIi3tqyBoemMDWNmUNGYNfk20CIEwmPDqNzime7w/R1mZQWlVkckRDC36gjW7spoJk0nivKL2HRrC/RXSaG2+TOWeMIDguyOiwhmjS7TaN3tzYAHMovYf+hQosjElaTTK0ekqISMJXCVJBR3PSbQpimyfNrllFuuHFocEuPM+gb19rqsIRoFnpX1rEbhsnmX7ZZHE3jkuVpQjQB9kSUAptmYDaTGfb/zPqS4vwyXGU65448k4EX9bE6JCGahdTkasvi/Wx7Nxlz1CYJez0kRcUDNJtO8UuydrLq4D4qNEWb8EjuO2Oo1SEJ0Wz4dR27NIARwnqVneLtNr1ZLInf9OsOln+xFne5TnhkKH9+8karQxKi2eibdLTxXNo2P2s810THHHl5eYwdO5bIyEiio6OZMGECJSUn7ify+uuvc9555xEZGYlSioKCgjo9tyTs9dA+PJoQWwC6avpL4gsdFbyyfgUuzbPn+uNnXUR4gCxLE+JU9a6WsPtbHbu82y2E9ZQWAbZ2nmXxegZmE2526yh3suD/PsFwm+hOkwlPXE9MfJTVYQnRbPTq1gq7zZOmrfOzxnNNdcwxduxYNm3axLfffsvnn3/Ojz/+yO23337Ca8rKyrjkkkt46KGH6vXc9npd7edsSqN7VBxbDu1jf1khZW4nofZAq8M6pjkbV5DvKKfCrrisUxLDO3SzOiQhmpXYNi1o3SWBA+k5bF2xA2eFk8DgpvnzLoTwUfYkbLYDYJaDngP2plnW9tm87zm0Nw9XmU7K2YmMGCcr+oQ4HcGBAfToksCGHQfYcyCfwwWltIwOszqsZqOoqGYz8KCgIIKC6j5RuWXLFhYvXsxvv/3GgAEDAHjppZe47LLLePbZZ2nTps0xr7vnnnsAWLp0aZ2fG2SGvd6Sozyd4gF2F+dbG8xxrDm4j8WZ26mwKcKDgnl00IVWhyREs9R7mKeO3eV0s+23XRZH04ikY6sQTYM9CfuRTvFNtPFc1vYDfLNgGe4KA7vdzl2zb0GT5rZCnLbqy+L9apbdC2OO9u3bExUVVXXMnDmzXiEtX76c6OjoqmQdYPjw4WiaxooVK+p171Mhv0HrKSkq4Win+JKm13jO4Xbz/Nqf0RW4NMXf+p9DfGi41WEJ0SylDPXPOvamujxNCH+j7IlomolSZpOsY9d1g7dnfIzb6cZdYTD6vj/QPrFprgIQoqmruR+7/9Sxe2PMkZWVRWFhYdXx4IMP1ium7Oxs4uPja5yz2+20aNGC7Ozset37VEjCXk9JUXGgVJNtPPfOtjT2lhRSblP0j2/LmKRUq0MSotlKqVHH7j8JuxUNYF555RU6depEcHAwgwYNYuXKlad03XvvvYdSiquvvrrml2CaTJs2jdatWxMSEsLw4cPZsWNH3YITwioBSYCn8ZzpTrc4mNqWfrCC9A1ZuMoM2ie25vp7L7M6JCGarT5JbVGVk4JpfjXDXs8DiIyMrHEcbzn83//+d5RSJzy2brW+b5Ek7PWUWL1TfFHTajyXUZjPwm3rcGgKm83GzCEj0I785AshTlvb7q2JSfA0Ttr0yzZ0Xbc4It+0aNEipkyZwiOPPMKaNWvo27cvI0aM4ODBgye8LjMzk7/+9a8MGzas1ueefvppXnzxRebMmcOKFSsICwtjxIgRVFRUNNSXIYT32ToCQdhsRpNbEp+XU8BHr3yN7jQw3CZ3v3ALgUEBVoclRLMVGRZM1/ZxAOzcfYjSMofFEfme++67jy1btpzw6NKlC61atao1BnG73eTl5dGqVasGj1MS9nqKCQolISQCXYOMksOYTaRe0zBNnlv7Ey4MHBr8OWUQiTGxVoclRLOmlKrqFl9WVE7G+j0WR9Q4GntJ/KxZs5g4cSLjx4+nZ8+ezJkzh9DQUObPn3/ca3RdZ+zYsTz22GN06dKlxudM02T27NlMnTqVq666ij59+vD222+zf/9+Pvnkk9MPUAiLKGUHe/fKTvH7Mc2m84bTwqc/o7zYgavM4NJbzqH3kESrQxKi2TuyLN4wTdbv2G9xNI2jMccccXFxJCcnn/AIDAxk8ODBFBQUsHr16qprv//+ewzDYNCgQV7+F6hNEnYvONJ4rsTl4FBFqdXhAPBZxhY2Hc6hXFN0jmrBX/oMtjokIXyCX9axG2b9DjwdW6sfDsexZwqcTierV69m+PDhVec0TWP48OEsX778uCE+/vjjxMfHM2HChFqfy8jIIDs7u8Y9o6KiGDRo0AnvKUSTFJDk2YsdA9y7rY4GgNXfb2TtD5txlenExEfyx8dGWR2SED6hb406dj9ZFu+FMYe39ejRg0suuYSJEyeycuVKfv75ZyZPnswNN9xQ1SF+3759JCcn1yjhy87OJi0tjZ07dwKwYcMG0tLSyMs7vVXZkrB7QY3Gc02gjj23vJS5G1bi1BS6pvi/ISMItssOfkJ4Q/U69g3+UsfuhXqyU+3Ympubi67rJCQk1DifkJBw3MYuy5Yt44033mDu3LnH/PyR607nnkI0Vcqe6FkSD02i8VxZSQULn/4Mw21iuEwmPTWGiBjZfkoIb0hNrtYpfqufNJ6zoG/OqXjnnXdITk7mwgsv5LLLLmPo0KG8/vrrVZ93uVxs27aNsrKyqnNz5syhX79+TJw4EYBzzjmHfv368emnn57Wc0sW5wWJUXGYSmEqk4ySXAbFd7Q0npfXLafE7cJhV4zqnsLg1h0sjUcIX9K5TwdCI0MoKypn409bME0T5eO9IRR17/Z+5F8mKyuLyMjIqvP12Q+1uuLiYsaNG8fcuXOJjZWyH+EH7EkoBTabga5nYPVvn49f/pqCg0U4S3UGXtyHYdcMtDgiIXxHXEw4beOj2HewkM3p2ThdbgIDfDt988aYoyG0aNGChQsXHvfznTp1qlUa/eijj/Loo4/W+7l9+3+8kSRHe2ZtmkLjuZ/3Z/K/fRmU2xQtQsJ4aMB5lsYjhK+x2Wz0GpLEb4vTyM8pZN/ObNp1l22LTuZIp9aTiY2NxWazkZOTU+N8Tk7OMRu77Nq1i8zMTK644oqqc4bhmX202+1s27at6rqcnBxatz76f5WTk0NqampdvhwhrBOQDIBNM9AtnmHfuX43P7y/Ale5QVBIIJOfu8nn38AUorH1TWrHvoOFOF06m9OzSa22P7vwD7Ik3gs6R7QkQGnoytol8aUuJy+k/YJbKdyaYtqZFxATHGJZPEL4qt7V6tg3+kMdu2nW7zgNgYGB9O/fnyVLllSdMwyDJUuWMHhw7V4cycnJVTVhR44rr7yS888/n7S0NNq3b0/nzp1p1apVjXsWFRWxYsWKY95TiKZMaS1Ai8Nm08GdblmzW7fLzdvTP0Z3G+gOg1umXktCB1nlIoS3pSYfrWNft9UP6tgbcczRXMgMuxcEaja6RsayKy+HvaUFOHU3gbbG/6f91+bVHCovpdyuGNamE1d26XHyi4QQp+33deyX/PECC6NpeHXt9n7k2tM1ZcoUbrnlFgYMGMCZZ57J7NmzKS0tZfz48QDcfPPNtG3blpkzZxIcHEzv3r1rXB8dHQ1Q4/w999zD9OnT6d69O507d+Yf//gHbdq0qbVfuxDNgj0Ju+1XMIvAyANby0YP4esFy9i3MwdXmU63vh256k8XNnoMQviD1N81nrvFwlgaQ2OPOZoDSdi9JCkqnh35ObhNg6zSArpGNu67zFvyDvLRzo1U2BRB9gBmDLlYlqUJ0UCSBnYlINCOy+lm7f/WkZaWhsPhICgoiG7duhEeHm51iN5Vn0Yudbhu9OjRHDp0iGnTppGdnU1qaiqLFy+uahq3Z88eNO30Fog98MADlJaWcvvtt1NQUMDQoUNZvHgxwcHBpx+gEFazJ2HTfvZ8rGc0esKesyeXT19fgtthoEzF3S/eis1ua9QYhPAX7VvFEBMZSn5RGeu376OwqIiM9HTfHXc08pijOZCE3UsSK7d2A8gozm3UhN1l6Dy3ZhluBU4FD/Y7mw4R0Y32/EL4m53pOznQchfph3ZQnF7Iu/2OdidXSpGUlMRFF13En//8Z3r27GlhpM3X5MmTmTx58jE/t3Tp0hNe++abb9Y6p5Ti8ccf5/HHH/dCdEJYSwUkYrOZKGWCOx0CBzTac5umyYL/+wRXhRt3ucHIySPonmpts10hfJlSinZROmu//4TSQzuJmX93jVIYGXf4PknYvSQ5OgGUwlAmu4rzGH7yS7zmwx0b2VV4mAq7okfLBP7Yq/FeuIXwJxkZGdxxxx0sXryYuNg4xt52IwMHDqRnz56EhoZSVlbG5s2b+e2331i0aBEvvfQSl1xyCa+++iqdO3e2Ovw6U6aJqmNdWF2vE0KcgD0J8DSec7vTG7VT/PIv1rBl5S5cZTrxHVoy7qGrG/HZhfAv1ccdLWNjGXfDKJ8fd8iYozZJ2L0kKSoe8HSKb8zGc/tLi3hzyxocmsJQiieHjCBAk2VpQnjbvHnzuOeee4iNjeWdd97huuuuIzAwsNbjBg0axPjx45k9ezYffPABDz74ICkpKcyePZvbbrvNgsi9wKg86nqtEMK77N0AGzabgVtvvE7xxfmlLJr1JbrLxHCbTH5uHMFh3tmiUQhRk9+OO2TMUYt0ifeS+OBwYgJDMBRkNlLCbpomz69ZRrnhxqHBrT370zdOtpcSwttmzJjBxIkTufHGG9mwYQNjxow55otmdYGBgYwZM4aNGzdy4403MnHiRGbMmNFIEXvXkXe763oIIbxLqUCwd8Fu08GdhWm6GuV5//P8FxTnl+Eq0zl35JmceXGfRnleIfyNP487ZMxRm8ywe4lSiqSoeFaVZ3LYUUa+s4yYwNAGfc4lWbtYdXAfFTZF67BI7jtjaIM+nxD+aN68eUydOpUnnniCqVOnnvb1ERERzJ07lw4dOjB16lRatWrFhAkTGiBSIYRfsSdhs6UDbnDvhYCGXf666dcd/PL5WtzlOuGRofz5yRsb9PmE8Fcy7hC/JzPsXpQYFY9R+S+aWZzXoM9V6KjglfW/4tI8e64/MfgiwgNkWZoQ3pSRkcE999zDbbfdVutFc+nSpSiljnn8+uuvte41depUbrvtNu6++24yMhpvCatXmPU8hBBep+yJ2LTK9Z8NvCzeWeFkwcz/YrhNdKfJhCeuJyY+qkGfUwh/JOMOZMxxDDLD7kXJ0fEYSgEm6UWH6deyXYM915yNK8h3lFNhV1zWKYnhHbo12HMJ4a/uuOMOYmNjmTVr1nEfc9dddzFw4MAa57p1q/3zqJTiueee45tvvuGOO+7gq6++8nq8DcY0PUddrxVCeJ89CU0z0TQTQ09HcUGDPdVn837gUNZhXGU6KWcnMmKcrOgToiHIuAMZcxyDJOxelBTl2SNY1xq28dyag/tYnLmdCpsiPDCIRwY13Iu0EP5q8+bNLF68mHfeeYeIiIjjPm7YsGFcd911p3TPyMhIZs6cydixY9myZQs9evTwVrgNSpmeo67XCiEaQEAyADabjuFquNmzrO0H+Prtn3BXGNjtdu6afQuaJgs0hfA2GXd4yJijNvmN60XdI+NQVHaKL2mYhN3hdvP82p/RFbg0xd8GnEtC6PF/qIUQdTNnzhzi4+NP6UWxuLgYt9t9SvcdOXIk8fHxvPbaa/UNUQjhz7RWoCKxa0aDLYnXdYO3Z3yM2+nGXWEw+r4/0D5RmtsK0RBk3CGORxJ2LwqxB9ApvEVlp/g8dNP7ewu8sy2NvSWFlNsU/ePbMiYp1evPIYSAb7/9lpEjR560K+v48eOJjIwkODiY888/n1WrVp3w8UFBQYwcOZLvvvvOm+E2rCPL0+p6CCG8TilV2XhOByMX0yjy+nMs/XAF6RuycJUZtE9szfX3Xub15xBCeMi4o5KMOWqRhN3LkqIT0BU4DZ39ZYVevXdGYT7vbl+HQ1PYbDZmDhmBppRXn0MI4Xnnetu2bbVqxKoLDAxk5MiRvPDCC/z3v/9l+vTpbNiwgWHDhrF27doT3n/AgAFs3bqVkpISb4feIJRRv0MI0UACErHbKn/I3JlevXVeTgEfvfw1utPAcJvc/cItBAYFePU5hBAeMu44SsYctUkNu5clRsXxdWUOnV50mPZhMV65r2GaPLf2J5ymgcOmuDNlEIkxsV65txCipl27dmGaJj179jzuY4YMGcKQIUOq/n7llVdy3XXX0adPHx588EEWL1583Gt79eqFaZrs3LmT1NRUb4beMKQBjBBNkrInoWkGKMCdDoHe2xd94dOfUV7swFVmcOkt59B7SKLX7i2EqGnr1q0y7jhCxhy1SMLuZclRCZhKYSqT9OLDnNvaO93bP8vYwqbDOZTbFJ2jWvCXPoO9cl8h/JFpOkHPASMb9GzQD2AaByo/zqb8wA4AQkNDT+u+3bp146qrruKjjz5C13VsNtsxHxcSEgKAw+Go3xcihPBv9mSUAptmoOvpeGvN3ervN7L2h824ynRi4iP542OjvHRnIfyP2+Xm8P58Du09zKGsw+TuPczBrFwO7fV8fCjrMJnZ6YCMO8SxScLuZUlR8QCVdezeaTyXW17K3A0rcWoKXVPMGHIxwXb5rxPiWEzTVTMZN7Ix9QOgH6j6O0buCe8RFOB5QSsrKzvt52/fvj1Op5PS0lIiIyOP+Zjy8nLP8wQFnfb9LVGfvU19881uIZoGe3fPHzYd3UtL4stKKlj49GcYbhPDZfLnJ8cQERPmlXsL4Wt0t87hA/nVEvHKJHxvLoeyDnNo72HyDhRgnmTmV5meKmUZdyBjjmOQrM/L2oVFE2YPxO12kF6S55V7vrxuOSVuFw67YlT3FIa07uiV+wrR3JimG4yDNZJvs+rjA5WJ+iHq9xtbo1vXdiiVxebNmxk0aNBpXZ2enk5wcDDh4eHHfcymTZtQSh1z39SmSJkmqo7LzOp6nRDi5JQWhmnrgM2WDa5MTNNAqfq1J/r45a8pOFiEs1Rn4MV9OOfa49fUCuHLdF0n70BBjZnxQ1m5HKw2M553IB/DqPvrnFKKmFbRdGnTgZWrl8i4AxlzHIsk7F6mKUViVDwbHVlklxVR6nISFnDibo8n8sv+3fxvXwblNkWLkDAeGnCe94IVognxJOOHqpaoe5Lxox97/swF6tNRRIEWB7bWoLUGWyuUrVXl34/8GUukspOU1IPffvuN8ePHH/NOhw4dIi4ursa5devW8emnn3LppZeecJ/iVatWkZycfMIX1yZF6smEaLrsidi1fWBWeH5P2tvW+Va71u/hh/dX4Co3CAoJZPJzN3m60QvhY3RdJz+nsFoi7pkNrz4zfnh/PoZevy5mLVpFE9e+JbHtWhJ35GgfS1x7z8ct28RgD/CkYz/2+FLGHSBjjmOQhL0BJEbFse5QFgCZJYfpFVO3PUtLXU5eSPsZt1K4NcU/zjyfmOAQb4YqRKMwTf1oMl6ZfJvVPvacP4h3kvFWVcm3qvax53wcSp1al+OLLrqIRYsWMXv27GNusTJ69GhCQkIYMmQI8fHxbN68mddff53Q0FCefPLJ497X4XDw4YcfMnr06Dp/pY3OpO7/Nb752ilE02FPwmZb4vlYT69zwu52uXlr+kfobgPdYfDHGdeQ0EGa24rmxzAMCg56kvGD1WbGD+3L8/yZ5UnGdbder+eJjo8irn1L4tu3JLZtZSLerkVVQt6yTQwBgae+s4KMOyrJmKMWSdgbQHJUAsaRTvHFdU/Y/7V5NQfLSym3K4a16cRVXY7fOVIIq5im4Zn5rpoJr1ymfmSJun6gMhmv3wsjWmyN5FtVzYofmRmPQ6m6r2b5vT//+c+89NJLfPDBB4wZM6bW56+++mreeecdZs2aRVFREXFxcVx77bU88sgjJ1xy9uGHH3Lw4EEmTZrktViFEP5LBSSjaSZKmZjuDFTQsDrd5+sFy9i3MwdXmU63vh25+s/DvRypEPVnGAaFh4qqJeI1Z8Zz9x4md18eblc9k/G4SM+sePvjzIy3beH1bQ5l3CGOR5kn64IgTttvh/YwZunbhDlN/r+9uw9uus7zAP7+JW3SlrTpQ5qmQJFCD9oC2h0qHHvOLiMVqo5zsnUWT1TsUVzpoEJ7x4p0xV3ArrPaBdTaOzJ6iuB4C+7t6koXqIt37rE8qDt6tLKCFVroA0kf0sc0D7/7I2maNG1p80tCmr5fMxm1TX6/b6uSzyef7/fz+ce0BXhqwQ8nfI2v21pR/KffoU8uQBYZiWOr/xmzYuP9v1iiMTiScaMz+XYm466q+OCZ8RYAVmk3kiU5t6inOCrjHlVxHSBP8WsyPl5333036urq8NVXXyE2Nlby9UwmExYtWoTs7GwcPXrUDysMLJPJBLVajTu/9wwi5FE+XcNq68fHX/wSnZ2dozbDISLfidbvIBpWwtQdDYtsOWTq5yZ8jZYrBuxYsxd9pgHYzSL2/uk5/F0O++VQcImiiE6DyZGEDybiDQYYrrY5uqo3GGG82gbLgLSYIy4p1pF4pyUh2VkZ18xMhNaZkGtmJEIRFfyYA5jacQdjjtGxwh4A7p3i67sm3njOYrfhpc8/hVUABgTgme/9A5N18jtHMt7uTMab3JJx93PjLQAs0m4kJDiTb0dCLjjPjg+dG0+BIIRm19LKykosWrQIJSUl2L9/v6RriaKI0tJSGI1GVFZW+mmFQSJCwnkyv66EiIaTpwFCNORyOyzWbyf8clEUceCF/8JAnxXWPjt+tGklk3XyO1EUYTJ2uRq4jVQZv97YBotZWswRm6hyVsMdlXDNzCRonQn54JZ1ZXRoxhwA4w4AjDlGwIQ9AOIUUZgeEwdDVye+7TJCFMUJNW058s3/4VKnEf0RArKSUrB+QW4AV0vhSBRFQGwfSr5tTSMk482QnozHuyXfqRCcFXKPreshmoyPR3p6Ovbs2YMNGzbglltuQVlZmU/XEUURu3btgl6vh16vR3p6up9XGmBsAEMUsgRBDjEiAxHyOsDcBNHeC0E2/lnOp/7wOerOXIKl1wbtrCQ8su3+wC2WwpIoiuhq7/YYbTZYGb/eYHBtXx/olxZzqOKnuRq4aWcOVcaT0zTQpjm2qUdP860yGyoYd4AxxwiYsAfIPLUWLd2d6LUMoLWvCykx49uW0dRjwn/UfQ6zTIBdEPDL769CpEwe4NXSZOJIxjtGGW3m1sQNA9JuJKg9KuGCs0Lu2LrurJYL4d8EsaioCC0tLSgrK8Ply5dRUVExoW1qJpMJpaWl0Ov12L17N9avXx/A1RLRlBQxH3LZeQAiYL0CKDLH9bKu9h68V/ERbBYRdquITS8/gmjV5E54yL9EUUR3R49bIu5MyhsNMDQ6EnJDYxv6e82S7jNNHeNVGfdo4jYzEdGq8I85AMYd5I0Je4BkqrX45No3AByN58aTsIuiiF9/8Wf02a0wywU8lrUYtyX71rCOJidHMt45xmizwcp4v7QbCXEjdFMfOkMOmW5CFZpwt337dqSkpGDz5s04duwYysvL8cADD4zYxXXQYFfWbdu2wWg0Qq/XT943TTsAXyc7SZuIQ0TjIERkQi53/s9m+xbA+BL2//z1H9DV3gtLrw0//NESLFl5a+AWSSFHFEX0mno9Gri1OhNw9/Fm/T3SkvGY2GiP0WbDt6gnp2kQEzs1kvHxmtJxB2MOL0zYA2S+OgWiIEAURHzb3YZlKTfeilLTcAlnWxrRLxeQOi0O/7L4jiCslILFkYx3ecwV9x5t1gyIfdJuJKjctqW7d1MfqpALsmn++aGmkKKiIqxYsQLFxcVYu3YttmzZgoKCAuTm5mLBggWIjo5GX18fzp8/j3Pnzrm6subn56OysnJybUcbRhBFCD5uM/P1dUQ0ARHzIQiAXG6HzVY/rlj3/F++wf9++AWsfTao4mLwk1/+U8CXScHVY+r1qowPH2/W1y2tABA1TTnUPX2Gs0I+bLzZtDgWAHwxVeMOxhzemLAHyPz4ocZz33UZb/h800A/XvvyL7DIHDPXdy67C6rIyXv2dyoS7V3OpLtpWDLuViEXe6XdRJg2bK744FZ1t63rMpV/fiDykp6ejqNHj6K2thZVVVU4ceIEqqqq4D5sQxAEZGZmYs2aNdi4cSOysrJu4or9hOfJiEJb5DwAgFxmg81Sf8OnD/QP4ED572C3irANiFj/0o+RmKIO9CrJj/q6+zxHm7k1cTM0Orqq95qkFQCiYpRDlfHh482cCfk0dcyE+jTRxEzJuIMxhxcm7AGSrkpCpEwOm2DFt6YbJ+xVX51Gu7kP/REC7r5lHvJmjT5PkYJPtHd7JN+i+xb1wQq52CPtJkLMsLniOsdWdbcKuSCTPuKDpMvOzsa+ffsAAN3d3bh48SLMZjOUSiUyMjKgUvFDEyIKHkGWAFGWggh5OwbM9TdsdvuB/k+43mCEpdeGhd+fh1WPcEdfKOnr6fecMd7gWRk3NLahu0NazKGIivSYKz48EdfMTERsgorJeIhg3DG1MWEPkAiZDBlxGlw0NqOxpwMDNisU8pF/3Z+3XsXR7/6GfrkAlUKJ5/9+RZBXO7WJ9h6vSrhXEzexW+JdoobNFXeeG3edHU8FhFi+MU5CKpUKOTk5N3sZgcVPu4lCX8Q8yOWnHEev7AZAnjzi0xq/acYf3/4fWPvtiIiIwFN7HoVMJgvyYqeu/l6zc4TZyJXx6w0GdLVLS8YjlZFDiXhaEjQzkqBN85w3HpvIZHyyCvu4gzGHFybsAZSp1uJCWzMs/f04fubP0ClUUCgUSE9Pd30SZrZa8esv/gybAFhkAnbk/hApMayi+oso9g2dD3duVx9q4tbiTMZNEu+iHJaMu58bd1bIBTXfGGny4psnUeiLzIRc9im6e2z4ruE4LOJ8r5jDZrPjrV3vwzpghbXfjoe33YdZ86ff5IWHD3Of2TnKzLMybrja5mrmZjJ2SbpHpCJixC3qg4m4ZmYi1Jo4xhw0eTHm8MKEPUBqa2vx2SsH0Xjyv9F7tRXrhp01ycjIwPLly6G+IxeN/Z3oixCwWDsDD83PuXmLnmREsd9rrrjo1tANthbH+DNJFG5b1FOclXH3ZFwHCAl8Y6Twxo6tRCGttrYWr7/6CU6caMSFi70Qxadc33OPOTJ1Ofj2qwZYeu1Im5eKH2+55yauenIZMFs8KuOuZm5ulfFOg7RkPCJS7uqkPlgZT07z7Kqu1sRyRwSFtxCNOdra2vDkk0/igw8+gEwmQ0FBAfbu3TvqcYS2tjbs2LEDx44dw5UrV5CcnIz7778fO3fuhFo9sZ4hTNj9rL6+HsXFxaiurkayVot1BQW4/fbbkZ2djZiYGPT29qK2thZnz57F4SNHcH3/fsQunI/EdT9C+er1kDHxAwCIotmjKu5Ixof+3lEZ75B4l0iPLeqQp0BwzRgfrIwzGSciotDkHnNotVoUFKzD1m0jxxxHjhzB/tb9SIlOwzz5Ujy1ZysUysib/SOEBMuAxVUZH+qqbnB+zYDrjW3oaO2UdA95hByaGYmuJm7amW7N3Jxnx+O1aibjRCFq7dq1aGpqwvHjx2GxWFBYWIjHH38chw4dGvH5165dw7Vr1/DSSy8hOzsbly9fxhNPPIFr167h8OHDE7q3IIphunfgJtDr9di8eTM0Gg1eeOGFG85LHBgYwOHDh7H1mZ/CYDTi1b37UFRUFMQV3xyiOOB2PtzZxM3urIgPVsjtbRLvEukcYTa0LV0Y1tANskQIAt8YiUZjMpmgVquRN68EEXLfplZYbWac+FsFOjs7ERcX5+cVEk1dPscc//pTGAwGvPraK1Mi5rBarDBcbXMl4kPN3ByJ+PUGA9pbpCXjMrkMSdMTkJymgdatMu7exC1eGwe5XO6nn4oo/Pgz5mhoaPCIOZRKJZRK36dv1dXVITs7G2fPnkVubi4AoLq6Gvfccw8aGxsxffr4jhb95je/wcMPP4yenh5ERIy/bs4Ku5/s3r0bZWVlKCoqQkVFBWJjb3wOXaFQ4KGHHsJ9992HLVu2YMOGDWhpacH27duDsOLAcCTjLW7JeLMzGXcm5PYmwH7jrvljiwBk2mHd1FOHtqjLUgFZEpNxIn/heTKikMKYw8FmtcF4rW1YIj64bd2RkLc3d0BKbUomE5A0fagynuy2ZX0wIU/QxTMZJ/IXP8QcaWlpHl/esWMHnn/+eZ+XdOrUKcTHx7uSdQDIy8uDTCbD6dOnsXr16nFdZ7B4MZFkHWDC7hd6vR5lZWXYuXMnysrKPL7X3d2NX/3qVzh9+jTOnDmD9vZ2vPnmm3jsscdcz4mNjYVer8ctt9yCsrIy6HQ6rF+/Psg/xY2JogWwtw41cbM3DzVwG2ziZjcAkBKgy53JeKqzQp46bLSZDpBpIAh8YyQKGrsICD7+f21nwk7kT1Ml5rBZbWhr7nAk3u5N3Nwr480dsEv4M0YQBCSmxg+NN5uR5NFdPTlNg0RdPOQRjDmIgsYPMcdIFXYpmpubodVqPb4WERGBxMRENDc3j+saBoMBO3fuxOOPPz7h+zNhl6i+vh6bN29GUVGR1xsn4PiX84tf/AKzZs3CbbfdhpMnT456rbKyMly5cgVPP/007rzzTqSnpwdw5Z5E0QrYr7sl327JuGve+HVIS8ZlgCzZmYw7mri5KuOywb8mMxknIiIaQbjEHDabDe3NHa7Ee3hl3NDYBmNTO+w23ztICYKABF28a0v6SJXxxNQEREQyFCYKN3FxceM6hvfMM8/gxRdfHPM5dXV1ktdjMplw7733Ijs726dKP/+Ukqi4uBgajQYVFRUjfj81NRVNTU3Q6XQ4d+4cbr/99lGvJQgCXn75ZRw7dgzFxcU4evSoX9YoirahZNzZQV0c1tDNkYxLaa0oDCXjrjnjKUMzxl3JOP+TI5p0uCWeKCRMhpjDbrejvaXTqzJuuDrUzM14TVoyDgAJKWqvyrhm5tC88cTUeEQq2FSPaNIJYsxRWlrqsQNpJHPmzIFOp0Nra6vH161WK9ra2qDT6cZ8fVdXF/Lz8xEbG4vf/va3iIyc+J9LzJ4kqK2tRXV1NQ4ePDjq+TGlUnnDf5Hu4uLiUF5ejrVr16Kurg5ZWVljPt+RjBuGdVNv8mjo5kjGbRP50YYRAJnGoxIuuI05cyTpyRAEvjEShScJb56SduUQ0aBQiDnsdjs6Wjs9KuOGRiNa3SrjhqttsFmlxBxAvFbtURkfTMQ1rnFniUzGicJW8GKO5ORkJCcn3/B5y5YtQ0dHBz777DMsXrwYAPDxxx/Dbrdj6dKlo77OZDJh1apVUCqV+P3vf4+oqKgJrW8QE3YJqqqqoNVq8cADD/j1ugUFBdiyZQsqKyuxb8/P3OaKDx9t1uw4Uw6rtBvKNCN0Ux86Qw65FoIweudZIgpzrLAT3XTBiDl+8bNdI1bGr7uNObNapCXjak0skgfnis/UeCTi2jQNkqYnQBHFmINoygrBmCMrKwv5+fnYsGEDqqqqYLFYsGnTJjz44IOuDvFXr17FihUr8Pbbb2PJkiUwmUxYuXIlent78c4778BkMsFkMgFwfFAwkUaVTNglOH78OAoKCsYco+ILpVKJgoIC1Bx7A+L1P0q7mCxx6Hy4XOecM+7exC2FyTgRjc0uwudKOZvOEflFoGOOA/9+EF+/Nr7mSaOJS4qFZmYitGka58xxjUcTN82MRCijpTV/IqIwF6Ixx8GDB7Fp0yasWLECMpkMBQUF2Ldvn+v7FosFFy5cQG9vLwDg888/x+nTpwEAGRkZHteqr6/H7Nmzx31vJuw+6urqwoULF7B169aAXD83NxdVVa+ju8cO1bRRxpMJCUPJt1w3VBl3q5ALAt8YiYiIJrNgxByvv14FK6yIGKXXTGzCNI/KuEc3dee29agYxhxEFJ4SExNx6NChUb8/e/ZsjxGSy5cvlzRS0h0Tdh9dunQJoigiOzs7INdfsGABRBG4ePU25Ny20DnaTOfWxC0FguDbOQgiogkR7Y6Hr68lIkmCEXMAIubcMQMLsxZ6V8ZnJiF6GmMOIgoCxhxemLD7yGw2AwBiYmICcv3o6GgAgEW5FTL16M0MiIgCLgTPkxFNJcGKOR5/6ZExGygREQUcYw4vTNh9pFQ6tn0NnlPwt76+Po/7EBHdNCF6noxoqmDMQURTBmMOL6McjqYbycjIgCAIqK2tDcj1z58/D0EQvJoUEBER0dTCmIOIaOpihd1HKpUK8+fPx9mzZ1FYWDjmc1999VV0dHTg2rVrAIAPPvgAjY2NAIAnn3wSarXa6zXnzp1DZmYmVCqV/xdPRDQR3J5GdFMx5iCiKYMxhxdB9Ff7uinoqaeewnvvvYeGhoYxx6zMnj0bly9fHvF7I7X1N5vNmDVrFtasWeMxLoCIKJhMJhPUajXyUn+CCJlvo6Ss9gGcaPo3dHZ2Ii4uzs8rJJo6GHMQUThjzDE6bomX4IknnkBraysOHz485vO+++47iKI44mOkGXxHjhxBa2srNm7cGKCVExFNwOCn3b4+iEgyxhxENCUw5vDChF2C7Oxs5Ofn49lnn0VXV5dfrmkymbBt2zbk5+cjKyvLL9ckIiKiyY0xBxHR1MSEXaLKykoYDAaUlJRIvpYoiigtLYXRaERlZaUfVkdE5Ad2u7QHEfkFYw4iCnuMObwwYZcoPT0de/bsgV6vx65du3y+jiiK2LVrF/R6Pfbu3Yv09HQ/rpKISAJuTyMKCYw5iCjsMebwwi7xflBUVISWlhaUlZXh8uXLqKioQGxs7LhfbzKZUFpaCr1ej927d2P9+vUBXC0R0QSxYytRyGDMQURhjTGHF1bY/WT79u3Yv38/3n33XSxcuBCHDh3CwMDAmK8xm804dOgQFi1ahHfffRd6vR7PPvtskFZMREREkxFjDiKiqYNj3fysvr4excXFqK6uhlarRUFBAXJzc7FgwQJER0ejr68P58+fx7lz51ydWfPz81FZWcktaUQUUlwjVhILpY1YaXsz7EasEIUCxhxEFC4Yc4yOCXuA1NbWoqqqCidOnMDXX38N91+zIAjIzMxEXl4eNm7cyM6sRBSSBt88VySsk/TmWdP+Vti9eRKFEsYcRDTZMeYYHc+wB0h2djb27dsHAOju7sbFixdhNpuhVCqRkZEBlUp1k1dIRDROogjYeZ6MKFQx5iCisMGYwwsT9iBQqVTIycm52csgIiKiMMeYg4govDBhJyKisYkiAH7aTURERAHGmMMLE3YiIhqb3Q4Idt9eK/r4OiIiIpp6GHN4YcJORERj46fdREREFAyMObxwDjsREY1JtNslPXzx2muvYfbs2YiKisLSpUtx5syZUZ/7/vvvIzc3F/Hx8Zg2bRpycnJw4MABj+c89thjEATB45Gfn+/T2oiIiCgwbkbMEepYYSciopDy3nvvoaSkBFVVVVi6dCn27NmDVatW4cKFC9BqtV7PT0xMxPbt25GZmQmFQoEPP/wQhYWF0Gq1WLVqlet5+fn5ePPNN13/rFQqg/LzEBEREfmKFXYiIhqbKEp7TFBFRQU2bNiAwsJCZGdno6qqCjExMXjjjTdGfP7y5cuxevVqZGVlYe7cuXj66adx66234tNPP/V4nlKphE6ncz0SEhJ8+nUQERFRgAQ55pgMmLATEdHY7KK0BwCTyeTxMJvNI95qYGAAn332GfLy8lxfk8lkyMvLw6lTp264VFEUUVNTgwsXLuAHP/iBx/dOnjwJrVaL+fPnY+PGjTAajRJ+KUREROR3fog5wg0TdiIiGpsoOjqv+vRwvHmmpaVBrVa7HuXl5SPeymAwwGazISUlxePrKSkpaG5uHnWJnZ2dUKlUUCgUuPfee/HKK6/grrvucn0/Pz8fb7/9NmpqavDiiy/ik08+wd133w2bzeaHXxARERH5hR9ijnDDM+xERBRwDQ0NiIuLc/2zv8+Px8bG4q9//Su6u7tRU1ODkpISzJkzB8uXLwcAPPjgg67nLlq0CLfeeivmzp2LkydPYsWKFX5dCxEREZG/MGEnIqIxiXYRouDbp9ai89PuuLg4j4R9NBqNBnK5HC0tLR5fb2lpgU6nG/V1MpkMGRkZAICcnBzU1dWhvLzclbAPN2fOHGg0Gly8eJEJOxERUYjwR8wRbrglnoiIxubz1jTnYwIUCgUWL16Mmpoa19fsdjtqamqwbNmycV/HbrePek4eABobG2E0GpGamjqh9REREVEABTHmmCxYYSciojEF+9PukpISrFu3Drm5uViyZAn27NmDnp4eFBYWAgAeffRRzJgxw3UOvry8HLm5uZg7dy7MZjM++ugjHDhwAK+//joAoLu7Gz//+c9RUFAAnU6HS5cuYevWrcjIyPAY+0ZEREQ3Fyvs3piwExFRSFmzZg2uX7+O5557Ds3NzcjJyUF1dbWrEd2VK1cgkw1tEOvp6UFxcTEaGxsRHR2NzMxMvPPOO1izZg0AQC6X48svv8Rbb72Fjo4OTJ8+HStXrsTOnTs5i52IiIhCmiCG60cRREQkiclkglqtxh24BxGI9OkaVljwKT5CZ2fnuM6wExER0dTDmGN0rLATEdGIFAoFdDodPm3+SNJ1dDodFAqFn1ZFRERE4YYxx+hYYSciolH19/djYGBA0jUUCgWioqL8tCIiIiIKR4w5RsaEnYiIiIiIiCgEcawbERERERERUQhiwk5EREREREQUgpiwExEREREREYUgJuxEREREREREIYgJOxEREREREVEIYsJOREREREREFIKYsBMRERERERGFICbsRERERERERCHo/wFxRk9ZL5qulwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "# shade the area of the triangle\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.51,\n", + "Variance in the edge (1,3) is 0.55,\n", + "The average variance is 0.50.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % jnp.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[0]\n", + " [1]\n", + " [2]]\n", + "\n", + "harmonic emedding (shape = (3, 1)):\n", + "[[ 0.17407766]\n", + " [ 0.34815531]\n", + " [-0.52223297]]\n", + "gradient emedding (shape = (3, 4)):\n", + "[[ 2.53358943e-01 1.23024295e-01 2.39383702e-01 9.54375058e-02]\n", + " [-4.53992875e-16 2.46048590e-01 -3.53474814e-16 1.90875012e-01]\n", + " [-4.09943381e-01 -7.60331958e-02 1.47947264e-01 1.54421128e-01]]\n", + "curl emedding (shape = (3, 1)):\n", + "[[ 5.77350269e-01]\n", + " [-5.77350269e-01]\n", + " [-5.55111512e-16]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.0\n" + ] + } + ], + "source": [ + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "\n", + "if use_hodge_composition:\n", + " _, harmonic_embedding = feature_map(xs, params_hodge_1['harmonic'], hodge_type='harmonic') \n", + " _, gradient_embedding = feature_map(xs, params_hodge_1['gradient'],hodge_type='gradient')\n", + " _, curl_embedding = feature_map(xs, params_hodge_1['curl'], hodge_type='curl')\n", + " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + " kernel_mat_32_alt = jnp.matmul(harmonic_embedding, harmonic_embedding.T) + jnp.matmul(gradient_embedding, gradient_embedding.T) + jnp.matmul(curl_embedding, curl_embedding.T) \n", + " print('harmonic emedding (shape = %s):\\n%s' % (harmonic_embedding.shape, harmonic_embedding))\n", + " print('gradient emedding (shape = %s):\\n%s' % (gradient_embedding.shape, gradient_embedding))\n", + " print('curl emedding (shape = %s):\\n%s' % (curl_embedding.shape, curl_embedding))\n", + "else:\n", + " # xs are random points from above\n", + " _, embedding = feature_map(xs, params_32, normalize=True)\n", + " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + " kernel_mat_32_alt = jnp.matmul(embedding, embedding.T)\n", + " print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + " \n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', jnp.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-0.64593905 0.53900576]\n", + " [-0.02115641 0.60742445]\n", + " [ 0.52768281 -0.08641872]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = PRNGKey(1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "if use_hodge_composition:\n", + " key, samples_harmonic = sample_paths(xs, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", + " key, samples_gradient = sample_paths(xs, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", + " key, samples_curl = sample_paths(xs, params_hodge_1['curl'], key=key, hodge_type='curl')\n", + " samples = samples_harmonic + samples_gradient + samples_curl\n", + "else:\n", + " key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = PRNGKey(seed=1234)\n", + "if use_hodge_composition:\n", + " key, samples_harmonic = sample_paths(other_edges, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", + " key, samples_gradient = sample_paths(other_edges, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", + " key, samples_curl = sample_paths(other_edges, params_hodge_1['curl'], key=key, hodge_type='curl')\n", + " samples = samples_harmonic + samples_gradient + samples_curl\n", + "else:\n", + " key, samples = sample_paths(other_edges, params_32, key=key)\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb b/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb deleted file mode 100644 index be07577c..00000000 --- a/notebooks/backends/PyTorch_EdgeSpaceGraph.ipynb +++ /dev/null @@ -1,940 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on (Oriented) Graphs\n", - "This notebook shows how to define and evaluate kernels on the edge space of an oriented simple graph.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **PyTorch** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): Torch backend enabled.\n" - ] - } - ], - "source": [ - "# Import a backend, we use torch in this example.\n", - "import torch\n", - "import numpy as np\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "import geometric_kernels.torch\n", - "# from geometric_kernels import jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAGjCAYAAACBlXr0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3H0lEQVR4nO3de1hVZb4H8O9Wg3B7KQWOVGI4GAhROWGSJxtNbeCUTc6mx0dy6nRAUzp4o2aOE9akoGdqMjRDJrYzWaHDjFhjnmRGnczyjqOFbMEw0tQIxZKLuPGyzh8MOxA27L1Za73r8v08T8+jsPfiZUb9sn7r974/iyRJEoiIiATqIXoBREREDCMiIhKOYURERMIxjIiISDiGERERCccwIiIi4RhGREQkHMOIiIiEYxgREZFwDCMiIhKOYURERMIxjIiISDiGERERCccwIiIi4RhGREQkHMOIiIiEYxgREZFwDCMiIhKOYURERMIxjIiISDiGERERCccwIiIi4RhGREQkHMOIiIiEYxgREZFwDCMiIhKOYURERMIxjIiISDiGERERCccwIiIi4XqJXoA36uvrUVFRAafTCX9/f4SHh6NPnz6il0VERN2k+TByOBzIzc3Fli1bUF5eDkmSXJ+zWCyIiIjAxIkTMXPmTERFRQlcKRER+coitf7XXUMqKyuRmpqKoqIiBAcHw2azYeTIkYiKikLv3r1x4cIFOBwO7N+/H4WFhaiurkZ8fDxycnIQFhYmevlEROQFTYaR3W7H3LlzERgYiCVLliAxMRF+fn5uX9/U1IT169djwYIFqKmpQXZ2NlJSUlRcMRERdYfmGhiysrIwffp0TJ06FSUlJUhKSuo0iADAz88PSUlJOHz4MKZOnYrp06cjKytLpRUTEVF3aeqZkd1uR0ZGBhYvXoyMjAyv39+3b1/k5eUhNDQUGRkZGDRoEJKTkxVYKRERyUkzZbrKykrExMRg6tSpyMvLa/O5/fv3Y82aNfjoo4/w1VdfYeDAgYiLi0NmZiZuu+22dteSJAkzZszAunXrUFJSwmdIREQap5kwSkhIwJEjR1BSUoK+ffu2+VxiYiJ27tyJxx57DHfccQeqqqqwcuVK1NfXY8+ePbj99tvbXa+2thYxMTGIiorC5s2b1fo2iIjIB5oII4fDgejoaOTn5yMpKand53ft2oXY2Ng2z46++OILxMTEIDExEe+++26H1127di0ef/xxOBwODB8+XLH1ExFR92gijGbPno2CggJ8/fXXXTYrtHb33XcDAA4cONDh551OJ0JDQzFlyhSsWLFClrUSEZH8NNFNt2XLFthsNq+CSJIkfPvttwgMDHT7Gn9/f9hsNmzdulWOZRIRkUKEh1FdXR3Ky8sxcuRIr96Xn5+PU6dOYcqUKZ2+LjY2FmVlZaivr+/OMomISEHCw+jYsWOQJMmro3zKysrwzDPP4N5778WTTz7Z6Wujo6MhSRIqKiq6u1QiIlKI8DByOp0AgN69e3v0+qqqKjz00EPo378/1q9fj549e3b6+oCAgDZfh4iItEf4pld/f38AwIULF7p87fnz55GQkIDvv/8en3zyCW666aYu39PY2Njm6xARkfYIvzMKDw+HxWKBw+Ho9HUXL17EpEmTcPToUWzatMnjsl5paSksFgvCw8PlWC4RESlAeBj16dMHERER2L9/v9vXXLlyBVOmTMHu3bvxl7/8Bffee6/H1y8uLkZkZCTnHhERaZjwMh0ATJw4EQUFBcjOzu6wvTs9PR0bN27EpEmTcO7cuXabXKdNm9bhdZ1OJwoLC7vsuCMiIrE0sem1qxMYxo4di48//tjt+919CzyBgYhIHzQRRkDnZ9P5gmfTERHph/BnRi1ycnJw9uxZzJ8/v9vXkiQJ8+fPxzfffIMlS5bIsDoiIlKSZsIoLCwM2dnZsNvtyMzM9Pk6kiQhMzMTq1evxqVLlzB16lR8+eWXMq6UiIjkppkwAoCUlBRkZmZi4cKFmD59Ourq6rx6f21tLWbMmIEXXngBVqsVAFBeXo64uDjs2bNHiSUTEZEMNBVGAPD8888jLy8P69atw+233461a9eiqamp0/c4nU6sXbsWMTExWLduHex2O0pKShAZGQkAOHPmDMaNG4fCwkI1vgUiIvKSZhoYrlVZWYnU1FQUFRUhODgYNpsNsbGxiI6ORkBAABobG1FaWori4mIUFhaiuroa8fHxyMnJcU12/e677/Dzn/8c27dvBwBYLBb87ne/w7x582CxWAR+d0RE1Jpmw6iFw+FAbm4utm7dirKysnZt3LfeeismTZqEWbNmddi+3dTUhJSUFLzzzjuujz3zzDPIzs5Gr16a2GZFRGR6mg+j1urr61FRUYE//elP+O1vfwsAWLlyJZ555plO3ydJEl566SW89NJLro89/PDDWLduHU9mICLSAM09M+pMnz59cNddd+Hhhx92fay0tLTL91ksFvzmN7/BW2+95bob2rRpE+6//36cPn1asfUSEZFndBVGLVofktrVAautPfnkkygqKkL//v0BAAcPHkRcXBwOHz4s+xqJiMhzugyjAQMGYNCgQQA8uzNqbfz48di5cydCQ0MBAF9//TX+/d//naPJiYgE0mUYAc0TXAHg7NmzqK6u9vq9e/fuxd133w2geX9SQkIC/vCHP8i+TiIi6ppuw8jXUl2LQYMG4eOPP8akSZMAAJcvX0ZycjIWLlzo9uBVIiJShm7DqOXOCPC+VNfCarXivffeQ1pamutjmZmZmDZtGseUExGpyNRhBAA9e/bEihUrkJ2d7doIu3btWjz44IM4d+5ct9dJRERd020YdbdMd605c+Zgw4YNCAgIAADs2LEDo0eP5iGrREQq0NWm12uFhISgqqoKgYGBOHPmjCzX3LdvHyZNmuRqiggKCsLGjRsRFxcny/WJiKg93d4ZAd3rqHPnnnvuwZ49e3jIKhGRinQdRnKX6lqEhYVh165dGDt2LADg4sWLeOyxx7Bs2TJ22hERKUDXYSRXE0NHbrzxRvztb3/DL37xCwDN59ulp6cjLS0Nly9flvVrERGZHcOoE35+flizZg1efPFF18feeOMNTJ48GfX19bJ/PSIis9J1GClVpmuNh6wSESlP1910gDIdde5s27YNNpsN58+fBwAMHjwYH374IW6//XZFvy4RkdHp+s4IUKajzh0eskpEpAzdh5EapbrWeMgqEZH8dB9GSjcxdISHrBIRyYth5CMeskpEJB/dh5HaZbrWeMgqEZE8dN9NB6jbUefO+++/j6SkJDQ2NgIAIiIi8OGHH2Lo0KFC1kNEpCe6vzMC1O2oc+fRRx/F9u3bERwcDAAoLy9HXFwc9uzZI2Q9RER6YogwElmqa42HrBLpQ319PQ4dOoS9e/fi0KFDPFFFAwwRRqKaGDrCQ1aJtMnhcGD27NkYPnw4+vXrhxEjRiAuLg4jRoxAv379MHz4cMyePVvoD7RmxjBSAA9ZJdKOyspKJCQkIDo6GgUFBRg3bhxWr16NPXv24PPPP8eePXuwevVqjBs3DgUFBYiOjkZCQgIqKytFL91cJAOoqamRAEgApJ/85Ceil+Ny9epV6cUXX3StDYD08MMPS3V1daKXRmQKeXl5ktVqlYYMGSLl5+dLTqez09c7nU4pPz9fCg0NlaxWq5SXl6fSSskQYSRJkjRo0CAJgBQYGCh6Ke289dZbUq9evVyBNGLECOnUqVOil0VkaJmZmRIAKSUlRaqtrfXqvbW1tVJKSooEQMrMzFRohdSaYcJo/Pjxrn/sv/32W9HLaWfr1q1S//79XWscPHiwVFJSInpZRIaUl5cnAZAWL17cressWrRIAiDZ7XaZVkbuGOKZEaCdjjp3eMgqkToqKysxd+5cpKSkICMjo8vXZ2VlwWKxdHj6fkZGBlJSUjBnzhw+Q1KYYcJIa00MHeEhq0TKS01NRWBgIJYtW9bla0+ePIklS5bAarV2+HmLxYJXX30VAwcORGpqqtxLpVYYRirjIatEynE4HCgqKsKSJUvQt2/fLl//7LPPIi4uDrGxsW5f069fPyxduhRFRUU4cuSInMulVgwTRlov07XGQ1aJlJGbm4vg4GAkJiZ2+dodO3Zg/fr1yM7O7vK1NpsNwcHBWLVqlQyrpI4YJowGDBiAQYMGAdD2nVELHrJKJL8tW7bAZrPBz8+v09dduXIFaWlpSElJQUxMTJfX9ff3h81m4zNeBRkmjABtnFHnrTlz5mDDhg0ICAgA0PzT2ujRo/Hll18KXhmRvtTV1aG8vBwjR47s8rW5ubk4fvw4Fi9e7PH1Y2NjUVZWxqODFGKoMNJTqa41HrJK1H3Hjh2DJElt/h3oSE1NDV544QUsXLgQQUFBHl8/OjoakiShoqKiu0ulDhgqjPTSxNARHrJK1D0tz1t79+7d6esyMjIwYMCANs9sPdFSveBzXWUwjDSEh6wS+c7f3x8AcOHCBbev+eKLL/Dmm29i9uzZOH36NL766it89dVXuHjxIi5duoSvvvrK7TPbllllLV+H5GWoMNJrma41HrJK5Jvw8HBYLJZO/+6fOnUKV69exezZsxEWFub6b+/evTh69CjCwsKwaNGiDt9bWloKi8WC8PBwpb4FU+slegFyaumoq6qq0uWdUQs/Pz+sWbMGQ4cOxUsvvQQAeOONN3D8+HGsW7cOffr0EbxCIu3p06cPIiIisH//fjz11FMdvub222/He++91+7jGRkZqKurw/Lly/GjH/2ow/cWFxcjMjKSf/8UYoix461NmDAB27ZtAwB8++23rqYAvVqzZg1SUlJcd0UjRozApk2bcNNNNwleGZH2zJ49GwUFBfj666+7bO9ubezYsTh79iwOHz7c4eedTidCQ0MxZcoUrFixQq7lUiuGKtMBxijVtfbkk0+iqKgI/fv3BwAcPHgQcXFxbv/SEJnZzJkzUV1djfXr18t63cLCQlRXV2PWrFmyXpd+YLgw0nsTQ0d4yCqRZ6KiohAfH48FCxagrq7O4/dt377d7Q94tbW1WLBgAeLj4zF8+HC5lkrXYBjpBA9ZJeqaJEm4++67cfLkScybN0+W66Wnp6OmpgY5OTkyrJDcEja8QiFanfoql/r6emnSpEltpsdmZGRIV69eFb00IqGampqkmTNntvm70Z15RlevXuU8IxUZLowkSdtTX+Vw+fJlKS0trc1fuqSkJOnixYuil0YkxHfffSdNnDixzd+JsWPH+jzp9fz5865Jr1lZWQqtmlozZBhpfeqrXLKzsyWLxeL6Xu+//36ppqZG9LKIVPXll19Kw4cPd/098PPzk95++21JkponvlqtVik0NFTKz8+XnE5np9e6ePGilJ+fL4WGhkpWq5V3RCoyXGs30Nze+frrrwMAPvroI9eJBkb0/vvvIykpybU7PCIiAh9++CGGDh0qeGVEytu1axceffRRnDlzBgAwcOBAvPfeexgzZozrNZWVlUhNTUVRURGCg4Nhs9kQGxuL6OhoBAQEoLGxEaWlpSguLnZ1zcXHxyMnJwdhYWGivjXzEZ2GSsjNzXX9lLRy5UrRy1Hc3r17peDgYNf3HBQUJO3evVv0sogUtXbtWsnf39/15z4iIkL64osv3L6+tLRUSktLk4YPH96motDy33XXXSclJCRIDodDxe+CWhiumw4wbkedOzxklcxEkiQsWrQISUlJrkNLH3jgAezevbvTo3qioqKwYsUKOBwO1NbW4uDBg9izZ49ruN6lS5cQFRXF9m1RRKehEozeUefOuXPnXA9tAUgWi0V69dVX2WlHhnHx4kVp2rRpbe5okpOTpaamJp+vWV1d7brW6NGjZVwtecOQz4wAICQkBFVVVQgMDHTVk82gqakJKSkpeOedd1wfe+aZZ5CdnY1evQx1FCGZzJkzZzB58mTs3LkTAGCxWPDb3/4Wzz77rGtasq+GDRuGiooK+Pv7o7a21qujhEgehizTAW2nvpopjFoOWX3xxRddH3vjjTcwefJkTqgk3SorK0NcXJwriAICAlBYWIjnnnuu20EEAPfeey+A5jPoDh482O3rkfcMG0atz6gzw3Oj1iwWC37zm9/grbfect0Nbdq0Cffffz9Onz4teHVE3tm2bRvi4uLw5ZdfAmiueuzYsQOTJ0+W7Wu0hBEA7N69W7brkucMG0Zma2LoCA9ZJb3Ly8tDfHw8zp8/DwC48847sW/fPsTGxsr6dRhG4pkijIxwereveMgq6dHVq1fxy1/+EjNmzHCNT3n44Yfx6aef4pZbbpH9691+++2wWq0AGEaiGDaMzFymuxYPWSU9aWhogM1mwyuvvOL62Ny5c/H+++8rNtiuV69eGDlyJIDmH9hOnTqlyNch9wwbRi1TXwGGEQAMGjQIH3/8MSZNmgQAuHz5MpKTk7Fw4UIYtKGSdOjUqVO4//778f777wMAevbsiZycHLz22mvo2bOnol+7daluz549in4tas+wYQSYt6POHavVivfeew9paWmuj2VmZmLatGmuzYNEohw8eBCjRo3CP//5TwBAv3798H//93+qDbTjcyOxDB1GLNW117NnT6xYsQLZ2dmulti1a9fiwQcfxLlz5wSvjszqgw8+wJgxY1zlsVtvvRW7du3CT3/6U9XWEBcX5/o1w0h9hg4jdtS5N2fOHGzYsAEBAQEAgB07dmD06NGu9lkiNUiShNdeew0/+9nP0NDQAKA5FPbu3dvm768agoKCXMcJHThwAE1NTap+fbMzTRiZuaPOnUcffRTbt29HcHAwAKC8vBxxcXGsl5MqLl26hNTUVMyfP9/13HLKlCn4xz/+4fozqTZufhXH0GHEMl3XeMgqifD999/joYceQm5urutjCxcuxNq1a1136yLwuZE4hg4jdtR5JiwsDLt27XLNfbp48SIee+wxLFu2jJ12JLvKykqMHj0aW7ZsAdB8hNXbb7+NRYsWoUcPsf8kMYzEMXQYAeyo89SNN96Iv/3tb/jFL34BoLmWn56ejrS0NNemQ6Lu2rVrF0aNGoUjR44AaB6Gt3XrVtefO9G4+VUcw4cRS3We4yGrpKR169bhgQcecP1QGBERgb1797aZyioaN7+KY/gwYkedd3jIKslN6mQY3o9+9CPBq2uPm1/FMFUYsaPOc+4OWS0pKRG8MtITp9OJJ554os3ddnJyMoqKinDjjTcKXJl7fG4khuHDiGU633V0yOp9993HQ1bJI2fOnMH48ePx7rvvAmi+63755ZeRl5eH6667TvDq3OPmVzEMO+m1NbNOfZVLVVUVJk2ahOLiYgDNdfXf//73+K//+i/BKyOtKisrw0MPPeTaRB0QEID8/HxZZxApiZNf1Wf4OyOAHXXdNWjQIGzfvh2PPPIIAB6ySp1TYxie0rj5VX2mCCOW6rrParViw4YNPGSVOqXWMDyl8bmR+kwRRuyokwcPWSV31B6GpzSGkfpMF0bsqOs+HrJKrYkYhqc0bn5VnynCiGU6+fGQVQKA06dPCxuGpyRuflWfKcKIZ9Qpg4esmtvBgwdxzz33CBuGpzRuflWXKcIIYEedUnjIqjlpYRie0vjcSF2mCSOW6pTDQ1bNQ0vD8JTGza/qMk0YsaNOWTxk1fi0OAxPSZz8qi5ThhE76pTBQ1aN6/z583j44Yc1NwxPadz8qh7ThBHLdOrhIavG0jIM7+9//zsAbQ3DUxqfG6nH2H+SWmFHnbp4yKoxtAzDa6kmaG0YntIYRuoxTRgB7KhTW3R0NPbu3es6Cqa2thYJCQn4wx/+IHhl5Ak9DMNTGje/qsdUYcRSnfp4yKr+6G0YnpK4+VU9pgojdtSJwUNW9UOPw/CUxs2v6jBtGLGjTl08ZFX79DoMT2l8bqQOU4URy3Ti8ZBVbSorK0NcXBx27twJoHkYXmFhIZ577jnXDw9mxc2v6jDFpNfWOPVVG/bt24dJkyahuroaQPMGw40bN7b5i0/q2LZtG2w2m2sGUUhICD744APcfffdglemHZz8qjxT3RkB7KjTCh6yqg3uhuExiNri5lflmS6MWKrTDh6yKo7RhuEpjc+NlGe6MGJHnbbwkFX1GXEYntIYRsozdRixo04beMiqeow6DE9p3PyqPNOFEct02sRDVpVn9GF4SuLmV+WZLox4Rp228ZBVZZhhGJ7SuPlVWaYLI4AddVrHQ1blY6ZheErjcyNlmTKMWKrTPh6y2n1mG4anNG5+VZYpw4gddfrAQ1Z9Z9ZheEri5FdlmT6M2FGnbTxk1XtmHoanNG5+VY4p/2SyTKcvPGTVcx0Nw9u2bZtphuEpjc+NlGPKMGJHnT7xkNXOuRuGd9999wlemXEwjJRjyjAC2FGnV48++ii2b9/uegBfXl6OuLg4U7fachieerj5VTmmDSOW6vSLh6z+gMPw1MXNr8oxbRixo07feMhq8139hAkTOAxPZdz8qgyGEdhRp1dmPmS1rKwMo0aNwqeffgqAw/DUxOdGyjBtGLFMZwxmPGR127ZtiIuLczVuhISE4JNPPsHkyZMFr8wcuPlVGaab9Noap74ay5o1a5CSkuK6KxoxYgQ2bdqEm266SfDK5JOXl4fU1FTX93jnnXdi06ZNnEGkMk5+lZ9p74wAdtQZjZEPWeUwPG3h5lf5mTqMWKozHiMesspheNrD50byM3UYsaPOmIx0yGpHw/BWrVrFYXiCMYzkxzD6F3bUGYsRDlntaBjehx9+iJkzZwpeGXHzq/xMHUYs0xmbng9ZdTcM78EHHxS8MgK4+VUJpg4jnlFnfHo7ZJXD8PSDm1/lZeowAthRZxZ6OGSVw/D0hc+N5GX6MGKpzjy0fMgqh+HpDze/ysv0YcSOOnPR4iGrHQ3De+eddzgMT+M4+VVepv+Tzo4689HSIavuhuFNmzZN1XWQb7j5VT6mDyOW6cxJC4eschie/vG5kXxMH0bsqDMvOQ5Zra+vx6FDh7B3714cOnTIo/dxGJ5xMIxkJJE0fvx4CYAEQKqurha9HBLgrbfeknr16uX6czBixAjp1KlTHb62tLRUSktLkyIjIyWLxeJ6DwDJYrFIkZGRUlpamlRaWtruvRcvXpSmTZvW5j3JyclSU1OT0t8iKeDSpUuS1WqVAEiDBw8WvRxdM/2dEcBSHXl2yGplZSUSEhIQHR2NgoICjBs3DqtXr8aePXvw+eefY8+ePVi9ejXGjRuHgoICREdHIyEhAZWVlQA4DM+IuPlVRqLTUAtyc3NdP6WuXLlS9HJIoMOHD0uhoaGuPw/9+vWTtmzZIuXl5UlWq1UaMmSIlJ+fLzmdzk6v43Q6pfz8fCk0NFSyWq3SokWLpKFDh7quGxAQIG3YsEGl74qUtGDBAtf/r+vXrxe9HN1iGEmS9Mknn7j+MKWmpopeDgn2zTffSLGxsa4/Ez169JAASCkpKVJtba1X16qtrZWSk5PblOVCQkKk4uJihVZPatu4caPr/9v09HTRy9EtlunAMh21de0hq1evXsXixYuRl5eHvn37enWtvn37wm63Y9GiRQCAW265Bfv27cPdd98t+7pJDG5+lQfDCOyoo/asViteffVV+Pn5ITk5GRkZGW0+X1paisceewxDhw5F7969ERgYiPvvvx8ffPBBh9fLyMhAcnIyvvvuO1y6dEmNb4FUws2v8mAY/QvPqKNrpaWlISQkBK+99lq7zx0/fhx1dXV48sknsXz5cixcuBAA8Mgjj+DNN99s93qLxYJly5Zh4MCBSE1NVXztpC5ufpWB6DqhVqSlpbnqvh999JHo5ZBgpaWlEgApPz/f4/dcvnxZuvPOO6WIiAi3r8nPz5cASA6HQ45lkkbk5OS4/v147bXXRC9Hl3hn9C88o45ay83NRXBwMBITEz1+T8+ePTF48GB8//33bl9js9kQHByMVatWybBK0gpufu2+XqIXoBU8o45a27JlC2w2G/z8/Dp9XUNDAxobG3H+/Hls3LgRmzdvxpQpU9y+3t/fHzabDVu3bpV7ySRQy+TXhoYGhpGPeGf0L+yooxZ1dXUoLy93bWbsTHp6uusB9rPPPovJkydj5cqVnb4nNjYWZWVlHh85RNrHza/dxzD6F3bUUYtjx45BkqQ2P6C4M3fuXGzZsgVr1qxBQkICrly50mU3VXR0NCRJQkVFhVxLJg3g5NfuYRi1wo46AuA6vLR3795dvjYyMhITJkzAE088gU2bNqG+vh6TJk3qdBRFy7C8lq9DxsDnRt3DMGqFpToCmp/rAMCFCxe8fm9iYiL279+Po0ePun1NY2Njm69DxsDNr93DMGqFHXUEAOHh4bBYLD41srQEzfnz592+prS0FBaLxbVRkoyBm1+7h2HUCjvqCAD69OmDiIgI7N+/3+1rqqur233s0qVLePvttxEQENDp86bi4mJERkaiT58+sqyXtIObX33HMGqFZTpqMXHiRBQWFrr96fbpp5/G+PHj8dJLL8FutyMzMxN33HEH/vnPfyIzM9Nt0DidThQWFmLChAlKLp8E4XMj3zGMWmFHHbWYOXMmqqursX79+g4/P2XKFPTo0QOrVq3CrFmzsGzZMtxyyy3461//ivnz57u9bmFhIaqrqzFr1iyllk4CMYx8Z5E6a/sxoQkTJmDbtm0AmksxQUFBgldEoiQkJODIkSMoKSnx+rTujtTW1iImJgZRUVHYvHmzDCskrbl8+TJuuOEGNDQ0YPDgwThx4oToJekG74yuwVIdtcjJycHZs2c7vdPxlCRJSE9PR01NDXJycmRYHWkRN7/6jmF0DXbUUYuwsDBkZ2e7ngn5SpIkZGZmwm63Y/ny5QgLC5NxlaQ13PzqG4bRNdhRR62lpKQgMzMTCxcuREpKCurq6rx6f21tLWbMmIEXXngBWVlZSE5OVmilpBV8buQbhtE1WKaja/3P//wPBg8ejD/+8Y+IjIzE2rVru9xD4nQ6sXbtWsTExGDdunWw2+349a9/rdKKSSRufvUNGxg6EBISgqqqKgQGBvJYIMKbb76Jp59+GgDQv39/nD9/HsHBwbDZbIiNjUV0dDQCAgLQ2NiI0tJSFBcXu7rm4uPjkZOTw9KcyQwbNgwVFRXw9/dHbW1tl6e/E8OoQ+yooxbnzp3DbbfdhpqaGgDAJ598ggEDBiA3Nxdbt25FWVlZm3PoLBaL67y6WbNmYfjw4aKWTgI98cQTeOeddwA0PzcaNWqU4BVpH+cZdSAqKsoVRqWlpRg7dqzYBZEwL7zwgiuIkpKScN999wEAVqxYAQCor69HRUUFnE4n/P39ER4ezpMVCPfee68rjHbv3s0w8gCfGXWAHXUEAJ9//rlrIqvVasXLL7/c7jV9+vTBXXfdhVGjRuGuu+5iEBEANjH4gmHUAXbUkSRJSEtLw9WrVwEAGRkZuPnmmwWvivSiZfIrwDDyFMOoA+yooz//+c/YsWMHgOZTvOfNmyd4RaQn3PzqPYZRB3hGnbk1NDTg2Wefdf0+Ozubs4fIa9z86h2GkRuc+mpeS5YswcmTJwEADz30EB566CHBKyI94nMj7zCM3GCpzpyOHTuG3/3udwAAPz8/ZGdni10Q6RY3v3qHYeQGO+rMad68ea7TFebPn89prOQzTn71DsPIDXbUmc/mzZvxwQcfAABuuukmPP/884JXRHrHya+eYxi5wTKduTQ1NWHu3Lmu37/yyivcM0TdxudGnmMYucGOOnNZvnw5jh49CgAYM2YMpk6dKnhFZAQMI8/xbLpO8Iw6czh9+jQiIiJQX1+PHj164MCBA7jrrrtEL4sMgJNfPcc7o06wVGcOv/rVr1BfXw8AePrppxlEJBtufvUcw6gT7Kgzvp07d+Ldd98F0FyaXbx4seAVkdFw86tnGEadYEedsV25cgVpaWmu32dmZmLgwIECV0RGxOdGnmEYdYJlOmNbvXq1q932zjvvxIwZMwSviIyIm189wwaGLnDqqzFdOzRvx44dGDNmjOBVkVFx8mvXeGfUBZ5RZ0zXDs1jEJGSuPm1awyjLrBUZzyeDM0jkhOfG3WNYdQFdtQZC4fmkQgMo64xjLrAjjpj4dA8EoGTX7vGMOoCy3TGwaF5JAo3v3aNYdQFnlFnHByaRyJx82vnGEYeYEed/nFoHonG50adYxh5gKU6/ePQPBKNm187xzDyADvq9I1D80gLOPm1cwwjD7CjTr84NI+0hJtf3WMYeYBlOv3Kzs7m0DzSDD43co9h5AF21OnT6dOnXSMhevTogRUrVsBisQheFZkZw8g9hpGH2FGnPxyaR1rDza/uMYw8xFKdvnBoHmkRN7+6xzDyEDvq9IND80jLuPm1YwwjD7GjTj84NI+0jM+NOsYw8hDLdPpw7tw5/PrXv3b9/vXXX0fPnj0FroioLW5+7RjDyEPsqNMHDs0jrePm144xjLzAjjpt49A80gtufm2PYeQFluq0i0PzSE/43Kg9hpEX2FGnXRyaR3rCMGqPYeQFdtRpE4fmkd5w82t7DCMvsEynTRyaR3rDza/tMYy8wI467eHQPNIrbn5ti2HkJXbUaQuH5pFe8blRWwwjL7FUpx0cmkd6xs2vbTGMvMQmBm3g0DzSO25+bYth5CW2d2tD66F59913H4fmkS5x8+sPGEZeYplOvGuH5r3++uscmke6xOdGP2AYeal1Rx3LdGJwaB4ZBcPoBxZJkiTRi9CbCRMmYNu2bQCA6upqBAUFCV6ReezcuRP33XcfgOYfDI4ePcpZRaRbly9fxg033ICGhgYMHjwYJ06cEL0kYXhn5AOW6sTg0DwyGm5+/QHDyAfsqBPDbrdzaB4ZDje/NmMY+YAddeo7d+5cm31EHJpHRsHnRs0YRj5gmU59HJpHRsXNr83YwOCjkJAQVFVVISgoCNXV1aKXY2iff/45RowYgatXr8JqtaK8vJyzishQhg0bhoqKCvj7+6O2thZ+fn6il6Q63hn5qKVUd+bMGZ5RpyAOzSMz4OZXhpHPWKpTB4fmkRnwuRHDyGfsqFMeh+aRWTCMGEY+Y0ed8jg0j8yCk18ZRj5jmU5ZHJpHZsLNrwwjn/GMOmVxaB6ZjdlLdQyjbmBHnTI4NI/MyOwnMTCMuoGlOvlxaB6Zldk3vzKMuoEddfLj0DwyK7NPfmUYdQM76uTFoXlkdmbe/Mow6gaW6eTFoXlkdmZuYmAYdQM76uSzc+dOvPvuuwCa/3dtuUMiMhOGEfmMHXXdx6F5RM3MvPmVYdRNLNV1H4fmETXr1asX7rnnHgDm2/zKMOomdtR1D4fmEbVl1hZvhlE3saOuezg0j6gts25+ZRh1E8t0vvv888+xatUqAIDVasXLL78seEVE4vHOiHzCjjrfcGgeUcfMuvmVYSQDdtR5r6CggEPziNww4+ZXhpEMWKrzDofmEXXOjPuNGEYyYEedd5YsWeJqWeXQPKL2GEbkE3bUee7aoXmvvfaa4BURaY8ZN78yjGTAMp3nrh2aN2zYMMErItIeM25+ZRjJgB11nuHQPCLPma3Fm2EkE3bUdY5D84i8Y7bNrwwjmbBU1zkOzSPyDu+MyCfsqHOPQ/OIvGe2za8MI5mwo849Ds0j8o2ZNr8yjGTCMl3HODSPyHdm2m/EMJIJO+ra49A8ou5hGJFP2FHXFofmEXWPmTa/MoxkxFLdDzg0j6j7zLT5lWEkI3bU/YBD84jkYZYWb4aRjNhR14xD84jkY5bNrwwjGbFMx6F5RHIzy52RRZIkSfQijCQkJARVVVUICgpCdXW16OWo7k9/+pPrdIXw8HAcPnyYs4qIumnYsGGoqKiAv78/amtr4efnJ3pJsuOdkczM3FHHoXlEyjDD5leGkczMXKrj0DwiZZhhvxHDSGZm7ajj0Dwi5TCMyGtm7ajj0Dwi5Zhh8yvDSGZmLNNxaB6Rssyw+ZVhJDOznVHX1NSEOXPmuH7PoXlEyjB6izfDSAFm6qjLzs7GF198AYBD84iUZPTNrwwjBZilVMeheUTq4Z0Rec0sHXUcmkekHqNPfmUYKcAMHXUcmkekPiNvfmUYKcDoZToOzSMSw8j7jRhGCjB6Rx2H5hGJwTAirxm1o45D84jEMfLmV4aRQoxaquPQPCJxjLz5lWGkECN21HFoHpF4Rm3xZhgpxGgddRyaR6QNRt38yjBSiNHKdAUFBdixYweA5qF58+bNE7wiInMy6p0RJ70qyChTXxsaGhAREeGqT2/atImziogEMuLkV94ZKcgoHXUcmkekLUbc/MowUpARSnUcmkekPUbcb8QwUpAROuo4NI9IexhG5BW9d9RxaB6RNhlx8yvDSEF6LtNxaB6Rdhlx8yvDSEF6PqOOQ/OItM1oLd4MI4XpsaOOQ/OItM9om18ZRgrTY6mOQ/OItI93RuQVvXXUcWgekT4YbfIrw0hheuqo49A8In0x0uZXhpHC9FSm49A8In0x0n4jhpHC9NJRx6F5RPrDMCKv6KGjjkPziPTHSJtfGUYq0Hqp7rPPPuPQPCIdMtLmV4aRCrTcUSdJEmbPns2heUQ6ZZQWb4aRCrTcUceheUT6ZpTNrwwjFWi1TNfQ0IBnn33W9fvs7Gz4+/sLXBEReYt3RuQxrXbUcWgekf4ZZfMrw0glWuuo49A8IuMwwuZXhpFKtFaq49A8IuMwwn4jhpFKtNRRx6F5RMZihDDqJXoBZqGVjjoOzSMynpbNrw0NDdi5cycOHToEp9MJf39/hIeH6+LvOMNIJVop03FoHpHxHD16FDfccAOamppw6tQpjBgxwvU5i8WCiIgITJw4ETNnzmzzb5GWWCRJkkQvwixCQkJQVVWFoKAgVFdXq/71T58+jYiICNTX16NHjx44cOAAZxUR6VhlZSVSU1NRVFSEwMBAPPbYYxg5ciSioqLQu3dvXLhwAQ6HA/v370dhYSGqq6sRHx+PnJwchIWFiV5+WxKpZvz48RIACYBUXV2t+tefNm2a6+vPmjVL9a9PRPLJy8uTrFarNGTIECk/P19yOp2dvt7pdEr5+flSaGioZLVapby8PJVW6hk2MKhIZKmOQ/OIjCMrKwvTp0/H1KlTUVJSgqSkJPj5+XX6Hj8/PyQlJeHw4cOYOnUqpk+fjqysLJVW3DWGkYpEddRxaB6RcdjtdmRkZGDx4sXIy8tD3759vXp/3759kZeXh0WLFiEjIwOrV69WaKXeYRipSFRHHYfmERlDZWUl5s6di5SUFGRkZLT53Pbt22GxWDr8r6Mz6zIyMpCSkoI5c+agsrJSrW/BLTYwqOjcuXOuO5Kf/OQn2L59uypf87bbbnPNKtqxYwdnFRHpVEJCAo4cOYKSkpJ2d0Tbt2/HuHHjMHv2bIwcObLN5+Lj4xEYGNjuerW1tYiJiUFUVBQ2b96s6Nq7wtZuFbWcUVdVVaVamY5D84iMweFwoKioCPn5+Z2W5saMGYPExESPrtmvXz8sXboUjz/+OI4cOYLhw4fLtVyvsUynMjXPqOPQPCLjyM3NRXBwsEdBU1dXh8uXL3t0XZvNhuDgYNe/FaIwjFSmVkedxKF5RIayZcsW2Gy2LrvmnnrqKfTr1w/XX389xo0bh+Li4k5f7+/vD5vNhq1bt8q5XK8xjFSmVkcdh+YRGUddXR3Ky8vbPQtqzc/PDzabDcuXL8df//pXZGZmoqSkBGPGjOnyJO/Y2FiUlZWhvr5e7qV7jM+MVKZGRx2H5hEZy7FjxyBJUqdH+YwePRqjR492/f6RRx5BYmIi7rjjDixYsABFRUVu3xsdHQ1JklBRUSHsVBaGkcrUKNNxaB6Rfl24cAEnTpzA8ePHcfz4cZw4cQIHDhwAAPTu3dura4WHh+NnP/sZNmzYgCtXrqBnz54dvi4gIABA8zwkURhGKlO6o66iooJD84g0SpIk1NTUtAmblsBp+fXZs2fdvv/ChQtef83BgwejqakJDQ0N6NevX4evaWxsBAChFRSGkQDR0dGoqqpyddQFBQXJdu358+dzaB6RIJcvX8bp06fbBUzr3/sSKC0cDgdGjRrl1Xu+/PJLXH/99Z2OkSgtLYXFYnGNLxeBYSRAVFQUtm3bBqD5D8HYsWNluS6H5hEpq6MSWutfnzx5EleuXPHp2j169MDNN9+MIUOGIDQ0FEOGDHH9FxoaismTJ2P//v146qmnOnx/Rz/YfvbZZ9i4cSMSEhLQo4f7frXi4mJERkYKnXvEMBLg2o46OcKIQ/OIuqe7JbSuBAQEtAmZa399880347rrrnP7/p/+9KcoKChAdnZ2h+3dU6ZMQUBAAEaPHo3g4GA4HA68+eab6N27N/73f//X7XWdTicKCwsxZcoUn783OTCMBFCio45D84g6p3QJbeDAgR3e0bT8OjAwEBaLxefrz5w5E6+//jrWr1+PpKSkdp9/9NFHkZ+fj2XLlqG2thZBQUH4+c9/jhdffLHT8lvLnKNZs2b5vDY58Gw6AeQ+o45D84jEltBCQ0NVqUR0djadL3g2ncnJ3VH3q1/9yrVZ7emnn2YQkeFovYSmlpycHMTExGD+/PnIy8vr1rUkSUJ6ejpqamqQk5Mj0wp9xzASRK6OOg7NIyPQewlNLWFhYcjOzsb06dMxZMiQdmMkPCVJEjIzM2G322G32zUxgpxhJIgcHXUcmkd6YYYSmlpSUlLw7bffIiMjA8ePH8eyZcu8KtnV1tYiPT0ddrsdWVlZSE5OVnC1nmMYCSJHRx2H5pEWsISmvueffx7/9m//hrlz5+Lvf/87li5disTExE4PUW3pmluwYAFqampgt9s1E0QAGxiE+fTTT12zhVJTU/HGG2949X4OzSO1sISmXZWVlUhNTUVRURGCg4Nhs9kQGxuL6OhoBAQEoLGxEaWlpSguLnZ1zcXHxyMnJ0cTpbnWGEaCdLej7r//+79dAZaUlIT8/Hy5l0gmwRKa/jkcDuTm5mLr1q0oKytD63/WLRYLIiMjMWHCBMyaNUvoAL3OMIwECgkJQVVVFYKCglBdXe3x+z777DP8+Mc/xtWrV2G1WlFeXs5ZRdQhltDMp76+HhUVFXA6nfD390d4eLguAp/PjATypaOOQ/OoNbVLaNfe3bCEpj19+vTR5fYOhpFAvnTUcWieuYgoobX8miU0UhPDSCBvO+o4NM9YWEIj+gHDSCBvz6jj0Dx9YQmNyHNsYBDIm466iooKREdHo6mpCX5+fjh8+DBnFQnGEhqRfHhnJJA3Z9RxaJ66WEIjUhfvjASbMGGCq4lh27ZtsFqt7doxN2/ejP/4j/8A0Dw0r7y8nD8VdxNLaETawjsjgRwOB86cOYPrrrsOly5dwvjx412fs1gsiIiIwAMPPIBNmza5Ps6heZ5hCY1IX3hnJEDrIzyCgoKQmJiIkSNHIioqCr1798aFCxfgcDiwf/9+/OUvf8HZs2fRo0cP/PjHP8a+fftM/xN1RyW0a+9uWEIj0heGkcrsdjvmzp2LwMBALFmypMvDDZuamrB+/Xo899xz+P7777F8+XKkpKSouGL1uSuhtfz6xIkTaGho8Pn6LKERaQ/DSEVZWVnIyMhASkqK18e+19XVYf78+bDb7cjMzMTzzz+v4EqVxRIaEV2Lz4xUYrfbkZGRgcWLF/s0EKtv377Iy8tDaGgoMjIyMGjQIE0d/95C6RLa9ddf7/aOhiU0Iv3inZEKKisrERMTg6lTp7YbFVxfX49XXnkFe/fuxb59+/Ddd9/hj3/8I/7zP/+zw2tJkoQZM2Zg3bp1KCkpUf0YeJbQiEgJDCMVJCQk4MiRIygpKWlXmvvqq68QFhaG0NBQDB06FNu3b+80jIDmSY0xMTGIiorC5s2bZV0rS2hEJALLdApzOBwoKipCfn5+h8+IQkJC8M0332DQoEEoLi7GyJEju7xmv379sHTpUjz++OM4cuSIx/NJWEIjIq1iGCksNzcXwcHBSExM7PDz/v7+GDRokNfXtdlsmDdvHlatWoUVK1YAUL6ENmDAALfTOFlCI6LuYBgpbMuWLbDZbJ22b/vC398fNpsN+fn5OHTokGwlNHfjn1lCIyIlMYwUVFdXh/Lycvzyl79U5PqxsbFYtWoVPvnkky5fyxIaEWkZw0hBx44dgyRJiIqKUuT6rUdQsIRGRHrGMFKQ0+kEAPTu3VuR6wcEBAAA/vGPf2DcuHGKfA0iIjX0EL0AI2uZwtqd058709jYCAC48cYbFbk+EZFaGEYKCg8Ph8Vi6XJWka9KS0thsVgQHh6uyPWJiNTCMFJQnz59EBERgf379yty/eLiYkRGRrLLjYh0j8+MFDZx4kQUFBQgOzvbbXv3ypUr8f333+P06dMAgA8++AAnT54EAKSlpaF///7t3uN0OlFYWIgpU6Yot3giIpXwOCCFORwOREdHIz8/H0lJSR2+5tZbb8Xx48c7/FxlZSVuvfXWdh9fu3YtHn/8cTgcDo9PYCAi0iqGkQo6O5vOF0qeTUdEJAKfGakgJycHZ8+exfz587t9LUmSkJ6ejpqaGuTk5MiwOiIi8RhGKggLC0N2drZrMJ6vJElCZmYm7HY7li9frvr4CCIipbCBQSUpKSn49ttvkZGRgePHj3s96bW2thbp6emw2+3IysrS5GA9IiJf8ZmRyux2O+bOnYuBAwdi6dKlSExM7PQQ1ZauuQULFqCmpgbLly9nEBGR4TCMBKisrERqaiqKiooQHBwMm82G2NhYREdHIyAgAI2NjSgtLUVxcTEKCwtRXV2N+Ph45OTksDRHRIbEMBLI4XAgNzcXW7duRVlZGVr/X2GxWBAZGYkJEyZg1qxZbN8mIkNjGGlEfX09Kioq4HQ64e/vj/DwcJ6sQESmwTAiIiLh2NpNRETCMYyIiEg4hhEREQnHMCIiIuEYRkREJBzDiIiIhGMYERGRcAwjIiISjmFERETCMYyIiEg4hhEREQnHMCIiIuEYRkREJBzDiIiIhGMYERGRcAwjIiISjmFERETCMYyIiEg4hhEREQnHMCIiIuEYRkREJBzDiIiIhGMYERGRcAwjIiISjmFERETCMYyIiEg4hhEREQnHMCIiIuEYRkREJBzDiIiIhPt/vapbqL5jsn8AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of the graph.\n", - "\n", - "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. The entry `incidence_matrix[i, j]` is `-1` if node `i` is the source of edge `j`, `1` if node `i` is the target of edge `j`, and `0` otherwise. \n", - "\n", - "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations.\n", - "\n", - "This space essentially contains the Edge-Laplacian matrix, which is the Laplacian matrix of the edge space of the graph. In the general case, it is the Hodge-Laplacian matrix of the edge space of a simplicial 2-complex.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "YJXKhf4y-tgV" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "incidence matrix:\n", - " tensor([[-1., -1., -1., 0., 0., 0.],\n", - " [ 1., 0., 0., -1., 0., 0.],\n", - " [ 0., 1., 0., 1., -1., 0.],\n", - " [ 0., 0., 1., 0., 0., -1.],\n", - " [ 0., 0., 0., 0., 1., 1.]], dtype=torch.float64)\n", - "\n", - "\n", - "edge Laplacian:\n", - " tensor([[ 2., 1., 1., -1., 0., 0.],\n", - " [ 1., 2., 1., 1., -1., 0.],\n", - " [ 1., 1., 2., 0., 0., -1.],\n", - " [-1., 1., 0., 2., -1., 0.],\n", - " [ 0., -1., 0., -1., 2., 1.],\n", - " [ 0., 0., -1., 0., 1., 2.]], dtype=torch.float64)\n" - ] - } - ], - "source": [ - "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", - "incidence_matrix = torch.tensor(incidence_matrix)\n", - "edge_graph = GraphEdge(incidence_matrix)\n", - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('incidence matrix:\\n', incidence_matrix)\n", - "print('\\n')\n", - "print('edge Laplacian:\\n', edge_graph.edge_laplacian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `edge_graph` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "kernel = MaternGeometricKernel(edge_graph)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "params[\"lengthscale\"] = torch.tensor([2.0])\n", - "params_32 = params.copy()\n", - "params_inf = params.copy()\n", - "del params\n", - "params_32[\"nu\"] = torch.tensor([3/2])\n", - "params_inf[\"nu\"] = torch.tensor([torch.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on our graph.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[4],\n", - " [2],\n", - " [1]], dtype=torch.int32)\n" - ] - } - ], - "source": [ - "key = torch.Generator()\n", - "key.manual_seed(124)\n", - "\n", - "key, xs = edge_graph.random(key, 3)\n", - "\n", - "print(xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = min([torch.min(kernel_mat_32), torch.min(kernel_mat_inf)])\n", - "maxmax = max([torch.max(kernel_mat_32), torch.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = 1 # choosing a fixed edge for kernel visualization\n", - "other_edges = torch.arange(edge_graph.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "values_32 = kernel.K(params_32, torch.tensor([[base_edge]]),\n", - " other_edges).flatten()\n", - "values_inf = kernel.K(params_inf, torch.tensor([[base_edge]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "variance_32 = kernel.K_diag(params_32, other_edges)\n", - "variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([0.1752, 0.2034, 0.1516, 0.1752, 0.1516, 0.1430], dtype=torch.float64)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "variance_32" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.18,\n", - "Variance in the edge (1,3) is 0.20,\n", - "The average variance is 0.17.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % torch.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = torch.Size([3, 1])):\n", - "tensor([[4],\n", - " [2],\n", - " [1]], dtype=torch.int32)\n", - "\n", - "emedding (shape = torch.Size([3, 6])):\n", - "tensor([[-1.8151e-01, 2.8001e-01, 1.7556e-01, 3.2562e-02, 6.3360e-02,\n", - " 6.6133e-02],\n", - " [ 1.8151e-01, -2.8001e-01, 1.7556e-01, -3.2562e-02, 6.3360e-02,\n", - " -6.6133e-02],\n", - " [ 1.8856e-01, 3.8734e-01, -7.2911e-17, 1.0537e-01, 7.5690e-17,\n", - " -8.1745e-02]])\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(4.9422e-08)\n" - ] - } - ], - "source": [ - "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", - "\n", - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - "\n", - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_32_alt = torch.matmul(embedding, embedding.T)\n", - "\n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', torch.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "tensor([[-0.4017, 0.2195],\n", - " [ 0.1529, 0.2334],\n", - " [-0.3671, 0.2540]])\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = torch.Generator()\n", - "key.manual_seed(1234)\n", - "\n", - "# new random state is returned along with the samples\n", - "key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = torch.Generator()\n", - "key.manual_seed(1234)\n", - "key, samples = sample_paths(other_edges, params_32, key=key)\n", - "\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb b/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb deleted file mode 100644 index ba3a5ab2..00000000 --- a/notebooks/backends/PyTorch_EdgeSpaceSimplicialComplex.ipynb +++ /dev/null @@ -1,1075 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", - "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **numpy** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): Torch backend enabled.\n" - ] - } - ], - "source": [ - "# Import a backend, we use jax in this example.\n", - "import torch\n", - "import numpy as np\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "import geometric_kernels.torch\n", - "# from geometric_kernels import jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the triangle set " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "triangles = [(1,2,3)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "# shade the area of the triangle\n", - "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the sets of nodes, edges and triangles. \n", - "\n", - "**Note that**: \n", - "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", - "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], - "source": [ - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('triangles:', triangles)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", - "\n", - "The `incidence_matrix` parameter is a `numpy` array of shape `(n_nodes, n_edges)` where `n_nodes` is the number of nodes in the graph and `n_edges` is the number of edges in the graph. \n", - "\n", - "The entry `incidence_matrix[i, e]` is \n", - "- `-1` if node `i` is the source of edge `e`, \n", - "- `1` if node `i` is the target of edge `e`, and \n", - "- `0` otherwise. \n", - "\n", - "The `edge_triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph.\n", - "\n", - "The entry `edge_triangle_incidence_matrix[e, t]` is\n", - "- `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$,\n", - "- `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and\n", - "- `0` otherwise.\n", - "\n", - "Note that: here we essentially consider the oriented incidence matrix, where the orientation of each edge can be user-defined. This will not affect the compuations." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def triangles_to_B2(striangles: list, edges: list) -> np.ndarray:\n", - " \"\"\"\n", - " Create the B2 matrix (edge-triangle) from the triangles.\n", - "\n", - " Args:\n", - " triangles (list): List of triangles.\n", - " edges (list): List of edges.\n", - "\n", - " Returns:\n", - " np.ndarray: B2 matrix.\n", - " \"\"\"\n", - " B2 = np.zeros((len(edges), len(triangles)))\n", - " for j, triangle in enumerate(triangles):\n", - " a, b, c = triangle\n", - " try:\n", - " index_a = edges.index((a, b))\n", - " except ValueError:\n", - " index_a = edges.index((b, a))\n", - " try:\n", - " index_b = edges.index((b, c))\n", - " except ValueError:\n", - " index_b = edges.index((c, b))\n", - " try:\n", - " index_c = edges.index((a, c))\n", - " except ValueError:\n", - " index_c = edges.index((c, a))\n", - "\n", - " B2[index_a, j] = 1\n", - " B2[index_c, j] = -1\n", - " B2[index_b, j] = 1\n", - "\n", - " return B2" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "YJXKhf4y-tgV" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "incidence matrix:\n", - " tensor([[-1., -1., -1., 0., 0., 0.],\n", - " [ 1., 0., 0., -1., 0., 0.],\n", - " [ 0., 1., 0., 1., -1., 0.],\n", - " [ 0., 0., 1., 0., 0., -1.],\n", - " [ 0., 0., 0., 0., 1., 1.]])\n", - "\n", - "\n", - "edge triangle incidence matrix:\n", - " tensor([[ 1.],\n", - " [-1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])\n" - ] - } - ], - "source": [ - "incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray()\n", - "incidence_matrix = torch.tensor(incidence_matrix, dtype=torch.float32)\n", - "edge_triangle_incidence_matrix = triangles_to_B2(triangles, list(G.edges))\n", - "edge_triangle_incidence_matrix = torch.tensor(edge_triangle_incidence_matrix, dtype=torch.float32)\n", - "print('incidence matrix:\\n', incidence_matrix)\n", - "print('\\n')\n", - "print('edge triangle incidence matrix:\\n', edge_triangle_incidence_matrix)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the Simplicial 2-Complex " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hodge Laplacian:\n", - " tensor([[ 3., 0., 1., 0., 0., 0.],\n", - " [ 0., 3., 1., 0., -1., 0.],\n", - " [ 1., 1., 2., 0., 0., -1.],\n", - " [ 0., 0., 0., 3., -1., 0.],\n", - " [ 0., -1., 0., -1., 2., 1.],\n", - " [ 0., 0., -1., 0., 1., 2.]])\n", - "\n", - "\n", - "Down Hodge Laplacian:\n", - " tensor([[ 2., 1., 1., -1., 0., 0.],\n", - " [ 1., 2., 1., 1., -1., 0.],\n", - " [ 1., 1., 2., 0., 0., -1.],\n", - " [-1., 1., 0., 2., -1., 0.],\n", - " [ 0., -1., 0., -1., 2., 1.],\n", - " [ 0., 0., -1., 0., 1., 2.]])\n", - "\n", - "\n", - "Up Hodge Laplacian:\n", - " tensor([[ 1., -1., 0., 1., 0., 0.],\n", - " [-1., 1., -0., -1., -0., -0.],\n", - " [ 0., -0., 0., 0., 0., 0.],\n", - " [ 1., -1., 0., 1., 0., 0.],\n", - " [ 0., -0., 0., 0., 0., 0.],\n", - " [ 0., -0., 0., 0., 0., 0.]])\n" - ] - } - ], - "source": [ - "sc = GraphEdge(incidence_matrix, edge_triangle_incidence_matrix)\n", - "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", - "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", - "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "kernel = MaternGeometricKernel(sc)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "params[\"lengthscale\"] = torch.tensor([2.0])\n", - "params_32 = params.copy()\n", - "params_inf = params.copy()\n", - "del params\n", - "params_32[\"nu\"] = torch.tensor([3/2])\n", - "params_inf[\"nu\"] = torch.tensor([torch.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on our graph.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[3],\n", - " [3],\n", - " [0]], dtype=torch.int32)\n" - ] - } - ], - "source": [ - "key = torch.Generator()\n", - "key.manual_seed(1234)\n", - "\n", - "key, xs = sc.random(key, 3)\n", - "\n", - "print(xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = min([torch.min(kernel_mat_32), torch.min(kernel_mat_inf)])\n", - "maxmax = max([torch.max(kernel_mat_32), torch.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = 1 # choosing a fixed edge for kernel visualization\n", - "other_edges = torch.arange(sc.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "values_32 = kernel.K(params_32, torch.tensor([[base_edge]]),\n", - " other_edges).flatten()\n", - "values_inf = kernel.K(params_inf, torch.tensor([[base_edge]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "variance_32 = kernel.K_diag(params_32, other_edges)\n", - "variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/UAAAMPCAYAAACUsvWGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wU5dbA8d9sTd0lkEJoIYAECAGpActVryhgRQFpiiJFQVTAhkjxUhQUERUVpSheQVEQy1Wx8IINQYpI7wFCSUKA9GTrvH+kSCRAstlks7vnez/zuWF2ypm42T3PzPOcR1FVVUUIIYQQQgghhBBeR+PpAIQQQgghhBBCCOEaadQLIYQQQgghhBBeShr1QgghhBBCCCGEl5JGvRBCCCGEEEII4aWkUS+EEEIIIYQQQngpadQLIYQQQgghhBBeShr1QgghhBBCCCGEl5JGvRBCCCGEEEII4aWkUS+EEEIIIYQQQngpadQLIYQQQgghhBBeShr1QgghhBBCCCGEl5JGvRu8//77KIrCkSNHPB1KlcjJyUGj0fDqq696OpTLeumll2jRogVOp7Nazzt//nwaNWqExWIp9z6bNm3iqquuIjg4GEVR2LZtW9UFWE418b38/PPPoyiKp8MQQgi/447vBG/JITyVP5TFV3IKqHl5heQUwlf5XKP+jjvuICgoiOzs7ItuM2jQIAwGA2fOnKnGyLzXzp07UVWV1q1bezqUS8rKymLWrFk888wzaDTV+9Z+4IEHsFqtvPPOO+Xa3maz0bdvX86ePcurr77Kf//7X2JiYqo4SiGEENWpuEGzefPmUuszMzPp3LkzAQEBrF692kPRVQ9vyCHKyh9ycnKYMmUKPXr0oHbt2iiKwvvvv18t8UhOIYSoKJ9r1A8aNIj8/HxWrVpV5ut5eXl88cUX9OjRgzp16rjlnPfddx/5+fk++wG6Y8cOABISEjwcyaUtXrwYu93OgAEDqv3cAQEB3H///cyZMwdVVS+7/aFDhzh69ChPPvkkI0aM4N577yUsLKwaIr00X38vCyGEp2VlZXHzzTezfft2Vq1aRY8ePTwdUpXyhhyirPwhPT2dqVOnsmfPHtq2bVut8fhKTgGSVwhRXXyuUX/HHXcQGhrKsmXLynz9iy++IDc3l0GDBlX6XLm5uQBotVoCAgJ8tjvPjh07CA8Pp27dup4O5ZLee+897rjjDgICAjxy/nvuuYejR4+ydu3ay26blpYGQK1atdx2/uL3Y2X4+ntZCCE8KTs7m+7du7Nt2zZWrlxJz5493XJcd3z+VxVvyCHKyh+io6M5deoUR48e5eWXX672mHwhpwDJK4SoLj7XqA8MDOTuu+9mzZo1JR9y51u2bBmhoaHccccdABw9epRRo0YRFxdHYGAgderUoW/fvheM/Skeg7N7924GDhxIWFgY11xzDVD2eKGKHvfgwYM88MAD1KpVC7PZzJAhQ8jLyyu17YkTJxg6dCj16tXDaDQSGxvLyJEjsVqtpbZ58MEHiYqKwmg0Eh8fz+LFi8v8Xe3du5djx45d9ne6Y8cO4uPjS61bsGABBoOBMWPG4HA4LnuMqpaUlMT27dvp1q2bx2Lo0KEDtWvX5osvvrjkdg888ADXXXcdAH379kVRFK6//noA/vzzT3r27InJZCIkJIQbb7yRDRs2XHCMS70fK6Os93JF3qMXU9735a+//kqnTp0ICAigadOmF+16uG7dOjp27Fhqu4uNkyvPubOzsxkzZgyNGzfGaDQSGRnJTTfdxNatW8t1fUIIcTk5OTn06NGDrVu3snLlSm699dZSr5f3c/Jin/8V/ayuSL7wT+XNH6Dm5xAXyx+MRqNHb0S4I6eA8uUVVZVTwIV5RU3MKUDyCuH9dJ4OoCoMGjSIJUuW8MknnzB69OiS9WfPnuW7775jwIABBAYGAoWFRdavX0///v1p0KABR44c4e233+b6669n9+7dBAUFlTp23759ueKKK3jhhRcu2SWqose95557iI2N5cUXX2Tr1q0sXLiQyMhIZs2aBcDJkyfp3LkzGRkZjBgxghYtWnDixAlWrFhBXl4eBoOB1NRUunTpgqIojB49moiICL799luGDh1KVlYWY8aMKXXOli1bct1117Fu3bpL/j537NhR0iXNbrczZswY3n33Xd58802GDx9+yX2ry/r16wFo3769R+No3749v/322yW3eeihh6hfvz4vvPACjz32GJ06dSIqKopdu3Zx7bXXYjKZePrpp9Hr9bzzzjtcf/31/PTTTyQmJl5wrPK+H93hcu/Riynv+3LHjh3cfPPNRERE8Pzzz2O325kyZQpRUVGljvfnn3/So0cPoqOj+c9//oPD4WDq1KlERES4fO6HH36YFStWMHr0aFq1asWZM2f49ddf2bNnj8ffU0II75ebm0vPnj3ZtGkTK1as4Lbbbiv1ekW/v+HCz//iBxnl+ax25XznK2/+ADU/h6gp+UNZKpNTABXOK/wxpwDJK4SPUH2Q3W5Xo6Oj1a5du5ZaP3/+fBVQv/vuu5J1eXl5F+z/+++/q4D6wQcflKybMmWKCqgDBgy4YPv33ntPBdSkpCSXj/vggw+W2vauu+5S69SpU/LvwYMHqxqNRt20adMFx3U6naqqqurQoUPV6OhoNT09vdTr/fv3V81m8wUxAep11113wfHOd/LkSRVQ58+fr545c0b997//rdauXVtdu3btJferbhMnTlQBNTs726NxjBgxQg0MDLzsdmvXrlUB9dNPPy1Z16tXL9VgMKiHDh0qWXfy5Ek1NDRU/de//lVq/0u9HyujrPdyed+jF1Pe92WvXr3UgIAA9ejRoyXb7N69W9Vqter5H1W33367GhQUpJ44caJk3YEDB1SdTqf+8yOtvOc2m83qI488ctlrEUKIiij+TI2JiVH1er36+eefl7ldRb6/L/b5X5HP6vKer6zvBFUtX/6gqt6RQ5Qnf9i0aZMKqO+99171BaZWLqdQ1fLnFVWVU6jqhe+hmpZTqKrkFcI3+Fz3eygcv9O/f39+//33Ut2Ily1bRlRUFDfeeGPJuuIn9lBYPfTMmTM0a9aMWrVqldlF5uGHHy5XDJU97rXXXsuZM2fIysrC6XTy+eefc/vtt9OxY8cL9lUUBVVVWblyJbfffjuqqpKenl6ydO/enczMzAvOq6rqZe+yb9++veQcnTp14uTJk2zcuLFU166a4MyZM+h0OkJCQkqt37BhA4qi8Pzzz7t87IocIywsjPz8/HJ3ISvmcDj4/vvv6dWrF02aNClZHx0dzcCBA/n111/Jysq6YL/yvh/d8Xu41Hv0Ysr7vnQ4HHz33Xf06tWLRo0alezfsmVLunfvXvJvh8PBjz/+SK9evahXr17J+mbNml0wNrUifxO1atVi48aNnDx50uXfjxBCXExqaioBAQE0bNjwgtdc+f6Gi3/+X+6z2tXz/TPm8jyl94Yc4mL5Q1Uq73eyqzkFuJZX+FtOAZJXCN/hk416oKQQXnHBvOPHj/PLL7/Qv39/tFptyXb5+flMnjyZhg0bYjQaCQ8PJyIigoyMDDIzMy84bmxsbLnOX9Hjnv+hA5RULT137hynT58mKyvrktPBnD59moyMDN59910iIiJKLUOGDAEos8bA5RRXrR09ejRRUVH8/vvvNGvW7ILtRowYQXR0NCaTiYSEBL766qsLttm2bRvt2rXjwQcfpFGjRphMJrp06cLvv/9e4bhqKrWou1pFC8KcPn2avLw84uLiLnitZcuWOJ1OkpOTL3itvO9Hd7jUe/Riyvu+PH36NPn5+VxxxRUXHOP830laWhr5+fllvgf/ua4ifxMvvfQSO3fupGHDhnTu3Jnnn3+ew4cPl+fXIoQQl/XOO+9gMBjo0aMH+/btK/Waq9/fF/v8v9xndVXlC2UpTw4h+cPFuZpTgGt5hb/lFMXbS14hfIFPjqmHwgIjLVq04KOPPmLChAl89NFHqKp6QdX7Rx99lPfee48xY8bQtWtXzGYziqLQv39/nE7nBcc9/wn8pVT0uOffaDhf8Qf65RQf89577+X+++8vc5s2bdqU61jn27FjBzExMTRt2pSdO3eSk5NTZnXVcePG8cYbb2A0Gtm0aRPdunXj8OHDpaYNXL16Nd26dSM0NJRff/2VBg0a8Mknn3D77bdz5MiRSt0lr1OnDna7nezsbEJDQ0vWt2/fnuTkZEwmk8vHrsgxzp07R1BQULnfJ5VV3vO44/fgynu0vO/Lsv4mKqsifxP33HMP1157LatWreL777/n5ZdfZtasWXz22Wduq04thPBfrVq14ptvvuHGG2/kpptu4rfffit5au/q9/fFPv8v91ldVflCWcqTQ9TU/KEqlfc7WXKK0jyZU1Tk/CB5hah+Ptuoh8Kn9ZMmTWL79u0sW7aMK664gk6dOpXaZsWKFdx///288sorJesKCgrIyMio1LndedyIiAhMJhM7d+685DahoaE4HA63VoDfsWMHV155JQsWLKBjx47cdddd/PLLLxdMG9eiRYuSnxVFwWq1cuLEiQu+lGfOnEmXLl1K1vXv359x48axb98+OnTocNE4Fi1axJdffskXX3zB3r176du3Ly+//HLJ/L7F509KSiqVjBgMBho0aFCp30FFjpGUlETLli0rfI6IiAiCgoIueIIDhVWGNRpNmd02y8sdvwdXlPd96XA4CAwM5MCBAxe8dv7vJDIykoCAAA4ePHjBdv9cV9G/iejoaEaNGsWoUaNIS0ujffv2zJgxQ758hRBu0blzZz7//HNuvfVWbrrpJn755ZeSp3xV8f19MdV5vvLkEFWdP8Clc4iL5Q9Vqbzfya7mFFC1eYWv5BQgeYXwHT7b/R7+7oI/efJktm3bVubc9Fqt9oK7gm+88Ualp1hx53E1Gg29evXiq6++YvPmzRe8rqoqWq2W3r17s3LlyjIb/6dPn75g3eWmpHE4HOzZs4eEhAQiIiL47LPP2LlzJyNHjixz+1GjRhEYGEinTp3497//TUJCQslr2dnZ7Nu3j86dO5fa58CBA5w9e7bMbk/n27FjB23atGH9+vX07t2b999/v6RBD9C1a1eAMn8/1Wnr1q1cddVVFd5Pq9Vy880388UXX5SqA5GamsqyZcu45pprKnVH3FPK+77UarV0796dzz//vNR7cs+ePXz33XeljtetWzc+//zzUuPUDh48yLfffuvSuR0OxwVDYiIjI6lXrx4Wi8WFqxZCiLLdeOONfPTRRxw8eJAePXqQlZXl0vd3ZbjjfOWZ0q4iOURV5g9w6RyipuQPZXE1pwDfzCvcnVMUbyt5hfAFPv2kPjY2lquuuqpkjs+yGvW33XYb//3vfzGbzbRq1Yrff/+dH3/8sdQdYle4+7gvvPAC33//Pddddx0jRoygZcuWnDp1ik8//ZRff/2VWrVqMXPmTNauXUtiYiLDhw+nVatWnD17lq1bt/Ljjz9y9uzZUse83JQ0Bw4coKCgoOTLtUOHDrz99tsMGTKEDh06lJouEOCtt97ijTfeYN26dezcubPUGLA1a9Zw3XXXodH8fR8pPz+fe++9l2effRaz2XzJ69+xYwd169blzjvvZOPGjaWKvgA0adKE1q1b8+OPP/Lggw9e9vcJhU8EyjslT3ls2bKFs2fPcuedd7q0//Tp0/nhhx+45pprGDVqFDqdjnfeeQeLxcJLL73klhg9obzvy//85z+sXr2aa6+9llGjRmG323njjTeIj48vKbYEhXPcfv/991x99dWMHDkSh8PBvHnzaN26Ndu2bavwubOzs2nQoAF9+vShbdu2hISE8OOPP7Jp06ZSPW2EEMId7rrrLhYsWMCDDz7IHXfcUfIUuiLf35VV2fOVZ0q7iuQQVZk/wKVziEvlD/PmzSMjI6OksffVV19x/PhxoHCY5fnnrmk5BfhmXuHunAIkrxA+orrK7HvKm2++qQJq586dy3z93Llz6pAhQ9Tw8HA1JCRE7d69u7p37141JiZGvf/++0u2K56C4/Tp0xcco6wpXyp73LKOefToUXXw4MFqRESEajQa1SZNmqiPPPKIarFYSrZJTU1VH3nkEbVhw4aqXq9X69atq954443qu+++e0HcXGZKmk8++UQF1F27dpVaP2rUKFWv16s//fTTRfe97bbb1K+//rrk3w899FCpqWCsVqt66623qgMHDiyZku9SIiIi1GuvvVY1m80XPe+cOXPUkJCQMqcT/Kfs7GwVUPv373/ZbcvrmWeeURs1alSu67nY9DNbt25Vu3fvroaEhKhBQUHqDTfcoK5fv/6C/S/1fqyMS01pV5736MWU9335008/qR06dFANBoPapEkTdf78+SXnP9+aNWvUdu3aqQaDQW3atKm6cOFC9YknnlADAgIqfG6LxaI+9dRTatu2bdXQ0FA1ODhYbdu2rfrWW2+V87cmhBBlK/6cLGs62tmzZ6uAetttt6k2m63cn5MX+0yu6Gd1ec5XmSntXM0h3J0/qOrlc4iL5Q8xMTEqUOZy/u+kpuYUqlq+vKKqcgpVvfiUdjUpp1BVySuE9/P5Rr3wjB49eqivvfZayb9jY2PVkydPqqqqqg6HQ+3Xr19JInM5KSkpakBAgFpQUKBOmDBB7datW5nbZWRkqLVr11YXLlx42WN+/fXXqqIo6vbt28t5RZdWUFCg1q1bV507d65bjicq7s4771SbNWvm6TCEEEJUgjvzB1UtXw5RkfyhLJJT+CbJK4Q38ekx9aJ6ZGZmsmzZMnJycrDb7Xz66aesXbuWf/3rX0Dh2DuTyUR0dDQADz30UMnQAZ2u9AiQBx54gAceeKDUuh07dtCyZUuMRiNjxoxh/fr1bNiw4YI4zGYzTz/9NC+//PJlK5+uXbuW/v37lxq3Vxnvvfceer2+3HO8isrJz88v9e8DBw7wzTff1Ki5j4UQQlyaO/MHcD2HqEj+UBbJKbyf5BXC2ymqWs4504S4iKysLO68807+/PNPVFWlWbNmPPfcc9x9990AzJ07l5SUFGbOnMnRo0dp3LgxAQEBpaYz+fbbb7n22mvp1q0b/fr1Y/jw4SWvvfrqq/z555988MEHADz++OMcPHiQr7/+unovVNQY0dHRPPDAAzRp0oSjR4/y9ttvY7FY+PPPP8ucl1YIIUTN4878AZAcQrhM8grh7aRRL6pcjx49GD9+/GXvdtrtdtq0acNff/2FXq+vnuCEVxoyZAhr164lJSUFo9FI165deeGFF2jfvr2nQxNCCOEm5c0fQHIIUTmSVwhvJ416UeVeeuklxo4dK1+yQgghhCg3yR+EEKJ8pFEvhBBCCCGEEEJ4KSmUJ4QQQgghhBBCeClp1AshhLiogoICsrKyKrUUFBRU+LxvvvlmSVGsxMRE/vjjj4tuu2DBAq699lrCwsIICwujW7dul9z+4YcfRlEU5s6dW+G4hBBCCFE1PJVz+IIL5wMRQgghKPxyjY0JISXNUanj1K1bl6SkJAICAsq1/fLlyxk3bhzz588nMTGRuXPn0r17d/bt20dkZOQF269bt44BAwZw1VVXERAQwKxZs7j55pvZtWsX9evXL7XtqlWr2LBhA/Xq1avUNQkhhBDCfTyVc/gKGVMvhBCiTFlZWZjNZpK2xGAKda1jV1a2k9gOR8nMzMRkMpVrn8TERDp16sS8efMAcDqdNGzYkEcffZTx48dfdn+Hw0FYWBjz5s1j8ODBJetPnDhBYmIi3333HbfeeitjxoxhzJgxLl2XEEIIIdzHUzmHr5An9UIIIS4pOKRwcYWj6LZxVlZWqfVGoxGj0XjB9larlS1btvDss8+WrNNoNHTr1o3ff/+9XOfMy8vDZrNRu3btknVOp5P77ruPp556ivj4eBeuRAghhBBVzR05hz+SMfVCCCGqXMOGDTGbzSXLiy++WOZ26enpOBwOoqKiSq2PiooiJSWlXOd65plnqFevHt26dStZN2vWLHQ6HY899pjrFyGEEEIIUQPJk3ohhBCX5ETFiWu3v4v3S05OLtUVrqyn9O4wc+ZMPv74Y9atW1cynm7Lli289tprbN26FUVRquS8QgghhKg8d+Qc/kie1AshhLgkZyX/B2AymUotF2vUh4eHo9VqSU1NLbU+NTWVunXrXjLO2bNnM3PmTL7//nvatGlTsv6XX34hLS2NRo0aodPp0Ol0HD16lCeeeILGjRtX7pcjhBBCCLdxR87hj6RRL4QQ4pIcqlqppSIMBgMdOnRgzZo1JeucTidr1qyha9euF93vpZdeYtq0aaxevZqOHTuWeu2+++5j+/btbNu2rWSpV68eTz31FN99913FfhlCCCGEqDLVmXP4Eul+L4QQokYZN24c999/Px07dqRz587MnTuX3NxchgwZAsDgwYOpX79+ybj8WbNmMXnyZJYtW0bjxo1Lxt6HhIQQEhJCnTp1qFOnTqlz6PV66tatS1xcXPVenBBCCCGEm0mjXgghxCVV9/i2fv36cfr0aSZPnkxKSgpXXnklq1evLimed+zYMTSavzuavf3221itVvr06VPqOFOmTOH55593KW4hhBBCVD8ZU+8amadeCCFEmUrmjN0bTaiLc8ZmZzuJbXHKL+eMFUIIIUT5SM5ROfKkXgghxCXJXXMhhBBCVAfJOVwjhfKEEEIIIYQQQggvJU/qhRBCXFJlKsr6cyVaIYQQQlSM5ByukUa9EEKIS3IWLa7uK4QQQghRHpJzuEYa9UIIIS7JgYrDxXFqru4nhBBCCP8jOYdrZEy9EEIIIYQQQgjhpWr0k/qcnBwOHjyIxWLBaDTSrFkzQkJCPB2WEEL4FYdauLi6rxDeQHIOIYTwPMk5XFPjGvW7d+9m/vz5/PDDD+zbtw/1vIIHiqIQFxfHTTfdxMMPP0yrVq08GKkQQvgHGd8mfJXkHEIIUbNIzuGaGtP9PikpiZ49exIfH8/y5cu54YYbWLRoERs2bGD79u1s2LCBRYsWccMNN7B8+XLi4+Pp2bMnSUlJng5dCCF8mhMFh4uLE8XT4QtxAck5hBCiZpKcwzWKqnq+9v/ChQsZM2YM4eHhvPDCC/Tp0weDwXDR7a1WKytWrODZZ5/lzJkzzJ07l2HDhlVjxEII4fuysrIwm81s3hVFSKhr94Bzsp10jE8lMzMTk8nk5giFqDjJOYQQouaRnKNyPP6kfsaMGQwfPpwBAwawY8cOBg4ceMkvVwCDwcDAgQPZuXMnAwYMYPjw4cyYMaOaIhZCCCGEN5KcQwghhC/y6Jj6hQsXMnHiRKZNm8bEiRMrvH9oaCgLFiygUaNGTJw4kbp16zJ06NAqiFQIIfxXcbc2V/cVoiaQnEMIIWo+yTlc47En9UlJSYwZM4Zhw4Zd8OW6adMmRo8eTXx8PMHBwTRq1Ih77rmH/fv3l3msiRMnMmzYMB5//HEZ7yaEEG7m6ti2ynwxC+FOknMIIYR3kJzDNR4bU9+zZ0/27NnDjh07CA0NLfVanz59+O233+jbty9t2rQhJSWFefPmkZOTw4YNG2jduvUFx8vKyiIhIYFWrVrx7bffVtdlCCGEzyoe3/brznqVGt92TeuTfjm+TdQcknMIIUTNJjlH5XikUb97927i4+NZunQpAwcOvOD19evX07Fjx1Lj3A4cOEBCQgJ9+vThww8/LPO4y5YtY9CgQezevZuWLVtWWfxCCOEP5AtW+ALJOYQQouaTnKNyPNL9fv78+URGRtKnT58yX7/qqqsuKFxzxRVXEB8fz549ey563N69exMZGcnbb7/t1niFEMKfSVc44c0k5xBCCO8hOYdrPNKo/+GHH+jdu/dlK86eT1VVUlNTCQ8Pv+g2RqOR3r178+OPP7ojTCGEEIADTaUWITxJcg4hhPAeknO4ptqvPDs7m3379tGpU6cK7bd06VJOnDhBv379Lrldx44d2bt3Lzk5OZUJUwghRBFVVXC6uKiq/941F54nOYcQQngXyTlcU+2N+kOHDqGqKq1atSr3Pnv37uWRRx6ha9eu3H///ZfcNj4+HlVVOXjwYGVDFUIIIYQXk5xDCCGEP6j2eeotFgsAQUFB5do+JSWFW2+9FbPZzIoVK9BqtZfcPjAwsNR5hBBCVI7MGSu8leQcQgjhXSTncE21N+qNRiMAeXl5l902MzOTnj17kpGRwS+//EK9evUuu09+fn6p8wghhKgch6rBobrWscvhkUlThSgkOYcQQngXyTlcU+3d75s1a4aiKOzevfuS2xUUFHD77bezf/9+/ve//5W769yuXbtQFIVmzZq5I1whhPB7ThScaFxc/PeuufA8yTmEEMK7SM7hmmpv1IeEhBAXF8emTZsuuo3D4aBfv378/vvvfPrpp3Tt2rXcx9+8eTMtWrQgJCTEHeEKIYQQwktJziGEEMIfeKTu/0033cTKlSuxWq1lvv7EE0/w5Zdf0rNnT86ePcuHH35YarkYi8XCypUr6datW1WFLoQQfkfmjBXeTHIOIYTwHp7IOd58800aN25MQEAAiYmJ/PHHHxfddteuXfTu3ZvGjRujKApz586t9DHdodrH1AM8/PDDvPHGG6xYsYKBAwde8Pq2bdsA+Oqrr/jqq68ueP3ee+8t87grV64kLS2NkSNHujVeIYTwZ5Ub3+bHA9xEjSA5hxBCeI/qzjmWL1/OuHHjmD9/PomJicydO5fu3buzb98+IiMjL9g+Ly+PJk2a0LdvX8aOHeuWY7qDoqqeybh69uzJnj172LFjB6GhoZU+XlZWFvHx8cS3imf1d6vdEKEQQvi3rKwszGYzK/9qTnDopauAX0xutoPebfeTmZmJyWRyc4RClE+V5BytW9OyVUu+X/2dGyIUQgj/5qmcIzExkU6dOjFv3jwAnE4nDRs25NFHH2X8+PGX3Ldx48aMGTOGMWPGuO2YrvJI93uAt956i/T0dMaNG1fpY6mqyrhx40g9mUrdM804m3LODREKIYQQwhdURc6RcjoNx6BrSc6VnEMIIWqSrKysUsvFph21Wq1s2bKl1DAqjUZDt27d+P333106d1Ucszw81qiPjY1l7ty5LFy4kOnTp7t8HFVVmT59OosWLaKFsR0n/kzlkU7j2bfpoBujFUII/+VEg8PFxem5rxkhSlRFzlFvcHdOBjros3Yh69MOuzFaIYTwX+7IORo2bIjZbC5ZXnzxxTLPlZ6ejsPhICoqqtT6qKgoUlJSXIq/Ko5ZHh4ZU19s2LBhpKamMnHiRI4ePcqcOXMq1C0uKyuLcePGsWjRIkYOfYTcDSpnTp7jbOo5xv5rMmPmj+Dm+6+vugsQQgg/IGPqhS9wZ87xyFPjSL46huN558gmj6G/LuWZhJu4v1kiiiLFIYUQwlXuyDmSk5NLdb83Go1uia0m8/gjlOeee44FCxbw0Ucf0bp1a5YtW3bRCrXFLBYLy5YtIyEhgY8//pi5c+cybdZ/mLLySZp3aoLBpMeJg5eHvMlbY97DbrNX09UIIYTvcX2+WHlSL2oWd+Uc/3lmAq937kNinRiCbKCzO3lxx/c8s+ULChy2aroaIYTwPe7IOUwmU6nlYo368PBwtFotqamppdanpqZSt25dl+KvimOWR43ItoYNG8aOHTto1aoVgwYNomHDhowaNYrFixezceNGtm/fzsaNG1m8eDGjRo2iUaNGDBo0iCuuuIKff/65pDKtOdzE0++P5ob+V6MP1qEP0rLq9W94tsd0MtOzPHyVQgjhnRyqUqlFiJrEXTlHiMHI8+1vpX9sB4wOCLCpfHH0Lwb+9D6n8jI9fJVCCOGdqjPnMBgMdOjQgTVr1pSsczqdrFmzhq5du7oUf1Ucszw82v3+fLGxsXz77bfs3r2b+fPn8+OPPzJ//nzOL86voFArMIzeg+7mwQcfpHnz5hccR2/Qc/9/+hHTqgEfTluBorOzbd0uRncez/OrnqZp28bVeFVCCCFc8eabb/Lyyy+TkpJC27ZteeONN+jcuXOZ2y5YsIAPPviAnTt3AtChQwdeeOGFku1tNhsTJ07km2++4fDhw5jNZrp168bMmTOpV69etV2TqDnKk3OgKITUj6TP7bcxYuiwMnMOraJhyBVdaWqK4JUda9DYbOw+d5LeaxfyemIfOobHVONVCSGEqKhx48Zx//3307FjRzp37szcuXPJzc1lyJAhAAwePJj69euXjMu3Wq3s3r275OcTJ06wbds2QkJCaNasWbmOWRU8NqVdeeTk5HDw4EEsFguLx3/EwV+PEWQOZNYPk4hqFHHZ/fdvOcybjy0iIy0La7Ydg0HPk4tHcX2/q6sheiGE8G7F08u8/2dbglycXiYv28ED7f6q0PQyy5cvZ/DgwaXmd/30008vOr/roEGDuPrqq7nqqqsICAhg1qxZrFq1il27dlG/fn0yMzPp06cPw4cPp23btpw7d47HH38ch8PB5s2bXbou4XvOzzkWJf3BT7ZThOqMzOnUm/iw6Mvufzg7nf/8+Q2nCrLI14Oi1TKxbQ8GNOlYDdELIYR381TOATBv3rySBwlXXnklr7/+OomJiQBcf/31NG7cmPfffx+AI0eOEBsbe8ExrrvuOtatW1euY1aFGt2oP9/7kz9m6YyVBIQZeHTeUDrc1LZc+51NOce8RxdxePsxbDl2HFYn/Z/pxQPT+6PVuvaGEUIIf1D8Bbt4a7tKfcE+2P7PapszFsDhcBAWFsa8efMYPHhwmdts2rSJzp07c/ToURo1alT+CxJ+YemhTUzd9g2hVni05XXc1jChXPtlWvN5Yft3bDt7nAId2LQK/Rq3Z+KVPTFoJOcQQoiL8VTO4StqxJj68mjSJgZUQIXkfSfLvV/tumGM//Axru7VGX2IDl2Qlo9nfc6kO2aRk5FbdQELIYSPcHVqmeIFqnfO2Ly8PGw2G7Vr177oNpmZmSiKQq1atcr/ixB+I84cCYqCU4Gk7LPl3s9sCGRG+zu4u1FbAuyF4+yXJ21h8M9LOF2QU4URCyGEb3BHzuGPvObKm7QpHJfmtDs5XoFGPYDBaGDYzEEMnHA3hmA9hlAdm1b/yejEZzm653hVhCuEEOI81Tln7DPPPEO9evVK3Rg4X0FBAc888wwDBgzwuzv5onyamwrffw4FDuekV2hfnUbDQy2u5an4bgShJcgG284k0/v/FrD97ImqCFcIIYSf85pGfXTTKIyBBpwOleT9FWvUAyiKws33X88Ti0YSGhGC0azn5OEUHusygfVfbqqCiIUQwjc4cb0arbPoGMnJyWRmZpYszz77bJXEOnPmTD7++GNWrVpFQEDABa/bbDbuueceVFXl7bffrpIYhPczGQKoF2jGqcCR7DO4MlKxW/0WvNLpbqIMIQTZID0vi0E/v8+qo39VQcRCCOEb3JFz+COvadRrtVpi4hui2lXSjqZTkFd2183Lie8ax5SVT9KoVX2MJj0FBRam9HqJD6etwOn057eCEEKUzVvmjJ09ezYzZ87k+++/p02bNhe8XtygP3r0KD/88IM8pReXFGeOxKGBPIeVtIJsF48RxbwufUkwRxNkA9VmZ/yWL5jx13fYnA43RyyEEN7PHTmHP/KqK2+S0AinQ0VVVU4ePOXycSIbhPPcR2PpfGs7DKE6dIFalkxZzrR75pCXne/GiIUQwvs5VE2llopwdX7Xl156iWnTprF69Wo6dryw2nhxg/7AgQP8+OOP1KlTp0JxCf/T3BSJs2jK48PZFeuCf74wYzAzO/bi1gatCbCD0a7ywcENDP1tKWcteW6KVgghfEN15hy+xKuuPLZNDKqjsAtc8l7XG/UAAUFGRs55gL7jbkcfpMMQquPXzzby+FXPcaISNwyEEEJUzrhx41iwYAFLlixhz549jBw58oI5Y8/vvj9r1iwmTZrE4sWLady4MSkpKaSkpJCTU1iYzGaz0adPHzZv3szSpUtxOBwl21itVo9co6j54sxRqIqCCiTllL9YXlkMGi2Ptbqex1tdT5BTQ5AN/khLos/ahezNKF+tCCGEEOJivKpRX1wsT3WoHN9X+WIziqJw60M3MeadEYTUDsZo1nN0z3FGd36Wzd/LmDchhABwolRqqah+/foxe/ZsJk+ezJVXXsm2bdtYvXp1SfG8Y8eOcerU3zdf3377baxWK3369CE6OrpkmT17NgAnTpzgyy+/5Pjx41x55ZWltlm/fr17fknC58SZC99vhRXwXX9Sf75bGrRmVsdehOuDCLLBqZxz9PtpMd8c3+WW4wshhLer7pzDV+g8HUBFxCYUziXsdKgkH3Df0/S218Uz+dNxvDZqIacOpZKXk8dzt8xg2Mx76fPE7SiK/75BhBCiMl3aXN1v9OjRjB49uszX1q1bV+rfR44cueSxGjdu7FKhM+HfGofUQa/R4tDYOZJzxm3HbR1WjzcS72HqX9+wPyuNfNXG2D9WsicjhTHxN6BVvOp5ixBCuJUncg5f4FVXbg43UTs6DNWukrzvhFuTtLqxUUz6dBxX3hiPIVSPxqDh3af/y8z7Xne5KJ8QQvgCmTNW+COdRsMVoRE4FTiem4HVYXfbsSMCQ3il0910i25BYNE4+3f3/crD6z8my1rgtvMIIYS3kZzDNV535U3aFBbLy83IIyMtw63HDgoJ5LE3h3PHqO7ogrToQ3T837JfGXvtJNKOnXbruYQQQghRszU3R+JQwInK0UqOq/8ng1bHk61v5OG4awlwKgTa4ZeUA/Rdt5BDWZJzCCGEKD/va9QnxKA6Cqeeq2yxvLJoNBrufvxWRr8xlKBaARjNeg79lcQjncaz/efdbj+fEELUdE5VqdQihLeKM0eVVMBPcmMX/GKKonBXTFteaH8HtbUBBNngWNYZ+q5bxJqT+9x+PiGEqOkk53CN1zXqY9vEoDoBFZL3nayy83S8uS2Tlo8jqnEERrOBrHPZPN1tKl+8uVrGZgoh/IqzEt3g/HnOWOH94kyRoChuLZZXlnZ1GvJ6Yl+ahoQTZAOLxcKoDct5c8/POCXnEEL4Eck5XON1V15cAd/pUDl+oOoa9QANmtdj8oonaH1tCwwmPehU5j26iDnD52O12Kr03EIIUVM4VU2lFiG81fkV8A9XwZP680UHmXm1091cF9WsZJz963vW8djGT8mxSW0fIYR/kJzDNV535Q1b1EOr06I6nByvwif1xUJqBTP2nYfo+eC/0Qfp0AfrWL34/3jyhimkn3Tv+DohhBBC1BzhASHUMQbjUOCIm8fUlyVQZ2BCm+482KwrRgcE2lR+OLGH/j8tdvuYfiGEEL7D6xr1eoOehi3q4bSrnDyUis1a9U/MtTot/Z7pxUMvDybQZMBo0rNn4wEe6TSe3Rv2V/n5hfBVOTk5bNu2jY0bN7Jt2zZycnI8HZIogwOlUosQ3qy5KRKnAhnWPM5Zcqv8fIqi0K9JB6a2uw2zxkCwDQ5lpNFn7UJ+TT1U5ecXwldJzuEdJOdwjdc16qGwC77qUHHYHaQcTqu283a9oyMTPhpLnYZhBNQykHE6gyevn8Lqxf9XbTEI4e12797NY489RsuWLTGZTLRr144uXbrQrl07TCYTLVu25LHHHmP3bilMWVNIVzjhz+LMkSXF8g5nV20X/PN1jmjM64l9iQkKI8gGuZZ8hv+2jEX710ttHyHKSXIO7yM5h2u88spjE2Jw2gu/0KqyWF5ZGsc3ZMrKp4jr3BSDSY9TcfLKsLeZ9+gi7Db3zWErhK9JSkqiZ8+exMfHs3z5cm644QYWLVrEhg0b2L59Oxs2bGDRokXccMMNLF++nPj4eHr27ElSUpKnQ/d7Dipz51wI7xZnjsKpKWzVV0UF/EtpEBzGa5370iU8liAb6OxOXtr5I09uXkW+XWr7CHExknN4L8k5XOOVjfriYnmqU+X4/upt1AOY64Ty1HuPcOOga9AH69AHa/nizdU8c/M0Mk5nVns8QtR0CxcuJCEhgT179rB06VKSk5N56623GDJkCImJiSQkJJCYmMiQIUN46623SE5OZunSpezevZuEhAQWLlzo6Uvwa3LXXPizOFNhsTyHAknV+KS+WLDewPPtbmFgk44YHRBgU/nfsR0M/Ok9TuZJziHEP0nO4d0k53CNV155kzaNAFAdnmnUA+j0Ou6bfA9Dpg3AGGLAYNKz/efdPNJpPAf/lLt8QhSbMWMGw4cPZ8CAAezYsYOBAwdiMBguuY/BYGDgwIHs3LmTAQMGMHz4cGbMmFFNEQshxN+amSLQUDit3ZFqflJfTKMo3N+sC5Pa9iQUPUE22JNxit5rF7Ap/ahHYhKiJpKcQ/grr2zU16lXm9CwYJx2tdq73//Tdfd0Zfx/H6V2vVoYzXpOnzjDmGsm8n8f/erRuISoCRYuXMjEiROZNm0aCxYsIDQ0tMztZsyYgaIotG7dutT60NBQFixYwNSpU5k4cSKLFi2qjrDFPzhUTaUWIbyZUaujcWgdHBo4knsWu9PpsViuiWrK3MQ+NAgwE2yFzPxcHvjlvyw9tEnG2Qu/JzmHb5CcwzVeeeWKohBbVCzvXGom2ec8W72yWbsmTFnxBE3bxWI067E77Lw46DUWPPMhDoc/j+4Q/iwpKYkxY8YwbNgwJk6ceNHtjh8/zgsvvEBwcPBFt5k4cSLDhg3j8ccfl/FuHqCi4HRxUf24Eq3wHXFFFfDtTgcn8jI8GktsaB1eT+xLxzoNCbKBYncw9a9veW7rV1gdUttH+CfJOXyH5Byu8cpGPUCT84rlVcd89ZcTFlWL8f8dzbV3J6IP0aEL0vLJy18w8bYXPX7TQQhPGDVqFOHh4cyZM+eS2z355JN06dKFjh07XnQbRVF45ZVXqFOnDqNGjXJ3qOIy5K658Hdx5qiSCvhJ2emeDQYwGQKY2u52ese0I8BeOM5+5ZE/ue+XJaTmZ3s6PCGqneQcvkNyDtd47ZXHtolBdRY16vef8nA0hQxGAw++MJB7J/XGEKzHEKpj8/d/MbrzeI7sSvZ0eEJUm927d7N69WpeeOGFi3Z/A/j5559ZsWIFc+fOvewxTSYTL774IqtXr2bPnj1ujFYIIS4tzhyJqhSOq/dEsbyy6DQaRsRdzdOtbyIYHUE2+OvMcXqvXcC2s8c9HZ4Q1UZyDiG8uFF/frG85H0nPBzN3xRFodu91/H0e49gjgzFaNZz6kgaj3WdwG+f/+Hp8ISoFvPnzycyMpI+ffpcdBuHw8Gjjz7KsGHDSEhIKNdxe/fuTWRkJG+//ba7QhXl4FSVSi1CeLs4c2EFfKdS/dPaXc6N9eKY0+lu6hpCCLbC2bxs7v15CSuO/Onp0ISoFpJz+BbJOVzjtY36mPiGKIqC0+65CviX0iLxCqasfIqY+AYYzXqsVivP3/0yHzz/CU4PFtkRojr88MMP9O7d+5IVZ+fPn8/Ro0eZNm1auY9rNBrp3bs3P/74ozvCFOXkQFOpRQhvVy/QTIjOWKOe1J/vCnMkb3S5hzZh9QiyATY7z239imnbvsXmlNo+wrdJzuFbJOdwjddeeWBwANFNo3A6nBzff6pGFqQLr1+b5z4aS+Kt7QvH2Qdq+e/UT/lP79nkZuV5OjwhqkR2djb79u2jU6dOF93mzJkzTJ48mUmTJhEREVGh43fs2JG9e/eSkyO1KqqL3DUX/k5RFJqbI3EokGbJJsdq8XRIFwgzBvFihzu5vWFCyTj7Dw/9wYO/fshZS66nwxOiSkjO4Xsk53CN1zbqAZq0iUG1q1gLbJw+5vnCNWUxBhp4+JX7ueepOzAE6zCE6lj/xSYe6zqB4wdqRi0AIdzp0KFDqKpKq1atLrrNxIkTqV27No8++miFjx8fH4+qqhw8eLAyYQohRIXEmc4rlpdbM3MOvUbL6JbXMabVDQSiJcgGm04foff/LWR3huQcwvdIziFEIe9u1CfE4HTUrGJ5ZVEUhVuGdWPMuw8TWicYo1lP8r6TjO48nk2rZcyb8C0WS+ETrKCgoDJfP3DgAO+++y6PPfYYJ0+e5MiRIxw5coSCggJsNhtHjhzh7NmzFz1+YGBgqfOIqudEU6lFCF8QZ448rwJ+zeuCf76eDeJ5uUMvIgzBBNkgJTeDAT+9x/+Sd3o6NCHcSnIO3yM5h2u8+spj2zQCFVAhuQZMa3c5ba5tyeQVT9AgLhqjWU9+Xj7P3foiH8/6HFVVPR2eEG5hNBoByMsre4jJiRMncDqdPPbYY8TGxpYsGzduZP/+/cTGxjJ16tSLHj8/P7/UeUTVc6hKpRYhfEGcOQoUBYcCSTkXbwTUFK3Conkj8R5ahUYRbAO71cYTmz7jpR0/4FClto/wDZJz+B7JOVyj83QAlRGbUFgB32l3crwGVcC/lKiYSCZ+Mo6FT/+XLT/uwJ7nYNGzSzn01xGeWDiSgCD50BDerVmzZiiKwu7du0lMTLzg9datW7Nq1aoL1k+cOJHs7Gxee+01mjZtetHj79q1C0VRaNasmVvjFhdXmXFq/jy+TfiW5qZIoLAC/pEaMFd9eYQHBPNyp7t4Y89PfH9yD1ZVZdH+9ezLTGVO596YDYGeDlGISpGcw/dIzuEar27URzeJIiDIiN1hJ3lfze1+/0+BwQE88sZQvnzrOz5/41s0OoV1H/9G8t4TPP/ZU9RtHOnpEIVwWUhICHFxcWzatIkhQ4Zc8Hp4eDi9evW6YH3xvLFlvXa+zZs306JFC0JCQtwQrRBClE+I3kj9oFqkZZ/jcM4ZnKqKRqn5CaRBq2Nc/L9pZopg/r5f0Kgqv6Ueos/ahbzVtR9XmCTnEN5Lcg4hCnl193uNRkPjhEaodpW05HTycws8HVK5aTQaeo3uyWNvDiMoLBCjWc/h7Ud4pNN4tq2VMW/Cu910002sXLkSq9Xq1uNaLBZWrlxJt27d3HpccWmqqsHp4qKqXv01I0QpxePqCxw2UvOzPB1OuSmKwp2N2jCzw53U1gYSZIPj2We5Z91ifjy519PhCVEpknP4Fsk5XOP1V94koVFJsbwTXlhNvn23Nkz6ZBx1m0RgNBvIyczhmZunser1b2ScvfBaDz/8MGlpaaxYsaLc+6xbt46dOy99Q2vlypWkpaUxcuTIyoYoKsCBUqlFCF9RqgJ+DS+WV5a2tRswr0tfrgiJINgGVouFRzZ8whu71+GUnEN4Kck5fIvkHK7x+kZ9bJsY1OIK+F5QLK8s9ZtFM/nTJ2hzXUsMJj2KHt4a8x6zh76FtcC9dx2FqA4tm6bT/YZaTJjwDNnZ2W45ZlZWFs8++yw9evSgZcuWbjmmKB+nWpl5Yz0dvRDuE2eOQlUUVCApx/sa9QBRgSbmdLqb6+teQaAdjHaVeXt/ZvSGT8ixSYVv4X2aNM3j+hvMTJjwtOQcPkByDtd4f6O+qFie6lBJ9pJieWUJNgfz+PwR3DL8RvRBOvTBOr5/fx1PXD+F9BPemTgI/6OqTtSct1HPDefNmbVIT09h7NixbjiuyhNPPMGZM2d466233BCpEEJUXJy5cPy5QwOHc7yjWF5ZAnR6xifczNArriLAoRBoU1lzci/3rFvEES+9WSH8j6qqZOUsIeX03Uydruf0ack5hP/ymUa906Fy3IuK5ZVFq9Vyz5N3MvLV+wk0GzGa9ezddJBHOo1n1/p9ng5PiEtSnTmoGaNRc14FVGIb6Zkz42oWLVrE9OnTXT+uqjJ9+nQWLlzIa6+9RmxsrPuCFuXi6ti24kUIXxETUhujRodTgaTsmj+t3aUoisI9se2Z1v42ammMBNsgKfM0fdYu5KeUA54OT4hLcqoFnDk3jrMZ4wEbDRvp+M+0NpJz+ADJOVzj9Vduqh1KRIM6qHaV5H0nfWIceuItHXju47FENKpDQC0DGemZPHnDFL5ZuMbToQlRJtV+EPVMb7D8WLRGQQkZw/DH/o/p06czadIkhg8fXuFucVlZWYwYMYLJkyczY8YMhg4d6v7gxWU5USq1COErtIqGZqYInAqczDtHgd3m6ZAqrWN4DK8n9iU2qDZBNsizFPDQ+o94d9+vPpFTCd9jtx8nJa0XOXkfl6wzhQznibEbJefwAZJzuMbrG/UAsW0a4XQ4ycvO5+ypc54Oxy1iWjZg8oonaNHlCgwmPapG5dUR83n9kYXYrN6fRAjfoRZ8j3qmLziSClcoJpSwd1BCRqEoGp577jkWLFjARx99ROvWrVm2bNllK9RaLBaWLVtGQkICH330EQsXLmTChAnVcDWiLA5VqdQihC+JM0fhUEAFjuR499P6YvWDa/Fq5z5cHdGEIBvo7Sqv7Po/xm36jDy71PYRNUd+wW+cTOuO1fYXAIoSQHjtN6ldayqKopecwwdIzuEan2jUN0mIwWkvKpa33zuL5ZXFVDuUJxeN5Kb7/oU+WIc+WMtXb3/HMzdN41xapqfDE35OVR04s+egZowGNbdwpS4Opc5KFOP1pbYdNmwYO3bsoFWrVgwaNIiGDRsyatQoFi9ezMaNG9m+fTsbN25k8eLFjBo1ikaNGjFo0CBatWrFjh075G65h0lXOCH+VjytHXhvsbyyBOsNTLqyJ/c17YzRAYE2lW+SdzLgp/c4npvh6fCEn1NVlczs+aSm34PTWXgzTadtRHTE/wgJurvUtpJzeDfJOVzjE1cem9Co8Ja5CslePq7+n3R6HYMm9uHBFwYSEGrAaNKz49c9PNLpGfZvOeTp8ISfUp0ZqOdGQO78v1cG3IpSezmKLqbMfWJjY/n222/ZtWsX/fr1Y926dQwbNowuXbrQtm1bunTpwrBhQ1n94/v06n09u3fv5ttvv5XxbH7qzTffpHHjxgQEBJCYmMgff/xx0W0XLFjAtddeS1hYGGFhYXTr1u2C7VVVZfLkyURHRxMYGEi3bt04cEDGDYuKizNFgaLgVPC5onIaReHepp2Z0vYWQhQ9QTbYl5FC77UL2HA6ydPhCT/ldOaRfnYU5zL/AzgBCDBeT3TUagyG+DL3KVfOMXQYy95fwbWd/y05h/B6Ok8H4A6xbQobEU4vr4B/Kf/q3YX6zeoy79FFnD2VQfrJs4y9dhLjFozkxkHXejo84UdU2x7UjEfAcbxojRYl9CkIGoKiXL7bU6tWrXj99dcByMnJ4eDBg1gsFnIcP6PWepOgYA2Nav2LBmaZQqamcFI4VYyr+1bU8uXLGTduHPPnzycxMZG5c+fSvXt39u3bR2Rk5AXbr1u3jgEDBnDVVVcREBDArFmzuPnmm9m1axf169cH4KWXXuL1119nyZIlxMbGMmnSJLp3787u3bsJCAhw6dqEfyqpgK/41pP6810V1YTXg/vy/J/fcCI/g2w1jwd//ZDxCTdzX9PO5fqsF8IdbPYk0tIfxGbfW7LOHPo4tUxPoSjay+5/sZzjwF/HWTJ1DTqNgRvbXSvT1tUg1Z1z+AqfeFLfMK4eOr0W1e702rnqy6Np28ZMXvEkV3SIxWjW43A6mHnf68x/YgkOu8PT4Qk/oOZ/iXqm398Nek1tlLD3UIIfdCnJCwkJ4corryQxMZGrOvUlKLjwIymrYJM7wxaVpFaiYI3qwhfsnDlzGD58OEOGDKFVq1bMnz+foKAgFi9eXOb2S5cuZdSoUVx55ZW0aNGChQsX4nQ6WbOmsLioqqrMnTuXiRMncuedd9KmTRs++OADTp48yeeff16ZX43wQ7WNwUQYQ4oq4Kf7bDG5mJDavJ7Yh051GhFkA43dyYzt3zFhy5dYHHZPhyf8QF7+Gk6l9ixp0CtKCBF1FhFmHl+uBv0/nZ9z9OrXE73WCMDOTYfdGreonOrOOXyFTzTqdXodjVo1wOlQOZWUhtWHC8mFRZp5+oNHue6eruhDdOiDtKx89X9MuPUFss5WrMqnEOWlqjacWTNQM58ECgpX6lqj1FmFYuzilnME6GLQayMAyLZsRVXlRlVN4VSVSi1QWFX4/MVisZR5LqvVypYtW+jWrVvJOo1GQ7du3fj999/LFW9eXh42m43atWsDkJSUREpKSqljms1mEhMTy31MIc5XPK4+y1bAGUuep8OpMqGGAKa2v417GrcnwA4BNpXPjm7j3p/fJzU/y9PhCR+lqk4ysuaQduY+nGphDSm9rhnRkd8QHHiLW84RYg4itmU0AEm7T5Kble+W44rKc0fO4Y98olEP0KRNYbE8p8PJqUOpng6nShkMeh6Y2p/BU/piCDFgCNWx9cftjO78LEk7jno6POFjVEc66tkHIG/J3ysD+6DU+QhFG+228yiKgsnYCQCHmkOudY/bji08r2HDhpjN5pLlxRdfLHO79PR0HA4HUVFRpdZHRUWRkpJSrnM988wz1KtXr6QRX7xfZY4pxPmam6NwFGVQSdnpng2mimkVDUObX8WENt0JQUeQDXacPUHv/1vI1jPJng5P+BinM4u0Mw+SkfUyhQWzICigJ9GR32DQX+HWc8V3bgoU9ubavUVqRgjv5jON+tjWjVAdRRXwfbgLfjFFUfj3wGt56v1HqBVlwmjWk3I0jceueo5fVm7wdHjCR6jWv1DP3AW24u7wehTTVBTTDBTF6PbzFTfqAbIs0gW/pnBHJdrk5GQyMzNLlmeffbZKYp05cyYff/wxq1atkrHyosrEmaNQFQUV3x1X/0/X1b2CVzv3pp4xlGArnM3PZvDPS/g0aaunQxM+wmrbx8m0W8gv+K5ojUIt07NE1FmIRhPq9vO17tSk5Oddf0gX/JpCqt+7xmeuvLhYnupUSd7r+436Yi06NWPKZ08Rm9AQo1mPzWZjat9XeH/SxzidTk+HJ7yYmrcc9exAcBb1fNFEotT+ECWof5UVSTIFSKO+JnJHVziTyVRqMRrLvikUHh6OVqslNbV0j6vU1FTq1q17yThnz57NzJkz+f7772nTpk3J+uL9XDmmEGWJMxUWyyscV+8fjXqApqYIXu/Sl7Zh9QmyAXYHE//8H8//+Q1WpwyZEq7Lzfsfp9JuwW4vnNlJo9QiKnwptUyPoShV01xp3fnvRv1OadTXGNL93jU+06hvUtyot6sk7/fNCvgXUyc6jAnLxtD1jo7oQ3ToArUsnbGSKXe9RG6W7471E1VDVa04M59DzZoEFNWn0HcoHD9vaFel5w7Sx6FVQgDILtjkswWovI2rBWuKl4owGAx06NChpMgdUFL0rmvXrhfd76WXXmLatGmsXr2ajh07lnotNjaWunXrljpmVlYWGzduvOQxhbiYpqHhaIumtUvK9Z9GPUAtQxAvdLiDOxu1KRln/9HhTQz55b+kF+R4OjzhZVTVwdnMGZw+OxxVLcxZ9fp4oqNWExhwQ5Weu3aUmeiYcAD2/XUUa4Hv1uTyJtWZc/gSn2nU165bC3N4KE6H6hfd7//JEGBgxEv30e+ZXhiCdRhCdWz43xYe7TLBZ6f5E+6nOlIKn87nf/r3yqD7UGovQSkqYleVFEVLqLEDADbnGQrsMsbNH40bN44FCxawZMkS9uzZw8iRI8nNzWXIkCEADB48uFT3/VmzZjFp0iQWL15M48aNSUlJISUlhZycwgaGoiiMGTOG6dOn8+WXX7Jjxw4GDx5MvXr16NWrlycuUXg5g1ZHk9BwHBpIzjnrd0+p9Roto1r8i3GtbiQQLUE22JJ+lN5rF7LznP/lYMI1DsdZUtMHkpU9r2RdcOBdREd8iV4XUy0xFD+tt1sd7P/rWLWcU4iq4DONekVRiG0Tg+pQyUzPJvOM/1WCVxSFng/+m3ELRxIaHozRrOf4/pOMTnyWjV9v8XR4ooZTrX8UjZ/fXrTGiGJ+CY1pEopiqLY4SnXBl6ntaoTq7grXr18/Zs+ezeTJk7nyyivZtm0bq1evLil0d+zYMU6dOlWy/dtvv43VaqVPnz5ER0eXLLNnzy7Z5umnn+bRRx9lxIgRdOrUiZycHFavXi3j7oXL4kxROBWwq06O557zdDge0b1BS17peBeRhmCCbJCWm8nAn97ny2M7PB2aqOEs1h2cTOtOgeXnojVaapunEl77TTSaoGqLI/68Lvg7/jhUbecVFyfd713jM416KCyW57QXFcvb7793iltf3YLJK56kYYt6GM16CvItTLpjFste+Ey6M4sLqKqKmvs+6tn7wVnUjVTbAKXOcpTAXtUejxTLq3k88QU7evRojh49isViYePGjSQmJpa8tm7dOt5///2Sfx85cqTwffyP5fnnny/ZRlEUpk6dSkpKCgUFBfz44480b97c1V+JEMSZI3EUvb2P+EmxvLK0qFWXNxLvobWpLsE2cNhsPLV5FTO3f49davuIMuTkfkpK2h04HMcB0GjCqRvxCabQ4VVWs+diWhdVwAcplldTSKPeNT7VqG/SJgbVWdSo96NieWWJahTBxI/H0rFHWwyhOrQBGt6b+BHT+s0hP0fm4hSFVDUfNfNJ1OwXgKLuo4arUeqsRNG38khMIcY2KBT2DJBGfc0gX7BCXKi5KRKKx9X7UbG8stQJCGZWx170rB9PoB2MdpX3DvzOiPXLyLBKziEKqaqNM+eeI/3cY6gUAGAwtKde5HcEGK/ySEz1GocTFlFYWX/3liQcDrkR5WmSc7jGpxr1saWK5fl3ox4gIDiAR157kLvH3Io+SIchRMcvKzbw+NUTOZWUevkDCJ+m2o+hnukHBV/9vTJ4BErYQhRNmMfi0ihGQo1tAbDYk7HYZR5xIUTNE2cuHA4ijfpCBq2Ox1tdz+iW1xHo1BBoh/Wph+izdiH7MiXn8Hd2Rxopp/uQnbu4ZF1I8CCiIz5Dp6vnsbgURSG+aGq7/BwLSbulDpXwTj7VqI9p1QCNRsHpcHJcisMBhR9Wd4zszmNvDSM4LAijWc+RXcd4pNN4tq6RMW/+SrX8jHqmN9j3Fq5QglFqvYEm9EkURevZ4ACTsXPJz9nytN7j5K65EBeqG2jCpA/AqcDhnHRPh1MjKIrC7Q0TmNnxTuroAgmywYnss/Rft5jvTuzxdHjCQwosmzmV2h2L9Y+iNQbq1HqZ8LDZKErZ05tWp9aJf3fBl6ntPE9yDtf4VKM+IMhI/SuicTpUTh5MwWH3r2q0l9Lu3wlMWvEE0c0iMZoN5Gbn8myP6Xw292sZZ+9HVFVFzXkb9dxwUDMLV2pjUep8ihLQ3bPBnSdUiuXVKCquTzEjny7CVymKUjKu/owllyxrgadDqjHahNVnXuI9NA+JJNgGVquVxzZ+yqu7/g+n5Bx+Q1VVsnKWkHL6bhzOwl53Wm000RGrCA2518PR/U3mq69ZJOdwjU816gEaJzRCtatYLXZSj8md8/PVaxLFpE+eoM31rTCE6tHoFd4e9z4vD3kTS77F0+GJKqY6c1AzRqPmvArFH3vGG1HqrEDRNfNobP8UamxH8ceTjKv3PLlrLkTZiivgAxyRp/WlRAaGMqfzXdxQN65knP38fb8y6vePybbJDRBf51QLOHPuCc5mjAcK5383GrpQL/I7jMb2ng3uHxq3qEdQaOFMKLs2HZKHXR4mOYdrfK5R3yQhBqejuFiedMH/p2BTEI+/PZzbHroJXZAWfYiOHz74iXHXTeH0cRkT6KtU+yHUM33A8kPRGgUlZAxKrTdRNKEeja0sOk0owYbCQn15tv3YHZkejkgIIS4UZ/67UX8456xng6mBjFo9zyR0Y3jzqwlwKATaVNad2k/ftYs4nC03QXyV3X6clLRe5OR9VLLOFDKcuhGfoNVGeDCysmm1Glp1jAUgIz2HE0mnPRyREBXne436NjGggupUSd4nxfLKotVq6TPudkbNHUKQOQCjWc+BrYd4pNMz7Pxtr6fDE26mFvxQ2KB3FHUpU0woYe+ghIxCUWruR4DJ2LHoJ5Usy2aPxuLv5K65EGVrbi6sgO9QIEkaqWVSFIU+jdsxvf3thGmMBNngaFY6fdcuYt2p/Z4OT7hZfsFvnEzrjtX2FwCKEkB47TepXWsqiqL3cHQX17rT313wZWo7z5KcwzU1N6N3UWybRgCoDpXk/fKk/lI692zHxI/HEhkTjtFsIPNMFk/9+3n+984Pl91X1Hyq6sCZPQc14xFQcwtX6uIKp6szXu/R2MpD5quvOeQLVoiyXWGKBIor4Euj/lI6hDfijS730CS4DkE2KLAU8PDvHzN/7y/S3dkHqKpKZvZ8UtP74XQW9lrRaRsRHfE/QoLu9nB0lxff+fxieYc8GImQnMM1Pteoj4qJICg0EKdD5cT+U54Op8Zr2KI+U1Y8SaurmmMw6VE1Kq+NfJe5D72DzWrzdHjCRaozA/XcCMid//fKgFtRai9H0cV4LrAKCA3oWPJztjyp9yj5ghWibME6A42Cw3Bo4GjOOSkCdxnRQWZe7dybayObEmgHvV3l1d1refyPFeTarZ4OT7jI6cwj/ewozmX+BygsUh1gvJ7oqNUYDPGeDa6cmrdthN6oA6RYnqd5Iud48803ady4MQEBASQmJvLHH39ccvtPP/2UFi1aEBAQQEJCAt98802p1x944AEURSm19OjRw6XYysvnGvUajYbGrRui2lVOHz9LXnaep0Oq8ULCgnli4Ui6P3A9+mAd+mAdXy/4kadu/A9nU855OjxRQaptD+qZu8H6S9EaLUroeBTzHBRNkEdjqwiDNoIAXeEYtxzLDhxOKazkKaqqVGoRwpcVj6svcNo4lSf1Py4nSGdgYtse3N+sCwEOCLSpfHd8N/3XLSY5V3IOb2OzH+HU6dvIzf+8ZJ059HGiwj9EqwnzXGAVZDDqiGtb2Ns35dgZzqTI37KnVHfOsXz5csaNG8eUKVPYunUrbdu2pXv37qSlpZW5/fr16xkwYABDhw7lzz//pFevXvTq1YudO3eW2q5Hjx6cOnWqZPnoo4/KPJ67+FyjHiD2/GJ5+1M8HI130Oq0DHj2bobPupeAUANGk55d6/fxSKfx7Nt00NPhiXJS879CPdMPHMcLVyhhKGHvoQQ/iKJ4X+PKVDS1nYqNHOs2zwYjhBBliDNFlhTLS8qRgrPloSgKA5t0ZMqVtxCq6Am2wYHMVPqsXcjvafKU1Fvk5a/hVGoPbLY9AChKCBF1FhFmHo+iaD0cXcVJF3z/NGfOHIYPH86QIUNo1aoV8+fPJygoiMWLF5e5/WuvvUaPHj146qmnaNmyJdOmTaN9+/bMmzev1HZGo5G6deuWLGFhVXuTyycb9U3axKAWN+r3ybj6iri6V2eeXTaGOg3CMJr1nEk5x9h/TeaHD37ydGjiElTVhjNrBmrmE0DRE21da5TwVSjGLh6NrTJKjasvuHRXKFF1XJ0vtngRwpc1N0ehKoXzI8u4+orpGtmE17vcQ8PAMIKtkF2Qx4O/LuX9AxtknH0NpqpOMrLmkHbmPpxq4RNtva4Z0ZHfEBx4i4ejc53MV18zuCPnyMrKKrVYLGVP3W21WtmyZQvdunUrWafRaOjWrRu///57mfv8/vvvpbYH6N69+wXbr1u3jsjISOLi4hg5ciRnzlTtTV8fbdSfVyxPKuBXWJOERkxZ+STNOzXBaNbjxMFLD8zj7bHv47A7PB2e+AfVkY56dgjkLfl7ZWAflDofoWjreS4wN5BieTWDjKkX4uLizIXF8hwaeVLvikbBYbzeuQ+JdWIIsoHO7uTFHd/zzJYvKHBIbZ+axunMIu3Mg2RkvQwU3ngJCuhJdOQ3GPRXeDa4SmrZIRaNpvA7S57Ue447co6GDRtiNptLlhdffLHMc6Wnp+NwOIiKiiq1PioqipSUsnt7p6SkXHb7Hj168MEHH7BmzRpmzZrFTz/9RM+ePXE4qq4dpauyI3tQbEJho97pUDl+QBr1rjCHm3j6/dEsnf4Z65b/hkbr4LPXvubwjqNMWj4OU52aN7e5P1Ktf6FmjAZnatEaPYppIgT298ru9v9k1DXEoI3C6kgl2/InqmpHUXzyY6tGq8zYeBlTL3xdw+AwArV6nHYrh7OlUe+KEIOR59vfygcHN/Jx0hY0qsoXR//iUFY687r0JTrI7OkQBWC17SPtzFDs9uIGr0It0zOYQx+t0VPklldwaACxrepzaOdxju5LITsjj9Ba3lOLyFe4I+dITk7GZDKVrDcajW6Jrbz69+9f8nNCQgJt2rShadOmrFu3jhtvvLFKzun9f4FlCDYHExUTgWpXOb73lHThcpHeoOeBqf24/z/9MIYaMJj0bFu7k0c6PcPh7Uc9HZ7fU/OWo54d+HeDXhOJUvtDlKABPtGgh8Jxl6FFT+udah451l0ejkgIIUrTKhquMEXgUCAlP5M8qeLuEq2iYcgVXZnQpgeh6Amywa5zJ+i9diGb0495Ojy/l5v3P06l3VrSoNcotYgKX0ot0+M+0aAvVjxfvaqq7N6c5OFohKtMJlOp5WKN+vDwcLRaLampqaXWp6amUrdu3TL3qVu3boW2B2jSpAnh4eEcPFh1dcp856/wH2ITGuF0OMnPLSD9xFlPh+PVbuh/NU8veZSwuiaMZj2pyek8ftVz/PRp2WNNRNVSVSvOzImoWZOAoq6J+g4odVahGNp5NLaqUFwsDyBbuuB7hHS/F+LSiivgq8CxHMk5KuO6us14NbE39Y0mgq2QkZ/DA798wMeHt3g6NL+kqg7OZc7g9NnhqGouAHp9PNFRqwkMuMHD0blf60Qpludp1ZlzGAwGOnTowJo1a/4+v9PJmjVr6Nq1a5n7dO3atdT2AD/88MNFtwc4fvw4Z86cITo6ukLxVYRvN+rthU/ok6VYXqU179CEKSufpOmVMRjNemx2G9P7zWHRhGVVOj5ElKY6Ugqfzud/8vfKoPtQai9B0UZ4LrAqVLpYnsxX7wkypZ0Ql9b8vAr4h2VcfaU1CQ3n9S59aVe7AUE2wO5gyravmbz1f1idknNUF4fjLKnpA8nM/ruqd3DgXURHfIleF+PByKpOfKe/i+Xt2iTF8jyhunOOcePGsWDBApYsWcKePXsYOXIkubm5DBkyBIDBgwfz7LPPlmz/+OOPs3r1al555RX27t3L888/z+bNmxk9ejQAOTk5PPXUU2zYsIEjR46wZs0a7rzzTpo1a0b37t3d80sqg8826pu0iSm8Za7C8X2nPB2OT6hdN4zxHz7G1b06ow/RoQvS8vHMVUy+cxY5GbmeDs/nqdY/UM/cBbbtRWuMKOaX0JgmoSgGj8ZWlYL0zdFpCsdTZlk2y3AaD1ArccdcGvXCH8SZo0BRcCpSAd9dzIZAZrS/g7sbtSXADgE2leVJW7j/lw84XZDj6fB8nsW6g1NpPSiw/Fy0Rktt81TCa7+JRuO748zDIkKp36TwIcmB7clYCmQ4TXWr7pyjX79+zJ49m8mTJ3PllVeybds2Vq9eXVIM79ixY5w69Xdb8qqrrmLZsmW8++67tG3blhUrVvD555/TunVrALRaLdu3b+eOO+6gefPmDB06lA4dOvDLL79U6dh+n604Fdum8A6iFMtzL4PRwLCZg4hp1YCPZ32ORqvwx7d/8miXZ3l+1dPEtGzg6RB9jqqqkPcBavZMoOgJhaY+Stg8FH28R2OrDoqiIdTYgXP5/4fdeZZ8+yGC9M08HZYQQpRobiqqgK9IBXx30mk0PNTiWpqGRjB3z1o0Ngd/ph+j9/8tYF6Xe2hTu76nQ/RJObkrOHPuKdSiKXI1mnAi67xDgPEqD0dWPVp3bsqJw6ex2xzs+/Mobbp6d1V/cXmjR48uedL+T+vWrbtgXd++fenbt2+Z2wcGBvLdd9+5M7xy8dkn9Q2uiEZv1KPanSTvlUa9OymKws33X88Ti0YSGhGC0aznxKEUHusygd+/ku7R7qSq+aiZT6Fmz6CkQW+4GiX8M79o0Bcr3QVfxtVXNxVQVRcXTwcvRDUIMwYRFRBa9KT+jPQocrNu9VvwSqe7iTKEEGSD03lZDPr5fVYd/cvTofkUVbVxJmMi6eceLWnQGwztqRf5nd806KF0F3yZr776Sc7hGp9t1Gt1WmJaNcDpUEk9koZVus+4XXzXOKasfJJGrepjNOkpKLAwpddLLJ2+EqfT6enwvJ5qP4Z6ph8UfPn3yuARKGELUTRhngvMA6RYnmc5USq1COEP4sxRODSQY7eQXiBD0twtzhzFvC59aW2OJtgGqs3O+C1fMOOv77BLzlFpdkcaKaf7kp2zqGRdSPAgoiM+Q6er58HIql/rztKo9yTJOVzjs416gNg2hcXynE6VEwdTPB2OT4psEM5zH42l863tMITq0AZoeH/yx0y7Zw75OfmeDs9rqZZfUM/0BvvewhVKEEqtN9CEPomiaD0bnAcEG1qjUQIAeVLvCVIoT4jLa27+u1heUo6Mq68KYcZgZnXsxa0NWhNgB6Nd5YODGxj624ecteR5OjyvVWDZzKnU7lisG4vWGKhT62XCw2ajKNU7v3dNULdRHepEFdby2bv1CA67FGesTpJzuManG/VNEmJQHcUV8KULflUJCDIycs4D9B13O/ogHYZQHb9+tpHHrnqOk4fkZkpFqKqKmvM26rlhoGYWrtTGotRZgRJQdRUzazqNYiDEcCUAFscJLHb5exZC1CxxpihURUGlsAu+qBoGjZbHWl3P462uJ8ipIcgGG9OS6LN2IXszJOeoCFVVyc75gJTTd+NwFv7utNpooiNWERpyr4ej8xxFUYgvelqfn2vh0C6ZRUvUfL7dqC8qlqc6VU7sl0ZAVVIUhVsfuokx74wgpHYwRrOeo7uPM7rzeLb8IGPeykN15qBmjEbNeZWSUUHGGwsb9DopDHd+F/ws6YJfrWSeeiEuL85cWCzPKcXyqsUtDVozq2MvwvVBBNngVM45+v/0Ht8c3+Xp0LyCUy3gzLknOZPxDGADwGjoQr3I7zAa23s2uBrg/C74MrVd9ZKcwzU+3agvroCv2lV5Ul9N2l4Xz+RPx1HviroYzXpyc/KY0HMGn77ylRQOugTVfgj1TB+w/FC0RkEJeRyl1psomlCPxlZTmIwdS37OKvjDg5H4H5cL1hQtQviD2NBw9IoGhwYOS/f7atE6rB5vJN5Di9BIgm1gs1oZ+8dK5uxcg0OVcfYXY7efICXtLnLylpWsM4UMp27EJ2i1ER6MrOZo3blpyc87Nh7yYCT+R3IO1/h0oz4s0kytSDNOh0ry3hPSqKwmdWOjmPTpOK68MR5DqB6NQcO7T33ArMFvYMm3eDq8Gkct+KGwQe8ouhOsmFDC3kEJeQRF8ek/0QoJNbYHCusJZFlkloXqJOPbhLg8g0ZLE1METgWO52Zgddg9HZJfiAgM4ZVOd9MtugWBRePs39n3KyPXf0yWtcDT4dU4+QXrOZnWHattGwCKEkB47XnUrjUVRdF7NrgaJCauLiGmQKDwSb20IaqP5Byu8fkWQ5OiYnnZ53LJTM/ydDh+IygkkMfeHM4do7qjC9KiD9GxZukvjL12EmnHTns6vBpBVR04s+egZjwCalGlZF0cSp2VKMbrPRpbTaTVBBNsaAVAvu0ANsc5D0ckhBClNTcVFstzqE6O58pnVHUxaHU82fpGHo67lgCnQqAdfk45QN91iziUJTkHFI6fz8x+h9T0e3A6C4eH6LSNiI74HyFBvT0cXc2j0Who1TEWgKyzuSQfTPVwREJcms836mMTYlAdhV2wkved8nA0/kWj0XD347cy+o2hBNUKwGjWc3BbEo90Gs/2n3d7OjyPUp0ZqOdGQO78v1cG3IJSezmKLsZzgdVw589Xny1P66uN3DUXonzizJE4it7yh2VcfbVSFIW7YtryQvs7qK0NIMgGx7LS6btuEWtO7vN0eB7ldOaRfvYRzmU+DxRWcg8wXk901GoMhniPxlaTxcvUdh4hOYdrfL5R36RNDMXDqo5LsTyP6HhzWyYtH0dU4wiMZgNZ57J5uttUvnzrO7/szqTa9hROV2f9pWiNFiV0PIr5VRRNkEdjq+lMAZ1LfpZiedVHitYIUT5xpihQFJwKHJYK+B7Rrk5DXk/sS9OQcIJsYLFYGLVhOW/u+RmnH+YcNvsRTp2+jdz8VSXrzKGPExX+IVpNmAcjq/kSEv8eV79LGvXVRnIO1/hFox4Ki+Udl2J5HtOgeT0mr3iC+GviMJj0oFN5Y/RCXh3xDlaLzdPhVRs1/yvUM/3AkVy4QglDCXsPJfhBFMV/P4jKq3SxPGnUVxcpWiNE+cSZo4DCCvhHpFiex0QHmXm1091cF9WMQDsY7Cqv71nH4xs/JcfmP7V98vLXcCq1BzbbHgAUJYSIOosIM49HUbQejq7ma5bQEGNAYZ2BnZukWF51kZzDNT7fqG/Usj4arQanw0nyPpln0pNCagUz7t2H6fngv9EH6dAH6/h20Rqe+vfznDnl22MPVdWGM+sF1MwngKLCPbrWKOGrUIxdPBqbN9FraxOoL5zeL9e6C4czz8MR+YfCL0pXu8J5Onohqk9kQAi1DIFF09qd9XQ4fi1QZ2BCm+482KwrAQ4ItKl8f2IP/X9azDEf/2+jqk4ysl4l7cx9ONVMAHS6pkRHfkNw4C0ejs576A064toVPhxMO36O0yd9O1etKSTncI3PN+oNAQYaNI/GaVc5dSgFu02q0XqSVqel3zO9eOjlwQSaDBhNenZv2M8jnZ5hz8YDng6vSqiOdNSzQyDv/b9XBvZGqfMRiraex+LyVsXj6lXsZFv+9HA0oqq8+eabNG7cmICAABITE/njj4tPY7hr1y569+5N48aNURSFuXPnXrCNw+Fg0qRJxMbGEhgYSNOmTZk2bZpfDgESVUdRFOLMUTgUOGvJJcMqNx49SVEU+jXpwNR2t2HWGAi2waGMNPqsXchvqb755NXpzCLtzINkZL0EFH6+BQX0oF7ktxj0V3g2OC8k4+qFt/D5Rj0Ujat3qNisDlKOSBXUmqDrHR2Z8NFY6jQMI6CWgXNpGTxx3WS+e3+tp0NzK9X6F+qZu8BW3CDRo5j+g2J6AUUxejQ2b3V+sTwZV189qrtozfLlyxk3bhxTpkxh69attG3blu7du5OWllbm9nl5eTRp0oSZM2dSt27dMreZNWsWb7/9NvPmzWPPnj3MmjWLl156iTfeeKPC8QlxKcUV8AGSsn37ibC36BzRmNcT+xITFEaQDXIs+Qz7bRmL9q/3qRt7Vtt+TqbdQn7Bd0VrFGqZxhNRZxEaTahHY/NWrTv9Pa5+5x++eSOoppFCea7xi0Z9bEIMTkfhh7YUy6s5Gsc3ZMrKp4jr3BSDSY9TcTL7wbd48/HFPtGjQs37BPXsQHAWTYOiiUSp/SFK0AAZP18JoQHnV8CXRn11UCu5VNScOXMYPnw4Q4YMoVWrVsyfP5+goCAWL15c5vadOnXi5Zdfpn///hiNZd8sW79+PXfeeSe33norjRs3pk+fPtx8882X7AEghCvizFE4NYWf8Ukyrr7GaBAcxmud+9IlPJYgG+jsTl7a+SNPbf6cAof31/bJzf+aU2m3YLcXNjw1Si0iwz+klulxFMUv0v0q0bJDYzTawt+fFMurHtWdc/gKv/grb9ImBlRQnSrJUiyvRjHXCeWp9x7hxkHXoA/WoQ/W8vkb3zK++3QyTmd6OjyXqKoVZ+Yk1KyJQFGioO+AUmcViqGdR2PzBQG6+hi00QBkW7bhVL0/Gavp3HHXPCsrq9RisZRdrMpqtbJlyxa6detWsk6j0dCtWzd+//13l6/hqquuYs2aNezfvx+Av/76i19//ZWePXu6fEwhyhJnigTAoUCSVMCvUYL1Bp5vdwsDm3TE6IAAm8pXx7Yz8Kf3OZnnrTmHg3OZMzh9ZhiqmguAXh9PdNRqggL+7eHovF9gsJGm8fUBOLo/haxzuR6OyPfJk3rX+EWjPjahEQCqQyrg10Q6vY77Jt/DkGkDMIYYMJj0/PXTLkZ3fpaD25I8HV6FqI4U1LODIH/53yuD7kWpvQRFG+G5wHxMcRd8p5pPrnWXh6MR5dGwYUPMZnPJ8uKLL5a5XXp6Og6Hg6ioqFLro6KiSElJcfn848ePp3///rRo0QK9Xk+7du0YM2YMgwYNcvmYQpTlClMkCoUV8KVRX/NoFIX7m3VhUtuehKInyAa7z52k99oFbEo/6unwKsThOEtq+iAys+eVrAsOvIvoiC/R62I8GJlvaX3euPrdm7wrLxX+wy8a9ZGNwgkyBeK0q1IBvwa77p6ujP/vo9SuVwujWU/a8XTGXD2RtR//5unQykW1bioaP/9X0RojinkWGtNkFMXg0dh8jem8LvgytV01cENfuOTkZDIzM0uWZ599tlov4ZNPPmHp0qUsW7aMrVu3smTJEmbPns2SJUuqNQ7h+wJ1emJC6uDQwNHcszhUp6dDEmW4JqopcxP70CDATLAVMvNzeeCX/7L00CavGGdvse7gVFoPCiw/Fa3RUts8lfDab6LRBHk0Nl8T3/m8cfUytV3Vk/73LvGLRr2iKCXF8s6eyiA3U7rO1FTN2jVhyoonaNouFqNZj91h54WBc1nwzIc4HA5Ph1cmVVVRcz9APXs/OIueymjqo9T5GCXwLs8G56NKF8uTMdFVrjLd4Iq6wplMplLLxca+h4eHo9VqSU1NLbU+NTX1okXwyuOpp54qeVqfkJDAfffdx9ixYy/aY0CIyogrKpZnddq9tlu3P4gNrcPriX3pWKchQTZQ7A6m/vUtE7f+D6uj5tb2ycldQUraHdgdyQBoNOHUjfgEU+hwqdlTBeI7nVcBf6M06qucG3IOf+QXjXr4R7G8A6534RRVLyyqFuP/O5pr705EH6JDF6Tlk5e/YNLtM8k+l+Pp8EpR1XzUzKdQs6cDRQmA4SqU8M9Q9PEejc2XBeqbodPUAiDbshlVnoRVqcI5Y11fKsJgMNChQwfWrFlTss7pdLJmzRq6du3q8jXk5eWh0ZT+ytNqtTid8t4R7tfc/HcF/MPSBb9GMxkCmNrudnrHtCPAXjjOfsWRrQz+5QPS8rM9HV4pqmrjTMZE0s89ikoBAAZ9O+pFfkeA8SoPR+e7atUJoWGzwloZB3cepyCv7Jowwj2qM+fwJX7TqC9+Ug9IF3wvYDAaePCFgdw7qTeGYD2GUB2bvtvG6MRnObo72dPhAaDak1HP9IeCL/9eGTwcJWwRiibMc4H5AUXREGrsCIDdmUme7YCHIxLuNG7cOBYsWMCSJUvYs2cPI0eOJDc3lyFDhgAwePDgUt33rVYr27ZtY9u2bVitVk6cOMG2bds4ePBgyTa33347M2bM4Ouvv+bIkSOsWrWKOXPmcNdd0ptGuF8LcxSqohSNq5cK+DWdTqNhRNzVPN36JoLREWSDbWeSuXvtAv46e9zT4QFgd6SRcrov2TmLStaFBA8iOnIVOl09D0bmH+KLprZz2J3s2epdtReEf/CbRn2pYnl7pVieN1AUhW73XsfT7z2COTIUo1nPqaRUHu0ygfVfeHYctWr5BfXM3WDfUxRsEEqtN9CEPoWiaD0am784vwu+TG1Xtaq7Em2/fv2YPXs2kydP5sorr2Tbtm2sXr26pHjesWPHOHXqVMn2J0+epF27drRr145Tp04xe/Zs2rVrx7Bhw0q2eeONN+jTpw+jRo2iZcuWPPnkkzz00ENMmzat8r8gIf4hzlz4XnUqcCRH5qr3FjfWi2NOp7upawgh2Apn87IZ9PMSVh7Z5tG4CixbOJXaHYt1Y9EaA3VqvUx42GwUpeyhTMK9zi+Wt0vmq69SUv3eNX7TqG/cuiFAYbE8maveq7RIvIIpK58iJr4BRrMeq9XKlLte4r//+bTau86qqoqaMx/13DBQi8ZJahuj1FmBEtC9WmPxd6aAziU/S7G8KlY8Ts3VxQWjR4/m6NGjWCwWNm7cSGJiYslr69at4/333y/5d+PGjQv/Nv+xrFu3rmSb0NBQ5s6dy9GjR8nPz+fQoUNMnz4dg0GKWAr3qx9UiyCdQZ7Ue6ErzJG80eUe2oTVI8gG2OxM2Pol0/9ajc1Z/bV9snP+S8rpu3A4C4eOarXRREesIjTk3mqPxZ+1TjyvWJ7MV1+1PJBz+AK/adQHm4KoGxuJ0+Hk+P6TMo7Sy4TXr81zH40l8db2hePsA7V88J9PmNpnNnnZ+eU+Tk5ODtu2bWPjxo1s27aNnJzyj9FXnTmoGaNRc+ZQUl7TeCNKnZUoumYVvCJRWcGGVmiUQACyLJu9olqxt5LxbUJUjEZRaG6KwKFASkEWuTarp0MSFRBmDOLFDndye8OEknH2/z24kQd//ZCzlvIXW65MzuFUC0g/9wRnMp4GbAAYDV2oF/kdRmP7il6SqKSoBrWJqFcLgL1/HsVuq5nFm32B5Byu8ZtGPfw9rt6SZyX9hHSH8zbGQAMPv3I/9zx5B/ogHYZQHb99vonHuk7gxMFTF91v9+7dPPbYY7Rs2RKTyUS7du3o0qUL7dq1w2Qy0bJlSx577DF279590WOo9kOoZ/qA5YeiNQpKyOMotd5E0YS6+UpFeWgUPaHGdgBYHaewOKRWhhCi5ogzRZUUyzuSI8XyvI1eo2V0y+sY0+oGAlUNQTbYdPoIfdYuZHdG1eYcdvsJUtLuIid3Wck6U8hw6kZ8glYb4dbrFOVXPLWdJd/KwZ01o76TEMX8qlEfm9AIp724WJ50wfdGiqJwy/BujH33IULrBGM06zm29wSjOz/LptV/lto2KSmJnj17Eh8fz/Lly7nhhhtYtGgRGzZsYPv27WzYsIFFixZxww03sHz5cuLj4+nZsydJSUmljqMW/FDYoHcUdbdSQlHC3kEJeQRF8as/oRqn1NR20gW/6sicsUJUWJz570Z9Uo50wfdWPRvE83LHu4gwBBNkg1M5GQz46T3+l7yz1HbuyjnyC9ZzMq07Vts2ABQlgPDa86hdayqKoq+uyxZlaH3+1HbSBb/qSM7hEr9qkcQmxJT8B0/eK0/1vFmbf7Vi8oonaBAXjdGsJy83j4m3vcjyl75AVVUWLlxIQkICe/bsYenSpSQnJ/PWW28xZMgQEhMTSUhIIDExkSFDhvDWW2+RnJzM0qVL2b17NwkJCSxcuBBVdeDMfhU14xFQi7rb6Zqj1PkMxXi9R69fFJJiedVDitYIUXFx5kgoqoAvxfK8W6uwaN5IvIdWoVEE28ButfHEps94eeePOFSnm3IOlczsd0hNvwens7Bnh07biLoRXxES1NvDvwEB/yyWJ436qiI5h2v8qlHfpE1hBXynvXBcvfBuUTGRTPxkHB1uSsAQqkdj0LBw/IfcfOVtDB8+nAEDBrBjxw4GDhx42WJYBoOBgQMHsnPnTgYMGMDw4cOZMbEz5L7990YBt6DU/gRFF1PFVybKK8TYDgUdIE/qq5zcMReiQpqbCivgOxQ4LMXyvF54QDAvd7qLm+u1JNAORrvKwn2/0fmh/m7JOZ6b2IVzmc8DhWO1A4zXEx21GqOhddVfnCiXhldEEVorCIBdmw5Lfa6qJDlHhflVo75es7oYAvQ4Hap0v/cRgcEBPPLGUHo92hNdkJZUw1F+3P4N06ZNY8GCBYSGVmy8e2hoKAsWLGDq1KlMemEri5ZlAhqU0GdQzK+iaIKq5kKES7SaQIKLEp58+yFsDhm3KoSoGUyGAKIDTUUV8M9IMU8fYNDqGBf/b0a1+BcBToW877ewdcGnbsk5XnzhD5Z/nAeAOfQxosI/RKsJq4rLEC7SaDTEF3XBz87II/lAqocjEuJvftWo12q1NG7dCNWhknY0nYI8i6dDEm6g0WjoNbonfafcyl7HXwwdOpSJEyeW2mbXrl307duXJk2aEBQURHh4OP/617/46quvyjzmxIkTGTp0KGMnn+VIxgyU4KEoiv926anJTAHnjau3bPZgJL5LusIJ4Zo4cxQODeQ5rKQVZHs6HOEGiqJwZ6M2PB7ZkdQPvndrzjF1Sh652TMIMz+Lomir43JEBcV3lnH1VU1yDtf4VaMeoElRsTxVVTl5MMXT4Qg3+uCLxUTXi+bVV1+94LWjR4+SnZ3N/fffz2uvvcakSZMAuOOOO3j33Xcv2F5RFObMmUOdOvV4ZOzCKo9duE6K5VUDKVojhEviTJElxfKkC75vee+FOdSLquvWnCM8vB5Pjvu0ymMXrjt/XP3OTdKorxKSc7hE5+kAqltsQuG0dlBYAb9JGxkf7Qv27dvHmjVrWLp0aZnd32655RZuueWWUutGjx5Nhw4dmDNnDiNGjLhgH5PJxIsvvsigQYPYs2cPLVu2rLL4hetCjR1Kfs6y/OHBSHyZUrS4uq8Q/inOHIWqKKioJOWcpWtkk8vvJGo8yTn8V7PWDTEGGrDkW9m58RCqqkpPTreTnMMVfvekPraoWJ7qUDm+Tyrg+4r333+fyMhI+vTpU+59tFotDRs2JCMj46Lb9O7dm8jISN5+++2LbiM8S68NI1DfHIBc624czhwPR+SD5K65EC6JMxcWyyusgC81P3yF5Bz+S6fX0qJd4QPB9FMZpB2XmS3cTnIOl/hfoz6hqAK+QyV5/ykPRyPcZd26dfTu3fuyFWdzc3NJT0/n0KFDvPrqq3z77bfceOONF93eaDTSu3dvfvzxR3eHLNzIZOxY9JOTbMufHo1FCCGKxYTURq/R4tBAknS/9xmSc/i31jKuXtRAfteorxVhpnZ0GKpDJXnfCalG6wOys7M5ePAgnTp1uuy2TzzxBBERETRr1ownn3ySu+66i3nz5l1yn44dO7J3715ycuQJcE1VuliejKt3O7lrLoRL9BotzUIjcCpwPDcDq8Pu6ZBEJUnOIeI7Ny35WRr1VUByDpf4XaMeCuerd9pVcjPyyEjL9HQ4opKOHDmCqqq0atXqstuOGTOGH374gSVLltCzZ08cDgdWq/WS+8THx6OqKgcPHnRXyMLNpFheFVOVyi1C+LE4cyQOBZyoHM2RrrreTnIO0bJ9DFpdYRNq16ZDHo7GB0nO4RK/bNTHtm6E6nACyHz1PqD4CzIo6PJzyLdo0YJu3boxePBg/ve//5GTk8Ptt99+yR4bgYGBAFgsMgViTWXU1cOobQBAjnUbTlX+W7mTqlZuEcKfxZmjSirgJ8m4eq8nOYcICDLSLKEhAMkH08g4I70q3ElyDtf4Z6O+TQyqE1DhuDTqvV7xmLa8vLwK79unTx82bdrE/v37L7pNfn4+UDjWTdRcxV3wnaqFHMtOD0cjhBCF4kyRoCg4FUjKlka9t5OcQ0DpcfW7ZGo7UQP4ZaO+eBo71aGSvF8a9d4uNjYWRVHYvXt3hfct/vLMzLz4MIxdu3ahKArNmjVzOUZR9Up1wZdx9e4l49uEcNn5FfCTcqVYnreTnEMAtO7097j6XX9IF3y3kpzDJX7ZqG/Yoj5anRanwylP6n1ASEgIzZo1Y9Omizfk0tLSLlhns9n44IMPCAwMvOTYuM2bN9OiRQtCQkLcEq+oGqHnFcvLlka9e8n4NiFcFh4QQm1jEA4FkrJlTL23k5xDALTqFFvysxTLczPJOVyi83QAnmAw6mnYoh7JB05w6nAqNqsNvUHv6bBEJVx//fWsXLmSuXPnljnFzEMPPURWVhb/+te/qF+/PikpKSxdupS9e/fyyiuvXPTL02KxsHLlSvr161fVlyAqKVDXBJ2mDnbnGbIsW1BVJ4ril/ct3U5RCxdX9xXC38WZotiUd5gMax7nLLmEGYM9HZKoBMk5hCksmJjmdTm6P4VDu06Qn2shMFiGTLiD5Byu8duMNzahEapDxW5zkJp04R1V4V0eeOAB0tLSWLFiRZmv9+vXD41Gw9tvv83IkSOZM2cODRo04IsvvmDcuHEXPe7KlStJS0tj5MiRVRW6cBNFUTAZOwDgcGaRZ9vn4YiEEKJQnDmypFjeYRlX7/Uk5xAA8UXj6p0OJ3u2HPFsMMLv+W2jvklCDE574e2c5H2nPByNqKy4uDhuvPFGJkyYQHZ29gWv9+/fnx9++IGUlBRsNhtnz57lhx9+4I477rjoMbOysnj22Wfp0aMHLVu2rMrwhZvIfPVVRMa3CVEpceYonJrCVv0RqYDv9STnEACtz5+vXqa2cx/JOVzit4362OJieU6V5H0nPByNcIeXXnqJ9PR0xo4dW+ljqarKE088wZkzZ3jrrbfcEJ2oDqXnq9/swUh8jIxvE6JS4kyFxfIcUgHfZ0jOIUpVwJdx9e4jOYdL/LZRf34F/ONSAd8nxMTEMH36dBYtWsT06dNdPo6qqkyfPp2FCxfy2muvERsbe/mdRI0QbGiFRikcq5pl+eOScwGLCpC75kJUSlNTOBqKprWTJ/U+QXIOEVEvjMgGYQDs3XoUq8Xu4Yh8hOQcLvHbRn14/dqEhgXjtKskSwV8n3HfffcxYcIEJk2axLBhw8rsFncpWVlZjBgxgsmTJzNjxgyGDh1aRZGKqqAoOkKN7QCwOdKw2I95OCIhhIAArZ7GoXVwaOBI7lnsTqenQxJuIDmHKJ7azmqxcXBHsoejEf7Mbxv1iqIQ2yYG1aFyLjWTnHO5ng5JuMnYsWP5d6+hfPDfD2nZshXLli3DarVech+LxcKyZctISEjgo48+YuHChUyYMKGaIhbuJPPVVwG5ay5EpcWZCovl2Z0OTuRleDoc4Sbjxo1jzos38/FHS2jduqXkHH4m/rwu+Dtlvnr3kJzDJX45pV2x2NaN2PHLHgCO7z9Ji8QrPByRcIeftxxCNceR0HMcJ//6ikGDBjF27Fh69+5Nx44diY+PJzAwkPz8fHbt2sXmzZtLKs726NGDt956S7q/eTFTQCfILPw5q2ATkSF9PBuQL6jMF6Uff8EKcb44cxSrj+8CCovlxYTU9nBEwh1U6xbu7ZVOj2tiGDv5jOQcfuaCcfWjPBiMr5CcwyV+3ahv0iYG1VlcAV8a9b4gKzefJV9sxOEEfXAdVnz2BWHGAubPn8+PP/7I/PnzS42zVhSFFi1a0K9fP0aOHCkVZ31AiOFKFPSo2ORJvbtUpviMHxetEeJ8ceZIVEXBqagczk7nurqSc3g7VS1AzXkNvc5OXDMN3/5vAXuOtJKcw480bBaFqXYwWWdz2b05CafTiUbjtx2h3UNyDpf4daM+9rxieVIB3zd88OUmsvMsWBwKNyY25+p2hXdQX3/9dQBycnI4ePAgFosFo9FIs2bNCAkJ8WTIws20mgBCjG3ItmyhwH4Eq+M0Bm2Ep8MSQvi55kUV8J1SAd9nqHkfgjOF4BALGBIhsDetWimSc/gRRVFo3bkp61dvJycrn6P7UohtWc/TYQk/5NeN+sbxDVAUBadd5fh+mave223ff4KfNh/E6lAICQpg3OB/X7BNSEgIV155ZfUHJ6qVydiRbMsWoLALfnjwLR6OyLspauHi6r5CCKgfZCZYZ8But0ij3geotkOQt5KgAAtarRbF9B8UpfRTQsk5/EPrzk1Yv3o7UDiuXhr1lSM5h2v8un9IYEgg0U2jcDqcnDhwCofD4emQhIssVhsLVq7HqYLdqTB6wL+oUyvY02EJDwk9r1hetkXmq680KVojRKUpikKcOQqHAmmWbHKsFk+HJFykqg7UnFfRam0EGK0oIaNQdE0uv6PwSfGdzi+WJ/PVV5rkHC7x60Y9QGxCI1S7iiXfyulkuXPurVb+uJ2U9GwsdoW2cfW54/oET4ckPMgU0BEofGIi4+qFEDVFnCkKZ9HD3KRcyTmq2vnj2d0q/yuw7yckMB9F3wyCh1fNeYRXaBpfn8BgI1BYLK/K3ndCXILfN+qbJMTgdBT+8R2X+eq90tGTZ/ly3XZsDgWtVsv4oTeh0fhvoQwBOo2JIH0cALnWPdidFZs7WJSm8Hd3uAovng5eiBokzhz5d6M+O92zwfigfzam/tkd3i3ncKSh5r1HgNGKTudEMU1DUQxuP4/wHlqdlhbtGwNwJjWTlGNyw64yJOdwjd836mPbxJR010iWRr3XcTpV3l3xG3a7is0J99/Rmdj6dTwdlqgBTAHFXfCdZFu2ejQWUXFvvvkmjRs3JiAggMTERP7444+Lbrtr1y569+5N48aNURSFuXPnlrndiRMnuPfee6lTpw6BgYEkJCSwebMMzxDVp7k5EhQFhwJJOWc9HY5PUVW1pBH/008/MX78eF555RVWrFhBWlqa286h5sxDo+QRFGCBwP4ohg5uObbwbq07Sxd84Vl+36hv0qYRAE67k+P7pVHvbb7/fS/7j57G4lCIia7N4DsSPR2SqCFM542rzyqQLviVUjy9jKtLBS1fvpxx48YxZcoUtm7dStu2benevftFE/O8vDyaNGnCzJkzqVu3bpnbnDt3jquvvhq9Xs+3337L7t27eeWVVwgLC6twfEK4qrkpEiisgH9EntS7ldPpBGDevHm8+OKLKIrCjh07mDlzJklJSe45ifVXsG4gOLAARRuBEvqke44rvF6p+eo3SaO+Uqo55/AVfl39HiC6SRQBQUbsDrt0v/cyZzJyWfb1ZuxOcKoKzwy9CaPB79/SooipVLE8adRXSmWKz7iw35w5cxg+fDhDhgwBYP78+Xz99dcsXryY8ePHX7B9p06d6NSp8L93Wa8DzJo1i4YNG/Lee++VrIuNja14cEJUQqg+gPpBtTiddY7DOWdwqiqaKugi7m9UVUWr1XLixAkWLVrEW2+9RdeuXZk9ezYFBQV07twZu93OkSNHaNKkiUvziKvOXNSctzDo7Rj0dhTTJBSNqQquRnijuHYx6PRa7DYHO/845OlwvFs15xy+wu+f1Gs0Ghq3bohqV0k9lk5BboGnQxLltHjV7+RZbFgdCrdf35r2LRt6OiRRgxh0URh1hT1xsi1/4VSl0rTL3FCJNisrq9RisZT938NqtbJlyxa6detWsk6j0dCtWzd+//13ly/hyy+/pGPHjvTt25fIyEjatWvHggULXD6eEK6KM0fi0ECBw0Zqfpanw/EJxd3uf/vtN1q2bEnXrl3ZuHEjy5YtY8KECSiKwpYtW1iyZAnHjx936Rxq7mIUNZ3gwAIw3gDG7u68BOHljAEGrmhTmIeeOHyas2nyt+0yqX7vEr9v1APEnl8s74DMV+8N/thxhD92HsNqVwgzBTN6wL88HZKogYqf1qtYybH85eFo/FvDhg0xm80ly4svvljmdunp6TgcDqKiokqtj4qKIiUlxeXzHz58mLfffpsrrriC7777jpEjR/LYY4+xZMkSl48phCtKVcCX+erdqkmTJthsNqCwd06/fv1o06YNADk5OWzbto2QkJAKH1e17oKCrwgKsKDRBqKYplRJET7h3c6f2k664IvqJo16oEmbGFSpgO818vKtLFq1AYcKDlVh3OAbMIcEejosUQOZjB1Lfpap7VznchXaogUgOTmZzMzMkuXZZ5+t1mtwOp20b9+eF154gXbt2jFixAiGDx/O/PnzqzUOIZqbI1EVBRVIypFGvTs1aNCA7OxsbrzxRjIzM3nmmWeAwrobr7zyCjfeeCO1a9cuGX9fHqpqRc19DZ3WQYDRhhIyFkVbr6ouQXix1p2blvy8S4rlucwdOUdFVaQ4L8Cnn35KixYtCAgIICEhgW+++abU66qqMnnyZKKjowkMDKRbt24cOHDAteDKSRr1QGxRsTzVoUqj3gt8tHoLZzPzsNoVurRpTLcucZ4OSdRQf1fAh6wCqXLuMjd0hTOZTKUWo9FY5qnCw8PRarWkpqaWWp+amnrRInjlER0dTatWrUqta9myJceOHXP5mEK4Is5c2AvFoYHDOVIsrzKKp7A7duwYVquVunXrMmPGDOrVq4fdbue9997jvffeY+zYsej1esaMGQNUcKq7vBVgP0JwUAHoWkPQvVVwJcIXtOoYW/Le2ilP6l1Xzd3vK1qcd/369QwYMIChQ4fy559/0qtXL3r16sXOnTtLtnnppZd4/fXXmT9/Phs3biQ4OJju3btTUFB1w7ylUQ/EJhRVwHeoJEsF/Bpt/9E0vvttD1aHgtGo5+kh3aQLnLioAF0sek04ANmWLaiqw8MRealq/II1GAx06NCBNWvWlKxzOp2sWbOGrl27unwJV199Nfv27Su1bv/+/cTExLh8TCFcERNcG6NGh1OBpGyZ1q4yFEXhr7/+YuzYsXz22WekpqbSoUMHxowZw0033cR///tfPvnkE1q2bMlrr70GgN1uL3feoNqPo+YtJdBoRadVUMzTURRtVV6S8GKhtYJo3CIagKTdJ8jNljpdLqnmRv35xXlbtWrF/PnzCQoKYvHixWVu/9prr9GjRw+eeuopWrZsybRp02jfvj3z5s0rDF9VmTt3LhMnTuTOO++kTZs2fPDBB5w8eZLPP/+84gGWkzTqAVPtUMLr10a1Fz6pL77zK2oWu93BO5/+hsMJdicM73019SLNng5L1GCKopQ8rXeoOeTa9no4IlEe48aNY8GCBSxZsoQ9e/YwcuRIcnNzS6rhDx48uFT3favVyrZt29i2bRtWq5UTJ06wbds2Dh48WLLN2LFj2bBhAy+88AIHDx5k2bJlvPvuuzzyyCPVfn3Cv+k0GpqZInAqcDLvHAV2m6dD8jrnd5/PzMxk//79zJ49m5kzZ7Jp0ybat2/PxIkT+b//+z+WLVvGmDFjaNy4MQA6XflmySmck/51NBoLgQEWCB6Com91+R2FXyue2s7pVNmzJcnD0fivqizO+/vvv5faHqB79+4l2yclJZGSklJqG7PZTGJiYqUK/l6ONOqLxLaJwelwkpuVz9mUDE+HI8rwv592cuzUOawOheaNo+jXo72nQxJeoNTUdjJfvUuqe3xbv379mD17NpMnT+bKK69k27ZtrF69uqR43rFjxzh16u+ipidPnqRdu3a0a9eOU6dOMXv2bNq1a8ewYcNKtunUqROrVq3io48+onXr1kybNo25c+cyaNCgSv9+hKioOHMUDqXwodLRXHla76rp06ezatUq+vXrx6hRo9i2bRvPPvssCxYs4PDhwu7PYWFhrh284AewbSMksABF1wAleLQbIxe+6vxieTtlXL1L3JFzVGVx3pSUlEtuX/z/7i74ezkyqXeRJgmN2PzdnwAc33eCOtEufgmIKpGSnsWn32/D7lQADc8OvQmdVu5JicsLPX9cvWUT0TzguWC8laoULq7u64LRo0czenTZSfS6detK/btx48bl6mF12223cdttt7kUjxDuFGeOLFUBv3icvSgfjUbD0aNH+fTTT/noo49K6mXce++9TJs2jVdeeYU9e/Zw++23c80112AwGCp0fNWZgZr7LkaDDb3egWJ6HkUTVBWXInxM6WJ5Ml+9S9yQcyQnJ2MymUpWX6yOjy+RVlGRJm1iUJ2ACsf3ybR2NYmqqry78jcsNgdWB9zToz0tm7heMEv4l2B9C7RK4RRGWQWbZHiNK6p5fJsQvi7OFAmKUjiuXirgV0hx1/tTp05Rq1atkn9bLBYMBgPTpk2jQ4cO/PHHH8yYMYO1a9dW+BxqznwUMgkKsEDA7ShGmTZXlE+dumbqNqoDwL6/jmG12D0ckReq4cV569ate8nti//f3QV/L0ca9UVi2xQWSyoslnfCw9GI8/285RA79p/C6lCoW8fEiD5XeTok4UUURUuosQMANmc6BfYjng1ICOH3ip/MS6O+fJxOJ7t37wYKn9IDxMTEoNFo2LSpcFiV0WjEbi9sQF1zzTVMmTKF6667jqeeeork5ORyn0u1bgHL/xEcWIBGa0IJneDmqxG+rnhcvc1iZ/9fMsNKTeZKcd6uXbuW2h7ghx9+KNk+NjaWunXrltomKyuLjRs3Vqrg7+VIo75Iw7h66PRaVLtTntTXIFm5+Xzw5UYczsI56Z8a0o2ggIp1oxPCFCDz1VeGJ+aMFcKX1TYGE2EMwaFAUna69CC6jAULFjBlyhQ+/vhj0tMLpwGMjo5m8ODBzJw5k0mTJmG1WtFoNKSmprJixQry8/MZNmwYtWvXJiMjo1znUdUC1JzX0OvsGA12lNBnULR1qvDKhC+SLviVU905R0WL8z7++OOsXr2aV155hb179/L888+zefPmkiGDiqIwZswYpk+fzpdffsmOHTsYPHgw9erVo1evXu74FZVJxtQX0el1NGrZgKP7kjl5OBWr1YbBoPd0WH7vgy83kZVrweJQuDGxOVe3a3L5nYT4h/OL5WUVbCIq5B4PRuOFKtONXtoqQpQpzhzJhrxssmwFnLXkUScg2NMh1VgdO3Zk586dfPLJJ+zatYubb76Za6+9liFDhlC7dm3mzZtHx44dadGiBenp6URERHDnnXeSkpKCqqoXrXz9T2reh+BMITjEAoZECOxdxVcmfFF85/OK5W06TD8PxuKVqjnn6NevH6dPn2by5MmkpKRw5ZVXXlCct7iHEMBVV13FsmXLmDhxIhMmTOCKK67g888/p3Xr1iXbPP300+Tm5jJixAgyMjK45pprWL16NQEBAS5e2OVJo/48sW0acWT3MZwOJ6cOpRLTsoGnQ/Jr2/ef4KfNB7E6FEKCAhg3+N+eDkl4qRBjWxQMqFjJtmz2dDjepzJP3KVRL0SZmpuj+C218CleUk66NOovoUOHDnTo0IH333+fr7/+mgMHDrB//35uvfVW7rzzTq655hp++ukn9u/fT4cOHejYsbB31ksvvUSjRo1K/n0pqu0Q5K0kKMCCVqtFMf2n3PPZC3G++rER1AoPISM9h92bk3A4nGiluHP5eSDnqEhxXoC+ffvSt2/fix5PURSmTp3K1KlTXQvIBfIOO0+ThBic9sJ3w/F9Jz0cjX+zWG0sWLkepwp2p8LoAf+iTi1JeIRrNIqREGMbAArsR7HaUy+zhxBCVK04UySqoqACh7NlXP3FOByOUj87nU6OHTvGW2+9xcyZM1mzZg2hoaHcfffdjB8/nptuugmNRsPSpUv/n737Do+qSv8A/r3T02YoadQUkAAhdIjo2hZUWBv+otJWgQVcRUQEV0GzwNoQUcQCIiC67oKiYFndlaWsyCq9LZBQRFpCGklIT2Yy957fH0OGDKROyWQy38/z3Gdxcufed9gh875zznkPjhw5goULF9Z7DyFkiJK3oFZXwqC3QAqeCknDmYHkHEmSED/INgW/rLgCZ46xpiDPY1FfTVWzPKEIFvVetmHLYWTlFsNsldAnrgPuvTXB2yGRj3OYgs919Y3D7vdEbufQLI9Ffa2qpr3OmjUL27dvx7x587Bjxw4kJycjIyMDr776Kt5//30cPnzY/hyDwYB+/frhnXfeQfv27eu/Sfm3gPUkggPKIWm7AkFTPPVyyE/0qjYFn+vqG4k5h1NY1FcTk9AZACCsAmknWdR7y7mMfPxj22FUyhLUajVmT7odKhWnwJFrjAYW9U7jByyR23UJCYW6alu7Uhb1tZEkCdnZ2Th06BDGjx+P3r1ts67uv/9+fPDBBwgLC8Onn36Kt99+276FlF6vR8+ePdGjR496ry/kHIiyj2DQW6DRKJCML0KS2JCXXFO9qD+657QXI/FBzDmcwqK+mrbtWsPYNgSKzJF6b1EUgRXrf4bVKlCpAOPvHYyYDuw8S64L0fcHYPtyqKiCRX1jsPs9kfvp1BrEhoRCVgFpJfmoVOT6n+Sn2rZti4iICOzZswcAYLVaIcsyWrdujd/97neIjY3Frbfeam9s1VBCCIiSpVBJZbY96QNGQ9LVv/6eqD4xPTsgINi2N3rK3tPc4aIRmHM4h0V9NZIkIbZ3ZwhZoOBiEYryi70dkt/ZtPM4Tp67CLMsIapdGzxyb6K3Q6IWQqMyIkjXEwBQVnkCVqXIyxERkb+LM0ZAkQCrUJBeWuDtcJolRVGgVqsxYMAAfPvtt9i5cyc0Gg3UajUAwGg04rrrrsOYMWPs5zeY5SfAshNBARWQ1GGQQp7xxEsgP6RWqxA/MAYAcOliMTLO5no5ImrpWNRfJYbN8rwmr6AUa/+5D1YFUISE5ybdDr2OGzSQ+1xZVy9QVMEu+ETkXd1M4ZAvry47U8Kkv0r1UU2VSgVJkjBr1izccsstmDRpEl544QVs3rwZH3zwAV577TV07doVGo0GQgiHrafqvIdSClGyDDqtFTqtFZIxGZLK6KmXRH4ovtp+9Ue5rp48jEX9VWJ7R0EoVUV9ppej8S8ffb0L5eZKWGQJ99zaC/17dPJ2SNTChOivTKss5rr6huP6NiKPiDOGA1Xr6tksz65qK7njx49j3bp1WL16NTIyMjBnzhy8+eab+N///ofXXnsNmzZtwn333YeHH37Y4XkNIUpXQxK5CAqoAPS3AfrhHnkt5L96DareLI/r6huMOYdTOAx6FYdmeScueDka/7HnyFnsPnIOZquE1sYgTBtzs7dDohbIsVkeR+obypV1av68vo2oPuyAfy2r1QqNRoOvv/4aK1asQKtWrZCXl4f33nsPH3/8MUaMGIERI0bg9OnT6NSpk31kXpZl+5T8+ghLClDxHQIDzFCpAyAZ53FPenK7bn06Q6NTw2qR2SyvEZhzOIcj9VeJiu8ESZKgyOyA31TKyi348KtdkAUgCwlPP3wrTMEB3g6LWiCdOgwGTTQAoMR8GLJS4d2AfAm/MSdyu8gAI4xag62oL2FRL4SARqNBaWkpXnrpJTz66KNYu3Ytxo4dizZt2qBLly625nZCIDY2Flqt1l7UN7igFxaI0rehUVth0FdCCp4BSd2Abe+IGkln0CKuTxQAIPNcLvKzC70ckQ9hztFoLOqvYgjUo8N1kVBkBRm/ZEKW2Y3W0z7buB/5hWWwWCVc3zsatw/p7u2QqAWrWlcvUIkSy/+8HA0R+TNJkhB3eV19rrkERRb//qKxarT8u+++Q7du3TBy5EicO3cOb7/9NpKTkxEUFIQdO3Zg9uzZ9u3rGj3CXrYesJ5FUGAFoOkFBD7s7pdBZMet7aipsKivQUzvKAirgMVsRc45Nq7xpJPncrDx52OwyBL0ei2enTiMU+DIoxym4HNru4bh+jYij+l2uQM+AJxlszwAQLt27WCxWAAAL7/8MoYOHYpbb70VAKDVanHy5ElUVlY2+rrCmg5RtgYBegs0agmS6WVIUsNG+ImcEV+9qN/Lor5BmHM4hUV9DWIToqDItndFGjvge4zVKuODL36GrABWBZiSdAPah5u8HRa1cFc64LNZXkNxz1giz4kzhduL+tMl+d4Nppno2rUrAODxxx/H4cOH8eKLL9p/9u6776JXr17o2LFjo/b+tu1J/w5UKjMCDGYgcAIkbU+3x05UXc8BMfbBqhR2wG8Q5hzOYVFfg5iEzoAAhCK4rZ0Hfbc9BeczL8EiS+gWFY5Rwwd4OyTyA3pNZ2jV4QCAIvMBCGH1ckQ+gN+aE3lMnCkCkCTIEnCmmCP1Qgi0b98e9913H3799Vd07doVP//8M3bu3Im5c+fi7NmzmDt3rv3cBqvYDFQeQnBABSRNR0jBT3roFRBdEWQMQExPW8+GM8cyUVJY5uWIfABzDqewqK9BbG9bUwshC6SdZAd8T8jKLcIX/z4IqyIBUGHO5DugUfPtSJ4nSZJ9tF4RpSi1pHo5IiLyZ9cZbV8yKhJwlh3w7aOav//97zF58mRoNBosXLgQf/zjH1FRUYE33ngDWq0WVqu1EXvSF0CUroBeVwmtVoZknA9JFejJl0FkV7W1nRACqfvOeDkaaqm4pV0NIqLDEBBsQKVcyZF6DxBCYMWGn2GulGGRJYwe3g89YiO9HRb5EaN+EPLK/gkAKDLvRbC+t5cjat64vQyR5wRpdOgc1BqZRfk4W5IPRQio/Ly3jKIoUKlUeOihh3DLLbdAURSUl5cjNvbK+mSNpuEprChZDgmFCDSYAcPdkPTcNpeaTq/BXfCPj/8LwNYsb/DQeC9H1Lwx53AOh0ZroFKpEJPQGcIqcDE9H2Ul5d4OqUXZfuBXHDmZCYssIbKtEY8+eKO3QyI/w2Z5jcSpcEQe1c1oW1dfoVQis4zbXqlUKvvU+oiICLRr186hoG8MYdkPmP+DoIAKqNRGSCHPuzNUonpVb5aXwg749WPO4RQW9bWIqdYs78LJTC9H03IUlZbjk292Q1Zse9L/aeIwBBp03g6L/EygthvUUggAoMi8v3HrMv0RP2CJPCrOdKUDvr/sV1/f71137IQjRAVEyTvQaqzQ66yQQp6DpA51+bpEjdEm3Ij20bb33cnD52GusHg5omaOOYdTWNTXIiahMwQ74LvdJ//Yi6JSM8yyhKGJ3XBjP+e+eSdyhSSpYTQMBABYlTyUW/nNORF5T5wpAkKSIOA/zfKqivYDBw7g/fffx8KFC7F9+3b7/vPuIMr+DiiZCAowA9rBQECS265N1Bi9ErsAAKyVMk4cOu/laKglYlFfi+rN8riu3j2O/JKBH/edgkWWEBxowNMP3+btkMiPhVTf2o5T8OvE7WWIPCvOZGuWJ6v8Y6TearXtOvLvf/8bf/rTn3Dw4EEcPXoUU6ZMwdGjR91yD1H5K1C2AYF6M9RqNSTTi24Z/SdyRi9OwW8w5hzOYVFfi5iEzgAAhR3w3cJsqcSK9T9DEYBVkTBtzM0IbR3s7bDIj1Xfr76I+9XXjVPhiDyqU1BrBKi1UCTgTHHL36teo9FAlmXMnz8ff/zjH7FixQqMGzcOERER6N+/PwAgJyfH6esLIUOULIFaXQmD3gIpeCokDWcGkvfED+pi//NR7ldfN+YcTmFRX4vgVkEI7xwKYRVIP5HJNbcu2rDlMLJyi2G2SujdrT3uvTXB2yGRnwvWJ0Al6QGwWV69+AFL5FFqSYXrjGGQJSCzvABl1pa/5vbHH39EREQEHnzwQWRlZSE5ORnPPfccWrdujZSUFCxatAgnT5507uLl3wLWEwgKqICk6QIETXFv8ESN1C6qLdqEGwEAx/afhWyVvRxRM8acwyks6usQ2zsKiqygvKQCeRmXvB2OzzqfeQn/2HYYlbIEtVqNOZPugErFKXDkXSpJh2BdXwCAWU6H2cqGmETkPd2MtmZ5AsD5kpY/Wh8VFQWLxQJJkvDGG29g8ODB+N3vfgcAUKvVSElJgaIojb6ukHMgyj6CQW+BViNDMr0ESWJDXvIuSZLsU/DLS804ncqlveReLOrrEN2rMxRrVbM8TsF3hqIIfPDFT7BaBSoVYPy9gxHTsa23wyICcNXWdpyCXyuubyPyvDhTuL0D/mk/WFcfGRkJk8mEBx54AFu2bMHChQshSRKEEHjrrbdw3XXXoXv37o26phAComQpVFKZbU/6gNGQdAM99AqIGid+MKfgNwRzDuewqK9DbO8o+1QOdsB3zqadx3Hy3EWYZQmd27XBI/cmejskIjuHdfWcgl87ToUj8rg4UwQgSZfX1be8DvhVo+5ZWVkoKipCUFAQnnzySQQEBKBdu3b44osvsGnTJsyePRupqal4+eWXHZ7XIJafAMtO27R7dRikkGc88VKInOLQLG8vm+XVijmHUzTeDqA5i+19pVle+kkW9Y2VV1CKT/+1D1YFUISE2ZNuh17Htxw1HyH6frB9t6mgmCP1tXLl229//tacqDG6GS93wJeAsy1s+r0sy1Cr1UhPT8err76KESNG4Pbbb8cNN9wAAPjuu+/w2WefIT8/H7/73e/w+uuvIyQkxP68hhBKKUTJMui0Vui0VkjGZEgqoydfFlGjRMW1Q5DRgNKiChzdcxpCCO7IUAPmHM5hhVWHjt3aQ6vTQFgVpB1nUd9YH329C2UVlbDIEu65tRf69+jk7ZCIHKhVwQjS9USp5SjKKk+iUi6AVt3K22E1P658++3HH7BEjdFaH4gIQwguWYtwpji3RSX8VYX5rFmz0KFDB1x//fUwGAwAgL59+9qL++zsbERERFzzvIYQZashiVwEBVQA+tsA/XA3vgIi16nVKvQcGIu9/0lFYV4JLpzOQccuEfU/0d8w53AKp9/XQa1RIyq+ExRZIPtsDizmlt+N1l32HjmH3UfOwWyV0NoYhGljbvZ2SEQ1qj4Fv9i8z4uRUHVLly5FdHQ0DAYDEhMTsWfPnlrPTUlJQVJSEqKjoyFJEpYsWVLntV977TVIkoQZM2a4N2giF3UzhUNWAcVWM3IrSr0djltU7R70/fffIzs7GwsWLEBYWBhOnz6N6dOn4/7778fTTz+NsrIyh4K+UfewpADl3yHQYIZKHQDJOK/FfCFCLUuvQVem4B/ZzSn45D4s6usR09vWLE9RBDJOZXs7HJ9QVm7Bqq92QhaALCQ8/fCtMAUHeDssohqxWV4DNPH6tnXr1mHmzJmYN28eDhw4gD59+uDOO++sdd/qsrIyxMbG4rXXXkNkZGSd1967dy8++OAD9O7du/GBEXlYnCnC3izvTEnLWFdfVVyfP38eUVFR0Ov12L59O5YsWYKsrCxMnDgR+/btw759zn2pKoQFovRtaNRWGPSVkIJnQFK3d+dLIHKb+Orr6tksr2ZcU+8UFvX1iOkVBSGzA35jfLZxP/ILy2CxSri+dzRuH9K47rVETSlEf6UzMpvl1Uxy8WisxYsXY8qUKZg4cSJ69uyJ5cuXIzAwEKtXr67x/EGDBmHRokUYPXo09Hp9rdctKSnBuHHjsHLlSrRu3dqJyIg8K84YASFJEADOFLesDvj9+vVDTk4OZs6ciaeeegpdu3bFkiVLMHr0aHTt2hWnTzs5alm2HrCeRVBgBaDpBQQ+7N7Aidzout6dodXbVj8fZbO8GjV1ztFSsKivR1WzPKEIpLMDfr1OnsvBxp+PwSJL0Om0eHbiME6Bo2ZNpw5FgMb2zXmp5ShkpczLETVDbvjWvKioyOEwm8013spisWD//v0YNmyY/TGVSoVhw4Zh586dLr2MJ554AnfddZfDtYmakziTrVmeIgFnWti2dgkJCbj33nsRHh6OmTNnYvr06Wjfvj3OnTuHo0ePom/fvgCuTNdvCGFNhyhbgwC9BRq1BMn0MiSp4evwiZqaTq9BXN8oAEB2Wj4uZhZ4N6DmiCP1TmGjvHrE9rb9wxNWwW3t6mG1ylixfgdkBbAqwOMP3ID24SZvh0VUL6NhMMpLTkPAihLzIZgCbvB2SC1Op06OjTLnzZuH+fPnX3Nebm4uZFm+Zm1tREQEjh8/7vT9P/vsMxw4cAB793I2BjVfMSGh0EoqyCrZp4v6q5v8Xbx4EWFhYXj88cehKApUKtuYUkpKChYsWIDbbrsNffv2bVRzQNue9O9ApTIjwGAGAidB0vb0yOshcqeExC44uts29T5lz6+49b4BXo6IWgIW9fVoHdEKrcJNKCkuQfrJTG+H06x9tz0F5zLyYZEldIsKx6jh/CVFviFEPwjZJZ8BsK2rZ1HvyB3by6SlpcFovLK9VF3T5N0tLS0NTz31FDZv3mzvuE3UHOlUasSEhOLMpWyklV6CRbZCp/a9VK2qOP/666+xbds2pKamIioqCrNmzUL37rYleRcuXMBnn32GVq1a4ZVXXnF4XoOYNwOVhxAcVAFJ0xFS8JOeejlEblV9Xf3RPadZ1F+FW9o5h9PvGyD2crO8orxiFOYWeTucZikrtwhf/PsgrIoEQIU5k++ARs23F/kGNsurhxumwhmNRoejtqI+NDQUarUa2dmOjUmzs7PrbYJXm/379yMnJwf9+/eHRqOBRqPBjz/+iHfeeQcajQayLDt1XSJPqGqWJwsF6aWXvB1Oo8myDJVKhePHj2PhwoVo06YN5s+fjz179mDs2LFYtGgR8vPz0aFDBzz11FOYO3cutFqt/XkNIZQCiJIV0OsqodXKkIzzIakCPfzKiNyjR/9oqFS2L69S9nBd/TU4/d4prLoaIKZX52rN8jgF/2pCCKzcsAPmShkWGXjozn7oEetc8k3kDXp1B+jU7QAAxeaDUESllyNqhprow1Wn02HAgAHYunWr/TFFUbB161YMGTLEqdCHDh2KI0eO4NChQ/Zj4MCBGDduHA4dOtSovbCJPC3OFA758mD1aR+cgl/172n+/Pm46667MHfuXOh0OhgMBkyYMAGffvoppk2bhu+//x6hoaEIDw93eF5DiJLlkFCIQIMZMNwNSc9tc8l3BAYb0CW+IwDg7IlMFBe0jO0r3YoFfaP53pwuL4jpHQWhXCnqe93Ibu7VbT/wKw6fzIBFlhDZ1ohHH7zR2yERNYokSTDqByK37FsoohylllSE6Pt4Oyy/NXPmTIwfPx4DBw7E4MGDsWTJEpSWlmLixIkAgEceeQQdOnTAggULANia66Wmptr/fOHCBRw6dAjBwcHo2rUrQkJC0KtXL4d7BAUFoW3bttc8TuRtccYIQJKgSMJnO+AfP34cRqMRDz9s60T/l7/8Bb///e/x5JNPwmKxYOXKlThy5AhuuukmBAcHN+rawrIfMP8HQYEVUKmNkEKe98RLIPKo+MGx+OVIGgAgZe8ZXH87P4vINSzqG6B6szx2wHdUVFqOT77ZDVmx7Un/zIShCDTovB0WUaMZDYOQW/YtANsUfBb1VzT1+rZRo0bh4sWLmDt3LrKystC3b19s3LjR3jzv/PnzDtN0MzIy0K9fP/t/v/HGG3jjjTdwyy23YNu2bc4FTuQlcSbb+9yXO+CHh4dj2LBhMJlM9lk3999/PwBg8ODBCAwMRFJSEoKDgyHLcoNH6YWogCh5B1qNFXqdFVLIs5DUoR57HUSe0mtwLL7+8EcAtin4LOqv4Jp657Cob4Conh2hUklQZAXpJ1nUV/e3b/eiqNQMsyxhaGI3/KZ/F2+HROSUEP2VdfXFFXsB42QvRtPMuDKtzcnnTZs2DdOmTavxZ1cX6tHR0Y3aBqumaxA1F+GGYLTSBaDcWuazRX2bNm3wwAMPQKVSITAwEBaLxd6kcvfu3Th27BimTp0KoJHT7sv+DiiZCAo2A9rBQMADHomfyNPiB1Vrlrf3Vy9G0gx5IedoCVjUN4DOoEPHuPa4cDoTGacyIVtlqDVcg3nklwxs23sKFllCcKABTz98m7dDInJaoPY6aFQmWJVCFJn3QQgFksS2IwC/NSdqSpIkoZsxHAfKzyLfXIoCSxla6Zp3E7iq0XZFUSBJEgoKCtC6dWsAtu0oL126hAkTJiAqKgrbt2/Hp59+CgAO29vVR1SeBso2INBghlqthmR6seGd8omamVahIejYJRzpv+bgl8NpqCi3wBDAma4Acw5nMWNtoJgEW7O8SouMrLM53g7H68yWSqxY/zMUAVgVCU+MvgmhrRu3Lo6oOZEkFUL0AwEAVuUSyiv5zTkReUdVB3wAOFOc791g6mG1Wu0F/euvv45Ro0bhySefxIwZM5CdnY3Y2Fh89tln6NGjB1q1aoU333wTvXr1alxBL2SIkregVlfCoLdACn4ckia2/icSNWO9Lo/Wy1YFJw6e83I05OtY1DdQTEIUFHbAt/tyy2Fk5RbDbJXQu1t73Hdbb2+HROQyo7761nZ7vBhJM8PtZYiaVPWi/mwznYJfWlqKvLw8aDS2SZ/PPPMMduzYgT59+uCmm25CRkYGhg0bhk8//RSxsbFYtGgRXnrpJdxxxx0A0LhR9vJvAesJBAVUQNJ0AYIe9cRLImpSDvvV7+ZAgh1zDqdw+n0DxfaOAgQgFIG0Exm4/q4B3g7Ja85nXsI32w6jUpagVqsxZ9Id9v02iXyZw371FXsRGTLOi9E0H5wKR9S04ozhgCRBlgTOFOd6O5wavf766ygqKsLYsWPRqVMnpKen47XXXkPPnj0BACNHjsSnn36Kjz/+GNdddx0GDhzoMDLf0KJeyDkQZR/BoLdAq5EhmV6CJHGaMvm+XoOv9KE6yv3q7ZhzOIcj9Q1k74AvC1zw42Z5iiKwYv1PsFoFKhXgkXsHI6ZjW2+HReQWQbp4qCRbM6ci814vR9OM8FtzoiZ1nTEcEmwd8E83023tOnbsiMzMTLzzzjvYsGEDgoODodNdKbYjIiIwbtw4qFQq/Oc//3HqHkIIiJKlUElltj3pA0ZB0g1010sg8qqITm3QNtIEADh24CyslbKXI2ommHM4hUV9A4V3DkWgMQCKVfj19PvNu47jxNmLMMsSOrdrg/H3Jno7JCK3UUk6BOtsW6NZ5ExUWC94OSIi8kcBGi2igttAVgHnSvMhC8XbIV1jypQpWLBgATp16oRNmzZhx44d+Oabb2C1Wu3nhIWF4eabb8a5c+cgy04ULJafAMtO27R7dRikkD+58RUQeZckSeh1eQq+udyCX1PSvRwR+TIW9Q0kSZK9WV5exiWUFpV5O6Qml1dQirX/3AerAihCwuxJt0Ov4woOalmqT8EvruBoPQB+a07kBXFG27p6i2JFRlmht8OpUUxMDF599VU8+eSTGDx4MP71r39h8eLFOHz4MADg+PHj+O6773DDDTfYm+k1lFBKIUqWQae1Qqe1QjImQ1IZPfVSiLyiVyKn4F+DOYdTWNQ3Qmy1ZnnpJzO9HE3T++jrXSirqIRFlnDPrb3Qv0cnb4dE5HaOzfJY1ANX1rc5exBR43Uzhdub5TXXKfhVhg0bhrfffhsjRozAzz//jOnTp+Pee+/F4sWLMXLkSIwbZ+tP0tBu9wAgylZDErkICqgA9LcB+uGeCp/Ia6qvq0/Zw2Z5AHMOZ7Gob4SY3lEQ9g74/jUtd++Rc9h95BzMVgmtjUGYNuZmb4dE5BEh+n6QLvcQZVF/Gb81J2py3U0REJIERQLOljTPZnnVtW7dGs888wyef/559O7dGxcuXEBkZCSmTp0KAI0bpbekAOXfIdBghkodAMk4j3vSU4vU+boIBJsCAQApe8806t9Ji8Wcwyks6huherO89BP+M1JfVm7Bqq92QhaALCQ8/fCtMAUHeDssIo9QqwIRpIsHAJRXnkKl3Lz3iG4KkhAuHUTUeHGmCAC2ZnnNfa/66hITE/Hmm29i/Pjx6N+/P4KCgiCEaMSe9BaI0rehUVth0FdCCp4BSd3ew1ETeYdKpUL8oBgAQNGlUqSdyvFyRN7HnMM5LOobIbqXbbq5YhVIP+k/I/WfbdyP/MIyWKwSru8djduHdPd2SEQe5bC1nXmfFyMhIn/VIbAVAtXay0V98x+pr06r1WL69OkYOXJk459cth6wnkVQYAWg6QUEPuz2+IiaE07BJ3dgUd8IQcZAREaHQZEVpJ/M9IspMr+cz8HGn4/BIkvQ6bR4duIwToGjFs9hXT2b5XEqHJEXqCQJ3UzhkCUgq6IIpZUWb4fktAbvSW9NhyhbgwC9BRq1BMn0MiRJ7eHoiLwr/nIHfAA4upfN8phzOIdFfSNVrauvKDUj94LvTIdzhtUq44MvdkBWAKsCPPrADWgfbvJ2WEQeF6K/sg9yMdfVs2kNkZdUdcAHgLMlzbtZnqtse9K/A5XKjACDGQicAEnb09thEXlc114doTdoAQAp7IDPnMNJLOobKTYhCoq1qlley96v/rvtKTiXkQ+LLKFbVDhGDR/g7ZCImoRW3RoB2usAACWWFMhKqZcj8jJ+a07kFXEm/ynqYd4MVB5CcEAFJE1HSMFPejsioiah1WnQvX80ACDnwiXkXLjk3YC8jTmHU1jUN1JM7yj7mya9BRf1WblF+GLTQVgVCYAKcybfAY2abxfyH0b7aL2MYvNBr8ZCRP4pzhQOXO6Af6YFF/VCKYAoWQG9rhJarQzJOB+SKtDbYRE1mfhB1abgc109OYFVWiPF9u4MAFCsCtJOtsyiXgiBlRt2wGyRYZGBh+7shx6xkd4Oi6hJcb/6KzgVjsg7rjOGAwBkCTjtY83yGkOULIeEQgQazIDhbkh6bptL/qVX9XX1u/27qGfO4RwW9Y3UvmskdAYtFFkgvYXuVb/9wK84fDIDFllCZFsjHn3wRm+HRNTkHDrg+3uzPE6FI/IKky4A7QKMlzvg50G0wO2ahGU/YP4PggIqoFIbIYU87+2QiJpc9/7RUF2eEXvU39fVM+dwCov6RlKr1YiK7wQhC2SfzYW53He70dakuLQCn3yzG7Ji25P+mQlDEWjQeTssoian13SA7vLeyCWWg1BEy/q33hj81pzIe+JMEZBVQJlsQU5FsbfDcSshKiBK3oFWY4VeZ4UU8iwkdai3wyJqcgFBenTt1REAkHYqG4X5JV6OyHuYcziHRb0TqprlCSFw4ZdMb4fjVp98uwdFpWaYZQlDE7vhN/271P8kohaqarReEWaUWo56ORoi8kdxxnB7s7wzxS1rXb0o+zugZCIowAxoBwMBD3g7JCKvqT4FP4Vb21Ejsah3Quzlbe0AIL0Fras/8ksGtu09BYssITjQgKcfvs3bIRF5lVE/2P5nv56Cz6lwRF4TZ4qAkCQItKxmeaLyNFC2AYF6M9RqNSTTiw3ez56oJeqVeGUgza+3tmPO4RQW9U6IudwsT8iixWxrZ7ZUYsX6n6EIwKpIeGL0TQhtHeztsIi8ymFdPZvlcRockRd0M9ma5bWkDvhCyBAlb0GtroRBb4EU/DgkTWz9TyRqwRw74PtxUQ/mHM5gUe+EmITLHfBl0WJG6r/cchhZucUwWyX07tYe993W29shEXldgKYLNKo2AIBi834IoXg5Ii8RwrWDiJwWHdwWWpUasgo401I64Jd/C1hPICigApKmCxD0qLcjIvI6Y+sgdL7OttvUqaPpKC81ezkiL2mmOUd+fj7GjRsHo9GIVq1aYdKkSSgpqbv3QUVFBZ544gm0bdsWwcHBSEpKQnZ2tsM5kiRdc3z22WeNjo9FvRNahZnQJrKVfaTe17vRns+8hG+2HUalLEGtVmPOpDugUnEKHJEkSfb96q1KIcoqT3o5IiLyN1qVGl1DwqBIQHpZASyy1dshuUTIORBlH9n2pNfIkEwvQZLYkJcIuLKuXpEVHD9w1rvBkINx48YhJSUFmzdvxnfffYft27fj0Ufr/kLy6aefxrfffosvvvgCP/74IzIyMvB///d/15z30UcfITMz036MHDmy0fGxqHdSTG9bs7ySS6UoyCn0djhOUxSBFet/gtUqUKkAj9w7GDEd23o7LKJmw2gYaP+zv07BZydaIu+KM4VDlgBFCJwvzfd2OE4TQkCULIVKKkNQQAUQMAqSbmD9TyTyE/GDOQW/OeYcx44dw8aNG7Fq1SokJibiN7/5Dd5991189tlnyMioedZ2YWEhPvzwQyxevBi//e1vMWDAAHz00UfYsWMHdu3a5XBuq1atEBkZaT8MBkOjY2RR76TYhM4Qsm0qbtpJ3+2Av3nXcZw4exFmWULndm0w/t5Eb4dE1KyE6K+sqy/212Z5bFpD5FVxpohqHfB9t6iH5SfAstM27V4dBinkT96OiKhZ6TW4WrM8f+2A74aco6ioyOEwm11byrBz5060atUKAwde+RJy2LBhUKlU2L17d43P2b9/PyorKzFs2DD7Y927d0fnzp2xc+dOh3OfeOIJhIaGYvDgwVi9erVTs8BZ1DsppncUhAJAAOknLng7HKfkF5Zi7T/3waoAipAwe9Lt0Os03g6LqFkJ1sVDJQUCAIrM+3x+uY0zJMW1g4hc080YDkgSFAk47aPr6oVSClGyDFqtFTqtFZIxGZLK6O2wiJqV8A6tEd6hNQDg+IGzqLT49nIbZ7gj5+jUqRNMJpP9WLBggUsxZWVlITw83OExjUaDNm3aICsrq9bn6HQ6tGrVyuHxiIgIh+e8+OKL+Pzzz7F582YkJSVh6tSpePfddxsdIys4J1U1yxOyQJqPNsv76KtdKKuohEWWcM8tvdC/Rydvh0TU7EiSBiH6fiis+BkWOQtmazoMWv5bIaKmE2eKAHC5A36pjxb1ZashiVwEB1QA+lsB/XBvh0TULMUPjkXOV/thrqjEqaPp6NE/2tsh+Zy0tDQYjVe+NNTr9TWeN3v2bCxcuLDOax07dsytsV3tz3/+s/3P/fr1Q2lpKRYtWoTp06c36jocqXdS5x4doVKroMgK0n1wW7u9R85h15FzMFsltDYGYtrYm70dElGzZdT7+dZ2nH5P5FWh+iC00QdClnxz+r2wpALl3yHQYIZKHQDJOI970hPVole1re38cr96N+QcRqPR4aitqJ81axaOHTtW5xEbG4vIyEjk5OQ4PNdqtSI/Px+RkZE1XjsyMhIWiwUFBQUOj2dnZ9f6HABITExEenp6o5cMsKh3kk6vRefuHaBYBTJ/zYa10nemx5RVWPDhVzshC0AWEp5++DaYggO8HRZRs+W4X/0eL0biHc2xaQ2RP5EkCXFG27r6AksZLplLvR1SgwlhgShdAo3aCoO+ElLwDEjqDt4Oi6jZiq+2rv7I7l+9GIl3NGXOERYWhu7du9d56HQ6DBkyBAUFBdi/f7/9uf/5z3+gKAoSE2vuRzZgwABotVps3brV/tiJEydw/vx5DBkypNaYDh06hNatW9f6RURtWNS7IKZ3ZwhZwFopI+tMTv1PaCbWbdyPvMIyWKwSru8djduHdPd2SETNWrCuLyRoAQBF/tgsr5nuGUvkT+JM4Vea5ZX40Gh92XrAehZBgRWAphcQ+LC3IyJq1jpfFwFj6yAAQOq+M1AUP2tO0wxzjh49emD48OGYMmUK9uzZg59//hnTpk3D6NGj0b59ewDAhQsX0L17d+zZYxv8MZlMmDRpEmbOnIkffvgB+/fvx8SJEzFkyBBcf/31AIBvv/0Wq1atwtGjR3Hq1Cm8//77ePXVV/Hkk082OkYW9S6ITbBtawcAaT4yBf+X8zn4/qdjsMgSdDotnp04jFPgiOqhVgUgSNcLAFBhPQOLfNHLETUtjtQTeV83YwQUle3z+oyPNMsT1nSIsjUI0FugUUuQTC9DktTeDouoWZMkCfGDYgAAJYVlOHey5kZsLVVzzTnWrFmD7t27Y+jQofjd736H3/zmN1ixYoX955WVlThx4gTKysrsj7311lu4++67kZSUhJtvvhmRkZH48ssv7T/XarVYunQphgwZgr59++KDDz7A4sWLMW/evEbHx6LeBfZmeYpAmg90wLdaZXzwxQ7ICmBVgEcfuAHtw03eDovIJ1Sfgl9csc+LkfiHpUuXIjo6GgaDAYmJifZvvmuSkpKCpKQkREdHQ5IkLFmy5JpzFixYgEGDBiEkJATh4eEYOXIkTpw44cFXQORecSZb52Xbuvo8L0dTP9ue9O9ApTIjwGAGAidA0vb0dlhEPqH6FHy/XFffDLVp0wZr165FcXExCgsLsXr1agQHB9t/Hh0dDSEEbr31VvtjBoMBS5cuRX5+PkpLS/Hll186rKcfPnw4Dh48iOLiYpSUlODQoUP44x//CJWq8SU6i3oXxPSOAmDrgJ/uA3vVf7c9Becy8mGRJXSLCseo4QO8HRKRz/DrZnluaFrTGOvWrcPMmTMxb948HDhwAH369MGdd955TZOaKmVlZYiNjcVrr71Wa/OZH3/8EU888QR27dqFzZs3o7KyEnfccQdKS31nbTL5t67GMKhg29buTEnzL+ph3gxUHrq8J30HSMGNn05K5K96JV4p6o/u8bN19U2cc7QU3NLOBWEd2yK4VRAqzBVIO968R+qzcovwxaaDsCoSABVmT7oDGjW/0yFqKKN+IAAJgECR2b9G6l2Z0ubM8xYvXowpU6Zg4sSJAIDly5fjn//8J1avXo3Zs2dfc/6gQYMwaJDtS5eafg4AGzdudPjvjz/+GOHh4di/fz9uvpm7f1DzZ1BrER3SFmkFF3GuNB9WRYHGidGcpiCUAoiSFdDrKqHTypBM8yGpAr0dFpHP6BrfAYZAHSrKLDi65zSEEH6zXLapc46Wonl+GvgISZLszfIuZReipKB5jvgIIbByww6YLTIsMvDQnf3Qs0vtWykQ0bU0ahMCtd0AAKWWVFiVYi9H1ITc0LSmqKjI4ahtqxaLxYL9+/dj2LBh9sdUKhWGDRuGnTt3uu0lFRYWArBNpyPyFXFGW7O8SkVGRlmBt8OplSj5ABIKEWgwA4a7Ielv8XZIRD5FrVHb96fPyypEdpoPNcd0VTNslOcLWNS7qHqzvPSTzbNZ3n8PnMbhkxmwyBIi2hrx6IM3ejskIp90ZQq+gmLzQa/G4ms6deoEk8lkPxYsWFDjebm5uZBlGREREQ6PR0REICvLPc2CFEXBjBkzcOONN6JXr15uuSZRU4gzRVTrgN88p+ALy37AvBVBARVQqUMghTzv7ZCIfFL84Cv71fvdFHxqNBb1LopJ6AyhXC7qm2EH/OLSCvz1m12QFdue9M9MGIpAg87bYRH5JMdmef6zrt4dnWjT0tJQWFhoP+bMmeO11/PEE0/g6NGj+Oyzz7wWA5EzuhnDISTbuvrTzbADvhAVECXvQKuxQq+zQgp5DpI61NthEfmkXn7aLK+5dr9v7rim3kXVm+U1x23tPvl2D4pKzbDIEoYmdsNN/bvU/yQiqlGIvzbLc6X5zOXnGY1GGI3Gek8PDQ2FWq1Gdna2w+PZ2dm1NsFrjGnTpuG7777D9u3b0bFjR5evR9SU4ky2GSxKM+2AL8rWAEomgoLNgHYwEPCAt0Mi8llx/aKg0aphrZRxdK//FPXuyDn8EUfqXRTTqxMAQLE2v6L+yC8Z2Lb3FCyyhKBAA55++DZvh0Tk0/SaSOg1tn/zxeZDUETN68Jbmqb81lyn02HAgAHYunWr/TFFUbB161YMGTLE6dcghMC0adPw1Vdf4T//+Q9iYmKcvhaRt3QINCFIo2uWRb2oPA2UrUeg3gy1Wg3J9KLfNPYi8gRDgA5dE2xfPqf/moOCXP/o5cOReuewqHdRQHAA2neJgCIruPBLJhRF8XZIAACzpRIr1v8MRQBWRcITo29CaOvg+p9IRHWqWlcvYEGJ+YiXo2mZZs6ciZUrV+Kvf/0rjh07hscffxylpaX2bviPPPKIw/R9i8WCQ4cO4dChQ7BYLLhw4QIOHTqEU6dO2c954okn8Pe//x1r165FSEgIsrKykJWVhfLy8iZ/fUTOkiQJcaYIyBKQYy5GaWXz+GJRCBmi5C2o1ZUw6C2Qgh+HpImt/4lEVKdeg6pNwfen0XpqNBb1bhDTOwrCKmAut+BiWvNY4/bllsPIyi2G2Sqhd7f2uO+23t4OiahF8Mv96hXh2tFIo0aNwhtvvIG5c+eib9++OHToEDZu3Ghvnnf+/HlkZmbaz8/IyEC/fv3Qr18/ZGZm4o033kC/fv0wefJk+znvv/8+CgsLceutt6Jdu3b2Y926da7//RA1oTjjlWZ5p5tLs7zybwHrCdue9JouQNCj3o6IqEVwbJbnJ0V9E+ccLQXX1LtBbEIUfv56DwAg7UQmIqLCvRrP+cxL+GbbYVTKEtRqNeZMugMqFafAEblD9WZ5RRV7ANPjXoymiXhhfdu0adMwbdq0Gn+2bds2h/+Ojo6GqGcbm/p+TuQrupnCr3TAL85FQuv2Xo1HyDkQZR9Br6uEViNDMr0ESWJDXiJ3iB90ZanY0d1+0gGfa+qdwpF6N4hJ6Gx/A6afuODVWBRFYMX6n2C1ClQqwCP3DkZMx7ZejYmoJTFoYqBV2f5NFZv3QwjZyxF5ngQX1rd5O3iiFibOFA5IEmQJOFPi/b2rRclSqKQyBAVUAAGjIOkGejskohYjpFUQouPaAQBOp15AaXGFlyPyPOYczmFR7wZVHfAVq+L1Znmbdx3HibMXYZYldG7XBuPvTfRqPEQtjSRJCDHYklZZlKCs8oSXIyIif9LNaJsNqEjAWS9vayfMPwGWnQg0VEBSh0EK+ZNX4yFqiaqm4CuKwPEDZ7wcDTVXLOrdoF1sOAyBeiiy8Ope9fmFpVj7z32wKoAiJDz3h9uh13GFBZG7Oayr94f96oVw7SAitwnRGtAhsJWtA35JHhQv/RsTSilEyVJotVV70r8ASVX/tpVE1Di9/G1dPXMOp7CodwO1Wo3oXp0grAI5aXmoKPXO1JiPvtqFsopKWGQJ99zSCwN6dvJKHEQtnVE/2P5nf2iWx+1liJqXOFM4ZBVQLlciu7zIKzGIstWQRC6CAyoA/a2AYYRX4iBq6eIHX+mA7w9FPXMO57Cod5OYhCgosoAQAhdOZTX5/fcePYddR87BbJXQ2hiIaWNvbvIYiPxFkK4H1JJti8is/F04ePAgdu/ejUOHDqGkpMTL0XmAcPEgIrfqZqzeLK/pO+ALSypQ/h0CDBao1AGQjPO4Jz2Rh4S1a4XITrZePicOnUN+XgEOHTrUcvMO5hxO4dxsN4lJ6Awh295J6Scy0KVPdJPdu6zCgg+/3AlZALKQMOP3t8EUHNBk9yfyN8eOncC7iyvx849ZOPfrGQjR3/4zSZIQFxeH22+/HY899hh69uzpxUiJqCWKM0VASBIEBM6U5OGGiKbbE14IC0TpEmjUVgToLZCCZ0FSd2iy+xP5o9Auevzn8DYUyhcQGrbYYUcX5h0EsKh3m9jLzfKELJB2vGk74K/buB95hWWwWCVc3zsad9zQvUnvT+Qvzpw5g6lTp2Ljxo0IDw9DUtIEDHp+EHr27InAwECUlZUhNTUVe/fuxbp16/Duu+9i+PDhWLZsGWJiYuq/QTMlCQHJyXVqzj6PiGoXZ4oAAMgq4HRJEzfLK1sPWM8iKKQC0PQCAh9u2vsT+ZHqeUfbtqEY+9CDGDSoZecdzDmcw6LeTWISOgMAFFkg7WTTNcv75XwOvv/pGCyyBJ1Oi2cnDuMUOCIPWLVqFWbMmIHQ0FCsWbMGDzzwAHS6a/diTkxMxMSJE7FkyRKsX78ec+bMQUJCApYsWYLJkyd7IXI3UC4fzj6XiNwqKqgN9CoNFKkSZ4ubbls7YU2HKFsDg94CjVqCZHoZksRUksgT/DbvYM7hFK6pdxNj2xCEdmgDYRVIP5nhMC3GU6xWGSu+2AFZAawKMCXpBrQPN3n8vkT+5pVXXsGUKVMwZswYHDlyBGPHjq3xg7U6nU6HsWPH4ujRoxgzZgymTJmCV155pYkidq+qb82dPYjIvTQqFboaw6BIQEZZASqslR6/pxACouQdqFRmBBrMQOB4SFpO8yXyBH/OO5hzOIdfr7pRTO8o7N9yCKWF5biUXYA2ka09er/vtqfgbEY+LLKEblHhGD1igEfvR+SPVq1aheTkZLz00ktITk5u9PNDQkKwcuVKdO7cGcnJyYiMjMSkSZM8EKkHudJ8xn8/X4k8Ks4YjmP5GVAgcK403z4l32PMm4HKQwgKqoCk7gApeLpn70fkp/w+72DO4RSO1LtRTK8rzfLSPLxffXZeEb7YdBBWRQKgwuxJd0Cj5v+dRO505swZzJgxA5MnT77mg3Xbtm2QJKnGY9euXddcKzk5GZMnT8ZTTz2FM2fONNVLIKIWKs4U0WQd8IVSAFGyAjptJXRaGZJpPiRVoEfvSeSPmHeQszhS70axvaMgFAACSD+egT63xHvkPkIIrFy/A2aLDIssYdTwfujZJdIj9yLyZ1OnTkVoaCgWL15c6znTp0/HoEGDHB7r2rXrNedJkoQ333wTmzZtwtSpU/H999+7PV6PEcJ2OPtcInK7OFM4IElQJFsHfE8SJR9AQiGCAsyA4S5I+ls8ej8if8W8A8w5nMSi3o1ie1dvlue5Dvj/PXAa/zuZAYssIaKtEY8+cKPH7kXkr1JTU7Fx40asWbMGISEhtZ5300034YEHHmjQNY1GIxYsWIBx48bh2LFj6NGjh7vC9ShJ2A5nn0tE7lc13V6RgLMeLOqFZT9g3oqgwAqo1CGQQl7w2L2I/BnzDhvmHM7hfG036hjXHhqtGsKqIP1kpkfuUVxagb9+swuyYtuT/pkJQxEUUHfjDCJqvOXLlyM8PLxBH5zFxcWwWq0Num5SUhLCw8Px/vvvuxpi06n61tzZg4jcro0+CGH6YMgScLo41yMNeoWogCh5B1qNFXqdFVLIc5DUoW6/DxEx77BjzuEUFvVupNVp0blHRyiyQObpHFgs7u9G+7fv9qCo1AyLLOG3g7vhpv5d3H4PIgI2b96MpKSkervNTpw4EUajEQaDAbfddhv27dtX5/l6vR5JSUnYsmWLO8MlIj/UzRQORQKKKiuQby5z+/VF2RpAybRNu9cOAgIaNjpIRI3HvINcwaLezWISbM3yZKuMrNPZbr32kV8y8MOeU7DIEoICDZj5yG1uvT4R2RQXF+PEiRPXrFmrTqfTISkpCW+//Ta++eYbvPzyyzhy5AhuuukmHDx4sM7rDxw4EMePH0dJSYm7Q/cISXHtICLPiDOFQ76cyZ0pyXXrtUXlaaBsPQL1ZqjVakimFyFJklvvQUQ2zDuuYM7hHBb1bhaTEAXFerkD/nH3dcC3WKxYuWEHFAFYFQlPjL4Joa2D3XZ9IrIRQuDULwcghEDPnrXvwXzDDTdg/fr1+MMf/oB7770Xs2fPxq5duyBJEubMmVPnPeLj4233OXXK3eF7BqfCETVLccYICEmCAHDajR3whZAhSpZAra6EQW+BFPw4JA1nBhK5mxACRXnF+OFf25l3VGHO4RQ2ynOzqmZ5QhFId+O2dl9u/R8yLxbBbJXQu1t73Hdbb7ddm8hfCCEAcQmQs2yHkgkhZwFy5uX/tj1ekVUEAAgMbNyWTV27dsV9992HL7/8ErIsQ61W13heQEAAAMBsNrv2gpoK94wlapYcm+Xlu+/C5d8C1uMICq6ApIkFgh5137WJ/IQQAiUFpbiYloeLabm4mJ5v+98LeZcfy0Nueh7M5RYUCtuXcsw7wJzDSSzq3SymdxQAQFgF0n9xT1F/PvMSvv7hMCplCWq1GrMn3Q6VilPgiKqzFeyFDgW6cCjWL/8Z9X+g6XW2f19lZY1fo9qpUydYLBaUlpbCaDTWeE55ebntPnp9o69PRFSlS0go1PZt7dwz/V7IFyHKPoJeVwmtRoZkegmSxIa8RNUJIVBaWIaL6XnVivY8XEy3FepVRXtFWcOKaBVsxTjzDnIWi3o3a9uuNYxtQ1BWVoa0E653wFcUgRXrf4bVKlCpSPjD/YMR25GdZ8m/2Ar2IvvoOuSsKyPsSiYgZ9sKd1Hu2o2kEEAdia7d2kKS/o7U1FQkJiY26hKnT5+GwWBAcHDty2NSUlIgSVKN+8o2R5IQkJyc0ubs84iofjq1BrEhoTh7KQfnS/JRqcjQqmoeqWsoUbIUKqkMQQEVQMAoSLra1/gStVSlRWW2wrxa0Z6bnoec9Csj7OUlFS7dIyDYgLBObRHasS1MEUHY8/etzDvAnMNZLOrdTJIkxCR0xtEdx1CQU4ii/GIY29S+12R9tuw6gRNnc2CWJXRu1wbj723cP3Si5s5WsJdUK9AvF+z20fVMQMkGhIudnaUgQN0OUEUC6khI9j+3A9SRgCoSksr2gWgEEBe3F3v37sXEiRNrvNzFixcRFhbm8Nj//vc//OMf/8CIESOgUtXesmTfvn3o3r17nR/AzYor69T8+AOWqCl0M4bjdEEOrEJBemkBYkLaOn0tYf4JsOxAYGAFJHUopJBn3BgpUfNQVlx+VbGej5y0XORWmxZfVuzaIIEhUI+wTm1tR8dQhHZsg/BOoQjtaHssvFNbBBoDHZpP/m3vSuYdAHMOJ7Go94CYhM44vD0VAJB+IgM9h8Q5dZ38wlKs+edeWBVAERKe+8Pt0Ov4fxn5FqGUOBTootradVvBngWIUtduIgVWK9DbAaoIW9GujgRUtseqCvaGuv3227Fu3TosWbKkxu1lRo0ahYCAANxwww0IDw9HamoqVqxYgcDAQLz22mu1XtdsNmPDhg0YNWpUo1+m1wgAznaU9d/PV6ImEWeKwL+kowBsHfCdLeqFUgpRshRabdWe9MmQVCZ3hkrkceWlFfaR9JxqI+z2Ij49D6WFrg0S6AN09hH2sE5tEd7xSrEedvl/g1sFNXq3COYdlzHncAorRA+I7R0FodjeVeknMp0u6j/6ahfKKiphkSXcc0svDOjZyZ1hErlMKKVXpr9fHmkX1ZrQQc6yjcK7Qgqwj67bCvZ2kNQR1Ubd2wFSiNu3Wnrsscfw7rvvYv369Rg7duw1Px85ciTWrFmDxYsXo6ioCGFhYfi///s/zJs3r87pbRs2bEBOTg4ef/xxt8ZLRP4pzhgOcXld/dnifKCdc9cRZashiVwEB1QA+lsBwwi3xknkqooys71Yz62+lr3aCHtJgWuDBDqDFqEdbSPpoR2rivRQe7Ee1qktQloHe2R7R+Yd5AoW9R4QW71Z3skLTl1j79Fz2HXkHMxWCa2NgZg29mZ3hkhUL6GUOTaYq6nxnCh28S56h+nvULe7PC0+4sqou2T0yt7IPXv2xPDhw/H888/jnnvuQUiI4zKa6dOnY/r06Y26ZlFREebMmYPhw4ejR48e7gzXo7i+jaj5qt4B/0yxc83yhCUVKP8OAQEWqNQGSMZ53JOempS53IyL6fn2Yj2n+gj75ceK810bJNDqtQjr2ObKqHqHywV7tRF2Y1v3DxI0FPMOG+YczmFR7wFR8Z0gSRIUWSDtZOOb5ZVVWPDhlzshC0AWEmb8/jaYggM8ECn5KyHKHbZ1u7KOPfPK46LQxbvoaijYq6bDXy7apVbNOnFctmwZEhISMHPmTKxcudKlawkhMGvWLOTl5WHZsmVuirCJCLiwvs2tkRDRVSIDjDBqDTBby3G6pPF71QthgShdAo3aigC9BVLwHEjqDh6IlPyVpcKC3Av51zSeqxphz03PQ2Gua4MEGq3acQr8VSPsoR3bolWYdwYJGoN5B5hzOIlFvQcYAvVo3zUSWWnZuHAyo859I2uybuN+5BWWwWKVcH3vaNxxQ3cPRkstjRAV1abDZ121jr1qSnyBi3fRVluvXkvjOal1s//wrE9MTAyWLFmCKVOmICoqCsnJyU5dRwiBl19+GatWrcKqVasQExPj5kg9jE1riJotSZLQzRiOQxXnkGsuQZGlAkadoeEXKFsPWM8iKKQC0PQCAh/2XLDU4ljMlci7kF/n1m4FF4tcuodGq0Zoh5pH2KumypvCjHU2ivMVzDvAnMNJLOo9JLZ3Z2SeyYLFbEXOuVy0i41o0PN+OZ+D7386BossQafT4tmJw3y+MCL3EcJy1b7rmRD2pnNVU+IvuXgXrW0kvVqBLjl0iW8HqNr4zfty8uTJyM7ORnJyMs6dO4fFixdfMyWuLkVFRZg1axZWrVqFV155BZMmTfJgtETkj+JMEThw8RwA4GxJLnq36dig5wlrOkTZGhj0FmjUEiTTy5AkpoZkU2mpRF7GpWu3drtwZV37pWzXZvWp1CqEdmhzzQh79XXtrSNMLaJgbyjmHeQM/ub2kJiEKPz3y90AgLQTGQ0q6q1WGSu+2AFZAawK8FjSDWgfzs6z/sJWsGc7dIYX1afDK1mA0viplY40l9erX2k8Jzk0oYsEVG0hSf7z4dkQL7zwAiIiIjBjxgxs2rQJCxYswAMPPFBjd9oqVd1m58yZg7y8PKxatcp3P1gVAM5+h+NsB1siarA4UziUy/9GT5fkN6ioF0JAlLwDlcqMQIMZCPwDJG1PD0dKzYW10mor2Kvtu55zeZS9aoT9UnahbdtZJ6lUEtq2b2NvMBfaoS3Cq42wh3WyFeyNmc3qL/w672DO4RQW9R4S2zsKEIBQBNJPZmDwiH71Pue77Sk4m5EPiyyhW1Q4Ro8Y0ASRUlMQotKxYLc3navWeE5xrsHRFWrHgl0VWW1bt6qivS0kiR+ezpg8eTKGDh2KqVOnYty4cXj66aeRlJSEgQMHIj4+HgEBASgvL0dKSgr27dtn7zY7fPhwLFu2zLemvl2FTWuImrc4UwQgSZAlgbPFDfzy17wZqDyEoKAKSOoOkIIb14CLmi/ZKiMv85LD1m62pnO59lH3/MwClwv2Nu1aX5kC37GqUL/SeK5NZCuoNcw5nOWveQdzDuewqPcQewd82VbU1yc7rwhfbDoIqyIBUGH2pDugUXO01BcIYQWUnFq6xF/e7k25CNe6d6gAVbhD4znHfdgjAFUYC3YPi4mJwffff4/U1FQsX74cW7ZswfLlyx0SI0mS0L17d4waNQqPP/64z3SbrRPXtxE1a9cZwwE0vAO+UAogSlZAp62ETitDMs2HpAr0dJjkBrIsIz+zwGGE/WJaLnKqjbDnZ16Cojj/u1eSJLSObIXwaiPsYZ1Cr2zz1qkt2rZrzYK9Cfhl3sGcwyks6j0kIjoMhiA9rLIVacfrLuqFEFi5fgfMFhkWWcKo4f3Qs0tkE0VKdbEV7BevrFdXLneJr9aEzjbC7sp8HwlQhdn3YLc1nas2HV7dDlCFcp1jM9KzZ0+88847AICSkhKcOnUKZrMZer0eXbt2RXBwsJcjdDN+wBI1a0EaHToFtUZWUT7OluRDEQKqOvqeiJIPIKEQQQFmwHAXJP0tTRgt1UaWZVzKLqxWrFdt6XZlhD0v4xIU2bU5xm0iW12ZAl+9U/zlEfa27VtDo2XO0Zz4Vd7BnMMp/BfrISqVCjEJnXHywK+4mJ6HspJyBNayLd1/D5zG/05mwCJLiGhrxKMP3NjE0fonIeQrBXttXeKVHLinYL96W7fqjefCIElad70samLBwcHo27evt8NocZYuXYpFixYhKysLffr0wbvvvovBgwfXeG5KSgrmzp2L/fv349y5c3jrrbcwY8YMl65J5GvijOHIKM5HhVKJzLJCdAhqVeN5wrIfMG9FYIAZKnUIpJAXmjZQP6UoCgpyCi/vwX5lhP3ihXzb/6bZCnbZKrt0n1bhJoR1utxkrqpLfMc29qK9bfvW0OqYc/gy5h1UExb1HhSbEIXje0/BKirxw/c/IjI2DDqdDjExMfZv1IpLK/DJP3ZBVmx70j8zYSiCAmpvgkENI4RiG0G3j6hfnhJfNR1ezrxcsLv24QlVqGOXePvoetUIexgkif9/ko9r4m/N161bh5kzZ2L58uVITEzEkiVLcOedd+LEiRMIDw+/5vyysjLExsbiwQcfxNNPP+2WaxL5mjhTBLZmHIdcYcbWvTsRHxJ+Tc4hRAVEyTvQaqww6CshhcyHpA71cuS+T1EUFF4sqlasO46w56bnIfdCPqyVLhbsYcaa92KvGmHv0AY6PQt28nEcqXcKi3oPSU1NxZYT/8JuaTuK8wux8fEv7D+TJAldu3bFrbfeCn1ELxSWmGGRJfx2cDfc1L+LF6P2DbaCPe9ygX65YK+2xZttDXs2AKtrN1K1vbJe3d4lvnrjuQgW7OQfmrgT7eLFizFlyhRMnDgRALB8+XL885//xOrVqzF79uxrzh80aBAGDRoEADX+3JlrEvmS1NRUbH1jFdK2bEFZeg4OXbXetirneOShEMR1ykRQsBnQDgICHvBi1L5BCIHC3KLL27lVbe2Wi9wL+bZu8Wl5yLuQj0qLazmHsW2IvUt81T7soR3bXOkW36ENdAbmHOQH2P3eKSzq3ezMmTOYOnUqNm7ciPCwcIybPAaDBg1Cz549ERgYiLKyMqSmpmLv3r1Yv34DLl5ciTYduqP7b0Zh5iO3eTt8r7MV7JcuF+yZ1Qr26uvYswFUunYjqfXlAt1WtEuX17JfWcceAUnSu+U1Efk6d3SiLSoqcnhcr9dDr7/235jFYsH+/fsxZ84c+2MqlQrDhg3Dzp07nYrBE9ckag4cco7wcIxPSqo159iwYT1WrryI228x4v3XwxHb/0VIday79wdCCBTlFVfbg/3aEfaL6fmoNLuWc4S0Cb48qm4bUbftwW4r2qumx+sDmHMQAex+7ywW9W60atUqzJgxA6GhoVizZk2t+0kmJiZi4sSJWLJkCdavX49nn30OB/+xCF8P64jJkyd7IfKmIYQAxKUrBbqcWUPBngXXC/ZW1Qr0dpAuj7Q7TJNnwU7UpDp16uTw3/PmzcP8+fOvOS83NxeyLCMiIsLh8YiICBw/ftype3vimkTe5mzOMWfOs+jz23QsWfIDJk9uubMDhRAovlTisK1b1Qj7xbRc+1R5S4VrOUdwqyCHbd3CqhXr4Z1sU+IDggxuelVERDVjUe8mr7zyCpKTkzF58mQsXrwYISEh9T5Hp9Nh7NixuOeee/D0009jypQpyM7Oxgsv+F7TGlvBXlDLtm7VGs/B4tqNJJPDiLqkrtrOrdqou1RzQ0IicpIb1relpaXBaDTaH65plJ6IGoY5h0BJQWm1Yv1y4Z6ei9x0W9Gem56PijKzS/cJMgVeM8Lu0HiuYxsE1NIEmYicxDX1TmFR7warVq1CcnIyXnrpJSQnJzv8rKSkBIsWLcLu3buxZ88eXLp0CR999BEmTJhgPyckJASrVq1CVFQUkpOTERkZiUmTJjXxq6idrWAvrGNbt6oR9grXbiQZa+gSf2VNO1SR3EeXyBsUAUhOflBe3ivZaDQ6FPW1CQ0NhVqtRnZ2tsPj2dnZiIx0bqtPT1yTyFv8IecoKypzaDqXc7lIr761W0WpawV7YEiAw7ZuV0+HD+sUisAQFuxETc4NOYc/YlHvojNnzmDGjBmYPHnyNR+ugG3a54svvojOnTujT58+2LZtW63XSk5Oxvnz5/HUU0/ht7/9LWJiYjwYuY2tYC922Hf92m3dsgBR7tqNpOBqU+Crd4m/MtIuqYLc86KIyL2a8FtznU6HAQMGYOvWrRg5ciQAW2fprVu3Ytq0aU6F4IlrEnmDr+ccAFBaVHbNCPvVW7uVl7g2SGAI0l/pCt/h8kj7VVu7BRk5SEDULHGk3iks6l00depUhIaGYvHixTX+vF27dsjMzERkZCT27dtn79BcE0mS8Oabb2LTpk2YOnUqvv/+e5fjE0rx5cI886qCvdpIuyhz7SZS0FX7rldNi682TV4V7PJrISL/MHPmTIwfPx4DBw7E4MGDsWTJEpSWlto71z/yyCPo0KEDFixYAMDWCC81NdX+5wsXLuDQoUMIDg5G165dG3RNIl/Q3HOO8pJyx23dqjWey023dYsvK3JtkMAQqL8ywn711m6Xi/YgU6DfNwEkIv/Cot4Fqamp2LhxI9asWVPreja9Xt+o6Z1GoxELFizAuHHjcOzYMfTo0aPWc4VS4lCgi+rT4atG2kVpo1+XAynwqn3XI23T4quNtEuq+tfyEZEvc+FbczT+eaNGjcLFixcxd+5cZGVloW/fvti4caO90d358+ehUqns52dkZKBfv372/37jjTfwxhtv4JZbbrGPVNZ3TaLmzts5R3lpheMe7GmOI+y56fkoKXAt59AZtA77rl9drId2bIOQ1sEs2IlatKbNOVoKFvUuWL58OcLDw/HAA+7d5zUpKQlPP/00li19De+8+Wi1dexXNZ4TJS7eyXDVvuuX17Hb17K3A6QQfngS+TsvTIWbNm1arVPjr55SHB0dbVtK5MI1iZo7T+ccixa8gScnzKhxhP1iWi6KL7lWsGv12ivFeqe2CO3QFuGdHPdjD2nDgp3I73H6vVNY1Ltg8+bNSEpKqnELGVfo9XokJSVh6+a/Qlxydg9l/VUFe/V17JdH2iUTPzyJqH6KgNPffvtx0xoid/J0zrFm1WdI+3uRU9fQ6jQ1ToevKtZDO7aBKdTInIOI6secwyks6p1UXFyMEydO4Nlnn/XI9QcOHIjly99HSamC4CDVVT/VVZsOH3F5hL16wR4JSK354UlERNQCNEXO8f77y2GFFRrJMTXUaNX2DvFVI+xhnRy7xZtCQxyWxBARUdNiUe+kX3/9FUII9OzZ0yPXj4+PhxDAqax70K/vgCuj7up2LNiJqGkJxXY4+1wicklT5ByAwE2PDEC/Af0dusW3CjexYCeipsOcwyks6p1kNtv2Rw0M9MyWKAEBtr1RKzWjIQUleuQeREQNwvVtRF7VVDnHXVNvR2Iicw4i8iLmHE5hUe8kvV4PACgrc3E7uFqUl5c73IeIyGu4vo3Iq5hzEJHfYM7hFM6nclLXrl0hSZJ9b2R3S0lJgSRJ9j2WiYiIyD8x5yAiorpwpN5JwcHBiIuLw969ezFx4sQ6z33vvfdQUFCAjIwMAMC3336L9PR0AMCTTz4Jk8l0zXP27duH7t27Izg42P3BExE1BqfCEXkVcw4i8hvMOZwiiYZs7ks1mj59OtatW4e0tLQ6t5iJjo7GuXPnavzZmTNnEB0d7fCY2WxG586dMWrUKLzzzjvuDJmIqMGKiopgMpkwrN0foVE5t42WVbFgS+YHKCwshNFodHOERP6DOQcRtWTNPefIz8/Hk08+iW+//RYqlQpJSUl4++236/wydMWKFVi7di0OHDiA4uJiXLp0Ca1atXL5ujXh9HsXPPbYY8jJycH69evrPO/s2bMQQtR4XP3hCgAbNmxATk4OHn/8cQ9FTkTUCFXfmjt7EJHLmHMQkV9opjnHuHHjkJKSgs2bN+O7777D9u3b8eijj9b5nLKyMgwfPhzPP/+8W69bE47Uu2jEiBE4duwYjhw5gpCQEJevV1RUhISEBPTs2RPff/+9GyIkInKO/Vvz8MmufWues4oj9URuwJyDiFqq5pxzHDt2DD179sTevXsxcOBAAMDGjRvxu9/9Dunp6Wjfvn2dz9+2bRtuu+22a0bqXb1udRypd9GyZcuQm5uLmTNnunwtIQRmzZqFvLw8LFu2zA3RERERUUvBnIOIqH5FRUUOR9W2oM7auXMnWrVqZS+8AWDYsGFQqVTYvXt3s7gui3oXxcTEYMmSJVi1ahVefvllp68jhMDLL7+MVatW4e2330ZMTIwboyQickEznQpH5G+YcxBRi+eGnKNTp04wmUz2Y8GCBS6FlJWVhfDwcIfHNBoN2rRpg6ysrGZxXXa/d4PJkycjOzsbycnJOHfuHBYvXtyoaXFFRUWYNWsWVq1ahVdeeQWTJk3yYLRERI3ETrREzQZzDiJq0dyQc6SlpTlMv9fr9TWePnv2bCxcuLDOSx47dsy5WJoYi3o3eeGFFxAREYEZM2Zg06ZNWLBgAR544IE6O9SazWZs2LABc+bMQV5eHlatWsUPVyJqfhQBwMkPWIVFPZG7MecgohbLDTmH0Whs0Jr6WbNmYcKECXWeExsbi8jISOTk5Dg8brVakZ+fj8jISOdiBdx6XRb1bjR58mQMHToUU6dOxbhx4/D0008jKSkJAwcORHx8PAICAlBeXo6UlBTs27fP3nF2+PDhWLZsGae/ERERUYMw5yAick1YWBjCwsLqPW/IkCEoKCjA/v37MWDAAADAf/7zHyiKgsTERKfv787rsvu9h6SmpmL58uXYsmULjh8/jup/zZIkoXv37hg2bBgef/xx9OjRw4uREhHVrKoT7dDW413qRLv10l/Z/Z7Ig5hzEJGva+45x4gRI5CdnY3ly5ejsrISEydOxMCBA7F27VoAwIULFzB06FB88sknGDx4MADbmvmsrCzs27cPU6ZMwfbt2xESEoLOnTujTZs2DbpuQ3Gk3kN69uyJd955BwBQUlKCU6dOwWw2Q6/Xo2vXrggODvZyhEREDSSE89Po+b0xkccx5yCiFqOZ5hxr1qzBtGnTMHToUKhUKiQlJdl/7wJAZWUlTpw4gbKyMvtjy5cvx1/+8hf7f998880AgI8++sg+7b++6zYUR+qJiKhG9m/NTQ9DIzn5rbmwYGvh3zhST0RERLVizuEabmlHRERERERE5KM4/Z6IiOqmKICkOPdc4eTziIiIyP8w53AKi3oiIqqbcGF7Ga7wIiIiooZizuEUFvVERFQnoSgQTn5rLvz4W3MiIiJqHOYczuGaeiIiIiIiIiIfxZF6IiKqG6fCERERUVNgzuEUFvVERFQ3RQASP2CJiIjIw5hzOIVFPRER1U0IAM52ovXfD1giIiJqJOYcTuGaeiIiIiIiIiIfxZF6IiKqk1AEhJNT4YQff2tOREREjcOcwzks6omIqG5CgfNT4fx3exkiIiJqJOYcTmFRT0REdeK35kRERNQUmHM4h0U9ERHVjd+aExERUVNgzuEUFvVERFQnKyqd3jLWikr3BkNEREQtFnMO57CoJyKiGul0OkRGRuKnrH+5dJ3IyEjodDo3RUVEREQtDXMO10jCnxcfEBFRnSoqKmCxWFy6hk6ng8FgcFNERERE1BIx53Aei3oiIiIiIiIiH6XydgBERERERERE5BwW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFPREREREREZGPYlFPRERERERE5KNY1BMRERERERH5KBb1RERERERERD6KRT0RERERERGRj2JRT0REREREROSjWNQTERERERER+SgW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFPREREREREZGPYlFPRERERERE5KNY1BMRERERERH5KBb1RERERERERD6KRT0RERERERGRj2JRT0REREREROSjWNQTERERERER+SgW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFPREREREREZGPYlFPRERERERE5KNY1BMRERERERH5KBb1RERERERERD6KRT0RERERERGRj2JRT0REREREROSjWNQTERERERER+SgW9UREREREREQ+ikU9ERERERERkY9iUU9ERERERETko1jUExEREREREfkoFvVEREREREREPopFvQd8/PHHkCQJZ8+e9XYoHlFSUgKVSoW33nrLq3G8/vrr6N69OxRFadL7Ll++HJ07d4bZbG7wc/bu3YsbbrgBQUFBkCQJhw4d8lyAjdDc3qvz58+HJEneDoOIiGrgjs+M5pBDeCt/qE1LySuaW04BMK8g/9Hii/p7770XgYGBKC4urvWccePGQafTIS8vrwkj811Hjx6FEAK9evXyWgxFRUVYuHAhnnvuOahUTfs2njBhAiwWCz744IMGnV9ZWYkHH3wQ+fn5eOutt/C3v/0NUVFRHo6SiIiam6qiZ9++fQ6PFxYWYvDgwTAYDNi4caOXomsa3s4hassfSkpKMG/ePAwfPhxt2rSBJEn4+OOPmyQm5hVE5KoWX9SPGzcO5eXl+Oqrr2r8eVlZGb755hsMHz4cbdu2dcs9H374YZSXl7fYX7BHjhwBACQkJHgthtWrV8NqtWLMmDFNfm+DwYDx48dj8eLFEELUe/6vv/6Kc+fO4ZlnnsGjjz6K3//+92jdunUTRFq/lv5eJSJq7oqKinDHHXfg8OHD+OqrrzB8+HBvh+RR3s4hassfcnNz8eKLL+LYsWPo06dPk8bUUvIK5hRE3tPii/p7770XISEhWLt2bY0//+abb1BaWopx48a5fK/S0lIAgFqthsFgaLHTfY4cOYLQ0FBERkZ6LYaPPvoI9957LwwGg1fu/9BDD+HcuXP44Ycf6j03JycHANCqVSu33b/qveaqlv5eJSJqzoqLi3HnnXfi0KFD2LBhA0aMGOGW67rrM8ITvJ1D1JY/tGvXDpmZmTh37hwWLVrU5HG1hLyCOQWR97T4oj4gIAD/93//h61bt9p/CVa3du1ahISE4N577wUAnDt3DlOnTkVcXBwCAgLQtm1bPPjgg9esD6pao5OamoqxY8eidevW+M1vfgOg5jVFjb3uqVOnMGHCBLRq1QomkwkTJ05EWVmZw7kXLlzApEmT0L59e+j1esTExODxxx+HxWJxOOcPf/gDIiIioNfrER8fj9WrV9f4d3X8+HGcP3++3r/TI0eOID4+3uGxlStXQqfTYcaMGZBlud5ruOLMmTM4fPgwhg0b5tH71GXAgAFo06YNvvnmmzrPmzBhAm655RYAwIMPPghJknDrrbfaf37w4EGMGDECRqMRwcHBGDp0KHbt2uVwjbrea666+r3amPdfbRr6nvvpp58waNAgGAwGdOnSpc5ph9u2bcPAgQMdzq1pnVxD711cXIwZM2YgOjoaer0e4eHhuP3223HgwIEGvUYiIleVlJRg+PDhOHDgADZs2IC77rrL4ecN/X1W22dEY3+fNyZfuFpD8wfAuzlEXfmDXq/36mCFO/KKhuQUgOfyipry3+aYVzQ0p2jovZlTUHOg8XYATWHcuHH461//is8//xzTpk2zP56fn49///vfGDNmDAICAgDYGo/s2LEDo0ePRseOHXH27Fm8//77uPXWW5GamorAwECHaz/44IO47rrr8Oqrr9Y5Zaqx133ooYcQExODBQsW4MCBA1i1ahXCw8OxcOFCAEBGRgYGDx6MgoICPProo+jevTsuXLiA9evXo6ysDDqdDtnZ2bj++ushSRKmTZuGsLAwfP/995g0aRKKioowY8YMh3v26NEDt9xyC7Zt21bn3+eRI0fs09asVitmzJiBFStWYOnSpZgyZUqdz3WHHTt2AAD69+/v8XvVpX///vj555/rPOePf/wjOnTogFdffRXTp0/HoEGDEBERAQBISUnBTTfdBKPRiGeffRZarRYffPABbr31Vvz4449ITEx0uFZD32vuUN/7rzYNfc8dOXIEd9xxB8LCwjB//nxYrVbMmzfP/ndT3cGDBzF8+HC0a9cOf/nLXyDLMl588UWEhYU5dW8AeOyxx7B+/XpMmzYNPXv2RF5eHn766SccO3bM6+8rImr5SktLMWLECOzduxfr16/H3Xff7fDzxn5+A9d+RlQNZDTk97kz96uuofkD4N0cornkD7VxJa9obE4B+Gde0dCcojH3Zk5BzYLwA1arVbRr104MGTLE4fHly5cLAOLf//63/bGysrJrnr9z504BQHzyySf2x+bNmycAiDFjxlxz/kcffSQAiDNnzjh93T/84Q8O595///2ibdu29v9+5JFHhEqlEnv37r3muoqiCCGEmDRpkmjXrp3Izc11+Pno0aOFyWS6JiYA4pZbbrnmetVlZGQIAGL58uUiLy9P/Pa3vxVt2rQRP/zwQ53Pc6fk5GQBQBQXFzfZPWvy6KOPioCAgHrP++GHHwQA8cUXXzg8PnLkSKHT6cSvv/5qfywjI0OEhISIm2++2f5YXe81V139Xm3o+682DX3PjRw5UhgMBnHu3Dn7OampqUKtVourfy3dc889IjAwUFy4cMH+2C+//CI0Go3DuY15v5tMJvHEE0/U+3qIiNyp6nduVFSU0Gq14uuvv67xvMb8PqvtM6Ixv88ber+a8hshGpY/COH9HKKh+cPevXsFAPHRRx81SVxVXMkrGppTCOG5vKKm90dzyysamlM05t7MKag5aPHT7wHbGp/Ro0dj586dDlOC1q5di4iICAwdOtT+WNWIPWDrLpqXl4euXbuiVatWNU6jeeyxxxoUg6vXvemmm5CXl4eioiIoioKvv/4a99xzDwYOHHjNcyVJghACGzZswD333AMhBHJzc+3HnXfeicLCwmvuK4So91v2w4cP2+8xaNAgZGRkYPfu3Q5Tyj0tLy8PGo0GwcHB1/xs165dkCQJ8+fPd/r6Db1G69atUV5e3uDpY9XJsoxNmzZh5MiRiI2NtT/erl07jB07Fj/99BOKioocntPQ95o7/g7qev/VpqHvOVmW8e9//xsjR45E586d7c/v0aMH7rzzTodryrKMLVu2YOTIkWjfvr398a5duzqsPW3s+71Vq1bYvXs3MjIynP47IiJyVnZ2NgwGAzp16nTNz5z5/AZq/4yo7/e5s/e7OuaGjNJ7O4eoK3/wlMZ8JjubVziTUwD+l1c0NKdozL0B5hTUPPhFUQ/A3givqmFeeno6/vvf/2L06NFQq9X288rLyzF37lx06tQJer0eoaGhCAsLQ0FBAQoLC6+5bkxMTIPu39jrVv+lBMDe1fTSpUu4ePEiioqK6twO5uLFiygoKMCKFSsQFhbmcEycOBEAauwxUJ+qrrXTpk1DREQEdu7cia5duzb6Oi2BuDxVzZmGMBcvXkRZWRni4uKu+VmPHj2gKArS0tIcHm/oe80d6nr/1aah77mLFy+ivLwc11133TXXuPrvIycnB+Xl5TW+x6o/1tj3++uvv46jR4+iU6dOGDx4MObPn4/Tp0/X99dCROQWH3zwAXQ6HYYPH44TJ044/MzZz+/aPiPq+33uqXyhJswh6uZsXuFMTgH4X17R0JyiMfcGmFNQ8+AXa+oBWwOS7t2749NPP8Xzzz+PTz/9FEKIa7reP/nkk/joo48wY8YMDBkyBCaTCZIkYfTo0VAU5ZrrVh+Br0tjr1v9i4bqqn7h16fqmr///e8xfvz4Gs/p3bt3g65V3ZEjRxAVFYUuXbrg6NGjKCkpcWv31YZo27YtrFYriouLERIS4vCz/v37Iy0tDUaj0enrN/Qaly5dQmBgYIPfA65q6H3c8XfgzPuvoe+5mt7vrmrs+/2hhx7CTTfdhK+++gqbNm3CokWLsHDhQnz55Zdu6z5NRFSbnj174l//+heGDh2K22+/HT///LN91N7Zz+/aPiPq+33uqXyhJt7OIerKHzylMZ/JzCsc+UpewZyCmgO/KeoB22j9n//8Zxw+fBhr167Fddddh0GDBjmcs379eowfPx5vvvmm/bGKigoUFBS4dG93XjcsLAxGoxFHjx6t85yQkBDIsuzWLvFHjhxB3759sXLlSgwcOBD3338//vvf/7p9a7kPP/wQ//jHP/DNN9/g+PHjePDBB7Fo0SIMHz4c3bt3B2DrYnt1oqHT6dCxY0eX7t3Qa5w5cwY9evRw6h5hYWEIDAy8ZoQGsHURVqlUNU7LbAh3/B04o6HvOVmWERAQgF9++eWan1399xEeHg6DwYBTp05dc271x5x5v7dr1w5Tp07F1KlTkZOTg/79++OVV17hBzARNYnBgwfj66+/xl133YXbb78d//3vf+0jgZ74/K5NU96vKXIIZ/MHT2nMZ7KzeYUncwqg5eQVDc0pGnPvKswpyNv8Zvo9cGUK/ty5c3Ho0KEa96ZXq9XXfGv47rvvurzFijuvq1KpMHLkSHz77bfYt2/fNT8XQkCtViMpKQkbNmyosfi/ePHiNY/VtyWNLMs4duwYEhISEBYWhi+//BJHjx7F448/fs252dnZuPfeezFs2DCcPXsWn3/+ORITEzFnzpwGvcYjR46gd+/e2LFjB5KSkvDxxx9j+PDhAIAhQ4YAQI2vvSkdOHAAN9xwg1PPVavVuOOOO/DNN9849HnIzs7G2rVr8Zvf/Malb8S9oaHvObVajTvvvBNff/21w/vt2LFj+Pe//33NNYcNG4avv/7aYa3aqVOn8P333zf63oDtfXz1kpfw8HC0b98eZrO5ka+aiMh5Q4cOxaeffopTp05h+PDhKCoqcurz2xXuuF9DtrRraA7hD/lDbZzNK1piTgG4P69oaE7RmHszp6Dmwq9G6mNiYnDDDTfY9wCtqai/++678be//Q0mkwk9e/bEzp07sWXLFrRt29ale7v7uq+++io2bdqEW265BY8++ih69OiBzMxMfPHFF/jpp5/QqlUrvPbaa/jhhx+QmJiIKVOmoGfPnsjPz8eBAwewZcsW5OfnO1yzvi1pfvnlF1RUVCAhIQGAbUnD+++/j4kTJ2LAgAEO2wW++eabeO2111BeXo5x48YhJCQEW7duxapVq7B161aH5oQ1OXLkCCIjI3Hfffdh9+7dDo1fYmNj0atXL2zZsgV/+MMfGvT3JUlSg7fbaYj9+/cjPz8f9913n9PXePnll7F582b85je/wdSpU6HRaPDBBx/AbDbj9ddfd0ucTa2h77m//OUv2LhxI2666SZMnToVVqsV7777LuLj4+2NlKrMnz8fmzZtwo033ojHH38csizjvffeQ69evXDo0KFG37u4uBgdO3bEAw88gD59+iA4OBhbtmzB3r17HWbSEBE1hfvvvx8rV67EH/7wB9x7773YuHFjoz+/XeXq/RqypV1Dcwhv5g/vvfceCgoK7AXft99+i/T0dAC2ZZQmkwmA+3MKwPW8oiXmFID784qG5hQNvTdzCmo2mqrNfnOxdOlSAUAMHjy4xp9funRJTJw4UYSGhorg4GBx5513iuPHj4uoqCgxfvx4+3lVW3RcvHjxmmvUtKWHq9et6Zrnzp0TjzzyiAgLCxN6vV7ExsaKJ554QpjNZvs52dnZ4oknnhCdOnUSWq1WREZGiqFDh4oVK1ZcEzfq2ZLm888/FwBESkqKw+NTp04VWq1W/Pjjj/bHpk2bZv/z+PHjxeeffy6EEOLYsWNi6dKltd6jSlhYmLjpppuEyWRyuG6VxYsXi+Dg4Bq3CrxacXGxACBGjx5d77kN9dxzz4nOnTvbtw+sS21b2gkhxIEDB8Sdd94pgoODRWBgoLjtttvEjh07HM6p673mqtq2tGvI+682DX3P/fjjj2LAgAFCp9OJ2NhYsXz5cvv9r7Z161bRr18/odPpRJcuXcSqVavErFmzhMFgaPS9zWaz+NOf/iT69OkjQkJCRFBQkOjTp49YtmxZA//WiIicU/W7tKbtaN944w0BQNx9992isrKywb9La/u93djf5w25nytb2jU0h/Bm/hAVFSUA1HhUvWZP5BRCuCevaEhOIYTn8oq6trRrTnlFQ3OKhtybOQU1F5IQDey8RtQIc+bMQVJSEnQ6HWbNmoXS0lJ88803WL16NYYMGYKbb7651udmZ2cjOjoaBQUFePHFF7Fnzx5s3rzZ4ZzCwkLExsbi9ddfx6RJk+qM5V//+hfuvvtu/O9//7OPELjCbDYjOjoas2fPxlNPPeXy9cg5I0eOREpKSo1r6IiIyDc1p/yhJu7OKQDmFc0BcwrydX61pp6azrPPPou3334bycnJWLFiBebPn48HH3wQ5eXlDh/IEyZMwIQJExyee+TIEfTo0QN6vR4zZszAjh07sGvXLodzTCYTnn32WSxatKjerqc//PADRo8e7bYP348++gharbbB+7uS68rLyx3++5dffsG//vWvJtvbmIiImkZzyh9q4u6cAmBe0dSYU1BLxJF68qphw4Zh1KhRmDJliv2xt956CwcPHsQnn3wCAHjqqadw6tQp/POf//RWmORl7dq1w4QJExAbG4tz587h/fffh9lsxsGDB2vcl5aIiFo25g/kLOYU1BKxqCevsVqt6N27N/73v/9Bq9V6OxxqxiZOnIgffvgBWVlZ0Ov1GDJkCF599VX079/f26EREVETY/5ArmBOQS0Ri3oiIiIiIiIiH8U19UREREREREQ+ikU9ERERERERkY/SeDsAIiJqvioqKmCxWFy6hk6ng8FgcFNERERE1BIx53Aei3oiIqpRRUUFYqKCkZUju3SdyMhInDlzxi8/ZImIiKh+zDlcw6KeiIhqZLFYkJUj48z+KBhDnFutVVSsIGbAOVgsFr/7gCUiIqKGYc7hGhb1RERUJ2OIyukPWCIiIqKGYs7hHBb1RERUJ1kokJ3c/FQWinuDISIiohaLOYdzWNQTEVGdFAgocO4T1tnnERERkf9hzuEcFvVERFQnBQqc/e7b+WcSERGRv2HO4RwuWCAiIiIiIiLyURypJyKiOslCQBbOTWlz9nlERETkf5hzOIdFPRER1Ynr24iIiKgpMOdwDot6IiKqkwIBmR+wRERE5GHMOZzDNfVEREREREREPooj9UREVCdOhSMiIqKmwJzDOSzqiYioTmxaQ0RERE2BOYdzWNQTEVGdlMuHs88lIiIiagjmHM5hUU9ERHWSXWha4+zziIiIyP8w53AOG+URERERERER+ahmXdSXlJTg0KFD2L17Nw4dOoSSkhJvh0RE5Hdk4dpB5AuYcxAReZ83co6lS5ciOjoaBoMBiYmJ2LNnT63npqSkICkpCdHR0ZAkCUuWLLnmnPnz50OSJIeje/fuzgXXQM1u+n1qaiqWL1+OzZs348SJExDVGh5IkoS4uDjcfvvteOyxx9CzZ08vRkpE5B+4vo1aKuYcRETNS1PnHOvWrcPMmTOxfPlyJCYmYsmSJbjzzjtx4sQJhIeHX3N+WVkZYmNj8eCDD+Lpp5+u9brx8fHYsmWL/b81Gs+W3c1mpP7MmTMYMWIE4uPjsW7dOtx222348MMPsWvXLhw+fBi7du3Chx9+iNtuuw3r1q1DfHw8RowYgTNnzng7dCKiFk2BBNnJQ4Hk7fCJrsGcg4ioeWrqnGPx4sWYMmUKJk6ciJ49e2L58uUIDAzE6tWrazx/0KBBWLRoEUaPHg29Xl/rdTUaDSIjI+1HaGhoo2NrjGZR1K9atQoJCQk4duwY1qxZg7S0NCxbtgwTJ05EYmIiEhISkJiYiIkTJ2LZsmVIS0vDmjVrkJqaioSEBKxatcrbL4GIiIh8AHMOIqKWraioyOEwm801nmexWLB//34MGzbM/phKpcKwYcOwc+dOl2L45Zdf0L59e8TGxmLcuHE4f/68S9erj9eL+ldeeQVTpkzBmDFjcOTIEYwdOxY6na7O5+h0OowdOxZHjx7FmDFjMGXKFLzyyitNFDERkX9RhGsHUXPBnIOIqHlzR87RqVMnmEwm+7FgwYIa75WbmwtZlhEREeHweEREBLKyspx+DYmJifj444+xceNGvP/++zhz5gxuuukmFBcXO33N+nh1Tf2qVauQnJyMl156CcnJyY1+fkhICFauXInOnTsjOTkZkZGRmDRpkgciJSLyX1XT2px9LlFzwJyDiKj5c0fOkZaWBqPRaH+8rmnynjBixAj7n3v37o3ExERERUXh888/99jnhtdG6s+cOYMZM2Zg8uTJ13y47t27F9OmTUN8fDyCgoLQuXNnPPTQQzh58mSN10pOTsbkyZPx1FNPcb0bEZGbObu2zZUPZiJ3Ys5BROQb3JFzGI1Gh6O2oj40NBRqtRrZ2dkOj2dnZyMyMtJtr6lVq1bo1q0bTp065bZrXs1rRf3UqVMRGhqKxYsXX/OzhQsXYsOGDRg6dCjefvttPProo9i+fTv69++Po0ePXnO+JEl488030bZtW0ydOrUpwiciIiIfwZyDiIiuptPpMGDAAGzdutX+mKIo2Lp1K4YMGeK2+5SUlODXX39Fu3bt3HbNq3ll+n1qaio2btyINWvWICQk5Jqfz5w5E2vXrnVY5zZq1CgkJCTgtddew9///vdrnmM0GrFgwQKMGzcOx44dQ48ePTz6GoiI/IUiJCjCuRF3Z59H5C7MOYiIfEdT5xwzZ87E+PHjMXDgQAwePBhLlixBaWkpJk6cCAB45JFH0KFDB/u6fIvFgtTUVPufL1y4gEOHDiE4OBhdu3YFADzzzDO45557EBUVhYyMDMybNw9qtRpjxoxx6nU1hFdG6pcvX47w8HA88MADNf78hhtuuKZxzXXXXYf4+HgcO3as1usmJSUhPDwc77//vlvjJSLyZ5x+T76MOQcRke9o6pxj1KhReOONNzB37lz07dsXhw4dwsaNG+3N886fP4/MzEz7+RkZGejXrx/69euHzMxMvPHGG+jXrx8mT55sPyc9PR1jxoxBXFwcHnroIbRt2xa7du1CWFiY639BtfDKSP3mzZuRlJRUb8fZ6oQQyM7ORnx8fK3n6PV6JCUlYcuWLe4Ik4iIAMhQQXbyO2DZzbEQNRZzDiIi3+GNnGPatGmYNm1ajT/btm2bw39HR0dDiLq39vnss8+cjMR5TT5SX1xcjBMnTmDQoEGNet6aNWtw4cIFjBo1qs7zBg4ciOPHj6OkpMSVMImIiMjHMecgIiJ/0ORF/a+//gohBHr27Nng5xw/fhxPPPEEhgwZgvHjx9d5bnx8PIQQHu0uSETkT8Tl9W3OHIJr6smLmHMQEfkW5hzOafLp92azGQAQGBjYoPOzsrJw1113wWQyYf369VCr1XWeHxAQ4HAfIiJyDfepJ1/FnIOIyLcw53BOkxf1VfsElpWV1XtuYWEhRowYgYKCAvz3v/9F+/bt631OeXm5w32IiMg1slBBFk6ub6t72RmRRzHnICLyLcw5nNPk0++7du0KSZLsWwHUpqKiAvfccw9OnjyJ7777rsFT51JSUiBJkn1LASIiIvJPzDmIiMgfNHlRHxwcjLi4OOzdu7fWc2RZxqhRo7Bz50588cUXGDJkSIOvv2/fPnTv3h3BwcHuCJeIyO8pkKBA5eTh3FS4pUuXIjo6GgaDAYmJidizZ0+t565cuRI33XQTWrdujdatW2PYsGHXnD9hwgRIkuRwDB8+3KnYyHcw5yAi8i3eyDlaAq9saXf77bdj3bp1WLJkSY1bzMyaNQv/+Mc/cM899yA/Px9///vfHX7++9//vsbrms1mbNiwod5utURE1HBNvb5t3bp1mDlzJpYvX47ExEQsWbIEd955J06cOIHw8PBrzt+2bRvGjBmDG264AQaDAQsXLsQdd9yBlJQUdOjQwX7e8OHD8dFHH9n/m1Om/QNzDiIi38E19c6RRH0b7XlAamoq4uPjsWbNGowdO/aan99666348ccfa31+bSGvXbsW48aNQ2pqKnr06OG2eImI/FFRURFMJhO++t91CAqpu2FYbUqLZdzf5xcUFhbCaDQ26DmJiYkYNGgQ3nvvPQCAoijo1KkTnnzyScyePbve58uyjNatW+O9997DI488AsA2Ul9QUICvv/7aqddBvos5BxFR8+etnKOlaPLp9wDQs2dPDB8+HM8//zyKi4uv+fm2bdsghKj1qElRURFmz56N4cOH88OViMiNbFPhnD8A2+/o6kdt3cItFgv279+PYcOG2R9TqVQYNmwYdu7c2aB4y8rKUFlZiTZt2jg8vm3bNoSHhyMuLg6PP/448vLynPwbIV/isZxjDnMOIiJ3c0fO4Y+8UtQDwLJly5Cbm4uZM2e6fC0hBGbOnImsC1kY1OYmVFoq3RAhERG5S6dOnWAymezHggULajwvNzcXsiwjIiLC4fGIiAhkZWU16F7PPfcc2rdv7/DFwPDhw/HJJ59g69atWLhwIX788UeMGDECsiw7/6LIZ3gi58i8mIOYacNRbrW4IUIiIiLneWVNPQDExMRgyZIlmDJlCqKiopCcnOzUdYQQePnll/Hhhx+il34Qdn56EM+mvYi5X8xC64hW7g2aiMgPKVBBdvI7YAW2kc60tDSHqXCeWs/+2muv4bPPPsO2bdtgMBjsj48ePdr+54SEBPTu3RtdunTBtm3bMHToUI/EQs2HJ3KOrtN+h32qbEze/QEW9fs92ge2dnPURET+xx05hz/y2kg9AEyePBkvv/wy/vznP2PKlCk1TourS1FREaZMmYK5c+di3MhHcF2bHtAbtTj683E8MWg2Tuz71UORExH5j6o9Y509AMBoNDoctRX1oaGhUKvVyM7Odng8OzsbkZGRdcb5xhtv4LXXXsOmTZvQu3fvOs+NjY1FaGgoTp061Yi/CfJl7sw5xj/9OK67fTACLMCpwkyM37kUe/OYcxARucodOYc/8vorf+GFF7By5Up8+umn6NWrF9auXQuLpe6pbGazGWvXrkVCQgI+++wzLFmyBG+vWow5a6ajTYdW0Ju0yM3Mx8yb/4wtf9/eRK+EiKhlcn5rGdvRGDqdDgMGDMDWrVuv3F9RsHXr1jq3Gnv99dfx0ksvYePGjRg4cGC990lPT0deXh7atWvXqPjIt7kr53jzhZewoO8YtNe3RoAFKKkow/R9H+Gzsz/Xug6fiIjq15Q5R0vile73NTlz5gymTp2KjRs3Ijw8HElJSRg4cCDi4+MREBCA8vJypKSkYN++fdiwYQNycnIwdOhQvP7664iKirJfp+BiId6bvhqnDpxBZakVsllB0tN3Y8rC30Otca6TIhGRP6rqRLv2UC8EOtmJtqxYxti+RxvViXbdunUYP348PvjgAwwePBhLlizB559/juPHjyMiIgKPPPIIOnToYF+Xv3DhQsydOxdr167FjTfeaL9OcHAwgoODUVJSgr/85S9ISkpCZGQkfv31Vzz77LMoLi7GkSNHuLWdH3JXzlFaWYElx/+Fg5fOwqwVsGqAu9r3x+z4+6BXa734ComIfIu3co6WotkU9VVSU1OxfPlybNmyBcePH3f4xluChFaBbZA09n784Q9/QLdu3Wq8vkwuBgAAt1JJREFURqWlEmte2oBtn++AXCGjskxG/2EJeOHTp2FsG9JUL4WIyKdVfcD+7WCCSx+wD/c70ugP2Pfeew+LFi1CVlYW+vbti3feeQeJiYkAbFuQRUdH4+OPPwYAREdH49y5c9dcY968eZg/fz7Ky8sxcuRIHDx4EAUFBWjfvj3uuOMOvPTSS9c05CP/UlfOAUmCsVMYHrj9HkyeNKnWnEMWCj47+zO+StsLq1rArAV6tuqIhf3GIcJgaqJXQkTk27yZc7QEza6or66kpASnTp2C2WzG8qc/wfl9mQg0BuCt7S82qAneD5/9jL+/tB6VFVZYiisRGR2Ov3z1LGJ7R9X7XCIif1f1AfvxwT4ufcBO6Pc/v/yAJd9SPedYfW47DqizEazS4/X+4xAbXP+XPz/nHMfSXzahQlSiQgu0NgRjYb9x6NOaOQcRUX2Yc7imWS88CA4ORt++fZGYmIghNyZCrdj+D047kdGg5982+kY898k0tIowQm/SIvv8RTx1wwvYvr5hex0TERGgCJVLB5EvqJ5z3DToekiBOgDAudLcBj3/xvDueKXPaEToTAiwAAXlJXh8zyp8lbbHk2ETEbUozDmc4zOvPKZ3FIQCQADpJxtW1ANAtwFdMG/DM4jp3Rl6kxaV1kq89NBirH5hLRRF8VzARERE5JO6hkQCEqBIosFFPQDEBIdjYd+xSDB1QoBFAiplLEj5Gq+lfI1KxerBiImIyJ/5TFFfNWVeyAJpjSjqAaBtu9Z4fs1TuGHkIGiDNdAEqvHpgq8w976FKC0s9US4REQthnx5z1hnDyJf0zXEtn2iogLOl1xs1HONukAk90rCXR36QV8pQVcJfHl+D6bu/RB55sZto0dE5G+YczjHZ155p+4doNaoocgK0hs4/b46nUGHKa/9HmNm3w9doAa6EA12/+sAnrz+eaSduOCBiImIWgYFgCwkpw7OhyJf1FYXjNa6IChSw6ffV6dRqTGxy214Iu5OBCoaGCzA4fxzGL9zGVIL0z0QMRFRy8Ccwzk+U9Tr9Fp0imsPxSqQ+Ws2Ki2Vjb6GJEm4c+JtmPXh4wgJC4bepEX6qUxMS5yDXd/t90DURES+j3vGkr+RJAldgiOgqIDCyjJcsjg3q++2iHi82PshhGmCYTADuWWF+OPuFfg+46CbIyYiahmYczjHp155TO/OELKAtVJG9pkcp68Tf0N3zFv/DDr36AC9UYuKcjPm3rcQa17ZgGa8GQARERE1ka4h7aBItj+nOTFaX+U6Yzss7P979AhpD4NFgmyxYt7hL7Dk+L9gVWQ3RUtERP7Mp4r62IQoKFZb0Z12ItOla4V3CsULn87AwBF9oQvRQG1Q4eM/f4aXRi1GeUm5O8IlImoRZKFy6SDyRdeFREKoACEBZ10o6gGgtS4I83s/iDsiEuzr7Nee+QlP7f8YBZYyN0VMROT7mHM4x6deeUxVszxFIO2k6+vgDUEGPLFkIpKevhvaQA10wRr8d/0uPHVjMjJPZ7t8fSKilkCB5NJB5IvszfIkgfOljWuWVxOtSoM/drsdj3YdCr2sgsEC7M39FRN2LsUvxa4NVBARtRTMOZzjU0V99Q746Sfd8wEoSRLueewOzFg+BUFtAqE3aXE2JQ1PDHoOB7Ycdss9iIh8Gb81J38UExwOFSRbB3wXR+qru6N9H/yl94Noow5EgBnIKr2ESbuWY2vWEbfdg4jIVzHncI5PvfLQDm0Q3CoIilUg7bh7O9b3ubUX5n4xC+2vi4DepEVpSRnmDH8Z6xd/y3X2REREfsag1qJTUFsoEpBWlufW9e89TB2xsN84dA2KhMEiodJSiTmHPsWyk5ugCH/u30xERM7wqaJekiR7s7xL2YUoueTePebbxUbgz5/PRN/fxkMXooVKp8IHz3yChePfhbnc7NZ7ERH5Cu4ZS/6qa0gkFAmoVGRklRe49dqhBiNe6vMQbgnrAYPFts7+49PbMOvA31BSWeHWexER+QrmHM7xuVdevVle+snG71dfn8CQQExfNgX3PHYHNIFqaIM12Pr3/+Lpm+ciJ8190++IiHyFIiSXDiJf1TUkEsrlTOmcG9bVX02v1uLJuOEYH3sLdFYJBjPwc84JTNy1DOdK3H8/IqLmjjmHc3yvqO8dBaF4rqgHAJVKhaSn78YTb09EYCsD9CYtTh08jScGzcaR/x7zyD2JiJorxYVvzP15z1jyfdeFtAMkW7O8c25cV1+dJEm4p+MA/DkhCSa1AQFmIK04FxN2LcN/c4575J5ERM0Vcw7n+Nwrj6nWLC/thGeK+iqDhvfDnz97GuFRodCbdCjKL8Kfhv4F3y7f5NH7EhE1J4pQuXQQ+aquwZc74Lu5WV5NereOwsK+4xAdGAaDBagwm/HMgb9h9a8/sLcPEfkN5hzO8blXHh3fEQBszfI8XNQDQMe4Dpi34RnE39gNOqMW0Ai8M3UllvzxA1RaKj1+fyIiIvKOdgGtEKTWQ5E8M/3+ahEBrfBqn9G4IbQbDBYJmkqB5b9sxpxDa1FmZW8fIiKqmc8V9QHBAWjfJQKKrODCL5mQZfd1o61NcKsgzFz5OIZP/C20gRpogzT458oteOa3f0Fe5iWP35+opSopKcGhQ4ewe/duHDp0CCUlJd4OiWogQ3LpIPJVkiShS0gEhARcNBejtNLzhbVBo8PM7ndjTPSN0Fsl6C3Af7JSMHnXB7hQlu/x+xO1VMw5fANzDuf4XFEP2KbgC6uAudyCi2l5TXJPtUaN0bNH4tHXH0aAUQe9UYvUnSfwxKDncHzPL00SA1FLkJqaiunTp6NHjx4wGo3o168frr/+evTr1w9GoxE9evTA9OnTkZqa6u1Q6TJOhSN/Vr1Z3vmypmleJ0kSkjonYnb8SIRIegRYgF+LsjB+51LsyT3VJDEQtQTMOXwPcw7n+OQrj02IgiJXNcvLbNJ733DfIMxZOwNtO7aGoZUOl3IKMPOWedj0121NGgeRrzlz5gxGjBiB+Ph4rFu3Drfddhs+/PBD7Nq1C4cPH8auXbvw4Ycf4rbbbsO6desQHx+PESNG4MyZM94O3e/JcOWbcyLfVrWtnZDgsWZ5tRnQNhav9RmLjoY2CLAApRXlmL7vI6w58xPX2RPVgTmH72LO4RyfLOpjekcBAoAA0k9caPr79+qMeRueQbeBsdAZtVAgY9HEpVj61GpYK61NHg9Rc7dq1SokJCTg2LFjWLNmDdLS0rBs2TJMnDgRiYmJSEhIQGJiIiZOnIhly5YhLS0Na9asQWpqKhISErBq1SpvvwQi8lNVHfCFBzvg16VDUBss6DMWA1t3gcEiQW0VePvEvzD/yBeokNnbh+hqzDnIH/lmUZ/QGQCgWJUmaZZXE1OoEX/6+An8dsxvoA3SQBukxtfvfo85w19GYW6RV2Iiao5eeeUVTJkyBWPGjMGRI0cwduxY6HS6Op+j0+kwduxYHD16FGPGjMGUKVPwyiuvNFHEdDVOhSN/1iU4AgCgSMD5JmiWV5MgrR7Pxd+L/+s0GLpK2zr77y8cwqO7VyC7vMArMRE1R8w5fB9zDuf45CtvFxsOQ6AeiiyQ7qWiHgC0Oi0emf8QJr40GvpgHXRGLQ5tS8G0wbPx6//Oei0uouZi1apVSE5OxksvvYSVK1ciJCSkxvNeeeUVSJKEXr16OTweEhKClStX4sUXX0RycjI+/PDDpgibriILlUsHkS8L1hrQztDq8rZ2eVCE4pU4VJIKY2N+g1k97kIQdAiwACcKLmD8zqU4mM8pw0TMOVoG5hzO8clXrlarEd2rE4RVIPt8LipKK7wazy0P3YDnPnkSbdqZoDdpkZ2Wi6dueAHb1v3s1biIvOnMmTOYMWMGJk+ejOTk5FrPS09Px6uvvoqgoKBaz0lOTsbkyZPx1FNPcb2bFwhIUJw8hB93oqWWo2pdfblswcUK787GGxIWh1f7jkakzoQAC1BQXoqpez/E+vO7uM6e/BZzjpaDOYdzfLKoB4CYas3yLpzK8nI0wHX9YzFvwyx06RsNvUkLq2zFK2OW4MM5a5pk2z2i5mbq1KkIDQ3F4sWL6zzvmWeewfXXX4+BAwfWeo4kSXjzzTfRtm1bTJ061d2hEhHVqXoHfG+sq79aVFAYFvYdhz6mKARYJEiVCl5P/QcWpHwNi8LePuR/mHOQK5YuXYro6GgYDAYkJiZiz549tZ6bkpKCpKQkREdHQ5IkLFmyxOVruoPPFvWxvaMgqjrge3EKfnWtI1pj9t+fxG/+LxHaYA00gWp8tvBr/PnehSgpKPV2eERNJjU1FRs3bsSrr75a6/Q3ANi+fTvWr19f6y/E6oxGIxYsWICNGzfi2LFjboyW6sOpcOTvuoZEQlQ1y2uibe3qE6ILwPO97sc9HQdAf3md/ddpezF1zyrkenk2AVFTYs7RsjR1zrFu3TrMnDkT8+bNw4EDB9CnTx/ceeedyMnJqfH8srIyxMbG4rXXXkNkZKRbrukOPpttVTXLE7JA2vGm74BfG51eh0mvjsW4F5KgC9JCF6LB3o0HMS1xDs6lpnk7PKImsXz5coSHh+OBBx6o9RxZlvHkk09i8uTJSEhIaNB1k5KSEB4ejvfff99doVIDKEJy6SDyddeF2BI3W7M874/UV9Go1BgfewuejBuOQKGBwQIcuXQe43cuQ0oBcw7yD8w5WpamzjkWL16MKVOmYOLEiejZsyeWL1+OwMBArF69usbzBw0ahEWLFmH06NHQ6/VuuaY7+HxRr8gCaSebx0h9FUmScPsjt+BPq6fCGB4CvUmLjNNZmD7kBez4Zq+3wyPyuM2bNyMpKanOjrPLly/HuXPn8NJLLzX4unq9HklJSdiyZYs7wqQGkqFy6SDydR0D20Kn0kBRNY/p91e7JaInXuozGmHaEASYgbzyIvxxz0p8d+GAt0Mj8jjmHC2LO3KOoqIih8NsNtd4L4vFgv3792PYsGH2x1QqFYYNG4adO3c6Fb8nrtkQPpttGduGILRDGwirrQN+c2wO0+P6bpi3/hl07tkBepMWZrMZ8+5/HX978Qsoine65xJ5WnFxMU6cOIFBgwbVek5eXh7mzp2LP//5zwgLC2vU9QcOHIjjx4+jpKTE1VCJiBpEo1IjNjgcigRkll2CWbZ4O6RrdAmJwMJ+49DD2AEGiwTFYsWLR9bjzWPfwqqwtw+1TMw5qCadOnWCyWSyHwsWLKjxvNzcXMiyjIiICIfHIyIikJXlXM82T1yzIXy2qAeAmN5RUGQFpUXluJRd4O1wahTWsS1e+PRpJP6un22dfYAan8z/HC8++CbKisu9HR6R2/36668QQqBnz561npOcnIw2bdrgySefbPT14+PjIYTAqVOnXAmTGoHT74muNMsTANLK8r0dTo1a64IwL+EB3BnZG/pKCbpKYN3ZnXhy30cosLC3D7U8zDlaHnfkHGlpaSgsLLQfc+bM8fKr8jyfLupjEzrbm+WlNZNmeTUxBOrx2OIJeHDWvdAGaqAL0eDnr/bgqRtewIVTmd4Oj8itqqY4BQYG1vjzX375BStWrMD06dORkZGBs2fP4uzZs6ioqEBlZSXOnj2L/PzaE+aAgACH+5DnKVC5dBC1BFXb2gHNa1391bQqDR69bhgeu24YDLIaBguwP+80xu9YipNFzTdXInIGc46Wxx05h9FodDhqW/seGhoKtVqN7Oxsh8ezs7NrbYJXH09csyF8OtuKSYiCUAAIIP148/6gkiQJdz06DE+v+COC2wRBb9Li3LF0TBs8B/s2/c/b4RG5TdUvzrKyshp/fuHCBSiKgunTpyMmJsZ+7N69GydPnkRMTAxefPHFWq9fXl7ucB/yPFlILh1ELUHXkEhAAhSVaJbr6q82rF1v/KX3g2irCUaAGcguK8CkXR9gc+Zhb4dG5DbMOVqepsw5dDodBgwYgK1bt9ofUxQFW7duxZAhQ5yK3xPXbAiNx67cBGJ7V2+W13w64Nel9809MXf9LLwzdSUyTmWjrKQML/zuFUx+7fd4YNY9kCQmwOTbunbtCkmSkJqaisTExGt+3qtXL3z11VfXPJ6cnIzi4mK8/fbb6NKlS63XT0lJgSRJ6Nq1q1vjJiKqS9fgKx3wz5V6blsid+pu6oCF/cZiUeo/8EtJNixKJV7432c4UZSBx7vdAbXk02M7RMw5yGUzZ87E+PHjMXDgQAwePBhLlixBaWkpJk6cCAB45JFH0KFDB/u6fIvFgtTUVPufL1y4gEOHDiE4ONj+Pqnvmp7g00V9x7j20GjVEFYF6Sd8Zxp7ZHQ4kj+fiZXP/g0H/5+9+46vqj4fOP75nruyF4QEZCUEZYUhIKC4Kq2orWKROnDxU2xFHICtC9E66rZqFakojhZHHbVqKw6so7IEpIYNykiABLLIvut8f3/cJJDKSG5ucm7ufd6v13kZT84597lAcr/POd/n+S5ei6/Gz3O/+wtb12xjxnO/ISZO7gaKjishIYHjjjuOb7755pC/vDp37syECRN+tL9h3dhDfe9gK1eupF+/fiQkJIQgWtEcramNl5p6ESnSXAmkOROo9FaxvboYrXWHuBHfyZXIPYN/xXNbF/N50XoMrXnlhy/ZWlnIvUMuJNERa3WIQgRNxhyRp73HHBdeeCH79u1jzpw5FBYWMnToUBYtWtTY6G7nzp0YxoEboLt372bYsGGN///oo4/y6KOPcuqpp/L5558365ptoUPfonU4HfTs3x3Tr9mzbS8ej9fqkJotLiGW65++mgnTx2OPs+FIsPPZq/9hxsl3UrRjn9XhCdEqP/3pT3n77bfxeELbIdrtdvP22283WSZEtD2tDcwgN6079MeMEE30rW+WV+Wt61CN55w2B9cdeyb/l30aLr9BjAeW7NvMlUvn8kNV0dEvIEQYkzFHZLFizDF9+nR27NiB2+1m+fLlTWZ9fP7557z00kuN/9+7d2+01j/aGhL65lyzLXT40VbW4ECzPL/PT+EPHeuDyTAMJlx/Ntc/fRXxqbG4kh18/99tXDfyFv77xTqrwxMiaL/5zW/Yu3cvb731VrPP+fzzz1m7du0Rj3n77bfZu3cv1157bWtDFC3gR7VqEyJSHNwsb0dN+NfVH0wpxdndj+fOQRNJtsUS64ZdVSVctXQeXxSttzo8IYImY47IImOO4HT8pH5QL0xffQf8MG+WdzjDfzqE2W/MJDMrHVeyk8ryKm756b3845lFaK2tDk+IFut/bAJn/iSD22+/hcrKypBcs6Kigttuu43x48fTv3//kFxTNI+pW7PEjNXRCxE6OYmZaAO06hjN8g4lN7UnDw2dTFZcF2I8UOdx89tv/8rzWxdjatPq8IRosf7HdebMM7rJmCNCyJgjOB0+qW9olqdNTUEYL2t3NN37dmXOW7MYdHI/nEkOsGuevv4FHr/6WTzujlNWIIR2f4Eu+SXPPBBLcXEhM2bMaP01tWbWrFmUlJQwd+7cEEQphBAtl5N4ULO8qo5bKpcRm8z9Qy7kpM7HEeNROLzw3NbF3LrmVap9snSX6Di0Z3VgzPEHp4w5RFTr8El91uBeAGifJn9zx03qAeKT45nx3K85++ozcMTZccTbWfTiv7n59Lso3n34NTSFCAdam+iqueiya0BXkNXTweP3HssLL7zAfffd14rrau677z6ef/55nnzySbKyskIYtWiOYGvbGjYhIkXv+HRsysA06LBP6hvE2J3M6HcOk7PG4vIpXB74vHA9Vy17lvzqEqvDE+KItNbomoXo0svA3BsYc9yTJWOOCCBjjuB0+HfeqWsqSZ0SMf2ags0dpwP+4dhsNn712/P49WNXEJvswpXkYMPyLVw38lbWL9tsdXhCHJI2K9Hl16GrngDq5z65xjH1xuXcd9993HnnnUydOrXF0+IqKiq45pprmDNnDvfffz9XXXVVyGMXR2eiWrUJESlcNgc94ztjKiioKcFn+q0OqVWUUpzf4wRuH3Q+ScpFrAe2VezlyqXPsHSfjDlEeNK6Dl1xG7ri90D9bFbnKKbeuFTGHBFAxhzB6fBJvVKK7PpmeeV791NRGppaGquN+flw7nhtBp17phGT4qR8Xzk3n3YXixZ8ZnVoQjShfVvRJReAe3H9HoVKmIFKeRplJHDHHXcwf/58XnvtNQYNGsSrr7561A61brebV199ldzcXF577TWef/55br/99rZ/M+KQ/Fq1ahMikvRNCHTA92uT3bVlVocTEsPSsnhw6GR6xqQR64Eadx0zVr3MX7Z9Kb19RFjR/l3okkug9p0DO+P+D5X6IsrWScYcEUDGHMHp8Ek9QO9BPRub5XXkuvr/1WtAd+56+2b6jcrBmeTAVCaPXf0sT1//Aj6vz+rwhEDXfYQumQT+bYEdKhmVOh+VcC1KHfj1cvXVV5OXl8eAAQOYPHkyPXr0YNq0aSxYsIDly5fz3XffsXz5chYsWMC0adPo2bMnkydPZsCAAeTl5cndciFE2GjSAb+qY0/BP1i3uFTuH3oJI9P6EONR2HyaP21axJ3fvUGdP7RLhQkRDO1egi7+Jfjqu9arWFTy4xhJt6KUvfE4GXOIaGQ/+iHhL3twL7TZkNTvYcCY4yyOKHSS0hK5ecE0Xn/g73y68CsMu59/PLOIbWt3cuffZpKSnmx1iCIKae1HV/0Rqp87sNN+HCrlGZS95yHPycrK4sMPP2T9+vXMmzePTz/9lHnz5jV5CqQUZOfEMPGCX3L99NnScTZMtKZOLZrr20Rk6pOYCQpMpdlZvQ/oZ3VIIRNvd/G7Aefy5o5lvLlzGYap+Xj3d+yoLubhYZPpGptqdYgiCmmtoeYFdOWjQP0KDbYegTGH49A/f80ac6BIcqRw5llncveDc2TMESZkzBGciEnqob5Z3qZdFkcTenaHnUvnTKLngO785fd/Q9l8fPfleq4beSt3v/Nb+h6fbXWIIoposwxdPgs8/zmwM+YXqKR7UUbcUc8fMGAATz31FABVVVVs3boVt9tNje9fxHWaT1y8QdeU0+mcKB+u4cIksFRMsOcKEUn6NnTANzreWvXNYSiDC3ufSK+EdJ7etAjD42Fz+W6uWPIMDw67hOPTZMwh2o82q9EVt0Pdhwd2Ok9BpTyGMo7+YOtwY468Lzbw6u3vY9cOzsw9VxL6MCJjjuBExO2MXgN7oJQKNMvb0vGb5R3OKReM4Za/3EBatxRcyQ727Sphxsl38tlr/zn6yUKEgPauR5dMPCiht6ESb0clP9qshP5/JSQkMHToUEaNGsXokb8iLj7wK6navSKEUYvW0q1oWKOj+ANWRKaMmGQS7DGYCrZXd9xl7Y5mdOe+/GHoxXR1pRDrgYq6Gq77ZgFv7lgqdfaiXWjfdnTphU0T+vjrUKnPNSuh/18HjznOv/Rc7MoBwNr/bAxVyCIEZMwRnIhI6mPiXBzTNxPTb7Jr8278/o7djfZIcoZmcddbs8g5PgtXsgOf38cDk59k/u/+EtHvW1hP1/4DXXIh+AsCO4w0VOpLqPgrUar1v0RjHP0wVCIANe4VMmgUQoQlpVSgrt6AUncVVd46q0NqMz3jO/PQ0MkMTelNrEehvCaPbHif+9a+g8eU3j6i7ei6fwceIvjqV2FQ8aiUuRiJNzbp2ROsTt3S6NYnA4BN33yPp076RoiOLSKSegisV699Go/bx94dkTcd7mCpGSnc8pfrOeWC0TgS7DjibPzt0fe445wHqCyrsjo8EWG09mJW3Ife/1vAHdjpGIzq9C7KNSpkr6OUjTjXCAB8ZjEe37aQXVu0jqlVqzYhIk3fg5vldfD16o8mwRHD7YPO57zuI3B5A+vZv1+wit8sn8++ugqrwxMRRmsTXfUndPmvQdevaGXrg+r0NipmXEhfa9BJgXp8r8fHppXfh/TaIngy5ghO5CT1g3pi+gNP9vIjqAP+4TidDqbcdzGXzZmEM8GJM9HOqk/+y/QTbmX7unyrwxMRQvv3oUuvgJpXDuyMnYRKexVlywz568UfdJOg2r085NcXwWloWhPsJkSkyUnMRCvQCnZE8BT8BjZlcFn2Kdx43NnEaQcxHlhXns8VS58hr3yn1eGJCKHNCnT5teiqPx3Y6ToT1elNlD30vRwGjT3QZE+m4IcPGXMEJ2LeefbgXqBBmzqilrU7EqUUZ0w+md++OI2UjCRcyQ72bN/LDWNu5+t3pSZZtI72rEGXnA/elfV7HKikezGS70cpZ5u8ZrzrhMavpa4+fMhdcyGa6pMQ6ICvlWZnhD+pP9jJGf24b+iFZDiSiHVDaW0lv1k+n38UrDz6yUIcgfZuQZdcAO5/1+8xUAmzUClPoYyENnnN3IOS+jxJ6sOGjDmCE1lJPaD9moIt0ZHUN+h3Ql/uevtmeg/qgSvZgcfj4e5fPsLLd72BaZpWhyc6GK01uuZ1dOlkMPcGdhoZqLSFqLgL2/S1Y51DULiAQF29EEKEoz6JgVpcM0qe1B8sOyGDh4ZdwsCkHsR4FNrr5/617/DI+vfwmdLbR7ScrvsQXToJ/NsDO1QKKvV5VMKvQ9Kz53C65WSSmhFouLd+6Wb8fhkzi44rYpL6jN7pxCbEYPo1+RujK6mHQMOP21+9idE/Px5Hgh17rI2/3vsWd//yEaoraqwOT3QQWrvRFXegK+YA3sBOx0hUp7+jnEPb/PUN5SLWFXgdj38HXn9hm7+mOLpgu9A2bEJEmni7i2Ni0/AbsLOmBFNHVzKQ7IxnTu5Ezuo6BJdX4fTCmzuWMf2bBZR5pLePaB6tfZiVj6DLbwRdP1a19w/Uz7vGtvnrK6Uap+DXVNSy7bsdbf6a4uhkzBGciEnqDcMgK7cn2qfZV1BCTVWt1SG1O1esk18/egUX/u48nPF2nIl2lr63khvG3E7B5ui70SFaRvv3oEsvgdq3DuyMuwKV9hLK1rnd4oh3yhT8cCNT4YT4sZz6Znluv5e9dfutDqfd2Q0bV+ecwbXH/pRYv40YD3xbuo0rlsxl4/5dVocnwpw2S9FlV0H1/AM7Y85FdXodZe/RbnE0NMsDmYIfLmTMEZyISeqhabO8XZsjd736I1FKcdZVZ3DTc78hsVM8rmQH+Zt2M33Ubaz48FurwxNhSruX19fP59XviUElP4KRdAeqfh3X9tK0rl6a5YUD+YAV4sf6JmbS0JNpexTV1f+vMzJz+f2QX9HZnkCMG/bWlDN1+XN8tPu/VocmwpT2rkMXTwTP0vo9dlTibFTyIygV266xHFxXv/ZrSerDgYw5ghNZSf3gXugo6oB/JINP7s+ct2bRo183XMkOamvqmP3zB3j9wb/L+t+ikdYaXf0iuuxKMEsDO23dA3fKY8+zJKbAsnaBX01SVy+ECFd9EjPqO+BHV7O8QzkuqRsPDZvMcQldifEo/B4vd373Bk9t+hB/lJUmiCPTte+gSy4Cs342h9EZlfYyKv7yNq2fP5yswb2ISwrcSFj7n40yRhYdVkQl9U2a5cl0czJ6deGON2Yw/GeDcSbascUYvHD7q/zhkieora6zOjxhMW3WoPfPQlc+ANQ3N3KORXV6B+UYYFlcNiORmPrXr/NuxG+WWxaLCJC75kL8WE5iVyA6m+UdSporgd8P+RVnZAxqrLP/6w9fcdPKl9nvkd4+0U5rD2bF79H7bwXcgZ2OoYExh3OkZXHZbAYDxhwLQFnRfnZtic6ZvuFExhzBiaikPiu3JwCmP3qWtTua2PgYrnvq/zj/hrOxx9pwJtj5/I0l3DR2NoXb91odnrCI9u1El14IdR8c2Bn/G1TqfJSRYllcjaE0TsHXVLtlqSSryQesED/WPS4Nl+HANGBHlD+pb+A07Fzb96dcnfMTXH6DGA8sL97ClGVz+b5SGp9GK+3fiy69HGoWHtgZezEq7a8oW6Z1gdWTpe3Ci4w5ghNRSX1CSjxdenZG+zT5m3bLFJp6hmFw3nXjuWHu1cSnxuFKdrAtbwfXjbyVNf9ea3V4op1p9xfokl+Cb1Ngh4pHpTyNkTgTpWzWBldP6urDiyb4brTyW1hEKpsy6JOYgamgqLacOp/H6pDCglKK8d2GclfuBaTa4oh1w+6qUv5v2Tz+XbTO6vBEO9Oe1YExh3d1/R4HKukPGMm/RymnpbE1GHRwXb0k9ZaTMUdwIiqph8DTetNvUltVR8nuMqvDCSvHnzGY2W/OJLNPF1zJTqr2V3HLz+7l70/9S26ARAGtTXTVXHTZNaArAjttWahOb6JifmZtcP8jzjWq8Wupq7ee3DUX4tByEjMxjcAgNL+mxOpwwsrAlB48NGwyfeIziPEoPB4Pt3y7kOe2fEq0LQEYjbTW6JqF6NLLwKyfGWpkojq9hoq7wNrg/sdxI/rgcAWaAkuzPOvJmCM4EZjU98L0NTTLkyVV/tcxfTKZ8+YsBp82AGeSA+WAuTe9yCP/9wyeOnnKEKm0WYkuvw5d9QQ03Md0nRFYC9aeY2Voh+SwpeO0ZwNQ6/kO04y+JSqFEOEvJyHwpB6krv5Q0mOSuG/IrxibfhwxHoXDC89//xm/+3YhVT7p7ROptHajK25DV/we8AZ2OkehOv0d5RhsaWyH4oxxctzIPgDs+WEvJbtLLY5IiJaLuKQ+e3CvQM6ipQP+4cQnxXHjs1M555pxOOLsOBLsfPLyF8w67S6Kd8mThkijfVvRJReAe3H9HoVKmIFKeQZlJFga25E0TMHXeKnxyHKMVpK75kIcWk5iJigwDS119Yfhsjm56bizuSz7FFw+hcsDXxZt4Kqlz8qfWQTS/t3okouh9p0DO+OmoFJfRNk6WRfYUUhdffiQMUdwIjCpP9Asb5d0wD8sm83GpFnnMu2PVxKXHIMr2cHGb7YybcQtrFuyyerwRIjouo/QJZPAvy2wQyWhUp9DJVyLUuH94x9/0BT8apmCbyn5gBXi0HISA02+Ah3wJUE9HKUU53Ufwe2DzidZuYj1wPbKfUxZOpev98mYI1Jo91J08fnga+jXFINKfhwj6TaUslsa29FIXX34kDFHcMJ7VB+E7sd2w+G0o32mPKlvhhPOPp47Xr+JLr06EZPiZH9JBTeffhf/mv+p1aGJVtDaj1n5GLr8etDVgZ324wJLx7hOtTa4Zjq4WZ7U1VtLPmCFOLQUZzzpriRMA3bW7JP+NEcxLC2LB4dOpldsJ2I9UOuuY+aqV3j5hy/kz64D01qjq19Al00BXd/PytYD1elvqNifWxtcMw0YcyyGEfi8kqTeWjLmCE7EJfU2u42eA7pj+jWF2/bicUud+NH07NedOW/dTP8Tj8WZ5EAbmj/++s88NW0+Xo/X6vBEC2mzDF02Far/fGBnzM9RaW+g7D2tC6yFHLae2G0ZANR4VqG1z+KIRHt65pln6N27NzExMYwaNYoVKw5/Y2f+/PmcfPLJpKamkpqayrhx4350vNaaOXPm0LVrV2JjYxk3bhxbtmxp67chokBOYiamgiqvm1JPldXhhL2ucancP+QSRnXKIcajsHs1z2z+iDv++zq1soJAh6PNavT+m9CVDwH1DRCdpwQeIjj6HfHccBKfFBco4QW2rc2nqrza4oiEaJmIS+ohUFdv+jSmqdm9tcjqcDqExNQEbn7+Wn56+ak44u044m28P+9jbvnpvZQVlVsdnmgm7V2PLpkInv/U77GhEm9HJT+GMuIsja2llFLEOwNT8E1dTa1XlkKyitaqVVtLvfHGG8ycOZO77rqL1atXM2TIEM4880z27t17yOM///xzLr74Yv7973+zdOlSevTowc9+9jN27TrQLPXhhx/mqaeeYt68eSxfvpz4+HjOPPNM6uqkWZdonYZl7UCa5TVXnN3Jzf1/wYW9xuCsr7P/dE8eVy//M7trZOWijkL7dqBLL4S6Dw/sjJ+GSv0zyki2LrAgNUzB11pLKaqF2nvMESkiMqnPyu2F9ksH/Jay2W1MvmMiVz84mZhEF64kB3n/2cB1I29l86rvrQ5PHIWu/Qe65ELwFwR2GGmo1JdQ8VeiVMf8JSdT8MNDsOvFNmwAFRUVTTa3233Y13v88ceZOnUqU6ZMYcCAAcybN4+4uDgWLFhwyOMXLlzItGnTGDp0KP369eP555/HNE0WLw40h9Ra88QTTzB79mzOO+88Bg8ezCuvvMLu3bt59913Q/7nJaJL38RMtAFaSbO8ljCUwaReY7hl4HkkEqiz37p/D1csfYZvSmTMEe503b8D68/7Ngd2qHhUylyMxJtQymZtcEGSuvrwEIoxRzSKyKS+oVmeNjUFm/dYHE3HM/b8Udy28AbSjknBleygeE8pM06+k0//+qXVoYlD0NqLWXEfev9vgfpEyTEY1eld1EHN5jqiuIOS+mr3cgsjiW6hqG/r0aMHycnJjdsDDzxwyNfyeDysWrWKcePGNe4zDINx48axdOnSZsVbU1OD1+slLS0NgG3btlFYWNjkmsnJyYwaNarZ1xTicKRZXuuM7NSHB4ZeTDdXKrEeqKyr4YaVL/L69q+lzj4MaW2iq55Gl/8GdGVgp61PYIncmHFHPjnMSQf88CA19cGJ0KQ+UBOjfZoCeVIflOzBvbnr7ZvpOyIbV7IDv/bz0OV/Yt6sl/H7/FaHJ+pp/z506RVQ88qBnbGTUGkLUbZM6wILkRhHPwwVmMJX7V4hA7wOLD8/n/379zdut9122yGPKy4uxu/3k5GR0WR/RkYGhYWFzXqtW265hW7dujUm8Q3nteaaQhxO7/h0bMoINMuTpD4o3eM78dDQSzg+JYtYj0J5TR7f+E/uyXsbt196+4QLbVaiy6ehq54isH404PoZqtObKHu2pbGFQmpGCsf0DYydNq/8Hnet9HgQHUdEJvWpGSmkpCdh+jX5m+RJfbBS0pP53cvTOfVXYwJ19nE23v7jB9x+9v1UlFRaHV7U05416JLzwbuyfo8DlXQPRvL9KOWyNLZQUcog3jUCAL9Zitu31eKIolMo6tuSkpKabC5X2/wbffDBB3n99df5+9//TkxMTJu8hhAHcxh2suK7YCooqCnBa0pTz2DEO2K4ddAEzu8+Epc3UGf/z12r+c2K+eyt2291eFFPe7cEeva4P6vfY6ASZqFS/oQyEiyNLZQGnRR4Wu/z+tm4QpqpWkFq6oMTkUk9QFZ9s7yKkkr2F1dYHU6H5XQ6mHLvxVzx+wtxJjhxJjlYvTiP6064lW15O6wOL2rpmtfRpZPBrG8cZmQEns7HXWRtYG2gaV29TMG3QntOhevcuTM2m42ioqZNTouKisjMPPLsk0cffZQHH3yQjz/+mMGDBzfubzgvmGsK0Rx9EjMwDTC1ZldtqdXhdFg2ZTA5+2Rm9DubOBzEemB9eQGXL3mG/5bJmMMquu5DdOkk8G8P7FApqNTnUQm/7rA9ew5HpuBbT6bfBydik/rs3J4HNcuT9epb6/SLTuKWV6aTkpGEK9lB0c593HDiHXz19jKrQ4sqWrsx99+BrpgD1E9JdIxAdfo7yjnUytDaTNxBfQGqpVmeJdrzrrnT6WT48OGNTe6AxqZ3Y8aMOex5Dz/8MPfeey+LFi1ixIgRTb6XlZVFZmZmk2tWVFSwfPnyI15TiOZqWNYOYEeVTMFvrZO69OP+IReR4Uwm1g3ldVVcu+J5/p4vnwHtSWsfZuUj6PIbQdcEdtr7B+rnXWOtDa6NSLM868mT+uBEbFKfNbgX2gwk9QWbJakPhWOH9+Gut28ma3BPXMkOvF4v90x6jBdnv4ZpmlaHF/G0fw+69BKoffPAzrgrUGkvo2ydrQusjcU6BzeWE0hSHx1mzpzJ/Pnzefnll9mwYQPXXnst1dXVTJkyBYDLL7+8SU3+Qw89xJ133smCBQvo3bs3hYWFFBYWUlUVWDNcKcVNN93Efffdx3vvvUdeXh6XX3453bp1Y8KECVa8RRFh+iZmggJTaVnWLkSyErrw0NBLyE3uQYxHgdfPA+ve5cF170qJQzvQZim67Gqonn9gZ8y5qE6vo+w9rAusjXXNziCtayoAG5ZtkT5SosOI2KT+4GZ58qQ+dDp1TeX2hTdy4oSROBLs2GNtvPqHd7hrwsNU76+2OryIpd3L6+vn8+r3xKCSH8FIugOlHJbG1tYM5STOeTwAXn8BHp/8PLc33YppcMHcNb/wwgt59NFHmTNnDkOHDmXNmjUsWrSosdHdzp072bPnQL+UZ599Fo/HwwUXXEDXrl0bt0cffbTxmN/97ndcf/31XHPNNYwcOZKqqioWLVokdfciJBo74Buws7rE4mgiR5IzjtmDJvLzbsNweRVOL7yzcwXTvnmBErf09mkr2rsOXTwRPEvq99hRibNRyY+gVKylsbU1pRS5Jwee1tdW1fH9mu3WBhSF2nvMESkiNqnv2f8YDENh+k0KJKkPKWeMk6kPXsrFt56PM96OM9HOsn+u4vrRt5Mvqw2ElNYaXf0iuuxKMOvrNG3dA3fKY8+zNLb2JHX11tKA1kFuQb7m9OnT2bFjB263m+XLlzNq1IEyjM8//5yXXnqp8f+3b98e+Fn5n+3uu+9uPEYpxT333ENhYSF1dXV8+umnHHvssUFGJ0RT6a4kkhyxmAp2ypP6kLIbNqb0OZ3rjjuTONNOjAe+K93BFUvnsn5/gdXhRRxd+3d0yUVg1o/njE6BGYHxl0dc/fzh5J4kdfVWsmLMEQkiNql3xbo45thumD7N7q17ZPpMiCmlOHPK6cx64VoS0xNwJTso2LKH6aNuY/k/V1kdXkTQZg16/yx05QNA/b9f59hALZtjgKWxtTepq7eWiWrVJkSkU0rRNzET04BSTzUVnhqrQ4o4p2cM5J7BvyLdnkCMG4pr9vPr5c/x4e5vrQ4tImjtwaz4PXr/LYA7sNMxtL5nz0hLY2tvTerqv5akvr3JmCM4EZvUA2QPDjTL83r8FG7fa3U4EWngif24662b6dn/GFzJDupq3dx57kMsvP9tWVO8FbRvJ7r0Qqj74MDO+F+jUuejjFTrArNInHM4YAMkqRdChKc+CQc1y5P16ttE36SuPHT8pfRP7EaMR+H3+Ljruzd5YuO/8Jny8CZY2r8XXXoF1Cw8sDP2IlTaX1G26FshpPegHiSkxAOw9utNMp6NAs888wy9e/cmJiaGUaNGsWLFkceab775Jv369SMmJobc3Fz+9a9/Nfn+lVdeiVKqyTZ+/Pi2fAuRndRn5fbC9EuzvLbWpUdn7njtJkacNRRnoh1bjMFLd77OvRc+Tm1VrdXhdTja/QW65Jfg2xTYoeJRKX/CSJyFUjZrg7OIzYgn1jEIALdvEz5/mcURRRfpRCvE0eUkZqIVaJmC36ZSnfHcNXgSP83Ibayzf3Xbf7hp1cuUywyJFtOe1YExh7dhlqUDlXQ/RvI9KOW0NDarGIbBwBMD5Vn791VIb6521t5jjjfeeIOZM2dy1113sXr1aoYMGcKZZ57J3r2HfiC8ZMkSLr74Yq666iq+/fZbJkyYwIQJE1i7dm2T48aPH8+ePXsat9deey2oP4/miuikPntwL9CgTU3+RvmBbEsx8TFc98QUJs74OY44O84EO1+9tYwbT5rNnh+Kjn4BgdYmumouuuwa0BWBnbYsVKc3UTFnWhtcGIg7uK7e842FkUQfWTNWiKNr6ICvlWZHjTTLa0tOw85vjv0p1+ScgctvEOOBFcVbuXLpM2yp3HP0C4hA75GaV9Gll4FZn7wYmai0V1Fxk6wNLgzI0nbWae8xx+OPP87UqVOZMmUKAwYMYN68ecTFxbFgwYJDHv/kk08yfvx4fvvb39K/f3/uvfdejj/+eJ5++ukmx7lcLjIzMxu31NS2nWkb0Ul9Vm5PALRfy5P6dqCU4he/+Rk3zZtKfFocrmQH29flc90Jt7L60++sDi+sabMKXX4duuoJGtt8uM4I1M/bc6wMLWwc3CyvWprltaugG9bUb0JEg+yEDBQKUyHL2rWTn3Ubwu8HTyLNFkesGwqry7hq2TwWF+Yd/eQoprUbXXE7uuJuwBvY6RxVXz8/xMLIwsegkySpt0ooxhwVFRVNNrfbfcjX8ng8rFq1inHjxjXuMwyDcePGsXTp0kOes3Tp0ibHA5x55pk/Ov7zzz+nS5cuHHfccVx77bWUlLTtzd6ITuozeqUTlxiLKcvatashpw1izpuz6NY3A1eyg+rKam4bfx9v//EDqUs6BO3bii6ZCO7F9XsUKuEmVMozKCPB0tjCSdOkXurq25NMvxfi6GLtTrrHpeE3IL+6BL82rQ4pKvRP7s5DwyaTE59JjEfh9Xi5bc1rzN38Mab8HfyI9u9Gl1wMtW8f2Bl3JSr1RZStk3WBhZljR/TBGRNYMjhPmuW1q1CMOXr06EFycnLj9sADDxzytYqLi/H7/Y1L5jbIyMigsLDwkOcUFhYe9fjx48fzyiuvsHjxYh566CG++OILzjrrLPz+tuv9EdFJvVKKrPpmeSW7y6iukFqr9tI1O4M7/zaToT8ZiDPRgeE0mDfrZR6+8mnctYe+WxaNdN1H6JJJ4N8W2KGSUKnPoRKmoVRE/3i2mN3WCVf9rIVaTx6mKT/PQojwkpMYaJbnMX0U1u63Opyo0TkmiXuH/IpT0/sT41E4vPDSD58za/VfqPLWWR1e2NDupeji88HXUPsbg0p+HCPpdpSyWxpbuHE47fQ7ITDmKNq+j7350vyyI8nPz2f//v2N22233daur3/RRRdx7rnnkpuby4QJE/jggw/45ptv+Pzzz9vsNSM+a8g+qFneri1SZ9We4hLjuGHuVH7xm59hj7PhSLDz6V++ZOapd0X9L0et/ZiVj6HLrwddHdhpPw7V6R2U61RrgwtjB+rqfdR4VlsaSzSRJ/VCNE9O/bJ2ADurZdWd9uSyObj+uPFckX0qLp/C5YGv925iyrK57KiK7nIIrTW6+gV02RTQ9Y1mbT1Qnf6Giv25tcGFMamrt0YoxhxJSUlNNpfLdcjX6ty5MzabjaKipv2/ioqKyMw89MoPmZmZLToeIDs7m86dO7N169aW/FG0SMQn9VmDe6Hrk3ppltf+DMNg4oyfc92TU4hLicGV7GDL6u+5buStrP3PBqvDs4Q2y9BlU6H6zwd2xvwclfYGyt7TusA6AKmrt4Y0yhOieXIObpYny9q1O6UUv+g+nDtzJ5JixBDrhp2VxVy5bC5f7Y3OpEybNej9M9CVDwH15QjOkwM9exz9jnhutJOk3hrtOeZwOp0MHz6cxYsXN+4zTZPFixczZsyYQ54zZsyYJscDfPLJJ4c9HqCgoICSkhK6du3aovhaIvKT+oOa5UldvXVGjh/Gna/PoEuvzriSnVSUVnDzT37P+/M+tjq0dqW96wP1857/1O+xoRJvQyU/hjLiLI2tI4h3jWr8Wurq2480yhOiefomBp7UBJrlSVJvlcGpvXho6GR6x6UT64E6t5ubV/+FBd//O6p6+2jfDnTpr6DuoDW046cFyvyMFMvi6igGjD4WwwgkiVJX337ae8wxc+ZM5s+fz8svv8yGDRu49tprqa6uZsqUKQBcfvnlTabv33jjjSxatIjHHnuMjRs3cvfdd7Ny5UqmT58OQFVVFb/97W9ZtmwZ27dvZ/HixZx33nnk5ORw5pltt5pV5Cf1g3oAYPo0BZt3WRxNdOt+3DHc9dbNDDzpWJxJDrBpnpo2nyd+/We8Hq/V4bU5XfsPdMlF4C8I7DDSUKkvoeKnoJQ8zWwOh607DlvgLmeNZzVaR/6/GyFEx9EtNpVYmxPTgJ2S1FsqIzaF+4dcxJhOxxLjUdi9mnlbPuG2Na9R44v83j667t+B9ed9mwM7VDwq5RmMxJtQymZtcB1EXGIsfYZmAbBjXQEVJZUWRyTawoUXXsijjz7KnDlzGDp0KGvWrGHRokWNzfB27tzJnj0HSrhPPPFEXn31VZ577jmGDBnCW2+9xbvvvsugQYMAsNlsfPfdd5x77rkce+yxXHXVVQwfPpyvvvrqsGUAoRDxXTHik+PJ7J1OcWEpBZv3YJomhhHx9zLCVkJqPDPnX8ubj77Pohc/w7Cb/HP+p2xbl89db80iLbNt13C0gtbewLS3mlcO7HTkolKeRtnabhpOJFJKEecaxf6ad9G6llpPHnGu460OK+IF7n4Hd+Mpih6KCYGhDPokZLDRnU9R3X5qfB7i7E6rw4pasXYns/r/nHfyV/D69q8xtOazwrXsrC7mkeMv5Zi4NKtDDDmtTaiei676E41L5NqyUanPoOx9LI2tI8o9uR9bVv8AwLolmxjzixEWRxT5rBhzTJ8+vfFJ+/86VHO7SZMmMWnSpEMeHxsby0cffRRcIK0QFdlt1uBemH6Tumo3xbtLrQ4n6tnsNi66dQLXPHwZsUlOXEkO1i/dxHUjb2XTN23XQMIK2l+MLr2yaUIfewEq7VVJ6IMkU/DbnzTKE6L5mjbLk6f1VlNKMbHnKG4dOIFE5SLWA99XFHLF0mdYURxhYw6zEl0+DV31FI0JvetnqE5vSUIfpIPr6vOkrr5dyJgjOFGR1Gfn9sL0BX65FUizvLBx4nkjue3Vm+jUPRVXsoPSojJmnDKHj1/+3OrQQkJ71qBLJoD3m/o9DlTSPRjJf0Cptpt+E+lkvfr2p1u5CRFNGpa1A9hZHd1d18PJ8E7ZPDjkErrHpBHrgeq6Wm5Y+SILt/0nIurstXdLoGeP+7P6PQqVMAuV8ieUkWBpbB3ZoJOkWV57kzFHcKIiqc/K7dn4Ny3N8sJL1qCe3PX2zRw3sg/OJAcmfh6Z8gxzb3oRv89vdXhB0zWvo0sng1m/pJHRBZW2EBV3kbWBRQCXvS+2+gY/NZ4VgamGQggRJho64JuGZmeNPKkPJ8fEp/HAkEsYkdqHGI/C5tM8uelf3J33JnX+jtujRdctQpdOAv/2wA6Vgkp9AZXwa+nZ00op6Un06NcNgC2rt1FbXWdxREIcWnQk9YN7AWD6TPI3S1IfbpI7J/Hbl67jJxePxRFvxxFn4+9P/Ytbx9/H/uIKq8NrEa3dmPvvQFfMAeoHCI4RqE7vopxDrQwtYihlEOcMPK33m+W4fVssjijyyVQ4IZovRzrgh7V4h4tbBp7LL3ucgNMbWM/+w11ruGb5cxTVllsdXoto7cOsfARdfgPomsBOe//AcnWusdYGF0Eantb7fX42roisko1wJGOO4ERFUn9MTibOGAfarynYJB3ww5HD6eDyu3/FlHsvwpXoxJnkYM2/1zL9hFv5/r/brQ6vWbR/T+DpfO2bB3bGXY5Kexll62xdYBFIpuC3M5kLJ0SzJTli6RKTjGnAjup9ETG1O9IYyuCSrLHM6n8O8TiJ9cCm8l1csfQZvi3dZnV4zaLNUnTZ1VA9/8DOmHNRnV5H2XtYF1gEypX16tuXjDmCEhVJvc1uo9fAHph+zd4dxbhrPVaHJA7j1F+dyO9evp7UzCRcyQ6K8ou58cQ7+PyNr60O7Yi0ezm65Hzwfle/JwaV/AhG0myUclgaWyRqmtQvtzCSKNGaO+ZRfNdcRK++9XX1NT4PxW5ZBitcjUk/jj8MvYhMZzKxHiivrWbaNy/w9s7lYX0zRnvXoYsngmdJ/R47KnE2KvkRlIq1NLZINEiS+vYlY46gREVSDwea5ZmmZtfWQqvDEUdw7PBs7n7nZvoM7Y0r2YHP7+P+i5/ghdsW4veHV5291hpd/SK67Eow61dWsHUP3CmPPc/S2CJZrDO3ceBSI0/qhRBhJifhQAd8mYIf3nrFp/Pg0MkMSe5FrEehvCYPrf8HD6x7F4/pszq8H9G1f0eXXARm/cxTo1NgRmD85VI/30YyeqXTuXtg+cP1y7bg84bfvwshoiapz8rtifbXd8CXKfhhLzUjlVv/ej1jfzkKR4Ide5yN1x96lzvPfYiq8mqrwwNAmzXo/TejKx8A6m82OMcGatkcAyyNLdIp5SDOGVif3uvfjcdXYHFEkS2wZmzwmxDRJicxk8BDIy0d8DuAJGcstw86n190H46rvs7+3fxvmLbieYrrwqO3j9YezIrfo/ffArgDOx1DUJ3+jnKOtDS2SKeUapyC765xs/Xb7dYGFOFkzBGc6Enq65vlab+WDvgdhNPl5Ko/XMLkOybijHfgTLTzzaJvmT7qNnZssDaJ076d6NILoe79Azvjf41KnY8yUq0LLIo0nYK/zMJIIp80rRGiZaRZXsdjN2xckX0q1x83njhtJ8YDeWU7uWLpXNaV51sam/bvQ5deATULD+yMvSiwqo4t07rAosjBS9vl/WeDhZFEPhlzBCdqkvrswT2BQFJfIB3wOwylFD+9/FR+u2AaSV0ScSU72P1DITeMvp0l731z9Au0Ae3+El3yS/Btqg8yHpXyJ4zEWShlsySmaBTvGtX4tTTLa2MNdWrBbkJEmV7xnbErW6BZXo08qe9ITs0YwL1DLiLdkUiMG0pqK/j1ivl8sGu1JfFoz7f1PXtW1e9xoJLux0i+B6WclsQUjQaN7d/4tdTVtzEZcwQlapL6lPRk0jJTMOuf1IdzAxTxY/1HH8tdb91MzwHH4EpyUFfn5q4JD/PXe9/CNJu/TnlVVRVr1qxh+fLlrFmzhqqqqmafq7WJrnoWXTYVdP10PFsWqtObqJgzW/qWRCsFpt/bAamrF0KEF7thIyuhC6aC3TVleDrwGujRqE9iBg8Nm8yApGOI8ShMj4978t7isQ3v4zOb39undWMOja55FV16KZh7AzuNTFTaq6i4SS19S6KVeg04hsTUeADWfr2pRWNPIdpD1CT1EJiCb/o0VWXVlO8Ljxop0Xzp3Ttxx2szGHXOMJyJduyxNl6+6w3u/dXj1FTWHva89evXc8MNN9C/f3+SkpIYNmwYo0ePZtiwYSQlJdG/f39uuOEG1q9ff9hraLMKXX4duuqPNK6X4ToD1ektlD0nxO9UNIdhxBHrHASA27cVn7/E4ogil9S3CdFyOYmBZnmm1hTUllodjmihVGc8d+VewJmZg3F5FU4vvLF9KdevfJFyz+F7+4RkzKHd6Irb0RV3A/U3hBwn1NfPDwnp+xTNYxgGA+un4FeWVrFzg/Tnaisy5ghOVCX12bk90f7AnTWpq++YYuJc/ObxK5k061wccXaciXb+885ybjzxDnZ/33RVg23btnHWWWcxcOBA3njjDU4//XReeOEFli1bxnfffceyZct44YUXOP3003njjTcYOHAgZ511Ftu2NV2jVvu2oksmgntx/R6FSrgJlfIMykhsp3cuDkWm4LcTWTNWiBZrWNYOYKfU1XdIDsPONX3H8Zu+44jx24jxwKqSH7hi6Vw2V+xpcmzIxhz+3eiSi6H27QM7465Epb2EsnVqj7ctDiP3ZFnarl3ImCMoUZXUZ+X2QpuAlg74HZlSinOuGceMP/+ahLR4XMkOdmwo4LqRt7Ly4/8C8Pzzz5Obm8uGDRtYuHAh+fn5zJ07lylTpjBq1Chyc3MZNWoUU6ZMYe7cueTn57Nw4ULWr19Pbm4uzz//PAC67mN0ySTw13/oqiRU6nOohGkoFVU/PmFJkvr2IU1rhGi5nMRMUGAqLc3yOrhxXQfz+8GT6GRPINYNRdVlXLVsHp/s+Q4I4ZjDvRRdfD741ta/cgwq+TGMpNtRym7RuxcNmjbLk6S+rciYIzhRlZVkHdQsL1+a5XV4g08dwJy3ZnHMsZm4kh3UVNdwx9n3c/FZlzJ16lQuvvhi8vLyuOSSS3A6j9xMxul0cskll7B27Vouvvhipk6dyn1zzkKXTwddP83Ofhyq0zso16nt8O5Ec8QdtIyP1NW3MbljLkSLNHbAN2BHlTTL6+j6JR/DQ8Mu4diETGI8Cr/Hyx3/fZ1fzLgiNGOOu85Hl00BXRY4yNYD1elvqNhftMO7E83R9/gsXHEuANZ+LUl9m5IxR4tFVVLfs393DJuB6TcpkOn3ESGzdxdm/20mw8YNwpnoYJexjdcXLeTee+9l/vz5JCa2bHp8YmIi8+fP55577uHOexfxwqv7A9+I+Tkq7Q2UvWcbvAsRLLstFZf9OABqvWvxm4evcxRCiPbUyZlAiiNOlrWLIJ1cidwz+Fec3mUALq+i9J9r+OCJV0Iz5rjnXV54tT6hd56M6vQ2ytHvyBcQ7crusNN/VKCP0r78Eop2yM06ET6iKql3uhz07HcMpk+z5/sifF6f1SGJEIhLiOX6p6/mpMnD2Wx+x1VXXcXs2bObHLNu3TomTZpEdnY2cXFxdO7cmVNOOYX333//kNecPXs2V111FTPmlLK95GpU8mMoI6493o5ooQPr1fup8aw64rEiODIVToiWU0o1Nsvb7605YnM10XE4bQ6uO/ZMfuE6jp0vfBbyMce2fb8KlPkZKe3wbkRLDRorU/Dbmow5ghNVST0EpuBrv8bn9VO4ba/V4YgQMQyDT9f9i67HZPLHP/7xR9/fsWMHlZWVXHHFFTz55JPceeedAJx77rk899xzPzpeKcXjjz9Op05due7mf6NU9P6SCHcHknqocS+3MJIIJk1rhAhKTmJXaZYXgZRS/OvxV+jaJSPkY47pv1uFUrY2fw8iOLljpVlem5MxR1CirutG1qBe/Pu1r4FAB/zux3azOCIRCps2bWLx4sUsXLjwkNPfzj77bM4+++wm+6ZPn87w4cN5/PHHueaaa350TlJSEg888CCTJ09mw4YN9O/fv83iF8GLk2Z57UDVb8GeK0R06puYiTZA10/BH5zay+qQRAjImCN69RvVF5vdht/nl7r6NiNjjmBE3ZP67IZmeaYmXzrgR4yXXnqJLl26cMEFFzT7HJvNRo8ePSgvLz/sMRMnTqRLly48++yzIYhStAWnvRsOW3cAajyrMbXH4oiEECKgsVme0uyolvrbSCFjjugVGx9DzrDeAOzcsIv9xRXWBiREvahL6rMGB+6Sa7+mYPOeoxwtOorPP/+ciRMnHrXjbHV1NcXFxXz//ff88Y9/5MMPP+SMM8447PEul4uJEyfy6aefhjpkEUINU/C1dlPrybM4mggkU+GECEpWQhcMFKYh0+8jiYw5oluTKfhfb7IwkgglY46gRF1Sn969Ewkp8Zg+LR3wI0RlZSVbt25l5MiRRz121qxZpKenk5OTw80338z555/P008/fcRzRowYwcaNG6mqqgpVyCLEmtbVL7MwkgglH7BCBCXG5qBHfCdMBfk1JfhMv9UhiVaSMYcYNPZAaUTeVxssjCRCyZgjKFGX1CulGpvllRaWU1Uu3Wg7uu3bt6O1ZsCAAUc99qabbuKTTz7h5Zdf5qyzzsLv9+PxHHm69sCBA9Fas3Xr1lCFLEJM6urbmFat24SIYjmJmZgKvKafwtpyq8MRrSRjDjHopOMav5ZmeW1AxhxBibqkHiBrUE9MX+BWTsFmeVrf0TV8QMbFHX3JuX79+jFu3Dguv/xyPvjgA6qqqvjFL36B1oe/tRcbGwuA2+0OTcAi5Fz2HGxGGgDV7pVobVockRBCBDQsawdIXX0EkDGHSOqUSK8BgV4+W9dsp7aqzuKIhIjSpD57cC+0WZ/UyxT8Dq+hpq2mpqbF515wwQV88803bN68+bDH1NbWAoFaNxGelFLEuwJTIU29nzqv3DkPJa1btwkRzfomdgXV0CxP6uo7OhlzCIBBJwXq6k2/yfplh//7FC0nY47gRGVSf3CzvHxJ6ju8rKwslFKsX7++xec2fHju37//sMesW7cOpRQ5OTlBxyjaXrxrdOPXNTIFP7Skvk2IoPVJyACQZnkRQsYcAiD3ZFmvvs3ImCMo0ZnUD+oBgOnT5EsH/A4vISGBnJwcvvnmm8Mes3fv3h/t83q9vPLKK8TGxh6xNm7lypX069ePhISEkMQr2kbcQc3ypK4+xKS+TYigdY1NId7mql+rXqbfd3Qy5hAAg8ZKUt9mZMwRFLvVAVghNiGWbn0yKNq1j12bd2OaJoYRlfc3IsZpp53G22+/zRNPPHHIJWZ+/etfU1FRwSmnnMIxxxxDYWEhCxcuZOPGjTz22GOH/fB0u928/fbbXHjhhW39FkQrxToGYqh4TF1NtWc5WmuUit5f7kKI8GAogz6JGax372Sfu5Jqr5t4h0yt7shkzCG69OhMRq/OFO0oZsPyLXg9PhzOqEyrRJiI2kw2K7cn2qdx13rYly/T4Tq6K6+8kr179/LWW28d8vsXXnghhmHw7LPPcu211/L444/TvXt3/vGPfzBz5szDXvftt99m7969XHvttW0VuggRpezEOYcD4PMX4fXvtDiiyKF06zYhot3BzfLya2TM0dHJmEPAgbp6T52XLat+sDiayCFjjuBEcVLfC9Mf+JvP3yRT8Du64447jjPOOIPbb7+dysrKH33/oosu4pNPPqGwsBCv10tpaSmffPIJ55577mGvWVFRwW233cb48ePp37//YY8T4UOm4LcRqW8TolUalrXTCrbLFPwOT8YcAv5nCv7XMgU/ZGTMEZSoTeqzB/dq/Msv2LTL6nBECDz88MMUFxczY8aMVl9La82sWbMoKSlh7ty5IYhOtIf4Jkn9cgsjiTBS3yZEq+QkZoICLR3wI4aMOUTu2AM3X/Kkrj50ZMwRlKhN6hs64Js+kwJplhcRevXqxX333ccLL7zAfffdF/R1tNbcd999PP/88zz55JNkZWWFMErRluKcw1A4AHlSL4QIHzkJmQCYCnbKk/qIIGMO0aNfN5I7JwKwfskmTNO0OCIRzaK2o0PX7C7ExLnw+X3ky5P6iHHZZZexb98+7rzzTrZv384f//hHEhMTm31+RUUFs2bN4vnnn+f+++/nqquuasNoRagZRiyxzsHUeFbh8f2A178Phy3d6rA6vtZMaYviqXBCNEhwxNA1JoViXzk7q0ukkWeEkDFHdFNKMfCkfiz5xzdUllWzY10BWbk9rQ6r45MxR1Ci9km9zWaj18DuaJ9m784S6qrrrA5JhMjMmTM59/LreOUvf6X/gAG8+uqreDyeI57jdrt59dVXyc3N5bXXXuP555/n9ttvb6eIRSgdXFcv69WHiNS3CdFqDXX1tX4Pe+sqrA5HhMjMmTOZef+lLHztFQYM6i9jjijT0CwPZAp+yMiYIyhRm9TDgWZ5Wmt2bS20OhwRImu3FVIa35v+E2dRZ09m8uTJ9OjRg2nTprFgwQKWL1/Od999x/Lly1mwYAHTpk2jZ8+eTJ48mQEDBpCXlyd3yzuweNeoxq+lrj5E5ANWiFY7uAP+TumAHzHKPAVk/bScW948gZReHhlzRJncsQcn9RssjCSCyJgjKFE7/R4CzfJ0fQf8gk276TOkt7UBiVbzeH08+94S/FphS+zM0wv+yuAMJ/PmzePTTz9l3rx5aH3gJ14pRb9+/bjwwgu59tprpeNsBIh3jQAUoKWuPlRa03wmipvWCHGwnMTM+h8lzfbqvYzs1MfqkEQraW3yzb4FaMNHeraD5995kMS9o2XMEUVyhvUmJt5FXbWbtf/ZKKU1oSBjjqBEfVIPoP2agk27LY5GhMLbX+Wxq3g/btNgUFYmk04djM0weOqppwCoqqpi69atuN1uXC4XOTk5JCQkWBy1CCWbkUKM4zjqvBup867Hb1ZiM5pf4yiEEG0hJ/HgZnnypD4SbKn8N/vcW7DFeUhxdmd42qXYOztlzBFFbHYb/Ucfy7eL8yjZXUbhtr10zc6wOiwRhaI6qW9oZmH6NfmbJanv6PL3lvH2l9/h1QqbYWP2peOwGU0rTBISEhg6dKg1AYp2E+caRZ13I2BS415JYuzpVofUoSkd2II9VwgBPeI64TTsmIZPlrWLADW+MtaUvoHh9KHsJqdlzsJuOJscI2OO6JA7th/fLs4DAnX1ktS3jow5ghPVNfVJnRLp1C0V7dPkb9rVZIqU6FhMUzP3vaV4/BqPqbjsZ8M5trt0PY9WTevqZQp+q0l9mxCtZjdsZCd0wVSwp6YMt99rdUiiFVaW/AWfrkE5vfRLGs8xcUOtDklYJPfkA3X1a6VZXutZMOZ45pln6N27NzExMYwaNYoVK448dnzzzTfp168fMTEx5Obm8q9//avpW9CaOXPm0LVrV2JjYxk3bhxbtmwJLrhmiuqkHgJT8E2/pnp/LWVF5VaHI4L06erNbNhRhMdUdE9PYeo5o60OSVgo/qAO+NUeSeqFEOGhoVmeBgpqSq0OJ+K11cOagupV5Fd/g4rxEudI4cQuv2mT1xEdQ78T+mJ32ABY+7Uk9R3NG2+8wcyZM7nrrrtYvXo1Q4YM4cwzz2Tv3r2HPH7JkiVcfPHFXHXVVXz77bdMmDCBCRMmsHbt2sZjHn74YZ566inmzZvH8uXLiY+P58wzz6Suru1WW4v6pD4rtxfabwKQL3X1HVJpZTUvfbQSn1b4teKOyWcQ44zqypKo57Bl4rQFembUutdgarfFEQkhxIFl7QB2VO+zNpgI9L9JfFs0LPOYtXxT8grK7sdw+Dmpy3XE2JJD/jqi43DFOjl2eDYABZv3yEPCDubxxx9n6tSpTJkyhQEDBjBv3jzi4uJYsGDBIY9/8sknGT9+PL/97W/p378/9957L8cffzxPP/00EPg99MQTTzB79mzOO+88Bg8ezCuvvMLu3bt599132+x9RH1Snz24F9oENBRs2mN1OCIIL/zrG6rrvLhNxTmj+zOqfy+rQxJhoGG9eo2bWs9/LY6mY1McqHFr8WZ18EKEkZyETFBgGlrq6kPs4K7jX3zxBbfeeiuPPfYYb7311mGfuAXju9K3qPGXYsR46RE3gr6JZ4Ts2qLjGnTQ0nZrv95kYSQdXyjGHBUVFU02t/vQD3c8Hg+rVq1i3LhxjfsMw2DcuHEsXbr0kOcsXbq0yfEAZ555ZuPx27Zto7CwsMkxycnJjBo16rDXDAVJ6gcfaJZXsHmXxdGIllq5KZ+v127DYypS4mOZecEpVockwkSTKfhSV986DcvLBLsJIYCmHfB3VIcu0RRgmoFZl08//TQPPPAASiny8vJ48MEH2bZtW0heo7juezZVfILh8uKwOTklY4YsXyaA/0nqpa6+dUIw5ujRowfJycmN2wMPPHDIlyouLsbv95OR0bS5YUZGBoWFhYc8p7Cw8IjHN/y3JdcMhaifo9z9uG7Y7Da0z5Tp9x1MrdvDnz9Yil8rfFoxc9KppCbGWR2WCBNNm+UtB6ZbF0xH15qGd9IoT4hGaa4E0pwJVHqr2FFdLGtah4jWGpvNxq5du3jhhReYO3cuY8aM4dFHH6Wuro4TTjgBn8/H9u3byc7OxjBa/kzLr32sKF6AsvlRDh8jO19FsrNbG7wb0RENPPE4lFJorcmTpL51QjDmyM/PJykpqXG3y+VqdVjhLuqf1DucDnr2PwbTr9nzw148HulG21G8tngN+8qrcZuKE/r14JzR/a0OSYQRpz0Lu9EZgBr3SrT2WxyREEJA3/pmeZXeOsq9NVaHExEabox8/fXX9O/fnzFjxrB8+XJeffVVbr/9dpRSrFq1ipdffpmCgoKgXmNT+SLKPDsxYjx0junD4NQLQvkWRAeXmJpA74E9APjhv9uprpCfbSslJSU12Q6X1Hfu3BmbzUZRUVGT/UVFRWRmZh7ynMzMzCMe3/DfllwzFKI+qYf6unq/xu/zU/hD0dFPEJbbuquYD5atx2MaOB12bp88Tp52iCaUUo119aaurF+3XgRFlrQTImSkWV7byc7OxusNPJx56KGHuPDCCxk8eDAAVVVVrFmzhoSEhBZft9JTRF753wNr0tvgtIybsamon+wq/kfDFHzT1GxY1rbLl0W0dhxzOJ1Ohg8fzuLFixv3mabJ4sWLGTNmzCHPGTNmTJPjAT755JPG47OyssjMzGxyTEVFBcuXLz/sNUNBknoCHfBNX+BfgTTLC38+v8ncfyzBp8GrYeo5o+nZJcXqsEQYalpXv9zCSDq2oBvW1G9CiAP6JGaiDdBKmuWFWvfu3amsrOSMM85g//793HLLLQDU1NTw2GOPccYZZ5CWltZYf98cWmu+KXkJv3KjXF4Gp/6SjNh+Rz9RRJ2D6+plCn7w2nvMMXPmTObPn8/LL7/Mhg0buPbaa6murmbKlCkAXH755dx2222Nx994440sWrSIxx57jI0bN3L33XezcuVKpk8PlHkqpbjpppu47777eO+998jLy+Pyyy+nW7duTJgwIRR/RIckST0HmuVpU1OwSZrlhbsPlq3nhz0luP2KnG6duexnw60OSYSpg+vqa6RZXvAseFL/zDPP0Lt3b2JiYhg1ahQrVhz+72/dunVMnDiR3r17o5TiiSee+NExd999N0qpJlu/fjIwF+2v78HN8qrkSX1rNCxht3PnTjweD5mZmdx///1069YNn8/Hiy++yIsvvsiMGTNwOBzcdNNNQMuWuttevYQ9tWsxYjwkONI5ofP/tcVbEREgV5rlhUY7jzkuvPBCHn30UebMmcPQoUNZs2YNixYtamx0t3PnTvbsOfDQ98QTT+TVV1/lueeeY8iQIbz11lu8++67DBo0qPGY3/3ud1x//fVcc801jBw5kqqqKhYtWkRMTEzLA2wmmTsEZOXWJ/U+Tf5maZYXzorKKnlt8bd4tUIrxR2XjsNhs1kdlghTMY4BGCoBU1dR7V4uTak6iDfeeIOZM2cyb948Ro0axRNPPMGZZ57Jpk2b6NKly4+Or6mpITs7m0mTJjFjxozDXnfgwIF8+umnjf9vt8tHoGh/vePTsSkD0zDlSX0rKaX473//yz333MOkSZM4/fTTGT58ODfddBMffvghf/nLX3C5XJx55pmNT9p8Pl+zf/bd/kpWl7yKcvhRdpNTM27CaUhDXnFonY9JIzOrC4Xb9rJxxVY8bi9Ol8PqsEQzTJ8+vfFJ+//6/PPPf7Rv0qRJTJo06bDXU0pxzz33cM8994QqxKOSEQ3QqVsaiWkJ1NbWki/T78OW1po/v7+MOq8fj6n41WlDGNJHOs+Kw1PKRpxrOFV1X+Az9+HxbcPlyLY6rI6nnbvfP/7440ydOrVx6tu8efP45z//yYIFC7j11lt/dPzIkSMZOXIkwCG/38But7dpkxohmsNlc9AzvjP53r3sqinBZ/qxG3JzuiVM02zsYL9//342b97Mo48+yvLly7nkkksYMWIEw4cPZ/bs2ZSVlZGamtp4bktu5q0ueQ23WYER66VPwqn0Tjgx5O9FRJZBJ/WjcNtevG4vm7/5vsmUfNFMsuJOUGT6PYG7KQ3N8sr37qeyrMrqkMQh/CdvG6u3FOA2FekpCUyfcJLVIYkOoOnSdjIFPxihqG+rqKhosrnd7kO+lsfjYdWqVYwbN65xn2EYjBs3jqVLl7bqfWzZsoVu3bqRnZ3N5MmT2blzZ6uuJ0Sw+iYEOuD7tMnu2jKrw+mw7rvvPv7+979z4YUXMm3aNNasWcNtt93G/Pnz+eGHHwCaJPQtUVS7nh+qvkK5PLjscYzNkGVRxdEdPAU/72uZgh8M6eMTHEnq62Xl9jyoWZ5MwQ83VTVuXvjXCvxa4deKWy76CQmxkb/mpGg9qasPAa1atwE9evQgOTm5cXvggQcO+VLFxcX4/f7GWrYGGRkZFBYWBv0WRo0axUsvvcSiRYt49tln2bZtGyeffDKVlZVBX1OIYPU5uAN+lUzBbynDMNixYwdvvvkmU6dOZfbs2fzf//0fH330EWPGjOGxxx7jT3/6E5999hkej6fF1/eZHpYXv4iymRhOP6PTryHe3rkN3omINLknS119q4VgzBGNZPp9vezBvdBmIKnP37Sb/qOPtTgicbCXP15JeXUdblNx+tA+/GRYjtUhiQ4i1jkEhRONh2qPdMC3Sn5+PklJSY3/f7g1Y9vKWWed1fj14MGDGTVqFL169eJvf/sbV111VbvGIkROYiYoMJVmZ/U+QKboNlfD1Ps9e/aQkpLS2Mne7Xbjcrm49957+f7771mxYgXfffcdv/vd7zjzzDNb9Brr9r9Hpa8QW5yHzJiBDEz+eVu8FRGBjunblZQuyZTv3c+6JZvw+01sNnmGKtqe/Curd3CzPOmAH17Wbivkk1WbcZuKuBgXv7vodKtDEh2IoWKIdQ4FwOPbgddfZG1AHVEIOtEmJSU12Q6X1Hfu3BmbzUZRUdO/p6KiopDWw6ekpHDssceydevWkF1TiOZq7IBvwI4aeVJ/NKZpsn79eoDGWvpevXphGAbffPMNELhR6PP5ABg7dix33XUXp556Kr/97W/Jz89v9muVewpYX/YBhtOLzWbjtMxZKCXDZdE8SikGjT0OgJqKWrbnSZlXi1mw4k4kkN9S9XoN7IFSCtOvyd8szfLChcfr49n3luDXCp9WXDfhJDJSE60OS3QwTderlyn4LdWe9W1Op5Phw4ezePHixn2mabJ48WLGjBkTsvdUVVXF999/T9euXUN2TSGaKyMmmQR7TGBZu2pZ1u5o5s+fz1133cXrr79OcXHgJkjXrl25/PLLefDBB7nzzjvxeDwYhkFRURFvvfUWtbW1XH311aSlpVFeXt6s19HaZMW+BWjDh3L6GNbpYtJcWW34zkQkyj1J1qtvDampD44k9fVi42PolpOJ6TfZtXk3fr/f6pAE8PZXeewq3o/bVAzKymTSqYOtDkl0QAcn9TVumYLfYu1813zmzJnMnz+fl19+mQ0bNnDttddSXV3d2A3/8ssvb1yeCgLN9dasWcOaNWvweDzs2rWLNWvWNHkKf/PNN/PFF1+wfft2lixZwvnnn4/NZuPiiy9ueYBCtJJSipzEQLO8EncVVd46q0MKayNGjCAzM5O//e1vPPnkk3z11VcATJkyhYcffphly5YxYsQILrroIi6++GLS09M577zzMAwDrfVhG3P+ry2V/2afewtGjIcUZ3eGp13alm9LRKhBY/s3fr1WmuW1nDypD4rU1B8ke3BP9mwrxOP2sW9nMZlZGUc/SbSZ/L1lvP3ld3i1wmbYmH3pOGyG3IcSLRfnGgEoQMuT+mC05u53EOddeOGF7Nu3jzlz5lBYWMjQoUNZtGhRY/O8nTt3Nk7BBdi9ezfDhg1r/P9HH32URx99lFNPPbVxfdmCggIuvvhiSkpKSE9PZ+zYsSxbtoz09PQg35gQrZOTmMF/S7YDsKO6mIEp3a0NKIwNHz6c4cOH89JLL/HPf/6TLVu2sHnzZs455xzOO+88xo4dyxdffMHmzZsZPnw4I0aMAODhhx+mZ8+ejf9/JDW+MtaUvoHh9KHsJqdlzsRuONv6rYkIlD2kF3GJsdRU1rL2PxvRWqNU9DZwa7F2HnNECknqD5KV24uv3gk8xcvftFuSeguZpubZ95bi8Ws8pmLK+OEc210G3yI4NiOJGMcA6rzrqPNuwG/ux2YkWx2WOILp06czffqhl5BqSNQb9O7dG62P/En++uuvhyo0IUIiJyGzsVnzjup9ktQfht/vx2azNX5tmia7du1i7ty55OXl8Ytf/IKTTz6ZX/7yl43n7N+/n4ULF5KXl8fLL7/crNdZVfJXfLoGw+mlX9J4jokbdvSThDgEm81gwJhjWfnxfyktLGf390UckxO6njBCHIo89jxIVm5P0KBNTb4sa2epT1dvZv2OIjymont6ClPPGW11SKKDOzAFX1PtXmlpLB2OTIUTIuRyEruCAq00O6ulWd7hNMzKmTVrFl9++SV33XUXS5YsYfbs2ezevZs//OEPPPvss3z33XeN58TExDBs2DCeeuopunXrdtTXKKhexc7qFagYL3GOFE7s8ps2ez8iOgwaK0vbBU3GHEGRpP4g2YN7AaD9moLNktRbpayyhpc+Womvfk36OyafQYxTJpWI1pH16ltBPmCFCLk+iYHZgNIs78iUUhQVFbFmzRquuOIKBg8O9NY5//zz+fOf/0x6ejqvvfYaTz75ZOOqGS6XiwEDBtC/f/8jXRoAj1nLNyWvoOx+DIefk7pMI8YmM7lE60hS3woy5giKJPUHyczqQky8K9ABf6Mk9VZ54cMVVNd5cZuKc0b3Z1T/XlaHJCJAnHTAD5p0ohUi9OLtLo6JTcNvwM6aEkxtWh1S2OrUqRMZGRmsWBH43e3z+fD7/aSmpnL22WeTnZ3Naaed1th3oyXyyt6mxl+KEeOlR9wI+iaOC3X4Igr1G9kHR/0DqTxpltciMuYIjiT1BzEMg6zcnmifZl9BCbXV0o22va3clM9/8rbhMRUp8bHMvOAUq0MSEcJh64LT3huAWs8aTLPW2oCEEFGvT2IGpgK338veuv1WhxOWTNPEZrMxfPhw3n//fZYuXYrdbm+ss09KSqJv376NK1mYZvNvjhTXfc/G/R9juLw4bE5OyZghDc1ESDhjnBw7og8Au7cWUrKnzOKIRKSTpP5/ZOf2wvQHbvPskin47arW7eHPHyxtXJN+xqRTSE2MszosEUEapuBrvNR41lgbjBAi6vVNzETXj8S2S119o4MbXxqGgVKKWbNmceqpp3LVVVdxxx138Mknn/DnP/+ZBx98kJycHOx2O1rrJitjHIlf+1hRvABl86McPkZ2uoJk59Hr74VoLpmCL9qTJPX/I2twL3R9Up+/aY/F0USX1z9bw77yatymYuRxPfj56AFWhyQiTJzz4PXqZQp+s0l9mxBtIiexoQO+NMs7WMPT8o0bN/LGG2+wYMECdu/ezW233cZjjz3Gf//7Xx588EE+/vhjzjvvPC677LIm5zXHpv0fUebZiRHjpXNMHwanTWqT9yKiV64k9cGRMUdQpPvY/8jK7QkEmuXlb9plcTTRY+uuYt5fuh6PaeB02Lnj0nEyBU6EXPzBdfUeSeqbqzV1atFc3ybE0eQkdgUCzfJ2SrM8IFAvb7fbeffdd3nuuedISUmhpKSEp59+mpdeeomzzjqLs846ix9++IEePXo0Ppk/eOm7o6n0FJFX9k5gTXqb5rSMm7EpGRKL0Bow5liUUmityZOkvtlkzBEceVL/PxqSetOvKZBl7dqFz28y9x9L8Gnwarj67NH07JJidVgiAjntvbEbgUZKNe6VaO2zOCIhRDTrHpeGy3BgGjL9HgLT7u12O9XV1dx7771cc801vPrqq1xyySWkpaXRp08ftNZorcnOzsbhcDQm9c1N6LXWfFPyEn7lRrm85KacT0Zsv6OfKEQLJaTEN66stS1vJ1Xl1RZHJCKZJPX/IzE1gfQendA+TcHmPU3qukTb+Oey9fywpwS3X5HTrTOX/2y41SGJCKWUanxab+pq6rzrLY6oA5FpcEKEnE0Zjc3yimrLqfN5rA7JUg0z9D744AOOPfZYJkyYwI4dO3jyySeZPXs28fHxLFmyhFtvvbVx+bqWzurbXr2UPbVrMWI8JDjSGZV+VcjfhxANGurqtdasX7rZ4mg6EBlztJgk9YeQPbgXpt+kprKWUulW2aaKyip5dfG3eLVCK8Udl47DYW/e3XYhgiFL2wVB6tuEaDN9EjIwjcCPSn5NidXhhIWuXbvi8QRucNx3332cccYZnHbaaQA4HA42b96M1+tt8XXd/kpWlyxEOfwou8mpGTfhNKQhr2g7B9fVyxT8ZpIxR1AkqT+ErNxemL6GZnkyBb+taK358wfLqPP68ZiKC04ZwpA+0nlWtK2GDvgA1e7lFkbScciasUK0nb6JmZj1D5t3SF09ADk5OQBce+21fPfdd9xzzz2N3/vTn/7EoEGD6N69e4tnU64ueQ23WYHh8pKdcAq9E04MadxC/C/pgN9yMuYIjiT1h5CV27Pxbo8k9W3nP3nbWL25ALepSE9JYPr5J1kdkogCMY7jMFQSEHhSLyU2Qggr5SRmggLT0Oyskbp6rTXdunXjvPPO4/vvvycnJ4evv/6apUuXMmfOHLZv386cOXMaj22uotr1/FD1FcrlwWWP4+SM69vqLQjRKC0zhW45mQBsXvk9nrroLrERbUeS+kNoaGoRaJYnHfDbQlWNmxf+tQK/Vvi14paLfkJirMvqsEQUUMpGvGsEAH6zBI/vB4sj6gBkKpwQbSYnMTDgNxXskGZ5jTXyl156KVdffTV2u52HHnqIX//619TV1fHoo4/icDjw+XzNXpPeZ3pYXvwiymZiOP2MTr+GeHvntnwbQjTKPSnwtN7r8bHxm+8tjqYDkDFHUGT9jkPofmxXHE472mdSsFnWqm8LL3+8kvLqOtym4vShffjJsByrQxJRJM51ApV1nwGBKfguRx+LIwpvsryMEG0nxRlPuiuJcl8FO6r3obWO+iVdTdPEMAx+9atfceqpp2KaJrW1tWRnZzceY7c3fwi7bv97VPoKscV5yIwZyMDkn7dF2EIc0qCx/fjo5c+BwBT8wSf3tzagMCdjjuDIk/pDsDvs9BzQHdOv2bNtLx63TJUJpbXbCvlk1WbcpiIuxsXvLjrd6pBElGlaVy/N8o5K7poL0aYaOuBXed2UeqqsDsdyhmE0Tq3PyMiga9euTRL6lij3FLC+7AMMpxebzcZpmbNQSoa/ov1IXX0LyZgjKPJb7TCyBwea5Zl+kz3f77U6nIjh8fp49r0l+LXCpxXXTTiJjNREq8MSUSbWORhFoNxDknohhNVyorBZ3tHq4UMxW0FrkxX7FqANH8rpY1ini0lzZbX6ukK0RLc+GaRlpgCwfulm/D6/tQGJiCRJ/WFkDeqJ9jd0wJe6+lB5+6s8dhXvx20qBmVlMunUwVaHJKKQoVzEuYYC4PXvxOuThphHJHfNhWhTfRMz0QZopaOmrr4haV+9ejXPPvssDz30EF9++WXj+vOhsKXy3+xzb8GI8ZDi7M7wtEtDdm0hmksp1fi0vqaylu//u8PiiMKcjDmCIkn9YWTVN8vTppYO+CGSv7eMd77Kw6sVNsPG7EvHYWtmkxshQi1OpuA3mywvI0TbOrhZ3s4oSOp9Ph8AH330Eb/97W/59ttvWbt2LVOnTmXt2rUheY0aXxlrSt/AcPpQdpPTMmdiN5whubYQLTXoJJmC31wy5giOZFSHkT24JwDaJx3wQ8E0Nc++txS3z8RjKi772XCO7Z5udVgiisU7T2j8WpL6o5C75kK0qd7x6diUgWlERwd8u92O3+/n7rvv5te//jXPPfcckydPJiMjg+OPPx6AvXtbV/q4quSv+HQNyumlX9J4jokbForQhQhK7sF19V9LUn9EMuYIiiT1h5GakUJKelJgWTvpgN9qn67ezPodRXhMRff0FKaeM9rqkESUi3MNp+FXYLVnubXBhDv5gBWiTTkMO73j0zEVFNSU4DV9VofU5r744gsyMjKYNGkShYWFzJ49m1tuuYXU1FTWrVvHI488wubNm4O6dkH1KnZWr0DFeIlzpHBil9+EOHohWqZ3bk/ikmIByPvPxqP2lIhqMuYIiiT1h6GUIqu+Wd7+4kr2F1dYHVKHVVZZw8sfr8RXvyb9HZPPIMYpqykKa9mMRGIdgwBwezfh85dZHJEQIprlJGZiGmBqza7aUqvDaXO9evXC4/GglOLRRx/lhBNO4OyzzwbAZrOxbt06TNNs8XU9Zi3flLyCsvsxHH5O6jKNGFtyqMMXokVsNqNxCv7+fRXywFCEnCT1R3Bws7yCzVJXH6wXPlxBVa0Xt6k4Z3R/RvXvZXVIQgCB9eob1HhWWhhJeJP6NiHaXpMO+FWRPwU/MzOT5ORkLrjgAj799FMeeughlFJorfnjH/9I37596dev39Ev9D/yyt6mxl+KEeOlR9wI+iaOa4PohWg5WdqueWTMERxJ6o8ga3AvtBn41yHN8oKzalMB/8nbhsdUpMTHMvOCU6wOSYhG8a6D6+plCv5hyVQ4Idpc38RMUGAqHZHN8hqeuhcWFlJRUUF8fDzXX389sbGxdO3alTfffJOPP/6YW2+9lfXr13Pfffc1Oa85iuu+Z+P+jzFcXhw2J6dkzAjJ0nhChELuQc3y8iSpPzwZcwRF5kAfwcHN8iSpb7lat4c//3Np45r0MyadQmpinNVhCdGoaVIvzfIOpzV3v6P5rrkQLdHYAT8Cm+X5/X5sNhsFBQX84Q9/4KyzzuKnP/0pJ554IgAffPABr7/+OqWlpZx99tk8/PDDJCYmNp7XrNfQPlYUL0DZ/CiHj5Gd/o9kZ7e2fFtCtEjfEdk4XA68bq80yzsCGXMER5L6I+g1oDuGoTD9Jrtk+n2Lvf7ZGvaWVeE2DUYe14Ofjx5gdUhCNGG3dcZl74Pb9z21nu8wzVoMI9bqsIQQUSjdlUSSI5Zaby07q/dZHU5INSTms2bN4phjjmH06NHExMQAMHTo0MbkvqioiIyMjB+d1xyb9n9EmWcntngvnWP6MDhtUgjfgRCt53Q56HdCDnlfbaBw216Kd5XS+Zg0q8MSEUKm3x+BK9bFMcd2w/Rpdm0pxO/zWx1Sh/H97mLeX7oej2ngdNi549JxMgVOhKUDdfU+ajyrLY0lbMlUOCHanFKKnIRAs7xSTzUVnhqrQwqJhi7fH374IUVFRTzwwAOkp6fzww8/cMMNN3D++eczY8YMampqmiT0LVHpKSKv7J3AmvQ2zWkZN2NT8txKhJ+D6+plCv5hyJgjKJLUH0VWbqBZntfjo3BHZN05bys+v8kz/1iCT4NXw9Vnj6ZnlxSrwxLikOJdoxq/lin4hyEfsEK0iybN8iJkCn7DDf2dO3fSq1cvXC4XX375JU888QSFhYVMmTKFlStXsnJlcM1KtdZ8U/ISfuVGubzkppxPRmzLG+wJ0R5ypVne0cmYIyiS1B9Fdm4vzIYO+Jt2WRxNx/DPZev5YXcJbr8ip1tnLv/ZcKtDEuKwDq6rr5Gk/pBUKzchRPPkJGaiFWgF+RGS1DcYNmwYe/fuZebMmdx4443k5OTwxBNPcNFFF5GTk8MPP/wQ1HW3Vy9lT+1ajBgPCY50RqVfFeLIhQid/qP7YhiBT0ZJ6g9NxhzBkaT+KLIG9wQN2tTkb5S6+qMpKqvk1cXf4tUKrRR3XDoOh735NXFCtDeHrQd2W6BBVY1nFVp7LY5ICBGtGjrga6XZXhNZSX1ubi7nnnsuXbp0YebMmdxwww1069aNHTt2sHbtWoYOHQocmK7fHG5/JatLFqIcfpTd5NSMm3Aa0pBXhK/4pDiyh/QGYPu6fCpKq6wNSEQMKTg6iuzBvQDQfk3BFknqj0RrzZ8/WEad14/HVEw6dQhD+kjnWRHelFLEu0axv+YfmLqGWs9a4lzDrA4rvLRmSlsUT4UToqWyEzJQKEyl2dGBm+VprZv00dm3bx/p6elce+21mKaJYQSeKa1bt44HHniA008/naFDh/7ovKNZXfIabrMCI9ZLdsIp9E44MeTvRYhQyx3bj63fbkNrzbolmxjzc5nR2oSMOYIiT+qPIqNXOnGJsZg+TcGmPVaHE9b+k7eN1ZsLcJuK9JQEpp9/ktUhCdEs8U5Z2u5IGpaXCXYTQjRPrN1J97g0/AbkV5fg181foz2cNDxtf/fdd7npppuYPHkyU6dOZePGjY0J/a5du3j99ddJSUnh/vvvb3JecxTVrueHqq9QLg8uexwnZ1wf+jciRBsYJHX1RxSuY47S0lImT55MUlISKSkpXHXVVVRVHXmmRV1dHddddx2dOnUiISGBiRMnUlRU1PT9KvWj7fXXX29xfJLUH4VSit71zfKKd5VSUxkZ3WhDrarGzQsfrsCvFX6tuOWin5AY67I6LCGapUldvUeS+h+RpjVCtJuGZnke00dh7X6rw2kxv9+PYRhs3LiRhx56iLS0NO6++25WrFjBJZdcwiOPPEJpaSnHHHMMN954I3PmzMHhcDSe1xw+08Py4hdRNhPD6Wd0+jXE2zu38TsTIjQGnXRc49eS1B9CmI45Jk+ezLp16/jkk0/44IMP+PLLL7nmmmuOeM6MGTN4//33efPNN/niiy/YvXs3v/zlL3903IsvvsiePXsatwkTJrQ4PknqmyE7t+eBZnmb5Wn9obz88UrKq+pwm4rThvThJ8NyrA5JiGZzOY7DZiQDgSf1uoM+HRNCdHw5iYFl7YAOuV59w9ryd999N+eccw5z5szB6XQSExPDlVdeyWuvvcb06dP58MMP6dy5M126dGlyXnOs2/8elb5CjBgPmTEDGZj88zZ5L0K0hdSMFLof2xWAzat+oK7GbXFEkaeioqLJ5na37s94w4YNLFq0iOeff55Ro0YxduxY/vSnP/H666+ze/ehy7P379/PCy+8wOOPP85PfvIThg8fzosvvsiSJUtYtmxZk2NTUlLIzMxs3GJiYlocoyT1zZA9uBe6PqmXZnk/tm57IZ+s2ozbVMS6nNxy8elWhyREiyhlEFc/Bd9vluH2bbU4ojAUZnfMhYhUOQc1y9vZQTvgb9y4kaSkJC677DIAfv/733PppZdyww03cMkll7Bq1Sp+97vfHXXq6qGUewpYX/YBhtOLzWbjtMxZKCXDWdGx5I7tD4Df52fjChlz/Egrxxw9evQgOTm5cXvggQdaFc7SpUtJSUlhxIgRjfvGjRuHYRgsX778kOesWrUKr9fLuHHjGvf169ePnj17snTp0ibHXnfddXTu3JkTTjiBBQsWtKgUqYE0ymuGrIOb5W2WpP5gHq+Pue8txa8VPq2Yef5YMlITrQ5LiBaLd51AZd0nQOBpfYzjWIsjCh+tqVOTmnohWqZvYmA1DlPB9g74pB6gS5cujBs3juTkZBYvXgzA+eefD8AJJ5xAXFwcEydOJCEhAb/f3+yn9FqbrNi3AG34MJw+hnW6jDRXVpu9DyHayqCx/fhwwWdAYAr+0NMGWhxR+AjFmCM/P5+kpKTG/S5X60qCCwsLG2cVNbDb7aSlpVFYWHjYc5xOJykpKU32Z2RkNDnnnnvu4Sc/+QlxcXF8/PHHTJs2jaqqKm644YYWxShJfTNkDeoBgOnT5EtS38Q7X+Wxa185HtNgUFYmk04dbHVIQgSl6Xr1y+mUcKmF0YQZ6UQrRLvpFptKrM2J3/B02Cf1aWlpXHDBBRiGQVxcHB6Pp3E66fLly9mwYQPTpk0DWjbtfkvlv9nn3oItzkOKszvD0+T3tOiYDm6Wlyd19U2FYMyRlJTUJKk/nFtvvZWHHnroiMds2LAhyGCa584772z8etiwYVRXV/PII49IUt8W4pPjyeiVTklRKbs27WmyHEs0K9hXzttf5eHVCsOwMfvScdjkz0V0UDHOXJSKQes66YAvhLCMoQz6JGSw0Z1PUd1+anwe4uxOq8M6ooan7aZpopSivLyc1NRUIPBUqqysjCuvvJJevXrx5Zdf8tprrwG0aDxV4ytjTekbGE4fym5yWuZM7EZ4/7kIcTiZvdPpfEwaxbtK2bBsM36fH5u9+Te4RGjMmjWLK6+88ojHZGdnk5mZyd69e5vs9/l8lJaWkpmZecjzMjMz8Xg8lJeXN3laX1RUdNhzAEaNGsW9996L2+1u0QwDSeqbKWtwT/YtKqa2uo7i3aV06R7dXVZNUzP3H0tw+0w8pmLK+OEc2z3d6rCECJqhnMQ5j6favQSvfxce3y6c9mOsDissyPR7IdpXTmIm68vyAcivKea4pG4WR3R4Pp8Pu92OaZo8/PDDrF69GqfTSefOnbntttvIzs7m9ddf59lnn8XpdPLYY48xaNCgFj8gWVXyV3y6BsPppV/SeI6JG9aG70qItqWUYtDYfnz+xhLqqt1s/XY7x43sY3VYYaE9xxzp6emkpx89fxkzZgzl5eWsWrWK4cOHA/DZZ59hmiajRo065DnDhw/H4XCwePFiJk6cCMCmTZvYuXMnY8aMOexrrVmzhtTU1BaXDMhj1WbKzu2F6avvgC/N8lj87WbW7yjCYyq6d05h6jmjrQ5JiFY7eAp+tfvQjU+iUpguLyNEpGpY1g4I2yn41dXVlJSUYLcHng/dfPPNLFmyhCFDhnDyySeze/duxo0bx2uvvUZ2djaPPPII9957Lz/72c+AQFLTXAXVq9lZvQIV4yXWkcyJXX7TJu9JiPY06CSZgn9IYTjm6N+/P+PHj2fq1KmsWLGCr7/+munTp3PRRRfRrVvgpuuuXbvo168fK1YEZnsmJydz1VVXMXPmTP7973+zatUqpkyZwpgxYxg9OpA3vf/++zz//POsXbuWrVu38uyzz/KHP/yB66+/vsUxypP6Zsoe3KvxH0vB5j0cPy56a8fLKmt46aOV+OrXpL998hnEOOWfkuj44l0H7rbWuFeQGv/jtUSjkTypF6J9NXTANw3NjjBtlvfwww9TUVHBJZdcQo8ePSgoKODBBx9kwIABAEyYMIHXXnuNl156ib59+zJixIgmT+abm9R7zFpWlryCsvsxHH7GdrmOGFtym7wnIdpT7kF19Wu/3sgFM86xMJrwEa5jjoULFzJ9+nTOOOMMDMNg4sSJPPXUU43f93q9bNq0iZqamsZ9f/zjHxuPdbvdnHnmmcydO7fx+w6Hg2eeeYYZM2agtSYnJ4fHH3+cqVOntjg+ycSaqaEDvukzo75Z3oIPv6Gq1ovbVJwzuj+jB/SyOiQhQiLWeTxgA/xSV38waZQnRLvKOagD/o4wfVLfvXt3Fi9ezFNPPcXo0aNJSEjA6TxQ456RkcHkyZP56KOP+Oyzz5osBdUSeWVvU+0vwRbvpUfcCPomjjv6SUJ0AL0GdicxNZ7KsmrWfb0RrXWLZrBErDAdc6SlpfHqq68e9vu9e/f+0VJ0MTExPPPMMzzzzDOHPGf8+PGMHz8+JPHJ9PtmOiYnE4fLEVjWbtMuq8OxzKpNBXyV9wMeU5ESH8vMC06xOiQhQsZmxBPrHASA27cZn7/U4oiEENEoyRFLl5hkTAN2VO8Las3itjZ16lQeeOABevTowccff8ySJUv4xz/+gc/nazwmPT2dU045hR07duD3+1v8GsV1P7Bx/8cYLi8Om5NTMmZI0iMihmEYDDjxOAD2F1eSL+W9ohUkqW8mm91G74HdMf2aou37cNd6rA6p3dV5vPz5nwfWpJ8x6RRSE+OsDkuIkIp3HpiCL0/r64VhfZsQka5vfV19jc9DsbvS6nAOKSsrq7H+84QTTuBf//oXjz/+ON999x0AGzdu5IMPPuDEE09s7I7fXH7tY0XxCyibH+XwMbLTFSQ7w7dhoBDBOHgK/ndfte3SaR2GjDmCIkl9C2QNDjTLM03Nrq2FVofT7l77bA17y6pwm4qRx/Xg56MHWB2SECEX12S9eknq4UB9W7CbEKLlchIyMetHaeHaLK/BuHHjePLJJznrrLP4+uuvueGGGzj33HN5/PHHmTBhApMnTwZoUbf7Tfs/osyzEyPGS+eYPgxOm9RW4QthmYOb5a2VZnmAjDmCJUl9C2Tn9kL76zvgR1ld/fe7i3l/yTo8poHDbueOyWfIFDgRkZp0wPdIB3xA7poLYYGcxEy0Aq3Ct1newVJTU7n55pu5/fbbGTx4MLt27SIzM5Np06YBtOgpfZVnL3ll7wTWpLdpTsuYhU1JGygRefoOz8YVG+hFsfZrSeoBGXMESZL6Fmholheoq4+epN7nN3nmH0vwafBqmHrOaHpmpFodlhBtwm5Lw2XvC0CtZy1+s9riiIQQ0SgnMQMI72Z5hzJq1Cgee+wxrrjiCo4//nji4+PRWjf7Kb3WmhUlL+FXbpTLS27K+WTE9m/jqIWwhsNpp98JOQDs3VnM3p0d52ddhBdJ6lsgK7cnEEjqo6kD/j+Xb+CH3SW4/Yqcbp25/GfDrQ5JiDZ1YGk7P7We1ZbGEg6U1q3ahBAt1ys+HbuyBZrl1YT/k/qDORwObrjhBiZMmNDic7dXL2VPbR5GjIcERzqj0q8KfYBChJHckw/ctJL16mXMESxJ6lsgtUsyqRnJmH5N/sZdYdmNNtSKyip59dPVeLVCK8Udl47DYbdZHZYQberguvpqt0zBl6lwQrQ/u2EjK6ELpoLdNWV4TN/RTwpTzS3Xc/urWF2yEOXwo+wmp2TciNOQhrwisg0aK3X1TciYIyiS1LdQQ7O8qrJqyvdVWB1Om9Ja89wHy6nz+vGYigtOGcKQPtJ5VkS+A0/qpQM+SNMaIaySkxholmdqza6aEqvDaXOrS1/DbVZguLxkJ5xCVsJJVockRJvrP6ovhi2QkkldvYw5giVJfQsFmuUFmr0UbN5jcTRt6+u121i1OR+3qUhPSWD6+fLhKqKD034MDtsxANR4VmPq6FvCUghhvYZl7aBj1dUHo6h2PT9UfolyeXDZ4zg543qrQxKiXcQmxNB3WBYAO9YXUFESnktYivAmSX0LZQ/uhTYBDQWbdlkdTpupqnHz/L9W4NcKv1b87sLTSYx1WR2WEO2moQu+1nXUefIsjsZiMhVOCEv0ScgABabSEZ3U+0wPy4tfRNlMDKef0Z2nEm/vbHVYQrSbJlPwv95kYSRhQMYcQZGkvoWipVneyx+vpLyqDrepOG1IH34yLMfqkIRoV3EyBb+RTIUTwhp9EzMBAs3yqjpWs7yWWL//PSp9hRgxHjJjBjIw5RdWhyREu2paV7/BwkisJ2OO4EhS30I9+x+DYTMw/Sb5GyPzSf267YV8smozblMR63Jyy8Wny5r0Iuo0Wa8+ypN6uWsuhDU6uRJJccR1uGXtWqLcU8C6sg8wnF5sNhunZc5CKRmeiugy6KTjGr+O+g74MuYIivzWbCFnjJMex3XD9Gn2fF+Ez9txu9EeisfrY+57SzFR+LRi+oSTyEhNtDosIdqdy94Xm5EKQI1nBVqbFkckhIg2SqnGZnn7vTWUe6qtDimktDZZsW8B2vChnD6GpV1EmivL6rCEaHfJnZPo2T/Qy2frt9upra6zOCLR0UhSH4Sswb3Qfo3P66dwe2RNh3vnqzx27SvH7VcM6p3JpNOGWB2SEJZQSjU+rfeb+3F7N1sckXVkKpwQ1slJ7NrYLG9nhD2t31r5b/a5t2DEeEhxdmd4p8usDkkIyww6KTAF3+/zs3H5FoujsY6MOYIjSX0QsnN7YfoD/2ryN0VOXX3BvnLe/ioPr1YYho3Zl43DZsg/ERG94pwHTcH3RPEUfJkKJ4RlchIz0AboCJuCX+Mr49vSNzCcPpTd5LTMmdgNp9VhCWGZg+vqo3oKvow5giIZWxCyB/cEDdrUEdMB3zQ1c/+xBI/PxGMqLv3p8RzbPd3qsISwVNO6+uUWRmI9uWMuhDVyGprlKc2O6siZHbiq5K/4dA3K6aVf0niOiRtmdUhCWCr34KT+qyhO6pExRzAkqQ9Ckw74EfKkfvG3m1m/owi3qejeOYWpPx9tdUhCWC7WOQilYoFAUq91lH9iCCHaXXZCFwwUphE50+8Lqlezs3oFKsZLrCOZE7v8xuqQhLBcRq900nt0AmDj8i14PZHVt0u0LUnqg5DeozPxyXGYPk1BBCT1ZVU1vPTRSnz1a9LfPvkMYp0Oq8MSwnJKOYhzDgfA5y/E68+3OCKLaN26TQgRtBibkx7xnTAVFNSU4DP9VofUKh6zlpUlr6DsfgyHn7FdriPGlmx1WEKEhYa6eneth62rt1kcjUVkzBEUSeqDoJQiu75ZXmlhOdX7O3Y32gX/+oaqWi9uU3H2qH6MHtDL6pCECBvxsl69NK0RwmI5iZmYCjymn8LacqvDaZW8srep9pdgxHjpETeCvonjrA5JiLCRe3L/xq/zvo7OKfgy5giOJPVBysrtiekL/MvJ37zH4miCt2pzAV/l/YDHVCTHxzJr0qlWhyREWJG6eixpWvPMM8/Qu3dvYmJiGDVqFCtWHP6Gyrp165g4cSK9e/dGKcUTTzzR6msKEU5yEgLL2gEduq6+uO4HNu3/BMPlxWFzckrGDJRSVoclRNg4uK5+bbQ2y7NgzBEJJKkPUvbgXmgz8C+nozbLq/N4+fMHS/HrwJr0MyedQmpinNVhCRFW4pzHowiUo9RE65N6s3VbS73xxhvMnDmTu+66i9WrVzNkyBDOPPNM9u7de8jja2pqyM7O5sEHHyQzMzMk1xQinOQkZoJqaJbXMevq/drHiuIXwOZDOXyM7HQFyc5uVoclRFjp2f8YkjolArDu642YZhAfoh1ce485IoUk9UGKhGZ5r322hr1lVbhNxcjjevDz0QOsDkmIsGMYscQ4cwFw+77H5++YA+qO5PHHH2fq1KlMmTKFAQMGMG/ePOLi4liwYMEhjx85ciSPPPIIF110ES6XKyTXFCKcNHbA78DN8jbt/4gyz06MGC+dY7IZnDbJ6pCECDtKKQaedBwAlWXV7FjfMR8civYnSX2Qeg8KJPWmT5O/qeNNv/9+dzHvL1mHxzRw2O3cMfkMmQInxGE0nYIfhU/rQzAVrqKiosnmdrsP+VIej4dVq1YxbtyBOlvDMBg3bhxLly4NKvy2uKYQ7alrbArxNldgrfqajpfUV3n2klf2TmBNepvmtIybsSm71WEJEZaaTsHfYGEkFpHp90GRpD5IcYmxdM3OwPSb7Nqyu0NNj/H5Teb+Ywk+DV4NU88ZTc+MVKvDEiJsRXuzvFA0renRowfJycmN2wMPPHDI1youLsbv95ORkdFkf0ZGBoWFhUHF3xbXFKI9GcqgT2IGpoJ9dRVUew99Uywcaa1ZUfISfuVGubzkppxPRmz/o58oRJRq6IAPsDYKm+VJo7zgyG3SVsge3JOinXtx13jYV1BCRs90q0Nqln8u38D3u0tw+w36dOvM5T8bbnVIQoS1OOeIxq+jsq6+NcvE1J+Xn59PUlJS4+7DTZMXQhxaTmIma0t3ApBfU0y/5GMsjqh5tlcvZU9tHrY4DwmOdEalX2V1SEKEtZxhvXHFuXDXuMn7z0a01tE1mzYEY45oJE/qWyErtxemv6FZXseoqy8qq+LVT1fj1QqtFLMvHYfDbrM6LCHCmt2WissRqHGr9a7Fb1ZZHFHHk5SU1GQ7XFLfuXNnbDYbRUVFTfYXFRUdtgne0bTFNYVobw3L2mkF2ztIB3y3v4rVJQtRDj/KbnJKxo04DWnIK8SR2B12BozuC0BxQSlFOzrGz7uwliT1rZCV27OxfqMjNMvTWvPcP5dR5/XjMRUXnDKEIX2k86wQzRHvbJiCb1LjWWVpLO2tPafCOZ1Ohg8fzuLFixv3mabJ4sWLGTNmTFDxt8U1hWhvDR3wdQfqgL+69DXcZgWGy0t2wilkJZxkdUhCdAiDonhpO5l+HxxJ6lshe3AvAEyf2SGe1H+9dhurNuXjNhWdkxOYfr58uArRXFHdLK+dm9bMnDmT+fPn8/LLL7NhwwauvfZaqqurmTJlCgCXX345t912W+PxHo+HNWvWsGbNGjweD7t27WLNmjVs3bq12dcUItzlJNR3wFewswM8qS+q3cAPlV+iXB5c9jhOzrje6pCE6DAOTurzoiypl0Z5wZGa+lbo2icDV6wTv99PfpivVV9V4+b5f63ArxV+rbjlotNJjJWaViGa6+Ckvsa9zMJI2l9r7n4Hc96FF17Ivn37mDNnDoWFhQwdOpRFixY1NrrbuXMnhnHgnvTu3bsZNmxY4/8/+uijPProo5x66ql8/vnnzbqmEOEuwRFD15gUin3l7KwuCes6W5/pYUXxiyibieH0M7rzVOLtna0OS4gOo/+ovtjsNvw+f9Ql9e095ogUktS3gs1mo/egHmz97zb27iyhrsZNTFx4JsqvfLKK8qo63KbitCF9+MmwHKtDEqJDcdi74bD1wOvPp8a9BlO7MVR4/rxHgunTpzN9+vRDfq8hUW/Qu3dvdDOa4xzpmkJ0BDmJmeytLqfW72FvXQUZsclWh3RI6/e/R4VvD7Y4D5kxAxmY8gurQxKiQ4mJc9H3+Cw2rthKwabdlO3dT2qX8Px5F+FBpt+3UkOzPK01u7eG53r167YX8vHKTbhNRazLye8uOj1s7+4LEc4antZr3NR6vrM4mnbU0Ik22E0IERJ9EjMx60duO8N0vfpyTwHryj7AcHqx2QxOzZyFUjLcFKKlDp6Cv+7rTRZG0s5kzBEU+S3bSlm5PdH1HfDzN4ZfUu/x+pj73lJMFD6tmD7hJDLTEq0OS4gOqWld/XILI2lf0rRGiPDQNzETXd8sb3v1XqvD+RGtTVYUL0AbPpTTx7C0i+nkyrI6LCE6pNwmdfUbLIykfcmYIzgy/b6VGprlab+mIAzr6v/+n7Xs2leO228wqHcmk04bYnVIQnRY8a7RjV9H1Xr1rWk+E8UfsEKEWk7iwc3ywu9J/dbKf7Ovbgu2OA8pzu4M73SZ1SEJ0WENPOngDvjR9KQeGXMEQZ7Ut1JWbk8ATL8mf3N4dcAv2FfOW19+h1crDMPG7MvGYTPkr1yIYDnt2diNQLOnavdKtPZbHJEQIpr0iOuE07BjGuGX1Nf4yvi29A0Mpw9lNzktcyZ2w2l1WEJ0WElpCfQe2AOA79dso6ay1uKIRDiTDK+Vkjsn0albKtoXSOqb06ypPZim5tn3luDxmXhMxaU/PZ5ju6dbHZYQHZpSijjXSABMXUGdNzrunMtUOCHCg92wkZ3QBVPB7poy3H6v1SE1WlXyV3y6BuX00i9pPMfEDTv6SUKII2qoqzdNzfplmy2Opn3ImCM4ktSHQPbgQLO86vIayveWWx0OAJ99u4V124twm4runVOY+vPRRz9JCHFU8a5RjV9HTV29qVu3CSFCpk9CoFmeBgpqSq0OB4CC6tXsrF6BivES60jmxC6/sTokISLCwXX1a6NlaTsZcwRFkvoQyBrUE+03gfBolldWVcOLH32Dr35N+tsnn0Gs02F1WEJEhKbr1UdJXb1u5SaECJmcxEzM+gVsdlTvszYYwGPWsrLkFZTdj+HwM7bLdcTYkq0OS4iIMCgak3oZcwRFkvoQyBrcC20CGvI3WV9Xv+Bf31BV68VtKs4e1Y/RA3pZHZIQESPGMQBDxQNQ7V4RNiU3Qojo0DcxExSYSrMjDOrq88reptpfghHjpUfcCPomjrM6JCEiRnr3TmT0DpTPblyxFY87fEpuRHiRpD4EGjrgm35NwWZrO+Cv2lzAV3k/4DEVyfGxzJp0qqXxCBFplLIT5xoBgM8swuPfYXFEbU/Rivo2q4MXIsI0dsA3YKfFT+qL635g0/5PMFxeHDYnp2TMQCn5qRcilHLru+B76rxsWfWDxdG0vXAdc5SWljJ58mSSkpJISUnhqquuoqqq6ojnPPfcc5x22mkkJSWhlKK8vDwk1z0USepDoEe/btjsNrTfpGCzddPv6zxe/vzBUvw6sCb9zEmnkJoYZ1k8QkSqeGeUTcHXunWbECJk0lwJpDkTMBVsr95n2Wwhv/axovgFsPlQDh8jO11BsrObJbEIEcmaTMH/Ogqm4IfpmGPy5MmsW7eOTz75hA8++IAvv/ySa6655ojn1NTUMH78eG6//faQXvdQJKkPAYfTQc/+x2D6NLu/L8LrsWZqzGufrWFvWRVuUzHyuB78fPQAS+IQItLFHVRXHw3N8qQTrRDhJScx0Cyv0ltHubfGkhg27f+IMs9OjBgvnWOyGZw2yZI4hIh00VZXH45jjg0bNrBo0SKef/55Ro0axdixY/nTn/7E66+/zu7dhy+9vummm7j11lsZPfrQDcuDve6hSFIfIlm5PdF+jd/np/CHve3++t/vLub9JevwmAYOu507Jp8hU+CEaCNxzqEoAs0n95YuYc2aNSxfvpw1a9YENWUq7EnTGiHCitXN8qo8e8kreyewJr1Nc1rGzdiUvd3jECIa9DiuG8npSQCs/XoT+/dXRPa4IwRjjoqKiiab2+1uVUhLly4lJSWFESNGNO4bN24chmGwfHnwD3dCeV1J6kMkK7cXpi/wL6m9m+X5/CZz/7EEnwavhqnnjKZnRmq7xiBENNm4cRuP/F4x4ScljDh2GcOGDWP06NEMGzaMpKQk+vfvzw033MD69eutDlUIEYFyEjPRBmhFuzfL01qzouQl/MqNcnnJTTmfjNj+7RqDENFEKUWX3GQ2+lfzWcW7pKamyLjjKHr06EFycnLj9sADD7TqeoWFhXTp0qXJPrvdTlpaGoWFhWFxXbmtGiINzfK0qSnYtAsY2W6v/c/lG/h+dwluv0Gfbp25/GfD2+21hYgm27ZtY9q0aSxatIguXTozceIURt4+kgEDBhAXF0dNTQ3r16/nm2++4Y033uBPf/oT48ePZ+7cuWRlZVkdftCU1qgg69SCPU8IcXh9G5rlKc3OqvZ9Ur+9eil7avOwxXlIcKQzKv2qdn19IaJJ47jj40V0SuvM5AsvYuTIyB53hGLMkZ+fT1JSUuN+l8t1yONvvfVWHnrooSNec8OGDUHF0t4kqQ+R7ME9AdB+TcGW9muWV1RWxWuLv8WrFVopZl86Dofd1m6vL0S0eP7557npppvo3LkzCxcu5IILLsDpdP7ouFGjRjFlyhSeeOIJ3nrrLW677TZyc3N54oknuPrqqy2IPATM+i3Yc4UQIdU7Ph2bMjANs12f1Lv9VawuWYhy+FF2k1MybsRpSENeIdpC1I47QjDmSEpKapLUH86sWbO48sorj3hMdnY2mZmZ7N3btLza5/NRWlpKZmZmkMES0uvK9PsQ6dQtjcS0BEyfbrfp91prnvvnMmo9Pjym4oJThjCkj3SeFSLU7r//fqZOncrFF19MXl4el1xyySE/WA/mdDq55JJLWLt2LRdffDFTp07l/vvvb6eIQ6vhrnmwmxAitFw2Bz3jOmEqKKgpwWf62+V1V5e+htuswHB5yU44hayEk9rldYWINtE87mjPMUd6ejr9+vU74uZ0OhkzZgzl5eWsWrWq8dzPPvsM0zQZNWpU0O81lNeVpD5ElFKNzfLKivZTWdb2TSu+XruNVZvycZuKzskJTD9fPlyFCLXnn3+e2bNnc++99zJ//nwSExNbdH5iYiLz58/nnnvuYfbs2bzwwgttFKkQIpo0dMD3aZPdtWVt/npFtRv4ofJLlMuDyx7HyRnXt/lrChGNZNwRfvr378/48eOZOnUqK1as4Ouvv2b69OlcdNFFdOsWeKC6a9cu+vXrx4oVB5Y6LiwsZM2aNWzduhWAvLw81qxZQ2lpabOv21yS1IdQ9kHN8gra+Gl9VY2b5/+1Ar9W+LXilotOJzH20PUiQojgbNu2jZtuuomrr76a2bNnN/ne559/jlLqkNuyZct+dK3Zs2dz9dVXc+ONN7Jt27b2eguhId3vhQg7OYldD3TAr2rbKfg+08OK4hdRNhPD6Wd056nE2zu36WsKEY1k3EHYjjkWLlxIv379OOOMMzj77LMZO3Yszz33XOP3vV4vmzZtoqbmwDKj8+bNY9iwYUydOhWAU045hWHDhvHee+81+7rNJTX1IZQ1uBfaPNABv//oY9vstV75ZBXlVXW4TcVpQ/rwk2E5bfZaQkSradOm0blzZx5//PHDHnPDDTcwcmTTxpg5OT/+eVRK8dhjj/Hxxx8zbdo0Pvzww5DH22a0DmzBniuECLmcxExQ9c3yavYB/Y56TrDW73+PCt8ebHEeMmMGMjDlF232WkJEMxl3ELZjjrS0NF599dXDfr93797o/3n9u+++m7vvvrtV120uSepDqEmzvM1t96R+3fZCPl65CbdpEOty8ruLTpc16YUIsfXr17No0SIWLlx4xKlvJ598MhdccEGzrpmUlMQDDzzA5MmT2bBhA/37d4xloJQObMGeK4QIvcYO+EbbLmtX7ilgXdkHGC4vNpvBqZmzUEomegoRajLuCJAxR3Dkt3II9RrYA6UUpq/tknqP18ez7y/FROHTiukTTiIzrWW1NkKIo5s3bx5dunRp1gdnZWUlPp+vWdedOHEiXbp04dlnn21tiEKIKJYRk0yCPQZTwY7qtlnWTmuTFcUL0IYP5fQxLO1iOrk65jJZQoQ7GXeI1pCkPoRi42Po2icD029SsHkPfn/ou9H+/T9rKdhbjtuvGNQ7k0mnDQn5awgh4JNPPmHixIlH7TY7ZcoUkpKSiImJ4fTTT2flypVHPN7lcjFx4kQ+/fTTUIbbthqmwgW7CSFCTilFn8QMTANK3FVUeetC/hpbK//NvrotGDEeUpzdGd7pspC/hhAiQMYd9WTMERRJ6kMse3AvtE/jqfOyb2dop8MV7CvnrS+/w6sVyjCYfdk4bIb8FQoRapWVlWzatOlHNWsHczqdTJw4kSeffJJ//OMf3HfffeTl5XHyySfz7bffHvH6I0aMYOPGjVRVtf0qGaGgzNZtQoi20TcxE93QLC/EU/BrfGV8W/oGhtOHspucmjEDu3HkZEMIERwZdxwgY47gSEYYYtm5vTD9B5rlhYppap59bwken4nHVFz20+Ec2z09ZNcXQhzw/fffo7VmwIABhz3mxBNP5K233uL//u//OPfcc7n11ltZtmwZSiluu+22I15/4MCBaK0blzgJe3LXXIiwlJOQialAt8EU/FUlf8Wna1BOL/2SxtM9/viQXl8IccCWLVtk3NFAxhxBkUZ5IZY1uGfjkgoFm/cwcvywkFz3s2+3sG57EW7ToHvnFKb+fHRIritENNLaBLMY/HvALAR/Ifqgr2v3bAIgLi6uRdfNycnhvPPO45133sHv92Oz2Q55XGxsLABut7t1b0QIEdVyEruCAq00+SF8Ul9QvZqd1SswYr3EOpI5sctvQnZtIaKNaZrs31fBvoIS9uXXbwUl7CsopriglH35xWzN3wLIuEMET5L6EMse3AsA02dSsGlXSK5ZVlXDix99g69+TfrbJ59BrNMRkmsLEWkCCXtJfYK+J5CwH/Q1/kIwi4DDN5hxOQIfegevNdpcPXr0wOP5//buPLip+9wb+PdItuRF8ibJlsEGTJxim70hcUh5Awm0cdrJvNyYjtM4t4WLnQTehmJ4SwK4SRvWTqYMIanrgCe5zVy2FmbyprmBsqTc3HvxBUzSlthACmGxwZvkRV4lyzrvH1os2UbY50hev58ZDY58dM5PmZDzPOf5/Z6fDW1tbYiKiur3mI6ODud11OpBn39YyNn7dfw+NCcKuge0CQAAhwDcDFClvsvRiTLzhxBCuqEI7cZ3DP8HYcrogJybaKwRRRHNJktPol5pRn2lCaY7DairdCbtpiozumz+m9q5C8yMO8CYQyIm9QFmTIlHWKQa9m47Kq9WB+ScH3x6Aa0dXbA6BHw/Mw2PZkwOyHmJRhtRFAFHA+BwJ+jVroS9xqvqXgugS9Z1Uh+IhyBUoqKiApmZmYP67DfffIOwsDBoNJp7HlNeXg5BEPrdV3YkEkQRgsQpbVI/R0T3FxmixoTwWNTZG3G73QyH6IBC5nZzf288irZuM5SRXUiKmIdvRS0J0GiJRhdRFGExt/itsNdXNaDLKi/m0MZpkDwhEee/Os24A4w5pGJSH2AKhQJTZkzCP768jrpKEzraOhEeGSb5fBe/rsLnl76BzaFAdGQ41v9wYQBHSzRyiKIIiI09CbpPwl7Tk8jLTNghxADKROdLYYSgNHp+dr6fgChBjWnT0nHhwgWsWLGi39PU19fDYPDta/G3v/0NH3/8MZ5++mko/DSxLCsrQ1pamt8b8IgiZ53aOL7BEg2FVK0Rta2NsHZ3oa6zGcbwWMnnMnV+g6vNJ6AI60KoUoWFCQUQBCGAoyUaGURRREtjK+orzTBVmVHnVWF3J+umKjOsHTZZ19HGRkKfpIMhWQdDkh4G98/JOhiSdNAn6RAW4ayel6afZNwBMOaQiEl9EEydOQlXy5yNKO58fRepc6dKOk+nrQvvfVKKbtG5J33BsscRqx3cWhuikcCZsDe5kvVawFHtXMPeXeNZx+5M2GWu9RJiAKXR+VIkuhJ258/u9wVhYA/Zvvvd7+Lw4cPYvXt3v9vL5OTkIDw8HI899hji4+NRUVGBvXv3IiIiAjt37rznea1WK44ePYqcnByp35KIyONBrRH/WXsZAHCzzSQ5qXeI3Thveh9Q2iGE2jFP9y+IVk0I5FCJhoQoimhtavMk6yZXpb3Oq8JuqmpAZ7u8mCMyOsKVoOthmBgHQ7Ie+iQd4l1Ju35iHMI14QM+H+MOkoNJfRCkzJoM0dUBv+rraslJ/cHP/oq6xlZYHQrMm5aMZ+bfuyMm0XBxJuzNPlPgRZ/p8O6EXeYeykKUq5JudFXY3dV1d6U9AYIicA+9Xn75Zbzzzjs4cuQInn/++T6/X7p0Kfbv349du3bBYrHAYDDg2WefxRtvvOF3etvRo0dRV1eHVatWBWysQScCkLpNzPh9aE40JFJd29qJgojbbSY8qn9Q0nmuNP8ZjbZbUEZ2QR82FbPjfhjgkRIFRltzm2+y7krS66ucFfb6ShM62+Ql7BFR4T1V9V4Vdn2Ss8oeoR14wj4QjDtcGHNIwqQ+CNzN8sRuEZUSm+Vdv2vCn86Ww+ZQIDQkBIW5izkFjoacM2Fv8UrQq50Ju3fjOUcNIHbIu5Cg9STrULoq7F7VdSiMEBSRgflSA5SRkYGsrCxs2rQJzzzzDLRarc/v16xZgzVr1gzqnBaLBRs3bkRWVhbS09MDOdyg4vo2opErVZsIwNks77bEZnmttjpcajzq3JNeKWJRwv+FUmCISEOvzdLep8JeX2lC/Z2eCnt7i7yYI1wT1m+F3ZDsrLLrk3SIjBr6mbGMO5wYc0jD/2MHQcrMSQAAR7eIKgnN8uzdDhT9v7Owi0CXCKz+QSYmJUhfI0d0L6KjxWu9unfC7lVpFwffidWHEOmqpDvXqws+69fdCfvIXONVVFSEmTNnYt26ddi3b5+sc4miiPXr18NsNqOoqChAIxwiImSsbwvoSIiol6SIOKgVoXAounBTwrZ2oijivPlf0S1YoVB3YWbMPyEhfHQE/zS6dLR29ErWfRvP1VWa0G6Rl7CHRai91qzroU+KQ3yvpD0iKmLEFsoYd4Axh0RM6oNAG6uBIUmHRlMTKq/ehSiKg/qfx6fnLuP6XTOs3Qo8MEGPn3xvXhBHS2OV6Gj1SdBFn+nw7oS9Td5FhAivBN01Bd6TrDvfG6kJ+0CkpKRg9+7dyM/Px+TJk1FYWCjpPKIoYuvWrSgpKUFJSQlSUlICPNIgY9MaohFLKSgwVROPf9juoLajCZ12G8JC+q7HvZdbbf+D6o5LUEbYoAk1INOQF8TR0ljV0dbpNR3enbj3VNjrK81oa5ZXJFCHq3qmvyfrEJ+k92pC5/xTExM5YhP2gWDcAcYcEjGpD5KUWZNgPumcItRQ3QjdhLgBfa62sRUHTn+JLlGAKAgofGEJQkOUQR4tjTaio61Pgu7beK4aEFvlXUQI77VmPRGCMsGr6m4EBO2ovnkORF5eHmpra1FYWIhbt25h165dfabE+WOxWLB+/XqUlJRg27ZtWLlyZRBHS0TjUarWiKtNdyACqGw348GoxAF9ztrdiovmf4MQ2g0hxIHHE34GVQB7k9DY0NludSbpfrZ2a2mUVyRQhYV6NZnTQ++aFu+9ll0bqxnzMQfAuIOkYVIfJFNnTsb5Y18CAKq+vjugpF4URez99/9Bh80Om0PADxfOwuwH2Hl2vBHFjp716q6p8X0az4kWmVdRe01/d/4puCrtnqq7EDUubp4DsXnzZiQkJGDt2rU4ceIEduzYgWXLlvXbndbN3W1248aNMJvNKCkpGb03VgcAqf8pSG12Q0QD9qDWCIfr7+itdtOAk/ovGg7C6rBAEd6FqZr/hRTNd4I4ShqJrB1W1zZu3km7c2u3OleFvaVBXpEgVB0KQ1Jc/1u7uf6M0o39IsFgjOu4gzGHJEzqgyRl1mTXmhCg8mo1Zi+acd/PnC2/iYtXK2F1KKCP1uCn/7Qg+AOlISWKnV7Vdef2bqJXEzpnwt4s8yoqn/Xqvo3nXEm7EMOb5yDl5eVh8eLFWL16NXJzc1FQUIDs7GzMmzcP06dPR3h4ODo6OlBeXo6ysjJPt9msrCwUFRWNrqlvvbBpDdHIlqo1AgLgUIgDbpZX23EZ37R8DkWYDeqQCCyIfyXIo6ShZrN23bfC3mxqkXWNkFCl7xT4JF2fCnu0nkUCKcZr3MGYQxom9UHi7oDvGGAH/NZ2K/b9+zl0iwK6RQGvPvcEtOHqYA+TAkgUrT7Vdec69lrPz86EvUnmVUL77rveu/GcEMubZ5CkpKTg2LFjqKioQHFxMU6dOoXi4mLnLgEugiAgLS0NOTk5WLVq1ajpNusX17cRjWipWiMAZwf8WwNolmd32HDe9AEEpQMKVTce1edDE2oI9jApgGzWLpjvOivs7m7x7gq7ew17U728WX0hoUroJ/ZfYXdPlY82REGhUAToW1Fv4zLuYMwhCZP6IEn6ViJCQpUQ7Q5UXb173+M/PHkRTa2dsDoELJw9FU/Ovfd+kzT0RNHmu169uwaiq9Lu/OdqQGyUeZVQZyXdK0EXfLrEJwKKOCbsI0BGRgb27NkDAGhtbcW1a9dgtVqhVquRmpoKjWb0NgckotEnRhUJvVqL5q4W3Gqrv2+D3ormj2GxV0MZYUNC2HRMj3lmCEdL92PvssN0p8ErWXc1nvPah72xVt6sPoVS4Vq37lthdyfr+iQdYhOimbCPEIw76H6Y1AdJSGgIJmUk4daVSlTfqIPN1gWVKrTfYytu1eJE2VVYHQqEq1V49bknmbgNIWfCXuvbKd6TvLsq7Q6zzKuEuNar9zSeE3ya0BkBhQ6CwJvnaKPRaDBnzpzhHkZw8ak50YiXqjXiQnsLWm1WNNhaoVP331iryVaF8sZPoFB3QalUYJFxPe89Q8jeZUdDdaPP1m51vSrsjbXNPpXYwVIoFdBNiO2pqk/UIT5Z79M5PjYhGkolGzGPRmM+7mDMIQmT+iCaOmsybnx1Gza7FWeO/wd0E2OhUqmQkpLieaJm67Kj6OOzcECAXRSwbul3YIwbeIdL8k8UuwBHXc/0d+8u8e617I7B7+vrS+mbsCuMXtu6uZN2PYMmGr14gyUa8VK1Rpyr+wfsHTZ8duG/MTXc0CfmEEUHzpveh6iwQ6GyY27cC9CpR+e625Go294Nc3Vj363dvCvsNU1wOGQk7AoBcYmxPVPgk9yJut5TdY8zxkDJnZNotGLMIQmT+iCpqKjAmet/xjnhv9HS0Izj//JHz+8EQUBqaioWLVqEhPRHUVXXBGu3AjOmGPHDRbOHcdSjiyjaXQm797ZuvbrEO+rh7FgolQJQxPs0nvPdhz0BUBggCLx50hjGTrREI1pFRQVO/+ZDVJz6DK2V9fivXutt3THHE8vSUB/7DygjbIhRTcRDuheGcdSjS3d3Nxprmnwq7L33YW+obpSVsAuCgLjEGJ8KuyFZ75kOb0jWQZcYy4SdxjbGHJIwqQ+wGzduYPXq1Th+/DgMhnjk5v0IDz/8MDIyMhAREYH29nZUVFTgwoULzi6V+/YhdlIakhYsQ+EL/wwl1y4BcCfspp716p6EvacJnbPCLudvrwJQGHpt6+Y1Hd5TYedfEyIiGnm8Y474+Hj8c3a235hj3759yPiOATm/mor//eg6hCjYkBdwJey1zV7Jek+XeHeF3Xy3EY5u6TGHIAiITYjumQLv3SneVWHXTYhFSChjDiIaPEGUs2iHfJSUlGDt2rXQ6/XYvn37ffeTtNlsOHLkCDa8+irMZjPe2bMHeXl5Qzji4SGK3c4KuldneNHThM5daa8H0C3jKoJXwu69rZt34zkDBKH/PgdEBFgsFkRHR2PJt9YhRCkt+Ld3W3Hq611obm5GVFRUgEdINH5JjTle3bgBZrMJe3a/Oy5iDofDgaa65j77sHtX2M13G9FtlxNzADHxzoQ93qvC7r0Pu25CLELv0VuJiBhzyMXHgQGybds2FBYWIi8vD7t27YJWe/918SqVCs8//zyeeeYZFBQUID8/H7W1tdi8efMQjDg4RNHRU2F3Jemi93T47mrnlHlZCTsAhd63S7ynuu6usBsgCPcObohoELi+jWhEYczh5HA40Fxv8bsPu+lOA+xdMhN2Q1T/e7G7K+wT46BSM2EnCgjGHJIwqQ+AkpISFBYWYsuWLSgsLPT5XWtrK9566y2cO3cO58+fR2NjIz744AMsX77cc4xWq0VJSQkmT56MwsJCGI1GrFy5coi/xf05E3Zzr23den52To2vBWCXdyGFrme9uqdLvHfjuQQm7ERDySECgsQbpYz1pUTU1/iJOUQ0myx9KuymOw3ObvFVzi3fumzyYo4ondaZnCfrYJjo3tYtrqdb/MQ4qMIYcxANGcYckjCpl+nGjRtYu3Yt8vLy+txcAcBkMuHNN9/EpEmTMHv2bJw5c+ae5yosLMTt27fxs5/9DE8++SRSUoauI60oioCjoWe9uidh9248VwugS96FhFhXgu5M2gVFYj8JO9f4ERER9TaWYg6LucVvhb2+qgFdVnkxhzZO45n+bnB1iffZ2i0pDupwxhxENPoxqZdp9erV0Ov12LVrV7+/T0xMRHV1NYxGI8rKyvDwww/f81yCIOA3v/kNTpw4gdWrV+PYsWMBGaMoioDY2JOge/Zh9248VwP5CXuM1/T3RAiuSru7CR2URibsRKMRp8IRjQijJeZoaWxFvatLfJ1Xhd2drJuqzLB22GRdRxMT2W+F3d0tXjcxDuGRYQH5TkQ0hBhzSMKkXoaKigocP34c+/fvv+d6NrVaDaPROOBzRkVFYceOHcjNzcXly5eRnp7u93hnwt7U/z7s3lPjIe/mCSHaK2F3b+uW4ErYXVV3IVzeNYhohJJxg5W1pSQRuY2UmKO1qc0rWXcl7t5r2Ksa0NluHdR36y0yOqJPhd2QrIfBlbQbkuIQrmHMQTQ2MeaQgkm9DMXFxYiPj8eyZcsCet7s7GwUFBSgqKgIe97e4n8f9u4aAJ3yLihE9dMlvmdNOxRGCIqIgHw3IhqF+NScaNgNRcyxc+tOn33Y3WvX66tMninynW3yEvYIbbjPtm7xXhV2dxIfoWXCTjRuMeaQhEm9DCdPnkR2drbfLWSkUKvVyM7OxukTH0Cs+7O8kwkar33XvbvE96xjFxSRgRk4ERERBUWwY45/23cAV35bI+tcYZFqT3Ie31+FPVmHyCgWCYiIAo1JvUQtLS24evUqNmzYEJTzz5s3D8XFv0NrmwOaSEX/BwmRfRN098+eCrsmKOMjonHEIULylLZx3ImWKFCGIub43e+KYYcdIUL/oWFYhLqnwt57azdX0h4ZHQFBEIIyRiIaJxhzSMKkXqLr169DFEVkZGQE5fzTp0+HKALXqjIwZ850V8Ju9Kq6J0JQ3H9fWiIi2USH8yX1s0Qky1DEHICISY8kYHr6jD7JuiFZB01MJBN2Igo+xhySMKmXyGp1rimLiAjONLLwcOd6sq6wzVBEZwblGkREA8L1bUTDaqhijtV7ViAzkzEHEQ0jxhySMKmXSK12bs3W3t4elPN3dHT4XIeIaNhwKhzRsGLMQUTjBmMOSe6xWJvuJzU1FYIgoKKiIijnLy8vhyAISE1NDcr5iYiIaHRgzEFERP6wUi+RRqPBtGnTcOHCBaxYscLvse+++y6amppw9+5dAMCf/vQnVFVVAQBeeeUVREdH9/lMWVkZ0tLSoNGw0R0RDTNOhSMaVow5iGjcYMwhiSCK4/jby7RmzRocPnwYlZWVfreYmTJlCm7dutXv727cuIEpU6b4vGe1WjFp0iTk5ORgz549gRwyEdGAWSwWREdHY0niSwhRSNtGy+6w4VT1e2hubkZUVFSAR0g0fjDmIKKxjDGHPJx+L8PLL7+Muro6HDlyxO9xN2/ehCiK/b5631wB4OjRo6irq8OqVauCNHIiokFwPzWX+iIi2RhzENG4wJhDEib1MmRkZCArKwubNm1CS0tLQM5psViwceNGZGVlIT09PSDnJCIiotGNMQcR0fBpaGhAbm4uoqKiEBMTg5UrV6K1tdXvZ/bu3YtFixYhKioKgiCgqampzzFTpkyBIAg+r507dw56fEzqZSoqKoLJZMK6detkn0sURaxfvx5msxlFRUUBGB0RUQA4HPJeRBQQjDmIaMwboTFHbm4uysvLcfLkSXzyySf4/PPP8eKLL/r9THt7u+dhrD9vvvkmqqurPa9XXnll0ONjUi9TSkoKdu/ejZKSEmzdulXyeURRxNatW1FSUoK3334bKSkpARwlEZEMwzAV7re//S2mTJmCsLAwZGZm4vz5836P/+Mf/4i0tDSEhYVh5syZ+PTTT31+v3z58j5PwrOysiSNjWi4MOYgojEvADGHxWLxeVmtVllDunz5Mo4fP46SkhJkZmZiwYIFeOedd3Do0CFPU9L+rF27Fq+99hoeffRRv+fXarUwGo2eV2Rk5KDHyKQ+APLy8rB161b84he/QH5+/qCnxVksFrz44ot4/fXXsW3bNqxcuTJIIyUikmCIk/rDhw9j3bp1eOONN/DFF19g9uzZeOqpp1BXV9fv8WfPnsWPfvQjrFy5El9++SWWLl2KpUuX4quvvvI5Lisry+dJ+MGDByX96yAaTow5iGhMC0DMkZycjOjoaM9rx44dsoZUWlqKmJgYzJs3z/PekiVLoFAocO7cOVnnBoCdO3dCp9Nh7ty5eOutt2C32wd9Dib1AbJ582bs27cPBw8exIwZM3DgwAHYbDa/n7FarThw4ABmzpyJgwcPoqSk5L7TM4iIxrpdu3YhPz8fK1asQEZGBoqLixEREYH333+/3+PffvttZGVl4ec//znS09OxZcsWfPvb38a7777rc5xarfZ5Eh4bGzsUX4co4BhzEBHdW2VlJZqbmz2vjRs3yjpfTU0N4uPjfd4LCQlBXFwcampqZJ17zZo1OHToEP7yl7/gpZdewvbt27Fhw4ZBn4f71AdQXl4eFi9ejNWrVyM3NxcFBQXIzs7GvHnzMH36dISHh6OjowPl5eUoKyvzdJzNyspCUVERp78R0cjkEAFI7Cjr6JkK502tVkOtVvc53Gaz4eLFiz43YIVCgSVLlqC0tLTfS5SWlvZZY/zUU0/ho48+8nnvzJkziI+PR2xsLJ588kls3boVOp1OyrciGnaMOYhoTApAzBEVFTWgLe1ee+01/PrXv/Z7zOXLl6WNZYC845dZs2ZBpVLhpZdewo4dO/qNk+6FSX2ApaSk4NixY6ioqEBxcTFOnTqF4uJiiF5TUAVBQFpaGnJycrBq1Sp2nCWiEU0UHRBFac1n3J9LTk72ef+NN97AL3/5yz7Hm0wmdHd3IyEhwef9hIQEXLlypd9r1NTU9Hu899PzrKwsPPvss0hJScH169exadMmPP300ygtLYVSqZTy1YiGHWMOIhprAhFzDNT69euxfPlyv8dMnToVRqOxzxJAu92OhoYGGI3GwQ7Tr8zMTNjtdty8eRPTpk0b8OeY1AdJRkYG9uzZAwBobW3FtWvXYLVaoVarkZqaCo1GM8wjJCIaIFH0PP2W9Fk4p8J5PzUfzNPnQHjuuec8P8+cOROzZs3CAw88gDNnzmDx4sVDOhaiQGPMQURjRgBijoEyGAwwGAz3PW7+/PloamrCxYsX8dBDDwEAPvvsMzgcDmRmZkoa6r389a9/hUKh6DPd/36Y1A8BjUaDOXPmDPcwiIiGzUCnwun1eiiVStTW1vq8X1tbe8+n4UajcVDHA84n73q9HteuXWNST2MKYw4iosBKT09HVlYW8vPzUVxcjK6uLvz0pz/Fc889hwkTJgAA7ty5g8WLF+PDDz/EI488AsA5k7CmpgbXrl0DAFy6dAlarRaTJk1CXFwcSktLce7cOTzxxBPQarUoLS1FQUEBXnjhhUH3/WGjPCIi8m8Iu9+rVCo89NBDOH36tOc9h8OB06dPY/78+f1+Zv78+T7HA8DJkyfveTwAVFVVwWw2IzExcVDjIyIioiAahm10B2L//v1IS0vD4sWL8f3vfx8LFizA3r17Pb/v6urC1atX0d7e7nmvuLgYc+fORX5+PgDg8ccfx9y5c/Hxxx8DcM5aPHToEBYuXIjp06dj27ZtKCgo8DnvQAmiGMRvT0REo5bFYkF0dDQWa3MRIqgkncMu2nC6ZT+am5sHVKkHnFva/eQnP8F7772HRx55BLt378Yf/vAHXLlyBQkJCfjxj3+MiRMneraoOXv2LBYuXIidO3fiBz/4AQ4dOoTt27fjiy++wIwZM9Da2opf/epXyM7OhtFoxPXr17Fhwwa0tLTg0qVLQ74UgIiIiHwNV8wxVnD6PRER+SfK6EQr4blxTk4O6uvr8frrr6OmpgZz5szB8ePHPc3wbt++DYWiZ6LZY489hgMHDqCwsBCbNm3Cgw8+iI8++ggzZswAACiVSvz973/H73//ezQ1NWHChAn43ve+hy1btjChJyIiGkmGOOYYK1ipJyKifnmemmuel/fUvPXAuHxqTkRERAPDmEMeVuqJiMgv0eGAKAzN9jJEREQ0fjHmkIZJPRER+cepcERERDQUGHNIwqSeiIj8c4iAwBssERERBRljDkmY1BMRkX+iCEDilLZxfIMlIiKiQWLMIQn3qSciIiIiIiIapVipJyIiv0SHCFHiVDhusEJEREQDxZhDGib1RETkn+iA9Klw47cTLREREQ0SYw5JmNQTEZFffGpOREREQ4ExhzRcU09EREREREQ0SrFST0REftlFq+QpbXZ0BXg0RERENFYx5pCGST0REfVLpVLBaDTiv2o+lXUeo9EIlUoVoFERERHRWMOYQx5BHM+LD4iIyK/Ozk7YbDZZ51CpVAgLCwvQiIiIiGgsYswhHZN6IiIiIiIiolGKjfKIiIiIiIiIRikm9URERERERESjFJN6IiIiIiIiolGKST0RERERERHRKMWknoiIiIiIiGiUYlJPRERERERENEoxqSciIiIiIiIapf4/Q6H6xvvz17MAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "# shade the area of the triangle\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge][0], edges[base_edge][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.08,\n", - "Variance in the edge (1,3) is 0.13,\n", - "The average variance is 0.17.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % torch.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = torch.Size([3, 1])):\n", - "tensor([[3],\n", - " [3],\n", - " [0]], dtype=torch.int32)\n", - "\n", - "emedding (shape = torch.Size([3, 6])):\n", - "tensor([[ 0.1403, -0.1369, 0.0665, -0.1392, 0.1293, 0.0516],\n", - " [ 0.1403, -0.1369, 0.0665, -0.1392, 0.1293, 0.0516],\n", - " [ 0.1403, 0.1369, 0.0665, -0.1392, -0.1293, 0.0516]])\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(1.7523e-08)\n" - ] - } - ], - "source": [ - "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", - "\n", - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - "\n", - "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - "kernel_mat_32_alt = torch.matmul(embedding, embedding.T)\n", - "\n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', torch.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "tensor([[ 0.0428, 0.2322],\n", - " [ 0.0428, 0.2322],\n", - " [-0.1651, -0.2720]])\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = torch.Generator()\n", - "key.manual_seed(1234)\n", - "\n", - "# new random state is returned along with the samples\n", - "key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = torch.Generator()\n", - "key.manual_seed(1234)\n", - "key, samples = sample_paths(other_edges, params_32, key=key)\n", - "\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/backends/PyTorch_SimplicialComplex.ipynb b/notebooks/backends/PyTorch_SimplicialComplex.ipynb new file mode 100644 index 00000000..0da45e8b --- /dev/null +++ b/notebooks/backends/PyTorch_SimplicialComplex.ipynb @@ -0,0 +1,1285 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", + "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", + "The graph **must be** undirected.\n", + "\n", + "We construct the simplicial 2-complex by adding triangles to the graph. The triangles can be provided by users. If not provided, we look for all the 2-cliques in the graph and add them to the simplicial 2-complex.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **PyTorch** backend here.\n", + "\n", + "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): Torch backend enabled.\n" + ] + } + ], + "source": [ + "# Import a backend, we use jax in this example.\n", + "import torch\n", + "import numpy as np\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "import geometric_kernels.torch\n", + "# from geometric_kernels import jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "G = nx.Graph()\n", + "G.add_edge(1, 2)\n", + "G.add_edge(1, 3)\n", + "G.add_edge(1, 5)\n", + "G.add_edge(2, 3)\n", + "G.add_edge(3, 4)\n", + "G.add_edge(4, 5)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the triangle set " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "triangles = [(1,2,3)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the positions of the nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# explicitly set positions\n", + "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(G, pos, **options)\n", + "# shade the area of the triangle\n", + "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the sets of nodes, edges and triangles. \n", + "\n", + "**Note that**: \n", + "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", + "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "print('nodes:', G.nodes)\n", + "print('edges:', G.edges)\n", + "print('triangles:', triangles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", + "\n", + "The `G` parameter is a 'networkx.classes.graph.Graph' object, from which we build the node-to-edge incidence matrix.\n", + "\n", + "The 'triangle_list' parameter is a list of tuples, where each tuple is a triangle in the graph. If provided, this will be used to construct a simplicial 2-complex.\n", + "\n", + "The 'sc_lifting' parameter is a boolean that determines if to build a simplicial 2-complex. \n", + "- If True and 'triangle_list' is not None, the edge space of a simplicial 2-complex will be built based on the provided triangles. \n", + "- If True and 'triangle_list' is None, the edge space of a simplicial 2-complex with all the 2-cliques as 2-simplices will be built. \n", + "- If False and no 'triangle_list' provided, the edge space of the graph will be built.\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the Simplicial 2-Complex " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----Simplicial 2-complex summary---\n", + "nodes: [1, 2, 3, 5, 4]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "triangles: [(1, 2, 3)]\n" + ] + } + ], + "source": [ + "sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True)\n", + "sc.sc_simplices()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the incidence matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.],\n", + " [-1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sc.triangle_incidence_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "node-to-edge incidence matrix:\n", + " [[-1. -1. -1. 0. 0. 0.]\n", + " [ 1. 0. 0. -1. 0. 0.]\n", + " [ 0. 1. 0. 1. -1. 0.]\n", + " [ 0. 0. 1. 0. 0. -1.]\n", + " [ 0. 0. 0. 0. 1. 1.]]\n", + "edge-to-triangle incidence matrix:\n", + " [[ 1.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 1.]\n", + " [ 0.]\n", + " [ 0.]]\n" + ] + } + ], + "source": [ + "print('node-to-edge incidence matrix:\\n', sc.incidence_matrices[0])\n", + "print('edge-to-triangle incidence matrix:\\n', sc.incidence_matrices[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the computed Laplacians" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hodge Laplacian:\n", + " [[ 3. 0. 1. 0. 0. 0.]\n", + " [ 0. 3. 1. 0. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [ 0. 0. 0. 3. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Down Hodge Laplacian:\n", + " [[ 2. 1. 1. -1. 0. 0.]\n", + " [ 1. 2. 1. 1. -1. 0.]\n", + " [ 1. 1. 2. 0. 0. -1.]\n", + " [-1. 1. 0. 2. -1. 0.]\n", + " [ 0. -1. 0. -1. 2. 1.]\n", + " [ 0. 0. -1. 0. 1. 2.]]\n", + "\n", + "\n", + "Up Hodge Laplacian:\n", + " [[ 1. -1. 0. 1. 0. 0.]\n", + " [-1. 1. 0. -1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 1. -1. 0. 1. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('\\n')\n", + "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('\\n')\n", + "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "use_hodge_composition=True\n", + "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the eigenbasis and their types being either gradient, curl or harmonic" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "eval: 0.00\n", + "evec: [0.17 0.35 -0.52 0.17 0.52 -0.52]\n", + "type: harmonic\n", + "\n", + "eval: 1.38\n", + "evec: [0.37 -0.00 -0.60 -0.37 -0.60 -0.00]\n", + "type: gradient\n", + "\n", + "eval: 2.38\n", + "evec: [0.24 0.48 -0.15 0.24 0.15 0.78]\n", + "type: gradient\n", + "\n", + "eval: 3.00\n", + "evec: [0.58 -0.58 -0.00 0.58 0.00 0.00]\n", + "type: curl\n", + "\n", + "eval: 3.62\n", + "evec: [0.60 -0.00 0.37 -0.60 0.37 -0.00]\n", + "type: gradient\n", + "\n", + "eval: 4.62\n", + "evec: [0.28 0.56 0.45 0.28 -0.45 -0.35]\n", + "type: gradient\n", + "\n" + ] + } + ], + "source": [ + "for entry in sc.hodge_eigenbasis.values():\n", + " if 'eval' in entry:\n", + " print(f\"eval: {entry['eval']:.2f}\")\n", + " if 'evec' in entry:\n", + " formatted_evec = np.array2string(entry['evec'], formatter={'float_kind': lambda x: f\"{x:.2f}\"})\n", + " print(f\"evec: {formatted_evec}\")\n", + " if 'type' in entry:\n", + " print(f\"type: {entry['type']}\")\n", + " \n", + " print() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'harmonic': {'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'nu': array([inf]), 'lengthscale': array([1.])}}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: for the Hodge-compositional kernel, we need to specify the parameters for each Hodge subspace. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "if use_hodge_composition:\n", + " params[\"harmonic\"][\"lengthscale\"], params[\"gradient\"][\"lengthscale\"], params[\"curl\"][\"lengthscale\"] = torch.tensor([0.5]), torch.tensor([2.0]), torch.tensor([1.0])\n", + " params_hodge_1 = copy.deepcopy(params)\n", + " params_hodge_2 = copy.deepcopy(params)\n", + " del params\n", + " params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = torch.tensor([3/2]), torch.tensor([3/2]), torch.tensor([3/2])\n", + " params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = torch.tensor([torch.inf]), torch.tensor([torch.inf]), torch.tensor([torch.inf])\n", + " \n", + "else:\n", + " params[\"lengthscale\"] = torch.tensor([2.0])\n", + " params_32 = params.copy()\n", + " params_inf = params.copy()\n", + " del params\n", + " params_32[\"nu\"] = torch.tensor([3/2])\n", + " params_inf[\"nu\"] = torch.tensor([torch.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check the eigenvalues of the kernels" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eigenvalues for the first set of parameters:\n", + "{'harmonic': tensor([[0.0241]]), 'gradient': tensor([[0.3212],\n", + " [0.1804],\n", + " [0.1095],\n", + " [0.0804]]), 'curl': tensor([[0.0680]])}\n", + "\n", + "Eigenvalues for the second set of parameters:\n", + "{'harmonic': tensor([[1.]]), 'gradient': tensor([[6.3043e-02],\n", + " [8.5320e-03],\n", + " [7.2014e-04],\n", + " [9.7460e-05]]), 'curl': tensor([[0.2231]])}\n" + ] + } + ], + "source": [ + "if use_hodge_composition:\n", + " # Evaluate the eigenvalues for the first set of parameters\n", + " eigenvalues_hodge_1 = kernel.eigenvalues(params_hodge_1, normalize=False)\n", + " # Evaluate the eigenvalues for the second set of parameters\n", + " eigenvalues_hodge_2 = kernel.eigenvalues(params_hodge_2, normalize=False)\n", + " # Print the results\n", + " print(\"Eigenvalues for the first set of parameters:\")\n", + " print(eigenvalues_hodge_1)\n", + " print(\"\\nEigenvalues for the second set of parameters:\")\n", + " print(eigenvalues_hodge_2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on the edge space of our simplicial complex.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[4],\n", + " [1],\n", + " [0]], dtype=torch.int32)\n" + ] + } + ], + "source": [ + "key = torch.Generator()\n", + "key.manual_seed(123)\n", + "\n", + "key, xs = sc.random(key, 3)\n", + "print(xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "if use_hodge_composition:\n", + " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs, normalize=False)\n", + " kernel_mat_inf = kernel.K(params_hodge_2, xs, xs, normalize=False)\n", + "else:\n", + " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + " kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = min([torch.min(kernel_mat_32), torch.min(kernel_mat_inf)])\n", + "maxmax = max([torch.max(kernel_mat_32), torch.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[ 0.4923, 0.1711, 0.0171],\n", + " [ 0.1711, 0.5515, -0.2242],\n", + " [ 0.0171, -0.2242, 0.5094]]),\n", + " tensor([[ 0.5921, 0.1899, -0.0975],\n", + " [ 0.1899, 0.4823, -0.2588],\n", + " [-0.0975, -0.2588, 0.4945]]))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_mat_32, kernel_mat_inf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "base_edge = (1,2)\n", + "base_edge_idx = list(G.edges).index(base_edge)\n", + "other_edges = torch.arange(sc.num_edges)[:, None]\n", + "edges = [e for e in G.edges()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "if use_hodge_composition:\n", + " values_32 = kernel.K(params_hodge_1, torch.tensor([[base_edge_idx]]), other_edges).flatten()\n", + " values_inf = kernel.K(params_hodge_2, torch.tensor([[base_edge_idx]]), other_edges).flatten()\n", + "else:\n", + " values_32 = kernel.K(params_32, torch.tensor([[base_edge_idx]]),\n", + " other_edges).flatten()\n", + " values_inf = kernel.K(params_inf, torch.tensor([[base_edge_idx]]),\n", + " other_edges).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "if use_hodge_composition:\n", + " variance_32 = kernel.K_diag(params_hodge_1, other_edges)\n", + " variance_inf = kernel.K_diag(params_hodge_2, other_edges)\n", + "else:\n", + " variance_32 = kernel.K_diag(params_32, other_edges)\n", + " variance_inf = kernel.K_diag(params_inf, other_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", + " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "# shade the area of the triangle\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", + " vmin=values_32.min(), vmax=values_32.max(), \n", + " **options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", + " vmin=values_inf.min(), vmax=values_inf.max(),\n", + " **options)\n", + "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the eigenbasis and their types being either gradient, curl or harmonic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from edge to edge** on this graph.\n", + "\n", + "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", + "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (1,2) is 0.51,\n", + "Variance in the edge (1,3) is 0.55,\n", + "The average variance is 0.50.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % torch.mean(variance_32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = torch.Size([3, 1])):\n", + "tensor([[4],\n", + " [1],\n", + " [0]], dtype=torch.int32)\n", + "\n", + "harmonic emedding (shape = torch.Size([3, 1])):\n", + "tensor([[0.5222],\n", + " [0.3482],\n", + " [0.1741]])\n", + "gradient emedding (shape = torch.Size([3, 4])):\n", + "tensor([[-4.0994e-01, 7.6033e-02, 1.4795e-01, -1.5442e-01],\n", + " [-4.5399e-16, 2.4605e-01, -3.5347e-16, 1.9088e-01],\n", + " [ 2.5336e-01, 1.2302e-01, 2.3938e-01, 9.5438e-02]])\n", + "curl emedding (shape = torch.Size([3, 1])):\n", + "tensor([[ 3.8858e-16],\n", + " [-5.7735e-01],\n", + " [ 5.7735e-01]])\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(1.4901e-08)\n" + ] + } + ], + "source": [ + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "\n", + "if use_hodge_composition:\n", + " _, harmonic_embedding = feature_map(xs, params_hodge_1['harmonic'], hodge_type='harmonic') \n", + " _, gradient_embedding = feature_map(xs, params_hodge_1['gradient'],hodge_type='gradient')\n", + " _, curl_embedding = feature_map(xs, params_hodge_1['curl'], hodge_type='curl')\n", + " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + " kernel_mat_32_alt = torch.matmul(harmonic_embedding, harmonic_embedding.T) + torch.matmul(gradient_embedding, gradient_embedding.T) + torch.matmul(curl_embedding, curl_embedding.T) \n", + " print('harmonic emedding (shape = %s):\\n%s' % (harmonic_embedding.shape, harmonic_embedding))\n", + " print('gradient emedding (shape = %s):\\n%s' % (gradient_embedding.shape, gradient_embedding))\n", + " print('curl emedding (shape = %s):\\n%s' % (curl_embedding.shape, curl_embedding))\n", + "else:\n", + " # xs are random points from above\n", + " _, embedding = feature_map(xs, params_32, normalize=True)\n", + " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + " kernel_mat_32_alt = torch.matmul(embedding, embedding.T)\n", + " print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + " \n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', torch.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "tensor([[-0.1916, 0.0824],\n", + " [-0.3929, 0.2983],\n", + " [-0.3407, -0.4310]])\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = torch.Generator()\n", + "key.manual_seed(123)\n", + "\n", + "# new random state is returned along with the samples\n", + "if use_hodge_composition:\n", + " key, samples_harmonic = sample_paths(xs, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", + " key, samples_gradient = sample_paths(xs, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", + " key, samples_curl = sample_paths(xs, params_hodge_1['curl'], key=key, hodge_type='curl')\n", + " samples = samples_harmonic + samples_gradient + samples_curl\n", + "else:\n", + " key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = torch.Generator()\n", + "key.manual_seed(1234)\n", + "if use_hodge_composition:\n", + " key, samples_harmonic = sample_paths(other_edges, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", + " key, samples_gradient = sample_paths(other_edges, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", + " key, samples_curl = sample_paths(other_edges, params_hodge_1['curl'], key=key, hodge_type='curl')\n", + " samples = samples_harmonic + samples_gradient + samples_curl\n", + "else:\n", + " key, samples = sample_paths(other_edges, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + " \n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", + " vmin=vmin, vmax=vmax, **options)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@InProceedings{pmlr-v238-yang24e,\n", + " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", + " pages = \t {3754--3762},\n", + " year = \t {2024},\n", + " volume = \t {238},\n", + " series = \t {Proceedings of Machine Learning Research},\n", + " month = \t {02--04 May},\n", + " publisher = {PMLR},\n", + " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", + " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/spaces/test_graph.py b/tests/spaces/test_graph.py deleted file mode 100644 index fc94155c..00000000 --- a/tests/spaces/test_graph.py +++ /dev/null @@ -1,220 +0,0 @@ -import warnings - -import jax -import lab as B -import numpy as np -import scipy.sparse as sp -import tensorflow as tf -import torch - -from geometric_kernels.jax import * # noqa -from geometric_kernels.kernels import MaternKarhunenLoeveKernel -from geometric_kernels.spaces import Graph -from geometric_kernels.tensorflow import * # noqa -from geometric_kernels.torch import * # noqa - -warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") - -A = np.array( - [ - [0, 1, 0, 0, 0, 0, 0], - [1, 0, 1, 1, 1, 0, 0], - [0, 1, 0, 0, 0, 1, 0], - [0, 1, 0, 0, 1, 0, 0], - [0, 1, 0, 1, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0], - ] -).astype(np.float64) - -L = np.array( - [ - [1, -1, 0, 0, 0, 0, 0], - [-1, 4, -1, -1, -1, 0, 0], - [0, -1, 2, 0, 0, -1, 0], - [0, -1, 0, 2, -1, 0, 0], - [0, -1, 0, -1, 2, 0, 0], - [0, 0, -1, 0, 0, 1, 0], - [0, 0, 0, 0, 0, 0, 0], - ] -).astype(np.float64) - - -def run_tests_with_adj(A, L, tol=1e-7, tol_m=1e-4): - ############################################## - # Inits - - n = A.shape[0] - L = B.cast(B.dtype(A), L) - graph = Graph(A) - - normed_graph = Graph(A, normalize_laplacian=True) - - ############################################## - # Laplacian computation - - comparison = graph._laplacian == L - - if sp.issparse(comparison): - comparison = comparison.toarray() - - if isinstance(comparison, np.matrix): # bug with lab? - assert comparison.all(), "Laplacian does not match." - else: - assert B.all(comparison), "Laplacian does not match." - - normed_l = normed_graph._laplacian - if sp.issparse(normed_l): - normed_l = normed_l.toarray() - - assert ( - B.max(B.abs(B.diag(normed_l) - 1)[:-1]) < tol_m - and B.abs(B.diag(normed_l)[-1] - 0) < tol_m - ) - - ############################################## - # Eigendecomposition checks - - evecs = graph.get_eigenvectors(n) - evals = graph.get_eigenvalues(n) - - evals_np, evecs_np = np.linalg.eigh(L) - evecs_np *= np.sqrt(graph.num_vertices) - - # check vals - np.testing.assert_allclose(evals[:, 0], evals_np, atol=tol, rtol=tol) - - # check vecs - np.testing.assert_allclose( - np.abs(evecs)[:, 2:], np.abs(evecs_np)[:, 2:], atol=tol, rtol=tol - ) - - try: - np.testing.assert_allclose( - np.abs(evecs)[:, :2], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol - ) - except AssertionError: - np.testing.assert_allclose( - np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol - ) - - normed_evals = normed_graph.get_eigenvalues(n) - assert (B.min(normed_evals) >= 0) and ( - B.max(normed_evals) <= 2 - ) # well known inequality - - ############################################## - # Kernel init checks - - K_cons = MaternKarhunenLoeveKernel(graph, n, normalize=False) - params = K_cons.init_params() - - idx = B.cast(B.dtype(A), np.arange(n)[:, None]) - - nu = B.cast(B.dtype(A), np.array([1.0])) - lscale = B.cast(B.dtype(A), np.array([1.0])) - - K_normed_cons = MaternKarhunenLoeveKernel(normed_graph, n, normalize=False) - normed_params = K_normed_cons.init_params() - - ############################################## - # Matern 1 check - - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - K1 = evecs_np @ np.diag(np.power(evals_np + 2, -1)) @ evecs_np.T - np.testing.assert_allclose(Kg, K1, atol=tol, rtol=tol) - - normed_params["nu"], normed_params["lengthscale"] = nu, lscale - K_normed_cons.K(normed_params, idx) - - ############################################## - # Matern 2 check - - nu = B.cast(B.dtype(A), np.array([2.0])) - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - K2 = evecs_np @ np.diag(np.power(evals_np + 4, -2)) @ evecs_np.T - np.testing.assert_allclose(Kg, K2, atol=tol, rtol=tol) - - ############################################## - # RBF check - - nu = B.cast(B.dtype(A), np.array([np.inf])) - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T - np.testing.assert_allclose(Kg, Ki, atol=tol, rtol=tol) - - ############################################## - # Fewer than n eigencomps check - - m = 4 - evecs = graph.get_eigenvectors(m) - evals = graph.get_eigenvalues(m) - if isinstance(L, jax.numpy.ndarray): - evals_np, evecs_np = np.linalg.eigh(B.to_numpy(L)) - evals_np, evecs_np = evals_np[:m], evecs_np[:, :m] - else: - evals_np, evecs_np = sp.linalg.eigsh(B.to_numpy(L), m, sigma=1e-8) - evecs_np *= np.sqrt(graph.num_vertices) - - np.testing.assert_allclose(evals[:, 0], evals_np, atol=tol_m, rtol=tol_m) - - try: - np.testing.assert_allclose( - np.abs(evecs)[:, :2], np.abs(evecs_np)[:, :2], atol=tol_m, rtol=tol_m - ) - except AssertionError: - np.testing.assert_allclose( - np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol_m, rtol=tol_m - ) - - K_cons = MaternKarhunenLoeveKernel(graph, m, normalize=False) - params = K_cons.init_params() - - nu = B.cast(B.dtype(A), np.array([np.inf])) - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T - np.testing.assert_allclose(Kg, Ki, atol=tol_m, rtol=tol_m) - - -def test_graphs_numpy(): - run_tests_with_adj(A, L) - - -def test_graphs_scipy_sparse(): - run_tests_with_adj(sp.csr_matrix(A), L) - - -def test_graphs_torch(): - run_tests_with_adj(torch.tensor(A), L) - - -def test_graphs_tf(): - run_tests_with_adj(tf.Variable(A), L) - - -def test_graphs_jax(): - run_tests_with_adj(jax.numpy.array(A), L, 1e-4, 1e-4) - - -def test_graphs_torch_cuda(): - if torch.cuda.is_available(): - adj = torch.tensor(A).cuda() - - n = adj.shape[0] - graph = Graph(adj) - # normed_graph = Graph(adj, normalize_laplacian=True) # fails due to bug in lab - - K_cons = MaternKarhunenLoeveKernel(graph, n, normalize=False) - params = K_cons.init_params() - - params["nu"] = torch.nn.Parameter(torch.tensor([1.0]).cuda()) - params["lengthscale"] = torch.nn.Parameter(torch.tensor([1.0]).cuda()) - - idx = torch.arange(n)[:, None].cuda() - K_cons.K(params, idx) - else: - pass diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edge.py index 91c73339..6f82f0c5 100644 --- a/tests/spaces/test_graph_edge.py +++ b/tests/spaces/test_graph_edge.py @@ -5,52 +5,38 @@ import numpy as np import scipy.sparse as sp import torch +import networkx as nx from geometric_kernels.jax import * # noqa -from geometric_kernels.kernels import MaternKarhunenLoeveKernel +from geometric_kernels.kernels import ( + MaternKarhunenLoeveKernel, + MaternKarhunenLoeveKernel_HodgeCompositionEdge +) from geometric_kernels.spaces.graph_edge import GraphEdge from geometric_kernels.torch import * # noqa warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") -B1 = np.array( - [ - [-1, -1, -1, 0, 0, 0], - [1, 0, 0, -1, 0, 0], - [0, 1, 0, 1, -1, 0], - [0, 0, 1, 0, 0, -1], - [0, 0, 0, 0, 1, 1], - ] -).astype(np.float64) - -B2 = np.array( - [ - [1], - [-1], - [0], - [1], - [0], - [0], - ] -).astype(np.float64) - - -def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): +G = nx.Graph() +G.add_edge(1, 2) +G.add_edge(1, 3) +G.add_edge(1, 5) +G.add_edge(2, 3) +G.add_edge(3, 4) +G.add_edge(4, 5) + +triangles = [(1,2,3)] + + +def run_tests_with_lap(tol=1e-7, tol_m=1e-4): ############################################## # Inits - - m = B1.shape[1] - sc = GraphEdge(B1, B2) + sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True) + m = sc.num_edges ############################################## # Laplacian computation - L = B.matmul(B1, B1, tr_a=True) + B.matmul(B2, B2, tr_b=True) - comparison = sc._edge_laplacian == L - - if sp.issparse(comparison): - comparison = comparison.toarray() - - assert B.all(comparison), "Laplacian does not match." + L = sc.edge_laplacian ############################################## # Eigendecomposition checks @@ -77,16 +63,17 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol ) + ############################################## # Kernel init checks K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) params = K_cons.init_params() - idx = B.cast(B.dtype(B1), np.arange(m)[:, None]) + idx = B.cast(B.dtype(L), np.arange(m)[:, None]) - nu = B.cast(B.dtype(B1), np.array([1.0])) - lscale = B.cast(B.dtype(B1), np.array([1.0])) + nu = B.cast(B.dtype(L), np.array([1.0])) + lscale = B.cast(B.dtype(L), np.array([1.0])) K_normed_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) normed_params = K_normed_cons.init_params() @@ -105,7 +92,7 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): ############################################## # Matern 2 check - nu = B.cast(B.dtype(B1), np.array([2.0])) + nu = B.cast(B.dtype(L), np.array([2.0])) params["nu"], params["lengthscale"] = nu, lscale Kg = K_cons.K(params, idx) K2 = evecs_np @ np.diag(np.power(evals_np + 4, -2)) @ evecs_np.T @@ -114,7 +101,7 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): ############################################## # RBF check - nu = B.cast(B.dtype(B1), np.array([np.inf])) + nu = B.cast(B.dtype(L), np.array([np.inf])) params["nu"], params["lengthscale"] = nu, lscale Kg = K_cons.K(params, idx) Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T @@ -146,7 +133,7 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) params = K_cons.init_params() - nu = B.cast(B.dtype(B1), np.array([np.inf])) + nu = B.cast(B.dtype(L), np.array([np.inf])) params["nu"], params["lengthscale"] = nu, lscale Kg = K_cons.K(params, idx) Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T @@ -154,21 +141,20 @@ def run_tests_with_adj(B1, B2, tol=1e-7, tol_m=1e-4): def test_graphs_numpy(): - run_tests_with_adj(B1, B2) - + run_tests_with_lap() def test_graphs_torch(): - run_tests_with_adj(torch.tensor(B1), torch.tensor(B2)) + run_tests_with_lap() def test_graphs_jax(): - run_tests_with_adj(jax.numpy.array(B1), jax.numpy.array(B2), 1e-4, 1e-4) + run_tests_with_lap(1e-4, 1e-4) def test_graphs_torch_cuda(): if torch.cuda.is_available(): - m = B1.shape[1] - sc = GraphEdge(torch.tensor(B1).cuda(), torch.tensor(B2).cuda()) + sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True) + m = sc.num_edges K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) params = K_cons.init_params() From c2de819322a18be8c1b7b38be98311ef54919378 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Mon, 21 Oct 2024 18:39:25 +0200 Subject: [PATCH 07/30] edge space takes edges of node pairs as inputs, instead of indices --- geometric_kernels/spaces/graph_edge.py | 51 +++++++--- .../backends/JAX_SimplicialComplex.ipynb | 65 +++++++++---- .../backends/PyTorch_SimplicialComplex.ipynb | 92 +++++++++++++------ 3 files changed, 147 insertions(+), 61 deletions(-) diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index 4ebc2125..955f9274 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -52,9 +52,13 @@ class GraphEdge(DiscreteSpectrumSpace): """ def __init__(self, G, triangle_list=None, sc_lifting=False): # type: ignore - self.G = G + self.G = nx.Graph() self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - self.incidence_matrix = nx.incidence_matrix(G, oriented=True).toarray() # "obtain the oriented incidence matrix" + # reorder the edges in the graph based on the order of the nodes + self.nodes = list(G.nodes) + self.edges = [(min(u, v), max(u, v)) for u, v in G.edges] + self.G.add_edges_from(self.edges) + self.incidence_matrix = nx.incidence_matrix(self.G, oriented=True).toarray() # "obtain the oriented incidence matrix" if sc_lifting is not False: if triangle_list is None: print("No list of triangles is provided, we consider all triangles in the graph as 2-simplices.") @@ -110,8 +114,8 @@ def dimension(self) -> int: def sc_simplices(self): """return the nodes, edges and triangles in the graph""" print('----Simplicial 2-complex summary---') - print('nodes: ', list(self.G.nodes)) - print('edges: ', list(self.G.edges)) + print('nodes: ', self.nodes) + print('edges: ', self.edges) print('triangles: ', self.triangles) return None @@ -150,6 +154,21 @@ def edge_laplacian(self): else: return self._edge_laplacian, self._down_edge_laplacian, self._up_edge_laplacian + def get_edge_index(self, edges): + """ + Get the indices of some provided edges in the edge list. + + Args: + edges (list): Edges. + + Returns: + list: Indices of the edges. + """ + assert isinstance(edges, list) # "The edges should be a list." + # each edge should be in the edge list + assert all(edge in self.edges for edge in edges) + return B.to_numpy([self.edges.index(edge) for edge in edges]) + def triangles_all_clique(self) -> list: """ Get a list of triangles in the graph. @@ -181,23 +200,23 @@ def triangles_to_B2(self) -> np.ndarray: Returns: np.ndarray: B2 matrix. """ - edges = list(self.G.edges) + triangles = self.triangles - B2 = np.zeros((len(edges), len(triangles))) + B2 = np.zeros((len(self.edges), len(triangles))) for j, triangle in enumerate(triangles): a, b, c = triangle try: - index_a = edges.index((a, b)) + index_a = self.edges.index((a, b)) except ValueError: - index_a = edges.index((b, a)) + index_a = self.edges.index((b, a)) try: - index_b = edges.index((b, c)) + index_b = self.edges.index((b, c)) except ValueError: - index_b = edges.index((c, b)) + index_b = self.edges.index((c, b)) try: - index_c = edges.index((a, c)) + index_c = self.edges.index((a, c)) except ValueError: - index_c = edges.index((c, a)) + index_c = self.edges.index((c, a)) B2[index_a, j] = 1 B2[index_c, j] = -1 @@ -363,11 +382,13 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: def random(self, key, number): num_edges = B.shape(self._edge_laplacian)[0] - key, random_edges = B.randint( + key, random_edges_idx = B.randint( key, dtype_integer(key), number, 1, lower=0, upper=num_edges, ) - - return key, random_edges + + random_edges = [self.edges[i] for i in random_edges_idx.flatten().tolist()] + + return key, random_edges, random_edges_idx @property def element_shape(self): diff --git a/notebooks/backends/JAX_SimplicialComplex.ipynb b/notebooks/backends/JAX_SimplicialComplex.ipynb index 89b101b8..ad4db439 100644 --- a/notebooks/backends/JAX_SimplicialComplex.ipynb +++ b/notebooks/backends/JAX_SimplicialComplex.ipynb @@ -294,7 +294,7 @@ "text": [ "----Simplicial 2-complex summary---\n", "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (4, 5)]\n", "triangles: [(1, 2, 3)]\n" ] } @@ -313,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -327,7 +327,7 @@ " [ 0.]])" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -338,7 +338,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -375,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -448,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -465,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -527,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -556,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -595,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -644,6 +644,35 @@ "An explicit `key` parameter is needed to support JAX as one of the backends." ] }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(1, 2), (1, 3), (1, 5)]\n" + ] + } + ], + "source": [ + "key = PRNGKey(1234)\n", + "\n", + "key, random_sampled_edges, xs = sc.random(key, 3)\n", + "print(random_sampled_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If users prefer input the edges directly, we would need to obtain the indices of the edges in the edge space of the simplicial complex. This can be done by calling `sc.get_edge_index(input_edges)`.\n", + "\n", + "Below we verify that the indices of the sampled edges are correct." + ] + }, { "cell_type": "code", "execution_count": 18, @@ -653,6 +682,9 @@ "name": "stdout", "output_type": "stream", "text": [ + "[[0]\n", + " [1]\n", + " [2]]\n", "[[0]\n", " [1]\n", " [2]]\n" @@ -660,11 +692,10 @@ } ], "source": [ - "key = PRNGKey(1234)\n", - "\n", - "key, xs = sc.random(key, 3)\n", - "\n", - "print(xs)" + "print(xs)\n", + "input_indices = sc.get_edge_index(random_sampled_edges)\n", + "input_indices = jnp.array(input_indices).reshape(-1, 1)\n", + "print(input_indices)" ] }, { @@ -785,8 +816,8 @@ "metadata": {}, "outputs": [], "source": [ - "base_edge = (1,2)\n", - "base_edge_idx = list(G.edges).index(base_edge)\n", + "base_edge = [(1,2)]\n", + "base_edge_idx = sc.get_edge_index(base_edge)[0]\n", "other_edges = jnp.arange(sc.num_edges)[:, None]\n", "edges = [e for e in G.edges()]" ] diff --git a/notebooks/backends/PyTorch_SimplicialComplex.ipynb b/notebooks/backends/PyTorch_SimplicialComplex.ipynb index 0da45e8b..774a936d 100644 --- a/notebooks/backends/PyTorch_SimplicialComplex.ipynb +++ b/notebooks/backends/PyTorch_SimplicialComplex.ipynb @@ -281,7 +281,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -290,7 +290,7 @@ "text": [ "----Simplicial 2-complex summary---\n", "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", + "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (4, 5)]\n", "triangles: [(1, 2, 3)]\n" ] } @@ -309,7 +309,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -323,7 +323,7 @@ " [ 0.]])" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -334,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -371,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -444,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -461,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -523,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -559,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -598,7 +598,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -644,21 +644,21 @@ "metadata": {}, "source": [ "We start by sampling `3` (uniformly) random points on the edge space of our simplicial complex.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." + "An explicit `key` parameter is needed to support JAX as one of the backends.\n", + "\n", + "**Note:** the here `xs` are the **indicex** of the sampled edges, not the edges themselves." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor([[4],\n", - " [1],\n", - " [0]], dtype=torch.int32)\n" + "[(3, 4), (1, 3), (1, 2)]\n" ] } ], @@ -666,8 +666,42 @@ "key = torch.Generator()\n", "key.manual_seed(123)\n", "\n", - "key, xs = sc.random(key, 3)\n", - "print(xs)" + "key, random_sampled_edges, xs = sc.random(key, 3)\n", + "print(random_sampled_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If users prefer input the edges directly, we would need to obtain the indices of the edges in the edge space of the simplicial complex. This can be done by calling `sc.get_edge_index(input_edges)`.\n", + "\n", + "Below we verify that the indices of the sampled edges are correct." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[4],\n", + " [1],\n", + " [0]], dtype=torch.int32)\n", + "tensor([[4],\n", + " [1],\n", + " [0]])\n" + ] + } + ], + "source": [ + "print(xs)\n", + "input_indices = sc.get_edge_index(random_sampled_edges)\n", + "input_indices = torch.tensor(input_indices).reshape(-1, 1)\n", + "print(input_indices)" ] }, { @@ -784,12 +818,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ - "base_edge = (1,2)\n", - "base_edge_idx = list(G.edges).index(base_edge)\n", + "base_edge = [(1,2)]\n", + "base_edge_idx = sc.get_edge_index(base_edge)[0]\n", "other_edges = torch.arange(sc.num_edges)[:, None]\n", "edges = [e for e in G.edges()]" ] @@ -803,7 +837,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -826,7 +860,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -850,7 +884,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -953,7 +987,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1008,7 +1042,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -1036,7 +1070,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1110,7 +1144,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -1157,7 +1191,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 33, "metadata": {}, "outputs": [ { From d7eb878831d90bbf8acd0bcb15b63ef383645eb2 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Fri, 29 Nov 2024 18:26:48 +0100 Subject: [PATCH 08/30] updates --- .gitignore | 1 + geometric_kernels/feature_maps/__init__.py | 3 +- .../feature_maps/deterministic.py | 55 +-- geometric_kernels/kernels/__init__.py | 6 +- .../kernels/hodge_compositional.py | 167 ++++++++ geometric_kernels/kernels/karhunen_loeve.py | 156 +------ geometric_kernels/kernels/matern_kernel.py | 30 +- geometric_kernels/sampling/samplers.py | 16 +- geometric_kernels/spaces/__init__.py | 1 + geometric_kernels/spaces/base.py | 78 +++- geometric_kernels/spaces/graph_edge.py | 379 ++++++++---------- notebooks/SimplicialComplex.ipynb | 207 +++++----- .../backends/JAX_SimplicialComplex.ipynb | 116 ++---- .../backends/PyTorch_SimplicialComplex.ipynb | 136 ++----- tests/spaces/test_graph_edge.py | 162 +------- tests/utils/test_special_functions.py | 5 +- 16 files changed, 701 insertions(+), 817 deletions(-) create mode 100644 geometric_kernels/kernels/hodge_compositional.py diff --git a/.gitignore b/.gitignore index 910896f3..07a80a31 100644 --- a/.gitignore +++ b/.gitignore @@ -142,3 +142,4 @@ dmypy.json # Idea /.idea/ +*_old* \ No newline at end of file diff --git a/geometric_kernels/feature_maps/__init__.py b/geometric_kernels/feature_maps/__init__.py index a0083cd7..9a42a1f9 100644 --- a/geometric_kernels/feature_maps/__init__.py +++ b/geometric_kernels/feature_maps/__init__.py @@ -8,7 +8,8 @@ # noqa: F401 from geometric_kernels.feature_maps.base import FeatureMap from geometric_kernels.feature_maps.deterministic import ( - DeterministicFeatureMapCompact, DeterministicFeatureMapCompact_HodgeCompositional + DeterministicFeatureMapCompact, + HodgeDeterministicFeatureMapCompact, ) from geometric_kernels.feature_maps.random_phase import ( RandomPhaseFeatureMapCompact, diff --git a/geometric_kernels/feature_maps/deterministic.py b/geometric_kernels/feature_maps/deterministic.py index 739cbca3..fbfcb943 100644 --- a/geometric_kernels/feature_maps/deterministic.py +++ b/geometric_kernels/feature_maps/deterministic.py @@ -9,11 +9,9 @@ from beartype.typing import Dict, Optional, Tuple from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.kernels.karhunen_loeve import ( - MaternKarhunenLoeveKernel, - MaternKarhunenLoeveKernel_HodgeCompositionEdge - ) -from geometric_kernels.spaces import DiscreteSpectrumSpace +from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.spaces import DiscreteSpectrumSpace, HodgeDiscreteSpectrumSpace class DeterministicFeatureMapCompact(FeatureMap): @@ -83,17 +81,18 @@ def __call__( return None, features -class DeterministicFeatureMapCompact_HodgeCompositional(FeatureMap): +class HodgeDeterministicFeatureMapCompact(FeatureMap): r""" Deterministic feature map for :class:`~.spaces.GraphEdge`\ s for which the actual eigenpairs are explicitly available. - - Note: We obtain the embedding by Hodge subspace. + + Note: We obtain the embedding by Hodge subspace. """ - def __init__(self, space: DiscreteSpectrumSpace, num_levels: int): + + def __init__(self, space: HodgeDiscreteSpectrumSpace, num_levels: int): self.space = space self.num_levels = num_levels - self.kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge(space, num_levels) + self.kernel = MaternHodgeCompositionalKernel(space, num_levels) def __call__( self, @@ -113,7 +112,7 @@ def __call__( or None, follows the standard behavior of :class:`~.kernels.MaternKarhunenLoeveKernel`). :param hodge_type: - The type of Hodge embedding to compute. + The type of Hodge embedding to compute. :param ``**kwargs``: Unused. @@ -127,16 +126,26 @@ def __call__( interface: for some other subclasses of :class:`FeatureMap`, this first element may be an updated random key. """ - self.repeated_eigenvalues = self.space.get_eigenvalues_by_type(self.kernel.num_levels, hodge_type) - - if hodge_type == 'harmonic': - hodge_kernel = self.kernel.harmonic_kernel - elif hodge_type == 'gradient': - hodge_kernel = self.kernel.gradient_kernel - elif hodge_type == 'curl': - hodge_kernel = self.kernel.curl_kernel - - spectrum = hodge_kernel._spectrum( + self.repeated_eigenvalues = self.space.get_eigenvalues( + self.kernel.num_levels, hodge_type + ) + + hodge_kernel = { + "harmonic": self.kernel.kernel_harmonic, + "gradient": self.kernel.kernel_gradient, + "curl": self.kernel.kernel_curl, + }.get(hodge_type) + + spectrum = B.cast( + B.dtype( + hodge_kernel._spectrum( + self.repeated_eigenvalues, + nu=params["nu"], + lengthscale=params["lengthscale"], + ) + ), + params["logit"], + ) * hodge_kernel._spectrum( self.repeated_eigenvalues, nu=params["nu"], lengthscale=params["lengthscale"], @@ -146,9 +155,9 @@ def __call__( normalizer = B.sum(spectrum) spectrum = spectrum / normalizer - weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] + weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] eigenfunctions = hodge_kernel.eigenfunctions(X, **params) # [N, M] features = B.cast(B.dtype(params["lengthscale"]), eigenfunctions) * B.cast( B.dtype(params["lengthscale"]), weights ) # [N, M] - return None, features \ No newline at end of file + return None, features diff --git a/geometric_kernels/kernels/__init__.py b/geometric_kernels/kernels/__init__.py index b3021a0b..c404c291 100644 --- a/geometric_kernels/kernels/__init__.py +++ b/geometric_kernels/kernels/__init__.py @@ -9,10 +9,8 @@ # noqa: F401 from geometric_kernels.kernels.base import BaseGeometricKernel from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel -from geometric_kernels.kernels.karhunen_loeve import ( - MaternKarhunenLoeveKernel, - MaternKarhunenLoeveKernel_HodgeCompositionEdge - ) +from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel from geometric_kernels.kernels.matern_kernel import ( MaternGeometricKernel, default_feature_map, diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py new file mode 100644 index 00000000..bb35338e --- /dev/null +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -0,0 +1,167 @@ +""" +This module provides the :class:`MaternKarhunenLoeveKernel` kernel, the basic +kernel for discrete spectrum spaces, subclasses of :class:`DiscreteSpectrumSpace`. +""" + +import lab as B +import numpy as np +from beartype.typing import Dict, Optional + +from geometric_kernels.kernels.base import BaseGeometricKernel +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.spaces import HodgeDiscreteSpectrumSpace + + +class MaternHodgeCompositionalKernel(BaseGeometricKernel): + r""" + TODO + :param space: + The space to define the kernel upon. + :param num_levels: + Number of levels to include in the summation. + :param normalize: + Whether to normalize kernel to have unit average variance. + """ + + def __init__( + self, + space: HodgeDiscreteSpectrumSpace, + num_levels: int, + normalize: bool = True, + ): + super().__init__(space) + self.num_levels = num_levels # in code referred to as `L`. + for hodge_type in ["harmonic", "curl", "gradient"]: + eigenvalues = self.space.get_eigenvalues(self.num_levels, hodge_type) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels, hodge_type) + num_levels_per_type = eigenvalues.shape[0] + setattr( + self, + f"kernel_{hodge_type}", + MaternKarhunenLoeveKernel( + space, + num_levels_per_type, + normalize, + eigenvalues_laplacian=eigenvalues, + eigenfunctions=eigenfunctions, + ), + ) + self.normalize = normalize + + @property + def space(self) -> HodgeDiscreteSpectrumSpace: + """ + The space on which the kernel is defined. + """ + self._space: HodgeDiscreteSpectrumSpace + return self._space + + def init_params(self) -> Dict[str, B.NPNumeric]: + """ + Initialize the three sets of parameters for the three kernels. + """ + params = dict( + harmonic=dict( + logit=np.array([1.0]), + nu=np.array([np.inf]), + lengthscale=np.array([1.0]), + ), + gradient=dict( + logit=np.array([1.0]), + nu=np.array([np.inf]), + lengthscale=np.array([1.0]), + ), + curl=dict( + logit=np.array([1.0]), + nu=np.array([np.inf]), + lengthscale=np.array([1.0]), + ), + ) + + return params + + def eigenvalues( + self, params: Dict[str, B.Numeric], normalize: Optional[bool] = None + ) -> B.Numeric: + """ + Eigenvalues of the kernel. + + :param params: + Parameters of the kernel. Must contain keys `"lengthscale"` and + `"nu"`. The shapes of `params["lengthscale"]` and `params["nu"]` + are `(1,)`. + :param normalize: + Whether to normalize kernel to have unit average variance. + If None, uses `self.normalize` to decide. + + Defaults to None. + + :return: + An [L, 1]-shaped array. + """ + assert "harmonic" in params + assert "gradient" in params + assert "curl" in params + assert params["harmonic"]["lengthscale"].shape == (1,) + assert params["gradient"]["lengthscale"].shape == (1,) + assert params["curl"]["lengthscale"].shape == (1,) + assert params["harmonic"]["nu"].shape == (1,) + assert params["gradient"]["nu"].shape == (1,) + assert params["curl"]["nu"].shape == (1,) + + spectral_values_harmonic = self.kernel_harmonic.eigenvalues( + params=params["harmonic"], normalize=normalize + ) + spectral_values_gradient = self.kernel_gradient.eigenvalues( + params=params["gradient"], normalize=normalize + ) + spectral_values_curl = self.kernel_curl.eigenvalues( + params=params["curl"], normalize=normalize + ) + spectral_values = { + "harmonic": spectral_values_harmonic, + "gradient": spectral_values_gradient, + "curl": spectral_values_curl, + } + return spectral_values + + def K( + self, params, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs # type: ignore + ) -> B.Numeric: + + return ( + B.cast( + B.dtype(self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs)), + params["harmonic"]["logit"], + ) + * self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs) + + B.cast( + B.dtype(self.kernel_harmonic.K(params["gradient"], X, X2, **kwargs)), + params["gradient"]["logit"], + ) + * self.kernel_gradient.K(params["gradient"], X, X2, **kwargs) + + B.cast( + B.dtype(self.kernel_harmonic.K(params["curl"], X, X2, **kwargs)), + params["curl"]["logit"], + ) + * self.kernel_curl.K(params["curl"], X, X2, **kwargs) + ) + + def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: + return ( + B.cast( + B.dtype(self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs)), + params["harmonic"]["logit"], + ) + * self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs) + + B.cast( + B.dtype(self.kernel_harmonic.K_diag(params["gradient"], X, **kwargs)), + params["gradient"]["logit"], + ) + * self.kernel_gradient.K_diag(params["gradient"], X, **kwargs) + + B.cast( + B.dtype(self.kernel_harmonic.K_diag(params["curl"], X, **kwargs)), + params["curl"]["logit"], + ) + * self.kernel_curl.K_diag(params["curl"], X, **kwargs) + ) diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index c5d075f9..ddc4a203 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -58,11 +58,27 @@ def __init__( space: DiscreteSpectrumSpace, num_levels: int, normalize: bool = True, + eigenvalues_laplacian: Optional[B.Numeric] = None, + eigenfunctions: Optional[Eigenfunctions] = None, ): super().__init__(space) self.num_levels = num_levels # in code referred to as `L`. - self._eigenvalues_laplacian = self.space.get_eigenvalues(self.num_levels) - self._eigenfunctions = self.space.get_eigenfunctions(self.num_levels) + if eigenvalues_laplacian is None: + assert eigenfunctions is None + eigenvalues_laplacian = self.space.get_eigenvalues(self.num_levels) + else: + assert eigenfunctions is not None + assert eigenvalues_laplacian.shape == (num_levels, 1) + + if eigenfunctions is None: + assert eigenvalues_laplacian is None + eigenfunctions = self.space.get_eigenfunctions(self.num_levels) + else: + assert eigenvalues_laplacian is not None + assert eigenfunctions.num_levels == num_levels + + self._eigenvalues_laplacian = eigenvalues_laplacian + self._eigenfunctions = eigenfunctions self.normalize = normalize @property @@ -186,7 +202,7 @@ def eigenvalues( ) ) return spectral_values / normalizer - + return spectral_values def K( @@ -218,137 +234,3 @@ def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: return B.real(K_diag) else: return K_diag - - -class MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type(MaternKarhunenLoeveKernel): - def __init__(self, hodge_type, - space: DiscreteSpectrumSpace, - num_levels: int, - normalize: bool = True,): - assert hodge_type in ['harmonic', 'gradient', 'curl'] - self.hodge_type = hodge_type - super().__init__(space, num_levels, normalize) - self._eigenvalues_laplacian = self.space.get_eigenvalues_by_type(self.num_levels, self.hodge_type) - self._eigenfunctions = self.space.get_eigenfunctions_by_type(self.num_levels, self.hodge_type) - - -class MaternKarhunenLoeveKernel_HodgeCompositionEdge(BaseGeometricKernel): - r""" - This class approximates Hodge-compositional Edge Matérn kernel by its truncated Mercer decomposition, together with the Hodge decomposition, - in terms of the eigenfunctions & eigenvalues of the Laplacian on the space. - - .. math:: k(x, x') = k_{\text{harmonic}}(x, x') + k_{\text{gradient}}(x, x') + k_{\text{curl}}(x, x') - - where $k_{\text{harmonic}}(x, x')$, $k_{\text{gradient}}(x, x')$ and $k_{\text{curl}}(x, x')$ are the Hodge kernels of the compositional kernel with respect to the harmonic, gradient and curl spaces, respectively. - - """ - def __init__(self, space: DiscreteSpectrumSpace, num_levels: int, normalize: bool = True): - super().__init__(space) - self.num_levels = num_levels - self.harmonic_kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type('harmonic', space, num_levels, normalize) - self.gradient_kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type('gradient', space, num_levels, normalize) - self.curl_kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge_by_type('curl', space, num_levels, normalize) - self.normalize = normalize - - @property - def space(self) -> DiscreteSpectrumSpace: - """ - The space on which the kernel is defined. - """ - self._space: DiscreteSpectrumSpace - return self._space - - def init_params(self) -> Dict[str, B.NPNumeric]: - """ - Initializes the dict of the trainable parameters of the kernel. - - Returns 'dict(harmonic=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), - gradient=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), - curl=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0]))'. - - This dict can be modified and is passed around into such methods as - :meth:`~.K` or :meth:`~.K_diag`, as the `params` argument. - - .. note:: - The values in the returned dict are always of the NumPy array type. - Thus, if you want to use some other backend for internal - computations when calling :meth:`~.K` or :meth:`~.K_diag`, you - need to replace the values with the analogs typed as arrays of - the desired backend. - """ - params = dict(harmonic=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), - gradient=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])), - curl=dict(nu=np.array([np.inf]), lengthscale=np.array([1.0])) - ) - - return params - - def eigenvalues( - self, params: Dict[str, B.Numeric], normalize: Optional[bool] = None - ) -> B.Numeric: - """ - Eigenvalues of the kernel. - - :param params: - Parameters of the kernel. Must contain keys `"lengthscale"` and - `"nu"`. The shapes of `params["lengthscale"]` and `params["nu"]` - are `(1,)`. - :param normalize: - Whether to normalize kernel to have unit average variance. - If None, uses `self.normalize` to decide. - - Defaults to None. - - :return: - An [L, 1]-shaped array. - """ - assert "harmonic" in params - assert "gradient" in params - assert "curl" in params - assert params["harmonic"]["lengthscale"].shape == (1,) - assert params["gradient"]["lengthscale"].shape == (1,) - assert params["curl"]["lengthscale"].shape == (1,) - assert params["harmonic"]["nu"].shape == (1,) - assert params["gradient"]["nu"].shape == (1,) - assert params["curl"]["nu"].shape == (1,) - - spectral_values_harmonic = self.harmonic_kernel.eigenvalues( - params=params["harmonic"], normalize=normalize - ) - spectral_values_gradient = self.gradient_kernel.eigenvalues( - params=params["gradient"], normalize=normalize - ) - spectral_values_curl = self.curl_kernel.eigenvalues( - params=params["curl"], normalize=normalize - ) - spectral_values = {'harmonic': spectral_values_harmonic, 'gradient': spectral_values_gradient, 'curl': spectral_values_curl} - return spectral_values - - def K(self, params, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs) -> B.Numeric: - assert "harmonic" in params - assert "gradient" in params - assert "curl" in params - assert params["harmonic"]["lengthscale"].shape == (1,) - assert params["gradient"]["lengthscale"].shape == (1,) - assert params["curl"]["lengthscale"].shape == (1,) - assert params["harmonic"]["nu"].shape == (1,) - assert params["gradient"]["nu"].shape == (1,) - assert params["curl"]["nu"].shape == (1,) - - return self.harmonic_kernel.K(params['harmonic'], X, X2, **kwargs) + self.gradient_kernel.K(params['gradient'], X, X2, **kwargs) + self.curl_kernel.K(params['curl'], X, X2, **kwargs) - - def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: - assert "harmonic" in params - assert "gradient" in params - assert "curl" in params - assert params["harmonic"]["lengthscale"].shape == (1,) - assert params["gradient"]["lengthscale"].shape == (1,) - assert params["curl"]["lengthscale"].shape == (1,) - assert params["harmonic"]["nu"].shape == (1,) - assert params["gradient"]["nu"].shape == (1,) - assert params["curl"]["nu"].shape == (1,) - - return self.harmonic_kernel.K_diag(params['harmonic'], X, **kwargs) + self.gradient_kernel.K_diag(params['gradient'], X, **kwargs) + self.curl_kernel.K_diag(params['curl'], X, **kwargs) - - - \ No newline at end of file diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 5c0b7ac3..23690581 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -11,7 +11,7 @@ from geometric_kernels.feature_maps import ( DeterministicFeatureMapCompact, - DeterministicFeatureMapCompact_HodgeCompositional, + HodgeDeterministicFeatureMapCompact, RandomPhaseFeatureMapCompact, RandomPhaseFeatureMapNoncompact, RejectionSamplingFeatureMapHyperbolic, @@ -19,10 +19,8 @@ ) from geometric_kernels.kernels.base import BaseGeometricKernel from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel -from geometric_kernels.kernels.karhunen_loeve import ( - MaternKarhunenLoeveKernel, - MaternKarhunenLoeveKernel_HodgeCompositionEdge - ) +from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel from geometric_kernels.spaces import ( CompactMatrixLieGroup, DiscreteSpectrumSpace, @@ -88,11 +86,13 @@ def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): else: return DeterministicFeatureMapCompact(kernel.space, kernel.num_levels) + @overload -def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel_HodgeCompositionEdge): +def feature_map_from_kernel(kernel: MaternHodgeCompositionalKernel): "For Hodge-compositional edge kernels ONLY" assert isinstance(kernel.space, GraphEdge) - return DeterministicFeatureMapCompact_HodgeCompositional(kernel.space, kernel.num_levels) + return HodgeDeterministicFeatureMapCompact(kernel.space, kernel.num_levels) + @overload def feature_map_from_kernel(kernel: MaternFeatureMapKernel): @@ -150,7 +150,7 @@ def feature_map_from_space(space: DiscreteSpectrumSpace, num: int): space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES ) else: - + return DeterministicFeatureMapCompact(space, num) @@ -212,9 +212,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) elif isinstance(space, GraphEdge): - return min( - MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges - ) + return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) elif isinstance(space, HypercubeGraph): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: @@ -327,12 +325,12 @@ def __new__( from Gaussian processes) along with the kernel. Default is False. - + :param use_hodge_composition: If `True`, use the Hodge compositional kernel on the edges of a graph or a simplicial complex. This is only relevant for the :class:`~.spaces.GraphEdge` space. - + :param ``**kwargs``: Any additional keyword arguments to be passed to the kernel (like `key`). @@ -348,7 +346,10 @@ def __new__( num = num or default_num(space) if isinstance(space, GraphEdge): if use_hodge_composition: - kernel = MaternKarhunenLoeveKernel_HodgeCompositionEdge(space, num, normalize=normalize) + kernel = MaternHodgeCompositionalKernel( + space, num, normalize=normalize + ) + print("Using Hodge compositional kernel!") else: kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) else: @@ -380,4 +381,3 @@ def __new__( return kernel, feature_map else: return kernel - \ No newline at end of file diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index 72928f1d..5f75900f 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -61,10 +61,10 @@ def sample_at( Passed down to `feature_map` directly. Controls whether to force the average variance of the Gaussian process to be around 1 or not. If None, follows the standard behavior, typically same as normalize=True. - + Defaults to None. :param hodge_type: - The type of Hodge component to sample. Only used when using Hodge-compositional edge kernels + The type of Hodge component to sample. Only used when using Hodge-compositional edge kernels Defaults to None. @@ -76,11 +76,15 @@ def sample_at( if key is None: key = B.global_random_state(B.dtype(X)) - if hodge_type is None: - _context, features = feature_map(X, params, key=key, normalize=normalize) # [N, M] + if hodge_type is None: + _context, features = feature_map( + X, params, key=key, normalize=normalize + ) # [N, M] else: - _context, features = feature_map(X, params, key=key, normalize=normalize, hodge_type=hodge_type) - + _context, features = feature_map( + X, params, key=key, normalize=normalize, hodge_type=hodge_type + ) + if _context is not None: key = _context diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index f2dde61d..f2dfa4bc 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -5,6 +5,7 @@ # noqa: F401 from geometric_kernels.spaces.base import ( DiscreteSpectrumSpace, + HodgeDiscreteSpectrumSpace, NoncompactSymmetricSpace, Space, ) diff --git a/geometric_kernels/spaces/base.py b/geometric_kernels/spaces/base.py index 6d192bf2..96f48e27 100644 --- a/geometric_kernels/spaces/base.py +++ b/geometric_kernels/spaces/base.py @@ -5,7 +5,7 @@ import abc import lab as B -from beartype.typing import List +from beartype.typing import List, Optional from geometric_kernels.spaces.eigenfunctions import Eigenfunctions @@ -145,6 +145,82 @@ def random(self, key: B.RandomState, number: int) -> B.Numeric: raise NotImplementedError +class HodgeDiscreteSpectrumSpace(DiscreteSpectrumSpace): + r""" + A Space with discrete spectrum (of the Laplacian operator) and Hodge + decomposition. Separates eigenpairs according to the Hodge decomposition, + into the harmonic type, the curl type and the gradient type. + This includes, e.g., the edges of a simplicial 2-complex (graph edges) + or tangent bundles of Riemannian manifolds. + .. note:: + TODO (docs theory page). + .. note:: + Typically used with :class:`~.kernels.MaternHodgeCompositionalKernel`. + """ + + @abc.abstractmethod + def get_eigenfunctions( + self, num: int, type: Optional[str] = None + ) -> Eigenfunctions: + """ + Returns the :class:`~.Eigenfunctions` object with `num` levels. + If `type` is specified, returns only the eigenfunctions of that type. + .. warning:: + If `type` is specified, the returned :class:`~.Eigenfunctions` + object does not have to have `num` levels. It can have less but can + never have more. + :param num: + Number of levels. + :param type: + Type of the eigenfunctions to return. Can be one of "harmonic", + "curl" or "gradient". + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + raise NotImplementedError + + @abc.abstractmethod + def get_eigenvalues(self, num: int, type: str) -> B.Numeric: + """ + Eigenvalues of the Laplacian corresponding to the first `num` levels. + If `type` is specified, returns only the eigenvalues corresponding to + the eigenfunctions of that type. + .. warning:: + If `type` is specified, the array can have fewer than `num` elements. + :param num: + Number of levels. + :return: + (n, 1)-shaped array containing the eigenvalues. n <= num. + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + raise NotImplementedError + + @abc.abstractmethod + def get_repeated_eigenvalues(self, num: int, type: str) -> B.Numeric: + """ + Eigenvalues of the Laplacian corresponding to the first `num` levels, + repeated according to their multiplicity within levels. If `type` is + specified, returns only the eigenvalues corresponding to the + eigenfunctions of that type. + :param num: + Number of levels. + :param type: + Type of the eigenvalues to return. Can be one of "harmonic", + "curl" or "gradient". + :return: + (J, 1)-shaped array containing the repeated eigenvalues, J is + the resulting number of the repeated eigenvalues (of the specified + type, if `type` is given). + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + raise NotImplementedError + + class NoncompactSymmetricSpace(Space): """ Non-compact symmetric space. diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index 955f9274..41da1481 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -3,27 +3,19 @@ """ import lab as B -import numpy as np import networkx as nx -from beartype.typing import Dict, Tuple, Optional - -from geometric_kernels.lab_extras import ( - degree, - dtype_integer, - eigenpairs, - reciprocal_no_nan, - set_value, - take_along_axis, -) +import numpy as np +from beartype.typing import Dict, Optional, Tuple -from geometric_kernels.spaces.base import DiscreteSpectrumSpace +from geometric_kernels.lab_extras import dtype_integer, eigenpairs +from geometric_kernels.spaces.base import HodgeDiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import ( Eigenfunctions, EigenfunctionsFromEigenvectors, ) -class GraphEdge(DiscreteSpectrumSpace): +class GraphEdge(HodgeDiscreteSpectrumSpace): """ The GeometricKernels space representing the edge set of any user-provided undirected graph. @@ -35,13 +27,13 @@ class GraphEdge(DiscreteSpectrumSpace): .. note:: A tutorial on how to use this space is available in the :doc:`EdgeSpaceGraph.ipynb ` notebook. - + :param G: A networkx graph object. - + :param triangle_list: A list of triangles in the graph. If not provided, all triangles in the graph are considered as 2-simplices. - + :param sc_lifting: If True, we lift the graph to a simplicial 2-complex using either the provided triangle list or all the triangles in the graph. This acts also a flag to compute the triangle incidence matrix. Defaults to False. @@ -51,54 +43,40 @@ class GraphEdge(DiscreteSpectrumSpace): citing :cite:t:`yang2024`. """ - def __init__(self, G, triangle_list=None, sc_lifting=False): # type: ignore - self.G = nx.Graph() + def __init__( + self, + node_to_edge_incidence: B.Int, + edge_to_triangle_incidence: Optional[B.Int] = None, + ): self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - # reorder the edges in the graph based on the order of the nodes - self.nodes = list(G.nodes) - self.edges = [(min(u, v), max(u, v)) for u, v in G.edges] - self.G.add_edges_from(self.edges) - self.incidence_matrix = nx.incidence_matrix(self.G, oriented=True).toarray() # "obtain the oriented incidence matrix" - if sc_lifting is not False: - if triangle_list is None: - print("No list of triangles is provided, we consider all triangles in the graph as 2-simplices.") - self.triangles = self.triangles_all_clique() - self.triangle_incidence_matrix = self.triangles_to_B2() - else: - self.triangles = triangle_list - self.triangle_incidence_matrix = self.triangles_to_B2() - else: - self.triangle_incidence_matrix = None - - self._checks(self.incidence_matrix, self.triangle_incidence_matrix) - self._set_laplacian() # type: ignore - self.num_vertices, self.num_edges = self.incidence_matrix.shape - self.num_triangles = self.triangle_incidence_matrix.shape[1] if self.triangle_incidence_matrix is not None else 0 - + self.num_nodes, self.num_edges = node_to_edge_incidence.shape + self._checks(node_to_edge_incidence, edge_to_triangle_incidence) + self._make_oriented(node_to_edge_incidence, edge_to_triangle_incidence) + self.num_triangles = self.edge_to_triangle_incidence.shape[1] + self._set_laplacian() @staticmethod - def _checks(incidence_matrix, triangle_incidence_matrix=None): + def _checks(node_to_edge_incidence, edge_to_triangle_incidence=None): """ - Checks if `incidence_matrix` and `triangle_incidence_matrix` are of + Checks if `node_to_edge_incidence` and `edge_to_triangle_incidence` are of appropriate structure. """ - assert B.rank(incidence_matrix) == 2, "Incidence matrix must be a 2-dim tensor." + assert ( + B.rank(node_to_edge_incidence) == 2 + ), "Incidence matrix must be a 2-dim tensor." assert B.all( - B.sum(incidence_matrix == 1, axis=0) == 1 - ), "Each column of the incidence matrix must contain 1 exactly once." - assert B.all( - B.sum(incidence_matrix == -1, axis=0) == 1 - ), "Each column of the incidence matrix must contain -1 exactly once." - if triangle_incidence_matrix is not None: + B.sum(node_to_edge_incidence != 0, axis=0) == 2 + ), "Each column of the incidence matrix must contain 2 exactly once." + if edge_to_triangle_incidence is not None: assert ( - B.rank(triangle_incidence_matrix) == 2 + B.rank(edge_to_triangle_incidence) == 2 ), "Triangle incidence matrix matrix must be a 2-dim tensor." - num_edges = B.shape(incidence_matrix)[1] - assert B.shape(triangle_incidence_matrix)[0] == num_edges, ( + num_edges = B.shape(node_to_edge_incidence)[1] + assert B.shape(edge_to_triangle_incidence)[0] == num_edges, ( "The first dimension of the triangle incidence matrix must" " be equal to the second dimension of the incidence matrix." ) - assert B.all(B.sum(triangle_incidence_matrix != 0, axis=0) == 3), ( + assert B.all(B.sum(edge_to_triangle_incidence != 0, axis=0) == 3), ( "Each column of the edge triangle incidence matrix must" " have exactly 3 non-zero entries." ) @@ -110,50 +88,63 @@ def dimension(self) -> int: 0. """ return 0 # this is needed for the kernel math to work out - - def sc_simplices(self): - """return the nodes, edges and triangles in the graph""" - print('----Simplicial 2-complex summary---') - print('nodes: ', self.nodes) - print('edges: ', self.edges) - print('triangles: ', self.triangles) - return None + + def _make_oriented(self, node_to_edge_incidence, edge_to_triangle_incidence=None): + """ + Since our inputs are non-oriented, we make them oriented by taking the vertex with the smallest index first. + """ + # make the edges oriented + self.edges = [] + self.nodes = list(range(1, self.num_nodes + 1)) + + for i in range(node_to_edge_incidence.shape[1]): + self.edges.append(tuple(np.where(node_to_edge_incidence[:, i] != 0)[0] + 1)) + + self.node_to_edge_incidence = B.zeros(self.num_nodes, self.num_edges) + for i, edge in enumerate(self.edges): + assert ( + edge[0] < edge[1] + ) # "The first node should have a smaller index than the second node." + self.node_to_edge_incidence[edge[0] - 1, i] = -1 + self.node_to_edge_incidence[edge[1] - 1, i] = 1 + + # make the triangles oriented + if edge_to_triangle_incidence is None: + cliques = nx.enumerate_all_cliques(nx.Graph(self.edges)) + triangle_vertices = [x for x in cliques if len(x) == 3] + # sort the triangles + self.triangles = [tuple(sorted(tri)) for tri in triangle_vertices] + else: + self.triangles = [] + for i in range(edge_to_triangle_incidence.shape[1]): + edge = self.edges[i] + edges_of_triangle = np.where(edge_to_triangle_incidence[:, i] != 0)[0] + nodes_of_triangle = np.unique( + np.where(self.node_to_edge_incidence[:, edges_of_triangle] != 0)[0] + ) + self.triangles.append(tuple(nodes_of_triangle + 1)) + + self.edge_to_triangle_incidence = self.build_edge_to_triangle_incidence() def _set_laplacian(self): """ Construct the appropriate graph Laplacian from the adjacency matrix. """ - self._down_edge_laplacian = self.incidence_matrix.T @ self.incidence_matrix - if self.triangle_incidence_matrix is None: - self._up_edge_laplacian = B.zeros( - B.dtype(self._down_edge_laplacian), *B.shape(self._down_edge_laplacian) - ) - else: - self._up_edge_laplacian = B.matmul( - self.triangle_incidence_matrix, self.triangle_incidence_matrix, tr_b=True - ) - self._edge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian - + self._down_edge_laplacian = ( + self.node_to_edge_incidence.T @ self.node_to_edge_incidence + ) + self._up_edge_laplacian = B.matmul( + self.edge_to_triangle_incidence, self.edge_to_triangle_incidence, tr_b=True + ) + self.hodge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian + @property def incidence_matrices(self): """ Return the incidence matrix """ - if self.triangle_incidence_matrix is None: - return self.incidence_matrix - else: - return self.incidence_matrix, self.triangle_incidence_matrix + return self.node_to_edge_incidence, self.edge_to_triangle_incidence - @property - def edge_laplacian(self): - """ - Return the Edge Laplacian - """ - if self.triangle_incidence_matrix is None: - return self._edge_laplacian - else: - return self._edge_laplacian, self._down_edge_laplacian, self._up_edge_laplacian - def get_edge_index(self, edges): """ Get the indices of some provided edges in the edge list. @@ -164,31 +155,18 @@ def get_edge_index(self, edges): Returns: list: Indices of the edges. """ - assert isinstance(edges, list) # "The edges should be a list." + assert isinstance(edges, list) # "The edges should be a list." # each edge should be in the edge list assert all(edge in self.edges for edge in edges) return B.to_numpy([self.edges.index(edge) for edge in edges]) - - def triangles_all_clique(self) -> list: - """ - Get a list of triangles in the graph. - Returns: - list: List of triangles. - """ - cliques = nx.enumerate_all_cliques(self.G) - triangle_vertices = [x for x in cliques if len(x) == 3] - # sort the triangles - triangle_vertices = [sorted(tri) for tri in triangle_vertices] - return triangle_vertices - - def triangles_to_B2(self) -> np.ndarray: + def build_edge_to_triangle_incidence(self) -> np.ndarray: """ Create the B2 matrix (edge-triangle) from the triangles. - - The `triangle_incidence_matrix` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph. - The entry `triangle_incidence_matrix[e, t]` is + The `edge_to_triangle_incidence` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph. + + The entry `edge_to_triangle_incidence[e, t]` is - `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$, - `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and - `0` otherwise. @@ -200,7 +178,7 @@ def triangles_to_B2(self) -> np.ndarray: Returns: np.ndarray: B2 matrix. """ - + triangles = self.triangles B2 = np.zeros((len(self.edges), len(triangles))) for j, triangle in enumerate(triangles): @@ -232,101 +210,62 @@ def get_eigensystem(self, num): :param num: Number of eigenpairs to return. Performs the computation at the first call. Afterwards, fetches the result from cache. - + :return: A tuple of eigenvectors [n, num], eigenvalues [num, 1]. """ eps = 1e-6 if num not in self.cache: - evals, evecs = eigenpairs(self._edge_laplacian, num) + evals, evecs = eigenpairs(self.hodge_laplacian, num) # make a dictionary of the eigenvalues and eigenvectors where the keys are the indices of the eigenvalues, and add another value which indicates the type of the eigenbasis (harmonic, gradient, curl) self.hodge_eigenbasis = {} # add keys to the dictionary - if self.triangle_incidence_matrix is not None: - # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian - total_var = [] - total_div = [] - total_curl = [] - num_eigemodes = len(evals) - for i in range(num_eigemodes): - total_var.append( - B.matmul( - evecs[:, i].reshape(1, -1), - B.matmul(self._edge_laplacian, evecs[:, i]), - ) + # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian + total_var, total_div, total_curl = [], [], [] + num_eigemodes = len(evals) + for i in range(num_eigemodes): + total_var.append( + B.matmul( + evecs[:, i].reshape(1, -1), + B.matmul(self.hodge_laplacian, evecs[:, i]), ) - total_div.append( - B.matmul( - evecs[:, i].reshape(1, -1), - B.matmul(self._down_edge_laplacian, evecs[:, i]), - ) + ) + total_div.append( + B.matmul( + evecs[:, i].reshape(1, -1), + B.matmul(self._down_edge_laplacian, evecs[:, i]), ) - total_curl.append( - B.matmul( - evecs[:, i].reshape(1, -1), - B.matmul(self._up_edge_laplacian, evecs[:, i]), - ) + ) + total_curl.append( + B.matmul( + evecs[:, i].reshape(1, -1), + B.matmul(self._up_edge_laplacian, evecs[:, i]), ) - - for i in range(num_eigemodes): - if total_var[i] < eps: - # harm_evecs.append(i) - hodge_type = 'harmonic' - elif total_div[i] > eps: - # grad_evecs.append(i) - hodge_type = 'gradient' - elif total_curl[i] > eps: - # curl_evecs.append(i) - hodge_type = 'curl' - self.hodge_eigenbasis[i] = {'eval': evals[i], 'evec': evecs[:, i], 'type': hodge_type} - + ) + harmonic_inds, gradient_inds, curl_inds = [], [], [] + for i in range(num_eigemodes): + if total_var[i] < eps: + harmonic_inds.append(i) + elif total_div[i] > eps: + gradient_inds.append(i) + elif total_curl[i] > eps: + curl_inds.append(i) + self.hodge_eigenbasis = { + "evals": evals, + "evecs": evecs, + "harmonic_idx": harmonic_inds, + "gradient_idx": gradient_inds, + "curl_idx": curl_inds, + } + self.cache[num] = self.hodge_eigenbasis return self.cache[num] - def get_eigenfunctions(self, num: int) -> Eigenfunctions: - """ - Returns the :class:`~.EigenfunctionsFromEigenvectors` object with - `num` levels (i.e., in this case, `num` eigenpairs). - - :param num: - Number of levels. - """ - eigenfunctions = EigenfunctionsFromEigenvectors(self.get_eigenvectors(num)) - return eigenfunctions - - def get_eigenvectors(self, num: int) -> B.Numeric: - """ - :param num: - Number of eigenvectors to return. - - :return: - Array of eigenvectors, with shape [n, num]. - """ - return np.array([entry['evec'] for entry in self.get_eigensystem(num).values()]).T - - def get_eigenvalues(self, num: int) -> B.Numeric: - """ - :param num: - Number of eigenvalues to return. - - :return: - Array of eigenvalues, with shape [num, 1]. - """ - return np.array([entry['eval'] for entry in self.get_eigensystem(num).values()])[:,None] - - def get_eigenbasis_type(self, num: int): - """ - :param num: - Number of eigenvalues to return. - - :return: - Array of strings, with shape [num, 1]. - """ - return [entry['type'] for entry in self.get_eigensystem(num).values()] - # get particular type of eigenbasis - def get_eigenfunctions_by_type(self, num: int, hodge_type: str) -> Eigenfunctions: + def get_eigenfunctions( + self, num: int, hodge_type: Optional[str] = None + ) -> Eigenfunctions: """ Returns the :class:`~.EigenfunctionsFromEigenvectors` object with `num` levels (i.e., in this case, `num` eigenpairs) of a particular type. @@ -339,55 +278,63 @@ def get_eigenfunctions_by_type(self, num: int, hodge_type: str) -> Eigenfunction :return: EigenfunctionsFromEigenvectors object. """ - eigenfunctions = EigenfunctionsFromEigenvectors(self.get_eigenvectors_by_type(num, hodge_type)) + eigensystem = self.get_eigensystem(num) + idx = ( + eigensystem[f"{hodge_type}_idx"] + if hodge_type is not None + else list(range(num)) + ) + eigenfunctions = EigenfunctionsFromEigenvectors(eigensystem["evecs"][:, idx]) return eigenfunctions - - def get_eigenvectors_by_type(self, num: int, hodge_type: str) -> B.Numeric: - """ - :param num: - Number of eigenvectors to return. - :param hodge_type: - The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. - :return: - Array of eigenvectors, with shape [n, num]. - """ - assert hodge_type in ['harmonic', 'gradient', 'curl'] #"The hodge type should be either 'harmonic', 'gradient', or 'curl'." - eigenbasis = self.get_eigensystem(num) - return np.array([entry['evec'] for entry in eigenbasis.values() if entry['type'] == hodge_type]).T - - def get_eigenvalues_by_type(self, num: int, hodge_type: str) -> B.Numeric: + def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numeric: """ + Eigenvalues of the Laplacian corresponding to the first `num` levels + (i.e., in this case, `num` eigenpairs). If `type` is specified, returns + only the eigenvalues corresponding to the eigenfunctions of that type. + .. warning:: + If `type` is specified, the array can have fewer than `num` elements. :param num: - Number of eigenvalues to return. - :param hodge_type: - The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. - + Number of levels. :return: - Array of eigenvalues, with shape [num, 1]. - """ - assert hodge_type in ['harmonic', 'gradient', 'curl'] # "The hodge type should be either 'harmonic', 'gradient', or 'curl'." - eigenbasis = self.get_eigensystem(num) - return np.array([entry['eval'] for entry in eigenbasis.values() if entry['type'] == hodge_type])[:,None] - + (n, 1)-shaped array containing the eigenvalues. n <= num. + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + eigensystem = self.get_eigensystem(num) + idx = ( + eigensystem[f"{hodge_type}_idx"] + if hodge_type is not None + else list(range(num)) + ) + eigenvalues = eigensystem["evals"][idx] - def get_repeated_eigenvalues(self, num: int) -> B.Numeric: + return eigenvalues[:, None] + + def get_repeated_eigenvalues( + self, num: int, hodge_type: Optional[str] = None + ) -> B.Numeric: """ Same as :meth:`get_eigenvalues`. - :param num: Same as :meth:`get_eigenvalues`. """ - return self.get_eigenvalues(num) + return self.get_eigenvalues(num, hodge_type) def random(self, key, number): - num_edges = B.shape(self._edge_laplacian)[0] + num_edges = B.shape(self.hodge_laplacian)[0] key, random_edges_idx = B.randint( - key, dtype_integer(key), number, 1, lower=0, upper=num_edges, + key, + dtype_integer(key), + number, + 1, + lower=0, + upper=num_edges, ) - + random_edges = [self.edges[i] for i in random_edges_idx.flatten().tolist()] - + return key, random_edges, random_edges_idx @property diff --git a/notebooks/SimplicialComplex.ipynb b/notebooks/SimplicialComplex.ipynb index 22432895..90e3a8cb 100644 --- a/notebooks/SimplicialComplex.ipynb +++ b/notebooks/SimplicialComplex.ipynb @@ -80,6 +80,8 @@ } ], "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", "# Import a backend, we use numpy in this example.\n", "import numpy as np\n", "\n", @@ -282,28 +284,24 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----Simplicial 2-complex summary---\n", - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], + "outputs": [], "source": [ - "sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True)\n", - "sc.sc_simplices()" + "B1 = nx.incidence_matrix(G).toarray()\n", + "B2 = np.array([[ 1.],\n", + " [1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [], "source": [ - "Check the incidence matrices" + "sc = GraphEdge(B1,B2)" ] }, { @@ -314,12 +312,9 @@ { "data": { "text/plain": [ - "array([[ 1.],\n", - " [-1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])" + "([1, 2, 3, 4, 5],\n", + " [(1, 2), (1, 3), (1, 4), (2, 3), (3, 5), (4, 5)],\n", + " [(1, 2, 3)])" ] }, "execution_count": 10, @@ -328,7 +323,14 @@ } ], "source": [ - "sc.triangle_incidence_matrix" + "sc.nodes, sc.edges, sc.triangles" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the incidence matrices" ] }, { @@ -406,11 +408,36 @@ } ], "source": [ - "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('Hodge Laplacian:\\n', sc.hodge_laplacian)\n", "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('Down Hodge Laplacian:\\n', sc._down_edge_laplacian)\n", "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + "print('Up Hodge Laplacian:\\n', sc._up_edge_laplacian)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[6.21724894e-15],\n", + " [1.38196601e+00],\n", + " [2.38196601e+00],\n", + " [3.00000000e+00],\n", + " [3.61803399e+00],\n", + " [4.61803399e+00]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sc.get_eigenvalues(6)" ] }, { @@ -441,23 +468,6 @@ "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." ] }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "use_hodge_composition=True\n", - "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "check the eigenbasis and their types being either gradient, curl or harmonic" - ] - }, { "cell_type": "code", "execution_count": 14, @@ -467,44 +477,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "eval: 0.00\n", - "evec: [0.17 0.35 -0.52 0.17 0.52 -0.52]\n", - "type: harmonic\n", - "\n", - "eval: 1.38\n", - "evec: [0.37 -0.00 -0.60 -0.37 -0.60 -0.00]\n", - "type: gradient\n", - "\n", - "eval: 2.38\n", - "evec: [0.24 0.48 -0.15 0.24 0.15 0.78]\n", - "type: gradient\n", - "\n", - "eval: 3.00\n", - "evec: [0.58 -0.58 -0.00 0.58 0.00 0.00]\n", - "type: curl\n", - "\n", - "eval: 3.62\n", - "evec: [0.60 -0.00 0.37 -0.60 0.37 -0.00]\n", - "type: gradient\n", - "\n", - "eval: 4.62\n", - "evec: [0.28 0.56 0.45 0.28 -0.45 -0.35]\n", - "type: gradient\n", - "\n" + "Using Hodge compositional kernel!\n" ] } ], "source": [ - "for entry in sc.hodge_eigenbasis.values():\n", - " if 'eval' in entry:\n", - " print(f\"eval: {entry['eval']:.2f}\")\n", - " if 'evec' in entry:\n", - " formatted_evec = np.array2string(entry['evec'], formatter={'float_kind': lambda x: f\"{x:.2f}\"})\n", - " print(f\"evec: {formatted_evec}\")\n", - " if 'type' in entry:\n", - " print(f\"type: {entry['type']}\")\n", - " \n", - " print() " + "use_hodge_composition=True\n", + "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the eigenbasis and their types being either gradient, curl or harmonic" ] }, { @@ -529,7 +515,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "params: {'harmonic': {'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'nu': array([inf]), 'lengthscale': array([1.])}}\n" + "params: {'harmonic': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}}\n" ] } ], @@ -655,31 +641,60 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n" + "[(2, 3), (4, 5), (3, 5)]\n" ] } ], "source": [ "key = np.random.RandomState(1234)\n", "\n", - "key, xs = sc.random(key, 3)\n", + "key, randopm_sampled_edges, xs = sc.random(key, 3)\n", "\n", - "print(xs)" + "print(randopm_sampled_edges)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we evaluate the two kernel matrices." + "If users prefer input the edges directly, we would need to obtain the indices of the edges in the edge space of the simplicial complex. This can be done by calling `sc.get_edge_index(input_edges)`.\n", + "\n", + "Below we verify that the indices of the sampled edges are correct." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3]\n", + " [5]\n", + " [4]]\n", + "[3, 5, 4]\n" + ] + } + ], + "source": [ + "print(xs)\n", + "input_indices = sc.get_edge_index(randopm_sampled_edges)\n", + "print(input_indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, "outputs": [], "source": [ "if use_hodge_composition:\n", @@ -699,7 +714,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -743,7 +758,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -757,7 +772,7 @@ " [ 0.28746792, -0.25884074, 0.59206623]]))" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -783,7 +798,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -802,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -825,7 +840,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -849,7 +864,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -945,7 +960,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -1000,7 +1015,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -1028,7 +1043,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1102,7 +1117,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -1148,7 +1163,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "metadata": {}, "outputs": [ { diff --git a/notebooks/backends/JAX_SimplicialComplex.ipynb b/notebooks/backends/JAX_SimplicialComplex.ipynb index ad4db439..8390c3b4 100644 --- a/notebooks/backends/JAX_SimplicialComplex.ipynb +++ b/notebooks/backends/JAX_SimplicialComplex.ipynb @@ -81,6 +81,8 @@ } ], "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", "# Import a backend, we use jax in this example.\n", "import numpy as np\n", "import jax\n", @@ -287,21 +289,24 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----Simplicial 2-complex summary---\n", - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (4, 5)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], + "outputs": [], + "source": [ + "B1 = jnp.array(nx.incidence_matrix(G).toarray())\n", + "B2 = jnp.array([[ 1.],\n", + " [1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], "source": [ - "sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True)\n", - "sc.sc_simplices()" + "sc = GraphEdge(B1,B2)" ] }, { @@ -313,32 +318,29 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[ 1.],\n", - " [-1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])" + "([1, 2, 3, 4, 5],\n", + " [(1, 2), (1, 3), (1, 4), (2, 3), (3, 5), (4, 5)],\n", + " [(1, 2, 3)])" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "sc.triangle_incidence_matrix" + "sc.nodes, sc.edges, sc.triangles" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -375,7 +377,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -411,11 +413,11 @@ } ], "source": [ - "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('Hodge Laplacian:\\n', sc.hodge_laplacian)\n", "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('Down Hodge Laplacian:\\n', sc._down_edge_laplacian)\n", "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + "print('Up Hodge Laplacian:\\n', sc._up_edge_laplacian)" ] }, { @@ -446,23 +448,6 @@ "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "use_hodge_composition=True\n", - "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "check the eigenbasis and their types being either gradient, curl or harmonic" - ] - }, { "cell_type": "code", "execution_count": 13, @@ -472,44 +457,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "eval: 0.00\n", - "evec: [0.17 0.35 -0.52 0.17 0.52 -0.52]\n", - "type: harmonic\n", - "\n", - "eval: 1.38\n", - "evec: [0.37 -0.00 -0.60 -0.37 -0.60 -0.00]\n", - "type: gradient\n", - "\n", - "eval: 2.38\n", - "evec: [0.24 0.48 -0.15 0.24 0.15 0.78]\n", - "type: gradient\n", - "\n", - "eval: 3.00\n", - "evec: [0.58 -0.58 -0.00 0.58 0.00 0.00]\n", - "type: curl\n", - "\n", - "eval: 3.62\n", - "evec: [0.60 -0.00 0.37 -0.60 0.37 -0.00]\n", - "type: gradient\n", - "\n", - "eval: 4.62\n", - "evec: [0.28 0.56 0.45 0.28 -0.45 -0.35]\n", - "type: gradient\n", - "\n" + "Using Hodge compositional kernel!\n" ] } ], "source": [ - "for entry in sc.hodge_eigenbasis.values():\n", - " if 'eval' in entry:\n", - " print(f\"eval: {entry['eval']:.2f}\")\n", - " if 'evec' in entry:\n", - " formatted_evec = np.array2string(entry['evec'], formatter={'float_kind': lambda x: f\"{x:.2f}\"})\n", - " print(f\"evec: {formatted_evec}\")\n", - " if 'type' in entry:\n", - " print(f\"type: {entry['type']}\")\n", - " \n", - " print() " + "use_hodge_composition=True\n", + "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" ] }, { @@ -534,7 +488,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "params: {'harmonic': {'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'nu': array([inf]), 'lengthscale': array([1.])}}\n" + "params: {'harmonic': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}}\n" ] } ], @@ -653,7 +607,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[(1, 2), (1, 3), (1, 5)]\n" + "[(1, 2), (1, 3), (1, 4)]\n" ] } ], diff --git a/notebooks/backends/PyTorch_SimplicialComplex.ipynb b/notebooks/backends/PyTorch_SimplicialComplex.ipynb index 774a936d..2e80be7a 100644 --- a/notebooks/backends/PyTorch_SimplicialComplex.ipynb +++ b/notebooks/backends/PyTorch_SimplicialComplex.ipynb @@ -283,58 +283,58 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----Simplicial 2-complex summary---\n", - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (4, 5)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], + "outputs": [], "source": [ - "sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True)\n", - "sc.sc_simplices()" + "B1 = nx.incidence_matrix(G).toarray()\n", + "B2 = np.array([[ 1.],\n", + " [1.],\n", + " [ 0.],\n", + " [ 1.],\n", + " [ 0.],\n", + " [ 0.]])" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [], "source": [ - "Check the incidence matrices" + "sc = GraphEdge(B1,B2)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[ 1.],\n", - " [-1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])" + "([1, 2, 3, 4, 5],\n", + " [(1, 2), (1, 3), (1, 4), (2, 3), (3, 5), (4, 5)],\n", + " [(1, 2, 3)])" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "sc.triangle_incidence_matrix" + "sc.nodes, sc.edges, sc.triangles" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the incidence matrices" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -371,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -407,11 +407,11 @@ } ], "source": [ - "print('Hodge Laplacian:\\n', sc.edge_laplacian[0])\n", + "print('Hodge Laplacian:\\n', sc.hodge_laplacian)\n", "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc.edge_laplacian[1])\n", + "print('Down Hodge Laplacian:\\n', sc._down_edge_laplacian)\n", "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc.edge_laplacian[2])" + "print('Up Hodge Laplacian:\\n', sc._up_edge_laplacian)" ] }, { @@ -442,23 +442,6 @@ "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "use_hodge_composition=True\n", - "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "check the eigenbasis and their types being either gradient, curl or harmonic" - ] - }, { "cell_type": "code", "execution_count": 13, @@ -468,44 +451,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "eval: 0.00\n", - "evec: [0.17 0.35 -0.52 0.17 0.52 -0.52]\n", - "type: harmonic\n", - "\n", - "eval: 1.38\n", - "evec: [0.37 -0.00 -0.60 -0.37 -0.60 -0.00]\n", - "type: gradient\n", - "\n", - "eval: 2.38\n", - "evec: [0.24 0.48 -0.15 0.24 0.15 0.78]\n", - "type: gradient\n", - "\n", - "eval: 3.00\n", - "evec: [0.58 -0.58 -0.00 0.58 0.00 0.00]\n", - "type: curl\n", - "\n", - "eval: 3.62\n", - "evec: [0.60 -0.00 0.37 -0.60 0.37 -0.00]\n", - "type: gradient\n", - "\n", - "eval: 4.62\n", - "evec: [0.28 0.56 0.45 0.28 -0.45 -0.35]\n", - "type: gradient\n", - "\n" + "Using Hodge compositional kernel!\n" ] } ], "source": [ - "for entry in sc.hodge_eigenbasis.values():\n", - " if 'eval' in entry:\n", - " print(f\"eval: {entry['eval']:.2f}\")\n", - " if 'evec' in entry:\n", - " formatted_evec = np.array2string(entry['evec'], formatter={'float_kind': lambda x: f\"{x:.2f}\"})\n", - " print(f\"evec: {formatted_evec}\")\n", - " if 'type' in entry:\n", - " print(f\"type: {entry['type']}\")\n", - " \n", - " print() " + "use_hodge_composition=True\n", + "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" ] }, { @@ -530,7 +482,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "params: {'harmonic': {'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'nu': array([inf]), 'lengthscale': array([1.])}}\n" + "params: {'harmonic': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}}\n" ] } ], @@ -658,7 +610,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[(3, 4), (1, 3), (1, 2)]\n" + "[(3, 5), (1, 3), (1, 2)]\n" ] } ], @@ -818,7 +770,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -837,7 +789,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -860,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -884,7 +836,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -987,7 +939,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1042,7 +994,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -1070,7 +1022,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -1144,7 +1096,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -1191,7 +1143,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 30, "metadata": {}, "outputs": [ { diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edge.py index 6f82f0c5..1b1cc32c 100644 --- a/tests/spaces/test_graph_edge.py +++ b/tests/spaces/test_graph_edge.py @@ -1,17 +1,9 @@ import warnings -import jax -import lab as B -import numpy as np -import scipy.sparse as sp -import torch import networkx as nx +import numpy as np from geometric_kernels.jax import * # noqa -from geometric_kernels.kernels import ( - MaternKarhunenLoeveKernel, - MaternKarhunenLoeveKernel_HodgeCompositionEdge -) from geometric_kernels.spaces.graph_edge import GraphEdge from geometric_kernels.torch import * # noqa @@ -25,144 +17,26 @@ G.add_edge(3, 4) G.add_edge(4, 5) -triangles = [(1,2,3)] - - -def run_tests_with_lap(tol=1e-7, tol_m=1e-4): - ############################################## - # Inits - sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True) - m = sc.num_edges +triangles = [(1, 2, 3)] +B1 = nx.incidence_matrix(G).toarray() +B2 = np.array([[1.0], [1.0], [0.0], [1.0], [0.0], [0.0]]) +sc = GraphEdge(B1, B2) +m = sc.num_edges +eigs = np.array( + [ + [6.21724894e-15], + [1.38196601e00], + [2.38196601e00], + [3.00000000e00], + [3.61803399e00], + [4.61803399e00], + ] +) - ############################################## - # Laplacian computation - L = sc.edge_laplacian +def test_get_eigenvalues(tol=1e-7): ############################################## # Eigendecomposition checks - - evecs = sc.get_eigenvectors(m) evals = sc.get_eigenvalues(m) - - evals_np, evecs_np = np.linalg.eigh(L) - # check vals - np.testing.assert_allclose(evals[:, 0], evals_np, atol=tol, rtol=tol) - - # check vecs - np.testing.assert_allclose( - np.abs(evecs)[:, 2:], np.abs(evecs_np)[:, 2:], atol=tol, rtol=tol - ) - - try: - np.testing.assert_allclose( - np.abs(evecs)[:, :2], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol - ) - except AssertionError: - np.testing.assert_allclose( - np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol, rtol=tol - ) - - - ############################################## - # Kernel init checks - - K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) - params = K_cons.init_params() - - idx = B.cast(B.dtype(L), np.arange(m)[:, None]) - - nu = B.cast(B.dtype(L), np.array([1.0])) - lscale = B.cast(B.dtype(L), np.array([1.0])) - - K_normed_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) - normed_params = K_normed_cons.init_params() - - ############################################## - # Matern 1 check - - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - K1 = evecs_np @ np.diag(np.power(evals_np + 2, -1)) @ evecs_np.T - np.testing.assert_allclose(Kg, K1, atol=tol, rtol=tol) - - normed_params["nu"], normed_params["lengthscale"] = nu, lscale - K_normed_cons.K(normed_params, idx) - - ############################################## - # Matern 2 check - - nu = B.cast(B.dtype(L), np.array([2.0])) - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - K2 = evecs_np @ np.diag(np.power(evals_np + 4, -2)) @ evecs_np.T - np.testing.assert_allclose(Kg, K2, atol=tol, rtol=tol) - - ############################################## - # RBF check - - nu = B.cast(B.dtype(L), np.array([np.inf])) - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T - np.testing.assert_allclose(Kg, Ki, atol=tol, rtol=tol) - - ############################################## - # Fewer than meigencomps check - - m = 4 - evecs = sc.get_eigenvectors(m) - evals = sc.get_eigenvalues(m) - if isinstance(L, jax.numpy.ndarray): - evals_np, evecs_np = np.linalg.eigh(B.to_numpy(L)) - evals_np, evecs_np = evals_np[:m], evecs_np[:, :m] - else: - evals_np, evecs_np = sp.linalg.eigsh(B.to_numpy(L), m, sigma=1e-8) - - np.testing.assert_allclose(evals[:, 0], evals_np, atol=tol_m, rtol=tol_m) - - try: - np.testing.assert_allclose( - np.abs(evecs)[:, :2], np.abs(evecs_np)[:, :2], atol=tol_m, rtol=tol_m - ) - except AssertionError: - np.testing.assert_allclose( - np.abs(evecs)[:, [1, 0]], np.abs(evecs_np)[:, :2], atol=tol_m, rtol=tol_m - ) - - K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) - params = K_cons.init_params() - - nu = B.cast(B.dtype(L), np.array([np.inf])) - params["nu"], params["lengthscale"] = nu, lscale - Kg = K_cons.K(params, idx) - Ki = evecs_np @ np.diag(np.exp(-0.5 * evals_np)) @ evecs_np.T - np.testing.assert_allclose(Kg, Ki, atol=tol_m, rtol=tol_m) - - -def test_graphs_numpy(): - run_tests_with_lap() - -def test_graphs_torch(): - run_tests_with_lap() - - -def test_graphs_jax(): - run_tests_with_lap(1e-4, 1e-4) - - -def test_graphs_torch_cuda(): - if torch.cuda.is_available(): - sc = GraphEdge(G,triangle_list=triangles, sc_lifting=True) - m = sc.num_edges - - K_cons = MaternKarhunenLoeveKernel(sc, m, normalize=False) - params = K_cons.init_params() - - params["nu"] = torch.nn.Parameter(torch.tensor([1.0]).cuda()) - params["lengthscale"] = torch.nn.Parameter(torch.tensor([1.0]).cuda()) - - idx = torch.arange(m)[:, None].cuda() - K_cons.K(params, idx) - else: - pass + np.testing.assert_allclose(evals, eigs, atol=tol, rtol=tol) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index 02ccba7c..fdb190d2 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -49,7 +49,10 @@ def test_walsh_functions(all_xs_and_combs, backend): # Check that Walsh functions only take values in the set {-1, 1}. check_function_with_backend( - backend, np.ones((2**d, 2**d)), lambda X: B.abs(walsh_matrix(d, combs, X)), X + backend, + np.ones((2**d, 2**d)), + lambda X: B.abs(walsh_matrix(d, combs, X)), + X, ) From 251faf30eee20ba380fa37d269d7f63593c1821f Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Thu, 12 Dec 2024 17:26:05 +0100 Subject: [PATCH 09/30] Some refactoring. Summary of important changes below. - New abstract class HodgeDiscreteSpectrumSpace, a subclass of DiscreteSpectrumSpace. Its methods have an additional parameter `type`, which can be one of "harmonic", "curl", "gradient". This allows getting (repeated) eigenvalues and eigenfunctions only for the respective type of the Hodge decomposition. - MaternKarhunenLoeveKernel can now directly accept `eigenvalues_laplacian` and `eigenfunctions` as parameters. This is useful for the new MaternHodgeCompositionalKernel. - New MaternHodgeCompositionalKernel, a class is similar to MaternKarhunenLoeveKernel, but providing a more expressive family of kernels on the spaces where Hodge decomposition is available. - DeterministicFeatureMapCompact and RandomPhaseFeatureMapCompact don't construct and store a kernel anymore. For this, the method `_spectrum` of MaternKarhunenLoeveKernel, now called just `spectrum`, has become static. Also, the `normalize` parameter of feature maps is now True by default. --- .../feature_maps/deterministic.py | 145 ++++++++++------- .../feature_maps/random_phase.py | 25 ++- .../feature_maps/rejection_sampling.py | 12 +- .../kernels/hodge_compositional.py | 153 +++++++++--------- geometric_kernels/kernels/karhunen_loeve.py | 37 +++-- geometric_kernels/kernels/matern_kernel.py | 19 +-- geometric_kernels/spaces/base.py | 28 +++- 7 files changed, 225 insertions(+), 194 deletions(-) diff --git a/geometric_kernels/feature_maps/deterministic.py b/geometric_kernels/feature_maps/deterministic.py index fbfcb943..0f515d17 100644 --- a/geometric_kernels/feature_maps/deterministic.py +++ b/geometric_kernels/feature_maps/deterministic.py @@ -9,9 +9,12 @@ from beartype.typing import Dict, Optional, Tuple from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel -from geometric_kernels.spaces import DiscreteSpectrumSpace, HodgeDiscreteSpectrumSpace +from geometric_kernels.spaces import ( + DiscreteSpectrumSpace, + Eigenfunctions, + HodgeDiscreteSpectrumSpace, +) class DeterministicFeatureMapCompact(FeatureMap): @@ -23,32 +26,57 @@ class DeterministicFeatureMapCompact(FeatureMap): A :class:`~.spaces.DiscreteSpectrumSpace` space. :param num_levels: Number of levels in the kernel approximation. + :param repeated_eigenvalues_laplacian: + Allowing to pass the repeated eigenvalues of the Laplacian directly, + instead of computing them from the space. If provided, `eigenfunctions` + must also be provided. Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. + :param eigenfunctions: + Allowing to pass the eigenfunctions directly, instead of computing them + from the space. If provided, `repeated_eigenvalues_laplacian` must also + be provided. Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. """ - def __init__(self, space: DiscreteSpectrumSpace, num_levels: int): + def __init__( + self, + space: DiscreteSpectrumSpace, + num_levels: int, + repeated_eigenvalues_laplacian: Optional[B.Numeric] = None, + eigenfunctions: Optional[Eigenfunctions] = None, + ): self.space = space self.num_levels = num_levels - self.kernel = MaternKarhunenLoeveKernel(space, num_levels) - self.repeated_eigenvalues = space.get_repeated_eigenvalues( - self.kernel.num_levels - ) + + if repeated_eigenvalues_laplacian is None: + assert eigenfunctions is None + repeated_eigenvalues_laplacian = self.space.get_repeated_eigenvalues( + self.num_levels + ) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels) + else: + assert eigenfunctions is not None + assert repeated_eigenvalues_laplacian.shape == (num_levels, 1) + assert eigenfunctions.num_levels == num_levels + + self._repeated_eigenvalues = repeated_eigenvalues_laplacian + self._eigenfunctions = eigenfunctions def __call__( self, X: B.Numeric, params: Dict[str, B.Numeric], - normalize: Optional[bool] = None, + normalize: bool = True, **kwargs, ) -> Tuple[None, B.Numeric]: """ :param X: [N, ...] points in the space to evaluate the map on. + :param params: Parameters of the kernel (length scale and smoothness). + :param normalize: - Normalize to have unit average variance (if omitted - or None, follows the standard behavior of - :class:`~.kernels.MaternKarhunenLoeveKernel`). + Normalize to have unit average variance. If omitted, set to True. + :param ``**kwargs``: Unused. @@ -62,57 +90,75 @@ def __call__( interface: for some other subclasses of :class:`FeatureMap`, this first element may be an updated random key. """ - spectrum = self.kernel._spectrum( - self.repeated_eigenvalues, + spectrum = MaternKarhunenLoeveKernel.spectrum( + self._repeated_eigenvalues, nu=params["nu"], lengthscale=params["lengthscale"], + dimension=self.space.dimension, ) - normalize = normalize or (normalize is None and self.kernel.normalize) if normalize: normalizer = B.sum(spectrum) spectrum = spectrum / normalizer + weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] - eigenfunctions = self.kernel.eigenfunctions(X, **params) # [N, M] + eigenfunctions = self._eigenfunctions(X, **kwargs) # [N, M] features = B.cast(B.dtype(params["lengthscale"]), eigenfunctions) * B.cast( B.dtype(params["lengthscale"]), weights ) # [N, M] + return None, features class HodgeDeterministicFeatureMapCompact(FeatureMap): r""" - Deterministic feature map for :class:`~.spaces.GraphEdge`\ s + Deterministic feature map for :class:`~.spaces.HodgeDiscreteSpectrumSpace`\ s for which the actual eigenpairs are explicitly available. - Note: We obtain the embedding by Hodge subspace. + Corresponds to :class:`~.kernels.MaternHodgeCompositionalKernel` and takes + parameters in the same format. """ def __init__(self, space: HodgeDiscreteSpectrumSpace, num_levels: int): self.space = space self.num_levels = num_levels - self.kernel = MaternHodgeCompositionalKernel(space, num_levels) + for hodge_type in ["harmonic", "curl", "gradient"]: + repeated_eigenvalues = self.space.get_repeated_eigenvalues( + self.num_levels, hodge_type + ) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels, hodge_type) + num_levels_per_type = self.space.get_eigenvalues( + self.num_levels, hodge_type + ).shape[0] + setattr( + self, + f"feature_map_{hodge_type}", + DeterministicFeatureMapCompact( + space, + num_levels_per_type, + repeated_eigenvalues_laplacian=repeated_eigenvalues, + eigenfunctions=eigenfunctions, + ), + ) def __call__( self, X: B.Numeric, - params: Dict[str, B.Numeric], - normalize: Optional[bool] = None, - hodge_type: Optional[str] = None, + params: Dict[str, Dict[str, B.Numeric]], + normalize: bool = None, **kwargs, ) -> Tuple[None, B.Numeric]: """ :param X: [N, ...] points in the space to evaluate the map on. + :param params: Parameters of the kernel (length scale and smoothness). + :param normalize: - Normalize to have unit average variance (if omitted - or None, follows the standard behavior of - :class:`~.kernels.MaternKarhunenLoeveKernel`). - :param hodge_type: - The type of Hodge embedding to compute. + Normalize to have unit average variance. If omitted, set to True. + :param ``**kwargs``: Unused. @@ -126,38 +172,21 @@ def __call__( interface: for some other subclasses of :class:`FeatureMap`, this first element may be an updated random key. """ - self.repeated_eigenvalues = self.space.get_eigenvalues( - self.kernel.num_levels, hodge_type - ) - hodge_kernel = { - "harmonic": self.kernel.kernel_harmonic, - "gradient": self.kernel.kernel_gradient, - "curl": self.kernel.kernel_curl, - }.get(hodge_type) - - spectrum = B.cast( - B.dtype( - hodge_kernel._spectrum( - self.repeated_eigenvalues, - nu=params["nu"], - lengthscale=params["lengthscale"], - ) - ), - params["logit"], - ) * hodge_kernel._spectrum( - self.repeated_eigenvalues, - nu=params["nu"], - lengthscale=params["lengthscale"], + # Copy the parameters to avoid modifying the original dict. + params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} + coeffs = B.softmax( + B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, + ) ) - normalize = normalize or (normalize is None and self.kernel.normalize) - if normalize: - normalizer = B.sum(spectrum) - spectrum = spectrum / normalizer - weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] - eigenfunctions = hodge_kernel.eigenfunctions(X, **params) # [N, M] - features = B.cast(B.dtype(params["lengthscale"]), eigenfunctions) * B.cast( - B.dtype(params["lengthscale"]), weights - ) # [N, M] - return None, features + return B.concat( + coeffs[0] + * self.feature_map_harmonic(X, params["harmonic"], normalize, **kwargs), + coeffs[1] + * self.feature_map_gradient(X, params["gradient"], normalize, **kwargs), + coeffs[2] * self.feature_map_curl(X, params["curl"], normalize, **kwargs), + axis=-1, + ) diff --git a/geometric_kernels/feature_maps/random_phase.py b/geometric_kernels/feature_maps/random_phase.py index 79a55111..d6a98704 100644 --- a/geometric_kernels/feature_maps/random_phase.py +++ b/geometric_kernels/feature_maps/random_phase.py @@ -13,7 +13,7 @@ """ import lab as B -from beartype.typing import Dict, Optional, Tuple +from beartype.typing import Dict, Tuple from geometric_kernels.feature_maps.base import FeatureMap from geometric_kernels.feature_maps.probability_densities import base_density_sample @@ -46,7 +46,7 @@ def __init__( self.space = space self.num_levels = num_levels self.num_random_phases = num_random_phases - self.kernel = MaternKarhunenLoeveKernel(space, num_levels) + self.eigenfunctions = space.get_eigenfunctions(num_levels) def __call__( self, @@ -54,7 +54,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = None, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -80,9 +80,8 @@ def __call__( does this for you. :param normalize: - Normalize to have unit average variance (if omitted - or None, follows the standard behavior of - :class:`kernels.MaternKarhunenLoeveKernel`). + Normalize to have unit average variance. If omitted, set to True. + :param ``**kwargs``: Unused. @@ -93,12 +92,13 @@ def __call__( state (generator) for any other backends. """ key, random_phases = self.space.random(key, self.num_random_phases) # [O, D] - eigenvalues = self.kernel.eigenvalues_laplacian + eigenvalues = self.space.get_eigenvalues(self.num_levels) - spectrum = self.kernel._spectrum( + spectrum = MaternKarhunenLoeveKernel.spectrum( eigenvalues, nu=params["nu"], lengthscale=params["lengthscale"], + dimension=self.space.dimension, ) if is_complex(X): @@ -110,7 +110,7 @@ def __call__( random_phases_b = B.cast(dtype, from_numpy(X, random_phases)) - phi_product = self.kernel.eigenfunctions.phi_product( + phi_product = self.eigenfunctions.phi_product( X, random_phases_b, **params ) # [N, O, L] @@ -121,7 +121,6 @@ def __call__( if is_complex(features): features = B.concat(B.real(features), B.imag(features), axis=1) - normalize = normalize or (normalize is None and self.kernel.normalize) if normalize: normalizer = B.sqrt(B.sum(features**2, axis=-1, squeeze=False)) features = features / normalizer @@ -164,7 +163,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = True, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -198,10 +197,6 @@ def __call__( state (generator) for any other backends. """ - # default behavior - if normalize is None: - normalize = True - key, random_phases = self.space.random_phases( key, self.num_random_phases ) # [O, ] diff --git a/geometric_kernels/feature_maps/rejection_sampling.py b/geometric_kernels/feature_maps/rejection_sampling.py index 3d96b91b..b445e055 100644 --- a/geometric_kernels/feature_maps/rejection_sampling.py +++ b/geometric_kernels/feature_maps/rejection_sampling.py @@ -6,7 +6,7 @@ """ import lab as B -from beartype.typing import Dict, Optional, Tuple +from beartype.typing import Dict, Tuple from geometric_kernels.feature_maps.base import FeatureMap from geometric_kernels.feature_maps.probability_densities import ( @@ -50,7 +50,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = True, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -83,9 +83,6 @@ def __call__( `key` is the updated random key for `jax`, or the similar random state (generator) for any other backends. """ - # Default behavior - if normalize is None: - normalize = True key, random_phases = self.space.random_phases( key, self.num_random_phases @@ -151,7 +148,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = True, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -184,9 +181,6 @@ def __call__( `key` is the updated random key for `jax`, or the similar random state (generator) for any other backends. """ - # Default behavior for normalization - if normalize is None: - normalize = True key, random_phases = self.space.random_phases( key, self.num_random_phases diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py index bb35338e..76760db6 100644 --- a/geometric_kernels/kernels/hodge_compositional.py +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -14,11 +14,40 @@ class MaternHodgeCompositionalKernel(BaseGeometricKernel): r""" - TODO + This class is similar to :class:`MaternKarhunenLoeveKernel`, but provides + a more expressive family of kernels on the spaces where Hodge decomposition + is available. + + The resulting kernel is a sum of three kernels, + + .. math:: k(x, x') = a k_{\text{harmonic}}(x, x') + b k_{\text{gradient}}(x, x') + c k_{\text{curl}}(x, x'), + + where $a, b, c$ are weights $a, b, c \geq 0$ and $a + b + c = 1$, and + $k_{\text{harmonic}}$, $k_{\text{gradient}}$, $k_{\text{curl}}$ are the + instances of :class:`MaternKarhunenLoeveKernel` that only use the eigenpairs + of the Laplacian corresponding to a single part of the Hodge decomposition. + + The parameters of this kernel are represented by a dict with three keys: + `"harmonic"`, `"gradient"`, `"curl"`, each corresponding to a dict with + keys `"logit"`, `"nu"`, `"lengthscale"`, where `"nu"` and `"lengthscale"` + are the parameters of the respective :class:`MaternKarhunenLoeveKernel`, + while the `"logit"` parameters determine the weights $a, b, c$ in the + formula above: $a, b, c$ are the softmax of the three `"logit"` parameters. + + Same as for :class:`MaternKarhunenLoeveKernel`, these kernels can sometimes + be computed more efficiently using addition theorems. + + .. note:: + A brief introduction into the theory behind + :class:`MaternHodgeCompositionalKernel` can be found in + :doc:`this ` documentation page. + :param space: - The space to define the kernel upon. + The space to define the kernel upon, a subclass of :class:`HodgeDiscreteSpectrumSpace`. + :param num_levels: Number of levels to include in the summation. + :param normalize: Whether to normalize kernel to have unit average variance. """ @@ -56,7 +85,7 @@ def space(self) -> HodgeDiscreteSpectrumSpace: self._space: HodgeDiscreteSpectrumSpace return self._space - def init_params(self) -> Dict[str, B.NPNumeric]: + def init_params(self) -> Dict[str, Dict[str, B.NPNumeric]]: """ Initialize the three sets of parameters for the three kernels. """ @@ -80,88 +109,60 @@ def init_params(self) -> Dict[str, B.NPNumeric]: return params - def eigenvalues( - self, params: Dict[str, B.Numeric], normalize: Optional[bool] = None + def K( + self, + params: Dict[str, Dict[str, B.NPNumeric]], + X: B.Numeric, + X2: Optional[B.Numeric] = None, + **kwargs, ) -> B.Numeric: - """ - Eigenvalues of the kernel. - - :param params: - Parameters of the kernel. Must contain keys `"lengthscale"` and - `"nu"`. The shapes of `params["lengthscale"]` and `params["nu"]` - are `(1,)`. - :param normalize: - Whether to normalize kernel to have unit average variance. - If None, uses `self.normalize` to decide. - Defaults to None. - - :return: - An [L, 1]-shaped array. - """ - assert "harmonic" in params - assert "gradient" in params - assert "curl" in params - assert params["harmonic"]["lengthscale"].shape == (1,) - assert params["gradient"]["lengthscale"].shape == (1,) - assert params["curl"]["lengthscale"].shape == (1,) - assert params["harmonic"]["nu"].shape == (1,) - assert params["gradient"]["nu"].shape == (1,) - assert params["curl"]["nu"].shape == (1,) - - spectral_values_harmonic = self.kernel_harmonic.eigenvalues( - params=params["harmonic"], normalize=normalize - ) - spectral_values_gradient = self.kernel_gradient.eigenvalues( - params=params["gradient"], normalize=normalize + assert all( + key in params for key in ["harmonic", "gradient", "curl"] + ), "MaternHodgeCompositionalKernel's parameters must contain keys 'harmonic', 'gradient', 'curl'." + assert all( + B.shape(params[key]["logit"]) == (1,) + for key in ["harmonic", "gradient", "curl"] + ), "The 'logit' parameters of MaternHodgeCompositionalKernel must have shape (1,)." + + # Copy the parameters to avoid modifying the original dict. + params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} + coeffs = B.softmax( + B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, + ) ) - spectral_values_curl = self.kernel_curl.eigenvalues( - params=params["curl"], normalize=normalize + + return ( + coeffs[0] * self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs) + + coeffs[1] * self.kernel_gradient.K(params["gradient"], X, X2, **kwargs) + + coeffs[2] * self.kernel_curl.K(params["curl"], X, X2, **kwargs) ) - spectral_values = { - "harmonic": spectral_values_harmonic, - "gradient": spectral_values_gradient, - "curl": spectral_values_curl, - } - return spectral_values - def K( - self, params, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs # type: ignore + def K_diag( + self, params: Dict[str, Dict[str, B.NPNumeric]], X: B.Numeric, **kwargs ) -> B.Numeric: - return ( - B.cast( - B.dtype(self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs)), - params["harmonic"]["logit"], - ) - * self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs) - + B.cast( - B.dtype(self.kernel_harmonic.K(params["gradient"], X, X2, **kwargs)), - params["gradient"]["logit"], - ) - * self.kernel_gradient.K(params["gradient"], X, X2, **kwargs) - + B.cast( - B.dtype(self.kernel_harmonic.K(params["curl"], X, X2, **kwargs)), - params["curl"]["logit"], + assert all( + key in params for key in ["harmonic", "gradient", "curl"] + ), "MaternHodgeCompositionalKernel's parameters must contain keys 'harmonic', 'gradient', 'curl'." + assert all( + B.shape(params[key]["logit"]) == (1,) + for key in ["harmonic", "gradient", "curl"] + ), "The 'logit' parameters of MaternHodgeCompositionalKernel must have shape (1,)." + + # Copy the parameters to avoid modifying the original dict. + params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} + coeffs = B.softmax( + B.stack( + [params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, ) - * self.kernel_curl.K(params["curl"], X, X2, **kwargs) ) - def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: return ( - B.cast( - B.dtype(self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs)), - params["harmonic"]["logit"], - ) - * self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs) - + B.cast( - B.dtype(self.kernel_harmonic.K_diag(params["gradient"], X, **kwargs)), - params["gradient"]["logit"], - ) - * self.kernel_gradient.K_diag(params["gradient"], X, **kwargs) - + B.cast( - B.dtype(self.kernel_harmonic.K_diag(params["curl"], X, **kwargs)), - params["curl"]["logit"], - ) - * self.kernel_curl.K_diag(params["curl"], X, **kwargs) + coeffs[0] * self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs) + + coeffs[1] * self.kernel_gradient.K_diag(params["gradient"], X, **kwargs) + + coeffs[2] * self.kernel_curl.K_diag(params["curl"], X, **kwargs) ) diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index ddc4a203..75a6a10a 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -51,6 +51,14 @@ class MaternKarhunenLoeveKernel(BaseGeometricKernel): Number of levels to include in the summation. :param normalize: Whether to normalize kernel to have unit average variance. + :param eigenvalues_laplacian: + Allowing to pass the eigenvalues of the Laplacian directly, instead of + computing them from the space. If provided, `eigenfunctions` must also + be provided. Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. + :param eigenfunctions: + Allowing to pass the eigenfunctions directly, instead of computing them + from the space. If provided, `eigenvalues_laplacian` must also be provided. + Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. """ def __init__( @@ -63,18 +71,14 @@ def __init__( ): super().__init__(space) self.num_levels = num_levels # in code referred to as `L`. + if eigenvalues_laplacian is None: assert eigenfunctions is None eigenvalues_laplacian = self.space.get_eigenvalues(self.num_levels) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels) else: assert eigenfunctions is not None assert eigenvalues_laplacian.shape == (num_levels, 1) - - if eigenfunctions is None: - assert eigenvalues_laplacian is None - eigenfunctions = self.space.get_eigenfunctions(self.num_levels) - else: - assert eigenvalues_laplacian is not None assert eigenfunctions.num_levels == num_levels self._eigenvalues_laplacian = eigenvalues_laplacian @@ -109,12 +113,14 @@ def init_params(self) -> Dict[str, B.NPNumeric]: return params - def _spectrum( - self, s: B.Numeric, nu: B.Numeric, lengthscale: B.Numeric + @staticmethod + def spectrum( + s: B.Numeric, nu: B.Numeric, lengthscale: B.Numeric, dimension: int ) -> B.Numeric: """ - The spectrum of the Matérn kernel with hyperparameters `nu` and - `lengthscale` on the space with eigenvalues `s`. + Static method computing the spectrum of the Matérn kernel with + hyperparameters `nu` and `lengthscale` on the space with eigenvalues `s` + and dimension `dimension`. :param s: The eigenvalues of the space. @@ -122,6 +128,8 @@ def _spectrum( The smoothness parameter of the kernel. :param lengthscale: The length scale parameter of the kernel. + :param dimension: + The dimension of the space. :return: The spectrum of the Matérn kernel. @@ -138,7 +146,7 @@ def _spectrum( ) # for nu < np.inf - power = -safe_nu - self.space.dimension / 2.0 + power = -safe_nu - dimension / 2.0 base = 2.0 * safe_nu / lengthscale**2 + B.cast(B.dtype(safe_nu), s) spectral_values_nu_finite = base**power @@ -184,10 +192,11 @@ def eigenvalues( assert "nu" in params assert params["nu"].shape == (1,) - spectral_values = self._spectrum( + spectral_values = self.spectrum( self.eigenvalues_laplacian, nu=params["nu"], lengthscale=params["lengthscale"], + dimension=self.space.dimension, ) normalize = normalize or (normalize is None and self.normalize) if normalize: @@ -206,7 +215,7 @@ def eigenvalues( return spectral_values def K( - self, params, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs # type: ignore + self, params: Dict[str, B.Numeric], X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs # type: ignore ) -> B.Numeric: assert "lengthscale" in params assert params["lengthscale"].shape == (1,) @@ -221,7 +230,7 @@ def K( else: return K - def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: + def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: assert "lengthscale" in params assert params["lengthscale"].shape == (1,) assert "nu" in params diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 23690581..817e94e4 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -26,6 +26,7 @@ DiscreteSpectrumSpace, Graph, GraphEdge, + HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, Hypersphere, @@ -89,8 +90,6 @@ def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): @overload def feature_map_from_kernel(kernel: MaternHodgeCompositionalKernel): - "For Hodge-compositional edge kernels ONLY" - assert isinstance(kernel.space, GraphEdge) return HodgeDeterministicFeatureMapCompact(kernel.space, kernel.num_levels) @@ -278,7 +277,6 @@ def __new__( num: int = None, normalize: bool = True, return_feature_map: bool = False, - use_hodge_composition: bool = None, **kwargs, ): r""" @@ -326,11 +324,6 @@ def __new__( Default is False. - :param use_hodge_composition: - If `True`, use the Hodge compositional kernel on the - edges of a graph or a simplicial complex. This is only relevant for the :class:`~.spaces.GraphEdge` - space. - :param ``**kwargs``: Any additional keyword arguments to be passed to the kernel (like `key`). @@ -344,14 +337,8 @@ def __new__( kernel: BaseGeometricKernel if isinstance(space, DiscreteSpectrumSpace): num = num or default_num(space) - if isinstance(space, GraphEdge): - if use_hodge_composition: - kernel = MaternHodgeCompositionalKernel( - space, num, normalize=normalize - ) - print("Using Hodge compositional kernel!") - else: - kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) + if isinstance(space, HodgeDiscreteSpectrumSpace): + kernel = MaternHodgeCompositionalKernel(space, num, normalize=normalize) else: kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: diff --git a/geometric_kernels/spaces/base.py b/geometric_kernels/spaces/base.py index 96f48e27..bf050bf9 100644 --- a/geometric_kernels/spaces/base.py +++ b/geometric_kernels/spaces/base.py @@ -147,11 +147,15 @@ def random(self, key: B.RandomState, number: int) -> B.Numeric: class HodgeDiscreteSpectrumSpace(DiscreteSpectrumSpace): r""" - A Space with discrete spectrum (of the Laplacian operator) and Hodge - decomposition. Separates eigenpairs according to the Hodge decomposition, - into the harmonic type, the curl type and the gradient type. - This includes, e.g., the edges of a simplicial 2-complex (graph edges) - or tangent bundles of Riemannian manifolds. + A Space with discrete spectrum (of the Laplacian) and Hodge decomposition. + + Separates eigenpairs according to the Hodge decomposition, into the curl + type (divergence-free), the gradient type (curl-free), and the harmonic + type (both divergence- and curl-free). + + Examples of such spaces are the edge space of a graph, or tangent bundles + of compact Riemannian manifolds. + .. note:: TODO (docs theory page). .. note:: @@ -165,15 +169,19 @@ def get_eigenfunctions( """ Returns the :class:`~.Eigenfunctions` object with `num` levels. If `type` is specified, returns only the eigenfunctions of that type. + .. warning:: If `type` is specified, the returned :class:`~.Eigenfunctions` - object does not have to have `num` levels. It can have less but can + object does not have to have `num` levels. It can have fewer but can never have more. + :param num: Number of levels. + :param type: Type of the eigenfunctions to return. Can be one of "harmonic", "curl" or "gradient". + .. note:: The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel`. @@ -186,12 +194,16 @@ def get_eigenvalues(self, num: int, type: str) -> B.Numeric: Eigenvalues of the Laplacian corresponding to the first `num` levels. If `type` is specified, returns only the eigenvalues corresponding to the eigenfunctions of that type. + .. warning:: If `type` is specified, the array can have fewer than `num` elements. + :param num: Number of levels. + :return: (n, 1)-shaped array containing the eigenvalues. n <= num. + .. note:: The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel`. @@ -205,15 +217,19 @@ def get_repeated_eigenvalues(self, num: int, type: str) -> B.Numeric: repeated according to their multiplicity within levels. If `type` is specified, returns only the eigenvalues corresponding to the eigenfunctions of that type. + :param num: Number of levels. + :param type: Type of the eigenvalues to return. Can be one of "harmonic", "curl" or "gradient". + :return: (J, 1)-shaped array containing the repeated eigenvalues, J is the resulting number of the repeated eigenvalues (of the specified type, if `type` is given). + .. note:: The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel`. From 89da1ad553b13d4a5a10721909cb7b4e8d5fccc7 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sat, 14 Dec 2024 15:07:12 +0100 Subject: [PATCH 10/30] Major revision of graph_edge.py --- geometric_kernels/spaces/graph_edge.py | 677 ++++++++++++++++++------- 1 file changed, 486 insertions(+), 191 deletions(-) diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index 41da1481..a26691a9 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -3,11 +3,11 @@ """ import lab as B -import networkx as nx import numpy as np -from beartype.typing import Dict, Optional, Tuple +from beartype.typing import Dict, List, Optional, Tuple, Union +from scipy.sparse import csr_array, sparray, spmatrix -from geometric_kernels.lab_extras import dtype_integer, eigenpairs +from geometric_kernels.lab_extras import dtype_integer, eigenpairs, int_like from geometric_kernels.spaces.base import HodgeDiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import ( Eigenfunctions, @@ -17,190 +17,425 @@ class GraphEdge(HodgeDiscreteSpectrumSpace): """ - The GeometricKernels space representing the edge set of any user-provided undirected graph. - - The elements of this space are represented by edge indices, integer values - from 0 to m-1, where m is the number of edges in the user-provided graph. - - Each individual eigenfunction constitutes a *level*. + The GeometricKernels space representing the node set of any user-provided + weighted undirected, but **oriented** graph without loops. + Actually, this space is a simplicial 2-complex, as explained below. + + The elements of this space are indices of positively oriented edges of the graph. + Edge indices are integers from 1 to the number of edges in the graph (inclusive). + The reason for indexing the edges from 1 is to allow for signed values. + + The fact that the graph is oriented means that despite the edge (j, i) is + always present in the graph as long as the edge (i, j) is present, any + function f on the set of edges must satisfy f(i, j) = -f(j, i). Mathematically, + this space is actually a simplicial 2-complex, and the functions satisfying + the above condition are called 1-cochains. + + The easiest way to construct an instance of this space is to use the + :meth:`from_adjacency` method, which constructs the space from the adjacency + matrix of the graph. By default this would use all possible triangles in the + graph, but the user can also provide a list of triangles explicitly. These + triangles define the curl operator on the graph and are thus instrumental in + defining the Hodge decomposition. If you don't know what triangles to provide, + you can leave this parameter empty, and the space will compute the maximal + set of triangles for you, which is arguably a good solution in most cases. + When constructing an instance this way, the orientation of the edges and triangles + is chosen automatically in such a way that (i, j) is always oriented from i to j + if i < j and the triangles are of form (e1, e2, e3) where e1 = (i, j), + e2 = (j, k), and e3 = -(i, k). + + When constructing an instance of this space directly, the user chooses the + orientation by providing an `oriented_edges` array, mapping edge indices + to pairs of node indices. And an `oriented_triangles` array, mapping triangle + indices to triples of signed edge indices. These arrays must be compatible in + the sense that the edges in the triangles must be connected. + + For this space, each individual eigenfunction constitutes a *level*. If + possible, we recommend using num=nun_edges levels. Since the current + implementation does not support sparse eigensolvers anyway, this should + not create too much time/memory overhead during the precomputations, and will + also ensure that all types of eigenfunctions are present in the eigensystem. .. note:: A tutorial on how to use this space is available in the - :doc:`EdgeSpaceGraph.ipynb ` notebook. - - :param G: - A networkx graph object. - - :param triangle_list: - A list of triangles in the graph. If not provided, all triangles in the graph are considered as 2-simplices. - - :param sc_lifting: - If True, we lift the graph to a simplicial 2-complex using either the provided triangle list or all the triangles in the graph. This acts also a flag to compute the triangle incidence matrix. Defaults to False. + :doc:`GraphEdge.ipynb ` notebook. + + .. warning:: + Make sure that `oriented_edges` and `oriented_triangles` are of the + backend (NumPy / JAX / TensorFlow, PyTorch) that you wish to use for + internal computations. + + :param num_nodes: + The number of nodes in the graph. + + :param oriented_edges: + A 2D array of shape [n_edges, 2], where n_edges is the number of edges + in the graph. Each row of the array represents an oriented edge, i.e. + a pair of node indices. If `oriented_edges[e]` is `[i, j]`, then edge `e` + is oriented from node `i` to node `j`. + + :param oriented_triangles: + A 2D array of shape [n_triangles, 3], where n_triangles is the number of + triangles in the graph. Each row of the array represents an oriented + triangle, i.e. a triple of signed edge indices. If `oriented_triangles[t]` + is `[i, j, k]`, then `t` consists of the edges `|i|`, `|j|`, and `|k|`, + where the sign of the edge index indicates the orientation of the edge. + + Optional. If not provided or set to `None`, we assume that the set of + triangles is empty. + + :param checks_mode: + A keyword argument that determines the level of checks performed on the + oriented_edges and oriented_triangles arrays. The default value is "simple" + which performs only basic checks. The other possible value is "comprehensive" + and "skip" which perform more extensive checks and no checks, respectively. + The "comprehensive" mode is useful for debugging, but can be slow for large + graphs. + + :param index: + Optional. A sparse matrix of shape [num_nodes, num_nodes] such that + `index[i, j]` is the index of the edge `(i, j)` in the `oriented_edges`, + if (i, j) is positively oriented, and minus index of the edge `(i, j)` + otherwise. If not provided, will be constructed automatically. + Should be compatible with the `oriented_edges` array. .. admonition:: Citation - If you use this GeometricKernels space in your research, please consider citing :cite:t:`yang2024`. """ def __init__( self, - node_to_edge_incidence: B.Int, - edge_to_triangle_incidence: Optional[B.Int] = None, + num_nodes: int, + oriented_edges: B.Int, + oriented_triangles: Optional[B.Int], + *, + checks_mode: str = "simple", + index: Optional[csr_array] = None, ): + if checks_mode not in ["simple", "comprehensive", "skip"]: + raise ValueError( + "The `checks_mode` parameter must be 'simple', 'comprehensive', or 'skip'." + ) + else: + do_checks = checks_mode != "skip" + comprehensive_checks = checks_mode == "comprehensive" + self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - self.num_nodes, self.num_edges = node_to_edge_incidence.shape - self._checks(node_to_edge_incidence, edge_to_triangle_incidence) - self._make_oriented(node_to_edge_incidence, edge_to_triangle_incidence) - self.num_triangles = self.edge_to_triangle_incidence.shape[1] + self.num_nodes = num_nodes + + if do_checks: + self._checks_oriented_edges(oriented_edges, num_nodes, comprehensive_checks) + self.num_edges = oriented_edges.shape[0] + self.oriented_edges = oriented_edges + + if oriented_triangles is not None: + if do_checks: + self._checks_oriented_triangles( + oriented_triangles, self.num_edges, comprehensive_checks + ) + if comprehensive_checks: + self._checks_compatible(oriented_edges, oriented_triangles, num_nodes) + self.num_triangles = oriented_triangles.shape[0] + else: + self.num_triangles = 0 + self.oriented_triangles = oriented_triangles + + if index is not None: + self._check_index(index) + self.index = index + else: + self.index = compute_index(oriented_edges) + self._set_laplacian() - @staticmethod - def _checks(node_to_edge_incidence, edge_to_triangle_incidence=None): + def _checks_oriented_edges( + self, oriented_edges: B.Numeric, num_nodes: int, comprehensive: bool = False + ): """ - Checks if `node_to_edge_incidence` and `edge_to_triangle_incidence` are of - appropriate structure. + Checks if `oriented_edges` is of appropriate structure. + + :param oriented_edges: + The oriented edges array. + + :param comprehensive: + If True, perform more extensive checks. """ + assert ( - B.rank(node_to_edge_incidence) == 2 - ), "Incidence matrix must be a 2-dim tensor." + B.rank(oriented_edges) == 2 + ), "The oriented_edges array must be 2-dimensional." + + assert B.shape(oriented_edges)[1] == 2, "oriented_edges must have shape (*, 2)." + + assert B.dtype(oriented_edges) == int_like( + oriented_edges + ), "The oriented_edges must be an array of integers." assert B.all( - B.sum(node_to_edge_incidence != 0, axis=0) == 2 - ), "Each column of the incidence matrix must contain 2 exactly once." - if edge_to_triangle_incidence is not None: - assert ( - B.rank(edge_to_triangle_incidence) == 2 - ), "Triangle incidence matrix matrix must be a 2-dim tensor." - num_edges = B.shape(node_to_edge_incidence)[1] - assert B.shape(edge_to_triangle_incidence)[0] == num_edges, ( - "The first dimension of the triangle incidence matrix must" - " be equal to the second dimension of the incidence matrix." - ) - assert B.all(B.sum(edge_to_triangle_incidence != 0, axis=0) == 3), ( - "Each column of the edge triangle incidence matrix must" - " have exactly 3 non-zero entries." - ) + oriented_edges >= 0 + ), "The oriented_edges array must contain only non-negative values." + assert B.all( + oriented_edges < self.num_nodes + ), "The values in the oriented_edges array must be < self.num_nodes." + assert B.all( + oriented_edges[:, 0] - oriented_edges[:, 1] != 0 + ), "Loops are not allowed." - @property - def dimension(self) -> int: + if comprehensive: + num_edges = oriented_edges.shape[0] + + for i in range(num_edges): + for j in range(i + 1, num_edges): + assert B.any( + oriented_edges[i, :] != oriented_edges[j, :] + ), "The oriented_edges array must not contain duplicate edges." + + assert set(range(self.num_nodes)) == set( + B.to_numpy(B.flatten(oriented_edges)) + ), "The oriented_edges array must contain all nodes." + + def _checks_oriented_triangles( + self, oriented_triangles: B.Numeric, comprehensive=False + ): """ - :return: - 0. + Checks if `oriented_triangles` is of appropriate structure. + + :param oriented_triangles: + The oriented triangles array. + + :param comprehensive: + If True, perform more extensive checks. """ - return 0 # this is needed for the kernel math to work out - def _make_oriented(self, node_to_edge_incidence, edge_to_triangle_incidence=None): + assert ( + B.rank(oriented_triangles) == 2 + ), "The oriented_triangles array must be 2-dimensional." + + assert ( + B.shape(oriented_triangles)[1] == 3 + ), "oriented_triangles must have shape (*, 3)." + + assert B.dtype(oriented_triangles) == int_like( + oriented_triangles + ), "The oriented_triangles must be an array of integers." + assert B.all( + oriented_triangles >= 1 + ), "The oriented_triangles array must contain only strictly positive values." + assert B.all( + oriented_triangles <= self.num_edges + ), "The values in the oriented_triangles array must be <= self.num_edges." + + assert B.all( + B.abs(oriented_triangles) < self.num_edges + ), "The absolute values in the oriented_edges array must be less than self.num_edges." + assert ( + B.all( + B.abs(oriented_triangles[:, 0]) - B.abs(oriented_triangles[:, 1]) != 0 + ) + or B.all( + B.abs(oriented_triangles[:, 0]) - B.abs(oriented_triangles[:, 2]) != 0 + ) + or B.all( + B.abs(oriented_triangles[:, 1]) - B.abs(oriented_triangles[:, 2]) != 0 + ) + ), "Triangle must consist of 3 _different_ edges." + + if comprehensive: + num_triangles = oriented_triangles.shape[0] + + for i in range(num_triangles): + for j in range(i + 1, num_triangles): + assert B.any( + num_triangles[i, :] != num_triangles[j, :] + ), "The num_triangles array must not contain duplicate triangles." + + def _checks_compatible( + self, + oriented_triangles: B.Numeric, + ): """ - Since our inputs are non-oriented, we make them oriented by taking the vertex with the smallest index first. + Checks if `self.oriented_edges` and `oriented_triangles` are compatible. + + :param oriented_triangles: + The oriented triangles array. """ - # make the edges oriented - self.edges = [] - self.nodes = list(range(1, self.num_nodes + 1)) - for i in range(node_to_edge_incidence.shape[1]): - self.edges.append(tuple(np.where(node_to_edge_incidence[:, i] != 0)[0] + 1)) + assert B.dtype(self.oriented_edges) == B.dtype( + oriented_triangles + ), "The oriented_edges and oriented_triangles arrays must have the same dtype." - self.node_to_edge_incidence = B.zeros(self.num_nodes, self.num_edges) - for i, edge in enumerate(self.edges): + num_triangles = oriented_triangles.shape[0] + for t in range(num_triangles): + resolved_edges = self.resolve_edge(oriented_triangles[t, :]) assert ( - edge[0] < edge[1] - ) # "The first node should have a smaller index than the second node." - self.node_to_edge_incidence[edge[0] - 1, i] = -1 - self.node_to_edge_incidence[edge[1] - 1, i] = 1 - - # make the triangles oriented - if edge_to_triangle_incidence is None: - cliques = nx.enumerate_all_cliques(nx.Graph(self.edges)) - triangle_vertices = [x for x in cliques if len(x) == 3] - # sort the triangles - self.triangles = [tuple(sorted(tri)) for tri in triangle_vertices] - else: - self.triangles = [] - for i in range(edge_to_triangle_incidence.shape[1]): - edge = self.edges[i] - edges_of_triangle = np.where(edge_to_triangle_incidence[:, i] != 0)[0] - nodes_of_triangle = np.unique( - np.where(self.node_to_edge_incidence[:, edges_of_triangle] != 0)[0] - ) - self.triangles.append(tuple(nodes_of_triangle + 1)) + resolved_edges[0, 1] == resolved_edges[1, 0] + ), "The edges in the triangle must be connected." + assert ( + resolved_edges[1, 1] == resolved_edges[2, 0] + ), "The edges in the triangle must be connected." + assert ( + resolved_edges[2, 1] == resolved_edges[0, 0] + ), "The edges in the triangle must be connected." - self.edge_to_triangle_incidence = self.build_edge_to_triangle_incidence() + def _check_index(self, index: csr_array): + TODO - def _set_laplacian(self): - """ - Construct the appropriate graph Laplacian from the adjacency matrix. + def resolve_edge(self, e: B.Int) -> B.Int: """ - self._down_edge_laplacian = ( - self.node_to_edge_incidence.T @ self.node_to_edge_incidence - ) - self._up_edge_laplacian = B.matmul( - self.edge_to_triangle_incidence, self.edge_to_triangle_incidence, tr_b=True - ) - self.hodge_laplacian = self._down_edge_laplacian + self._up_edge_laplacian + Resolve the signed edge indices to node indices. - @property - def incidence_matrices(self): - """ - Return the incidence matrix - """ - return self.node_to_edge_incidence, self.edge_to_triangle_incidence + :param e: + A 1-dimensional array of edge indices. Each edge index is a number + from 1 to the number of edges (incl.). - def get_edge_index(self, edges): + :return: + A 2-dimensional array `result` such that `result[e, :]` is `[i, j]` + where |e| = (i, j) if e > 0 and |e| = (j, i) if e < 0. + """ + assert B.rank(e) == 1 + assert B.all(B.abs(e) >= 1) and B.all(B.abs(e) <= self.num_edges) + + result = self.edges[B.abs(e) - 1] + # TODO: will not work with TF/JAX + result[e < 0] = result[e < 0][::-1] + + return result + + @classmethod + def from_adjacency( + cls, + adjacency_matrix: Union[B.NPNumeric, sparray, spmatrix], + type_reference: B.RandomState, + triangles: Optional[List[Tuple[int, int, int]]] = None, + *, + checks_mode: str = "simple", + ) -> "GraphEdge": """ - Get the indices of some provided edges in the edge list. + Construct the GraphEdge space from the adjacency matrix of the graph. - Args: - edges (list): Edges. + :param adjacency_matrix: + Adjacency matrix of the graph. A numpy array of shape [n_nodes, n_nodes] + where n_nodes is the number of nodes in the graph. adjacency_matrix[i, j] + can only be 0 or 1. - Returns: - list: Indices of the edges. - """ - assert isinstance(edges, list) # "The edges should be a list." - # each edge should be in the edge list - assert all(edge in self.edges for edge in edges) - return B.to_numpy([self.edges.index(edge) for edge in edges]) + :param type_reference: + A random state object of the preferred backend to infer backend from. - def build_edge_to_triangle_incidence(self) -> np.ndarray: - """ - Create the B2 matrix (edge-triangle) from the triangles. + :param triangles: + A list of tuples of three integers representing the nodes of the + triangles in the graph. If not provided or set to None, the maximal + possible set of triangles will be computed and used. - The `edge_to_triangle_incidence` parameter is a `numpy` array of shape `(n_edges, n_triangles)` where `n_triangles` is the number of triangles in the graph. + :param checks_mode: + Forwards the `checks_mode` parameter to the constructor. - The entry `edge_to_triangle_incidence[e, t]` is - - `-1` if edge `e` is anti-aligned with triangle `t`, e.g., $(1,3)$ is anti-aligned with $(1,2,3)$, - - `1` if edge `e` is aligned with triangle `t`, e.g., $(1,2)$ is aligned with $(1,2,3)$, and - - `0` otherwise. + :return: + A constructed instance of the GraphEdge space. + """ + if isinstance(adjacency_matrix, np.ndarray): + index = csr_array(adjacency_matrix, dtype=int) + elif isinstance(adjacency_matrix, (sparray, spmatrix)): + index = csr_array(adjacency_matrix, dtype=int, copy=True) + + if len(index.shape) != 2: + raise ValueError("Adjacency matrix must be a square matrix.") + if (abs(index - index.T) > 1e-10).nnz != 0: + raise ValueError("Adjacency matrix must be symmetric.") + if (index.diagonal() != 0).any(): + raise ValueError("Adjacency matrix must have zeros on the diagonal.") + if np.sum(index.data == 1) + np.sum(index.data == 0) != len(index.data): + raise ValueError("Adjacency matrix can only contain zeros and ones.") + + number_of_nodes = index.shape[0] + number_of_edges = np.sum(index.data) // 2 + + oriented_edges = B.zeros(dtype_integer(type_reference), number_of_edges, 2) + + cur_edge_ind = 0 + for i in range(number_of_nodes): + for j in range(i + 1, number_of_nodes): + if index[i, j] == 1: + oriented_edges[cur_edge_ind, 0] = i + oriented_edges[cur_edge_ind, 1] = j + # We also store cur_edge_ind in the index matrix for later use + index[i, j] = cur_edge_ind + 1 + index[j, i] = -index[i, j] + cur_edge_ind += 1 + assert ( + cur_edge_ind == number_of_edges + ) # double check that we have the right number of edges + + if triangles is None: + triangles = [] + for i in range(number_of_nodes): + for j in range(i + 1, number_of_nodes): + for k in range(j + 1, number_of_nodes): + if index[i, j] != 0 and index[j, k] != 0 and index[i, k] != 0: + triangles.append((i, j, k)) + + number_of_triangles = len(triangles) + oriented_triangles = B.zeros( + dtype_integer(type_reference), number_of_triangles, 3 + ) + for triangle_index, triangle in enumerate(triangles): + i, j, k = sorted(triangle) # sort the nodes in the triangle + oriented_triangles[triangle_index, 0] = index[i, j] + oriented_triangles[triangle_index, 1] = index[j, k] + oriented_triangles[triangle_index, 2] = index[k, i] + + return cls( + number_of_nodes, + oriented_edges, + oriented_triangles, + checks_mode=checks_mode, + index=index, + ) - Args: - triangles (list): List of triangles. - edges (list): List of edges. + @property + def dimension(self) -> int: + """ + :return: + 0. + """ + return 0 # this is needed for the kernel math to work out - Returns: - np.ndarray: B2 matrix. + def _set_laplacian(self): + """ + Construct the appropriate graph Laplacian from the adjacency matrix. """ - triangles = self.triangles - B2 = np.zeros((len(self.edges), len(triangles))) - for j, triangle in enumerate(triangles): - a, b, c = triangle - try: - index_a = self.edges.index((a, b)) - except ValueError: - index_a = self.edges.index((b, a)) - try: - index_b = self.edges.index((b, c)) - except ValueError: - index_b = self.edges.index((c, b)) - try: - index_c = self.edges.index((a, c)) - except ValueError: - index_c = self.edges.index((c, a)) - - B2[index_a, j] = 1 - B2[index_c, j] = -1 - B2[index_b, j] = 1 - - return B2 + # TODO: make this more efficient, avoid for loops. + self._down_laplacian = B.zeros( + B.dtype(self.oriented_edges), self.num_edges, self.num_edges + ) + for i in range(self.num_edges): + for j in range(self.num_edges): + self._down_laplacian[i, j] = ( + self.oriented_edges[i, 0] + == self.oriented_edges[j, 0] + self.oriented_edges[i, 1] + == self.oriented_edges[j, 1] - self.oriented_edges[i, 0] + == self.oriented_edges[j, 1] - self.oriented_edges[i, 1] + == self.oriented_edges[j, 0] + ) + + # TODO: make this more efficient, avoid for loops. + self._up_laplacian = B.zeros( + B.dtype(self.oriented_edges), self.num_edges, self.num_edges + ) + for i in range(self.num_edges): + for j in range(self.num_edges): + for t in range(self.num_triangles): + cur_triangle = set(B.to_numpy(self.oriented_triangles[t, 0])) + if (i in cur_triangle and j in cur_triangle) or ( + -i in cur_triangle and -j in cur_triangle + ): + self._up_laplacian[i, j] += 1 + if (i in cur_triangle and -j in cur_triangle) or ( + -i in cur_triangle and j in cur_triangle + ): + self._up_laplacian[i, j] += -1 + + self._hodge_laplacian = self._down_laplacian + self._up_laplacian def get_eigensystem(self, num): """ @@ -214,52 +449,107 @@ def get_eigensystem(self, num): :return: A tuple of eigenvectors [n, num], eigenvalues [num, 1]. """ + + # The current implementation computes the complete set of eigenpairs of + # three num_edges x num_edges matrices. Since we don't currently support + # sparse laplacian matrices, in this class, this is not a major issue. + # + # Here is some important points for anyone who wants to add proper + # support for sparse eigensolvers which allow to compute only a subset + # of the most important eigenpairs, like scipy.sparse.linalg.eigsh. + # + # 1. You cannot just compute the eigenpairs of the Hodge Laplacian and + # then filter them into the harmonic, gradient, or curl parts. This + # is because up and down edge Laplacians may have common non-zero + # eigenvalues. This means that the eigenspaces of the the Hodge + # Laplacian that correspond to such eigenvalues will contain both + # gradient and curl type of eigenvectors. When an eigenspace is + # multi-dimensional, an eigensolver can return an arbitrary basis + # for it. For example, you may get a basis where all the vectors + # have non-zero grad and curl components at the same time. Thus, you + # won't be able to filter them. + # + # If you put in more effort, you can take the basis for each non-zero + # eigenvalue with multiplicity > 1, project each vector onto the + # pure-gradient and pure-curl subspaces, using up and down Laplacians, + # and then orthogonalize the projected vectors. + # + # 2. You cannot just request `num` eigenpairs from the Hodge Laplacian, + # up and down Laplacians separately. Imagine that you have a space + # with 5 harmonic, 100 gradient, and 100 curl eigenpairs. Then, + # first 105 eigenpairs of the up Laplacian will correspond to + # harmonic and gradient eigenvectors, both correspond to zero + # eigenvalues, while only the last 100 eigenpairs will correspond + # to the actual curl eigenvectors that we are interested to get + # from the up Laplacian. The same is true for the down Laplacian. + # + # 3. An elegant solution would be to construct + # > diff_laplacian = up_laplacian - down_laplacian + # and run a sparse eigensolver on this matrix, requesting `num` + # eigenpairs with the lowest absolute value of eigenvalues. Then, + # you get eigenpairs of the Hodge Laplacian corresponding to the + # first `num` smallest eigenvalues, but the gradient and curl + # eigenvectors would correspond to eigenvalues of different signs. + eps = 1e-6 + if num not in self.cache: - evals, evecs = eigenpairs(self.hodge_laplacian, num) - # make a dictionary of the eigenvalues and eigenvectors where the keys are the indices of the eigenvalues, and add another value which indicates the type of the eigenbasis (harmonic, gradient, curl) - self.hodge_eigenbasis = {} - # add keys to the dictionary - # harmonic ones are the ones associated to zero eigenvalues of the edge laplacian - total_var, total_div, total_curl = [], [], [] - num_eigemodes = len(evals) - for i in range(num_eigemodes): - total_var.append( - B.matmul( - evecs[:, i].reshape(1, -1), - B.matmul(self.hodge_laplacian, evecs[:, i]), - ) - ) - total_div.append( - B.matmul( - evecs[:, i].reshape(1, -1), - B.matmul(self._down_edge_laplacian, evecs[:, i]), - ) - ) - total_curl.append( - B.matmul( - evecs[:, i].reshape(1, -1), - B.matmul(self._up_edge_laplacian, evecs[:, i]), - ) - ) - harmonic_inds, gradient_inds, curl_inds = [], [], [] - for i in range(num_eigemodes): - if total_var[i] < eps: - harmonic_inds.append(i) - elif total_div[i] > eps: - gradient_inds.append(i) - elif total_curl[i] > eps: - curl_inds.append(i) - self.hodge_eigenbasis = { + # We use Hodge Laplacian to find the eigenpairs of harmonic type, these + # are the ones associated to zero eigenvalues. + evals_hodge, evecs_hodge = eigenpairs(self._hodge_laplacian, self.num_edges) + + # We use up and down Laplacians to find the eigenpairs of curl and + # gradient types. These are the ones associated to non-zero eigenvalues. + evals_up, evecs_up = eigenpairs(self._up_laplacian, self.num_edges) + evals_down, evecs_down = eigenpairs(self._down_laplacian, self.num_edges) + + # We count the number of eigenpairs of each type for future reference. + n_harm = B.sum(evals_hodge < eps) + n_curl, n_grad = B.sum(evals_up >= eps), B.sum(evals_down >= eps) + + # We concatenate the eigenvalues and eigenvectors of harmonic, curl, and + # gradient types into a single array. + evals = B.concatenate( + evals_hodge[evals_hodge < eps], + evals_up[evals_up >= eps], + evals_down[evals_down >= eps], + ) + evecs = B.concatenate( + evecs_hodge[:, evals_hodge < eps], + evecs_up[:, evals_up >= eps], + evecs_down[:, evals_down >= eps], + axis=1, + ) + + # We get the indices that would sort the eigenvalues in ascending order. + sorted_indices = B.argsort(evals) + + # In harmonic_idx, gradient_idx, and curl_idx, we store the indices of + # the eigenvalues and eigenvectors of harmonic, gradient, and curl types. + # We also make sure that the indices are not greater than `num`. + def filter_inds(inds: B.Int, num: int) -> List[int]: + return [i for i in inds if i < num] + + harmonic_idx = filter_inds(sorted_indices[:n_harm], num) + curl_idx = filter_inds(sorted_indices[n_harm : n_harm + n_curl], num) + grad_idx = filter_inds( + sorted_indices[n_harm + n_curl : n_harm + n_curl + n_grad], num + ) + + # We sort the eigenvalues and eigenvectors in ascending order of + # eigenvalues, keeping only `num` of the first eigenpairs. + sorted_indices = sorted_indices[:num] + evals = evals[sorted_indices] + evecs = evecs[:, sorted_indices] + + self.cache[num] = { "evals": evals, "evecs": evecs, - "harmonic_idx": harmonic_inds, - "gradient_idx": gradient_inds, - "curl_idx": curl_inds, + "harmonic_idx": harmonic_idx, + "gradient_idx": curl_idx, + "curl_idx": grad_idx, } - self.cache[num] = self.hodge_eigenbasis - return self.cache[num] # get particular type of eigenbasis @@ -323,19 +613,16 @@ def get_repeated_eigenvalues( return self.get_eigenvalues(num, hodge_type) def random(self, key, number): - num_edges = B.shape(self.hodge_laplacian)[0] - key, random_edges_idx = B.randint( + key, random_edges = B.randint( key, dtype_integer(key), number, 1, - lower=0, - upper=num_edges, + lower=1, + upper=self.num_edges + 1, ) - random_edges = [self.edges[i] for i in random_edges_idx.flatten().tolist()] - - return key, random_edges, random_edges_idx + return key, random_edges @property def element_shape(self): @@ -344,3 +631,11 @@ def element_shape(self): [1]. """ return [1] + + @property + def element_dtype(self): + """ + :return: + B.Int. + """ + return B.Int From 4b55b9efcdaa902d5a388339f126ce10b6ac6617 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sat, 14 Dec 2024 17:00:25 +0100 Subject: [PATCH 11/30] Major revision of graph_edge.py [continued] --- geometric_kernels/spaces/graph_edge.py | 350 +++++++++++++++---------- 1 file changed, 214 insertions(+), 136 deletions(-) diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edge.py index a26691a9..27e98a2e 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edge.py @@ -5,7 +5,7 @@ import lab as B import numpy as np from beartype.typing import Dict, List, Optional, Tuple, Union -from scipy.sparse import csr_array, sparray, spmatrix +from scipy.sparse import csr_array, lil_array, coo_matrix, spmatrix from geometric_kernels.lab_extras import dtype_integer, eigenpairs, int_like from geometric_kernels.spaces.base import HodgeDiscreteSpectrumSpace @@ -17,96 +17,130 @@ class GraphEdge(HodgeDiscreteSpectrumSpace): """ - The GeometricKernels space representing the node set of any user-provided - weighted undirected, but **oriented** graph without loops. - Actually, this space is a simplicial 2-complex, as explained below. - - The elements of this space are indices of positively oriented edges of the graph. - Edge indices are integers from 1 to the number of edges in the graph (inclusive). - The reason for indexing the edges from 1 is to allow for signed values. - - The fact that the graph is oriented means that despite the edge (j, i) is - always present in the graph as long as the edge (i, j) is present, any - function f on the set of edges must satisfy f(i, j) = -f(j, i). Mathematically, - this space is actually a simplicial 2-complex, and the functions satisfying - the above condition are called 1-cochains. - - The easiest way to construct an instance of this space is to use the - :meth:`from_adjacency` method, which constructs the space from the adjacency - matrix of the graph. By default this would use all possible triangles in the - graph, but the user can also provide a list of triangles explicitly. These - triangles define the curl operator on the graph and are thus instrumental in - defining the Hodge decomposition. If you don't know what triangles to provide, - you can leave this parameter empty, and the space will compute the maximal - set of triangles for you, which is arguably a good solution in most cases. - When constructing an instance this way, the orientation of the edges and triangles - is chosen automatically in such a way that (i, j) is always oriented from i to j - if i < j and the triangles are of form (e1, e2, e3) where e1 = (i, j), - e2 = (j, k), and e3 = -(i, k). - - When constructing an instance of this space directly, the user chooses the - orientation by providing an `oriented_edges` array, mapping edge indices - to pairs of node indices. And an `oriented_triangles` array, mapping triangle - indices to triples of signed edge indices. These arrays must be compatible in - the sense that the edges in the triangles must be connected. + The GeometricKernels space representing the edge set of a user-provided + graph. The graph must be unweighted, undirected, and without loops. + However, we assume the graph is oriented: for every edge, either (i, j) + or (j, i) is chosen as the positively oriented edge, with the other one + being negatively oriented. Any function f on this space must satisfy + f(e) = -f(-e) if e is a positively oriented edge and -e is the + corresponding negatively oriented edge. + + All positively oriented edges are indexed **from 1 to the number of edges + (inclusive)**. The reason why we start indexing the edges from 1 is to + allow for edge -e to correspond to the opposite orientation of edge e. + Importantly, orientation or a particular ordering of edges does not + affect the geometry of the space. However, changing those requires the + respective change in the way you represent the data. For this space, each individual eigenfunction constitutes a *level*. If - possible, we recommend using num=nun_edges levels. Since the current + possible, we recommend using num=n_edges levels. Since the current implementation does not support sparse eigensolvers anyway, this should - not create too much time/memory overhead during the precomputations, and will - also ensure that all types of eigenfunctions are present in the eigensystem. + not create too much time/memory overhead during the precomputations and + will also ensure that all types of eigenfunctions are present in the + eigensystem. + + .. admonition:: Tutorial - .. note:: A tutorial on how to use this space is available in the :doc:`GraphEdge.ipynb ` notebook. - .. warning:: - Make sure that `oriented_edges` and `oriented_triangles` are of the - backend (NumPy / JAX / TensorFlow, PyTorch) that you wish to use for - internal computations. + .. admonition:: Theory + + Mathematically, this space is actually a simplicial 2-complex, and + the functions satisfying the condition f(e) = -f(-e) are called + 1-cochains. These admit a Hodge decomposition into the harmonic, + gradient, and curl parts. You can find more about Hodge decomposition + on :doc:`this page `. + + .. admonition:: Construction + + **Easy way:** construct the space from the adjacency matrix of the graph. + + The easiest way to construct an instance of this space is to use the + :meth:`from_adjacency` method, which constructs the space from the + adjacency matrix of the graph. By default, this would use all possible + triangles in the graph, but the user can also provide a list of + triangles explicitly. These triangles define the curl operator on the + graph and are thus instrumental in defining the Hodge decomposition. + If you don't know what triangles to provide, you can leave this + parameter empty, and the space will compute the maximal set of + triangles for you, which is a good solution in most cases. + + When constructing an instance this way, the orientation of the edges and + triangles is chosen automatically in such a way that (i, j) is always + positively oriented if i < j, and the triangles are of form (e1, e2, e3) + where e1 = (i, j), e2 = (j, k), e3 = -(i, k), and i < j < k. + + **Hard way:** construct the space from the oriented edges and triangles. + + When constructing an instance of this space directly via :meth:`__init__`, + the user provides an `oriented_edges` array, mapping edge indices to + ordered pairs of node indices, with order defining the positive + orientation, and an `oriented_triangles` array, mapping triangle indices + to triples of signed edge indices. These arrays must be compatible in + the sense that the edges in triangles must be connected. This way, the + user has full control over the orientation and ordering of the edges. - :param num_nodes: + .. admonition:: Complexity + The current implementation of the GraphEdge space is supposed to occupy + O(n_edges^2) memory and take O(n_edges^3) time to compute the eigensystem. + + Currently, it does not support sparse eigensolvers, which would allow + storing the Laplacian matrices in a sparse format and potentially reduce + the O(n_edges^3) complexity to O(n_edges) with a large constant. + + :param n_nodes: The number of nodes in the graph. :param oriented_edges: A 2D array of shape [n_edges, 2], where n_edges is the number of edges - in the graph. Each row of the array represents an oriented edge, i.e. - a pair of node indices. If `oriented_edges[e]` is `[i, j]`, then edge `e` - is oriented from node `i` to node `j`. + in the graph. Each row of the array represents an oriented edge, i.e., + a pair of node indices. If `oriented_edges[e]` is `[i, j]`, then the + edge with index e+1 (edge indexing starts from 1) represents an edge + from node `i` to node `j` which is considered positively oriented, while + the edge with index -e-1 represents an edge from node `j` to node `i`. + + Make sure that `oriented_edges` and `oriented_triangles` are of the + backend (NumPy / JAX / TensorFlow, PyTorch) that you wish to use for + internal computations. :param oriented_triangles: - A 2D array of shape [n_triangles, 3], where n_triangles is the number of - triangles in the graph. Each row of the array represents an oriented - triangle, i.e. a triple of signed edge indices. If `oriented_triangles[t]` - is `[i, j, k]`, then `t` consists of the edges `|i|`, `|j|`, and `|k|`, - where the sign of the edge index indicates the orientation of the edge. + A 2D array of shape [n_triangles, 3], where n_triangles is the number + of triangles in the graph. Each row of the array represents an + oriented triangle, i.e., a triple of signed edge indices. If + `oriented_triangles[t]` is `[i, j, k]`, then `t` consists of the edges + `|i|`, `|j|`, and `|k|`, where the sign of the edge index indicates + the orientation of the edge. Optional. If not provided or set to + `None`, we assume that the set of triangles is empty. - Optional. If not provided or set to `None`, we assume that the set of - triangles is empty. + Make sure that `oriented_edges` and `oriented_triangles` are of the + backend (NumPy / JAX / TensorFlow, PyTorch) that you wish to use for + internal computations. :param checks_mode: - A keyword argument that determines the level of checks performed on the - oriented_edges and oriented_triangles arrays. The default value is "simple" - which performs only basic checks. The other possible value is "comprehensive" - and "skip" which perform more extensive checks and no checks, respectively. - The "comprehensive" mode is useful for debugging, but can be slow for large - graphs. + A keyword argument that determines the level of checks performed on + the oriented_edges and oriented_triangles arrays. The default value is + "simple", which performs only basic checks. The other possible values + are "comprehensive" and "skip", which perform more extensive checks + and no checks, respectively. The "comprehensive" mode is useful for + debugging but can be slow for large graphs. :param index: - Optional. A sparse matrix of shape [num_nodes, num_nodes] such that - `index[i, j]` is the index of the edge `(i, j)` in the `oriented_edges`, - if (i, j) is positively oriented, and minus index of the edge `(i, j)` - otherwise. If not provided, will be constructed automatically. - Should be compatible with the `oriented_edges` array. + Optional. A sparse matrix of shape [n_nodes, n_nodes] such that + `index[i, j]` is the index of the edge `(i, j)` in the `oriented_edges`. + `index[i, j]` is positive if (i, j) corresponds to positive orientation + of the edge, and negative if it corresponds to the negative orientation. + If provided, should be compatible with the `oriented_edges` array. .. admonition:: Citation + If you use this GeometricKernels space in your research, please consider citing :cite:t:`yang2024`. """ def __init__( self, - num_nodes: int, + n_nodes: int, oriented_edges: B.Int, oriented_triangles: Optional[B.Int], *, @@ -122,35 +156,57 @@ def __init__( comprehensive_checks = checks_mode == "comprehensive" self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - self.num_nodes = num_nodes + self.n_nodes = n_nodes if do_checks: - self._checks_oriented_edges(oriented_edges, num_nodes, comprehensive_checks) - self.num_edges = oriented_edges.shape[0] + self._checks_oriented_edges(oriented_edges, n_nodes, comprehensive_checks) + self.n_edges = oriented_edges.shape[0] self.oriented_edges = oriented_edges if oriented_triangles is not None: if do_checks: self._checks_oriented_triangles( - oriented_triangles, self.num_edges, comprehensive_checks + oriented_triangles, self.n_edges, comprehensive_checks ) if comprehensive_checks: - self._checks_compatible(oriented_edges, oriented_triangles, num_nodes) - self.num_triangles = oriented_triangles.shape[0] + self._checks_compatible(oriented_edges, oriented_triangles, n_nodes) + self.n_triangles = oriented_triangles.shape[0] else: - self.num_triangles = 0 + self.n_triangles = 0 self.oriented_triangles = oriented_triangles if index is not None: - self._check_index(index) + if comprehensive_checks: + self._check_index(index) self.index = index else: - self.index = compute_index(oriented_edges) + self.index = self.compute_index(n_nodes, oriented_edges) self._set_laplacian() + @staticmethod + def compute_index(n_nodes: int, oriented_edges: B.Numeric) -> csr_array: + """ + Construct the index matrix from the oriented edges. + + :param n_nodes: + The number of nodes in the graph. + + :param oriented_edges: + The oriented edges array. + + :return: + The index matrix. A scipy csr_array of shape [n_nodes, n_nodes] such + that `index[i, j]` is the index of the edge `(i, j)`. + """ + result = lil_array((n_nodes, n_nodes), dtype=int) + for i in range(oriented_edges.shape[0]): + result[oriented_edges[i, 0], oriented_edges[i, 1]] = i + 1 + result[oriented_edges[i, 1], oriented_edges[i, 0]] = -i - 1 + return result.tocsr() + def _checks_oriented_edges( - self, oriented_edges: B.Numeric, num_nodes: int, comprehensive: bool = False + self, oriented_edges: B.Numeric, n_nodes: int, comprehensive: bool = False ): """ Checks if `oriented_edges` is of appropriate structure. @@ -175,22 +231,22 @@ def _checks_oriented_edges( oriented_edges >= 0 ), "The oriented_edges array must contain only non-negative values." assert B.all( - oriented_edges < self.num_nodes - ), "The values in the oriented_edges array must be < self.num_nodes." + oriented_edges < self.n_nodes + ), "The values in the oriented_edges array must be < self.n_nodes." assert B.all( oriented_edges[:, 0] - oriented_edges[:, 1] != 0 ), "Loops are not allowed." if comprehensive: - num_edges = oriented_edges.shape[0] + n_edges = oriented_edges.shape[0] - for i in range(num_edges): - for j in range(i + 1, num_edges): + for i in range(n_edges): + for j in range(i + 1, n_edges): assert B.any( oriented_edges[i, :] != oriented_edges[j, :] ), "The oriented_edges array must not contain duplicate edges." - assert set(range(self.num_nodes)) == set( + assert set(range(self.n_nodes)) == set( B.to_numpy(B.flatten(oriented_edges)) ), "The oriented_edges array must contain all nodes." @@ -222,12 +278,12 @@ def _checks_oriented_triangles( oriented_triangles >= 1 ), "The oriented_triangles array must contain only strictly positive values." assert B.all( - oriented_triangles <= self.num_edges - ), "The values in the oriented_triangles array must be <= self.num_edges." + oriented_triangles <= self.n_edges + ), "The values in the oriented_triangles array must be <= self.n_edges." assert B.all( - B.abs(oriented_triangles) < self.num_edges - ), "The absolute values in the oriented_edges array must be less than self.num_edges." + B.abs(oriented_triangles) < self.n_edges + ), "The absolute values in the oriented_triangles array must be less than self.n_edges." assert ( B.all( B.abs(oriented_triangles[:, 0]) - B.abs(oriented_triangles[:, 1]) != 0 @@ -238,16 +294,16 @@ def _checks_oriented_triangles( or B.all( B.abs(oriented_triangles[:, 1]) - B.abs(oriented_triangles[:, 2]) != 0 ) - ), "Triangle must consist of 3 _different_ edges." + ), "Triangles must consist of 3 different edges." if comprehensive: - num_triangles = oriented_triangles.shape[0] + n_triangles = oriented_triangles.shape[0] - for i in range(num_triangles): - for j in range(i + 1, num_triangles): + for i in range(n_triangles): + for j in range(i + 1, n_triangles): assert B.any( - num_triangles[i, :] != num_triangles[j, :] - ), "The num_triangles array must not contain duplicate triangles." + oriented_triangles[i, :] != oriented_triangles[j, :] + ), "The oriented_triangles array must not contain duplicate triangles." def _checks_compatible( self, @@ -264,8 +320,8 @@ def _checks_compatible( oriented_triangles ), "The oriented_edges and oriented_triangles arrays must have the same dtype." - num_triangles = oriented_triangles.shape[0] - for t in range(num_triangles): + n_triangles = oriented_triangles.shape[0] + for t in range(n_triangles): resolved_edges = self.resolve_edge(oriented_triangles[t, :]) assert ( resolved_edges[0, 1] == resolved_edges[1, 0] @@ -278,7 +334,18 @@ def _checks_compatible( ), "The edges in the triangle must be connected." def _check_index(self, index: csr_array): - TODO + edges = [] + for e in range(1, self.oriented_edges.shape[0] + 1): + i, j = self.oriented_edges[e - 1, :] + assert index[i, j] == e, "The index matrix must be compatible with oriented_edges." + assert index[j, i] == -e, "The index matrix must be compatible with oriented_edges." + edges.append((min(i, j), max(i, j))) + + for i in range(self.n_nodes): + for j in range(i + 1, self.n_nodes): + if (i, j) not in edges: + assert index[i, j] == 0, "The index matrix must be compatible with oriented_edges." + assert index[j, i] == 0, "The index matrix must be compatible with oriented_edges." def resolve_edge(self, e: B.Int) -> B.Int: """ @@ -293,7 +360,7 @@ def resolve_edge(self, e: B.Int) -> B.Int: where |e| = (i, j) if e > 0 and |e| = (j, i) if e < 0. """ assert B.rank(e) == 1 - assert B.all(B.abs(e) >= 1) and B.all(B.abs(e) <= self.num_edges) + assert B.all(B.abs(e) >= 1) and B.all(B.abs(e) <= self.n_edges) result = self.edges[B.abs(e) - 1] # TODO: will not work with TF/JAX @@ -311,12 +378,12 @@ def from_adjacency( checks_mode: str = "simple", ) -> "GraphEdge": """ - Construct the GraphEdge space from the adjacency matrix of the graph. + Construct the GraphEdge space from the adjacency matrix of a graph. :param adjacency_matrix: - Adjacency matrix of the graph. A numpy array of shape [n_nodes, n_nodes] - where n_nodes is the number of nodes in the graph. adjacency_matrix[i, j] - can only be 0 or 1. + Adjacency matrix of a graph. A numpy array of shape + `[n_nodes, n_nodes]` where `n_nodes` is the number of nodes in the + graph. `adjacency_matrix[i, j]` can only be 0 or 1. :param type_reference: A random state object of the preferred backend to infer backend from. @@ -406,10 +473,10 @@ def _set_laplacian(self): # TODO: make this more efficient, avoid for loops. self._down_laplacian = B.zeros( - B.dtype(self.oriented_edges), self.num_edges, self.num_edges + B.dtype(self.oriented_edges), self.n_edges, self.n_edges ) - for i in range(self.num_edges): - for j in range(self.num_edges): + for i in range(self.n_edges): + for j in range(self.n_edges): self._down_laplacian[i, j] = ( self.oriented_edges[i, 0] == self.oriented_edges[j, 0] + self.oriented_edges[i, 1] @@ -420,11 +487,11 @@ def _set_laplacian(self): # TODO: make this more efficient, avoid for loops. self._up_laplacian = B.zeros( - B.dtype(self.oriented_edges), self.num_edges, self.num_edges + B.dtype(self.oriented_edges), self.n_edges, self.n_edges ) - for i in range(self.num_edges): - for j in range(self.num_edges): - for t in range(self.num_triangles): + for i in range(self.n_edges): + for j in range(self.n_edges): + for t in range(self.n_triangles): cur_triangle = set(B.to_numpy(self.oriented_triangles[t, 0])) if (i in cur_triangle and j in cur_triangle) or ( -i in cur_triangle and -j in cur_triangle @@ -451,57 +518,59 @@ def get_eigensystem(self, num): """ # The current implementation computes the complete set of eigenpairs of - # three num_edges x num_edges matrices. Since we don't currently support - # sparse laplacian matrices, in this class, this is not a major issue. + # three n_edges x n_edges Laplacian matrices. Since we don't currently + # support sparse Laplacians, this should not be a major bottleneck. # - # Here is some important points for anyone who wants to add proper - # support for sparse eigensolvers which allow to compute only a subset - # of the most important eigenpairs, like scipy.sparse.linalg.eigsh. + # Here are some important points for anyone who wants to add proper + # support for sparse Laplacians and sparse eigensolvers which allow + # computing only a few of the most important eigenpairs, like + # scipy.sparse.linalg.eigsh. # # 1. You cannot just compute the eigenpairs of the Hodge Laplacian and # then filter them into the harmonic, gradient, or curl parts. This # is because up and down edge Laplacians may have common non-zero - # eigenvalues. This means that the eigenspaces of the the Hodge + # eigenvalues. This means that the eigenspaces of the Hodge # Laplacian that correspond to such eigenvalues will contain both - # gradient and curl type of eigenvectors. When an eigenspace is + # gradient and curl types of eigenvectors. When an eigenspace is # multi-dimensional, an eigensolver can return an arbitrary basis - # for it. For example, you may get a basis where all the vectors + # for it. Thus, for example, you may get a basis where all the vectors # have non-zero grad and curl components at the same time. Thus, you # won't be able to filter them. # # If you put in more effort, you can take the basis for each non-zero # eigenvalue with multiplicity > 1, project each vector onto the - # pure-gradient and pure-curl subspaces, using up and down Laplacians, + # pure-gradient and pure-curl subspaces (using up and down Laplacians), # and then orthogonalize the projected vectors. # - # 2. You cannot just request `num` eigenpairs from the Hodge Laplacian, - # up and down Laplacians separately. Imagine that you have a space - # with 5 harmonic, 100 gradient, and 100 curl eigenpairs. Then, - # first 105 eigenpairs of the up Laplacian will correspond to - # harmonic and gradient eigenvectors, both correspond to zero - # eigenvalues, while only the last 100 eigenpairs will correspond - # to the actual curl eigenvectors that we are interested to get - # from the up Laplacian. The same is true for the down Laplacian. + # 2. You cannot just request `num` eigenpairs from the Hodge Laplacian, + # up Laplacian and down Laplacian. Imagine that you have a space + # with 5 harmonic, 100 gradient, and 100 curl eigenpairs. Then, + # the first 105 eigenpairs of the up Laplacian will correspond to + # harmonic and gradient eigenvectors, both corresponding to zero + # eigenvalues, while only the last 100 eigenpairs will correspond + # to the actual curl eigenvectors that we are interested in getting + # from the up Laplacian. The same is true for the down Laplacian. # - # 3. An elegant solution would be to construct - # > diff_laplacian = up_laplacian - down_laplacian - # and run a sparse eigensolver on this matrix, requesting `num` - # eigenpairs with the lowest absolute value of eigenvalues. Then, - # you get eigenpairs of the Hodge Laplacian corresponding to the - # first `num` smallest eigenvalues, but the gradient and curl - # eigenvectors would correspond to eigenvalues of different signs. + # 3. An elegant solution would be to construct + # > diff_laplacian = up_laplacian - down_laplacian + # and run a sparse eigensolver on this matrix, requesting `num` + # eigenpairs with the lowest absolute value of eigenvalues. Then, + # you get eigenpairs of the Hodge Laplacian corresponding to the + # first `num` smallest eigenvalues, but the gradient and curl + # eigenvectors would correspond to eigenvalues of different signs + # and thus would be separated. eps = 1e-6 if num not in self.cache: - # We use Hodge Laplacian to find the eigenpairs of harmonic type, these - # are the ones associated to zero eigenvalues. - evals_hodge, evecs_hodge = eigenpairs(self._hodge_laplacian, self.num_edges) + # We use Hodge Laplacian to find the eigenpairs of harmonic type, + # these are the ones associated to zero eigenvalues. + evals_hodge, evecs_hodge = eigenpairs(self._hodge_laplacian, self.n_edges) # We use up and down Laplacians to find the eigenpairs of curl and # gradient types. These are the ones associated to non-zero eigenvalues. - evals_up, evecs_up = eigenpairs(self._up_laplacian, self.num_edges) - evals_down, evecs_down = eigenpairs(self._down_laplacian, self.num_edges) + evals_up, evecs_up = eigenpairs(self._up_laplacian, self.n_edges) + evals_down, evecs_down = eigenpairs(self._down_laplacian, self.n_edges) # We count the number of eigenpairs of each type for future reference. n_harm = B.sum(evals_hodge < eps) @@ -552,7 +621,6 @@ def filter_inds(inds: B.Int, num: int) -> List[int]: return self.cache[num] - # get particular type of eigenbasis def get_eigenfunctions( self, num: int, hodge_type: Optional[str] = None ) -> Eigenfunctions: @@ -562,11 +630,16 @@ def get_eigenfunctions( :param num: Number of levels. + :param hodge_type: The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. :return: EigenfunctionsFromEigenvectors object. + + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. """ eigensystem = self.get_eigensystem(num) idx = ( @@ -582,12 +655,16 @@ def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numer Eigenvalues of the Laplacian corresponding to the first `num` levels (i.e., in this case, `num` eigenpairs). If `type` is specified, returns only the eigenvalues corresponding to the eigenfunctions of that type. + .. warning:: If `type` is specified, the array can have fewer than `num` elements. + :param num: Number of levels. + :return: (n, 1)-shaped array containing the eigenvalues. n <= num. + .. note:: The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel`. @@ -607,6 +684,7 @@ def get_repeated_eigenvalues( ) -> B.Numeric: """ Same as :meth:`get_eigenvalues`. + :param num: Same as :meth:`get_eigenvalues`. """ @@ -619,7 +697,7 @@ def random(self, key, number): number, 1, lower=1, - upper=self.num_edges + 1, + upper=self.n_edges + 1, ) return key, random_edges From cbc14adff7eadf62737c2f859944de31cee50717 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sat, 14 Dec 2024 17:06:49 +0100 Subject: [PATCH 12/30] Major revision of graph_edge.py [continued 2] --- geometric_kernels/kernels/matern_kernel.py | 4 ++-- geometric_kernels/spaces/__init__.py | 2 +- .../spaces/{graph_edge.py => graph_edges.py} | 12 ++++++------ .../{SimplicialComplex.ipynb => GraphEdges.ipynb} | 4 ++-- tests/spaces/test_graph_edge.py | 4 ++-- 5 files changed, 13 insertions(+), 13 deletions(-) rename geometric_kernels/spaces/{graph_edge.py => graph_edges.py} (98%) rename notebooks/{SimplicialComplex.ipynb => GraphEdges.ipynb} (99%) diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 817e94e4..8a63aafb 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -25,7 +25,7 @@ CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, - GraphEdge, + GraphEdges, HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, @@ -210,7 +210,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: return min( MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) - elif isinstance(space, GraphEdge): + elif isinstance(space, GraphEdges): return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) elif isinstance(space, HypercubeGraph): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index f2dfa4bc..700b75a5 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -11,7 +11,7 @@ ) from geometric_kernels.spaces.circle import Circle from geometric_kernels.spaces.graph import Graph -from geometric_kernels.spaces.graph_edge import GraphEdge +from geometric_kernels.spaces.graph_edges import GraphEdges from geometric_kernels.spaces.hyperbolic import Hyperbolic from geometric_kernels.spaces.hypercube_graph import HypercubeGraph from geometric_kernels.spaces.hypersphere import Hypersphere diff --git a/geometric_kernels/spaces/graph_edge.py b/geometric_kernels/spaces/graph_edges.py similarity index 98% rename from geometric_kernels/spaces/graph_edge.py rename to geometric_kernels/spaces/graph_edges.py index 27e98a2e..1ea4c8b1 100644 --- a/geometric_kernels/spaces/graph_edge.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -15,7 +15,7 @@ ) -class GraphEdge(HodgeDiscreteSpectrumSpace): +class GraphEdges(HodgeDiscreteSpectrumSpace): """ The GeometricKernels space representing the edge set of a user-provided graph. The graph must be unweighted, undirected, and without loops. @@ -42,7 +42,7 @@ class GraphEdge(HodgeDiscreteSpectrumSpace): .. admonition:: Tutorial A tutorial on how to use this space is available in the - :doc:`GraphEdge.ipynb ` notebook. + :doc:`GraphEdges.ipynb ` notebook. .. admonition:: Theory @@ -82,7 +82,7 @@ class GraphEdge(HodgeDiscreteSpectrumSpace): user has full control over the orientation and ordering of the edges. .. admonition:: Complexity - The current implementation of the GraphEdge space is supposed to occupy + The current implementation of the GraphEdges space is supposed to occupy O(n_edges^2) memory and take O(n_edges^3) time to compute the eigensystem. Currently, it does not support sparse eigensolvers, which would allow @@ -376,9 +376,9 @@ def from_adjacency( triangles: Optional[List[Tuple[int, int, int]]] = None, *, checks_mode: str = "simple", - ) -> "GraphEdge": + ) -> "GraphEdges": """ - Construct the GraphEdge space from the adjacency matrix of a graph. + Construct the GraphEdges space from the adjacency matrix of a graph. :param adjacency_matrix: Adjacency matrix of a graph. A numpy array of shape @@ -397,7 +397,7 @@ def from_adjacency( Forwards the `checks_mode` parameter to the constructor. :return: - A constructed instance of the GraphEdge space. + A constructed instance of the GraphEdges space. """ if isinstance(adjacency_matrix, np.ndarray): index = csr_array(adjacency_matrix, dtype=int) diff --git a/notebooks/SimplicialComplex.ipynb b/notebooks/GraphEdges.ipynb similarity index 99% rename from notebooks/SimplicialComplex.ipynb rename to notebooks/GraphEdges.ipynb index 90e3a8cb..d1ff5da8 100644 --- a/notebooks/SimplicialComplex.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -1268,7 +1268,7 @@ "provenance": [] }, "kernelspec": { - "display_name": "base", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1282,7 +1282,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edge.py index 1b1cc32c..edc3317f 100644 --- a/tests/spaces/test_graph_edge.py +++ b/tests/spaces/test_graph_edge.py @@ -4,7 +4,7 @@ import numpy as np from geometric_kernels.jax import * # noqa -from geometric_kernels.spaces.graph_edge import GraphEdge +from geometric_kernels.spaces import GraphEdges from geometric_kernels.torch import * # noqa warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") @@ -20,7 +20,7 @@ triangles = [(1, 2, 3)] B1 = nx.incidence_matrix(G).toarray() B2 = np.array([[1.0], [1.0], [0.0], [1.0], [0.0], [0.0]]) -sc = GraphEdge(B1, B2) +sc = GraphEdges(B1, B2) m = sc.num_edges eigs = np.array( [ From 1d5b52798d5b6220c7ec217791f02a1bde020bd0 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sat, 14 Dec 2024 17:16:48 +0100 Subject: [PATCH 13/30] Some cleanup --- .gitignore | 1 - notebooks/Graph.ipynb | 116 +- notebooks/backends/JAX_Graph.ipynb | 39 +- .../backends/JAX_SimplicialComplex.ipynb | 1265 ---------------- notebooks/backends/PyTorch_Graph.ipynb | 109 +- .../backends/PyTorch_SimplicialComplex.ipynb | 1271 ----------------- ...test_graph_edge.py => test_graph_edges.py} | 0 7 files changed, 98 insertions(+), 2703 deletions(-) delete mode 100644 notebooks/backends/JAX_SimplicialComplex.ipynb delete mode 100644 notebooks/backends/PyTorch_SimplicialComplex.ipynb rename tests/spaces/{test_graph_edge.py => test_graph_edges.py} (100%) diff --git a/.gitignore b/.gitignore index 07a80a31..910896f3 100644 --- a/.gitignore +++ b/.gitignore @@ -142,4 +142,3 @@ dmypy.json # Idea /.idea/ -*_old* \ No newline at end of file diff --git a/notebooks/Graph.ipynb b/notebooks/Graph.ipynb index 285e2986..8c18fd17 100644 --- a/notebooks/Graph.ipynb +++ b/notebooks/Graph.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "id": "N2YCQeyY50Xg" }, @@ -61,19 +61,7 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -86,8 +74,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" + "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n" ] } ], @@ -131,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -149,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -165,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -178,7 +165,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -208,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -240,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -262,14 +249,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + "params: {'lengthscale': array(1.), 'nu': array(inf)}\n" ] } ], @@ -296,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -332,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -362,7 +349,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -379,12 +366,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -438,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -455,7 +442,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -474,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -483,27 +470,6 @@ "variance_inf = kernel.K_diag(params_inf, other_points)" ] }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.4852701 , 1.08578832, 1.08578832, 1.08578832, 1.08578832,\n", - " 1.08578832, 1.08578832])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "variance_32" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -515,12 +481,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -557,7 +523,7 @@ "\n", "# Plot kernel values 32\n", "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=values_32,\n", - " vmin=vmin, vmax=vmax, edgecolors=edgecolors, edge_color='red',\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", " linewidths=2.0, **kwargs)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -612,7 +578,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -665,7 +631,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -693,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -706,14 +672,14 @@ " [5]]\n", "\n", "emedding (shape = (3, 7)):\n", - "[[-0.64111333 -0.10633366 0.79213149 -0.10633366 -0.10633366 -0.10633366\n", - " -0.04541286]\n", - " [-0.64111333 -0.10633366 -0.10633366 -0.10633366 -0.10633366 0.79213149\n", - " -0.04541286]\n", - " [-0.64111333 -0.10633366 -0.10633366 -0.10633366 0.79213149 -0.10633366\n", - " -0.04541286]]\n", + "[[-6.41113328e-01 -1.64036543e-01 -2.00902915e-01 -4.58519688e-17\n", + " -4.04993805e-18 7.78093645e-01 -4.54128597e-02]\n", + " [-6.41113328e-01 -1.64036543e-01 -2.00902915e-01 -3.66796862e-01\n", + " 6.35310801e-01 -2.59364548e-01 -4.54128597e-02]\n", + " [-6.41113328e-01 -1.64036543e-01 -2.00902915e-01 -3.66796862e-01\n", + " -6.35310801e-01 -2.59364548e-01 -4.54128597e-02]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 2.220446049250313e-16\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.839349969133127e-16\n" ] } ], @@ -753,7 +719,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -761,9 +727,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-1.28404228 1.792016 ]\n", - " [ 0.3966486 1.88615994]\n", - " [-0.62251577 -1.02004327]]\n" + "[[ 0.45905103 1.50022096]\n", + " [-1.03938522 -0.72020871]\n", + " [-1.05932937 2.12939523]]\n" ] } ], @@ -793,12 +759,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -894,9 +860,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "base", + "display_name": "gkconda_updated_sh", "language": "python", - "name": "python3" + "name": "gkconda_updated_sh" }, "language_info": { "codemirror_mode": { @@ -908,7 +874,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/notebooks/backends/JAX_Graph.ipynb b/notebooks/backends/JAX_Graph.ipynb index 1e839545..ee7e5e68 100644 --- a/notebooks/backends/JAX_Graph.ipynb +++ b/notebooks/backends/JAX_Graph.ipynb @@ -101,8 +101,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n", "INFO (geometric_kernels): JAX backend enabled.\n" ] } @@ -197,7 +196,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -288,7 +287,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + "params: {'lengthscale': array(1.), 'nu': array(inf)}\n" ] } ], @@ -412,7 +411,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -527,7 +526,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -711,14 +710,14 @@ " [0]]\n", "\n", "emedding (shape = (3, 7)):\n", - "[[ 6.41113328e-01 -5.83886545e-02 6.17736550e-01 -4.27352887e-01\n", - " -3.11382096e-01 -9.00150537e-02 -4.54128597e-02]\n", - " [ 6.41113328e-01 -5.94955097e-01 -8.38744739e-02 -9.08091414e-02\n", - " 5.37162459e-01 -1.22079428e-01 -4.54128597e-02]\n", - " [ 6.41113328e-01 -1.39164210e-17 -1.80081302e-17 -1.70475463e-17\n", - " -3.65882793e-17 1.27432374e-17 2.72477158e-01]]\n", + "[[ 6.41113328e-01 -1.49568079e-01 -6.27429672e-01 -1.91494425e-01\n", + " -4.33620981e-01 -1.78784271e-01 4.54128597e-02]\n", + " [ 6.41113328e-01 2.18591915e-01 1.75155061e-01 -5.48113035e-01\n", + " -2.98734457e-17 5.42042498e-01 4.54128597e-02]\n", + " [ 6.41113328e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 -0.00000000e+00 -2.72477158e-01]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 2.4196749845665633e-16\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 4.041272810440265e-16\n" ] } ], @@ -766,9 +765,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[ 1.10845648 -0.5087827 ]\n", - " [-0.14199361 -0.39358291]\n", - " [ 0.01605173 0.02902955]]\n" + "[[ 0.3998562 0.46701571]\n", + " [ 1.33493251 -0.18550569]\n", + " [ 0.50898399 -0.45234307]]\n" ] } ], @@ -803,7 +802,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -897,9 +896,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "base", + "display_name": "gkconda_updated_sh", "language": "python", - "name": "python3" + "name": "gkconda_updated_sh" }, "language_info": { "codemirror_mode": { @@ -911,7 +910,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/notebooks/backends/JAX_SimplicialComplex.ipynb b/notebooks/backends/JAX_SimplicialComplex.ipynb deleted file mode 100644 index 8390c3b4..00000000 --- a/notebooks/backends/JAX_SimplicialComplex.ipynb +++ /dev/null @@ -1,1265 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", - "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected and we assign user-chosen orientations for the edges.\n", - "\n", - "We construct the simplicial 2-complex by adding triangles to the graph. The triangles can be provided by users. If not provided, we look for all the 2-cliques in the graph and add them to the simplicial 2-complex.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **JAX** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): JAX backend enabled.\n" - ] - } - ], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "# Import a backend, we use jax in this example.\n", - "import numpy as np\n", - "import jax\n", - "import jax.numpy as jnp\n", - "from jax.random import PRNGKey\n", - "jax.config.update(\"jax_enable_x64\", True) # enable float64 in JAX\n", - "\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "# import geometric_kernels.torch\n", - "from geometric_kernels import jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the triangle set " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "triangles = [(1,2,3)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "# shade the area of the triangle\n", - "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the sets of nodes, edges and triangles. \n", - "\n", - "**Note that**: \n", - "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", - "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], - "source": [ - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('triangles:', triangles)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", - "\n", - "The `G` parameter is a 'networkx.classes.graph.Graph' object, from which we build the node-to-edge incidence matrix.\n", - "\n", - "The 'triangle_list' parameter is a list of tuples, where each tuple is a triangle in the graph. If provided, this will be used to construct a simplicial 2-complex.\n", - "\n", - "The 'sc_lifting' parameter is a boolean that determines if to build a simplicial 2-complex. \n", - "- If True and 'triangle_list' is not None, the edge space of a simplicial 2-complex will be built based on the provided triangles. \n", - "- If True and 'triangle_list' is None, the edge space of a simplicial 2-complex with all the 2-cliques as 2-simplices will be built. \n", - "- If False and no 'triangle_list' provided, the edge space of the graph will be built.\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the Simplicial 2-Complex " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "B1 = jnp.array(nx.incidence_matrix(G).toarray())\n", - "B2 = jnp.array([[ 1.],\n", - " [1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "sc = GraphEdge(B1,B2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the incidence matrices" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([1, 2, 3, 4, 5],\n", - " [(1, 2), (1, 3), (1, 4), (2, 3), (3, 5), (4, 5)],\n", - " [(1, 2, 3)])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sc.nodes, sc.edges, sc.triangles" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "node-to-edge incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", - "edge-to-triangle incidence matrix:\n", - " [[ 1.]\n", - " [-1.]\n", - " [ 0.]\n", - " [ 1.]\n", - " [ 0.]\n", - " [ 0.]]\n" - ] - } - ], - "source": [ - "print('node-to-edge incidence matrix:\\n', sc.incidence_matrices[0])\n", - "print('edge-to-triangle incidence matrix:\\n', sc.incidence_matrices[1])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the computed Laplacians" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hodge Laplacian:\n", - " [[ 3. 0. 1. 0. 0. 0.]\n", - " [ 0. 3. 1. 0. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [ 0. 0. 0. 3. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Down Hodge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Up Hodge Laplacian:\n", - " [[ 1. -1. 0. 1. 0. 0.]\n", - " [-1. 1. 0. -1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 1. -1. 0. 1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]]\n" - ] - } - ], - "source": [ - "print('Hodge Laplacian:\\n', sc.hodge_laplacian)\n", - "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc._down_edge_laplacian)\n", - "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc._up_edge_laplacian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using Hodge compositional kernel!\n" - ] - } - ], - "source": [ - "use_hodge_composition=True\n", - "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'harmonic': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "import copy\n", - "\n", - "if use_hodge_composition:\n", - " params[\"harmonic\"][\"lengthscale\"], params[\"gradient\"][\"lengthscale\"], params[\"curl\"][\"lengthscale\"] = jnp.array([0.5]), jnp.array([2.0]), jnp.array([1.0])\n", - " params_hodge_1 = copy.deepcopy(params)\n", - " params_hodge_2 = copy.deepcopy(params)\n", - " del params\n", - " params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = jnp.array([3/2]), jnp.array([3/2]), jnp.array([3/2])\n", - " params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = jnp.array([np.inf]), jnp.array([np.inf]), jnp.array([np.inf])\n", - "\n", - "else:\n", - " params[\"lengthscale\"] = jnp.array([2.0])\n", - " params_32 = params.copy()\n", - " params_inf = params.copy()\n", - " del params\n", - " params_32[\"nu\"] = jnp.array([3/2])\n", - " params_inf[\"nu\"] = jnp.array([np.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Check the eigenvalues of the kernels" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eigenvalues for the first set of parameters:\n", - "{'harmonic': Array([[0.02405626]], dtype=float64), 'gradient': Array([[0.32123998],\n", - " [0.18041575],\n", - " [0.10953956],\n", - " [0.0804039 ]], dtype=float64), 'curl': Array([[0.06804138]], dtype=float64)}\n", - "\n", - "Eigenvalues for the second set of parameters:\n", - "{'harmonic': Array([[1.]], dtype=float64), 'gradient': Array([[6.30433923e-02],\n", - " [8.53199536e-03],\n", - " [7.20137798e-04],\n", - " [9.74600529e-05]], dtype=float64), 'curl': Array([[0.22313016]], dtype=float64)}\n" - ] - } - ], - "source": [ - "if use_hodge_composition:\n", - " # Evaluate the eigenvalues for the first set of parameters\n", - " eigenvalues_hodge_1 = kernel.eigenvalues(params_hodge_1, normalize=False)\n", - " # Evaluate the eigenvalues for the second set of parameters\n", - " eigenvalues_hodge_2 = kernel.eigenvalues(params_hodge_2, normalize=False)\n", - " # Print the results\n", - " print(\"Eigenvalues for the first set of parameters:\")\n", - " print(eigenvalues_hodge_1)\n", - " print(\"\\nEigenvalues for the second set of parameters:\")\n", - " print(eigenvalues_hodge_2)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on our graph.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(1, 2), (1, 3), (1, 4)]\n" - ] - } - ], - "source": [ - "key = PRNGKey(1234)\n", - "\n", - "key, random_sampled_edges, xs = sc.random(key, 3)\n", - "print(random_sampled_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If users prefer input the edges directly, we would need to obtain the indices of the edges in the edge space of the simplicial complex. This can be done by calling `sc.get_edge_index(input_edges)`.\n", - "\n", - "Below we verify that the indices of the sampled edges are correct." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0]\n", - " [1]\n", - " [2]]\n", - "[[0]\n", - " [1]\n", - " [2]]\n" - ] - } - ], - "source": [ - "print(xs)\n", - "input_indices = sc.get_edge_index(random_sampled_edges)\n", - "input_indices = jnp.array(input_indices).reshape(-1, 1)\n", - "print(input_indices)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "if use_hodge_composition:\n", - " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs, normalize=False)\n", - " kernel_mat_inf = kernel.K(params_hodge_2, xs, xs, normalize=False)\n", - "else:\n", - " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - " kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAEJCAYAAABcycfyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAY4klEQVR4nO3df3AV1d3H8c/exCTyhBtAIBEaSCMWZCIwJkMmfUZFiSRIQVpRSvkRMxGfGSe202i1djpAy9CIpQxYmfJA+WEtDIzYOh2HhidGU4vNGEtGR1vkjyhCZW5IBuVi+BG4u88fyLWBJOze5LL33L5fnfMHm7O7Z/+49TPfc3aP5TiOIwAAAEME/B4AAACAF4QXAABgFMILAAAwCuEFAAAYhfACAACMQngBAABGIbwAAACjEF4AAIBRCC8AAMAohJcEsGLFClmWpY6ODr+HAuAaGIjffGNjoyzLUmNjY0znt7W1ad68ebrhhhtkWZbWrVsX81iAa43wkiSOHTumRYsWafz48Ro8eLCGDBmiqVOn6oUXXtDlO0D84Q9/0Pz585Wfn69BgwZp/Pjxevzxx/X555/7M3gA19wPf/hD7du3T08//bRefPFFlZeX+z0kwLVUvweAgdHR0aF//etfmjdvnsaMGaPz58+rvr5eDz30kA4dOqRf/OIX0b6PPPKIRo0apUWLFmnMmDF6//339fzzz2vv3r1qaWnR9ddf7+OTAHDjjjvu0JkzZ5SWlhbT+a+//rruu+8+PfHEEwM8MiD+CC9JYtKkSVeUj6urqzV79mw999xzWrlypVJSUiRJe/bs0bRp07r1LSwsVEVFhXbs2KGHH374Go0aQKwCgYAyMjJiPv/48eMaMmTIwA0IuIaYNkpQn3zyicaNG6eCggK1tbXFfJ28vDydPn1aXV1d0WOXBxdJ+va3vy1JOnjwYMz3AhA7r7/5nta8TJs2TQUFBfrnP/+pu+66S4MGDdLo0aP17LPPRvts375dlmXJcRxt2LBBlmXJsqx4PBLi4OzZswqHw57a2bNn/R72gKPykoBaW1t19913a9iwYaqvr9fw4cNdn3vmzBl1dnbqiy++0F/+8hdt27ZNJSUlV50KCoVCkuTpXgAGRn9+85f77LPPVF5eru985zt68MEHtWfPHj311FO69dZbNXPmTN1xxx168cUXtXjxYt1zzz1asmTJAD4J4uns2bP6+thMhY5HPJ2Xk5Ojjz/+uF+VukRDeEkwH374oaZPn67Ro0dr3759Gjp0qKfz169fr6effjr67+nTp2vbtm1XPW/16tVKSUnRvHnzPI8ZQOz6+5u/3LFjx/S73/1OixcvliRVVVVp7Nix2rJli2bOnKn8/Hzl5+dr8eLF+sY3vqFFixYNxGPgGujq6lLoeEQfHxir4GB3EyfhU7a+XviJurq6CC+Ijw8++EDz58/XuHHj9Oc//1nBYNDzNRYsWKCioiK1t7fr1VdfVVtbm86cOdPnOTt37tSWLVv05JNP6uabb451+AA8Gojf/OUyMzO7BZK0tDRNnTpVH330Ub+vjcTwX5kXmxsR5+p9TMSalwQye/ZsDR48WPv27Yv5/8TGjh2r0tJSLViwQDt27FB+fr5KS0t7DTB//etfVVVVpbKyMq1atao/wwfg0UD85i/3ta997Yo1LEOHDtVnn302INeH/2w5nloyIrwkkPvvv1+tra3asWPHgF1z3rx5Onr0qN58880r/vbee+9pzpw5Kigo0J49e5SaSiEOuJbi8Zu/9Fbh5S7/3hPMZXv8XzLiv1YJ5Je//KVSU1P16KOPavDgwfre977X72teqricPHmy2/HW1laVl5dr5MiR2rt3rzIzXdYgAQyYePzmkfwijqOIyzDqtp9pCC8JxLIsbdq0SadOnVJFRYUyMzM1Z84cV+e2t7drxIgRVxzfsmWLLMvSbbfdFj0WCoU0Y8YMBQIB7du3r8fzAMRff37z+M/lZTooWaeNCC8JJhAI6Pe//73mzp2rBx98UHv37tXdd9991fNWrVqlt956S+Xl5RozZoxOnDihl19+We+8844ee+wxjRs3Ltq3vLxcH330kZ588knt379f+/fvj/4tOztb99xzT1yeDcCVYv3N4z/XBdk676FvMiK8JKDrrrtOe/bs0cyZM3XffffptddeU3FxcZ/nzJo1S62trdq6dava29uVkZGhSZMmadu2baqoqOjW97333pOkbh+uuuTOO+8kvADXWCy/efznYtpIshxWcQEAkPDC4bCysrL04cFsDXb5nZdTp2xNuKVNJ0+eHLA32hIBlRcAAAwSkaOIy7UsbvuZhvCS4M6cOXPFm0KXGzZsWMw7ywJILPzmcTURx/3H55L1I3WElwS3e/duVVZW9tnnjTfe6HGzRQDm4TePq7G/bG77JiPCS4IrKytTfX19n30mT558jUYDIN74zeNqbFmKyN1O4LbLfqYhvCS4G2+8UTfeeKPfwwBwjfCbx9XYzsXmtm8yIrwAAGCQiIfKi9t+piG8AABgEMKLh/DSePjmeI7DWKv/u9zvISSkyKgb/B5Cwvq/d1b4PQRX9n5U4PcQEtL6yUV+DyEh2Z2dfg8hYdXbLw3o9WzHku24XPPisp9pqLwAAGAQKi+EFwAAjBJRQBG5+8JuJM5j8QvhBQAAgzgepo0cpo0AAIDfmDYivAAAYJSIE1DEcTltxHdeAACA384roPNKcdk3ORFeAAAwiLfKS3KWXggvAAAYxJbles8i9jYCAAC+sz28Km2LygsAAPAZ00aEFwAAjGIrIJvKCwAAMEXEsRRx+fE5t/1MQ3gBAMAg3rYHoPICAAB8ZjsB2S7XvNiseQEAAH6j8kJ4AQDAKLbcr2Wx4zsU3xBeAAAwiLe3jdz1Mw3hBQAAg3j7zgvhBQAA+IztAQgvAAAYpctJVYrj7j/fXcm5XpfwAgCASWzHku12wS4fqQMAAH7ztjEja14AAIDPvH2kjvACAAB8FpGliMuFuG77mYbwAgCAQai8EF4AADBKRO4rKpH4DsU3hBcAAAxC5YXwAgCAUfjCLuEFAACjOB6+sOuwYBcAAPiNyouS9Os1AAAkqUtf2HXbYrFhwwbl5eUpIyNDxcXFam5udnXerl27ZFmW5s6dG9N93SK8AABgkMiXX9h127zavXu3ampqtHz5crW0tGjy5MkqKyvT8ePH+zzv8OHDeuKJJ3T77bfH+miuEV4AADBIvCsva9eu1dKlS1VZWamJEydq48aNGjRokLZu3drrOZFIRAsXLtTPfvYz5efn9+fxXCG8AABgEFsBT02SwuFwt3bu3Lker93V1aUDBw6otLQ0eiwQCKi0tFRNTU29junnP/+5Ro4cqaqqqoF92F4QXgAAMMh5O+CpSVJubq6ysrKirba2tsdrd3R0KBKJKDs7u9vx7OxshUKhHs/Zv3+/tmzZos2bNw/sg/aBt40AADCI4+Ejdc6X/Y4ePapgMBg9np6ePiBjOXXqlBYvXqzNmzdr+PDhA3JNNwgvAAAYJJaNGYPBYLfw0pvhw4crJSVFbW1t3Y63tbUpJyfniv6tra06fPiwZs+eHT1m27YkKTU1VYcOHdJNN93kaqxeMG0EAIBBbMfLol1v105LS1NhYaEaGhq+up9tq6GhQSUlJVf0nzBhgt5//329++670TZnzhzdddddevfdd5Wbm9vfx+0RlRcAAAwS772NampqVFFRoaKiIk2dOlXr1q1TZ2enKisrJUlLlizR6NGjVVtbq4yMDBUUFHQ7f8iQIZJ0xfGBRHgBAMAgtoftAdz2+3fz589Xe3u7li1bplAopClTpqiuri66iPfIkSMKBPyduCG8AABgkIhjKeLy+y1u+12uurpa1dXVPf6tsbGxz3O3b98e0z29ILwAAGCQeE8bmYDwAgCAQWy5/3JuLNNGJiC8AABgEMfDmheH8AIAAPzmZc+iWHeVTnSEFwAADMKaF8ILAABGofJCeAEAwCjx/s6LCQgvAAAYhMoL4QUAAKNcsAOybHdrWS647GcawgsAAAah8kJ4AQDAKI7cr2XxuKm0MQgvAAAYhMoL4QUAAKMQXggvAAAYhfBCeAEAwCiEF8ILAABGcRxLjstQ4rafaQgvAAAYhC/sEl4AADAK00aEFwAAjMK0EeEFAACjUHkhvAAAYBQqL4QXAACM4niovBBeAACA7xxJjstNi9jbCAAA+C7iBCQn4L5vEiK8AABgENuxZLFgFwAAmMJxPEwbJem8EeEFAACD8LYR4QUAAKMQXjyEl9X/XR7PcRjrf9/e4/cQEtLSex/2ewjop/WTi/weQkL6n3ff83sICWnTrDK/h/AfgzUvVF4AADAKa14ILwAAGOVieHE7bRTnwfiE8AIAgEFY80J4AQDAKI7cfzk3SQsvhBcAAExC5YXwAgCAWSi9EF4AADCKh8qLqLwAAAC/8ao04QUAAKOw5oXwAgCAURzbkmO7DC8u+5mG8AIAgElYsEt4AQDAJEwbEV4AADBPklZU3CK8AABgECovhBcAAMzCmhcF/B4AAADwwvLYvNuwYYPy8vKUkZGh4uJiNTc399p38+bNuv322zV06FANHTpUpaWlffYfCIQXAABM4nhsHu3evVs1NTVavny5WlpaNHnyZJWVlen48eM99m9sbNSCBQv0xhtvqKmpSbm5uZoxY4Y+/fTTWJ7OFcILAAAmiXN4Wbt2rZYuXarKykpNnDhRGzdu1KBBg7R169Ye++/YsUOPPvqopkyZogkTJui3v/2tbNtWQ0NDLE/nCuEFAACTOJa3JikcDndr586d6/HSXV1dOnDggEpLS6PHAoGASktL1dTU5Gp4p0+f1vnz5zVs2LD+P2svCC8AABjk0t5Gbpsk5ebmKisrK9pqa2t7vHZHR4cikYiys7O7Hc/OzlYoFHI1vqeeekqjRo3qFoAGGm8bAQBgkhjeNjp69KiCwWD0cHp6+oAPS5KeeeYZ7dq1S42NjcrIyIjLPSTCCwAAZvm36SBXfSUFg8Fu4aU3w4cPV0pKitra2rodb2trU05OTp/nrlmzRs8884xee+01TZo0yd34YsS0EQAABrEcb82LtLQ0FRYWdltse2nxbUlJSa/nPfvss1q5cqXq6upUVFQU66O5RuUFAACTxPkjdTU1NaqoqFBRUZGmTp2qdevWqbOzU5WVlZKkJUuWaPTo0dF1M6tXr9ayZcu0c+dO5eXlRdfGZGZmKjMz0/sAXCC8AABgEtu62Nz29Wj+/Plqb2/XsmXLFAqFNGXKFNXV1UUX8R45ckSBwFcTN7/5zW/U1dWlefPmdbvO8uXLtWLFCs/3d4PwAgCASa7B9gDV1dWqrq7u8W+NjY3d/n348OHYbtIPhBcAAEzC3kaEFwAAjBLD20bJhvACAIBBvLxF5PVtI1MQXgAAMAnTRnznBQAAmIXKCwAABrHkYdooriPxD+EFAACTsGCX8AIAgFFY80J4AQDAKIQXwgsAACbhVWnCCwAAZqHyQngBAMAohBfCCwAAJmHaiPACAIBZbOtic9s3CRFeAAAwCJUXwgsAAGZhzQvhBQAAo3iovBBeAACA/6i8EF4AADAK4YXwAgCASViwKwX8HgAAAIAXVF4AADAJ00aEFwAATMK0EeEFAADzJGkocYvwAgCASZg2IrwAAGASpo0ILwAAmIXKC+EFAACTUHkhvAAAYBb7y+a2bxIivAAAYBAqL4QXAADMwpoXwgsAAEYhvBBeAAAwCdNGhBcAAMxC5YXwAgCASai8EF4AADALlRfCCwAARiG8EF4AADCJ9WVz2zcZEV4AADAJlRfCCwAAJmHBLuEFAACzUHkhvAAAYJwkDSVuEV4AADAI00ZSwO8BAAAA9yzbW4vFhg0blJeXp4yMDBUXF6u5ubnP/i+99JImTJigjIwM3Xrrrdq7d29sN3bJdeUlMuqGeI7DWEvvfdjvISSk6lde8XsICWyl3wNwxe7s9HsICWnTrDK/h5CQ9ja+7PcQEtgzA3u5OK952b17t2pqarRx40YVFxdr3bp1Kisr06FDhzRy5Mgr+v/tb3/TggULVFtbq29961vauXOn5s6dq5aWFhUUFHgfgAtUXgAAMMilaSO3zau1a9dq6dKlqqys1MSJE7Vx40YNGjRIW7du7bH/+vXrVV5erh/96Ee65ZZbtHLlSt122216/vnn+/mkvSO8AABgEsdj86Crq0sHDhxQaWlp9FggEFBpaamampp6PKepqalbf0kqKyvrtf9AYMEuAAAmiWHaKBwOdzucnp6u9PT0K7p3dHQoEokoOzu72/Hs7Gx9+OGHPd4iFAr12D8UCrkcpHdUXgAAMEgs00a5ubnKysqKttraWn8fop+ovAAAYJIYKi9Hjx5VMBiMHu6p6iJJw4cPV0pKitra2rodb2trU05OTo/n5OTkeOo/EKi8AABgEMtxPDVJCgaD3Vpv4SUtLU2FhYVqaGiIHrNtWw0NDSopKenxnJKSkm79Jam+vr7X/gOBygsAACaJ86vSNTU1qqioUFFRkaZOnap169aps7NTlZWVkqQlS5Zo9OjR0amnH/zgB7rzzjv1q1/9SrNmzdKuXbv097//XZs2bfJ+c5cILwAAGCTeX9idP3++2tvbtWzZMoVCIU2ZMkV1dXXRRblHjhxRIPDVxM03v/lN7dy5Uz/96U/1k5/8RDfffLNeeeWVuH3jRSK8AABglmuwMWN1dbWqq6t7/FtjY+MVxx544AE98MADsd0sBoQXAAAMwt5GhBcAAMxyDSoviY7wAgCAQai8EF4AADALlRfCCwAARnEcWbbLVOIkZ3ohvAAAYBCmjQgvAACYhWkjwgsAACax7IvNbd9kRHgBAMAkVF4ILwAAmIQ1L4QXAADM4jju3yLibSMAAOA3Ki+EFwAAzMKaF8ILAAAmofJCeAEAwCyseSG8AABgEiovhBcAAMzCmhfCCwAAJqHyQngBAMAstnOxue2bhAgvAACYhGkjwgsAACaxHEeWy4qKxdtGAADAb6x5IbwAAGAWpo0ILwAAmMRyHNfTQUwbAQAA/9lfNrd9kxDhBQAAg1B5IbwAAGAW1rwQXgAAMAobMxJeAAAwCa9KE14AADALlRfCCwAAJrHsi81t32REeAEAwCRUXggvAAAYhbeNCC8AAJiE77wQXgAAMAvTRoQXAABMYtmOrIjLyotNeAEAAH5z5KHyEteR+IbwAgCASZg2IrwAAGAUW5LloW8SIrwAAGAQ3jYivAAAYBamjQgvAAAYhfBCeAEAwCiEF8ILAABGYcGuAn4PAAAAuHdpwa7bFi8nTpzQwoULFQwGNWTIEFVVVemLL77os/9jjz2m8ePH6/rrr9eYMWP0/e9/XydPnvR8b8ILAAAmuTRt5LbFycKFC/WPf/xD9fX1evXVV/Xmm2/qkUce6bX/sWPHdOzYMa1Zs0YffPCBtm/frrq6OlVVVXm+N9NGAACYxHYky2UoidP2AAcPHlRdXZ3eeecdFRUVSZJ+/etf695779WaNWs0atSoK84pKCjQyy+/HP33TTfdpFWrVmnRokW6cOGCUlPdRxIqLwAAmCSGyks4HO7Wzp07168hNDU1aciQIdHgIkmlpaUKBAJ6++23XV/n5MmTCgaDnoKLRHgBAMAwXoLLxfCSm5urrKysaKutre3XCEKhkEaOHNntWGpqqoYNG6ZQKOTqGh0dHVq5cmWfU029YdoIAACTxPCq9NGjRxUMBqOH09PTe+z+4x//WKtXr+7zkgcPHnR37z6Ew2HNmjVLEydO1IoVKzyfT3gBAMAkkYjkRNz1tS/2CwaD3cJLbx5//HE99NBDffbJz89XTk6Ojh8/3u34hQsXdOLECeXk5PR5/qlTp1ReXq7Bgwfrj3/8o6677rqrjutyhBcAAEwSx4/UjRgxQiNGjLhqv5KSEn3++ec6cOCACgsLJUmvv/66bNtWcXFxr+eFw2GVlZUpPT1df/rTn5SRkeFpfJew5gUAAJPYjrcWB7fccovKy8u1dOlSNTc366233lJ1dbW++93vRt80+vTTTzVhwgQ1NzdLuhhcZsyYoc7OTm3ZskXhcFihUEihUEiRiMtK0peovAAAYJIE2R5gx44dqq6u1vTp0xUIBHT//ffrueeei/79/PnzOnTokE6fPi1Jamlpib6JNG7cuG7X+vjjj5WXl+f63oQXAABM4shDeInfMIYNG6adO3f2+ve8vDw5/zbOadOmdft3fxBeAAAwSYJUXvxEeAEAwCS2Ldc7LtrJuTMj4QUAAJNQeSG8AABgFMIL4QUAAKPYX332313f5GM5A7X0FwAAxE04HFZWVpamD61QaiDN1TkX7C41fPZCdAPEZEHlBQAAkzgePj6XpPUJwgsAACZxPEwbEV4AAIDvbFuyXL4C7fCqNAAA8BuVF8ILAAAmcSIROZa7jQwdx9uGh6YgvAAAYBLbkSwqLwAAwBSOI9fbAxBeAACA3xzbkeOy8pKsn3IjvAAAYBLHw8aMvG0EAAD8RuWF8AIAgFEuOOdcV1Qu6HycR+MPwgsAAAZIS0tTTk6O9of2ejovJydHaWnu9kIyBRszAgBgiLNnz6qrq8vTOWlpacrIyIjTiPxBeAEAAEYJ+D0AAAAALwgvAADAKIQXAABgFMILAAAwCuEFAAAYhfACAACMQngBAABG+X8P2nu28JAZFgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = min([jnp.min(kernel_mat_32), jnp.min(kernel_mat_inf)])\n", - "maxmax = max([jnp.max(kernel_mat_32), jnp.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Array([[ 0.50937497, -0.22424068, -0.15397211],\n", - " [-0.22424068, 0.55151863, -0.17105091],\n", - " [-0.15397211, -0.17105091, 0.49229617]], dtype=float64),\n", - " Array([[ 0.49452715, -0.25884074, -0.28746792],\n", - " [-0.25884074, 0.48231852, -0.18992884],\n", - " [-0.28746792, -0.18992884, 0.59206623]], dtype=float64))" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "kernel_mat_32, kernel_mat_inf" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = [(1,2)]\n", - "base_edge_idx = sc.get_edge_index(base_edge)[0]\n", - "other_edges = jnp.arange(sc.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "if use_hodge_composition:\n", - " values_32 = kernel.K(params_hodge_1, jnp.array([[base_edge_idx]]), other_edges).flatten()\n", - " values_inf = kernel.K(params_hodge_2, jnp.array([[base_edge_idx]]), other_edges).flatten()\n", - "else:\n", - " values_32 = kernel.K(params_32, jnp.array([[base_edge_idx]]),\n", - " other_edges).flatten()\n", - " values_inf = kernel.K(params_inf, jnp.array([[base_edge_idx]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "if use_hodge_composition:\n", - " variance_32 = kernel.K_diag(params_hodge_1, other_edges)\n", - " variance_inf = kernel.K_diag(params_hodge_2, other_edges)\n", - "else:\n", - " variance_32 = kernel.K_diag(params_32, other_edges)\n", - " variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "# shade the area of the triangle\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.51,\n", - "Variance in the edge (1,3) is 0.55,\n", - "The average variance is 0.50.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % jnp.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = (3, 1)):\n", - "[[0]\n", - " [1]\n", - " [2]]\n", - "\n", - "harmonic emedding (shape = (3, 1)):\n", - "[[ 0.17407766]\n", - " [ 0.34815531]\n", - " [-0.52223297]]\n", - "gradient emedding (shape = (3, 4)):\n", - "[[ 2.53358943e-01 1.23024295e-01 2.39383702e-01 9.54375058e-02]\n", - " [-4.53992875e-16 2.46048590e-01 -3.53474814e-16 1.90875012e-01]\n", - " [-4.09943381e-01 -7.60331958e-02 1.47947264e-01 1.54421128e-01]]\n", - "curl emedding (shape = (3, 1)):\n", - "[[ 5.77350269e-01]\n", - " [-5.77350269e-01]\n", - " [-5.55111512e-16]]\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.0\n" - ] - } - ], - "source": [ - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "\n", - "if use_hodge_composition:\n", - " _, harmonic_embedding = feature_map(xs, params_hodge_1['harmonic'], hodge_type='harmonic') \n", - " _, gradient_embedding = feature_map(xs, params_hodge_1['gradient'],hodge_type='gradient')\n", - " _, curl_embedding = feature_map(xs, params_hodge_1['curl'], hodge_type='curl')\n", - " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", - " kernel_mat_32_alt = jnp.matmul(harmonic_embedding, harmonic_embedding.T) + jnp.matmul(gradient_embedding, gradient_embedding.T) + jnp.matmul(curl_embedding, curl_embedding.T) \n", - " print('harmonic emedding (shape = %s):\\n%s' % (harmonic_embedding.shape, harmonic_embedding))\n", - " print('gradient emedding (shape = %s):\\n%s' % (gradient_embedding.shape, gradient_embedding))\n", - " print('curl emedding (shape = %s):\\n%s' % (curl_embedding.shape, curl_embedding))\n", - "else:\n", - " # xs are random points from above\n", - " _, embedding = feature_map(xs, params_32, normalize=True)\n", - " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - " kernel_mat_32_alt = jnp.matmul(embedding, embedding.T)\n", - " print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - " \n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', jnp.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "[[-0.64593905 0.53900576]\n", - " [-0.02115641 0.60742445]\n", - " [ 0.52768281 -0.08641872]]\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = PRNGKey(1234)\n", - "\n", - "# new random state is returned along with the samples\n", - "if use_hodge_composition:\n", - " key, samples_harmonic = sample_paths(xs, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", - " key, samples_gradient = sample_paths(xs, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", - " key, samples_curl = sample_paths(xs, params_hodge_1['curl'], key=key, hodge_type='curl')\n", - " samples = samples_harmonic + samples_gradient + samples_curl\n", - "else:\n", - " key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = PRNGKey(seed=1234)\n", - "if use_hodge_composition:\n", - " key, samples_harmonic = sample_paths(other_edges, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", - " key, samples_gradient = sample_paths(other_edges, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", - " key, samples_curl = sample_paths(other_edges, params_hodge_1['curl'], key=key, hodge_type='curl')\n", - " samples = samples_harmonic + samples_gradient + samples_curl\n", - "else:\n", - " key, samples = sample_paths(other_edges, params_32, key=key)\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/backends/PyTorch_Graph.ipynb b/notebooks/backends/PyTorch_Graph.ipynb index a863e868..652b4fee 100644 --- a/notebooks/backends/PyTorch_Graph.ipynb +++ b/notebooks/backends/PyTorch_Graph.ipynb @@ -88,21 +88,7 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# current path \n", - "import os \n", - "import sys\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n", - "# add the first parent path\n", - "sys.path.append(os.path.dirname(os.path.dirname(os.getcwd())))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -115,8 +101,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n", "INFO (geometric_kernels): Torch backend enabled.\n" ] } @@ -161,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "id": "PM1H-As8-KF7" }, @@ -179,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -195,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -208,7 +193,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -238,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": { "id": "YJXKhf4y-tgV" }, @@ -270,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -292,14 +277,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + "params: {'lengthscale': array(1.), 'nu': array(inf)}\n" ] } ], @@ -333,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -371,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -402,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -419,12 +404,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAEJCAYAAABG9Sd8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAYDklEQVR4nO3df2xV9f3H8de5hbbwhQs6bAu1UBgTdQjMEprq5kALLTNFtxEJDKgNYHR0wVaDssmPzQFxBlaWYRoZBecwY+mWZRkdHevWOSYLDlfjNoEIKkzWSxvUYgUK95zvH8B1hUrPudzLpx94PsznDw6fc87nLjnjlffn8znH8TzPEwAAgCEh0wMAAADXNsIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCSA+wYsUKOY6j1tZW00MBcAUk4plvbGyU4zhqbGyM6/xIJKLp06frM5/5jBzHUVVVVdxjAS4XYeQqceTIEc2ePVujRo1S//79NXDgQE2YMEEvvPCCLnzj/69+9SvNmDFDI0aMUN++fTVq1Cg99thj+uCDD8wMHsAVV1FRofr6ei1ZskQvvviiiouLTQ8J17BepgeAxGhtbdV//vMfTZ8+XUOHDtXp06e1Y8cOPfjgg9q3b59WrVoV6/vQQw9pyJAhmj17toYOHao33nhDP/7xj1VXV6fXXntNffr0MfhLAPhx11136cSJE0pNTY3r/D/+8Y+677779Pjjjyd4ZEBwhJGrxJgxYy4q15aXl6ukpEQ/+tGP9PTTTyslJUWSVFtbq4kTJ3bqm5eXp9LSUm3ZskXz58+/QqMGEK9QKKT09PS4zz969KgGDhyYuAEBl4Fpmh7q3Xff1ciRIzV69GhFIpG4r5Obm6uPP/5YHR0dsWMXBhFJ+upXvypJevPNN+O+F4D4BX3mu1ozMnHiRI0ePVr//ve/NWnSJPXt21fZ2dn6wQ9+EOuzefNmOY4jz/O0fv16OY4jx3GS8ZOQBCdPnlRbW1ugdvLkSdPD7haVkR7owIEDuvvuu3X99ddrx44dGjRokO9zT5w4ofb2dn300Uf685//rE2bNqmgoKDbqZfm5mZJCnQvAIlxOc/8hd5//30VFxfra1/7mh544AHV1tbqiSee0G233aapU6fqrrvu0osvvqg5c+Zo8uTJmjt3bgJ/CZLp5MmTGj6sn5qPRgOdl5WVpbfffvuyKmnJRhjpYfbu3at77rlH2dnZqq+v13XXXRfo/HXr1mnJkiWxP99zzz3atGlTt+c988wzSklJ0fTp0wOPGUD8LveZv9CRI0f005/+VHPmzJEkzZs3T8OGDdPGjRs1depUjRgxQiNGjNCcOXN00003afbs2Yn4GbgCOjo61Hw0qrf3DFO4v7+JjbbjrobnvauOjg7CCPz55z//qRkzZmjkyJH63e9+p3A4HPgaM2fO1Pjx49XS0qLf/va3ikQiOnHixCXPeemll7Rx40YtXrxYn/vc5+IdPoCAEvHMX6hfv36dAkZqaqomTJiggwcPXva10TP8X7+zzY+o132fnoA1Iz1ISUmJ+vfvr/r6+rj/T2nYsGEqLCzUzJkztWXLFo0YMUKFhYWfGkj+8pe/aN68eSoqKtLKlSsvZ/gAAkrEM3+hG2+88aI1INddd53ef//9hFwf5rnyAjUbEEZ6kK9//es6cOCAtmzZkrBrTp8+XYcPH9bLL7980d+9/vrrmjZtmkaPHq3a2lr16kWhDLiSkvHMn981d6EL3zcEe7kB/7MB//r0IM8++6x69eqlb37zm+rfv79mzZp12dc8XxH58MMPOx0/cOCAiouLlZGRobq6OvXr57PmByBhkvHM4+oX9TxFfYZLv/1MI4z0II7j6Pnnn9fx48dVWlqqfv36adq0ab7ObWlp0Q033HDR8Y0bN8pxHN1+++2xY83NzZoyZYpCoZDq6+u7PA9A8l3OM49rV5DpF1umaQgjPUwoFNLPfvYz3X///XrggQdUV1enu+++u9vzVq5cqb/+9a8qLi7W0KFDdezYMf3yl7/Uq6++qm9961saOXJkrG9xcbEOHjyoxYsXa+fOndq5c2fs7zIzMzV58uSk/DYAF4v3mce164xcnQ7Q1waEkR6od+/eqq2t1dSpU3XffffpD3/4g/Lz8y95zr333qsDBw6opqZGLS0tSk9P15gxY7Rp0yaVlpZ26vv6669LUqcXIZ335S9/mTACXGHxPPO4dl2N0zSOx6omAAB6vLa2Ng0YMEB738xUf5/vGTl+3NXNt0T04YcfJmzHVjJQGQEAwCJReYr6XAvit59phJEe7sSJExfthLnQ9ddfH/eXOwH0LDzz6E7U8/8yM1teekYY6eG2bt2qsrKyS/b505/+1OXH7wDYh2ce3XHPNb99bUAY6eGKioq0Y8eOS/YZO3bsFRoNgGTjmUd3XDmKyt+Xll2f/UwjjPRwgwcP1uDBg00PA8AVwjOP7rje2ea3rw0IIwAAWCQaoDLit59phBEAACxyTYcRt5lPy3elaMg400PokZy8z5seQo/1+1dXmB6CL21HckwPoUea8tijpofQIx0fyndXP82/nqlI6PVcz5Hr+Vwz4rOfaVRGAACwyDVdGQEAAOZFFVJU/ipR0SSPJVEIIwAAWMQLME3jWTJNwyQfAAAWOT9N47cF8fLLL6ukpERDhgyR4zj69a9/3e05jY2Nuv3225WWlqaRI0dq8+bNgX8TYQQAAIuc9lJ02uvls6UEunZ7e7vGjh2r9evX++r/9ttv695779WkSZPU1NSkRx99VPPnz1d9fX2g+zJNAwCARZK5gHXq1KmaOnWq7/7V1dUaPny41qxZI0m65ZZbtHPnTv3whz9UUVGR7+tQGQEAwCJRLxSoJdOuXbtUWFjY6VhRUZF27doV6DpURgAAsIgrx/c3Z873a2tr63Q8LS1NaWlplz2W5uZmZWZmdjqWmZmptrY2nThxQn369PF1HSojAABYxD23tddPc8/9M5+Tk6MBAwbE2urVqw3/is6ojAAAYJEg0y9R7+yX8g4fPqxwOBw7noiqiCRlZWUpEol0OhaJRBQOh31XRSTCCAAAVnH/p+LRfd+zYSQcDncKI4lSUFCgurq6Tsd27NihgoKCQNdhmgYAAItEPSdQC+Kjjz5SU1OTmpqaJJ3dutvU1KRDhw5JkpYsWaK5c+fG+j/88MM6ePCgFi9erL179+q5557TL37xC1VUBPseD5URAAAsEux18F6ga//973/XpEmTYn+urKyUJJWWlmrz5s3673//GwsmkjR8+HBt27ZNFRUVWrdunW688Ub95Cc/CbStVyKMAABgFdcLyfW5ZsT1goWRiRMnyrvEOV29XXXixIn6xz/+Eeg+FyKMAABgkWRWRkwhjAAAYBFX8r0WxE3uUBKGMAIAgEWC7aaxY58KYQQAAIsEe88IYQQAACRYPK+D7+kIIwAAWKTD66UUz98/3x12rF8ljAAAYBPXc+T6XcAa8KVnphBGAACwiBtgay8LWAEAQMIFe+kZYQQAACRYVI6iPhem+u1nGmEEAACLUBkBAABGReW/4hFN7lAShjACAIBFqIwAAACjeAMrAAAwygvwBlaPBawAACDRqIwAAACjeAMrAAAwKhrgDax++5lGGAEAwCJURgAAgFGuQr6/OcO3aQAAQMKddkMKuf5Cxmmf/UwjjAAAYBEvwEvPPHbTAACARONDeQAAwCjX878w1fWSPJgEIYwAAGARvk0DAACMcgO8Dt5vP9MIIwAAWCTqOYr6nKbx2880wggAABZhmgYAABjlKsAbWJmmAQAAieYFWDPiEUYAAECi8W0aAABgFGtGAACAUVRGAACAUbxnBAAAGEVlBAAAGHXGDclx/a0FOeOzn2mEEQAALEJlBAAAGOXJ/1oQSz7aSxgBAMAmVEYAAIBRhBEAAGAUYQQAABhFGAEAAEZ5niPPZ8jw2880wggAABbhDawAAMAopmkAAIBRTNMAAACjqIwAAACjqIwAAACjvACVEVvCiB2f8wMAAJLOfm/G83y2OO+xfv165ebmKj09Xfn5+dq9e/cl+1dVVWnUqFHq06ePcnJyVFFRoZMnT/q+H5URAAAsEvVCkuevlhD12e9/bd26VZWVlaqurlZ+fr6qqqpUVFSkffv2KSMj46L+L730kp588knV1NTojjvu0P79+/Xggw/KcRytXbvW1z2pjAAAYJHzC1j9tqDWrl2rBQsWqKysTLfeequqq6vVt29f1dTUdNn/lVde0Z133qlZs2YpNzdXU6ZM0cyZM7utpvwvwggAABbxPUVzrklSW1tbp3bq1Kkur93R0aE9e/aosLAwdiwUCqmwsFC7du3q8pw77rhDe/bsiYWPgwcPqq6uTl/5yld8/yamaQAAsEg8u2lycnI6HV++fLlWrFhxUf/W1lZFo1FlZmZ2Op6Zmam9e/d2eY9Zs2aptbVVX/ziF+V5ns6cOaOHH35Y3/72t32NUSKMAABglXjCyOHDhxUOh2PH09LSEjaexsZGrVq1Ss8995zy8/P11ltvadGiRXr66ae1dOlSX9fwHUaKhoyLd5xXtfojTaaH0CMVl3ze9BBwmaY89qjpIfRIv19TZXoIPVLBukrTQ7hmuJ4jJ+BLz8LhcKcw8mkGDRqklJQURSKRTscjkYiysrK6PGfp0qWaM2eO5s+fL0m67bbb1N7eroceekjf+c53FAp1vyKENSMAAFgknjUjfqWmpiovL08NDQ2xY67rqqGhQQUFBV2e8/HHH18UOFJSUs6N1d8AmKYBAMAiZ0OG32ma4NevrKxUaWmpxo8frwkTJqiqqkrt7e0qKyuTJM2dO1fZ2dlavXq1JKmkpERr167VF77whdg0zdKlS1VSUhILJd0hjAAAYJFkvw5+xowZamlp0bJly9Tc3Kxx48Zp+/btsUWthw4d6lQJeeqpp+Q4jp566im99957uuGGG1RSUqKVK1f6vidhBAAAi3jy/2bVeN/AWl5ervLy8i7/rrGxsdOfe/XqpeXLl2v58uVx3o0wAgCAVfhQHgAAMOtKlEauMMIIAAA2CVAZEZURAACQaEG27Mazm8YEwggAABZhzQgAADDKcx15rs8w4rOfaYQRAABswgJWAABgEtM0AADAPEsqHn4RRgAAsAiVEQAAYBZrRgAAgFnOuea3b89HGAEAwCZURgAAgFGEEQAAYJTn+P/mDAtYAQBAovFtGgAAYBbTNAAAwCimaQAAgEmOd7b57WsDwggAADZhmgYAABjlOmeb374WIIwAAGATKiMAAMAowggAADCK3TQAAMAkdtMAAACzrsJpmpDpAQAAgGsblREAACziKMA0TVJHkjiEEQAAbMICVgAAYNRVuGaEMAIAgE0IIwAAwCS29gIAALOojAAAAKMIIwAAwCSmaQAAgFmuc7b57WsBwggAABahMgIAAMxizQgAADAqQGWEMAIAABKPyggAADCKMAIAAEy6GhewhkwPAAAAXNuojAAAYBOmaQAAgElX4zQNYQQAANtYEjL8IowAAGATpmkAAIBJV+M0DbtpAACwiRewxWH9+vXKzc1Venq68vPztXv37kv2/+CDD7Rw4UINHjxYaWlpuummm1RXV+f7flRGAACwSLIrI1u3blVlZaWqq6uVn5+vqqoqFRUVad++fcrIyLiof0dHhyZPnqyMjAzV1tYqOztb7777rgYOHOj7noQRAABs4p5rfvsGtHbtWi1YsEBlZWWSpOrqam3btk01NTV68sknL+pfU1OjY8eO6ZVXXlHv3r0lSbm5uYHuyTQNAAAWOV8Z8dskqa2trVM7depUl9fu6OjQnj17VFhYGDsWCoVUWFioXbt2dXnOb37zGxUUFGjhwoXKzMzU6NGjtWrVKkWjUd+/iTACAIBN4lgzkpOTowEDBsTa6tWru7x0a2urotGoMjMzOx3PzMxUc3Nzl+ccPHhQtbW1ikajqqur09KlS7VmzRp9//vf9/2TmKYBAMAmcWztPXz4sMLhcOxwWlpawobjuq4yMjL0/PPPKyUlRXl5eXrvvff07LPPavny5b6uQRgBAMAi8SxgDYfDncLIpxk0aJBSUlIUiUQ6HY9EIsrKyurynMGDB6t3795KSUmJHbvlllvU3Nysjo4OpaamdntfpmkAALBJErf2pqamKi8vTw0NDbFjruuqoaFBBQUFXZ5z55136q233pLrfrJadv/+/Ro8eLCvICIRRgAAsEo8C1iDqKys1IYNG/TCCy/ozTff1COPPKL29vbY7pq5c+dqyZIlsf6PPPKIjh07pkWLFmn//v3atm2bVq1apYULF/q+J9M0AADYJMmvg58xY4ZaWlq0bNkyNTc3a9y4cdq+fXtsUeuhQ4cUCn1Sy8jJyVF9fb0qKio0ZswYZWdna9GiRXriiSd835MwAgCATa7At2nKy8tVXl7e5d81NjZedKygoEB/+9vf4ruZCCMAAFjFOdf89rUBYQQAAJvw1V4AAGDS1fjVXsIIAAA2oTICAACMsyRk+EUYAQDAIkzTAAAAoxz3bPPb1wa+w4iT9/lkjsNaxSX879KV9mH9TA8Bl+n4UF7Q3JWCdZWmh4BrHWtGAACASUzTAAAAs6iMAAAAowgjAADAJKZpAACAWVRGAACASY7nyfH8pQy//UwjjAAAYBMqIwAAwCTWjAAAALOojAAAAJOojAAAALOojAAAAJOojAAAALOojAAAAKM8T47rM2XwnhEAAJBoTNMAAACzmKYBAAAmOe7Z5revDQgjAADYhMoIAAAwiTUjAADALM/zv0uG3TQAACDRqIwAAACzWDMCAABMojICAADMYs0IAAAwicoIAAAwizUjAADAJCojAADALNc72/z2tQBhBAAAizhegG/T2JFFCCMAAFiF3TQAAMAk1owAAACz2E0DAABMcjxPjs/pF7/9TCOMAABgE/dc89vXAoQRAAAsQmUEAACYxZoRAABgFFt7AQCASWztBQAAZlEZAQAAJjlugNfBs5sGAAAk3FVYGQmZHgAAAAjAC9jisH79euXm5io9PV35+fnavXu3r/N+/vOfy3Ec3X///YHuRxgBAMAi598z4rcFtXXrVlVWVmr58uV67bXXNHbsWBUVFeno0aOXPO+dd97R448/ri996UuB70kYAQDAJq4nRX02N3gYWbt2rRYsWKCysjLdeuutqq6uVt++fVVTU/Op50SjUX3jG9/Qd7/7XY0YMSLwPQkjAABYJJ7KSFtbW6d26tSpLq/d0dGhPXv2qLCwMHYsFAqpsLBQu3bt+tQxfe9731NGRobmzZsX128ijAAAYBNPnyxi7badPSUnJ0cDBgyItdWrV3d56dbWVkWjUWVmZnY6npmZqebm5i7P2blzpzZu3KgNGzbE/ZPYTQMAgE3i2E1z+PBhhcPh2OG0tLSEDOX48eOaM2eONmzYoEGDBsV9HcIIAAA2cSU5AfpKCofDncLIpxk0aJBSUlIUiUQ6HY9EIsrKyrqo/4EDB/TOO++opKTkk1u6Z2/aq1cv7du3T5/97Ge7vS/TNAAAWCSZu2lSU1OVl5enhoaG2DHXddXQ0KCCgoKL+t98881644031NTUFGvTpk3TpEmT1NTUpJycHF/3pTICAIBNkvzSs8rKSpWWlmr8+PGaMGGCqqqq1N7errKyMknS3LlzlZ2drdWrVys9PV2jR4/udP7AgQMl6aLjl0IYAQDAJkkOIzNmzFBLS4uWLVum5uZmjRs3Ttu3b48taj106JBCocROrBBGAACwyRV4HXx5ebnKy8u7/LvGxsZLnrt58+bA9yOMAABgkzgWsPZ0hBEAACwSZGFqPK+DN4EwAgCATa7Cr/YSRgAAsInrSY7PkBHHt2lMIIwAAGATKiMAAMCsAGFEhBEAAJBoUVfyfG6Tce3YTkMYAQDAJl6AMOK3n2GEEQAAbMKaEQAAYJTryfdaEHbTAACAhKMyAgAAjPIUIIwkdSQJQxgBAMAmVEYAAIBRrivfX8Bjay8AAEg4KiMAAMAowggAADDqWt7a+/tXVyRxGAB6mn89U2F6CAC64HmuPJ9vVvXbzzQqIwAA2MTz/Fc8mKYBAAAJ5wWYpiGMAACAhHNdyeFDeQAAwBAvGpXnRP319fz1M40wAgCATZimAQAARrme5BBGAACAKZ4n36+DJ4wAAIBE81xPns/KiEcYAQAACecF+FAeu2kAAECiURkBAABGnfFO+a54nNHpJI8mMQgjAABYIDU1VVlZWdrZXBfovKysLKWmpiZpVInheLbUcAAAuMadPHlSHR0dgc5JTU1Venp6kkaUGIQRAABgVMj0AAAAwLWNMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAo/4f3rtbWoqDAvsAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -478,7 +463,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -495,7 +480,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -514,7 +499,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -523,27 +508,6 @@ "variance_inf = kernel.K_diag(params_inf, other_points)" ] }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([0.4853, 1.0858, 1.0858, 1.0858, 1.0858, 1.0858, 1.0858],\n", - " dtype=torch.float64)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "variance_32" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -555,12 +519,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+AAAAMYCAYAAABL5o0JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1gU5xYH4N8sHSlKEVFRQVQ0KlY6wqwoGsTeNZbYS2wxlsSWaDRqjEkssSS2JBp7L6DSpIpiwd4rivRed+f+oe4NERXYMrs7532eea5ZZr45y112zpn5CsNxHAdCCCGEEEIIIYQolYjvAAghhBBCCCGEECGgApwQQgghhBBCCFEBKsAJIYQQQgghhBAVoAKcEEIIIYQQQghRASrACSGEEEIIIYQQFaACnBBCCCGEEEIIUQEqwAkhhBBCCCGEEBWgApwQQgghhBBCCFEBKsAJIYQQQgghhBAVoAKcEEIIIYQQQghRASrACSGEEEIIIYQQFaACXAG2bdsGhmHw6NEjvkNRitzcXIhEIqxevZrvUD5qxYoVcHJyglQqVel5N2zYgHr16qGoqKjCx8THx8PDwwPVqlUDwzC4fPmy8gKsIE3+LC9atAgMw/AdBiGEaA1FXBM0JYfgK38oj7bkFADlFYSUR+sK8O7du8PY2Bg5OTnv3WfIkCHQ19dHWlqaCiPTXNeuXQPHcWjevDnfoXxQdnY2li9fjtmzZ0MkUu1He8SIESguLsbGjRsrtH9JSQn69euH9PR0rF69Gn/++Sfq16+v5CgJIYSo0tvi48KFC2Vez8rKgouLCwwNDXHq1CmeolMNTcghyssfcnNzsXDhQnTp0gUWFhZgGAbbtm1TSTyUUxCi3bSuAB8yZAgKCgpw8ODBcn+en5+Pw4cPo0uXLrC0tFTIOT/77DMUFBRo7ZddYmIiAKBFixY8R/JhW7ZsQWlpKQYNGqTycxsaGmL48OH46aefwHHcR/e/f/8+Hj9+jJkzZ2Ls2LEYOnQoatSooYJIP0zbP8uEEMK37OxsdO7cGVevXsXBgwfRpUsXvkNSKk3IIcrLH1JTU/Hdd9/h5s2bcHZ2Vmk82pJTAJRXEFIerSvAu3fvDlNTU+zcubPcnx8+fBh5eXkYMmSI3OfKy8sDAOjo6MDQ0FBru6kkJibCysoKtWrV4juUD9q6dSu6d+8OQ0NDXs7fv39/PH78GKGhoR/d99WrVwCA6tWrK+z8bz+P8tD2zzIhhPApJycH/v7+uHz5Mvbv34+uXbsqpF1FfP8riybkEOXlD7a2tnjx4gUeP36MlStXqjwmbcgpAMorCCmP1hXgRkZG6N27N86ePSv7Qvq3nTt3wtTUFN27dwcAPH78GBMnTkSTJk1gZGQES0tL9OvX752xKm/Hgdy4cQODBw9GjRo14OXlBaD88S2VbffevXsYMWIEqlevDnNzc4wcORL5+fll9n3+/DlGjRqF2rVrw8DAAPb29pgwYQKKi4vL7PP555/DxsYGBgYG+OSTT7Bly5Zyf1e3bt3CkydPPvo7TUxMxCeffFLmtc2bN0NfXx/Tpk2DRCL5aBvK9vDhQ1y9ehV+fn68xdC2bVtYWFjg8OHDH9xvxIgR8PHxAQD069cPDMPA19cXAHDp0iV07doVZmZmMDExQceOHREbG/tOGx/6PMqjvM9yZT6j5anM8RV9/5GRkWjfvj0MDQ3RsGHDD3bTq8jfRE5ODqZNm4YGDRrAwMAANWvWRKdOnZCQkPDR90cIIRWRm5uLLl26ICEhAfv370dAQECZn1f0+v2+7//KfldXJl/4r4rmD4D65xDvyx8MDAx4vWmgiJwCqNh1VVk5BfBuXqHKnKKi7x+gvIKoli7fASjDkCFDsH37duzZsweTJ0+WvZ6eno6goCAMGjQIRkZGAF5PWhEdHY2BAweibt26ePToEX777Tf4+vrixo0bMDY2LtN2v3790KhRIyxduvSD3YIq227//v1hb2+PZcuWISEhAb///jtq1qyJ5cuXAwCSkpLg4uKCzMxMjB07Fk5OTnj+/Dn27duH/Px86OvrIzk5GW5ubmAYBpMnT4a1tTVOnjyJUaNGITs7G9OmTStzzqZNm8LHxwdhYWEf/H0mJibKumWVlpZi2rRp2LRpE9atW4cxY8Z88FhViY6OBgC0adOG1zjatGmDqKioD+4zbtw41KlTB0uXLsWUKVPQvn172NjY4Pr16/D29oaZmRlmzZoFPT09bNy4Eb6+vggPD4erq+s7bVX086gIH/uMynt8Rd9/YmIiOnfuDGtrayxatAilpaVYuHAhbGxs3jlnRf8mxo8fj3379mHy5Mlo1qwZ0tLSEBkZiZs3b/L+mSKEaL68vDx07doV8fHx2LdvH7p161bm55W9fgPvfv+/fehQke/qqpzv3yqaPwDqn0OoS/5QHnlyCqDi19W3tCmnACivIGqM00KlpaWcra0t5+7uXub1DRs2cAC4oKAg2Wv5+fnvHB8TE8MB4Hbs2CF7beHChRwAbtCgQe/sv3XrVg4A9/Dhwyq3+/nnn5fZt1evXpylpaXsv4cNG8aJRCIuPj7+nXalUinHcRw3atQoztbWlktNTS3z84EDB3Lm5ubvxASA8/Hxeae9f0tKSuIAcBs2bODS0tI4sVjMWVhYcKGhoR88TtXmzZvHAeBycnJ4jWPs2LGckZHRR/cLDQ3lAHB79+6VvdazZ09OX1+fu3//vuy1pKQkztTUlOvQoUOZ4z/0eZRHeZ/lin5G36eix1f0/ffs2ZMzNDTkHj9+LHvtxo0bnI6ODvffr7SK/k2Ym5tzkyZN+uh7IYSQynj7nVq/fn1OT0+PO3ToULn7Veb6/b7v/8p8V1f0fOVdEziuYvkDx2lGDlGR/CE+Pp4DwG3dulV1gXHy5RQcV/HrqrJyCo579zOkqpyC4yivIOpL67qgA6/HmwwcOBAxMTFlutLu3LkTNjY26Nixo+y1t0/CgdezSKalpcHR0RHVq1cvt5vI+PHjKxSDvO16e3sjLS0N2dnZkEqlOHToEAIDA9GuXbt3jmUYBhzHYf/+/QgMDATHcUhNTZVt/v7+yMrKeue8HMd99O711atXZedo3749kpKSEBcXV6Z7kzpIS0uDrq4uTExMyrweGxsLhmGwaNGiKrddmTZq1KiBgoKCCnWj+jeJRILg4GD07NkTDg4OstdtbW0xePBgREZGIjs7+53jKvp5VMTv4UOfUXmPr+j7l0gkCAoKQs+ePVGvXj3Zfk2bNoW/v3+Z9ivzN1G9enXExcUhKSmpUr8TQgipiOTkZBgaGsLOzu6dn1Xl+g28//v/Y9/VVT3ff2OuyNNvTcgh3pc/KFNFr8lVzSmAquUV2pJTABV//5RXED5oZQEOQDbJ2tvJ2J49e4Zz585h4MCB0NHRke1XUFCABQsWwM7ODgYGBrCysoK1tTUyMzORlZX1Trv29vYVOn9l2/33Hz0A2eyVGRkZSElJQXZ29geX8EhJSUFmZiY2bdoEa2vrMtvIkSMBoNwx8R/zdvbSyZMnw8bGBjExMXB0dHxnv7Fjx8LW1hZmZmZo0aIFjh49+s4+ly9fRuvWrfH555+jXr16MDMzg5ubG2JiYiodl7ri3nTZquxkIykpKcjPz0eTJk3e+VnTpk0hlUrx9OnTd35W0c+jInzoMyrv8RV9/ykpKSgoKECjRo3e2e+/x1bmb2LFihW4du0a7Ozs4OLigkWLFuHBgwcVel+EEPIxGzduhL6+Prp06YLbt2+X+VlVr9/v+/7/2He1svKF8lQkh6D84f2qmlMAVcsrtCWnACr+/imvIHzQyjHgwOvJK5ycnLBr1y58/fXX2LVrFziOe2f28y+++AJbt27FtGnT4O7uDnNzczAMg4EDB0Iqlb7T7r+fbH9IZdv9902Bf3v75fsxb9scOnQohg8fXu4+LVu2rFBb/5aYmIj69eujYcOGuHbtGnJzc8udZXPGjBlYs2YNDAwMEB8fDz8/Pzx48KDMUm+nTp2Cn58fTE1NERkZibp162LPnj0IDAzEo0eP5Lr7bGlpidLSUuTk5MDU1FT2eps2bfD06VOYmZlVue3KtJGRkQFjY+MKf07kVdHzKOL3IO9nVN7jK6syfxP9+/eHt7c3Dh48iODgYKxcuRLLly/HgQMHFDZLMSFEuJo1a4YTJ06gY8eO6NSpE6KiomRPw6t6/X7f9//HvmuVlS+UpyI5hLrmD8pU0Wsy5RTKO74qKK8giqK1BTjw+in4/PnzcfXqVezcuRONGjVC+/bty+yzb98+DB8+HKtWrZK9VlhYiMzMTLnOrch2ra2tYWZmhmvXrn1wH1NTU0gkEoXOBJ6YmIhWrVph8+bNaNeuHXr16oVz5869s9SXk5OT7N8Mw6C4uBjPnz9/5wL6ww8/wM3NTfbawIEDMWPGDNy+fRtt27Z9bxx//PEHjhw5gsOHD+PWrVvo168fVq5cKVs/9e35Hz58WCZx0NfXR926deX6HVSmjYcPH6Jp06aVPoe1tTWMjY3feTICvJ5tViQSldt1saIU8XtQpoq+/2rVqsHIyAh37959Z7//HlvZvwlbW1tMnDgREydOxKtXr9CmTRt8//33dKEkhCiEi4sLDh06hICAAHTq1Annzp2TPT1TxvX7fVR5vorkEMrOH4AP5xDvyx+UqaLX5KrmFIBy8wp1zykAyiuIetPaLujA/7uhL1iwAJcvXy537W8dHZ137patWbNG7mUxFNmuSCRCz549cfToUVy4cOGdn3McBx0dHfTp0wf79+8vt1BPSUl557WPLSMikUhw8+ZNtGjRAtbW1jhw4ACuXbuGCRMmlLv/xIkTYWRkhPbt20MsFqNFixayn+Xk5OD27dtwcXEpc8zdu3eRnp5ebrf2f0tMTETLli0RHR2NPn36YNu2bbLiGwDc3d0BoNzfjyolJCTAw8Oj0sfp6Oigc+fOOHz4cJl5C5KTk7Fz5054eXnJdadZ3VX0/evo6MDf3x+HDh0q89m9efMmgoKC3mmzIn8TEonknWEhNWvWRO3atVFUVKTAd0kIEbqOHTti165duHfvHrp06YLs7OwqXb/loYjzVWQZssrkEMrMH4AP5xDqkj+Up6o5BUB5BeUVRJ1p9RNwe3t7eHh4yNZQLK8A79atG/7880+Ym5ujWbNmiImJwZkzZ8rcea0KRbe7dOlSBAcHw8fHB2PHjkXTpk3x4sUL7N27F5GRkahevTp++OEHhIaGwtXVFWPGjEGzZs2Qnp6OhIQEnDlzBunp6WXa/NgyInfv3kVhYaHsQti2bVv89ttvGDlyJNq2bVtmiTcAWL9+PdasWYOwsDBcu3atzJils2fPwsfHByLR/+/5FBQUYOjQoZg7dy7Mzc0/+P4TExNRq1Yt9OjRA3FxcWUm1AAABwcHNG/eHGfOnMHnn3/+0d8n8PpOe0WXUamIixcvIj09HT169KjS8UuWLMHp06fh5eWFiRMnQldXFxs3bkRRURFWrFihkBjVWUXf/7fffotTp07B29sbEydORGlpKdasWYNPPvlENuHPWxX5m8jJyUHdunXRt29fODs7w8TEBGfOnEF8fHyZHiyEEKIIvXr1wubNm/H555+je/fusqe7lbl+y0ve81VkGbLK5BDKzB+AD+cQH8of1q5di8zMTNlEWkePHsWzZ88AvB5q+O9zq1tOAVBeQXkFUVuqm3CdH+vWreMAcC4uLuX+PCMjgxs5ciRnZWXFmZiYcP7+/tytW7e4+vXrc8OHD5ft93bZg5SUlHfaKG+ZDnnbLa/Nx48fc8OGDeOsra05AwMDzsHBgZs0aRJXVFQk2yc5OZmbNGkSZ2dnx+np6XG1atXiOnbsyG3atOmduPGRZUT27NnDAeCuX79e5vWJEydyenp6XHh4+HuP7datG3f8+HHZf48bN67M8h3FxcVcQEAAN3jwYNkyah9ibW3NeXt7c+bm5u89708//cSZmJiUuwTcf+Xk5HAAuIEDB35034qaPXs2V69evQq9n/ctGZKQkMD5+/tzJiYmnLGxMceyLBcdHf3O8R/6PMrjQ8uQVeQzWp7KHF/R9x8eHs61bduW09fX5xwcHLgNGzbIzvNfH/ubKCoq4r766ivO2dmZMzU15apVq8Y5Oztz69ev/8hvixBCPuzt91x5S4j++OOPHACuW7duXElJSYWv3+/7Tq3sd3VFzifPMmRVzSEUnT9w3MdziPflD/Xr1+cAlLv9+3eirjkFx1XsuqqsnILj3r8MmSpyCo6jvIKoJ4bjlDhbARGsrl27omvXrpgyZQqA13eYo6KiYGtrC6lUisGDByMvLw8HDx6Eru6HO2IkJyejQYMGyMzMxHfffYfz58/j9OnT7+yXlZUFBwcHrFixAqNGjfpgmydOnEC3bt1w5cqVMl3dqqqoqAgNGjTAnDlzMHXqVLnbI4QQQoRIkfkDULEcojL5Q3kopyCEVIZWjwEnqpGVlYWdO3ciNzcXpaWl2Lt3L0JDQ9GhQwcAr8eKmZmZwdbWFgAwbtw4Wff5/148R4wYgREjRpR5LTExEU2bNoWBgQGmTZuG6OhoxMbGvhOHubk5Zs2ahZUrV5Y70/y/hYaGYuDAgQq5UALA1q1boaenV+E1NAkhhBChU2T+AFQ9h6hM/lAeyikIIZVBT8CJ3LKzs9GjRw9cunQJHMfB0dER33zzDXr37g0A+Pnnn/Hy5Uv88MMPePz4MRo0aABDQ8MyS0icPHkS3t7e8PPzw4ABAzBmzBjZz1avXo1Lly5hx44dAICpU6fi3r17OH78uGrfKCGEEEIURpH5AwDKIQghGoEKcKJ0Xbp0wZw5c+Dr6/vB/UpLS9GyZUtcuXIFenp6qgmOEEIIIWqpovkDQDkEIURzaPUs6EQ9iMVieHp6fnQ/XV1d3LhxQwUREUIIIUTdVTR/ACiHIIRoDnoCTgghhBBCCCGEqABNwkYIIYQQQgghhKgAdUEnhBDyXoWFhSguLparDX19fRgaGiooIkIIIYRoI6HkHFSAE0IIKVdhYSHs65vg5SuJXO3UqlULDx8+VPsLIiGEEEL4IaScgwpwQggh5SouLsbLVxI8vtgAZqZVG7GUnSNF/baPUFxcrNYXQ0IIIYTwR0g5BxXghBBCPsjElIGJKVOlY6Wo2nGEEEIIER4h5BxUgBNCCPkgCSeFpIrrZUg4qWKDIYQQQojWEkLOQQU4IYSQD5KCgxRVuxpW9ThCCCGECI8Qcg5ahowQQgghhBBCCFEBegJOCCHkg6SQoqqduqp+JCGEEEKERgg5BxXghBBCPkjCcZBwVevWVdXjCCGEECI8Qsg5qAAnhBDyQUIYj0UIIYQQ/gkh56ACnBBCyAdJwUGi5RdDQgghhPBPCDkHTcJGCCGEEEIIIYSoAD0BJ4QQ8kFC6A5GCCGEEP4JIeegApwQQsgHCWFCFEIIIYTwTwg5BxXghBBCPkj6ZqvqsYQQQgghFSGEnIPGgBNCCCGEEEIIISpAT8AJIYR8kESOGUmrehwhhBBChEcIOQcV4ESpOE4KSJ4A0lcAJwFEZoCuIxjGgO/QCCEVJOFeb1U9lhBCCCGkIoSQc1ABThSO44qBwmBwBXuAkisAV/CfPUTgdBuCMewGGPUDo2PFS5yEkIoRwngsQohmKy4pxZ2Hr3D7fjJepGRBIuFQzVgfjvWt0dSxFmyszPgOkRBSAULIOagAJwrDcRxQeBxc9mKAy8DrKQbK+1OQAqV3weX+AuT+Cs54KBiT6WBExiqOmBBCCCGaLCk5E/tOXsKJsOvIyS18734tneqgd5dW6OjhBJGIUWGEhBBSFhXgRCE4aQ64rFlA0VkAby9sH7sP9ebn+X+CKzwD1PgVjF4LJUZJCKkKKRhIULWEVVrF4wgh5EOkUg67j13Apn+iUFxc+tH9r956jqu3nmPfiUv4elIX1K9joYIoCSGVJYScg2ZBJ3LjpNng0ocARWFvX6lkC1JA+gJc2hBwxRcUHB0hRF5STr6NEEIUqbCoBDOX7sfaHeEVKr7/7dqdJIz8agfOxd9TUnSEEHkIIeegApzIheMk4DLGAaV3AUjkaEkKoBhcxihwpY8UExwhRCEkb+5GV3UjhBBFKSmRYPYPBxF3+VGV2ygqLsW8VUcQk/BAcYERQhRCCDkHFeBEPvnbgZKLkK/4fksKcMXgsma9nj2dECI4ERERCAwMRO3atcEwDA4dOvTRY8LCwtCmTRsYGBjA0dER27ZtU3qchBB+bNkbjQuJT+Rup7RUiu9+PYG0jDwFREUI0UR85RxUgJMq4yQvweWsUnCrEqDkMlCwR8HtEkKqSpV3o/Py8uDs7Ix169ZVaP+HDx8iICAALMvi8uXLmDZtGkaPHo2goKCqvFVCiBq7/SAZfx+OV1h72bmF+HHzaYW1RwiRnxByDpqEjVQZl78Linny/V8MuLw/AKMBYBjN6EpCiDaTcgykXBUnRKnkcV27dkXXrl0rvP+GDRtgb2+PVate3wxs2rQpIiMjsXr1avj7+1fq3IQQ9bbjQCwkEsX2kIs4fw/3H6egYX1rhbZLCKkaIeQc9AScVAnHlQL5u6CcFfc4QPIYKD6vhLYJIZWlzuOxYmJi4OfnV+Y1f39/xMTEKPW8hBDVSknPxbn4+0pp+0DQZaW0SwipPCHkHPQEnFRN6V2Ay1TiCXTAFceCMXBV4jkIIaqSnZ1d5r8NDAxgYGAgd7svX76EjY1NmddsbGyQnZ2NgoICGBkZyX0OQgj/4i49VPjT77eiL9JkbIRoE3XPOegJOKmakutKPoEUKLmq5HMQQipCApFcGwDY2dnB3Nxcti1btoznd0UI0SS3HyQrre1XaTnIyKLJ2AhRB0LIOegJOKkSTvIIrz8+lVt/sxJnAErpjjQh6oCTYzwW9+a4p0+fwszMTPa6Iu5EA0CtWrWQnFw2MU9OToaZmRk9/SZEizxJSldq+4+fp6OGeTWlnoMQ8nFCyDmoACdVwxUDSl9rr1jJ7RNCKkKecVVvjzMzMytzMVQUd3d3nDhxosxrp0+fhru7u8LPRQjhT3GJMiZ9VV37hJCKEULOQV3QSdUwBgA4FZyDEMI3CSeSa6uM3NxcXL58GZcvXwbwesmPy5cv48mT1+v+zp07F8OGDZPtP378eDx48ACzZs3CrVu3sH79euzZswfTp09X2PsnhPDPQF+5z4yU3T4hpGKEkHNQAU6qhNF1gPK6nwOACNBtrMT2CSHq6MKFC2jdujVat24NAJgxYwZat26NBQsWAABevHghuzACgL29PY4fP47Tp0/D2dkZq1atwu+//05LkBGiZRrUtVRq+/ZKbp8Qon74yjnodh+pGt3mSj4BA0avhZLPQQipCCkYSKt4v1ZayZ4yvr6+4Lj3H7Nt27Zyj7l06VJlQyOEaBCnhjYf36mKbGuawcyU5owgRB0IIeegApxUja4DIKoJSF8p6QQSQN9LSW0TQipDEeOxCCFEHm6t7aGvp6OUsdodXBopvE1CSNUIIeegLuikShhGB4zxECjnI8QAuk0AvZZKaJsQUlmqHI9FCCHlqW5mDNa9icLbZRigl38rhbdLCKkaIeQcmhElUU9G/QEoY6I0Dky1sWAYzbiLRQghhBDlG97HFfoKnizNv0Mz2NnWUGibhBDyIVSAkypjdCzBmH2j4FZ1Xnc9N+ym4HYJIVX1ejxW1TdCCFGE+nUsMbq/h8Las6xRDVNHihXWHiFEfkLIOagAJ/Ix6gcYiKGYj5IOwJiCMV9KT78JUSNSiCCp4lbViVQIIaQ8g7q3B+sm/yophga6+P7L7jAzMVRAVIQQRRFCzqEZURK1xTAMmOqrAf32kO/jpAMw1cBYbAejU0tR4RFCFEAI47EIIZpBJGKwaFoAOns3rXIbpiaGWPVNX7RwqqPAyAghiiCEnEMzoiRqjWGMwNT4/fXTcABV+ljpNgZjuReMXtUvqIQQQgjRfrq6Olg4NQDzv+gK00o+wfZs64C/Vo9Aq2Z1lRQdIYR8GC1DRhSCYQzAmC8GZ9gFXPYiQPIYgA6A8pcLkUoBkQgAYwym2jig2hgwDH0cCVFHUjm6dVV2TU5CCKmoLj6fwL2NA46euYrDp68i6VVW+TtyUvi4NUGfLq3RtkU91QZJCKkUIeQcVPEQhWIMPAGrYKA4DlzBPqA4HpC+KLNPYZEeYi/mwdd/BRijbmBExjxFSwipCAnHQMJVcU3OKh5HCCEVYW5qhKG9XDG0lyuSkjNx+0Eykl5lQSLhYGKsj6sJkfhh8RwE73iFatWq8R0uIeQjhJBzUAFOFI5hGMDADYyBGwCAk2YD0hSAkwIiU8RF3EDHPh1x5YoTWrak4psQdfd2cpOqHasZd6MJIZqvtk111LapXuY1p3oG+PabfERFRaFz5878BEYIqTAh5Bw0BpwoHSMyA6PbEIxeIzA6teDm5g59fX2EhobyHRohhBBCtFjTpk1hY2ODsLAwvkMhhBAAVIATHhgZGcHd3Z0KcEI0hJQTybURQghfGIaBr68v5RyEaAgh5ByaESXROizLIjw8HBJJ+ZO0EULUR1XX45SnGxkhhCgKy7KIj49HTk4O36EQQj5CCDmHZkRJtA7LssjMzMSVK1f4DoUQ8hFS/H9SlMpuUr6DJ4QIHsuykEgkiIyM5DsUQshHCCHnoAKc8MLV1RWGhobUJYwQQgghStWoUSPUrl2bcg5CiFqgApzwwsDAAB4eHjQpCiEa4O2anFXdCCGETzQOnBDNIYScQzOiJFqJZVlERESgtLSU71AIIR8g4URybYQQwjeWZZGQkICsrCy+QyGEfIAQcg7NiJJoJZZlkZ2djUuXLvEdCiHkA6Rg5NoIIYRvLMtCKpXi3LlzfIdCCPkAIeQcVIAT3rRv3x7GxsbUJYwQNSeEu9GEEO3m4OAAOzs7yjkIUXNCyDk0I0qilfT19eHl5UUXQ0IIIYQoFcMwYFmWcg5CCO+oACe8YlkW586dQ0lJCd+hEELeQwhrchJCtJ+vry8uX76M9PR0vkMhhLyHEHIOzYiSaC1fX1/k5eXh4sWLfIdCCHkPKcfItRFCiDpgWRYcxyEiIoLvUAgh7yGEnIMKcMKrtm3bwsTEhLqEEaLGpHLcidaUJUEIIdqvQYMGaNCgAS2BSogaE0LOoRlREq2lp6cHb29vKsAJIYQQonQ0DpwQwjcqwAnvWJZFVFQUiouL+Q6FEFIOKSeSayOEEHXBsiyuXr2K1NRUvkMhhJRDCDmHZkRJtBrLssjPz8f58+f5DoWoMY4rAldwBNKseZCmBkKa3ArSly0gTW4HadogSLOXgSuKAcdxfIeqdSRg5NoIIURd+Pr6AgDCw8P5DYRojKycAiTeeo6LiU9w7XYScvOK+A5Jqwkh59DlOwBCWrduDTMzM4SFhcHLy4vvcIia4aT54PI2APl/A1wOXn9tlf5rhyKg5CJQcgVc/lZApx5QbQJg1BsMoxlfxOpOnrvKmnI3mhAiDHZ2dmjYsCFCQ0PRp08fvsMhaurRszQcDLqMqIv38eJVdpmfMQxQx6Y6vF0c0cu/FerYVOcnSC0lhJxDM6IkWk1HRwcdOnSgMVnkHVxxPLjUT4G8TW+Kb6BM8V3Gm9clT8FlzwWXMQKcJEkVYRJCCNEgLMvSRGykXBlZeZi/6giGTNuKfScvvVN8AwDHAc9eZmLXkQsY+MUfWLruFD0VJ5VCBThRCyzLIjo6GkVF9AVGXuMKDoNL/wyQvgQgrcyRr/+n+Dy41J7gSm4rIzxBkUCeLmGEEKJeWJbF9evX8erVK75DIWrk/JVHGDp9G0Ji7lT4GKmUw/HQaxg6fSuu3aGb/ooghJyDCnCiFliWRWFhIWJjY/kOhagBrjAYXNYsvC68K1N8/5sE4HLApX8GrvSJAqMTHiFMiEIIEQ6WZQGAnoITmeiEB5i17CAyswuqdHxKei6mfbcXV289V3BkwiOEnEMzoiRaz9nZGTVq1KBu6AScJBlc1mwFtfamCM+aCY7TlPui6kfCieTaCCFEndja2qJJkyaUcxAAwNMXGZi/6ghKSuXLEwoKSzD7h4NIy8hTUGTCJIScQzOiJFpPJBLBx8eHLoYEXPYCgCuErCu53CRAyWUg/y8FtUcIIUTT0XrgBHjdhXzpulMoLHrf/DKVk51biBUbgxXSFtFeVIATtcGyLGJjY1FQULXuP0TzcSU3gaJQQAmjeLjc9eC4EoW3KwQcGEiruHEasiQIIURYfH19cfv2bSQl0bhdIQuNva3wbuORF+7j4jUa+lZVQsg5qAAnasPX1xfFxcWIiYnhOxTCEy5/FwAdJTWeARSeVk7bWk4I3cEIIcJC64ETADhw6rKS2r2klHaFQAg5h2ZESQShefPmsLS0pC5hAsVxHFB4Asp4+v2aDjgqwKtEyjFybYQQom5sbGzQrFkzyjkE7FVaDi7feKaUts/F30dBYbFS2tZ2Qsg5qAAnakMkEsHX15cuhkIlfQFw7663qThvxoITQgghoHHgQnfr/kultS2RSHH3UYrS2ieajQpwolZYlsX58+eRl0czSAqOKtbrlj4Hx9EcA5UlgUiujRBC1BHLsrh37x6ePVPOU1Ci3u4puUC++5DWma8KIeQcmhElEQyWZVFSUoLo6Gi+QyGqxqnopos0XzXn0SJC6A5GCBEeHx8fAKCn4AKVm1+k0e1rKyHkHFSAE7XStGlT1KxZky6GQsQoafI1vs6jRaQQybURQog6srKyQosWLSjnECiRSLnFmq4OXf+qQgg5hy7fARDybwzD0DhwoRLVUsFJDAHGTAXn0S4SjoGkineVq3ocIYSoAsuyOHr0KN9hEB7YWpsrtf1aNSnfqAoh5ByacZuACArLsoiPj0dOTg7foRBV0nOC0r+S9JqCYehrjxBCyGssy+Lhw4d4/Pgx36EQFWvS0Ea57Tuo4sEC0USUiRK1w7IsJBIJIiMj+Q6FqBDDGAG6TgCUdfdSB9Bvr6S2tZsQxmMRQoTJx8cHDMNQzzsBamxfE6Ymhkpp28bKFHVslPuEXVsJIeegApyoncaNG8PW1pYuhgLEGA8EwCmpdQkYo75Kalu7cZwI0ipuHEeXGUKI+qpRowZatWpFOYcA6evpoqvPJ0ppu0cnZzCMZhSD6kYIOYdmREkEhWEYsCyLsLAwvkMhqmYYCDDVlNCwDqDvAUa3gRLa1n4SMHJthBCizt7OPcNxyroBTNRV309bQ19fsVNimRgboLtfS4W2KSRCyDmoACdqiWVZXLx4EVlZWXyHQlSIEVUDY/q1MloGYzZfCe0SQgjRdCzL4unTp3jw4AHfoRAVq2NTHaP6uyu0zSkjfFHD3FihbRLtQgU4UUu+vr6QSqU4d+4c36EQFcsp6YyLiUYoLVXckwjG9Eswug0V1p7QSDl5xmTxHT0hhHxYhw4dIBKJqOedABUWFuL47l+QmXxHIe2JPZogQNxCIW0JlRByDirAiVpq2LAh6tatS2OyBObx48fw9PJCn8+foKC0DgAFrNlt1A8w/lz+dgSsqmOx3m6EEKLOzM3N0aZNG8o5BCYlJQV+fn44dOggvpnYEW2a28nVXgcXRyz44lMFRSdcQsg5aB1wopbejgOni6FwxMfHIzAwEEZGRjgVFAWzenXAZUwESuKr0JoIgBQwHgXG9CuaCEVOUjCQVnFcVVWPI4QQVWJZFn///Tc4jqNrhgDcunULAQEByM3NRWhoKNzc3NC3pBR/7InGrsPxkFTiUaqerg4+7++BIT3aQ0dHMwpAdSaEnIM+JURtsSyLy5cvIyMjg+9QiJLt378fPj4+sLe3R1xcHJo1awZGZA7G4k8wpvMA6KNiX1dv9hFZg6mxHSKz2bTuNyGEkI/y9fVFUlIS7t69y3coRMlCQkLg7u4OQ0NDxMXFwc3NDcDrWdEnDOmAjUuHoIOLI3REHy7m9HR14OfphC0rP8Ow3q5UfJMKoyfgRG2xLAuO4xAREYEePXrwHQ5RAo7jsHLlSsyePRsDBgzA1q1bYWRkJPs5w4iAasMAwwCgYC+4/L8BafKbn+rg9Zrh0jcbAN1mYKoNAwy7gmEMVPxutJeEYyCp4tqaVT2OEEJUydvbGzo6OggNDUXjxo35DocoyZYtWzBu3DiwLIu9e/fC3PzdtbqbOtbCslk9kZyajbhLj3DrQTKePE9DUYkEhga6aFDXEk4ONnBv4wCL6spYuUXYhJBzUAFO1FaDBg3QoEEDhIaGUgGuhUpKSjBhwgT88ccfmDdvHr799luIROXfPWZ0LAGT8UC1cYDkOVB6HZA8BbgSgDECdB0BvU/AiGqo+F0IgzzjqjRlPBYhRNhMTU3Rrl07hIaGYty4cXyHQxRMKpXi66+/xvLlyzFu3DisWbMGenp6HzzGxsoM3Tu1RHcVxUheE0LOoRlREsF6uzYn0S4ZGRno0qULduzYgW3btmHx4sXvLb7/jWEYMLp1wRj6g6k2GozJBDDVRoAx8KLiW4mkqOpspFUfx7Vu3To0aNAAhoaGcHV1xfnz5z+4/88//4wmTZrAyMgIdnZ2mD59OgoLC6t0bkKIMLEsi7CwMFoPXMvk5+ejf//+WLFiBVatWoXffvvto8U34Y8Qcg4qwIlaY1kWV69eRWpqKt+hEAV58OABPDw8cOnSJZw+fRrDhw/nOySiZnbv3o0ZM2Zg4cKFSEhIgLOzM/z9/fHq1aty99+5cyfmzJmDhQsX4ubNm/jjjz+we/dufP21MtaUJ4RoK5ZlkZycjFu3bvEdClGQly9fgmVZnDx5EgcOHMCMGTNokj1SBh85BxXgRK2xLAsACA8P5zkSogjR0dFwdXVFaWkpYmNj4ePjw3dIpAK4NzOSVmXjqnA3+qeffsKYMWMwcuRINGvWDBs2bICxsTG2bNlS7v7R0dHw9PTE4MGD0aBBA3Tu3BmDBg366B1sQgj5N09PT+jq6lLPOy1x7do1uLq64unTp4iIiEDPnj35DolUgBByDirAiVqzs7NDw4YNERYWxncoRE67du2CWCxG06ZNERsbS5PcaJAqdwV7s1VGcXExLl68CD8/P9lrIpEIfn5+iImJKfcYDw8PXLx4UXbxe/DgAU6cOIFPP6X1WAkhFVetWjW4uLhQAa4FgoKC4OHhgerVqyMuLg5t27blOyRSQULIOWgSNqL2aD1wzcZxHJYsWYIFCxZg6NCh+P3332FgQDOUaxJFTIiSnZ1d5nUDA4NyPwepqamQSCSwsbEp87qNjc17u4UOHjwYqamp8PLyAsdxKC0txfjx46kLOiGk0liWxcaNGyGVSis0NwlRP7/99hu++OIL+Pv7459//oGpqSnfIZFKEELOQd8sRO35+vri+vXr7x2LQdRXUVERhg8fjgULFuC7777Djh07qPgWKDs7O5ibm8u2ZcuWKaztsLAwLF26FOvXr0dCQgIOHDiA48ePY/HixQo7ByFEGFiWRWpqKm7cuMF3KKSSJBIJZsyYgYkTJ2LixIk4fPgwFd8Cpe45Bz0BJ2rv7TjwsLAw9O/fn+doSEWlpaWhd+/eiI2Nxc6dOzFo0CC+QyJVVJVuXf8+FgCePn0KMzMz2evvuxFjZWUFHR0dJCcnl3k9OTkZtWrVKveY+fPn47PPPsPo0aMBAC1atEBeXh7Gjh2Lb775hp5iEUIqzMPDA/r6+ggNDUXz5s35DodUUG5uLoYMGYJjx47h119/xRdffMF3SKSKhJBzUFZC1F7t2rXRuHFj6oauQe7cuQM3NzfcuHEDISEhVHxruKpOhvJ2AwAzM7My2/suhvr6+mjbti3Onj37//NLpTh79izc3d3LPSY/P/+dC56Ojg4A0HJChJBKMTIygpubG+UcGuT58+fo0KEDQkJCcOTIESq+NZwQcg56Ak40Ao0D1xzh4eHo3bs3atasidjYWDRs2JDvkIicFHE3ujJmzJiB4cOHo127dnBxccHPP/+MvLw8jBw5EgAwbNgw1KlTR9alLDAwED/99BNat24NV1dX3Lt3D/Pnz0dgYKDsokgIIRXFsizWrFlD48A1wOXLl9GtWzcwDIPIyEg4OzvzHRKRkxByDirAiUZ4OynKixcvYGtry3c45D127NiB0aNHw9vbG/v27UONGjX4DokogKovhgMGDEBKSgoWLFiAly9folWrVjh16pRskpQnT56USYrnzZsHhmEwb948PH/+HNbW1ggMDMT3339fpZgJIcLm6+uLb7/9FlevXkWrVq34Doe8x7FjxzBw4EA4OTnh6NGjlB9qCSHkHAxH/fOIBng7FoPGEqsnqVSKhQsXYsmSJRg1ahR+++036Onp8R0WkVN2djbMzc3R9dQY6FXTr1IbJXnFONllM7KyssqMxyKEEHVVWFiI6tWrY9myZZg+fTrf4ZD/4DgOv/76K2bMmIHu3bvjr7/+QrVq1fgOi8hJSDkH9ashGsHGxgZNmzalbuhqqLCwEIMHD8aSJUuwfPlybN68mYpvLaPKNTkJIYRvhoaG8PDwQFhYGN+hkP8oLS3FF198gWnTpmHGjBnYv38/Fd9aRgg5B3VBJxqDZVkEBwfzHQb5l1evXqFnz564dOkS9u3bhz59+vAdElECVXcHI4QQvrEsi1WrVkEikdBcEmoiOzsbAwcORHBwMDZu3IixY8fyHRJRAiHkHPQEnGgMlmVx7949PHv2jO9QCIAbN27Azc0NDx48QHh4OBXfWoxD1WclpTFOhBBNxLIssrKycPnyZb5DIXg9DtfLywtRUVE4efIkFd9aTAg5BxXgRGP4+voCAHUJUwNnzpyBh4cHqlWrhri4OLi4uPAdEiGEEKIw7du3h5GREQ19UwPx8fFwcXFBTk4OYmJi0KlTJ75DIkQuVIATjWFlZYUWLVrQxZBnv//+O7p27Qp3d3dERUWhfv36fIdElEwI47EIIeTfDAwM4OnpSTkHzw4cOAAfHx/Y29sjNjYWzZo14zskomRCyDmoACcahdYD549UKsXs2bMxZswYjBkzBkePHlXrGSaJ4gjhYkgIIf/FsizOnTuH0tJSvkMRHI7jsGLFCvTp0weBgYEICQmRLQtFtJsQcg4qwIlG8fX1xcOHD/H48WO+QxGU/Px89OvXDytXrsTq1auxbt066OrSHI5CIYSLISGE/BfLssjJyUFCQgLfoQhKSUkJxo4di9mzZ+Obb77Brl27YGRkxHdYREWEkHNQAU40io+PDxiGoafgKvTixQv4+Pjg1KlTOHToEKZNmwaG0YwvOEIIIaSq2rVrh2rVqlHOoUKZmZno2rUrtm/fjq1bt2LJkiUQiahcIdqFPtFEo1hYWMDZ2ZkuhiqSmJgIV1dXJCUl4dy5c+jevTvfIREeCOFuNCGE/Jeenh68vb0p51CRhw8fwsPDAwkJCQgODsaIESP4DonwQAg5BxXgROOwLIuwsDBwnKYsNqCZTp48CU9PT1haWiIuLg5t2rThOyTCE45j5NoIIURT+fr6IjIyEiUlJXyHotViYmLg6uqK4uJixMTEyFa+IcIjhJyDCnCicViWxZMnT/Dw4UO+Q9Fa69atQ7du3eDr64tz586hbt26fIdEeFTV9TjfboQQoqlYlkVeXh7i4+P5DkVr7d69GyzLokmTJoiNjUWTJk34DonwSAg5BxXgRON4e3tDJBJRlzAlkEgkmDZtGiZPnowpU6bg4MGDMDEx4TssQgghhBdt2rSBqakp5RxKwHEclixZgoEDB6Jfv344c+YMrKys+A6LEKWjApxonOrVq6N169Z0MVSw3Nxc9OzZE2vWrMG6deuwevVq6Ojo8B0WUQNCGI9FCCHl0dXVRYcOHRAWFsZ3KFqlqKgII0aMwPz58/Htt99ix44dMDAw4DssogaEkHPQOkJEI7Esi507d4LjOJqRWwGePXuGwMBA3L9/H8ePH0eXLl34DomoEXnGVWnKeCxCCHkflmUxf/58FBUVUZGoAGlpaejduzdiY2Px999/Y/DgwXyHRNSIEHIOegJONBLLskhKSsK9e/f4DkXjJSQkwNXVFenp6YiKiqLim7xDCHejCSHkfXx9fVFQUIDz58/zHYrGu3v3Ltzd3XHjxg2EhIRQ8U3eIYScgwpwopG8vb2ho6ND3dDldOTIEXh7e6NOnTqIi4tDixYt+A6JEEIIUSutWrVC9erVKeeQU0REBNzc3CASiRAbGwtPT0++QyKEF1SAE41kamqKdu3a0cWwijiOw+rVq9GzZ0907doVYWFhqFWrFt9hETUlhCVBCCHkfXR0dNChQwfKOeSwY8cO+Pn5wdnZGTExMWjYsCHfIRE1JYScgwpworFYlkVoaCitB15JpaWlmDRpEmbMmIFZs2Zhz549MDY25jssosY4ObqCacrFkBBCPoRlWcTExKCwsJDvUDQKx3FYsGABhg8fjs8++wynTp1CjRo1+A6LqDEh5Bw0CRvRWL6+vvjhhx9w69YtNG3alO9wNEJ2djb69++Ps2fPYvPmzRg9ejTfIRENwAGo6n0uuj1G1F5xMXDtGnDxIvD48ev/NjICmjQB2rYFGjUCRPS8QuhYlkVRURFiY2Ph6+vLdzgaobCwECNHjsQ///yDH374AbNmzaKJc8lHCSHnULsCnOOkQHEMuOILQEkiIHkCoBRgqgG6TcHoNQcMWDC6dnyHSnjm6ekJXV1dhIaGUgFeAY8fP0a3bt3w9OlTnDp1Ch07duQ7JKIhpGDAoGpJk7SKxxGidNeuAb/9Bvz5J5CT8/79atcGxo4Fxox5/W8iSC1atICFhQVCQ0OpAK+AlJQU9OjRA5cuXcLevXvRt29fvkMiGkIIOYfa3NLluGJweVvBpbDgMkYCeRuA4nOA5BEgeQaU3gYKj4LL+R5cqh+k6aNfF+lEsExMTODi4kJrc1bA+fPn4erqiry8PMTExFDxTQgRrsxMYNQooEULYP36DxffAJCUBCxaBDg4AD/8AJSWqiJKomZEIhF8fHxoHHgF3Lx5E66urnjw4AHCw8Op+CbkP9SiAOdKboBL6wku5wdA+uLNqxK825Hg7WscUBwFLn0wpFnfgZPmqzReoj5YlkVYWBiNA/+Affv2wcfHBw4ODoiLi6PeAqTShDAhChGIuDigeXNgyxbZS5wRA66nCaSLrCDdWRvS/XUg3W4L6SxLcKwxuLeZUlERMHcu4OkJPH/OT/yEVyzLIjY2Fvn5lHe+z9mzZ+Hu7g5jY2PExcXBxcWF75CIhhFCzsF7Ac4VBoFL6wuUPkTleu5LXv9PwU5w6f3ASVKVER5RcyzLIiUlBdevX+c7FLXDcRyWL1+Ofv36oWfPnggJCYG1tTXfYRENJIQ1OYkAREQAHTvKimfORATpQitwl+3B/WYLjKsBsNUAD2Ogswkw3QLczjrg4hqAG1P9/4X4+fOAlxfw9Cl/74XwgmVZlJSUIDo6mu9Q1NIff/yBLl26wNXVFVFRUahfvz7fIRENJIScg9cCnCsMBZc5Fa+LaUkVW5ECpQ/ApX8GTpqtwOiIJnB3d4e+vj51CfuP4uJijBkzBnPmzMH8+fPx999/w9DQkO+wiIbiOPk2Qnh39y7QrRuQlwcA4NyMwIXWA8bXAMx0PnxsXT1w31mDO1IXXL03U+c8egT4+wP0JFRQPvnkE1hbW9PQt/+QSqWYM2cORo8ejdGjR+P48eMwNzfnOyyioYSQc/BWgHOSV+CyvoSsS7lcJIDkEbjsxQqIjGgSY2NjuLq6UgH+LxkZGejatSt27NiB7du347vvvoOIZvAlhAiVRAKMHCkb682JjcHtqg3U1atcO22NwB22A2f/5ribN4F58xQcLFFnDMPA19eXco5/yc/PR//+/bFixQr89NNPWL9+PXR11W6OZ0LUCn8FePZ8gCuA4iaMlwCFh8EV0pei0LAsi/DwcEilUr5D4d39+/fh7u6Oy5cv48yZMxg2bBjfIREtIITxWESLbdwIREUBALgGeuA22wKGVUx/aumC214bnMGbz/XPPwPx8YqJk2gElmVx/vx55Obm8h0K716+fAlfX1+cPHkSBw8exPTp02mZMSI3IeQcvBTgXMlVoCgUVe92/j4MuNxVNCGXwLAsi/T0dCQmJvIdCq+ioqLg5uYGqVSK2NhYdOjQge+QiJYQwsWQaCmpFPjpJ9l/cj/ZAMZypj6N9MHNsnzTIAesXi1fe0Sj+Pr6orS0FFFvbuoIVWJiIlxdXfH8+XOcO3cOPXr04DskoiWEkHPwU4Dn7QTwkTFXVWsZKL0DlFxWQttEXbm5ucHAwEDQXcJ27dqFjh07olmzZoiJiUGjRo34DoloESFMiEK01OnTwP37AACugxHgbqSYdj83B2fxJo/Ztw9ITlZMu0TtOTk5oVatWoLOOU6dOgVPT0/UqFEDcXFxaNOmDd8hES0ihJxD5QU4x0mAwhNQ/NPvt3TBFZ5QUttEHRkaGsLDw0OQF0OO47B48WIMHjwYAwYMQHBwMCwtLfkOixBC1MPRo7J/cp8pcFIoQxEwyOz1v0tKgOBgxbVN1JrQx4GvX78eAQEB8PHxQWRkJOrWrct3SIRoHNU/AZc8BFCoxBOU0hNwAXo7DlwiUdaNHfVTVFSE4cOHY8GCBViyZAm2bdsGAwMDvsMiWkgIM5ISLXXhwv//7W2s0KY5r389Tb94UaFtE/XGsiwuXryI7GzhrL4jkUgwffp0TJo0CV988QUOHToEExMTvsMiWkgIOYfqC/CSW9pxDqJWfH19kZWVhcuXL/MdikqkpaWhU6dO2LNnD3bt2oVvvvmGJj4hSvP6olbV8Vh8R08E7c3cIFwDPcBcwUPfWv5racerVxXbNlFrLMtCIpEgMjKS71BUIjc3F7169cKvv/6KtWvX4ueff4aOjjKGkhIijJxD9QU4p4q7hUXguFIVnIeoCxcXFxgZGQlibc47d+7Azc0Nt27dQmhoKAYOHMh3SETLCWFCFKKFJJL/r9NtrYRiwUIH3Ntms7IU3z5RW46Ojqhdu7YguqE/e/YM3t7eCA0NxbFjxzBp0iS+QyJaTgg5Bw+TsKnqlLTusZAYGBjA09NT6y+G4eHhcHNzg56eHmJjY+Hu7s53SIQQop7+3StIGatUctz/26WngYLCMAxYltX6nOPSpUtwdXVFWloaoqKi0LVrV75DIkQrqL5KFVkp/xyMGRiGCnChYVkWERERKC3Vzt4P27dvR6dOndCmTRtER0fDwcGB75CIQHByboTwQiQC3k5K+aRE8YMDn5WCeduktbVi2yZqj2VZXLp0CZmZmXyHohRHjx6Fl5cXateujbi4OLRs2ZLvkIhACCHnUH2VqveJUpuXSoEHT02QkJAAqVQZt7yJumJZFjk5OUhISOA7FIWSSqWYN28eRowYgeHDh+PkyZOoXr0632ERARFCdzCipVq3BgAwKRLghYJvzl75/4Syz2rWFNQkoOR1ziGVShEREcF3KArFcRx+/vln9OjRA126dEF4eDhsbW35DosIiBByDh6egNcCRMpbJonjgH/230Lbtm1ha2uLoUOH4s8//0QyrdGp9dq1a4dq1appVZewgoICDB48GEuXLsWKFSuwadMm6Onp8R0WERoh3I4m2snF5f//DspTaNPMqf+3N3HbNlhZWaFfv374/fff8fTpU4Wei6gfe3t71KtXT6vmniktLcXkyZMxffp0fPXVV9i7dy+MjRW7egAhHyWAnEPlBTjDMIDRAKWdWkeHwawF0QgNDcXnn3+OGzduYNiwYahVqxZat26NOXPmICQkBEVFRUo5P+GPnp4evLy8tOZi+OrVK4jFYhw5cgT79u3DV199RTOdE0JIZfxrkkpmW5biuqGnlgJHcwEAnIUFvg4JwZQpU/D06VOMGzcO9erVQ7NmzTB9+nScOnUKBQUFijkvURvaNg48OzsbgYGB2LhxIzZt2oTly5dDJKLhnIQoAy9/WYzxACW1rAPoe0PfyAG+vr5YtmwZEhIS8PLlS/z5559o3rw5tm7dio4dO8LS0hLdunXDmjVrcOfOHXCaMm89+SCWZXHu3DmUlJTwHYpcbty4AVdXVzx69Ajh4eHo3bs33yERIZOnK5iGdAcjWqpFC8DLCwDA3CkG/lTMSizMklQwxa/zBubzz+HGsvj2228RGxuLlJQU7N69G+7u7ti7dy+6du2KGjVqoHPnzli1ahWuXbtGOYeW8PX1xZUrV5Cens53KHJ5/PgxPD09ERMTg1OnTmHMmDF8h0SETAA5Bz8FuI4tUG00AEX/khgwZnPeedXGxkbWFf3FixdISEjAvHnzkJeXhy+//BJNmjSBg4MDxo8fj4MHDyKLlhPRWCzLIi8vDxcuXOA7lCo7c+YMPDw8YGpqiri4OLRv357vkIjAvV6Ts+obIbxauFD2T+a7FOBhsXztBeWC2Z3z+t9mZsC0aWV+bGFhgf79++OPP/7A06dPcf36dSxbtgwikQjz5s1DixYtYGdnh88//xy7d+9GWlqafPEQ3rAsC47jEB4ezncoVRYfHw9XV1fk5uYiOjoafn5+fIdEBE4IOQdvfUsYkymATn0Ailu6gzGZDkbX8YP7iEQiWVf00NBQpKen4+jRo+jWrRtCQkLQu3dvWFpawtvbG0uWLEF8fDxNrKJB2rRpA1NTU43tErZ582Z06dIF7u7uiIyMRL169fgOiRBBTIhCtJifHzB6NACAyePADHgOPK1iL6nofDATXv7/v3/6CahT5727MwxTpit6eno6goKCMGDAAJw/fx4DBw6EtbU1XFxcMH/+fERGRmrtSh7aqH79+rC3t9fYnGP//v3w8fGBvb094uLi0KxZM75DIkQQOQd/BTijD6bGZoAxg/xFOAMYBgLVRlX6SBMTkzJd0R88eIC1a9fCysoKK1asgIuLC2xsbDBo0CBs3boVSUlJcsZKlElXVxcdOnTQuIuhVCrFrFmzMHbsWIwbNw5Hjx6FmZkZ32ER8trbbl1V3Qjh26pVwCevV2FhnpaC+fQpcCK34sdLOGBdOphBSWAK3jxi6dsX+PzzSoVhZGRUpiv606dP8fvvv8Pe3h7r1q2Dt7c3LC0t0bt3b2zcuBGPHj2qVPtE9TRxHDjHcVixYgX69u2L7t27IyQkBDVr1uQ7LEJeE0DOwevsCoxufTCWuwGRTRVDefNLNuoHxny5Qtb+tre3l3VFT0tLQ0REBMaPH4979+5h1KhRqFOnDlq0aIGZM2fi9OnTKCws/HijRKV8fX0RFRWlMRPt5efno2/fvvjxxx/x888/Y+3atdDV1eU7LEII0R5mZkBwMODkBABgUiUQjXoB5rPnQHgeIH1Pv8UiKbA/G0zXpxAtSZON+0a3bsBffwFyToxZt25dWVf0lJQUxMbGYubMmXj16hUmTZoEe3t7NGnSBFOmTMHx48eRl6fYmdyJ/FiWxbVr15CSksJ3KBVSUlKCMWPGYPbs2Zg3bx527twJIyMjvsMiRFAYTg1mAuGkeeByVgIFO/H6aXhFunwzAGMOxnwJGMPOSo7wtdTUVJw+fRpBQUEIDg7GixcvYGRkBB8fH/j7+8Pf3x9OTk40UzXPLl68iHbt2uHcuXPwejP5jrp68eIFunfvjps3b2LXrl0IDAzkOyRCZLKzs2Fubo76v8+HyNiwSm1I8wvxePRiZGVlUa8Owr/UVGDUKODIkTIvczV1AGdDoIk+YMAAOVLgehFwtQhMjvT/OzIM8OWXwNKlgJKXhMzMzERISAiCgoIQFBSEx48fQ19fH15eXvD390fnzp3h7OxMOQfPnj17Bjs7O+zduxd9+/blO5wPysjIQN++fXHu3Dls3rwZw4cP5zskQmSElHOoRQH+FldyHVzeX0DhEQAleP1U/N9Ptd+MixLVBlPtM8CoLxiRueoDxevuO9euXZNdGCMiIlBcXAw7OztZMd6xY0fUqFGDl/iETCKRwMrKCjNmzMD8+fP5Due9rl69im7dukEqleLo0aNo3bo13yERUobsYrhZzovhGPW/GBIB4Tjg77+B2bOBygwrc3YGfvsNcHdXXmzvwXEc7ty5I8s5wsLCkJ+fDxsbG3Tu3Bn+/v7o1KkTdSPmSaNGjdC5c2esW7eO71De68GDBwgICEBycjIOHjwIHx8fvkMipAwh5RxqVYC/xUlzgZLrQOk1cJIkgCsFGGMweo0A3eaArqNCupsrUn5+PsLDw2UXx1u3bkEkEsHFxUVWkLu4uEBHR3GTzpH369GjB3JychASEsJ3KOU6ceIEBgwYgEaNGuHo0aOo84FJfAjhy9uLYb1NC+S6GD4Z+53aXwyJAJWUAIcPA1u2ADExQGbmu/vUrg34+gLjx79ezkxNnjYXFRUhMjISwcHBCAoKwpUrVwC8noj0bc7h7u4OfX19niMVhrFjxyIyMhI3btzgO5RyRUdHo0ePHqhevTqOHz+Oxo0b8x0SIe8QUs6hlgW4Nnjy5Imsq/qZM2eQmZmJ6tWrw8/PT3ZxtLOz4ztMrfXzzz9jzpw5yMzMhKFh1f6IlWXdunWYMmUKunXrhr///hsmJiZ8h0RIuYR0MSQCx3HAgwfAo0dAcTFgZPR6vHitWnxHViEvXrwoM0QuNTUVJiYmEIvFsifkjo4fXiWGVN2uXbswePBgvHjxArXU7DOza9cujBw5Ei4uLjh48CAsLS35DomQcgkp51Cvx8hapF69ehgzZgz27t2LlJQUREdHY+rUqXj27BnGjRuHevXqlVmaJD8/n++QtQrLsigqKkJsbCzfochIJBJMnToVkydPxrRp03DgwAEqvonm4Kq4EaIJGAZo2BDo2BHo2vX1U281K6Q+xNbWFsOGDcPff/+N5ORkXLhwAXPnzkVmZiamTZuGRo0aoWHDhpg4cSIOHz6MnJwcvkPWKr6+vgCAsLAwXuP4N47jsGTJEgwePBj9+/fH6dOnqfgmmkPLcw4qwFVAV1cX7u7uWLRoEWJiYpCSkoI9e/bAw8MD+/btQ9euXWFhYVFmaRLqmCCfFi1awMLCQm2WBsnJyUGPHj2wbt06rF+/HqtWraLhCERjCGFNTkK0hUgkQtu2bfH1118jPDwcaWlpOHToEPz9/REUFISePXvCwsICPj4+WLp0KS5evAipVPrxhsl72drawsnJSW0K8KKiIgwfPhzz58/H4sWLsX37dhgYGPAdFiEVIoScg7qg84zjONy8eVM2djw8PByFhYWoXbt2mYlV6K5l5fXu3RtpaWkIDw/nNY5nz56hW7duePDgAfbu3Qt/f39e4yGkot52B7PbsBAioyp2BysoxNPx36p9dzBChOL+/fuynCMkJAS5ubmwtrZGp06dZLOrq1s3ak0wYcIEhISE4Pbt27zGkZaWht69eyMuLg5bt27FoEGDeI2HkIoSUs5BT8B5xjBMma7o6enpCAoKwqBBg3DhwgUMGjQI1tbWcHFxwfz58xEZGYnS0lK+w9YILMsiNjYWBQUFvMWQkJAAV1dXZGRkIDo6mopvQgghvPp3V/S0tDSEhYVh9OjRuHXrFoYPHw5bW1u0atUKs2bNwtmzZ1FUVMR3yBqBZVncuXMHSZWZWV/B7ty5Azc3N9y4cQMhISFUfBOipqgAVzNGRkbo3LkzfvzxRyQmJuLZs2f4448/4ODggPXr18Pb2xuWlpbo3bs3Nm7ciEePHvEdstpiWRbFxcWIjo7m5fyHDx+Gt7c36tSpg7i4ODRv3pyXOAiRHyPnRghRR/r6+mW6oicnJ+Ovv/5Cy5YtsWPHDvj5+cHCwgIBAQH49ddfcfv2bRoi9x5vx4HzNfQtPDwc7u7u0NXVRVxcHDw8PHiJgxD5aX/OQQW4mqtTpw5GjhyJf/75B69evUJcXBxmzpyJV69eYdKkSbC3t0eTJk0wZcoUHD9+HLm5uXyHrDY++eQTWFtbq/xiyHEcVq9ejV69eqFr164ICwuj7nxEs1V1MhQ5JkVZt24dGjRoAENDQ7i6uuL8+fMf3D8zMxOTJk2Cra0tDAwM0LhxY5w4caJqJydEoGrWrIkhQ4Zgx44dSEpKwqVLl7BgwQIUFhbiq6++gpOTE+zt7TFu3DgcOHAAWVlZfIesNmrWrIlPPvmElwJ8x44d6NSpE1q1aoXo6Gg4ODioPAZCFEYAOQcV4BpER0enTFf01NRU7N+/H76+vjhy5Ai6desGCwsLiMViLF++HJcvXxb0nWqGYeDr66vSi2FpaSkmTpyIGTNmYPbs2dizZw+MjY1Vdn5ClELFF8Pdu3djxowZWLhwIRISEuDs7Ax/f3+8evWq3P2Li4vRqVMnPHr0CPv27cPt27exefNm1KlTp/InJ4QAeD2ZW6tWrTB79mycPXsW6enpOHbsGLp3746wsDD06dMHlpaW8PLywuLFi3H+/HlIJBK+w+YVy7IqnYhNKpVi/vz5GD58OIYNG4ZTp06hRo0aKjs/IUohgJyDJmHTEhzH4e7du7KJVUJDQ5Gfnw8bG5syk7nVrFmT71BVav369Zg6dSoyMzNRrVo1pZ4rKysL/fv3R0hICDZs2IBRo0Yp9XyEKJtsQpT1i+SbEGXiokpNiOLq6or27dtj7dq1r9uQSmFnZ4cvvvgCc+bMeWf/DRs2YOXKlbh16xb09PSqFCchpHIePXokyznOnj2L7OxsWFhYwM/PD/7+/vD39xfcTbADBw6gT58+ePLkCezs7JR6rsLCQowYMQK7d+/G8uXL8dVXX4FhNKP7LSHlEVLOQU/AtQTDMGjcuDG++OILHDt2DOnp6Th79iyGDx+Oq1evYujQobCxsUHbtm0xd+5chIWFobi4mO+wlY5lWZSWliIqKkqp53n06BE8PT1x/vx5BAUFUfFNtAvHyLdVQnFxMS5evAg/Pz/ZayKRCH5+foiJiSn3mCNHjsDd3R2TJk2CjY0NmjdvjqVLlwr+aRwhytSgQQNZV/TU1FScO3cOEydOxMOHDzF69GjUrVsXzZs3x5dffong4GBeJ0RVlQ4dOgBQ/jjwV69eQSwW4/Dhw9i3bx9mzZpFxTfRHgLIOagA11IGBgZluqK/ePEC27dvh5OTE37//XewLAtLS0t0794d69atw7179/gOWSmcnJxQq1YtpV4M4+Li4OrqioKCAsTExEAsFivtXITwgePk24DXd7b/vb1vZuXU1FRIJBLY2NiUed3GxgYvX74s95gHDx5g3759kEgkOHHiBObPn49Vq1ZhyZIlCv09EELKp6enV6Yr+qtXr7Br1y64uLjgn3/+gb+/PywsLNClSxesXr0aN27c0MohclZWVmjZsqVSc44bN27Azc0NDx48QHh4OPr06aO0cxHCByHkHFSAC0StWrUwbNgw/P3330hOTsaFCxcwd+5cZGVlYdq0aWjUqFGZpUlycnL4DlkhlD0OfN++ffD19YWjoyNiY2Ph5OSklPMQwisFjMeys7ODubm5bFu2bJnCwpNKpahZsyY2bdqEtm3bYsCAAfjmm2+wYcMGhZ2DEFJxVlZWGDhwILZs2YJnz54hMTERS5YsgVQqxdy5c/HJJ5+gXr16GD16NPbu3Yv09HS+Q1YYlmWVlnOcOXMGHh4eqFatGuLi4uDi4qKU8xDCKwHkHLoKi4ZoDJFIhLZt26Jt27b4+uuvkZOTg9DQUNlYrt9++w26urrw8PCQjeNq3bo1RCLNvF/Dsiz27t2LnJwcmJqaKqRNjuOwfPlyzJ07F4MGDcKWLVtgaFi18SqECMHTp0/LjMcyMDAodz8rKyvo6OggOTm5zOvJycnvXU3A1tYWenp60NHRkb3WtGlTvHz5EsXFxdDX11fAOyCEVAXDMGjevLmsO3p+fj4iIiJkOccff/wBkUiE9u3by3IOFxcX6OpqZorKsix++eUXPHz4EPb29gprd/PmzZgwYQI6deqE3bt3V3h8KyFCpO45h2ZWVEShTE1Ny3RFv3fvHn755RdUr14dy5YtQ7t27WBjY4PBgwdj+/btePHiBd8hVwrLspBIJDh37pxC2isuLsbo0aMxd+5cLFiwAH///TcV30S7KWA8lpmZWZntfRdDfX19tG3bFmfPnpW9JpVKcfbsWbi7u5d7jKenJ+7duwepVCp77c6dO7C1taXimxA1Y2xsXKYr+pMnT7Bx40bY2dnh119/haenJ6ytrdG3b19s3rwZT5484TvkSunQoQMYhlHYbOhSqRSzZs3C2LFjMXbsWBw9epSKb6LdBJBzUAFO3vHvruhpaWkICwvDmDFjcPv2bYwYMQK1a9eGs7MzZs2ahbNnz753XIW6cHR0RO3atRVyMczIyECXLl3w119/4c8//8S3335LE58Qrcdw8m2VNWPGDGzevBnbt2/HzZs3MWHCBOTl5WHkyJEAgGHDhmHu3Lmy/SdMmID09HRMnToVd+7cwfHjx7F06VJMmjRJUb8CQoiS2NnZybqip6SkICYmBtOmTUNSUhLGjx+P+vXro2nTppg2bRpOnjyJ/Px8vkP+oBo1aqBVq1YK6Yaen5+Pfv364ccff8Tq1auxbt06je0ZQEhFCSHnoL9i8kH6+vrw8fGBj48Pli5dilevXuH06dMIDg7Gjh07sHLlShgbG8PX11fWdaxx48ZqVZQyDIMO4o44feUatsUlICk7BxKpFMZ6emhc0wrNbW3QwKL6R2O+f/8+AgICkJqaijNnzsDb21tF74AQnlVxbU3ZsZU0YMAApKSkYMGCBXj58iVatWqFU6dOySZJefLkSZkhMXZ2dggKCsL06dPRsmVL1KlTB1OnTsXs2bOrGDQhhA+6urpwc3ODm5sbFi5ciIyMDJw9exZBQUE4cOAAfvnlFxgYGMDb21u2xGqLFi3UKucAXve827NnDziOq3JsL168QPfu3XHz5k0cPnwYgYGBCo6SEDUlgJyD1gEnVcZxHK5evSobxxUZGYni4mLUr19fVox37NgR5ubmvMV44+Ur/H3hCg5cvgYJAIYBdJj//xGVvuk+Ut+iOj5r3wq9WzaDSTndVKKiotCzZ09YWFjg+PHjcHR0VNVbIIQ3sjU5Vy+Wb03O6fMrtSYnIYT8F8dxuHXrliznCA8PR0FBAWxtbWXFeKdOnWBlZcV3qFj31158t24Lug4YirT8YpRIpDDS10MjW0s0s7OBX8tGqGv5/twoMTERAQEBkEgkOHbsGFq3bq3C6Anhh5ByDirAicLk5eUhLCxMdnG8c+cOdHR04OrqKivI27VrV2bSAqXFUlyMlWfPYefFq9ARMZBIP/wxf3t/2qKaEZYF+sPX8f8Tp+zcuRMjR46Eh4cH9u/fDwsLCyVGToj6ENLFkBCiWQoLC3Hu3DkEBwcjKCgIiYmJYBgGbdu2leUcbm5u0NPTU1lMpy7dxh9n4nE7KeWD+4kYBh5O9TG5qwea2ZVd/ujkyZMYMGAAHB0dcfToUdSpU0eZIROiNoSUc1ABTpTm0aNHsgvjmTNnkJ2dDQsLC/j5+ckujsq4sDxMy8DIv/fjZU4upJX8eDPM6zUEP2vfCl938sH3S5Zg4cKFGD58ODZt2kQTOhFBkV0Mf5LzYjhD/S+GhBDNlpSUJMs5Tp8+jbS0NJiamkIsFstyDgcHB6WcOz03H9/tOYOQxPuVOk5XJMLIju0wwd8dujoirFu3DlOmTEFAQAB27twJExMTpcRLiDoSUs5BBThRidLSUsTFxcmejsfHx4PjOHzyySeyC6O3tzeMjIzkOs+j9AwM2PoPsguLIJHzo22dmYroVUvx/fffY+7cuWo3xowQZZNdDFfJeTH8Uv0vhoQQ7SGRSJCQkCDLOWJiYiCRSODo6CjLOViWVUiB+yIjG6PX78PT1Kwqt9GhmT1E18Ow5pdfMH36dKxcuVIlvQUJUSdCyjmoACe8SEtLw5kzZ2QXx6SkJBgaGsLHxwf+/v7o3LkzmjVrVqmit6i0FN02/olnWVkf7XJeUZ9am+HncaMU0hYhmkZ2MfxRzovhTPW/GBJCtFdWVhZCQkJkOcejR4+gp6cHT09PWUHu7OxcZqKlisgtLMKgn3bhcUqG3DFm3krA3O4emDBhgtxtEaKJhJRz0DJkhBeWlpYYMGAAtmzZgmfPniExMRFLliyBVCrF3Llz0bx5c9SrVw+jRo3Cnj17kJ6e/tE2fwmPxpPMTIUV3wBwJj0Pj9MzFdYeIYQQQlTL3NwcvXr1woYNG/DgwQPcuXMHP/30E0xMTLBkyRK0adMGtra2+Oyzz/DXX38hOTm5Qu2uPBShkOIbAKo7tUF9V1YhbRFC1BsV4IR3DMOgefPm+PLLLxEcHIz09HScOnUK/fr1Q2xsLAYMGABra2vZsiTR0dEoLS0t08azzCz8EXMRiu7PIZFKsfLsOcU2Soim4Rj5NkIIURMMw6BRo0aYPHkyjh49irS0NISEhGDkyJG4du0aPvvsM9SqVQutW7fGnDlzEBoaiuLi4nfauXD/GQ7GXVNobD8cCEVuYZFC2yRE4wgg56ACnKgdY2Nj+Pv746effsL169fx5MkTbNq0CfXq1cOaNWvg6ekJa2tr9O3bF5s3b8aTJ0/wT0IiREoYoy3hOJy5cx8vs3MV3jYhmoLh5NsIIURdGRgYgGVZ/PDDD7h06RJevHiBHTt24JNPPsGWLVsgFothYWGBwMBArF27Fnfv3gXHcfgrPEHhsWTmFeJo/E2Ft0uIJhFCzkEFOFF7dnZ2sq7oKSkpiImJwbRp05CUlITx48ejfv362BRyTu5J1z7kcOINpbVNiNrj5NwIIURD1KpVS9YV/eXLl7h48SLmzZuH3NxczJgxA40bN4ZjsxYIuXpPKeffG3NVKe0SojEEkHNQAU40io6OTpmu6Kmpqdj49y7AsGqTNVTU5ecvlNo+IYQQQtSLSCRCmzZtZF3R09LScOTIEbTzC3i9bqkS3HuRhqy8QqW0TQhRD1SAE41Wo0YN1G/dVqnnkHIcrjx/qdRzEEIIIUS9mZqaIjAwEB5dApV6npvPKjYJHCFEM+nyHQAh8nqVmwcGyu11kpFfoMTWCVFvDKo+rkozpkMhhJCKS87IUW77WTTvDBEuIeQcVIATjcdxHBiGgTKXtJdynOw8hAiOPDOLasiMpIQQUlHKHmYqVWI+Q4jaE0DOQV3QicYzMdBX+sXKWF+fim9CCCGEwMxIufPOKLt9Qgi/qAAnGs/JxlrJZ+BgV80IUqlUyechRE0JYEZSQgipKKe6ys07ClKeQSKRKPUchKgtAeQcVIATjdfI2hJ6Osr7KHMSKWKOHoKtrS2GDh2KP//8E8nJNEEKERABXAwJIaSiWtSrpbS2JQW5CPRjYWVlhX79+uH333/H06dPlXY+QtSOAHIOKsCJxtPT0YG/UyPoiJTTRZzR0cHKSePx+eef48aNGxg2bBhq1aqF1q1bY86cOQgJCUFRUZFSzk2IOmA4+TZCCNEmjrZWaFq3plLaHtHFG1FRUZgyZQqePn2KcePGoV69emjWrBmmT5+OU6dOIT8/XynnJkQdCCHnoAKcaIUh7ZwhkSr+r07EMGhWqyZGBH6KZcuWISEhAS9fvsSff/6J5s2bY+vWrejYsSMsLS3RrVs3rFmzBnfu3FHqhHCEEEII4ddAL2eFtyliGAz0agUPDw98++23iI2NRUpKCvbs2QMPDw/s27cPXbt2hYWFBTp37owff/wRiYmJlHMQomGoACdaoU3d2nBvYAcdBU+UJuU4TPP1KPOajY2NrCv6ixcvcOnSJcyfPx/5+fn48ssv0aRJEzg4OGD8+PE4ePAgsrKyFBoTISongO5ghBBSGd3bN0PzejYKbfMz3zaws6pe5jULCwtZV/QnT57g+vXrWLZsGUQiEebPn4+WLVuibt26GDlyJP755x+kpaUpNCZCVE4AOQcV4EQrMAyDZYGdIQIHjlPMZGkihkGvls3g62j//n1EIrRq1QqzZ89GSEgI0tPTcfToUXTr1g0hISHo3bs3LC0t4e3tjcWLF+P8+fM0sQrRPAK4GBJCSGXoiETwq20IaWmxQtpzsLHA5K4eH9yHYZgyXdHT09MRFBSEQYMG4cKFCxg0aBCsra3h4uKC+fPnIzIyEiUlJQqJjxCVEUDOQQU40Qocx2Hzz6vxZOc2MJD/KbgOw6ChlQXmdfat1HEmJiZluqI/ePAAa9euhZWVFVauXAlXV1fUrFkTAwcOxNatW/H8+XO5YyVE2YQwHosQQipj3bp1GDO4H2qn3pZ7Itha1U2xbmxPGOjpVuo4IyOjMl3Rnz17hj/++AMODg5Yv349vL29YWVlhV69emHDhg14+PChXHESogpCyDmoACcar6ioCMOHD8eiRYswd8gA/NizK0QMU+Xu6KI3xfeOoX1hamggV2z29vayruhpaWk4d+4cJk6ciAcPHmDUqFGoW7cuWrRogZkzZyI4OBiFhYVynY8QpeAY+TZCCNESEokE06dPx+TJkzFt2jSc/Gsz1o/rBWuzalVqr3m9Wtg+pT/qWJjLHVudOnVkXdFfvXqFuLg4zJw5EykpKZg8eTIcHBzQuHFjfPHFFzh27Bhyc3PlPichCieAnIPhaOYGosHS09PRu3dvxMbGYtu2bRg4cCAA4MrzF5h56BSeZGaiop9wHYaBhOMwtF0rfCn2RDV9fSVGDqSmpuLMmTMICgpCcHAwkpKSYGhoCB8fH/j7+8Pf3x9NmzYFo+Bx7YRUVHZ2NszNzWH/7VKIDA2r1Ia0sBAPF36NrKwsmJmZKThCQghRnby8PAwZMgRHjx7FmjVrMHHiRNnPsvMLseJQOI5fvFmhSWGrGehjTCcXDGfbQkek/OdhWVlZCAkJQVBQEIKCgvDo0SPo6enBy8sLnTt3hr+/P5ydnSFSQSyElEdIOQcV4ERj3b9/H59++inS0tJw+PBheHp6lvl5UWkptsUlYEf8ZaTk5kFXJIJEKi0zPIThOEg5DiKRCJ4O9THB0wXt69dV7RvB6y70169fl10YIyIiUFRUhLp168qKcT8/P9SoUUPlsRHhkl0MF8l5MVyk/hdDQgj5kBcvXiAwMBC3b9/G7t278emnn5a/X0Y29sUkIvrWY9xJSkXJv+Z90RcBGU/u49uJI9DboyWMDZR7o/99OI7D3bt3ZTlHaGgo8vPzYWNjg06dOsHf3x+dO3dGzZrKWWqNkPIIKeegApxopOjoaPTo0QMWFhY4fvw4HB0d37tvqVSKyAePcfHJc1xNeolnmdkolUpRTV8PFpDi+I5t2Lt6JfxcXVT4Dj4sPz8fERERsovjzZs3IRKJ0L59e1lB7uLiAl3dyo0XI6Qy3l4MHRbKdzF88K36XwwJIeR9EhMTERAQAKlUimPHjqFVq1YVOq5EIsHLjByUSCQw0tdD6rPHaNmyJc6cOYOOHTsqN+hKKCoqQlRUFIKDgxEUFITLly8DAFq3bi3LOTw8PKCv5J6BRNiElHNQAU40zu7duzF8+HC4urriwIEDsLS0rHJbBQUFqF69On788Ud88cUXCoxSsZ4+fSq7MJ45cwYZGRmoXr06OnbsKLs41qtXj+8wiZaRXQwXyHkx/E79L4aEEFKe4OBg9O3bFw0bNsTRo0dRt27Ve8lxHAcbGxuMHTsWS5YsUWCUivXy5UucPn1aNkQuJSUF1apVA8uyspzD0dGRhsgRhRJSzkEDPYjG4DgOy5Ytw8CBA9GvXz8EBwfLVXwDr2cQdXd3R0hIiIKiVA47OzuMGjUKe/bsQUpKCmJiYjBt2jQkJSVh/PjxqF+/Ppo2bYqpU6fixIkTyMvL4ztkQgghRKNt3rwZn376Kby9vRERESFX8Q28XkaMZVm1zzlq1aqFzz77DH/99RdevnyJixcv4ptvvkFubi5mzJiBxo0bo2HDhpgwYQIOHTqE7OxsvkMmRKNQAU40QklJCcaMGYOvv/4aCxcuxI4dO2BgIN8M5W+JxWKEhYVpzPrcOjo6cHNzw8KFCxEdHY3U1FTs3bsXXl5eOHjwIAICAmBhYQE/Pz+sXLkSV69eBXV0IXKRZzkQ+ugRQjSMVCrF7NmzMXbsWIwfPx6HDx+GqampQtoWi8U4f/48cnJyFNKesolEIrRp0wZz585FaGgo0tLScOTIEXz66ac4c+YMevXqBUtLS3To0AFLlixBfHw8pFIp32ETTSaAnIMKcKL2MjMz0bVrV+zYsQM7duzAokWLFNrtSSwWIzMzUzbmSdPUqFEDffv2xebNm/H48WPcvHkTK1asgL6+PhYuXAhnZ2fUqVMHI0aMwK5du5CSksJ3yETTcHJuhBCiIQoKCjBgwACsXLkSq1evxpo1axQ634pYLIZEIsG5c+cU1qYqmZqaIjAwEGvXrsXdu3dx//59/Prrr7CwsMCKFSvg4uKCmjVrYtCgQdi2bRuSkpL4DploGgHkHDSDE1Frjx49QkBAAF68eIHTp0/Dx8dH4edwcXGBsbExQkJC0LZtW4W3r0oMw8DJyQlOTk6YOnUqCgsLERkZKZvMbfv27WAYBm3atJGN43J3d4eenh7foRN1Js9FTUMuhoQQ8urVK3Tv3h2JiYk4ePAgevToofBzODo6ok6dOggJCXnvTOqaxMHBARMmTMCECRNQUlKC2NhYWc6xe/ducByHFi1ayHIOLy8vGFZxfC8RCAHkHDQJG1Fb58+fR/fu3VGtWjWcOHECTZo0Udq5/P39oaOjgxMnTijtHOogKSlJNrHK6dOnkZqaClNTU4jFYtnF0cHBge8wiZqQTYjyzVLoVDFhkhQW4sH36j8hCiFE2G7evImAgAAUFBTg6NGjaNeundLONWzYMFy/fh0XL15U2jnUQWpqapnJ3F68eAEjIyP4+PjIcg4nJyeazI0AEFbOQV3QiVo6ePAgfH194eDggNjYWKUW38DrLmEREREoKSlR6nn4Vrt2bQwfPhw7d+5EcnIy4uPjMXv2bKSnp2PKlClo2LAhHB0dMWnSJBw5ckRjxqgR5arqWCzZmCxCCFFjoaGh8PDwQLVq1RAbG6vU4ht4nXNcunQJ6enpSj0P36ysrGRd0Z8/f44rV67gu+++Q2lpKWbPno1mzZqhfv36GDNmDPbt24eMjAy+QyZqQAg5BxXgRK1wHIdVq1ahT58+CAwMREhICKytrZV+XrFYjLy8PMTHxyv9XOpCJBKhXbt2+OabbxAREYG0tDQcPHgQnTt3xqlTp9CjRw9YWlrC19cXy5YtQ0JCAk2sQgghRKts27YNnTt3Rvv27REZGYn69esr/Zwsy4LjOISHhyv9XOqCYRi0bNkSM2fOxOnTp5GRkYETJ06gd+/eiIyMRL9+/WBlZQV3d3csWrQIMTExGjM5LiGVRQU4URulpaWYOHEiZs6ciTlz5mDXrl0qGyfUunVrmJubq/3SIMpkZmaGnj17Yv369bh//z7u3r2L1atXw8zMDN9//z3atm2LWrVqYejQodixYwdevnzJd8hEVQQwIQohRFg4jsP8+fMxcuRIjBw5EsePH4e5ublKzl2/fn00bNhQ0DmHsbExunbtip9//hk3b97E48ePsWHDBtSpUwc///wzPDw8YGVlhX79+uH333/H06dP+Q6ZqIoAcg4aA07UQnZ2NgYMGIAzZ85gw4YNGDVqlMpj6N69O/Ly8nD27FmVn1vdFRcXIzo6WjaxyqVLlwAAzs7OsnFcnp6eClsajqiHt+OxGs6VbzzW/WXqPx6LECIchYWFGDVqFHbu3Inly5fjq6++Uvk45DFjxiAmJgbXrl1T6Xk1QWlpKeLj42U5x/nz5yGVStG0aVP4+/ujc+fO8PHxgbGxMd+hEgUSUs5BT8AJ754+fQpvb29ER0fj5MmTvBTfwOtu6FFRUSgsLOTl/OpMX1+/TFf05ORk/PXXX2jZsiW2b9+Ojh07wsLCAt26dcOaNWtw+/ZtWntciwhhPBYhRBhSU1PRqVMnHDhwAHv37sWsWbN4mQRMLBbj+vXrSE5OVvm51Z2urm6ZrugpKSnYs2cPPDw8sG/fPnz66aewsLBAp06d8OOPPyIxMZFyDi0ihJyDCnDCq4SEBLi5uSErKwvR0dHw8/PjLRaxWIyioiLExMTwFoOmqFmzJoYMGYIdO3YgKSkJly5dwoIFC5Cfn48vv/wSTk5OsLe3x7hx43DgwAFkZWXxHTKRlxZ3BSOECMPdu3fh7u6O27dvIzQ0FH379uUtFpZlAbyeAI58mIWFhawr+pMnT3D9+nX88MMP0NXVxfz589GyZUvUrVsXI0eOxD///IPU1FS+Qyby0vKcgwpwwptjx46hQ4cOqFOnDmJjY/HJJ5/wGk/z5s1hZWUl6DFZVSESidCqVSvMnj0bISEhSE9Px9GjRxEYGIiwsDD06dMHlpaW8PLywuLFi3H+/HmaWEXTCGA8FiFEu507dw5ubm7Q1dVFbGws3NzceI2nVq1aaNasGeUclcQwDJo1a4Zp06bh5MmTyMjIQHBwMAYNGoQLFy5g0KBBqFmzJtq3b4958+bh3LlzWr/CjdYRQM5BBTjhxZo1a9CjRw907twZYWFhqFWrFt8hQSQSwdfXly6GcjIxMSnTFf3BgwdYt24datasiR9//BGurq6oWbMmBgwYgC1btuD58+d8h0wIIUSL7dy5E35+fnB2dkZ0dDQcHBz4DgnA66fglHPIx9DQsExX9GfPnuGPP/6Ao6MjNmzYgA4dOsDKygq9evXChg0b8PDhQ75DJoQKcKJaEokEU6dOxZQpUzB9+nTs3btXrSbREIvFOH/+PHJzc/kORWv8uyt6amoqzp07h4kTJ+Lhw4cYPXo06tati+bNm+PLL79EcHAwCgoK+A6Z/IcQxmMRQrQPx3FYvHgxhgwZgsGDB+PUqVOoUaMG32HJiMVi3L9/H0+ePOE7FK1Rp04djBw5Ert27UJycjLOnz+Pr776CqmpqZg8eTIcHBzQuHFjTJ48GUePHqV8Tw0JIeegApyoTG5uLnr16oW1a9di/fr1+PHHH6Gjo8N3WGWIxWKUlpYiMjKS71C0kp6eXpmu6K9evcI///wDFxcX/PPPP/D394eFhQW6dOmC1atX4/r162o9sQrHceAkL8EVxYErigRXHA9Oms53WIongO5ghBDtUlxcjJEjR2LBggVYvHgxtmzZAn19fb7DKsPHxwcMw9A4cCXR0dEp0xU9LS0NBw4cgFgsxvHjx9G9e3dYWFiAZVn88MMPuHTpEqRSKd9hEwHkHLQMGVGJpKQkBAYG4s6dO9izZw+6du3Kd0jl4jgOdevWxZAhQ7BixQq+wxEUjuNw/fp12bIjERERKCoqQt26ddG5c2f4+/vDz88PFhYWvMeJknhweTuB4iiAK2eCOZE1YCAGYzwYjF5T1QepIG+XBGk8cyl0DKq4JEhRIe78qP5LghBCtEdGRgZ69+6N6OhobN26FYMHD+Y7pPdq06YNWrRoge3bt/MdiqBwHId79+7Jco7Q0FDk5eWhZs2aspyjU6dOsLGx4TtUAK/jvf84FbcfvMSj5+koLCqBgb4u6texRBMHGzjWt4ZIpPrZ/BVJSDmHLt8BEO139epVdOvWDVKpFJGRkXB2duY7pPdiGAZisZjGZPGAYRg0b95c1h09Pz8fERERCA4ORlBQELZs2QKRSIT27dvL1h53cXGBrq7qvsa4kkRwWXOB0jsAdAC8ZzI5aQpQsA9cwW5wem5gzJeA0a2nsjgVTp67ynSLlxCiQg8ePEBAQABevXqFs2fPwsvLi++QPkgsFmP37t3gOI6X5dCEimEYNGrUCI0aNcLkyZNRVFSE6OhoWUH+119/AQBatWolyzk8PT1V3osiN68Ih89cwaHgK0hKfv+KMrY1zdCjkzN6dHKGmUnVile1IYCcg56AE6UKCgpCv3794OjoiKNHj6JOnTp8h/RRW7ZswZgxY5CamqpWY8WE7unTp7Ji/MyZM8jIyIC5uTk6duwouzjWr19fKefmOCm43LVA3noADN5beJdLB4AuGLOFYIz5W/KmKmR3o7+U8270KvW/G00I0XyxsbHo3r07zM3NceLECTRq1IjvkD7q+PHj6NatG+7evQtHR0e+wyFvJCcnIzg4WLa9evUK1apVA8uyspzD0dFRqTdNohMeYMWGYKSkV3ycumX1avhqXCd4t9e8z5KQcg4aA06UZuPGjQgICICPjw8iIiI0ovgGXt+NlkqliIiI4DsU8i92dnYYNWoU9uzZg5SUFMTExGD69Ol48eIFJkyYgAYNGsDJyQlTp07FiRMnkJeXp5DzcpwUXPZ8IG8tACkqV3zjzf5F4LK/Bpf3u0JiUjkBjMcihGi2vXv3gmVZNGnSBLGxsRpRfAOAt7c3dHR0qOedmrGxscFnn32GP//8Ey9evEBCQgLmzZuH3NxczJgxA40bN0bDhg0xYcIEHDx4EFlZ7386XRWbdkXiq6UHKlV8A0BaZh7mLD+EtTvCFBqPSgkg56ACnCicVCrFV199hfHjx2PixIk4dOgQTExM+A6rwho0aAB7e3u6GKoxHR0duLm5YeHChYiOjkZaWhr27duHDh064NChQwgICICFhQU6duyIFStW4MqVK1WezI3LXQMU7FVI3FzOCnAFRxTSlioJYUZSQohm4jgOy5cvR//+/dG7d2+cOXMGlpaWfIdVYWZmZmjfvj3lHGpMJBKhdevWmDNnDkJDQ5Geno4jR47g008/xZkzZ9C7d29YWlrC29sbS5YsQXx8vFyTuW3+JxLb98fKFfOuIxew7s9wudrgixByDirAiULl5+ejf//+WLVqFX755Rf8+uuvajfTeUXQOHDNUr16dfTp0webNm3Co0ePcPPmTaxYsQIGBgZYtGgRWrVqhdq1a2P48OHYuXMnUlJSKtQuV3L1TbdzRWHAZS8AJ3mpwDZVQAB3owkhmqekpATjxo3DnDlzMH/+fPz1118wMDDgO6xKe5tz0KhQzWBiYoLAwECsXbsWd+/exf3797F27VpYWVlhxYoVcHFxQc2aNTFo0CBs27YNSUlJFW77/JVH2LZPvuL7rZ2H4xF14b5C2lIpAeQcVIAThUlOTgbLsjh58iQOHTqEKVOm8B1SlbEsi2vXruHVq1d8h0IqiWGYMl3R09PTcebMGXz22We4fPkyhgwZAhsbG7Rr1w7ffPMNIiIiUFJS8k47HMeBy5wDxX5NcgBXBC57iQLbJIQQ4cnKykJAQAC2bduGbdu24bvvvtPYScxYlkVKSgquX7/OdyikChwcHDB+/HgcPHgQaWlpiIiIwPjx43Hv3j18/vnnqFOnDlq0aIGZM2fi9OnTKCwsLLedgsJi/PBbkEJjW7HpNHLzihTaJpEfFeBEIW7cuAE3Nzc8efIEERER6N69O98hyYVlWQBAWFgYv4EQuRkaGpbpip6UlIStW7eicePG2LRpE3x8fGBhYYEePXpg/fr1uH//zd3i4lhAcg+VH/P9MRKg6DQ4yXMFt6tEArgbTQjRHI8fP4anpyfi4+MRFBSE4cOH8x2SXDw8PKCvr0/rgWsBPT29Ml3RX716hV27dqFdu3bYuXMnOnfuDAsLC3Tt2hU///wzbt68Kev5cCL0OpJTcxQaT2p6Lo6FJCq0TaUTQM5BBTiR29mzZ+Hh4QFTU1PExcWhbdu2fIckt9q1a8PJyYm6oWshW1tbWVf05ORkxMfHY86cOcjMzMTUqVPh6OgIR0dHJER9BalUWV+RDLj8PUpqW/GEMB6LEKIZLly4ADc3N+Tn5yM6Olp2w1yTGRsbw93dnXIOLWRlZYWBAwdi69ateP78Oa5evYrvvvsOpaWlmDNnDpo1a4b69etj9OjR2L5XOZP/Hgqu+jw4fBBCzkEFOJHLli1b0KVLF7i5uSEyMhL16mnwWsf/QePAtZ9IJJJ1RQ8PD0daWhoOHTqEzp07wbFeMkSiqk+i8mFSoDhKSW0rgQDuRhNC1N+hQ4fQoUMHNGjQALGxsWjatCnfISmMWCxGWFgYJBJF97oi6oJhmDJd0dPT03HixAn06dMHsfFXkZb97nA4RXj6IgNPkjKU0rZSCCDnoAKcVIlUKsU333yDUaNGYdSoUTh69Khar7dXFWKxGHfv3sWzZ8/4DoWoiJmZGXr06IF1v34DUxMljyUsuQWOK1XuOQghRAtwHIfVq1ejd+/e6NatG0JCQlCzZk2+w1IosViMzMxMXL58me9QiIoYGxuja9euWL16NdZs/Eup57r9IFmp7ZPKoQKcVFphYSGGDBmCpUuXYuXKlfjtt9+gp6fHd1gK5+PjAwA0JkuIJI9VcJJiQFqx2dj5xkd3sHXr1qFBgwYwNDSEq6srzp8/X6Hj/vnnHzAMg549e1btxIQQtVJaWoovvvgCM2bMwKxZs/DPP//AyMiI77AUzsXFBcbGxpRzCNST5+nKbT9Jue0rkhByDirASaWkpqaiY8eOOHToEPbt24eZM2dq7KyjH2NlZQVnZ2fqhi5EXLF2nUdeKu4Otnv3bsyYMQMLFy5EQkICnJ2d4e/v/9FVCR49eoSZM2fC29u78iclhKidnJwc9OjRAxs2bMCmTZvwww8/QCTSztRVX18fXl5elHMIVEmpcocelJRo0NAGAeQc2vktRpTizp07cHNzw7179xAWFoY+ffrwHZLS0dqcAsUYqug8GrJerYovhj/99BPGjBmDkSNHolmzZtiwYQOMjY2xZcuW9x4jkUgwZMgQfPvtt3BwcKj8SQkhauXZs2fw9vZGZGQkTp48iTFjxvAdktKJxeL3Lo1JtJuhvq5S2zdQcvsKJYCcgwpwUiERERFwc3ODvr4+YmNj4erqyndIKiEWi/HkyRM8ePCA71CIKumqooAzBETaNYZREYqLi3Hx4kX4+fnJXhOJRPDz80NMTMx7j/vuu+9Qs2ZNjBo1ShVhEkKU6PLly3B1dUVGRgaioqLQqVMnvkNSCbFYjLy8PMTHx/MdClGxBnZWSm3f3s5Sqe1rKr5yDirAyUf99ddf8PPzQ+vWrREdHQ17e3u+Q1IZb29viEQi6hImMIyODcDUUO5J9D4Bw2jGVzAj5wYA2dnZZbaioqJyz5WamgqJRAIbG5syr9vY2ODly5flHhMZGYk//vgDmzdvlut9EkL4d/z4cXh5ecHW1haxsbFo3rw53yGpTOvWrWFmZkY5hwA1cbD5+E5q3L4iCSHn0Izsj/CC4zh8++23+OyzzzB06FCcPHkS1atX5zsslTI3N0e7du1oUhQhMvABoKOkxkVgDHyU1LYSKKA7mJ2dHczNzWXbsmXLFBJaTk4OPvvsM2zevBlWVsp9gkAIUa5169ahe/fu8PPzQ3h4OGxtbfkOSaV0dXXh4+NDOYcAWVuYoJljLaW03ahBTdS2qa6UtpVCADmHBg0IIKpUVFSEMWPG4M8//8T333+PuXPnau1kax8jFouxdetWcBwn2N+BEDHGQ8AVHlJW64BRPyW1rXjyzCz69rinT5+WWarQwKD88e9WVlbQ0dFBcnLZJVOSk5NRq9a7ycn9+/fx6NEjBAYGyl6TSl+v366rq4vbt2+jYcOGVQueEKISEokEX331FVavXo3p06dj5cqV0NFR1g1Q9SYWizFnzhwUFhbC0FBF85EQtdCrSyvcWHtK8e36Oyu8TWUSQs5BT8DJO9LT0+Hv7489e/Zg165d+PrrrwVdeIrFYiQnJ+PmzZt8h0JUSa8loNcain8KLgKMeoPREdZ4LDMzszLb+y6G+vr6aNu2Lc6ePSt7TSqV4uzZs3B3d39nfycnJyQmJuLy5cuyrXv37mBZFpcvX4adnZ3S3hMhRH55eXno06cPfvnlF6xduxY//fSTYItv4HXOUVRU9MHxp0Q7dfJsqvCx2na1a6BLh2YKbVMTqHvOQU/ASRn3799HQEAAUlNTcfbsWXh6evIdEu88PT2hp6eHkJAQNGsmvC8xoWIYBjBfBi61myJbBUTVwZjOUmCbKlDFmUVlx1bSjBkzMHz4cLRr1w4uLi74+eefkZeXh5EjRwIAhg0bhjp16mDZsmUwNDR8Z4zo26EyQho7SogmevHiBQIDA3Hr1i0cOXIEAQEBfIfEu+bNm8PKygohISFgWZbvcIgK6enp4JtJXTDu652QSOVffUckYvDNxC4wMNBTQHQqJICcgwpwIhMdHY0ePXqgRo0aiI2NhaOjI98hqQVjY2O4ubkhNDQUkydP5jscokKMrgNg+jW4nO8U16b5CjAic4W1pzIqXIlvwIABSElJwYIFC/Dy5Uu0atUKp06dkk2S8uTJE61dC5gQobh27RoCAgJQWlqKyMhItGrViu+Q1IJIJIKvry+NAxeopo62mD6qI37cfEbutiYP80ULpzoKiIoHWp5zMBwtcEzwehH64cOHw8XFBQcPHoSlpbC6x37MokWL8OuvvyI1NZUSfwHicteAy10jRwuvh3Aw5ivAGPVQTFAqkJ2dDXNzczQfuxQ6+lUbiygpLsS1TV8jKyurzHgsQohwBQcHo1+/frC3t8exY8dQt25dvkNSK7/99humTJmCjIwMmJiY8B0O4cHBoMtYvSUEEom00sfqiBh8MZxFv4A2SohMeYSUc1AlIXAcx2HZsmUYOHAg+vbti9OnT1PxXQ6xWIyMjAxcuXKF71AIDxiTL8CYLQFgiMqPCdcBmOpgamzSqOK7DAXMSEoIIQCwefNmfPrpp/Dy8sK5c+eo+C6HWCyW9QwgwtTLvxV+XzYEjvWtK3Vcg7qW2Lh0sMYV32UIIOegAlzASkpKMGbMGHz99ddYuHAh/vzzz/dOUiB0rq6uMDIyorU5BYwx7g/G6gSg7/XmlY8V4qLXm2EPMNZBmrXsGCGEKJhUKsWcOXMwduxYjB8/HocPH4apqSnfYamlxo0bo3bt2pRzCFxjBxv8sXwovp3eDa2affhGVUunOlg4NQDbVg5DU0dhLd+niWgMuEBlZmaib9++iIiIwPbt2zFs2DC+Q1JrBgYG8PT0REhICL788ku+wyE8YXTrgrHYDK70EbiCPUBRFFB6F0Dpv/bSB/SagjFgAaN+YHQqd/daHSliSRBCiHAVFBRg2LBh2L9/P1avXo2pU6cKenWVj2EYBizLUgFOoKurAz9PJ/h5OiE7txC3HyTj0bM0FBeXQl9PF/XrWsDJwQZmpkZ8h6owQsg5qAAXoEePHiEgIABJSUkIDg6Gr68v3yFpBLFYjKVLl6KkpAR6eho2oyRRKEa3weuZzE0BjisGJC8BFAMwBHRswTBatoSOimckJYRoj1evXqFHjx64cuUKDhw4gJ49e/IdkkYQi8XYtWsXMjIyUKNGDb7DIWrAzMQQ7VvWR/uW9fkORbkEkHNQF3SBiY+Ph5ubGwoLCxETE0PFdyWIxWLk5ubi4sWLfIdC1AjD6IPRrQdG1/H1E3JtK77x/7vRVd0IIcJ08+ZNuLm54dGjR4iIiKDiuxLEYjGkUikiIiL4DoUQlRJCzkEFuIAcPHgQPj4+cHBwQGxsLJycnPgOSaO0bdsWpqam1CWMEEII+YjQ0FB4eHjA2NgYsbGxaNeuHd8haZQGDRrA3t6ecg5CtBAV4ALAcRxWrVqFPn36IDAwEGfPnoW1teaPS1U1XV1d+Pj40MWQCI8AZiQlhCjO9u3b0blzZ7Rv3x5RUVGoX1/Lu8wqiVgsppyDCI8Acg4qwLVcaWkpJk2ahJkzZ2LOnDnYtWsXjIy0Z6IGVWNZFlFRUSgqKuI7FEJURwAXQ0KI/DiOw4IFCzBixAiMHDkSx48fh7m5Od9haSyWZXHt2jW8evWK71AIUR0B5BxUgGuxnJwcdO/eHZs3b8bvv/+OpUuXQiSi/8vlIRaLUVhYiNjYWL5DIURlhDAeixAin6KiIgwdOhSLFy/G8uXLsXHjRpqwVE4sywIAwsLC+A2EEBUSQs5B1ZiWevbsGby8vBAVFYWTJ09i1KhRfIekFVq2bAkLCwvqEkYIIYS8kZqaCj8/P+zfvx979uzBrFmzaJkxBahduzacnJwo5yBEy1ABroUuXboEV1dXZGVlITo6Gn5+fnyHpDVEIhGtzUmERwDdwQghVXP37l24u7vj9u3bCA0NRb9+/fgOSavQOHAiOALIOagA1zLHjh2Dt7c36tSpg9jYWHzyySd8h6R1WJZFXFwc8vLy+A6FEJVgOE6ujRCinc6dOwc3Nzfo6uoiNjYW7u7ufIekdViWxd27d/Hs2TO+QyFEJYSQc1ABrkXWrFmDHj16oHPnzggLC0OtWrX4DkkricVilJSUICoqiu9QCFENAdyNJoRUzs6dO+Hn5wdnZ2dER0fDwcGB75C0kq+vL4DXy7oRIggCyDmoANcCEokE06ZNw5QpUzB9+nTs3bsXxsbGfIeltZycnFCrVi3qEkYIIURwOI7DkiVLMGTIEAwaNAinTp1CjRo1+A5La1lZWcHZ2ZlyDkK0iC7fARD55OXlYfDgwTh27BjWr1+PCRMm8B2S1mMYhsZkEUGRZ2ZRTZmRlBDyccXFxRg7diy2b9+OxYsX45tvvqHJ1lRALBZj//794DiOft9E6wkh56An4BosKSkJHTp0QEhICI4dO0bFtwqJxWJcvHgRWVlZfIdCiPIJoDsYIeTDMjIy0KVLF+zatQt///035s2bR8WgiojFYjx58gQPHjzgOxRClE8AOQcV4BoqMTERbm5uSE5ORmRkJLp27cp3SILCsiykUikiIiL4DoUQpRPCmpyEkPd78OABPDw8cOXKFZw5cwaDBw/mOyRB8fb2hkgkonHgRBCEkHNQAa6BgoKC4OnpCSsrK8TFxcHZ2ZnvkATH3t4e9evXp27ohBBCtFpsbCzc3NxQWlqK2NhYeHt78x2S4Jibm6Ndu3aUcxCiJagA1zAbN25EQEAAOnTogIiICNSpU4fvkASJxoETQRFAdzBCyLv27t0LlmXRpEkTxMTEoFGjRnyHJFhvcw5OQ5ZZIqTKBJBzUAGuIaRSKWbNmoXx48djwoQJOHz4MExMTPgOS9DEYjGuXr2KlJQUvkMhRKmE0B2MEPJ/HMdhxYoV6N+/P3r16oXTp0/DysqK77AETSwWIzk5GTdv3uQ7FEKUSgg5BxXgGqCgoAD9+/fHjz/+iF9++QVr1qyBjo4O32EJHsuyAICwsDB+AyFE2QRwN5oQ8lpJSQnGjRuH2bNnY/78+fj7779haGjId1iC5+npCT09Pep5R7SfAHIOKsDVXHJyMliWxcmTJ3Ho0CFMmTKF75DIG3Xq1EHjxo1pUhQiCNp8J5oQ8lpWVhYCAgKwdetWbN26Fd999x3NdK4mjI2N4ebmRjkHEQRtzzloHXA1duPGDQQEBKCwsBARERFo27Yt3yGR/6Bx4IQQQrTBkydPEBAQgGfPniEoKAhisZjvkMh/iMVi/Prrr5BKpRCJ6BkaIZqK/nrV1NmzZ+Hh4QFTU1PExcVR8a2mxGIxbt++jefPn/MdCiHKw3HybYQQtXbhwgW4uroiLy8P0dHRVHyrKbFYjIyMDFy5coXvUAhRHgHkHFSAq6GtW7eiS5cucHV1RWRkJOrVq8d3SOQ9fH19AYC6hBGtJoQJUQgRqsOHD6NDhw5o0KABYmNj0bRpU75DIu/h6uoKIyMj6nlHtJoQcg4qwNWIVCrFvHnz8Pnnn+Pzzz/HsWPHYGZmxndY5AOsra3RokULKsCJdhPAhCiECA3Hcfj555/Rq1cvBAQEICQkBDVr1uQ7LPIBBgYG8PT0pJyDaDcB5BxUgKuJwsJCDBkyBN9//z1WrlyJDRs2QE9Pj++wSAXQOHBCCCGapLS0FF988QWmT5+OWbNmYffu3TAyMuI7LFIBYrEY4eHhKCkp4TsUQkgVUQGuBlJTU+Hn54dDhw5h3759mDlzJs06qkHEYjEePXqEhw8f8h0KIUrBSOXbCCHqIycnBz169MCGDRuwadMm/PDDDzShlwYRi8XIzc3FxYsX+Q6FEKUQQs5B37g8u3PnDtzc3HD37l2EhYWhT58+fIdEKqlDhw4QiUT0FJxoLwF0ByNECJ4/f44OHTrg3LlzOHHiBMaMGcN3SKSS2rZtC1NTU8o5iPYSQM5BBTiPIiIi4O7uDn19fcTGxsLV1ZXvkEgVVK9eHW3btqWLIdFaQpgQhRBtd/nyZbi6uiItLQ3R0dHo3Lkz3yGRKtDV1YWPjw/lHERrCSHnoAKcJ3///Tc6deqEVq1aISoqCvb29nyHROTAsixCQ0PBacjyB4QQQoTjxIkT8PLyQq1atRAXF4fmzZvzHRKRA8uyiIqKQlFREd+hEEKqgApwFeM4Dt999x2GDh2KwYMH4+TJk6hRowbfYRE5icVivHjxArdv3+Y7FEIUTwBrchKirdavX4/AwED4+fkhPDwctra2fIdE5CQWi1FYWIjY2Fi+QyFE8QSQc1ABrkLFxcUYMWIEFi5ciO+//x5btmyBvr4+32ERBfDy8oKuri51CSNaSQjdwQjRNhKJBDNmzMCkSZMwdepU7N+/H9WqVeM7LKIALVu2hIWFBeUcRCsJIeegArwSOK4EnDQDnDQTHFe55R/S09Ph7++Pf/75Bzt37sTXX39NM51rkWrVqsHNzY0uhkQ7CWBCFEK0SV5eHvr06YNffvkFa9euxU8//QQdHR2+wyIKIhKJwLIs5RxEOwkg59DlOwB1xnEcUHIBXMFRoCQBKL0PQPLmp7rgdB0BvTZgjHoAeq3eW1Dfv38fAQEBSE1NxdmzZ+Hl5aWy90BUh2VZrF+/HlKplJZ0IYQQUmVZOQW4dT8ZaZm54DiguqkRGtvXhLWl6UePffnyJQIDA3Hz5k0cOXIEAQEBKoiYqBrLspg+fTry8vKoZwMhGoYK8PfgisLBZf8ASO4D0MH/C++3SoHSW0DpXXAFOwHdxoDpXDAGnmX2io6ORo8ePVCjRg3ExsbC0dFRVW+BqJhYLMbixYuRmJgIZ2dnvsMhRGHk6dalKd3BCOFbdm4hToRew9GzV/HoWXq5+9hYmaKr7yfo2cm53GL82rVrCAgIQGlpKSIjI9GqVSslR034IhaLUVJSgqioKJrRnmgVIeQc9JjuPzhpLqSZs8FljAEkD9+8+t/i+9/e/Kz0HriMkZBmzQcnzQcA7NmzB2KxGE2bNkVMTAwV31rOzc0NhoaG1CWMaB8BTIhCCJ+OnLmKvhM3Yc32sPcW3wCQnJqDbfti0W/S79i6NwalEqnsZ8HBwfD09ESNGjUQFxdHxbeWc3JyQq1atSjnINpHADkHFeD/wkmzwKUPBQoPv3lF+sH9y3qzb8FecOnD8dOq7zBgwAD07dsXp0+fhqWlpaLDJWrG0NAQnp6edDEkWkcIE6IQwofCohLM/uEglm8IRl5+cYWPKymV4PfdURj39d9Iz8zD5s2b8emnn8LLywvnzp1D3bp1lRg1UQcMw0AsFlPOQbSOEHIOKsDf4LhicBmjgdLbqFzh/V9SSIqvoE3DTVi0aD7+/PNPGBgYKCpMoubEYjHCw8NRWlrKdyiEEELUWFFxKb5adgCRF+5XuY1b95PRf8IaTJw8HePGjcPhw4dhavrxceJEO4jFYly8eBFZWVl8h0IIqQQqwN/gcn8DSq7iw93NK0ZHBHi7GmPBl3VopnOBYVkWOTk5SEhI4DsUQhRHADOSEqJq6/4MR8K1p3K3U1Cii8DPFmHt2rXQ1aWpfYSEZVlIpVJERPyPvfsOj6Jq2wB+z256SEISQmih9xZ6CAmQWUroRelIVVARpVgQleKLKIgKVhAEERFEFBCRDgkEUugC0ntNSIEE0nd3vj8i+xkJkGyb3Z37d13zvrCZOfMsbvY8z8w5Z/bKHQqR+Sgg52ABDkDKPwdkLoQ5/6sJAiA9+ByS9vLTdyaH0aJFC5QqVYpDwsihKGE4GJE1Hf37OtZtPWq29pLuAX/sOmG29sg+VKtWDVWqVGHOQQ5FCTkHC3AAUuYyAJa4Uy1ByvzBAu2SrXJ2dka7du3YGZJj0UumbURUyKKfYsy+VtB3a/ZDqzV9FB/ZD84DJ4ekgJxD8QW4pL8H5PwBcww9f5QOyF4HSf/AAm2TrdJoNNi3bx9yc3PlDoXIPBQwHIzIWs5dvoOT526Zvd3Uu5nYc+C82dsl26bRaHD8+HEkJyfLHQqReSgg51B8AY68BAD5FjxBDpB30ILtk60RRRHZ2dlISEiQOxQiIrIxUXFnLdb27ljLtU22SRRFAEB0dLS8gRBRsSm+AJfyTwCw5KIlakD7twXbJ1sTHBwMX19fREVFyR0KkVkIMGE+ltzBE9mY0xcSLdb22UtJFmubbFPFihVRu3Zt5hzkMJSQcyi+AIf2Aiwz/PwhCZKWQ8KURK1WIyIignOyyHFIkmkbERlcup5isbZv38lAVnbxnydOjoHzwMmhKCDnYAEuZcKyEwb0gJRjwfbJFmk0GsTFxSErK0vuUIhMpoQVSYmsJSfXktPegOwcy7ZPtkej0eDs2bO4efOm3KEQmUwJOQcLcLhYuH0Blh3iTrZIo9EgPz8f+/fvlzsUIiKyIU5qtUXbd3Ziaqc0ERERAMBh6ER2gt/STkGw+BxwdZAF2ydbVK9ePQQGBrIzJMeggBVJiaylYrnSFmvbu5QbvL3cLdY+2aaAgAA0atSIOQc5BgXkHIovwAWnhgC0FjyDFoJzQwu2T7ZIEASIosg5WeQQBEkyaSOi/1e3RqDF2q5T3XJtk23jPHByFErIORRfgMOlpYVPIAAuzS18DrJFGo0GBw8eRHp6utyhEJlGb+JGRAatm1SzXNtNLdc22TaNRoMrV67g8uXLcodCZBoF5ByKL8AFpyqASwgs80+hBlzaQVCXt0DbZOs0Gg30ej1iYmLkDoXI7nz99deoWrUq3NzcEBISggMHDjx23yVLlqBt27bw9fWFr68vOnbs+MT9ieQU2qw6ygV4m71dFxcndItoYPZ2yT60a9cOKpWKd8GJjGDtnEPxBTgACB4jYZlLJjoIniMt0C7Zg+rVqyMoKIidIdk9aw8HW7NmDSZPnowZM2bgyJEjCA4ORmRkJO7cuVPk/tHR0Rg8eDCioqIQFxeHoKAgdO7cmSsCk01SqQQM7W3+0Xe9OzXm/G8FK126NJo1a8acg+yeEnIOFuAA4Kop2GDOlUnVgGs3CK5hZmyT7IkgCNBoNFwUheyflRdE+eyzzzBmzBiMGjUK9evXx6JFi+Dh4YFly5YVuf9PP/2EcePGoUmTJqhbty6+++476PV67Nq1q+QnJ7KCvpFN0KR+JbO1VyHQBy8ODjdbe2SfHuYckp3MgyUqkgJyDhbgKCiUBO9ZgOAJ8/yTqAGVDwSf6WZoi+yZRqPBsWPHkJqaKncoRMaTJNM2ABkZGYW23NzcIk+Vl5eHw4cPo2PHjobXVCoVOnbsiLi4uGKFm5WVhfz8fPj5+Zn+3oksQBAETHu1K/x9PU1uy93NGTMn9IC7m6Ufq0q2TqPR4Pbt2zh79qzcoRAZTwE5BwvwfwjqAAh+ywHBHabdCVcDggcE3+UQVEz+lE4URQAFw1WIlCwoKAg+Pj6G7aOPPipyv5SUFOh0OgQGFl7NOTAwEImJicU615QpU1ChQoVCHSqRrSkX4IMvZw5AWX8vo9vwcHfBx2/3RYPaXGuGgPDwcDg5OXEYOimerecclnwAtt0RnBsCfqsg3RsH6G6j5PPCBUBdCYLvQghONS0RItmZoKAg1KpVC7t378azzz4rdzhERhGkgs3YYwHg+vXr8Pb+/4WnXF1dzRDZo+bMmYOff/4Z0dHRcHNzs8g5iMylSkV/fD9vGD79bhd2x5bsrmWT+pUwdVwXVLLgc8XJvnh6eqJ169bYvXs3xo0bJ3c4REZRQs7BAvw/BOd6QJnNkO5/BmStACDg6YX4PwMJPEdDKDUBgmCZ/8hkn0RR5Dxwsm//GtZl1LEAvL29C3WGj1OmTBmo1WokJSUVej0pKQnlypV74rGffPIJ5syZg507d6Jx48bGxUtkZaW9PTBrck90i2iAtZuP4MBfV57461a/Vnn069oUndvWgyAI1guU7IIoivjmm2+g1+uhUnGgK9khBeQcLMCLIAjuELzfheQ5GlLWL0D2b4D+McMQVBUgePQD3PtDUAcWvQ8pmkajweLFi3H79m2UL89hgmR/BH3BZuyxJeHi4oLmzZtj165d6NOnDwAYFjcZP378Y4/7+OOPMXv2bGzbtg0tWrQwLlgiGYU2q47QZtWRmJyOE2dv4ezFJKTczYQkSfDxdkedamXRsE4FVKnoL3eoZMM0Gg1mzZqFEydOIDg4WO5wiEpMCTkHC/AnENTlIXhNALwmQNKnAfmnAf3dgh+qfAHn+hBUvvIGSTYvIiICABAVFYUhQ4bIGwyRHZg8eTJGjBiBFi1aoFWrVliwYAEyMzMxatQoAMDw4cNRsWJFw5yuuXPnYvr06Vi1ahWqVq1qmLdVqlQplCpVSrb3QWSMcgE+KBfgg07h9eQOhexQ69at4ebmht27d7MAJyoGOXIOFuDFJKj8AD5SjIwQGBiIhg0bYvfu3SzAyT6ZYThYSQwcOBDJycmYPn06EhMT0aRJE2zdutWwSMq1a9cKDa1cuHAh8vLy0K9fv0LtzJgxAzNnzjQubiIiO+Tm5oawsDDs3r0bkyZNkjscopJTQM4hSHxYIJHFvfbaa9i0aRMuXbokdyhExZaRkQEfHx9EtHwXTk7GLWim1eYg+uBspKenF2s+FhERmWb27NmYO3cu0tLS4OTEe21kH5SUc3B1BiIr0Gg0uHz5Mq5cuSJ3KEQlJkiSSRsREVmPRqPB/fv3ceTIEblDISoxJeQcLMCJrKB9+/YQBIGroZN9ejgczNiNiIispkWLFihVqhSfB072SQE5BwtwIivw9fVFs2bN2BkSERGRRTk7O6Ndu3bMOYhsFAtwIivRaDTYvXs3uOwC2R0JgN7IjR93IiKr02g02LdvH3Jzc+UOhahkFJBzsAAnshJRFHHr1i2cP39e7lCISkQJ87GIiByJKIrIzs7GgQMH5A6FqESUkHOwACeykvDwcDg5OXFIGNkfCSbMx5I7eCIi5QkODoavry9zDrI/Csg5WIATWYmXlxdatWrFzpCIiIgsSq1WIyIigjkHkQ1iAU5kRRqNBlFRUdDr9XKHQlR8CliRlIjI0Wg0GsTFxSErK0vuUIiKTwE5BwtwIisSRREpKSk4efKk3KEQFZ+xi6E83IiIyOpEUUR+fj72798vdyhExaeAnIMFOJEVhYaGwtXVlc8DJ7uihAVRiIgcTf369VG2bFnmHGRXlJBzsAAnsiJ3d3e0adOGc7KIiIjIogRBMDwClYhsBwtwIivTaDSIjo6GVquVOxSi4lHAfCwiIkek0Whw8OBBpKenyx0KUfEoIOdgAU5kZRqNBhkZGTh69KjcoRAVjwI6QyIiR6TRaKDX6xETEyN3KETFo4Ccw0nuAIiUpmXLlqha2QtXz/2AFvUOQNLfBSBAUJUGnOoDzo0gqMvIHSbR/zOlU7OTzpCIyBFVr14dQUFBiIqKQo8ePeQOh+jpFJBzsAAnshJJ0gG5u6HOWomLCeUAbIf0YBcAoeDnkADoCv7s0gaCxzDAVYQgcKAKERERlZxWq0fLdn0Q81c6Xn5vNVLSHkCCBB8vd9SuFogGtcpDDK0NTw9XuUMlUgwW4ERWIGmvQEp/C8g/BkD9r5/oij4gLwFSXizg3BTw+RiCUxUrREn0GHo8vE5k3LFERGRVuXla/LThANZtO4a7OZXhXBo4fuam4ee372TgzMUkbNx5HAu+342u7RvghUFh8PFyly9oIkAROQcLcCILk7I3Q0p/E///rfCYoruQf/bJPw4ppTtQ+hMIbl0sFCHRk5nyaA97eSQIEZGjOHX+Nj74aguu3kwr1v7ZOflYt+0YouLP4a0XO6Fdq1oWjpDo8ZSQc3BsK5EFSdmbIKVPAqBF8Qrv/9IById0bwKknC3mDY6ouBSwIAoRkSOIPXwRr8xYU+zi+9/upmfhnXm/Y82mwxaIjKiYFJBzsAAnshAp/8w/d76lfzajWyr433uvQ8o/Z47QiIiIyMGcOHMT736yEXl5xj/mVJKAL5ZHYUv032aMjIj+jQU4kQVIUv4/xbfZWgQgQUp/A5LE54eTlekl0zYiIrKonNx8fPDVFuTlGzPa7lGfLd2FxOQMs7RFVCIKyDlYgBNZQvY6QHsWxg07fxwdoD0DZK83Y5tExaCA4WBERPbs+1/jcCPxntnay8rOw2dLd5mtPaJiU0DOwQKcyMwkSYKU+QOMX8LxSQRIWT9AspMvGHIUpnSE/KwSEVlSTm4+ft/+l9nbjT18Eddv3zV7u0RP5vg5BwtwInPTngZ0F2CZLwEJ0J4ruBNOZC0KuBpNRGSvouLO4X5mrtnblSRg487jZm+X6IkUkHOwACcyt/yjsMzd74cEIN/8V7qJiIjI/hw7dd2Cbd+wWNtESsXngBOZmZT/NwA1Ch49ZglqSPknLVriExWiN2FYl50siEJEZK/OXEqyWNsXriZDq9PDSc17dmQlCsg5WIATmZvuDixXfKOgbV2yBdsn+g9JX7AZeywREVlMcuoDi7Wdl6dFxv1s+JX2tNg5iApRQM7BApzI7Kzxy28fXzDkIEyZV2Un87GIiOyVpRdm1fN7nKxJATkHx5MQmZvKG5b91VL/cw4iIiJSOq9SbhZrW6USUMrD1WLtEykRC3AiMxOc6lr4DJIVzkH0L3rJtI2IiCymVtUAi7UdVN4Xbq7OFmuf6BEKyDlYgBOZm3MjWHaIuB5wbmjB9on+QwGPBCEislf1a5W3WNv1apazWNtERVJAzsECnMjcXFoCgo/l2hd8AZcWlmuf6L8kmNAZyh08EZFj6xxeD2oLrVLeLYIX/MnKFJBzsAAnMjNBcAE8hqDgUWTmpgI8hkAQOByMiIiIgAB/L7RrWdPs7Vat5IfmjSqbvV0ipWMBTmQBgsdwQHAHzPq0bgEQSkHwHGbGNomKQQHDwYiI7Nm4Ye3g7ma+i/OCAEx+vqPZ2iMqNgXkHCzAiSxAUPtD8P4fzDsWRoLgMwuCys+MbRIVg15v2kZERBZVIbA0XhnW3mzt9e3chHe/SR4KyDlYgBNZilt3wH2g+dpzHwzBrav52iMqLgVcjSYisnd9I5tgcE/T14gJa1EDE0aJZoiIyAgKyDmc5A6AyFEJggB4z4QEPZC91rTG3AdA8J5hnsCIiIjIIY0fEYHS3u5YsmY/tNqS3w3s3akxJj/fAU5OlljHhogAFuBEFiUIasD7A8A5GFLGbAB5AHTFPFoNCC4QvKYD7s8UFPREcjDlqrKdXI0mInIUz/UNQUjTavj42x04df52sY6pWK40Xn+hI0KaVLVscERPo4CcgwU4kYUJggB4DABcwyE9+AbI3oCCQtwJgPY/ez98zRVw7wuh1DgIaj6Dk2Sml2D0egZ6++gMiYgcSa2qZbHko6E4ee4W/th5HH+dvokbiXcL1SeBZbzQoFZ5dBUbonWTalCpeKGfbIACcg4W4ERWIqgrQPD5AJLXFCB3B6T8E0DecUCfVrBYuuAHuDSG4NwIcO0EQeUld8hEAABJ0kOSjFvYxNjjiIjIdA1rV0DD2hUAAJlZuUi9lwlJkuDj5Y7S3h4yR0f0KCXkHCzAiaxMUHkVDCl3f0buUIiIiEghPD1c4enhKncYRIrHApyIiJ5Mkowf1mUn87GIiIjIBigg52ABTkRETyaZMB/LTjpDIiIisgEKyDlYgBMR0ZPp9YBg5LwqO5mPRURERDZAATkHC3AiInoyBVyNJiIiIhuggJxDJXcARERERERERErAO+BERPREkl4PycjhYPbySBAiIiKSnxJyDhbgRET0ZAoYDkZEREQ2QAE5BwtwIiJ6Mr0ECI7dGRIREZENUEDOwTngRERERERERFbAO+BERPRkkgTA2EeC2MfVaCIiIrIBCsg5WIATEdETSXoJkpHDwSQ76QyJiIhIfkrIOTgEnYiInkzSm7YZ4euvv0bVqlXh5uaGkJAQHDhw4In7r127FnXr1oWbmxsaNWqEzZs3G3VeIiIikpECcg4W4EREZFPWrFmDyZMnY8aMGThy5AiCg4MRGRmJO3fuFLl/bGwsBg8ejOeffx5Hjx5Fnz590KdPH5w8edLKkRMREZE9kSPnECR7uVdPRERWlZGRAR8fH0QIfeEkOBvVhlbKR7S0Hunp6fD29i7WMSEhIWjZsiW++uorAIBer0dQUBBeffVVvP3224/sP3DgQGRmZmLTpk2G11q3bo0mTZpg0aJFRsVNRERE1qOknIN3wImI6Im0Ui60eiM3KRdAQcf67y03N7fIc+Xl5eHw4cPo2LGj4TWVSoWOHTsiLi6uyGPi4uIK7Q8AkZGRj92fiIiIbJMScg4uwkZEREVycXFBuXLlsC/RtPnUpUqVQlBQUKHXZsyYgZkzZz6yb0pKCnQ6HQIDAwu9HhgYiDNnzhTZfmJiYpH7JyYmmhQ3ERERWYeScg4W4EREVCQ3NzdcvnwZeXl5JrUjSRIEQSj0mqurq0ltEhERkeNQUs7BApyIiB7Lzc0Nbm5uVjtfmTJloFarkZSUVOj1pKQklCtXrshjypUrV6L9iYiIyPYoJefgHHAiIrIZLi4uaN68OXbt2mV4Ta/XY9euXQgNDS3ymNDQ0EL7A8COHTseuz8RERGRXDkH74ATEZFNmTx5MkaMGIEWLVqgVatWWLBgATIzMzFq1CgAwPDhw1GxYkV89NFHAIAJEyagffv2+PTTT9G9e3f8/PPPOHToEBYvXizn2yAiIiIbJ0fOwQKciIhsysCBA5GcnIzp06cjMTERTZo0wdatWw2Lnly7dg0q1f8P4GrTpg1WrVqF9957D++88w5q1aqFDRs2oGHDhnK9BSIiIrIDcuQcfA44ERERERERkRVwDjgRERERERGRFbAAJyIiIiIiIrICFuBEREREREREVsACnIiIiIiIiMgKWIATERERERERWQELcCIiIiIiIiIrYAFOREREREREZAUswImIiIiIiIisgAU4ERERERERkRWwACciIiIiIiKyAhbgRERERERERFbAApyIiIiIiIjICliAExEREREREVkBC3AiIiIiIiIiK2ABTkRERERERGQFLMCJiIiIiIiIrIAFOBEREREREZEVsAAnIiIiIiIisgIW4ERERERERERWwAKciIiIiIiIyApYgBMRERERERFZAQtwIiIiIiIiIitgAU5ERERERERkBSzAiYiIiIiIiKyABTgRERERERGRFbAAJyIiIiIiIrICFuBEREREREREVsACnIiIiIiIiMgKWIATERERERERWQELcCIiIiIiIiIrYAFOREREREREZAUswImIiIiIiIisgAU4ERERERERkRWwACciIiIiIiKyAhbgRERERERERFbAApyIiIiIiIjICliAExEREREREVkBC3AiIiIiIiIiK2ABbgHLly+HIAi4cuWK3KFYxIMHD6BSqTB//nxZ4/j4449Rt25d6PV6q5530aJFqFy5MnJzc4t9zMGDB9GmTRt4enpCEAQcO3bMcgGWgD1/VmfOnAlBEOQOg4hIMczRZ9hCDiFX/vA4jpJXMKcgKh6HL8B79eoFDw8P3L9//7H7DB06FC4uLkhNTbViZPbr5MmTkCQJDRs2lC2GjIwMzJ07F1OmTIFKZd2P8ciRI5GXl4dvv/22WPvn5+ejf//+SEtLw/z58/Hjjz+iSpUqFo6SiIhszcMC5dChQ4VeT09PR6tWreDm5oatW7fKFJ11yJ1DPC5/ePDgAWbMmIEuXbrAz88PgiBg+fLlVomJeQWRsjh8AT506FBkZ2dj/fr1Rf48KysLv//+O7p06QJ/f3+znHPYsGHIzs522C/DEydOAAAaNWokWwzLli2DVqvF4MGDrX5uNzc3jBgxAp999hkkSXrq/hcvXsTVq1fxxhtvYOzYsXjuuefg6+trhUifztE/q0REti4jIwOdO3fG8ePHsX79enTp0kXukCxK7hzicflDSkoK/ve//+H06dMIDg62akyOklcwpyAqHocvwHv16gUvLy+sWrWqyJ///vvvyMzMxNChQ00+V2ZmJgBArVbDzc3NYYeynDhxAmXKlEG5cuVki+H7779Hr1694ObmJsv5BwwYgKtXryIqKuqp+965cwcAULp0abOd/+FnzVSO/lklIrJl9+/fR2RkJI4dO4bffvsNXbt2NUu75uojLEHuHOJx+UP58uVx+/ZtXL16FfPmzbN6XI6QVzCnICoehy/A3d3d8cwzz2DXrl2GL6x/W7VqFby8vNCrVy8AwNWrVzFu3DjUqVMH7u7u8Pf3R//+/R+Zz/JwrsipU6cwZMgQ+Pr6Ijw8HEDRc2BK2u6FCxcwcuRIlC5dGj4+Phg1ahSysrIK7Xvz5k08//zzqFChAlxdXVGtWjW8/PLLyMvLK7TP6NGjERgYCFdXVzRo0ADLli0r8t/qzJkzuHbt2lP/TU+cOIEGDRoUem3JkiVwcXHBxIkTodPpntqGKS5fvozjx4+jY8eOFj3PkzRv3hx+fn74/fffn7jfyJEj0b59ewBA//79IQgCIiIiDD8/evQounbtCm9vb5QqVQodOnRAfHx8oTae9Fkz1X8/qyX5/BWlpMcX5/0DwL59+9CyZUu4ubmhRo0ajx2mV9zP+/379zFx4kRUrVoVrq6uKFu2LDp16oQjR4489T0SEZnDgwcP0KVLFxw5cgS//fYbunfvXujnxf0+e1wfUdLv45LkC/9V3PwBkDeHeFL+4OrqKuuNBXPkFcXtUy2VVxSV/1ozrzB3TgEU7/eCOQWVlJPcAVjD0KFD8cMPP+CXX37B+PHjDa+npaVh27ZtGDx4MNzd3QEULGoRGxuLQYMGoVKlSrhy5QoWLlyIiIgInDp1Ch4eHoXa7t+/P2rVqoUPP/zwicOGStrugAEDUK1aNXz00Uc4cuQIvvvuO5QtWxZz584FANy6dQutWrXCvXv3MHbsWNStWxc3b97Er7/+iqysLLi4uCApKQmtW7eGIAgYP348AgICsGXLFjz//PPIyMjAxIkTC52zXr16aN++PaKjo5/473nixAnD0C2tVouJEydi8eLF+PrrrzFmzJgnHmsOsbGxAIBmzZpZ/FxP0qxZM+zfv/+J+7z44ouoWLEiPvzwQ7z22mto2bIlAgMDAQB///032rZtC29vb7z11ltwdnbGt99+i4iICOzZswchISGF2iruZ80cnvb5M8fxxX3/J06cQOfOnREQEICZM2dCq9VixowZhn/Hh0ryeX/ppZfw66+/Yvz48ahfvz5SU1Oxb98+nD59WvbPFRE5vszMTHTt2hUHDx7Er7/+ih49ehT6eUn7b+DRPuLhTYfifB8bc75/K27+AMibQ9hK/vA4puQVJc0pAMfKK8ydUwDF/71gTkElJimAVquVypcvL4WGhhZ6fdGiRRIAadu2bYbXsrKyHjk+Li5OAiCtWLHC8NqMGTMkANLgwYMf2f/777+XAEiXL182ut3Ro0cX2rdv376Sv7+/4e/Dhw+XVCqVdPDgwUfa1ev1kiRJ0vPPPy+VL19eSklJKfTzQYMGST4+Po/EBEBq3779I+39261btyQA0qJFi6TU1FRJo9FIfn5+UlRU1BOPM6f33ntPAiDdv3/faucsytixYyV3d/en7hcVFSUBkNauXVvo9T59+kguLi7SxYsXDa/dunVL8vLyktq1a2d47UmfNVP997Na3M/f45Tk+OK+/z59+khubm7S1atXDa+dOnVKUqvV0r+/wkryeffx8ZFeeeWVp74fIiJzevidW6VKFcnZ2VnasGFDkfuV5PvscX1ESb6Pi3u+ovIbSSpe/iBJ8ucQxc0fDh48KAGQvv/+e6vE9ZApeUVx+1RJslxeUdTnw1p5hblzCkkq/u8FcwoqKYcfgg4UzEkZNGgQ4uLiCg2LWbVqFQIDA9GhQwfDaw/vhAMFq0ympqaiZs2aKF26dJFDSV566aVixWBqu23btkVqaioyMjKg1+uxYcMG9OzZEy1atHjkWEEQIEkSfvvtN/Ts2ROSJCElJcWwRUZGIj09/ZHzSpL01KvXx48fN5yjZcuWuHXrFhISEgoNq7a01NRUODk5oVSpUo/8LD4+HoIgYObMmUa3X9w2fH19kZ2dXawhVP+l0+mwfft29OnTB9WrVze8Xr58eQwZMgT79u1DRkZGoWOK+1kzx7/Bkz5/5ji+uO9fp9Nh27Zt6NOnDypXrmzYr169eoiMjDT8vaSf99KlSyMhIQG3bt0q/j8KEZGZJCUlwc3NDUFBQY/8zJj+G3h8H/G072Njz/ffmItz91vuHOJJ+YOllKRPNjavMCanABwnrzB3TgGU7PeCOQWVlCIKcACGRdYeLsZ248YNxMTEYNCgQVCr1Yb9srOzMX36dAQFBcHV1RVlypRBQEAA7t27h/T09EfarVatWrHOX9J2//3FAMCwuuXdu3eRnJyMjIyMJz7CIzk5Gffu3cPixYsREBBQaBs1ahQAFDkn/mkerl46fvx4BAYGIi4uDjVr1ixxO45A+me4ljGLjSQnJyMrKwt16tR55Gf16tWDXq/H9evXC71e3M+aOTzp82eO44v7/pOTk5GdnY1atWo9st+/jy3p5/3jjz/GyZMnERQUhFatWmHmzJm4dOlSsd4bEZGpvv32W7i4uKBLly44e/ZsoZ8Z238/ro8ozvexJfKFojCHeDJj8wpjcgrAcfIKc+cUQMl+L5hTUEkpYg44ULC4Rd26dbF69Wq88847WL16NSRJemT181dffRXff/89Jk6ciNDQUPj4+EAQBAwaNAh6vf6Rdv99Z/tJStruvy8K/NvDL+enedjmc889hxEjRhS5T+PGjYvV1r+dOHECVapUQY0aNXDy5Ek8ePDArKtwFoe/vz+0Wi3u378PLy+vQj9r1qwZrl+/Dm9vb6PbL24bd+/ehYeHR7E/A6Yq7nnM8W9g6ufP1ONLqqSf9wEDBqBt27ZYv349tm/fjnnz5mHu3LlYt26d2VYhJiJ6nPr162Pz5s3o0KEDOnXqhP379xvuhhvbfz+uj3ja97Gl8oWiyJ1DPCl/sJSS9MnMKyx3fEmV5PeCOQWVlGIKcKDgLvi0adNw/PhxrFq1CrVq1ULLli0L7fPrr79ixIgR+PTTTw2v5eTk4N69eyad25ztBgQEwNvbGydPnnziPl5eXtDpdGZdLfzEiRNo0qQJlixZghYtWqBv376IiYkx++PAli5dio0bN+L333/HmTNn0L9/f8ybNw9dunRB3bp1ARSsZvrfpMDFxQWVKlUy6dzFbePy5cuoV6+eUecICAiAh4fHI3c+gILVZFUqVZFDE4vDHP8Gllbc9+/p6Ql3d3ecP3/+kf3+fawxn/fy5ctj3LhxGDduHO7cuYNmzZph9uzZ7CyJyCpatWqFDRs2oHv37ujUqRNiYmIMd9gs0X8/jjXPZ40cwtj8wVJK0icbm1dYMqcAbD+vMHdO8bDNkvxeMKegklDMEHTg/4ehT58+HceOHSvy2d9qtfqRq2lffvmlyY/FMGe7KpUKffr0wR9//IFDhw498nNJkqBWq/Hss8/it99+K7JQT05OfuS1pz1GRKfT4fTp02jUqBECAgKwbt06nDx5Ei+//PIj+yYlJaFXr17o2LEjrly5gl9++QUhISGYOnVqsd7jiRMn0LhxY8TGxuLZZ5/F8uXL0aVLFwBAaGgoABT53q3pyJEjaNOmjVHHqtVqdO7cGb///nuhdQmSkpKwatUqhIeHm3Sl2dYV9/2r1WpERkZiw4YNhT6bp0+fxrZt2wq1V9zPu06ne2TaR9myZVGhQgXk5uaa8V0SET1Zhw4dsHr1aly4cAFdunRBRkaGUf23KcxxvuI8hqy4OYQS8ofHMTavYE5h3pziYZvF+b1gTkHGUNQd8GrVqqFNmzaGZywWVYD36NEDP/74I3x8fFC/fn3ExcVh586d8Pf3N+nc5m73ww8/xPbt29G+fXuMHTsW9erVw+3bt7F27Vrs27cPpUuXxpw5cxAVFYWQkBCMGTMG9evXR1paGo4cOYKdO3ciLS2tUJtPe4zI+fPnkZOTg0aNGgEoGNa/cOFCjBo1Cs2bNy/0iLdPP/0Uc+bMQXZ2NoYOHQovLy/s2rUL3333HXbt2lVo4buinDhxAuXKlUPv3r2RkJBQaFGN6tWro2HDhti5cydGjx5drH8vQRCK/YiU4jh8+DDS0tLQu3dvo9v44IMPsGPHDoSHh2PcuHFwcnLCt99+i9zcXHz88cdmidOWFff9v//++9i6dSvatm2LcePGQavV4ssvv0SDBg0MC/oAKPbn/f79+6hUqRL69euH4OBglCpVCjt37sTBgwcLjVAhIrKGvn37YsmSJRg9ejR69eqFrVu3lrj/NpWp5yvOY8iKm0PImT989dVXuHfvnmExrT/++AM3btwAUDCV0MfHB4D5cwrA9LyCOYV5cwqgeL8XzCnIGIoqwIGCojs2NhatWrUqcuGPzz//HGq1Gj/99BNycnIQFhaGnTt3PrI6YkmZu92KFSsiISEB06ZNw08//YSMjAxUrFgRXbt2NTxTPDAwEAcOHMD//vc/rFu3Dt988w38/f3RoEGDYj938d8eLp7y78XfRo4ciYMHD2Ly5Mlo3Lgx2rVrB6Bg0bn69esDAGrVqoXu3bujVKlS6NKlC3bv3l2sDjQ/Px/5+fm4ceNGoQ4UAEaPHo3p06cjOzv7qXOYHjx4AKBgeJC5rF27FpUrV4ZGozG6jQYNGiAmJgZTp07FRx99BL1ej5CQEKxcubLI53U6muK+/8aNG2Pbtm2YPHkypk+fjkqVKuH999/H7du3C3WWxf28e3h4YNy4cdi+fTvWrVsHvV6PmjVr4ptvvilyNAcRkaWNGjUKaWlpeOONN9C/f3+sX7/erP3305g7XyhKcXMIOfOHTz75BFevXjX8fd26dVi3bh2AgrnAPj4+FskpANPzCuYU5s0pgOL9XjCnIGMIkqVWLyBFmzp1Kp599lm4uLjg9ddfR2ZmJn7//XcsW7YMoaGhhkK9KElJSahatSru3buH//3vfzhw4AB27NhRaJ/09HRUr14dH3/8MZ5//vknxrJ582b06NEDf/31l+HKuylyc3NRtWpVvP3225gwYYLJ7REREVEBW8ofimLunAJgXkGkNIq7A07W8dZbb+G1115Deno6Fi9ejPPnz6N///6IiIgo1HmOHDkSALB8+XLDaydOnEC9evXg6uqKiRMnomrVqoiPj0fr1q0N+/j4+OCtt97CvHnzMGrUKKhUj1/OICoqCoMGDTJbR/n999/D2dm52M/PJCIiouKxpfyhKObOKQDmFURKwzvgJKuOHTti4MCBGDNmjOG1+fPn4+jRo1ixYgUAYMKECbhw4QL+/PNPucIkIiIiG8L8gYjsFQtwko1Wq0Xjxo3x119/wdnZWe5wiIiIyA4wfyAie8YCnIiIiIiIiMgKFPUccCIiIiIiIiK5sAAnIiIiIiIisgIW4ERERERERERWwMeQERHRY+Xk5CAvL8+kNlxcXODm5mamiIiIiMgRKSXnYAFORERFysnJQbUqpZB4R2dSO+XKlcPly5dtvkMkIiIieSgp52ABTkRERcrLy0PiHR0uH64Cby/jZixl3NejWvOryMvLs+nOkIiIiOSjpJyDBTgRET2RZ6mCzRg6PuiSiIiIikkJOQcLcCIieiI9JOhhXK9m7HFERESkPErIObgKOhEREREREZEV8A44ERE9kR566E04loiIiKg4lJBzsAAnIqIn0kkSdJJxw7qMPY6IiIiURwk5BwtwIiJ6IiXMxyIiIiL5KSHn4BxwIiIiIiIiIivgHXAiInoiPSToHPxqNBEREclPCTkHC3AiInoiJQwHIyIiIvkpIedgAU5ERE+khAVRiIiISH5KyDk4B5yIiIiIiIjICngHnIiInkj/z2bssURERETFoYScgwU4ERE9kc6EBVGMPY6IiIiURwk5BwtwsjhJ0gNSNgAdILhDEJzlDomISkAnFWzGHktERERUHErIOViAk0XotZegzVoLXd5B6LUn/ynAAUAFwak61M7NoHbvAbVLWwgClyIgIiIi0+Tka3H6TjJupmdAp9ejlKsL6pYNQEUfb7lDIyIyYAFOZqXPP4PcjPehz4sFoAag++8ekLQXoNVehjb7FwiqinD2egNO7n0hCIIMERPR0yhhPhYR2ac8nQ5bzpzDz0eP4+jN20Wuguzn4Y4e9epgaLNgVPf3kyFKIiouJeQcLMDJLCRJj/wHXyP/wfx/vfrf4huP/EzS30Re+iRoczbC1edjqNRlLRonEZWcHgJ0MO4Cmd7I44iInib+6nVM3bwdN9IznrhfWlY2Vhw+hh8PH8Ogpo0xRWwLTxcXK0VJRCWhhJyDBTiZTJK0yL03CbqcPwAjFz/Q5+5FTkpvuPmvhcqpknkDJCKT6KWCzdhjiYjMbV50DJbEHypR1iEBWH30OGIuXcHi/n1Qq4y/pcIjIiMpIefg5FsyWV76eyYV3wV0kPRJyEkbCEl/z0yRERERkaP53/YoLC5h8f1vN9IzMPSntbiQkmrWuIiIioMFOJlEm7MV2uzVMK34fkgHSXcbuekzzNAWEZmL7p/hYMZuRETmsvavk/jxyDGT27mbnY2Xf9uInHyt6UERkdkoIedgAU5Gk/QZyL33NmDWD7sOupwN0ObsNmObRGQKa3aGe/fuRc+ePVGhQgUIgoANGzY89Zjo6Gg0a9YMrq6uqFmzJpYvX27cGyUim3Y74z4+2r3XbO1duXsPn+3db7b2iMh0Ssg5WICT0bTZvwHSPZjn7ve/qZD/4Gszt0lExtJLgklbSWRmZiI4OBhff12874DLly+je/fuEEURx44dw8SJE/HCCy9g27ZtxrxVIrJhC+MO4H5urlnbXHHoKBLvPzBrm0RkPCXkHFyEjYwiSRLyM7+3UOt66PMPQZ9/FirnOhY6BxEVlynDukp6XNeuXdG1a9di779o0SJUq1YNn376KQCgXr162LdvH+bPn4/IyMgSnZuIbNeD3Dxs/Pu02dvVSRJ+PnocE9u1MXvbRFRySsg5eAecjCLprkDSXYX5734/pIY2d5eF2iYia8vIyCi05ZrpLlZcXBw6duxY6LXIyEjExcWZpX0isg17Ll1GZl6+RdrecuacRdolInnYes7BApyMos8/YeEzSNDnHbfwOYioOHRQmbQBQFBQEHx8fAzbRx99ZJbYEhMTERgYWOi1wMBAZGRkIDs72yznICL5nbidZLG2L6fdNfvQdiIyjhJyDg5BJ6PotedQ8PGx1Oqheui1pyzUNhGVhGTEvKp/HwsA169fh7e3t+F1V1dXs8RGRMpw3oKPDJMAXEhJRdOKFSx2DiIqHiXkHCzAySiSlAXzrn5e1El494rIFphjPpa3t3ehztBcypUrh6SkwnfGkpKS4O3tDXd3d7Ofj4jkkZmXZ+H2LTO8nYhKRgk5B4egk1EEOFvhLNY4BxHZs9DQUOzaVXi9iB07diA0NFSmiIjIEpxVagu3z5SYiJ7MXDkHv23IKII6CJYbfg4AAgSnKhZsn4iKSyepTNpK4sGDBzh27BiOHTsGoOCRH8eOHcO1a9cAAFOnTsXw4cMN+7/00ku4dOkS3nrrLZw5cwbffPMNfvnlF0yaNMls75+I5FfZ18fC7Ze2aPtEVDxKyDk4BJ2MonJuBMutgA4Aaqidgy3YPhEVlx4C9EZer9WX8Hvi0KFDEEXR8PfJkycDAEaMGIHly5fj9u3bho4RAKpVq4Y///wTkyZNwueff45KlSrhu+++4yPIiBxMg3Jlgb8s07a/hwfKe3tZpnEiKhEl5BwswMkoKue6gOABSFkWOoMWKpdWFmqbiErCms/kjIiIgCQ9vgNdvnx5kcccPXq0pKERkR0Jq1oFAixz6b9tNY64I7IVSsg5OASdjCIIrnByHwTAMnOyBFU5qF3bW6RtIiIisi9VfEsj3EKF8pBmjS3SLhFRUViAk9GcPYfBMteiBTh5joIgWHbBFSIqHmvOxyIiepwXW7c0e5utgirx8WNENkQJOYd9REk2SeVUHc6eL8O8jyNTQ1DXgLPnaDO2SUSmKJiPZfxGRGQOIVWCMKhJI7O15+7shA+7dTJbe0RkOiXkHCzAySTOXhMgONWEeYaiCwAEuPougCC4mKE9IjIHPVTQGbkZu5AKEVFR3ta0Q72yASa3IwCY2VmDKlz9nMimKCHnsI8oyWYJgivc/FZCUAXCtCL8YfH9NdTO5ru6TURERI7D08UF3w96Bg0CyxrdhkoQ8H5kBzzTqIEZIyMiKh4W4GQylboc3MpsgMq5vpEtqAHBC66+y+Dk1sWssRGR6ZQwH4uI7Ie/hwdWPzcAI1o0LfGA08qlfbBySD8MbsqF14hskRJyDj6GjMxCpQ6Em/8G5Gd+h/z7nwDQ4ukLtKkB6KB27QhXn9kQ1KYPKSMi89ObMKyrpM/kJCIqDndnZ7zXMQI96tfBsgOHsfPcReTr9Y/dP6i0DwY3bYznmgXD3dnZipESUUkoIedgAU5mIwhOcCn1Epw9BkKb9Qvys1ZB0l0pct+M+4Bf2cFw9hxW8ExxIrJZOkmATjLymZxGHkdEVBxNKpTHF316ICUzEwev38TfiXdwIz0dWr0eXq6uuHH8L2xavgwnj/8FVxeuL0Nk65SQc7AAJ7MTVL5wLvUinEu9CEmfDn3+SUj6O5AkPQRVKeyOvoXIrqNx6dILqFa6mtzhEhERkZ0r4+mJrnVro2vd2oVeP1CmNFZOfQtHjxxB69atZYqOiOj/sQAnixJUPlC7hhV6rWXIXQjC84iKikK1aizAiWzdw9VFjTvWPoaDEZFjatasGby8vBAVFcUCnMgOKCHnsI+Z6uRQfH190bRpU0RFRckdChEVg15SmbQREcnFyckJbdu2Zc5BZCeUkHPYR5TkcERRRFRUFCTJPq5UESmZsc/jNOUqNhGRuYiiiP379yMvL0/uUIjoKZSQc9hHlORwRFHEzZs3ceHCBblDIaKn0OP/F0Up6fb4NYmJiKxDFEVkZWXhwIEDcodCRE+hhJyDBTjJom3btlCr1YiOjpY7FCIiInJgTZo0gY+PD4ehE5FNYAFOsvD29kbz5s3ZGRLZgYfP5DR2IyKSk1qtRrt27XjRn8gOKCHnsI8oySFFRERwHjiRHdBJKpM2IiK5iaKI2NhY5Obmyh0KET2BEnIO+4iSHJIoikhMTMTZs2flDoWInkAPwaSNiEhuoigiJycH8fHxcodCRE+ghJyDBTjJJjw8HE5OThyGTkRERBbVuHFj+Pn5MecgItmxACfZlCpVCi1btmRnSGTjlDAcjIgcm0qlQvv27ZlzENk4JeQc9hElOSxRFBEdHc154EQ2TAnP5CQixyeKIuLj45GdnS13KET0GErIOewjSnJYoigiOTkZp06dkjsUInoMvSSYtBER2YKIiAjk5eUhLi5O7lCI6DGUkHOwACdZtWnTBs7OzhwSRkRERBbVoEEDlClThjkHEcmKBTjJysPDAyEhIewMiWyY3oShYPbyTE4icnwqlcrwCFQisk1KyDnsI0pyaA/ngev1erlDIaIi6CWVSRsRka0QRREHDhxAZmam3KEQURGUkHPYR5Tk0ERRRFpaGk6cOCF3KGTj9NqLyM9ahdx7byM7dTCyU55Fduow5GbMgjb7d0i6VLlDdEg6CCZtRES2QhRF5OfnY//+/XKHQnYkV6vF/Zxc5Ol0cofi8JSQczjJHQBRaGgoXF1dER0djeDgYLnDIRsjSRJ0OVuRn7kU+vyDAAQAagBawz76vFhooQXgBLVbdziXGgu1c0OZIiYiIltVt25dBAYGIioqCp07d5Y7HLJRuVot/jx9FrsvXMLfiXdwIz0DQEEGUtm3NBqWK4uOtWoisk5NOKvV8gZLdocFOMnOzc0NoaGhiIqKwoQJE+QOh2yIXpeE3PS3oM+Nxv8P2JHw7+K7gNbw/7qcTdDlbISz58tw9poAQXCzVrgOy5RhXfYyHIyIlEEQBERERCA6OlruUMgG6fR6fHfgML6LP4R7OTmP/FwCcPXuPVy9ew9/nj6HAE8PvBLWGkOaNoYg2MfdV1unhJzDPqIkhxcREYE9e/ZAx6E99A9d3l/ITu4IfW7MP68Ud40AHQAJ+ZkLkZPyDCR9moUiVA4dTBkSRkRkW0RRxMGDB3H//n25QyEbcvXuPQz48Wd8Er2vyOK7KMmZWZi5fTeGr/4NSfcfWDhCZVBCzsECnGyCKIq4d+8e/vrrL7lDIRugy/8bOWmDACkTMPrrVIJeewbZqYMg6TPMGZ7iKGFBFCJSDlEUodPpsG/fPrlDIRtxISUVg1auwfHbSUYdH3/tOgatXINb6cw3TKWEnMM+oiSHFxISAjc3Nz4ahCDps5Cb9gIg5cD44vshHSTtBeSmv2eO0IiIyAHUqlULFSpUYM5BAIB72TkYtWYdUjKzTGrnRnoGRv2yHjn5/50mR1QYC3CyCa6urggLC+OcLELe/Y8h6RNR/CHnT6ODLud3aHO2m6k95dFJKpM2IiJbIggCRFFkAU4AgFk7o5BopuHjl1LT8OkejqwwhRJyDvuIkhRBFEXs3bsXWi2vHCqVXncL2qzlMF/x/ZCAvIwPIUmSmdtVBgkC9EZukp08EoSIlCUiIgJHjhxBenq63KGQjBKu3cDGv8+Ytc0Vh4/hXHKKWdtUEiXkHCzAyWZEREQgIyMDR48elTsUkok2axVgkS9PCZLuMvR58RZo2/Ep4Wo0ESmLKIrQ6/WIiYl5+s7ksH48bP6cUy9JWHmEaxoZSwk5h31ESYrQsmVLeHh4cEiYgmmzfoX5734/pIY2e4OF2nZsekkwaSMisjXVq1dHUFAQcw4Fu5edg13nL1mk7Y1/n0Y+n+xjFCXkHCzAyWa4uLggPDycnaFCSfo0SPrbFjyDDrr8wxZsn4iI7AXngdOJxCRo9Za56J+Zl49zyakWaZvsHwtwsimiKCImJgb5+flyh0JWps//2+LnkLSXIEm5Fj+Po9FBZdJGRGSLRFHEsWPHkJaWJncoJINTicY9cqzY7SfdsWj7jkoJOYd9REmKIYoiMjMzcfgw71QqjaS/Z4Wz6AC9eVY6VRIlDAcjIuWJiIiAJEnYu3ev3KGQDNKysi3cvmmPNVMqJeQcLMDJpjRv3hylSpXikDBFstKXpsCvvZLSQ2XSRkRki6pWrYqqVasy5yCyIUrIOewjSlIMJycntG3blp2hAgkqXyucxQkQSlnhPEREZA9EUUR0dLTcYZAMypTytGz7npZtn+wXC3CyOaIoYv/+/cjLy5M7FLIilXNDy5/DqRYEwdni53E0OkkwaSMislWiKOL48eNISeFzm5WmYWBZy7ZfLtCi7TsqJeQcLMDJ5oiiiKysLBw4cEDuUMiKBJUPBHWQBc+ghsqluQXbd1xKmI9FRMokiiIAYM+ePTJHQtbWsHwgXNRqi7Tt7eqKGmX8LNK2o1NCzsECnGxO06ZN4ePjwyFhCuTkPhCW+1rSwcn9WQu17dgkSQW9kZsksZshIttVqVIl1KxZk1PfFMjL1RVd6taySNvPNKoPJxX7P2MoIeewjyhJUdRqNdq1a8fOUIGcPQbBMouxqSA41YHKuakF2iYiInsWERHBnEOhhjdvavasw0mlwtBmwWZulRwJC3CySaIoIjY2Frm5fGazkgjqADh7vgTzF+F6uHpPhyDYx9AkW6ODYNJGRGTLRFHEqVOncOcOn9usNMEVymFgk0ZmbXNs65ao6meNhWUdkxJyDhbgZJMiIiKQk5OD+Ph4uUMhK1N7voqUtFLQaiUztaiCk/sQqF3DzdSe8uglU+ZkyR09EdGTPZwHzqlvyiNJEjxOHENeSrJZ2mtYrixeCQsxS1tKpYScgwU42aTg4GD4+vpySJjCZGVlYeDAYejU+xy0OncApi6OooLKuQlcfKabIzzFMnYu1sONiMiWlS9fHnXq1GHOoTD5+fl46aWX8M5bb6K3i4CKPt4mtVerjD++69/XYgu7KYUScg77iJIUR6VSoX379uwMFSQxMRERERHYsmULPv7kF/hW3ARB5Q9TinCVSyu4+f0IQXA3X6BERORwRFFkzqEg9+7dQ7du3bBs2TIsXboUX3w4G2ueG4iwqpWNaq9z7ZpYNXQA/D09zBwpOSIW4GSzRFFEfHw8srOz5Q6FLOzkyZMICQnBjRs3sHfvXvTp0wcq51pwD9gJtVvvf/YqbiGuBuAEF6934Oa3CoKqlIWiVg49BJM2IiJbJ4oizp49i1u3bskdClnY5cuXERYWhkOHDmH79u0YPXo0ACDQqxSWD3oWs7t2RKVi3g2v7ueLBb274etneqK0u5slw1YMJeQcTnIHQPQ4oigiLy8PcXFx0Gg0codDFrJt2zb0798f1atXx6ZNm1CpUiXDzwSVD9x850OXOxD5mcugy90BQI+Cry49AAn/fx1RBwgecHIfCGfPkVA5VbX2W3FYOkmAzshnaxp7HBGRNbVv3x5AwTzwIUOGyBwNWUp8fDx69+6NUqVKIS4uDnXr1n1knwHBjdCvcUNEX7yMqAuXcDIxCZdS7yJPp4OrkxNqlvFDo3KB6FS7JtoYececHk8JOQcLcLJZDRo0QJkyZRAVFcUC3EEtXLgQr776Krp06YLVq1fDy8uryP3Urq2hdm0NvS4J+rzD0OefhF53DZDyAJUHVE61oHJuBLVzCwgqDv8yN1PmVdnLfCwiUrbAwEDUr1+fBbgD++WXXzBixAg0b94cGzZsQJkyZR67r0oQoKlZHZqa1a0YIQHKyDlYgJPN4jxwx6XT6fDmm29i/vz5eO211/DZZ59BXYxFS1TqQKjcuwHu3awQJRERKYkoiti2bZvcYZCZSZKEjz76CO+++y6GDBmCpUuXws2Nw8VJPvZxmYAUSxRFHDhwAJmZmXKHQmby4MEDPPPMM/j888/x5Zdf4vPPPy9W8U3y0cPYx4EYPx/r66+/RtWqVeHm5oaQkBAcOHDgifsvWLAAderUgbu7O4KCgjBp0iTk5OQYdW4iUiZRFHHhwgXcuHFD7lDITPLy8jB69Gi8++67mDFjBlauXMni28YpIedgAU42TRRF5OfnY//+/XKHQmZw8+ZNtGvXDrt378Yff/yB8ePHyx0SFYNkwmIokhGd4Zo1azB58mTMmDEDR44cQXBwMCIjI3Hnzp0i91+1ahXefvttzJgxA6dPn8bSpUuxZs0avPPOO6a+dSJSkIfzwDnyzjGkpaWhc+fOWLVqFVauXImZM2dCEOxjjrCSKSHnYAFONq1evXoIDAxEdHS03KGQiY4ePYpWrVohJSUF+/fvR7duHEZuL4y+Ev3PVlKfffYZxowZg1GjRqF+/fpYtGgRPDw8sGzZsiL3j42NRVhYGIYMGYKqVauic+fOGDx48FOvYBMR/VuZMmXQqFEjFuAO4MKFCwgNDcXJkyexc+dODB06VO6QqJiUkHOwACebJggCIiIi2BnauT/++ANt27ZF+fLlkZCQgMaNG8sdEpXAwwVRjN0AICMjo9CWm5tb5Lny8vJw+PBhdOzY0fCaSqVCx44dERcXV+Qxbdq0weHDhw2d36VLl7B582Ze5CGiEuPzwO1fTEwMQkJCABSset62bVuZI6KSUELOwQKcbJ4oijh48CDu378vdyhUQpIkYcGCBejduzc6deqEPXv2oHz58nKHRTIICgqCj4+PYfvoo4+K3C8lJQU6nQ6BgYGFXg8MDERiYmKRxwwZMgT/+9//EB4eDmdnZ9SoUQMREREcgk5EJSaKIq5cuYIrV67IHQoZYeXKlejYsSMaN26MuLg41KxZU+6QSAa2nnOwACebFxERAZ1Oh3379skdCpWAVqvF+PHjMWnSJLz++uv47bff4OnpKXdYZARzDAe7fv060tPTDdvUqVPNFl90dDQ+/PBDfPPNNzhy5AjWrVuHP//8E7NmzTLbOYhIGdq3bw9BEDj1zc5IkoQZM2Zg2LBhGDx4MLZt2wY/Pz+5wyIjKCHn4GPIyObVrl0b5cuXR1RUFLp27Sp3OFQMGRkZGDhwIHbs2IFvv/0WY8eOlTskMsHDxU2MPRYAvL294e3t/dT9y5QpA7VajaSkpEKvJyUloVy5ckUeM23aNAwbNgwvvPACAKBRo0bIzMzE2LFj8e6770Kl4rVmIioeX19fNGnSBFFRURg5cqTc4VAx5OTkYPTo0Vi9ejVmz56NqVOncrE1O6aEnINZCdk8QRAgiiKvRtuJa9euITw8HLGxsdiyZQuLbwdgzQVRXFxc0Lx5c+zatev/z6/XY9euXQgNDS3ymKysrEc6vIePtpMkqYTvloiU7uE8cH5/2L7k5GR07NgR69atM6xEzeLbvikh52ABTnZBFEUcPnwY6enpcodCT3Dw4EG0atUK9+/fR1xcHDp16iR3SGSHJk+ejCVLluCHH37A6dOn8fLLLyMzMxOjRo0CAAwfPrzQcLKePXti4cKF+Pnnn3H58mXs2LED06ZNQ8+ePfmMeSIqsYiICFy/fh2XLl2SOxR6gjNnzqB169Y4d+4coqOjMWDAALlDIjskR87BIehkF0RRhF6vR0xMDHr06CF3OFSEdevW4bnnnkNwcDA2bNjwyIIWZL+MfbTHw2NLauDAgUhOTsb06dORmJiIJk2aYOvWrYbP1LVr1wpdfX7vvfcgCALee+893Lx5EwEBAejZsydmz55tVMxEpGzt2rWDSqVCVFQUatSoIXc4VITdu3fj2WefRYUKFbBz505Uq1ZN7pDITJSQcwgSx9eQHZAkCVWqVEH//v3x6aefyh0O/YskSZg3bx6mTJmCAQMGYPny5XB3d5c7LDKDjIwM+Pj4IHLLWDh7uhjVRn5mHrZ1XYz09PRizcciIrIFLVu2RJ06dbBy5Uq5Q6H/+P777zF27FiIoohffvkFpUuXljskMgMl5Rwcgk52gc8Dt035+fkYO3YspkyZgnfffRerV69m8e2ArDkfi4jIFnAeuO3R6/WYOnUqRo8ejdGjR+PPP/9k8e2AlJBzsAAnuyGKIo4dO4a0tDS5QyEA9+7dQ9euXfHDDz9g+fLl+OCDD7jaNBEROQRRFHHr1i2cP39e7lAIQHZ2NgYOHIi5c+fik08+waJFi+Ds7Cx3WERG4RxwshuiKEKSJMTExKB3795yh6Noly5dQvfu3ZGUlITt27cjIiJC7pDIgiTA6EeC8N4REdmj8PBwqNVqREVFoXbt2nKHo2hJSUno1asXTp48iXXr1qFPnz5yh0QWpIScg7eryG5UrVoVVatW5TB0mcXGxqJ169bQarWIj49n8a0AShgORkT0b15eXmjRogVzDpmdPHkSISEhuH79Ovbu3cviWwGUkHOwACe78nBOFsnj559/hkajQZ06dRAXF8e7AgqhhM6QiOi/RFFEdHQ054HLZNu2bQgLC4OPjw8SEhLQvHlzuUMiK1BCzsECnOyKKIo4fvw4UlJS5A5FUSRJwgcffIDBgwejf//+2LlzJ8qUKSN3WERERBYjiiKSkpJw5swZuUNRnEWLFqF79+4ICwvDvn37EBQUJHdIRGbDApzsysPhznv27JE3EAXJzc3FyJEjMW3aNLz//vtYsWIFXF1d5Q6LrEgJV6OJiP4rLCwMzs7OHHlnRTqdDpMnT8bLL7+Ml19+GRs3boSXl5fcYZEVKSHnYAFOdiUoKAg1atRAdHS03KEoQmpqKjp37oyff/4ZP/30E6ZPnw5BsI8vNzIfJXSGRET/5enpiVatWrEAt5IHDx7gmWeeweeff44vvvgCX375JZycuF600igh5+CnmuwO54Fbx/nz59G9e3fcvXsXu3fvRlhYmNwhkUwkSYBkZKdm7HFERLYgIiIC3377LfR6PR+1aUE3b95Ez549cf78eWzcuBHdu3eXOySSiRJyDn6TkN0RRRF///037ty5I3coDmvv3r1o3bo1VCoV4uPjWXwTEZEiiaKIlJQU/P3333KH4rCOHTuGkJAQJCcnY9++fSy+yeGxACe783AeOIehW8aKFSvQsWNHBAcHIy4uDjVq1JA7JJKZHoJJGxGRvWrTpg1cXFw48s5CNm3ahPDwcAQGBiIhIQHBwcFyh0QyU0LOwQKc7E6FChVQu3ZtdoZmJkkSpk+fjhEjRmDYsGHYunUrfH195Q6LbIAS5mMRERXF3d0drVu35kV/C/jiiy/Qu3dvdOzYEXv37kWFChXkDolsgBJyDhbgZJc4D9y8cnJyMGTIEMyaNQtz5szBd999BxcXF7nDIhvxcD6WsRsRkT0TRRF79uyBXq+XOxSHoNVq8eqrr2LChAmYNGkSfvvtN3h6esodFtkIJeQcLMDJLomiiLNnz+L27dtyh2L3kpOTodFosGHDBqxduxZTpkzhSudUiBKuRhMRPY4oikhLS8Px48flDsXuZWRkoFevXli4cCEWLVqETz75BGq1Wu6wyIYoIedgAU52ifPAzeP06dMICQnBpUuXsGfPHvTr10/ukIiIiGxKSEgIXF1dOfLORNeuXUN4eDj279+PzZs348UXX5Q7JCJZsAAnuxQYGIj69euzMzTBrl27EBoaCg8PDyQkJKBVq1Zyh0Q2SgnDwYiIHsfNzQ1t2rRhzmGCQ4cOISQkBBkZGYiNjUXnzp3lDolslBJyDhbgZLc4D9x43333Hbp06YLWrVtj//79qFKlitwhkQ2TTBgKZi+dIRHRk4iiiL1790Kn08kdit1Zv3492rVrhypVqiAhIQENGjSQOySyYUrIOViAk92KiIjAhQsXcOPGDblDsRt6vR5TpkzBmDFj8MILL2DTpk3w8fGROyyycRIASTJykzt4ouLIywOOHAHWrwfWrAE2bgTOngW46Bb9QxRFpKen49ixY3KHYjckScK8efPw7LPPokePHoiKikJgYKDcYZGNU0LO4SR3AEWRdCnQ5R+FPv8EJN1NSJIWgsoDKqfaUDk3hsq5MQTBWe4wSWYP54FHRUVh2LBh8gZjB7KysjB8+HCsW7cOn332GSZOnMjF1ohIubKygJ9/BpYtAw4eLCjC/8vLC4iIAF58EejSBeBiUYrVqlUreHh4ICoqCs2bN5c7HJuXn5+PV155BUuWLMHUqVPxwQcfQKXifT8iwMYKcF1uAvIzv4cudxsAPYB/d3QCAB0ACVD5wdljGJw8noNKXVaWWEl+ZcqUQaNGjRAdHc0C/CkSExPRq1cv/P3331i/fj169+4td0hkR/QQIMC4izV6I48jshi9Hli0CHjvPeDu3Sfve/8+8McfBVuNGsA33wCcu6pILi4uCAsLQ1RUFN544w25w7Fp9+7dQ//+/REdHY1ly5Zh1KhRcodEdkQJOYdNFOCS/h5y02dAl7MBBUX3wyFfj5lno09D/oMvkZ+5BC7es+Dk/izv5CmUKIr4448/5A7Dpp04cQI9evSAVqtFTEwMmjVrJndIZGdMWdjEXuZjkULcugU89xzwn/VD9NWdoG/iAn1tZ0iuAoT7eqhO5UN1JBeqO//kJBcvApGRwJgxwBdfAG5uMrwBklNERATmzJkDrVYLJyebSKFtzuXLl9G9e3fcvn0b27dvhyiKcodEdkYJOYfsY0H0+aeRldwBupyHRVRxF7fQA1I28tJfR+698ZCkIoaOkcMTRRGXL1/G1atX5Q7FJm3duhVhYWHw9fVFQkICi28yihKeyUkKcOUKEBZWqPjW9vVA9p+ByI4pj9yvyiD/NR9oX/RG/hulkbssANmHKyLnhwDoWrv+fztLlgDduhUMYSdFEUUR9+/fx+HDh+UOxSbFxcUhJCQEeXl5iI+PZ/FNRlFCziFrAa7PP4fs1P6A/i6KX3j/W8FUe13On8i9Ow6SpDVrfGT72rVrB0EQuBp6Eb755ht0794d7du3x759+1CpUiW5QyIikkdaGtCxY0ERDkBfQY3sn8si9+sy0Dd1BR43ik4tQNfJHTm/lUXuXF9IHv/sFxUF9O/PRdoUpkWLFvD09ER0dLTcodicNWvWQBRF1K5dG/Hx8ahTp47cIRHZLNkKcEnKRs7dUYCUBeOK70KtQZe7E/kPvjJHaGRH/Pz8EBwczAL8X3Q6HSZNmoRXXnkFr776KjZs2IBSpUrJHRbZMaNXI/1nI5Lda68VDCEHoK/phJw/y0HfrgRDyAUB2mFeyPmlLCSvf4rwzZsL5oSTYjg7O6Nt27bMOf5FkiTMnj0bgwYNQr9+/bBr1y6UKVNG7rDIjikh55CtAM/L+BiS7hZML74fkpD/4HPo8v82U3tkL0RRRHR0NCR7+a2zoAcPHqBv37744osv8NVXX2HBggVQc9VeMtHD+VjGbkSy2rQJ+OknAIDkIyBnVVlIgcZ9L+qbuSJn8b+KiylTDHfVSRlEUcS+ffuQn58vdyiyy8vLw6hRo/Dee+9h5syZ+PHHH+Hq6vr0A4meQAk5hywFuF57Ddqs7/H/i62Zi4C8jA/N3CbZOlEUce3aNVy+fFnuUGR148YNw5X5TZs24ZVXXpE7JHIQSugMyYF98IHhj3n/84VUybTFs/Tt3ZE/4p9RRVlZwIIFJrVH9iUiIgKZmZk4ePCg3KHIKi0tDZ07d8bq1auxcuVKzJgxgwsik1koIeeQpQDXZv1koVProM/bB71W2YWY0rRr1w4qlUrRQ8KOHj2KkJAQpKamYv/+/ejatavcIRERye/IESAhAQCgq+8MbT9PszSb95YPJLd/Er3ly4HMTLO0S7avWbNm8PLyUnTOcf78ebRu3RonT57Erl27MHToULlDIrIrVi/AJUlCftYamG/o+X+poc3+zUJtky3y8fFBs2bNFNsZbty4EeHh4ahQoQISEhLQuHFjuUMiB6OEFUnJQa1ZY/ijdkSpxy+2VlK+amj7eBT8OT0d2LbNPO2SzXNyckK7du0Um3PExMSgdevWUKlUSEhIQHh4uNwhkYNRQs5h/QJcdxOQ7lrwDHro8o5asH2yRaIoIioqSlHzwCVJwoIFC9CnTx906dIFe/bsQfny5eUOixyQEhZEIQd16JDhj7rOHmZtWtfJvcjzkOMTRRGxsbHIzc2VOxSr+vHHH9GhQwcEBwcjLi4ONWrUkDskckBKyDmsXoDrtSctfAYJ+vy/LHwOsjURERG4desWzp8/L3coVqHVajF+/HhMmjQJb7zxBtauXQsPD/Mml0QPFXRqxs7Hkjt6UrSjBRfk9YFqoxdeexx9Y5dHzkPKIIoisrOzceDAAblDsQpJkjB9+nQMHz4czz33HLZu3QpfX1+5wyIHpYScQ4Y74ClWOMl9SJKlhriTLWrbti3UarUins2ZkZGBnj174ttvv8XixYvx8ccfQ6WS7YEGRES2SacD7haMuJMqmf9pEFIFNQyjHVOskNuQzQgODkbp0qUVMQw9JycHQ4cOxaxZs/Dhhx9i6dKlcHFxefqBRPRYMmTtdnJpguyKl5cXWrRo4fCd4dWrVxEWFoa4uDhs3boVY8aMkTskUgAlrEhKDs5SH8OH7drLbRcyC7VarYh54MnJyejQoQPWr1+PX375BVOnTuVK52RxSsg5rF6AC6rSVjiJOwSBzz5WGkefB37w4EGEhITgwYMHiI2NRceOHeUOiRRCMnEjkoVaDXgWrHouJFlgVFyqHsLDp6n6+Ji/fbJpoigiLi4OOTk5codiEadPn0ZISAguXLiAqKgo9O/fX+6QSCGUkHNYvQBXOde3aPuSBGQ8qIjs7GyLnodsjyiKSEpKwpkzZ+QOxex+++03tG/fHtWqVUNCQgLq17fs7xHRvynhajQ5qOBgAIDqug64a94iXH08z/DnPH4nK44oisjNzUVcXJzcoZjdrl27EBoaCnd3dyQkJKB169Zyh0QKooScw/p3wNXVAMFyi0VpdRKW/3gEfn5+6NKlC+bPn49Tp0457F1R+n9hYWFwcnJyqCFhkiTh448/Rr9+/dCrVy/s3r0bZcuWlTssUholXI4mx9SiheGP6j3mvVP57/ZeWLgQGo0Gc+bMwdGjR6HX659wJDmCRo0awd/f3+HWnlm6dCm6dOmCVq1aITY2FlWrVpU7JFIaBeQc1i/ABRWc3PsCsMwQcWcnAc8OWoYPPvgAer0eU6dORYMGDVC5cmW88MILWLt2LdLS0ixybpKXp6cnWrVq5TAFeH5+PsaMGYMpU6bgvffew6pVq+Du7v70A4mIqECfPoY/Ov/4wHztZunh9EtBe3oXF7T94AN4eHhg1qxZaNasGSpUqIBhw4Zh5cqVuHPnjvnOSzZDpVKhffv2DpNz6PV6vP3223jhhRfw/PPP488//4QPp1YQWYSTLCf1eA7arJ8s0LIKKqf6qF2vL16vB7z++uvIysrC3r17sW3bNmzbtg1Lly6FSqVCy5YtERkZicjISLRq1QpOTrL8U5CZiaKIb7/9FpIk2fVCIXfv3kW/fv0QExOD5cuXY8SIEXKHREpmyrAuOxkORg4qIgKoWxc4cwbquFyoo7OhizD9Qqbzt/chpBfcalENHowxb7+NMQByc3Oxf/9+bNu2Ddu3b8fKlSsBAE2bNjXkHG3atOEq0g4iIiLCkGva86NAs7KyMHz4cKxbtw6ffvopJk2aZNc5FNk5BeQcsjy7SO1cH2q3bjD/XXA9XLynFnrFw8Oj0FD0a9eu4dtvv0VQUBC++OILhIWFISAgAP369cOSJUtw7do1M8dE1iSKIlJSUvD333/LHYrRLl26hDZt2uDo0aPYsWMHi2+SXcEzOY3fiGQjCMCbbxr+6vJGGpBh2vBw4VQenBekF/xFrQYmTTL8zNXVFRqNBnPnzsXRo0dx+/ZtrFixAvXr18fSpUshiiL8/f3Rq1cvfP3117hw4YJJsZC8RFFEfn4+YmNj5Q7FaImJiRBFEVu2bMG6deswefJkFt8kKyXkHLI9PNjV+wNAKGXGEFRwch8CtWv4E/cKCgoyDEVPTk5GXFwcJk6ciFu3buGll15ClSpVUK9ePUycOBFbtmxBVlaWmeIja3h4Z8Feh4TFxsYiJCQEWq0W8fHxaN++vdwhESliQRRyYKNGAR06AABUt3RwG5UMZBlXhAvXtXAbngwh/58XpkwxLPRWlHLlyhmGoicmJuLw4cN45513kJGRgYkTJ6JWrVqoUaMGXn75ZWzYsAEZGRlGxUXyaNCgAQICAuw25zh58iRCQkJw/fp17N27F33+NWWDSC5KyDlkK8AFtT/cfBf+E4KpYaihcqoPF+/3SnSUk5MTWrdujRkzZiA2NhYpKSlYu3YtwsPDsW7dOnTr1g1+fn7o1KkTPvnkExw/fpyLudk4d3d3tG7d2i47w9WrV0Oj0aBevXqIj49H7dq15Q6JiMj+CQKwdCng5wcAUMflwu3ZOxAu5D/lwMJUe3Pg1jsJqlv/rKbetCkwfXrxj1ep0KxZM0ydOhXR0dFIS0vD77//ji5dumDHjh3o27cv/P390a5dO8yePRuHDh3iYm42ThAERERE2GXOsW3bNrRp0wa+vr44cOAAmjdvLndIRIohWwEOAGrXMLj6LQPgDOOHowtQOTeEm/8qCCpPk+Lx9fU1DEW/evUqTp06hTlz5sDJyQnTp09HcHAwKlasiJEjR2L16tVISUkx6XxkGaIoYs+ePXaTuEiShA8++ABDhgzBgAEDsGPHDvj7+8sdFtH/kwTTNiK5VakCbN1qeF63+q88uHdOhPMn94DkJz+eTDifD5fJqXAfdAeqxH/2rVsX2LIFcHU1OiQvL69CQ9EvXLiAzz//HH5+fpgzZw5atmyJwMBADBkyBD/88ANu375t9LnIckRRxMGDB/HggRkX+bOwhQsXonv37mjXrh1iYmJQqVIluUMi+n8KyDkEyQZu6eq1F5F7bxL0+X8BEFC8NeTVACQ4lxoH51KvQRCM7wSLIycnBzExMYbF3E6ePAlBENC8eXPDwiqtW7eGs7OzReOgp4uOjoYoijh27BiCnzA00Bbk5uZizJgx+PHHH/G///0P7733Hudekc3IyMiAj48Pqnw3DSoPN6Pa0Gfl4OoLs5Ceng5vb28zR0hUQsePA88+C/xr7rXkDOjauUEf7AJ9HRfAFcADCaq/86A+lAf1wdzCbYgisGYNEBBgsTDz8/MRFxdnyDkOHz4MAGjcuLEh5wgPD4erCRcAyDzOnDmDevXqYevWrYiMjJQ7nCfS6XR48803MX/+fLz22mv47LPPoFZb5qlERCWlpJzDJgpwAJAkHbTZa5Gf+R0k7XkU3JwXAPz7yrQTAC0ANdRu3eBc6iWonRvKES5u3bqF7du3Y9u2bdixYwdSU1Ph7e0NjUZj6ByrVasmS2xKl5OTg9KlS2POnDmYOHGi3OE8VmpqKp555hnEx8dj+fLlGDx4sNwhERVi6AyXmNgZjrH9zpAUJCsLePdd4IsvgJKMlCpVCpg7F3jpJUBl3QGEycnJ2LFjh2F19cTERLi7uyMiIsKQc9SpU4cXcGUgSRIqVKiAESNGYM6cOXKH81gPHjzA0KFDsWnTJixYsACvvvqq3CERFaKknMNmCvCHJEmCPv8v6PMOQJd/ApLuKiDlA4IXVM71oHJuBCfX9hDUlrvyXFI6nQ5HjhwxXKmOi4uDTqdDrVq10LlzZ0RGRkIURZQqVUruUBVDo9HAy8sLv//+u9yhFOncuXPo3r077t27hw0bNiAsLEzukIgeoaTOkBToyhVg8eKC+eFPelZ3nToFRfeIEYCvr9XCexxJknD8+HFDzrFv3z7k5eWhcuXKhmK8Q4cOKF26tNyhKsbgwYNx6dIlJCQkyB1KkW7evImePXvi/Pnz+Pnnn9G9e3e5QyJ6hJJyDpsrwB1Beno6du/ebegcr1y5AmdnZ4SFhRk6x+DgYKisfAVdSWbNmoVPP/0UqampNje8as+ePXjmmWdQtmxZbNq0CTVq1JA7JKIiPewMKy+eblJneG3s/2y+MyQFkyTg0iXg8OGCojwvD3B3L5jn3bw5UK6c3BE+UWZmJvbs2WPIOc6ePQu1Wo2QkBBERkaic+fOaNmypc31hY5k8eLFGDduHNLS0mzue+7o0aPo0aMHVCoVNm3aZPNT80i5lJRzsAC3MEmScP78ecNw9aioKGRmZqJs2bKGu+OdO3dG2bJl5Q7Voezbtw9t27bFoUOHbGplzxUrVuCFF15A27Zt8euvv8LXBu6mED1Ooc7Q3cjOMNs+OkMiR3HlyhVDzrFr1y6kp6fD19cXHTt2NNwE4KJb5nX+/HnUrl0bmzZtsqm7y3/88QcGDx6MunXr4o8//kD58uXlDonosZSUc/AWrIUJgoDatWtj/Pjx+OOPP5Camordu3dj1KhROHnyJIYNG4bAwMBCjybJy8uTO2y716pVK7i7u9vMo0H0ej2mTZuGESNGYPjw4di6dSuLb7IbSngmJ5GjqFq1KsaOHYvffvsNKSkp2LdvH8aPH4+rV69izJgxCAoKQoMGDTB58mRs27YN2dnZcods92rWrImKFSsiOjpa7lAAFNz8WbBgAXr37o1OnTphz549LL7Jbigh5+AdcJklJiYWWlglOTkZnp6eEEXRcKW6Zs2aXFjFCJ06dYKrqys2bdokaxw5OTkYOXIk1qxZg7lz5+LNN9/kf0+yCw+vRgd9O8Okq9HXX3zf5q9GEylBWloadu7caRiufvPmTbi5uaFdu3aGnKN+/frso4wwbNgwnD59GocOHZI1Dq1WiwkTJuCbb77BG2+8gblz53LKI9kFJeUc/I2UWbly5TBs2DCsXLkSiYmJOHz4MN577z08ePAAkydPRu3atVGjRg28/PLL2LBhAzIyMuQO2W6Iooi9e/dCq9XKFsOdO3eg0Wjw+++/49dff8Vbb73FxIbsj2TiRkQ2wc/PDwMGDMDSpUtx/fp1nDx5ErNnzwYAvPvuu2jYsCGCgoLw/PPPY82aNUhNTZU5YvsRERGBo0eP4t69e7LFkJGRgV69euHbb7/Ft99+i3nz5rH4JvujgJyDv5U2RKVSoVmzZnj77bcRFRWF1NRUbNy4Ed26dcPOnTvRt29f+Pv7o127dpg9ezYOHToEfUkeoaIwoiji/v37OHLkiCznP3XqFFq3bo1Lly5hz549ePbZZ2WJg8h0gokbEdkaQRAKDUVPS0vD1q1bMWDAAMTHx2PQoEEICAhASEgIpk+fjv3798t6QdvWiaIIvV6PvXv3ynL+a9euITw8HPv378eWLVswduxYWeIgMp3j5xwswG2Yl5cXevbsia+++grnz5/HxYsX8cUXX8DPzw9z585Fy5YtERgYiCFDhuCHH37A7du35Q7ZprRo0QKenp6yzAPfuXMn2rRpA09PTyQkJKBVq1ZWj4HIbGS4Gv3111+jatWqcHNzQ0hICA4cOPDE/e/du4dXXnkF5cuXh6urK2rXro3Nmzcbd3IiBXJ3d0dkZCQ+++wz/P3337h27RqWLFmCKlWq4KuvvkJ4eDjKlCmDZ599FosXL8bVq1flDtmmVKtWDZUrV5Yl5zh48CBatWqF+/fvIy4uDp06dbJ6DERmo4CcgwW4HalevbphKHpqair27NmDsWPH4ty5cxg1ahQqVKiAxo0b480338TOnTuRk5Mjd8iycnZ2Rtu2ba3eGX733Xfo2rUrQkNDsX//flSpUsWq5yeyd2vWrMHkyZMxY8YMHDlyBMHBwYiMjMSdxzyrOS8vD506dcKVK1fw66+/4uzZs1iyZAkqVqxo5ciJHMfDoei//PILkpOTER8fj8mTJyMxMREvv/wyqlatirp162LChAnYvHkzMjMz5Q5ZVoIgQBRFq+cc69atQ/v27VGtWjXEx8ejfv36Vj0/kb2TI+fgImwOIjk5udDCKomJiXB3d0dERIRhYZU6deoobv7x3LlzMWvWLNy9exfOzs4WPZder8fUqVPx8ccf4+WXX8YXX3wBJycni56TyJIMC6J8M9O0BVHGzSzRgighISFo2bIlvvrqq4I29HoEBQXh1Vdfxdtvv/3I/osWLcK8efNw5swZi/+eE1HB3Z9du3YZco5r167BxcUF4eHhhpyjcePGiss5fvjhB4waNQopKSnw8/Oz6LkkScK8efMwZcoUDBgwAMuXL4e7u7tFz0lkSUrKOXgH3EEEBARg8ODBWL58OW7duoW//voL77//PvLy8vDWW2+hXr16hR5NIuciIdYkiiIyMzMtvippVlYW+vfvj3nz5mH+/Pn4+uuvWXyT45AE07YSyMvLw+HDh9GxY0fDayqVCh07dkRcXFyRx2zcuBGhoaF45ZVXEBgYiIYNG+LDDz+ETqcz6W0TUdFKly5tGIp+5coVnD59Gh9//DFcXV0xc+ZMNGnSBBUqVMCIESOwatUqJCcnyx2yVURERECSJOzZs8ei58nPz8fYsWMxZcoUvPvuu1i9ejWLb3IcCsg5WCE4IEEQ0LhxY8Nw9MzMTOzZs8dwpXrJkiVQqVQICQkxXKlu2bIl1Gq13KGbXbNmzeDl5YWoqCiEhoZa5By3b99Gr169cOrUKWzYsAG9evWyyHmI5CJJBZuxxwJ45AkOrq6ucHV1fWT/lJQU6HQ6BAYGFno9MDAQZ86cKfIcly5dwu7duzF06FBs3rwZFy5cwLhx45Cfn48ZM2YYFzgRFYsgCKhbt65hOHpOTg727duH7du3Y9u2bVixYgUEQUCzZs0MOUdoaKhDjlapUqUKqlWrhqioKPTt29ci57h37x769euHvXv34vvvv8fIkSMtch4iuSgh5+AdcAXw9PREt27d8Pnnn+PMmTO4cuUKFi5ciPLly2P+/PkIDQ1FQECA4dEkN27ckDtks3FyckK7du0sNifrxIkTCAkJwa1btxATE8PimxyTGRZECQoKgo+Pj2H76KOPzBaeXq9H2bJlsXjxYjRv3hwDBw7Eu+++i0WLFpntHERUPG5ubujYsSM+/vhj/PXXX7h16xa+//571K5dG4sXL0b79u3h7++PPn36YOHChbh06ZLcIZuVJeeBX7p0CaGhoThy5Ai2b9/O4psckwJyDt4BV6AqVapg7NixGDt2LLRaLQ4cOGC4Oz5mzBhIkoT69esbrlS3a9fOroc2iaKIadOmITc3t8irX8basmULBg4ciBo1auCPP/5ApUqVzNY2kaO5fv16oflYj/tdLFOmDNRqNZKSkgq9npSUhHLlyhV5TPny5eHs7FxoFE+9evWQmJiIvLw8uLi4mOEdEJExypcvjxEjRmDEiBHQ6/U4cuSIIed47bXXoNVqUaNGDUPOIYoivLy85A7baKIoYtmyZUhOTkZAQIDZ2o2NjUWfPn3g7e2NuLg41KlTx2xtEzkaW885eAdc4ZycnNCmTRu8//77iI+PR0pKCtasWYPWrVvjl19+QZcuXeDn54fIyEh8+umnOHnyJOxt3T5RFJGdnf3URwqUxNdff40ePXogIiICMTExLL7JsZlhPpa3t3eh7XGdoYuLC5o3b45du3YZXtPr9di1a9djp5GEhYXhwoUL0Ov1htfOnTuH8uXLs/gmsiEqlQotWrTAu+++i7179yI1NRXr169Hp06dsGXLFvTu3Rv+/v6IiIjARx99hCNHjhT6vbYHoigCgFnngf/888/QaDSoU6cO4uPjWXyTY1NAzsECnArx8/MzDEW/fv06Tp48idmzZwMA3nvvPTRq1AhBQUEYPXo01qxZg9TUVJkjfrrg4GCULl0a0dHRJrel0+kwceJEjB8/Hq+99hrWr1+PUqVKmR4kkQ0TJNO2kpo8eTKWLFmCH374AadPn8bLL7+MzMxMjBo1CgAwfPhwTJ061bD/yy+/jLS0NEyYMAHnzp3Dn3/+iQ8//BCvvPKKuf4JiMgCvL29DUPRL168iHPnzmH+/Pnw9vbG7Nmz0bx5c5QvXx7PPfccfvzxx0fuUtmiihUrolatWmYZhi5JEj744AMMHjwY/fv3x86dO1GmTBkzRElku5SQc3AIOj2WIAho0KABGjRogMmTJyM7Oxt79+7Ftm3bsH37dnz//fcQBAEtW7Y0DB0LCQmxudW/1Wo12rVrh10xexGZeB03H2RAJ0nwcHJGXb8AVPX2haoYj0p58OABBg8ejM2bN+Prr7/GuHHjrBA9kQ3417wqo44toYEDByI5ORnTp09HYmIimjRpgq1btxoWSbl27RpUqv+/fhwUFIRt27Zh0qRJaNy4MSpWrIgJEyZgypQpRgZNRNYmCAJq1aqFWrVq4ZVXXkFeXh5iY2MNw9V/+uknAECTJk0QGRmJzp07IywszKxTy8wlIiLC5AI8NzcXY8aMwY8//oj3338f06ZNU9xj3UihFJBz8DngZLQbN24YVjndsWMH7t69Cx8fH3To0MFQkFepUkXWGB/k5WLDxVOYH7MDySqpyM7Lw8kZnarUxPB6zdC8bIUi97lx4wZ69uyJixcvGobmEzk6wzM5F/zPtGdyTpxeomdyEhH9V1JSEnbs2GG4CXDnzh14enoiIiLCkHPUqlXLJorUZat+wvh5H2LKgk+Ros9Dvl4PDydn1PYtg8ZlyqFluUpwVj3+yTOpqal45plnEB8fj++//x5DhgyxYvRE8lBSzsECnMxCp9Ph0KFDhivV8fHx0Ov1qF27tqFjjIiIgKenp1XikSQJa8+fxMz4XcjMz4OAJ18UUwsq6CQ9QspVwidtu6Gyd2nDz44cOYKePXvCyckJmzZtQqNGjSwdPpFNMHSG82eZ1hlOmmbznSER2Q+9Xo+//vrLkHPs378f+fn5qFq1qiHn0Gg08PHxsWpc5++lYvGJA/j9wink6h//TOCyHp4YVLsxnm/YAqVdCy9ye/78eXTv3h13797Fhg0bEBYWZumwiWyCknIOFuBkEffu3cOuXbsMneO1a9fg4uKC8PBwQ+fYuHFji1ypzsjLxatRGxF943KJj1ULApxUKnwUFolnazXExo0bMXjwYDRo0AAbN2587IqIRI7I0Bl+ZmJnONn2O0Misl8PHjxAdHS0Iec4f/481Go1QkND0blzZ0RGRqJ58+aFVi02J61ej4XHE/DF0VjkPaHw/q8Ad098GNYZnavUAgDs3bsXffv2RUBAAP7880/UqFHDIvES2SIl5RwswMniJEnC2bNnDcPVo6OjkZWVhXLlyhk6xk6dOpnlcR0ZebkY+OdqnL2bDJ2JH20xW4UVr72FZ555BitWrICHh4fJ8RHZE0Nn+KmJneHrtt8ZEpHjuHz5sqEY37VrF+7fvw9/f3907NjRcBOgQoUKZjlXtjYfY3eux96bV4xu49UmoSj792W88MILCA8Px2+//QZfX1+zxEdkL5SUc7AAJ6vLzc3Fvn37DJ3j8ePHIQgCmjVrZugYQ0ND4ezsXKJ2JUnC0K2/IP72NZOL74fa3byPH957v9DiC0RKoaTOkIgcU35+PuLj4w1zxw8dOgRJktCwYUNDztG2bVu4uZX8O06n12Pk9l9NKr4furd+K/oFVsPChQv5+ERSJCXlHCzASXa3b98utJhbSkoKSpUqBY1GY+gcizMM66czx/DO/u1mi0uQAD93D0T1ewE+rsZ9ERDZM0Nn+ImJneEbtt8ZEpEypKSkYOfOnYabALdv34a7uzvat29vyDnq1q1brClyXx2Lw7zDMWaJS5Ak/NpjKFqUq2SW9ojsjZJyDhbgZFP0ej2OHj1q6BhjY2Oh1WpRo0YNQ8coiiK8vLwKHZeem4NWq79Bjk5r1njUgoDn6jXF/0I7mrVdIntg6AznfWBaZ/jmezbfGRKR8kiShJMnTxpyjpiYGOTm5iIoKMgwRa5jx45FDge/cC8VXdcvL9Gc76ep7uOL7c+MfuIK6USOSkk5B8fVkk1RqVRo3rw53nnnHezZswepqanYsGEDOnfujK1bt6J3797w9/dHREQEPvroIxw5cgR6vR6/nDuBXDMX3wCgkySsOXsc9/Nyzd42kb0QJNM2IiJbJAgCGjVqhDfeeAM7duxAWloaNm/ejGeeeQb79+/HgAEDUKZMGYSGhmLmzJmIi4uDVluQa3x38qBZi28AuJR+F1uvnDNrm0T2Rgk5Bwtwsmne3t7o3bs3vvnmG1y8eBHnz5/H/Pnz4e3tjdmzZ6N58+YoV64cPone+sTHjJkiV6fF7xdPWah1IiIisgUeHh7o2rUrFixYgNOnT+Pq1atYtGgRKlWqhM8//xxt2rRBQEAAnhk0EL+eOW6RGFaePmaRdonIdjjJHQBRSdSsWRM1a9bEK6+8gry8PMTGxmLDzu1Y7+FqsXOqBAEHkm7guXpNLXYOIpsm/bMZeywRkR2qXLkyxowZgzFjxkCr1eLgwYPYtm0bfv/7GPLN/xRVAMDBpBvI1ubD3alkC9ESOQwF5BwswMluubi4ICIiAvoaQVi//TeLnUcnSTiSdMti7RMREZFtc3JyQmhoKEJDQ+F7NBafHdlnkfPoJAl/p95Bi8CKFmmfiOTHIehk967fT4eFLkQb3MrMsPAZiGyXABPmY8kdPBGRmV27f8+i7V/NuGvR9olsmRJyDhbgZPe0en2xHhdiCp0kgQ8MICIiojydeRdf+698vd6i7RORvDgEneyeh5Mz9BYujl3VThYv8olsliQUbMYeS0TkQDydLTs/29LtE9k0BeQcLMDJ7tXyLWPxc9TwfvQZoESKoYAFUYiIiquOb4BF2w9y9bRo+0Q2TQE5B4egk91r4F/WonM+JK0Oh37/E126dMH8+fNx6tQpDkcnZZFM3IiIHEhwQHmLta3PyUWr6rWg0WgwZ84cHD16FHoOSSclUUDOwQKc7J67kzNCy1eG2kJDxAUnNQY1aw29Xo+pU6eiQYMGqFy5Ml544QWsXbsWd+9ysRRybEYvhvLPRkTkSJoElEelUt4WaTuyck18+skn8PDwwKxZs9CsWTNUqFABw4YNw8qVK3Hnzh2LnJfIVigh52ABTg5hRP1m0FnornR5Ty8seHUytm/fjrS0NGzZsgX9+vVDbGwsBgwYgDJlyqB169aYMWMGYmNjodVqLRIHERERyU8lCBhSt4lF2n4lpD1effVVbNq0CWlpadi1axdGjhyJkydPYtiwYQgMDESzZs0wdepUREdHIy8vzyJxEJHlsAAnh9Cxck1U8/a1yF3w8cGtoVYV/Kp4eHgUGop+7do1LF68GJUrV8aXX36JsLAwBAQEoF+/fliyZAmuXbtm9niIrE4Bw8GIiEpieL2mqODpZdY2u1StjaZlKxj+7urqWmgo+u3bt7FixQrUr18fS5cuhSiK8PPzQ8+ePfHVV1/h/PnznCJH9k8BOQcLcHIITioVFkT0MOtq6GpBQMvAik+8yh0UFITnn38ev/zyC5KTkxEXF4eJEyfi1q1beOmll1ClShXUq1cPEydOxJYtW5CVlWW2+IisRgGdIRFRSXi5uOLVqg3N1p6vqztmt+n0xH3KlStnGIqemJiIw4cP491338WDBw8wefJk1K5dGzVq1MDLL7+MDRs2ICMjw2zxEVmNAnIOFuDkMK7GHsCDTbvN0pZaEFDK2RWfte8OVTHvqqvV6kJD0VNSUrB27VqEh4dj3bp16NatG3x9fdGxY0fMmzcPx48f55VqsgtKmI9FRFQSe/bswfhuveGy95DJbbmpnbC4Yx+UcS/+6ucqlcowFD0qKgqpqanYuHEjunXrhp07d6Jv377w9/dHu3btMHv2bBw6dIiLuZFdUELOwQKc7J4kSfj888/Rt29ftFeXwuh6TU1qr6D4dsHqbgNR2au00e34+voahqJfvXoVp0+fxscffwwXFxfMmDEDwcHBqFixIkaOHInVq1cjJSXFpLiJiIjI8n788Ud06tQJzZo1w8HPF2NGiAZOgnEptb+bB37s0h+tygWZFJOXl1ehoegXL17EF198AT8/P8ydOxctW7ZE2bJlMXjwYCxfvhy3bt0y6XxEZDxB4i04smNarRaTJk3CV199hbfeegsfffQRBEHA6rN/4f343cjX60q8OFuTgPL4PKIHqlrw2d85OTnYt28ftm3bhm3btuHEiRMQBAHNmzdH586dERkZidDQUDg7O1ssBqKnycjIgI+PD6q9/yFUbm5GtaHPycHlGe8gPT0d3t6WWTWYiMgaJEnC+++/j/fffx+jR4/GwoUL4eLiAgA4mZKEN2O24FRa8Vcp716tDmaFdoK/u4elQgYA5OfnIz4+3pBzHD58GJIkoVGjRoiMjERkZCTCw8PhZuT3PJE5KCnnYAFOduvBgwcYNGgQtm7dim+++QZjx44t9PPr99MxK2E3tl89D0EQIElS0VND9HpApYK/mwfGB7fGiPrNDIuuWcutW7ewY8cObNu2DTt27EBKSgq8vLyg0WgMnWP16tWtGhORoTOcaWJnONP2O0MioifJzc3FCy+8gJUrV+LDDz/E22+/DeE/U9T0koRd1y7gxzPHEHfrGvL0ukfakbJzMLBxCwyv3wyNypSzVviFpKSkGHKO7du34/bt23B3d0dERIThJkDdunUfeX9ElqSknIMFONmlmzdvokePHrh48SLWrl2LyMjIx+5760EG1p4/gYTbN3A85Tbu5xc8skMA4KdyxrXYBHw6ZjyGtAiFs0ptpXfweHq9HkeOHDFcqY6Li4NWq0XNmjUNxXhERAS8vMy7+irRfz3sDKvPMK0zvPS+7XeGRESPk5aWhr59+yIhIQE//PADBg4c+NRj8nQ6nL2bjCsZd5Gv08Pd2RlZV66jn9gRCQkJaNWqlRUifzpJknDixAls374d27Ztw969e5GXl4fKlSsbivEOHTrA19dyowKJAGXlHCzAye789ddf6N69O1QqFf788080atSolwK4NQAAQB9JREFU2MdKkoRsbT7y9Xq4OznjQXo6ypQpg2XLlmHkyJGWC9oEGRkZ2L17t6FzvHTpEpydndGmTRtDQd6kSROorHzXnhyfkjpDIqKiXLx4Ed26dUNqaip+//13hIWFGd1Wfn4+fH19MW3aNEyZMsWMUZpPVlYW9uzZY7gJcObMGahUKoSEhBhyjpYtW0Ktlv+GBTkWJeUczNjJrmzevBnh4eEoV64cEhISSlR8A4AgCPBwdoGPqxtc1Gr4+fmhadOm2L3bPKunW4K3tzf69OmDb775BhcvXsT58+cxf/58eHt7Y/bs2WjevDnKly+P5557Dj/++COSkpLkDpkcjQIeCUJE9F+xsbFo3bo1ACA+Pt6k4hsAnJ2d0a5dO5vOOTw8PNC1a1csWLAAp0+fxtWrV7Fo0SJUqFAB8+fPR2hoKMqUKYP+/fvju+++w/Xr1+UOmRyNAnIOFuBkNxYuXIiePXtCo9Fgz549KF++vFna1Wg02L17t908EqxmzZp45ZVXsHHjRqSlpSEqKgqjR4/GqVOnMHz4cJQrVw5NmzbFlClTsHv3buTm5sodMtk7Ux4HYh+/VkREhaxZswYajQb169dHXFwcatasaZZ2NRoNYmJikJeXZ5b2LK1y5coYM2YMfv31V6SkpCA2NhYTJkzAjRs38OKLL6Jy5cqoX78+Jk2ahK1btyIrK0vukMneKSDnYAFONk+n0+H111/HuHHj8Nprr2HdunXw9Cz+szKfRqPR4ObNmzh//rzZ2rQWFxcXRERE4KOPPsKRI0eQlJSElStXolGjRvjhhx/QoUMH+Pv7o0ePHvjyyy9x7tw5u7nQQDZEAVejiYiAgqlqH374IQYNGoT+/ftj+/bt8PPzM1v7Go0G2dnZSEhIMFub1uLk5ITQ0FDMnDkTcXFxSE5Oxi+//II2bdrg119/RdeuXeHn54fOnTvjk08+wYkTJ5hzUMkpIOdgAU42LTMzE/369cOCBQvw5ZdfYv78+WafdxQeHg61Wo2oqCiztiuHsmXLYujQoVixYgVu3bqFo0ePYtq0acjKysLrr7+OOnXqoHr16njppZewfv16pKenyx0yERGRTcjPz8cLL7yAd999FzNnzsSKFSvg6upq1nMEBwejdOnSDpFz+Pn5GYaiX7t2DX///TfmzJkDtVqNadOmoXHjxqhUqRJGjRqFn3/+GampqXKHTGQTuAgb2azExET07NkTp0+fxs8//4wePXpY7Fxt2rRBUFAQ1qxZY7FzyO3BgweFFlY5d+4c1Go1WrdubVhYpXnz5lxYhQwMC6K8+yHURi6IosvJwaXZtr8gChEp271799CvXz/s3bsXS5cuxbBhwyx2rr59++Lu3buIjo622DnklpOTg5iYGEPOcfLkSQiCgBYtWhhyjpCQEDg7O8sdKtkIJeUcvANONunkyZMICQnBrVu3EBMTY9HiGygYEhYVFQW9Xm/R88ipVKlS6N69O7744gucPXsWly9fxtdff42yZcvik08+QUhICMqWLYtBgwbh+++/x82bN+UOmWyEsXOxDHOyiIhs2JUrVxAWFoYjR45gx44dFi2+gYKcIy4uzqHnS7u5uaFTp06Goeg3btzA0qVLUb16dXzzzTdo27YtypQpg759+2LRokW4fPmy3CGTjVBCzsECnGzOjh07EBYWBl9fXyQkJKBp06YWP6dGo0FycjL+/vtvi5/LVlStWhUvvvgi1q1bh5SUFMTExGDcuHG4fPkynn/+eVSqVAmNGjXCG2+8ge3btyMnJ0fukImIiMzqwIEDCAkJQU5ODuLi4tC+fXuLn1Oj0SAvLw+xsbEWP5etqFixomEo+p07d3DgwAG8+eabSElJwfjx41G9enXUrl0br776KjZt2oQHDx7IHTKRxbAAJ5vy3XffoVu3bggLC0NMTAwqVapklfOGhobCxcXFph8NYknOzs4IDw/HrFmzkJCQgOTkZPz8889o2bIlVq9ejcjISPj6+qJLly6YP38+Tp06xYVViIjIrq1btw4RERGoWbMm4uPjUadOHauct379+ihbtqxicw61Wo2WLVvivffeQ0xMDFJTU7Fu3TpoNBps2rQJPXv2hJ+fHzQaDebOnYujR4869AhFUh4W4GQT9Ho9pk6dijFjxmDMmDHYuHEjvLy8rHZ+d3d3tGnTxiEWRTEHf39/DBw4EMuWLcONGzdw4sQJfPDBB4b/Tg0aNEDlypXxwgsvYO3atbh7967cIZMlKWBFUiJSDkmS8Omnn6Jfv37o1asXdu3ahYCAAKudXxAEiKLInOMfPj4+hqHoly5dwrlz5/DZZ5/B09MTs2bNQrNmzVChQgUMGzYMK1euxJ07d+QOmSxJATmHk9wBEGVnZ2PEiBH49ddf8emnn2LSpEkQBMHqcWg0Gnz66afQ6XRciOxfBEFAw4YN0bBhQ7z++uvIysoqtLDK0qVLoVKp0LJlS8PCKq1atYKTE79eHIUp86rsZT4WESmDVqvFq6++ikWLFuGdd97BrFmzoFJZ/36URqPBuHHjkJGRYdOLRVmbIAioVasWatWqhfHjxyM3NxexsbGGnGPlypUAgKZNmxpyjjZt2sDFxUXmyMlclJBz8A44ySo5ORkdOnTApk2b8Ntvv2Hy5MmyFN9AQWeYnp6Oo0ePynJ+e+Hh4YHIyEh89tln+Pvvv3Ht2jUsXrwYlStXxpdffomwsDAEBASgX79+WLJkCa5duyZ3yGQODnwlmoiUISMjAz179sR3332HpUuXYvbs2bIU30BBzqHT6RATEyPL+e2Fq6srRFHEnDlzcPToUSQmJmLFihVo0KABli1bBlEU4efnh549e+Krr77C+fPnOUXOETh4zsFbVCSbM2fOoHv37sjMzMSePXvQsmVLWeNp2bIlPD09sXv3brRo0ULWWOxJUFAQnn/+eTz//PPQ6XQ4ePCg4Ur1Sy+9BL1ej7p16yIyMhKdO3dGREQEPDw85A6bSsKUjs2OOkQiclzXr19Hjx49cOXKFWzZsgUdO3aUNZ4aNWogKCgIu3fvRvfu3WWNxZ4EBgZi2LBhGDZsGPR6Pf766y9DzjF58mTk5+ejWrVqhrvjGo2GIwzsjQJyDt4BJ1lER0cjNDQU7u7uSEhIkL34BgAXFxeEh4dzTpYJHj5XfMaMGYiNjUVqaip+/fVXtG3bFuvXr0f37t3h6+uLjh07Yt68eTh+/DivVBMRkUUdOXIEISEhSE9PR2xsrOzFN8B54OagUqnQtGlTvP3224iKikJaWho2btyIbt26YefOnejbty/8/f3Rrl07zJ49G4cOHeJibmQTWICT1a1YsQKdO3dGixYtsH//flSpUkXukAw0Gg1iYmKQl5cndygOoXTp0nj22WexePFiXLlyBadPn8bHH38MFxcXzJgxA8HBwahYsSJGjhyJ1atXIyUlRe6QqQhKeCYnETmmP/74A+3atUOlSpWQkJCABg0ayB2SgUajwbFjx5Camip3KA6hVKlShYaiX7x4EV9++SX8/f0xd+5ctGzZEmXLlsXgwYOxfPly3Lp1S+6QqQhKyDlYgJPVSJKEGTNmYMSIERg+fDg2b94MHx8fucMqRKPRIDMzEwcPHpQ7FIcjCALq1q2LCRMmYPPmzUhLS8POnTvx3HPP4ejRoxgyZAjKli2LFi1a4N1338XevXuRn58vd9hPJUkSJP0DSPq7kKRsucOxDAWsSEpEjufLL79Enz590LlzZ0RHRyMwMFDukAoRRRGSJGHPnj1yh+KQqlevjpdeegnr169Hamoq9u7di5deegkXLlzA6NGjUbFiRTRu3Bhvvvkmdu7ciZycHLlDJkAROYcgcfwnWUFubi6ef/55/PTTT/joo48wZcoU2RZbexKdTgd/f3+8/vrrmDZtmtzhKMrt27exfft2bNu2DTt27EBKSgq8vLyg0WgMc7mqV68ud5gAAEmfBm3WWmhz90Of/xcg3TP8TFCVhcq5CdRuIpzcekNQecoXqIkyMjLg4+OD2m98CLWrm1Ft6HJzcO6Td5Cens55eERkFTqdDpMnT8YXX3yBN954A3PnzpVtsbWnqVWrFiIjI/HVV1/JHYqipKSkYOfOnYb547dv34a7uzsiIiLQuXNnREZGom7dujaVq2r1elxIScXF1DTk5Gvh6uSE6v6+qB1QBk42+vkuCSXlHCzAyeJSU1PRt29fHDhwACtWrMCAAQPkDumJevfujYyMDM7LkpFer8eRI0ewbds2bN++HbGxsdBqtahZs6ZhMTdRFK36rHigoPDOzfgIuux1APR4/OVWVcHPBQ84e4yEs9drEAR3q8ZqDkrqDInIMTx48ABDhgzB5s2b8dVXX+Gll16SO6QnGjt2LPbt24dTp07JHYpiSZKEkydPGorxmJgY5ObmonLlyoZivEOHDvD19ZUlvrgr1/DT0b+w5+IV5Gi1j/zc1UmNdtWqYkizYIRVrWxTFw1KQkk5BwtwsqgLFy6gW7duuHv3LjZu3IjQ0FC5Q3qqzz//HFOmTMHdu3fh7m5/RZMjenhB5GHneOnSJTg7O6NNmzaGu+NNmjSx6B0Obc525N57E5DuA9CV4EgBgroSXEt/AbVLM0uFZxGGzvB1EzvDT22/MyQi+3fr1i307NkT586dw9q1a9GlSxe5Q3qqn3/+GYMHD8bt27dRrlw5ucMhAFlZWdizZ49hVN7p06ehUqkQEhJiyDlatmwJtVpt0Tiu3buHdzbvQMK1G8U+pnmlCpjTrTOq+slzscAUSso57H+8Atmsffv2oXXr1lCpVIiPj7eL4hsomAeem5uLuLg4uUOhf3h7e6N379745ptvcPHiRZw/fx7z58+Ht7c3PvzwQzRv3hzly5fHc889hx9//BFJSUlmPX9+5grk3h0DSOkoWfENABIk3S3kpA6ANmeXWeOyGgXMxyIi+3b8+HGEhITgzp072Ldvn10U30DBPHAAHHVnQzw8PNC1a1fMnz8fp06dwtWrV/Htt9+iYsWKWLBgAUJDQ1GmTBn0798f3333Ha5fv272GLacOYeeS1eWqPgGgMM3bqHnspX449QZs8dkNQrIOViAk0WsXr0aHTp0QMOGDREbG4saNWrIHVKxNWjQAAEBAdi9e7fcodBj1KxZE6+88go2btyI1NRUREdH4/nnn8fp06cxfPhwlCtXDk2bNsWUKVOwe/du5ObmGn0ubfYG5GU8XA/A2G92HQAtcu+OhS7P/hb4U8KKpERkv7Zu3Yrw8HAEBAQgISEBwcHBcodUbIGBgWjQoAFzDhtWuXJlvPDCC1i7di2Sk5MRGxuLCRMm4MaNG3jxxRdRuXJl1K9fH5MmTcLWrVuRlZVl0vk2nz6LSb9vRpaRC9HmaLV444+t+P3kaZPikIsScg4W4GRWkiRh9uzZGDJkCAYNGoTt27fDz89P7rBKRKVSQRRFdoZ2wsXFBe3bt8eHH36Iw4cPIykpCStXrkSjRo3www8/oEOHDvD390ePHj3w5Zdf4ty5c8V+9rhedxO56W+bKVIJgB65d1+DpDetcyYiogLffvstevTogfbt22Pv3r2oUKGC3CGVmEajYc5hJ5ycnBAaGoqZM2ciLi4OKSkpWLt2LcLCwvDbb7+ha9eu8PPzQ+fOnfHJJ5/gxIkTxc45AOBCSire3LQNOhNnCOslCVM3b8eZO8kmtUOWwQKczCYvLw+jR4/Ge++9h/fffx/Lly+Hi4uL3GEZRRRFHDx4EPfv35c7FCqhsmXLYujQoVixYgVu3bqFo0ePYtq0acjOzsYbb7yBOnXqFHo0SXp6+mPbyr33NiCZ85nwekj6ROQ9+MSMbVqBAoaDEZF90ev1ePPNN/HSSy9h3Lhx2LBhA0qVKiV3WEYRRRGXLl3C1atX5Q6FSsjX1xf9+vXDkiVLcPXqVZw6dQpz5syBWq3G9OnT0bhxY1SqVAmjRo3Czz///MRnvuv0ekz5czvydCWd6la0/H/ayzdTe1ajgJyDBTiZxb1799C1a1esWrUKP/74I6ZPn263qzACBVejtVot9u3bJ3coZAKVSoUmTZpgypQp2LVrF9LS0rBp0yb07NkTUVFReOaZZ+Dv74/w8HDMmjULBw4cgO6fjkqffxr6vL0o+Zzvp9FDm/kjJP3jC3+bo4DOkIjsR1ZWFvr374/PPvsMn3/+Ob744guLL4hlSe3bt4cgCJwHbucEQUC9evUwceJEbNmyBWlpadi+fTuGDBmCw4cPY/DgwQgICECrVq0wbdo07Nu3D/n/Gma+/dwFHL+daNaYTiXdwebT58zapsUpIOdgAU4mu3z5Mtq0aYNjx45hx44deO655+QOyWS1atVCxYoVOSTMwXh6eqJ79+744osvcPbsWVy+fBlff/01ypYti08++QQhISEoW7YsBg0ahBNH3oMkWSqhy4c2+1cLtW1+SpiPRUT2ISkpCaIoYuvWrdiwYQNee+01uUMymZ+fH5o2bcqcw8G4ubmhU6dOmDdvHo4fP46bN29i2bJlqFGjBhYuXIi2bduiTJkyeOaZZ7Bo0SIsjU2wSBw/Hf3LIu1aihJyDhbgZJKEhASEhIQgPz8fcXFxaNeundwhmYUgCJyTpQBVq1bFiy++iHXr1iElJQX79u3DK6+8gsuXL6OUawIEwXLDtrQ5Oy3WNhGRIzp16hRCQkJw/fp17N27Fz179pQ7JLN5mHPw6cCOq0KFChg5ciRWr16NpKQkHDhwAG+++SZSUlLw2ltT8NedFIuc9+jN27idwSmVtoQFOBntt99+Q0REBGrXro24uDjUrl1b7pDMShRFHD16FHfv3pU7FLICZ2dnhIWF4X//196dR0dR5usDf6p6TSALJJCwSQQEWYMQSCBrFxEUgjciMyCyXERm1Du4IOOAOKD+RFTEH8zg4IzKHXFBxAUUBcUsxpgF2TfBAVEQzMKWkECSXur+waJogkm6qqur6/mcU8dj2/32k4Okvt+q933riSdQVPARoqPUnM4ow+PcpZ9CywDTwYjIv2VlZWHo0KEIDQ1FcXExBg4cqHUkRTkcDhw7dgwHDx7UOgr5gMlkwqBBg/Doo48iLy8PHxSo++jbvSVlqo6vKAPUHGzAqclkWcaiRYswduxYZGZm4rPPPkNkZKTWsRQnSRJkWcbnn3+udRTyMY/rP+p/iVwF2aOPE6IW08FeeOEFxMTEwG63Iz4+Hps3b27U59566y0IgoDMzMzmfTER+Z0VK1bgpptuQkJCAvLz89GpUyetIykuOTkZJpOJM+8M6mi1uk9HOVCuzt11NRih5mADTk3idDpx99134+GHH8bcuXPxxhtvwG63ax1LFZ07d0aXLl14MjQgWfbRY8Lk8775Hm/5+Gr06tWrMXPmTMyfPx/btm1DbGwsRowYgbKyq1+w+O677zBr1iwkJyc3/UuJyO94PB7MnTsX06ZNw7Rp07B+/XqEhoZqHUsVISEhGDx4MGsOgzpXp+QTV+oZ36nu+IoyQM3BBpwarbKyEhkZGVixYgVWrFiBJ598EqIY2P8LcR24QQmWwPoenXn++ecxffp0TJ06Fb169cKLL76I4OBgrFixosHPuN1u3HHHHXj88cfRpUsXH6YlIjXU1NRgwoQJWLhwIRYtWoTly5fDbDZrHUtVkiQhJycHHo9H6yjkYxaVd/E3i/p9SoDatKg5Art7IsUcOXIESUlJKC4uxieffIKpU6dqHcknJEnC3r17UVpaqnUU8iHR5IvpjRYIYlsffI8CfHg1uq6uDlu3bkV6evrl10RRRHp6OgoLG14j98QTT6Bt27aYNm1a076QiPxOeXk5hg0bhnXr1mHNmjWYNWuWrh9t2liSJKG8vBx79+7VOgr5WOdW4aqOH6Py+IoyQM0R2JcSSRFbt25FRkYG7HY7CgoK0KtXL60j+UxaWhoAIDc3F+PGjdM2DPmMYOoMCMGAilPRRXN3CDq5Ay5cPJr7WeDCDJqfs9lssNlsv3r/iRMn4Ha7ERUVdcXrUVFR2L9/f73fkZ+fj1deeQU7duxoZkoi8hcHDhzAqFGjcPbsWeTm5iI+Pl7rSD4zZMgQWK1W5OTkoG/fvlrHIR/qEx3122/yanydXPCHMWoO3gGnq/rggw+QkpKCa665BkVFRYZqvgGgXbt26NmzJ6ehG4wgiDBZEwCoNWXLBNE2VKWxVaDA1ehOnTohLCzs8rFw4UJFop09exaTJk3CSy+9FJCbQRIZSV5e3uUm9NJjTo0kKCgIQ4cOZc1hQNeEh+Ga8DBVxm4XGoKukRGqjK0KA9QcvANODVq6dCkefPBBjBkzBitXrkRwcLDWkTQhSRI++eQTrWOQj5mDJ8Jdq1YR5IYleIJKYyvPm51FL33u6NGjV2yeVN+VaACIjIyEyWT61bKP0tJSREdH/+r9hw4dwnfffXfF84AvrZ80m804cOAAunbt2rzwROQzr7/+Ou68804kJyfj3XffRXh4uNaRNCFJEhYvXgy32w2TyuuCyX8IgoDbb+iHZ3K+UHzs8f37QtTREg4j1By8A06/4nK5MGPGDDzwwAOYNWsW3n77bcM238CFk+HBgwdx9OhRraOQD5lsaRBMHaH8r0kTRGsyRLOxNgoLDQ294mjoZGi1WjFw4EBkZWVdfs3j8SArKwtDhgz51fuvv/567N69Gzt27Lh83HLLLXA4HNixY0dAPq6IKJDIsozHH38ckyZNwsSJE7FhwwbDNt/AhZqjoqIC27dv1zoK+djvY/sgQuF6O9xux/j+/RQdUw/8vebgHXC6QlVVFcaPH4+NGzfixRdfxB//+EetI2kuNTUVgiAgJycHkydP1joO+YggmGALexY1p5S+U22CLexJhcdUWTMf7XH5s000c+ZMTJkyBXFxcRg8eDCWLFmC6urqy5s/Tp48GR06dMDChQtht9vRp0+fKz5/qXj/5etE5F9qa2sxffp0vPbaa1iwYAHmzJljiM3WrmbQoEEIDg5GTk4O4uLitI5DPhRqt+Ox4RJmrF2v2Jh/vdGB1sFBio3nEwaoOdiA02XHjh3D6NGjcfDgQXz00UcYMWKE1pH8QkREBGJjY5Gdnc0G3GBMtkSYg6fAdW4lmn82uJI1dC5Ec4wiY/mUMj9+o4wbNw7l5eWYN28eSkpK0L9/f2zcuPHyJilHjhwJ+EcgEgW6U6dOYcyYMSgqKsKqVaswfvx4rSP5BavViuTkZGRnZ+PPf/6z1nHIx266/jpMuKEf3ty+y+uxxvbrjVt6X69AKg0EeM0hyLLswx+R/NXOnTsxatQoiKKIjz76iLtv/sJDDz2ENWvW4Pvvvzf81XmjkWUXak/fDXftZ/D2jGBuMR3WkLm6+X+osrISYWFh6POHp2Cy2ps1hruuBnv+9QgqKiquWI9FRMZ16NAhjBw5EidPnsS6deuQmJiodSS/8uyzz+KJJ57AqVOnYLVatY5DPuaRZczb+BlW79zT7DFu7dMLC0feCJOOLlYbqebQz58KqWbDhg1ISkpCVFQUioqK2HzXQ5IkHD16FIcOHdI6CvmYIJhha7Uc5qBLU9Gb+mvTBECEJeRhXTXfRERqKCgoQEJCAgCgqKiIzXc9JElCdXU1vvrqK62jkAZEQcCTN9+Ip0cOR2gDa5cb0tJmxZM3pePZjBG6ar6Nhn8yBrd8+XJkZGRAkiTk5eWhffv2WkfyS8nJyTCZTHw0iEEJggW28Kdga70Sgtjm4qu/9evzwu61grkr7JEfwtryf/TbfCvwSBAiotWrV0OSJPTq1QsFBQXo1q2b1pH80g033ICwsDDWHAZ3W7/e+PiuyZg2eCDC7Ve/Ixxmt2HqoAH4eNpkjOuv8xtpBqg5uAbcoNxuNx5++GE8//zzuP/++7F48WI+7uIqQkNDERcXh5ycHPzhD3/QOg5pxGxLhantl3DXfApn9avwOLcCcNXzThtMthRYWkyBaE2EIOj7WqcSjwQhIuOSZRlPP/00HnnkEUycOBEvv/xyg7sSE2AymZCamoqcnBz89a9/1ToOaSgqpCVmSyl4MGUotvxwDHtKynDoxCnUulywmU3oEtEavaOjMKhjB9gtgdHWGaHmCIw/KWqSc+fOYeLEiVi3bh3+9re/YcaMGVpH0gVJkvDKK69AlmX93skkrwmCBeagUTAHjYIs18HjOgDZ9T0g1wGCHaK5GwRzVwhCAF3Q8vGOpEQUOJxOJ+655x688sormD9/PubPn89zaCNIkoS//OUvOH/+PIKCdLaLNSnOZjYjMaYzEmM6ax1FfQaoOfR9W4aarKSkBGlpafj000+xbt06Nt9NIEkSysrKsG/fPq2jkJ8QBCtMlr4wB2XAHDwG5qCREC3dA6v5JiJqpjNnzuDmm2/GypUrsXLlSjz22GNsvhtJkiTU1taisLBQ6yhEpDA24AayZ88exMfH49ixY/jiiy+QkZGhdSRdGTp0KKxWK9dkkeFcmg7W3IOIjOe7775DYmIitm3bhk2bNmHSpElaR9KV3r17o02bNqw5yHCMUHOwATeITZs2ITExEeHh4SguLsYNN9ygdSTdCQ4ORkJCAnJycrSOQuRbBtgQhYiUs3nzZsTHx6OmpgaFhYVITU3VOpLuiKKItLQ01hxkPAaoOdiAG8DLL7+MkSNHIjExEfn5+ejYsaPWkXRLkiTk5ubC7XZrHYXIdwxwMiQiZbz33ntIS0tD165dUVRUhB49emgdSbckScLmzZtx9uxZraMQ+Y4Bag424AHM4/Fgzpw5mD59OqZPn44PPvgAISEhWsfSNUmScPr0aezcuVPrKERERH5DlmUsXrwYY8eOxejRo5GdnY02bdr89gepQZIkweVyIT8/X+soRKQgNuAB6vz58xg/fjyeeeYZLF68GC+88ALMZm567634+HgEBQVxTRYZihHWYxFR87lcLtx7772YNWsWZs+ejVWrVsH+G88tpt923XXXoUOHDqw5yFCMUHOwAQ9A5eXlGDZsGNavX493330XM2fO5K6jCrFarUhOTubJkIzFANPBiKh5KisrMXr0aLz88st4+eWX8dRTT0EUWV4qQRAESJLEmoOMxQA1B39DBpj9+/cjISEB3377LT7//HPceuutWkcKOA6HA1988QWcTqfWUYh8QpBlrw4iCkxHjx5FcnIyCgoKsGHDBkybNk3rSAHH4XBg+/btOH36tNZRiHzCCDUHG/AAkpubiyFDhsBut6OoqAiDBg3SOlJAkiQJVVVV2LJli9ZRiIiINLFt2zbEx8ejoqICBQUFSE9P1zpSQJIkCbIs4/PPP9c6ChEphA14gFi5ciWGDx+OuLg4fPnll4iJidE6UsAaMGAAQkNDOSWMjMMA08GIqPE+/PBDpKSkoGPHjigqKkLv3r21jhSwOnfujC5durDmIOMwQM3BBlznZFnG/PnzMWXKFEyePBkff/wxwsPDtY4V0MxmM1JTU3kyJMMwwoYoRNQ4f//735GZmYnhw4cjNzcX0dHRWkcKeFwHTkZihJqDDbiO1dbWYtKkSXjiiSewcOFCvPTSS7BYLFrHMgRJklBQUICamhqtoxCpzwBXo4no6txuN+6//37cd999ePDBB7FmzRoEBwdrHcsQJEnC3r17UVpaqnUUIvUZoOZgA65TJ0+exI033oh33nkHq1evxuzZs7nTuQ85HA7U1NSgqKhI6yhEqjPC1WgialhVVRVuvfVWLFu2DP/4xz/w3HPPwWQyaR3LMNLS0gBc2OuHKNAZoeZgA65DBw8exJAhQ/D1118jOzsbv//977WOZDh9+/ZFREQEp4QREVFAO378OFJTU5GTk4P169fjnnvu0TqS4bRr1w49e/ZkzUEUINiA60x+fj4SEhIgiiKKioowdOhQrSMZkiiKcDgcPBmSMRhgOhgR/dquXbsQHx+P0tJS5Ofn4+abb9Y6kmFxHTgZhgFqDjbgOrJq1SoMGzYMffr0QUFBAbp27ap1JEOTJAnFxcWoqqrSOgqRqowwHYyIrrRx40YkJSWhTZs2KC4uRmxsrNaRDE2SJBw8eBBHjx7VOgqRqoxQc7AB1wFZlrFgwQJMmDAB48aNw6efforWrVtrHcvwHA4HXC4XvvzyS62jEKnLAFejiegn//znP5GRkYHU1FTk5eWhQ4cOWkcyvNTUVAiCgJycHK2jEKnLADUHG3A/V1dXhzvvvBOPPvooHn/8cbz66quwWq1axyIAPXr0QLt27TgljIiIAoLH48Gf//xn3H333bj33nuxdu1atGzZUutYBCAiIgKxsbGsOYgCgFnrANSwM2fO4LbbbkN+fj5ee+01TJw4UetI9DOCIHBNFhmGXqZ1EVHznDt3DpMmTcL777+PpUuX4r777tM6Ev2CJElYs2YNZFnmk28ooAV6zcE74H7q8OHDGDp0KHbs2IFNmzax+fZTkiRh27ZtOHPmjNZRiNQjy94dROTXSktL4XA4sHHjRqxdu5bNt5+SJAlHjx7FoUOHtI5CpB4D1BxswP1QcXEx4uPjUVdXh8LCQqSkpGgdiRogSRI8Hg/y8vK0jkKkGiNsiEJkVPv27UN8fDyOHDmCvLw83HLLLVpHogYkJyfDZDJxHTgFNCPUHGzA/cy7776LtLQ0dO/eHUVFRejevbvWkegqYmJiEBMTw2noRESkO1lZWRg6dChCQ0NRXFyMgQMHah2JriI0NBRxcXGsOYh0jg24n5BlGYsWLcLYsWORmZmJzz77DJGRkVrHokbgOnAKeAbYkZTIaFasWIGbbroJCQkJyM/PxzXXXKN1JGqESzWHrJOptkRNZoCagw24H3A6nbj77rvx8MMPY+7cuXjjjTdgt9u1jkWNJEkSdu/ejbKyMq2jEKlC8Hh3EJH/8Hg8mDt3LqZNm4Zp06bhww8/RGhoqNaxqJEkSUJZWRn27dundRQiVRih5mADrrHKykpkZGRgxYoVWLFiBZ588kmIIv9Y9MThcAAAcnNztQ1CpBYDXI0mMoKamhpMmDABTz31FBYtWoTly5fDYrFoHYuaYOjQobBarZx5R4HLADUHOz0NHTlyBElJSSguLsbGjRsxdepUrSNRM7Rv3x49evTgpihEROS3ysvLMWzYMKxbtw7vvPMOZs2axUdZ6VBwcDASEhJYcxDpGJ8DrpGtW7ciIyMDdrsdBQUF6NWrl9aRyAuSJCErK0vrGESq8GZnUb3sSEoUyA4cOIBRo0bh7NmzyM3NRXx8vNaRyAuSJGHp0qVwu90wmUxaxyFSlBFqDt4B18AHH3yAlJQUXHPNNSgqKmLzHQAkScI333yDH374QesoRMozwDM5iQJVXl4ehgwZAqvViqKiIjbfAUCSJJw+fRo7d+7UOgqR8gxQc7AB97GlS5ciMzMTN998M3JychAVFaV1JFJAWloaAHBKGAUkIzyTkygQvf7660hPT8cNN9yAgoICXHvttVpHIgXEx8cjKCiI68ApIBmh5mAD7iMulwszZszAAw88gFmzZuHtt99GcHCw1rFIIZGRkYiNjWUDTkREmpNlGY8//jgmTZqEiRMnYsOGDQgPD9c6FinEarUiOTmZNQeRTnEN+G+QPWfgqtkAT91OeJw7IHtOARAgiBEQrbEQLbEw22+GIIY1OEZVVRXGjx+PjRs34sUXX8Qf//hH3/0A5DMOhwPvvfceZFnmxjYUWLzZWVQnV6OJ/M2Z8zUoq6qCLAOtg4PQpmWLRn2utrYW06dPx2uvvYYFCxZgzpw5PCcFIIfDgQULFsDpdHInewosBqg52IA3wOM6grqqpXCfXwfABcB08Z8XyJ4SeFwHALyJuoq/whQ0BtaQ+yCaOlwxzrFjxzB69GgcPHgQH330EUaMGOHLH4N8SJIkLFmyBIcPH0aXLl20jkOkGCNsiELkD4qP/IA1O3djy9HjOFZZecV/a9MiGP3bt8OYvr3h6HYtTPU8svTUqVMYM2YMioqKsGrVKowfP95X0cnHJEnCnDlzsGXLFgwZMkTrOESKMULNwQb8F2TZA9e511BXuQAXGm73xf/iqufdl16rg/v8GpyvWQdr6DyYg26HIAjYuXMnRo0aBUEQkJ+fj379+vnkZyBtpKSkQBRFZGdnswGnwOLNxiY62RCFSEu7fyzBoxuzsK+0rMH3lFefw6b/HMKm/xxCx7BQzB8uIa3rT2u6Dx06hJEjR+LkyZPIyspCYmKiL6KTRgYMGIDQ0FBkZ2ezAafAYoCag2vAf0aWXag9MxN1lfMA1OKn5rsx3IB8HnUVc1BbMRsbNnyEpKQkREVFobi4mM23AYSFhSEuLo6bolDAMcKGKERa+Xt+EX7/2uqrNt+/9ENFJaavWYtHPt6EOrcbBQUFSEhIgCzLKCoqYvNtAGazGampqaw5KOAYoeZgA36RLMuorXgY7pq1Xo/lOvcWvtk1GQ6HA3l5eWjfvr33AUkXHA4HcnJyIOvkChwREWnn8U+z8bf8Qrg8nmZ9fs2uPbh12T8hpaejZ8+eKCwsRLdu3RROSf7K4XCgoKAANTU1WkchoiZgA36R6/y7cJ9/F0qs3hcE4K7JLfHOqrvQokXjNk2hwCBJEkpKSrB//36toxApR/byIKJf+d+vtuH1bd4/x/mb87UY+D/3Y9OmTYiIiFAgGemFJEmoqalBUVGR1lGIlGOAmoMNOACPuxR1lX8FoOQuoQKcZ+dCdp9UcEzyd4mJibBYLJwSRgHFCNPBiHzp8KnTeP7zLxUbrzyiLbb+WKrYeKQPffv2RUREBGsOCihGqDnYgANwVa8A5Fooe9lEBuQqOM+tVHBM8nctWrRAQkICT4YUWDyydwcRXWFRzheocdW3uWvzyAD+32c5io1H+iCKIhwOB2sOCiwGqDkM34DLcg2c595E0zZcaywPnOdWQpadKoxN/kqSJOTm5sLTzDV9REQUuI5XVCL74LeKj3vwxCkUfX9U8XHJv0mShOLiYlRXV2sdhYgayfANuLu2CJArf/uNzeU5BU/dFvXGJ7/jcDhw6tQp7Nq1S+soRMowwHosIl/5cN9+uFXaqHPtnq9VGZf8l8PhgMvlQn5+vtZRiJRhgJrD8A24x7kLgEnFbxDhce5WcXzyNwkJCbDb7ZwSRgFDgBfrsbQOT+Rndh4vUW/sH39UbWzyTz169EC7du1Yc1DAMELNwQbc9TXUvVwiwO3ap+L45G9sNhuSkpJ4MqTAIcveHUR02ddl5aqN/e3J06hVcG05+T9BECBJEmsOChwGqDkM34DLnjMA1Fyr6wY8Z1Ucn/yRJEnIy8uDi4UQERH9TEVNrWpje2QZZ2vVG5/8kyRJ2LZtG86cOaN1FCJqBMM34OpOP/fld5A/cTgcOHv2LLZu3ap1FCKvGeGRIES+ovYUSVFgaWc0DocDHo8HeXl5Wkch8poRag7D/5YWTdEAzCp+gxmCqY2K45M/iouLQ0hICKeEUWAwwIYoRL7SLjREtbGDLRaEB9lVG5/807XXXouYmBjWHBQYDFBzsAG39IE6jyC7xAXR0lfF8ckfmc1mpKSk8GRIAUGQZa8OIvpJ7+i2qo3dM6oNREEv2xCRkrgOnAKFEWoONuDWgVD7conJMkDV8ck/SZKE/Px81HI9HhERXRR/TUfVxh7cSb2xyb9JkoTdu3ejvFy9Tf6ISBlswM19IJivgzqrskSIlr4QLd1VGJv8nSRJqKmpQXFxsdZRiLzj8fJohhdeeAExMTGw2+2Ij4/H5s2bG3zvSy+9hOTkZLRq1QqtWrVCenr6Vd9PpKWR1/dAqM2m+LiiIOB3sX0UH5f0weFwAAByc3O1DULkLQPUHIZvwAVBgKXFnVDnLrgH5uCpKoxLetCvXz+0bt2aU8JI93w9HWz16tWYOXMm5s+fj23btiE2NhYjRoxAWVlZve/Pzc3F7bffjpycHBQWFqJTp04YPnw4jh075u2PTqQ4u8WMCQP6KT5u+nVd0Sk8TPFxSR/at2+PHj16sOYg3TNCzSHIsk4my6tIlp04fyIDsus/UG49uAmipTfsEWshCNwF3ahuu+02lJeXc2dS0qXKykqEhYUhJWkezObmbezkctUgL/8JVFRUIDQ0tFGfiY+Px6BBg7Bs2TIAgMfjQadOnTBjxgzMnj37Nz/vdrvRqlUrLFu2DJMnT25WbiI11ThdyFjxGr4/fUaR8UJtNnx812REhbRUZDzSp3vvvRdZWVk4cOCA1lGImsxINYfh74ADgCBYYA9fcunflBgRgAhb+P9n821wkiShqKgI1dXVWkch0oW6ujps3boV6enpl18TRRHp6ekoLCxs1Bjnzp2D0+lE69at1YpJ5BW7xYxFGSNgM3tfIwgAnrhpGJtvgiRJ+Oabb/DDDz9oHYVIF7SqOdiAXyRaesIWvvTiv3nThAsABNha/QOiuZsCyUjPJEmC0+nEl19+qXUUouaTZe8OXLiy/fOjoc0JT5w4AbfbjaioqCtej4qKQklJSaPi/uUvf0H79u2vOKES+ZsbOrTHsltHe9WECwDmD5cwqmcP5YKRbqWlpQEAcnJytA1C5A0D1BxswH/GHDQatvAXAFgANOeEaAJgg63Vv2C2D1c2HOnS9ddfj+joaJ4MSdcE2bsDADp16oSwsLDLx8KFC1XJ+vTTT+Ott97C+++/D7udz0Mm/5bW9VqsuuP36BbZ9NkaUS1b4J9j/wt3DIhVIRnpUWRkJPr168eag3TNCDWHWZU0OmYOGgXR0hu1Zx6Cx7kFF5rq31oXfuE9onUwbGGLIJo7qR+UdEEQBDgcDm6KQvr2s6vKzfosgKNHj16xHsvWwC7QkZGRMJlMKC0tveL10tJSREdHX/WrnnvuOTz99NP47LPP0K+f8ptcEamhb7torP3vO/DK5q14Y9tOlFVdfclSiM2G2/r2woykBITyIhP9giRJeO+99yDLMgQ+E570yAA1BxvweojmGNgj1sBdmwNn9b/hqfsCF3ZJN+GnSQMeXGjMBZhsqTAHT4bJlsZfdvQrkiRh9erVqKioQFgYd6gl/RE8F47mfhYAQkNDG7UhitVqxcCBA5GVlYXMzEwAFzZEycrKwp/+9KcGP/fss89iwYIF+OSTTxAXF9e8sEQasZnNuHdoPP6QMAg5B7/F1h+OY09JKcqrquGRZbQKDkLvqLbo36EdhnfvhiCLRevI5KckScKSJUtw+PBhdOnSRes4RE1mhJqDDXgDBEGE2T4MZvswyJ5TcDt3w+PcC9lzCgIEQGwNk6UPREsfCGIrreOSH5MkCR6PB3l5eRg9erTWcYj83syZMzFlyhTExcVh8ODBWLJkCaqrqzF16oXHOk6ePBkdOnS4PKXsmWeewbx58/Dmm28iJibm8rqtli1bomVLbkxF+mEWRdzYvRtu7M49ZKh5UlJSIIoisrOz2YATNYIWNQcb8EYQxNYw21IBW6rWUUiHrr32WnTu3Bk5OTlswEmfFJgO1hTjxo1DeXk55s2bh5KSEvTv3x8bN268vEnKkSNHIIo/bWGyfPly1NXVYezYsVeMM3/+fDz22GPNy01EpENhYWGIi4tDTk4O7rrrLq3jEDWdAWoOPgecyAemTp2K7du3Y8eOHVpHIWq0S8/kTBs016tncuZ+taBJz+QkIqLmmz17Nl599VUcP36cSyNJN4xUc3AXdCIfkCQJO3fuxIkTJ7SOQtRkgix7dRARke9IkoSSkhLs379f6yhETWaEmoMNOJEPOBwOAEBubq62QYiIiCigJSYmwmKx8AksRH6KDTiRD3Ts2BHdu3fnyZD06dJ6rOYeRETkMy1atEBCQgJrDtInA9QcbMCJfMThcCAnJ0frGERNJ+PCkxebc+jjXEhEFFAcDgdyc3Ph8TTzeU5EWjFAzcEGnMhHJEnC/v37cfz4ca2jEDWJEdZjEREFEkmScOrUKezatUvrKERNYoSagw04kY+kpaUBAO+CExERkaoSEhJgt9s5DZ3ID7EBJ/KRtm3bom/fvjwZkv7I8GI9ltbhiYiMx2azISkpiTUH6Y8Bag424EQ+JEkS74CT/hhgQxQiokAjSRLy8vLgcrm0jkLUeAaoOdiAE/mQw+HA4cOHcfjwYa2jEDVeczdDuXQQEZHPORwOnD17Flu3btU6ClHjGaDmYANO5EOpqakQRZF3wYmIiEhVcXFxCAkJ4TR0Ij/DBpzIh8LDwzFgwACeDElXjLAjKRFRoDGbzUhJSWHNQbpihJqDDTiRj0mShOzsbMg6+SVBZIT1WEREgUiSJOTn56O2tlbrKESNY4Cagw04kY85HA78+OOP+Oabb7SOQtQ4BjgZEhEFIofDgZqaGhQXF2sdhahxDFBzsAEn8rGkpCSYzWYUfvkBXDXZcJ57F85z78FVkw2Pu0zreERERBQgYmNj0apVK05DJ/IjZq0DEBmJx3UUVs+b+HZnR7RutQy1p3/9HkFsC3PQ72AOngDR3NH3IYl+yZuryjq5Gk1EFIhEUcTQm27C+gP/gfmzXJRVVUGWgfAgO3pFtUX/9u3QM6qN1jGJfmKAmoMNOJEPyJ5q1J19Bq5zKwGIaN2q4eckyJ4yOKuXw1n9D5iD/xvWkIchiMG+C0v0Sx4AghefJSIin8s++C3+/dU2HOg3CADw6pbt9b6vV1RbTBwQi9v69YYoNPeXPZFCDFBzsAEnUpnbuRe1p+6C7CkBIANwN+JTF36DuM69Cnftp7C1ehkmSy81YxI1yJudRfWyIykRUaA4WX0O8z7JwqffHGzU+/eVluGRDZvw9s49eGbUcHSJaK1yQqKGGaHm4BpwIhW563ah5uTYi813cy7LeSC7S1Bzcizczt1KxyNqHANsiEJEFAgOnjiJ//r3G41uvn9ux/Efceu/30T+4e9VSEbUSAaoOdiAE6nE4y5FzamJgFwL7+bEuAH5PGpO3gHZXa5UPCIiIgogP5ypwORV76D0bFWzxzjndOKedz/AlqPHFExGRD/HBpxIBbIso65iDiBXoXFTzn+LB5CrUFvxCJ8fTr7nkb07iIhIVbIs4+GPPkF59Tmvx6pxufDQhxtQVVunQDKiJjJAzcEGnEgF7tosuGuzoEzzfXlUuGs/hbs2R8ExiRrBANPBiIj07M3tu/CVgnetj1eexXOf5ys2HlGjGaDmYANOpAJn9SsATCqMbLo4NpEveXMi1MfJkIhIrzyyjJeKtig+7pqde3DynPd31ImaJvBrDjbgRArzuL6Hp64Ayt79vsQNT10+PK4jKoxNREREepN76DCOVVYqPm6d2413du1VfFwio2MDTqQwd91mH3yH8le6iRpkgOlgRER6lf+teruWqzk2Ub0MUHOwASdSmMe5G4BZxW8wX/wOIh8xwIYoRER6tae0VLWx95aWcfNX8i0D1BxqdglEhuRxHwXgUvEbXJDdP6g4PtEvyJ4LR3M/S0REqjlyukK1sc/W1uLU+fOICA5W7TuIrmCAmoN3wImUJqv/2A5ZrlX9O4iIiMj/Od1q7DnzE5dbH00NkV7wDjiRwgShBQAB6u3EKEAQW6g0NlE9vFlXxamLRESqamGzorJWvQvzwVaLamMT/YoBag7eASdSmGjpDnUeQXb5GyCau6s4PtEvGGA9FhGRXnWPjFBt7PahIQix2VQbn+hXDFBzsAEnUpho6Qt114C7L34HkY8YYEdSIiK96hMdpcuxieplgJqDDTiRwkzWIQDUvFpsh8kar+L4REREpBcje6o3K07NsYmMig04kcIEMRTm4NugzjR0E8zBYyGIISqMTdQAGV5cjdY6PBFRYOveJhJxHTsoPm6bFsEY3r2b4uMSXZUBag424EQqsLSYptLIgopjEzXAANPBiIj07M9pSRAFQdExH0xJhMWk5p42RPUwQM3BBpxIBaK5GywtH1R8XEvIQxDNXRQfl+iqPB7vDiIiUtWAju3x33E3KDZe8rWd8bvYPoqNR9RoBqg52IATqcTS8m6IlkFQ5q+ZCNESD0uLPygwFhEREQWah9KSkNIlxutxukW2xuJbbvY+EBHViw04kUoEwQJ76/+FaOkH7/6qiRAt/WFvvQKCYFYqHlHjGWA6GBGR3llNJvxjzGjcfP11zR4jtn00Xp/wO7QKClIwGVETGKDmYANOpCJBDIG99SqYg8ZffKUpf+UuvNccfAfsEW9CEFsqno+oUQxwMiQiCgQ2sxl/y8zAcxk3Icze+CeyWE0mPJSaiNUTxyEiOFjFhES/wQA1B2+nEalMEINhC18Ic9Ao1FY+Cdn1NS781WvoWeEX/pto7glr6FyYbIm+C0tUH4+MZm8t6tHHyZCIKJD8V5+ekK7rgrV7vsbbO3bjQPmJen+LdwwLxZi+vTGufx+0bckL/eQHDFBzsAEn8hGTLQlBkRvgce6E6/z78Di3weP8GoDz4jssEC09IVoGwBw0BiZrrJZxiS6TZQ9kuXkbmzT3c0RE5J0Qmw2TBvbHpIH9cbamFvtKy1BWXQ2PLKN1UBB6RbVFRAve7Sb/YoSagw04kQ8JggCTtT9M1v4AAFl2A/J5AAIg2CEIfNwHERERKSvEbkN8505axyAisAEn0pQgmACBU77Iz8ly86d16WQ9FhEREfkBA9QcbMCJiOjqZC/WY+nkZEhERER+wAA1BxtwIiK6Oo8HEJq5rkon67GIiIjIDxig5uBjyIiIiIiIiIh8gHfAiYjo6gwwHYyIiIj8gAFqDjbgRER0VbLHA7mZ08H08kgQIiIi0p4Rag424EREdHUGuBpNREREfsAANQfXgBMRERERERH5AO+AExHR1XlkQAjsq9FERETkBwxQc7ABJyKiq5NlAM19JIg+ToZERETkBwxQc7ABJyKiq5I9MuRmXo2WdXIyJCIiIu0ZoebgGnAiIvI7L7zwAmJiYmC32xEfH4/Nmzdf9f1r1qzB9ddfD7vdjr59++Ljjz/2UVIiIiLSM1/XHGzAiYjo6mSPd0cTrV69GjNnzsT8+fOxbds2xMbGYsSIESgrK6v3/QUFBbj99tsxbdo0bN++HZmZmcjMzMSePXu8/cmJiIjIlwxQcwiyXu7VExGRT1VWViIsLAxpwq0wC5ZmjeGSnciV30dFRQVCQ0Mb9Zn4+HgMGjQIy5YtAwB4PB506tQJM2bMwOzZs3/1/nHjxqG6uhrr16+//FpCQgL69++PF198sVm5iYiIyHeMVHPwDjgREV2dD69G19XVYevWrUhPT7/8miiKSE9PR2FhYb2fKSwsvOL9ADBixIgG309ERER+ygA1BzdhIyKiq3LBCTRzrpQLTgAXrmz/nM1mg81m+9X7T5w4AbfbjaioqCtej4qKwv79++v9jpKSknrfX1JS0rzQREREpAkj1BxswImIqF5WqxXR0dHIL/FuQ7OWLVuiU6dOV7w2f/58PPbYY16NS0RERIHBSDUHG3AiIqqX3W7H4cOHUVdX59U4sixDEIQrXqvvSjQAREZGwmQyobS09IrXS0tLER0dXe9noqOjm/R+IiIi8i9GqjnYgBMRUYPsdjvsdrvPvs9qtWLgwIHIyspCZmYmgAsbomRlZeFPf/pTvZ8ZMmQIsrKy8MADD1x+bdOmTRgyZIgPEhMREZESjFJzsAEnIiK/MnPmTEyZMgVxcXEYPHgwlixZgurqakydOhUAMHnyZHTo0AELFy4EANx///1ITU3F4sWLMWrUKLz11lvYsmUL/vWvf2n5YxAREZGf06LmYANORER+Zdy4cSgvL8e8efNQUlKC/v37Y+PGjZc3PTly5AhE8aeHeAwdOhRvvvkmHn30UTzyyCO47rrrsHbtWvTp00erH4GIiIh0QIuag88BJyIiIiIiIvIBPgeciIiIiIiIyAfYgBMRERERERH5ABtwIiIiIiIiIh9gA05ERERERETkA2zAiYiIiIiIiHyADTgRERERERGRD7ABJyIiIiIiIvIBNuBEREREREREPsAGnIiIiIiIiMgH2IATERERERER+QAbcCIiIiIiIiIfYANORERERERE5AP/B9P5tBjZLarOAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -652,7 +616,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -703,7 +667,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -731,7 +695,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -744,11 +708,14 @@ " [0]], dtype=torch.int32)\n", "\n", "emedding (shape = torch.Size([3, 7])):\n", - "tensor([[ 0.6411, -0.1063, -0.1063, -0.1063, -0.1063, 0.7921, 0.0454],\n", - " [ 0.6411, -0.1063, -0.1063, 0.7921, -0.1063, -0.1063, 0.0454],\n", - " [ 0.6411, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, -0.2725]])\n", + "tensor([[ 6.4111e-01, -3.5117e-02, -1.9342e-01, 4.7708e-01, 6.3531e-01,\n", + " 5.3155e-02, 4.5413e-02],\n", + " [ 6.4111e-01, 1.0346e-02, -2.3692e-01, -4.4906e-01, -7.8950e-17,\n", + " 6.4406e-01, 4.5413e-02],\n", + " [ 6.4111e-01, 0.0000e+00, 0.0000e+00, -0.0000e+00, 0.0000e+00,\n", + " 0.0000e+00, -2.7248e-01]])\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(1.8612e-07)\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(5.1619e-08)\n" ] } ], @@ -788,7 +755,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -796,8 +763,8 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "tensor([[ 0.2799, -0.3914],\n", - " [ 0.3957, 0.4641],\n", + "tensor([[ 0.1226, 1.7916],\n", + " [ 0.1192, -0.3994],\n", " [ 0.0718, 0.6314]])\n" ] } @@ -829,12 +796,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -929,9 +896,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "base", + "display_name": "gkconda_updated_sh", "language": "python", - "name": "python3" + "name": "gkconda_updated_sh" }, "language_info": { "codemirror_mode": { @@ -943,7 +910,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/notebooks/backends/PyTorch_SimplicialComplex.ipynb b/notebooks/backends/PyTorch_SimplicialComplex.ipynb deleted file mode 100644 index 2e80be7a..00000000 --- a/notebooks/backends/PyTorch_SimplicialComplex.ipynb +++ /dev/null @@ -1,1271 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "N2YCQeyY50Xg" - }, - "outputs": [], - "source": [ - "# To run this in Google Colab, uncomment the following line\n", - "# !pip install geometric_kernels\n", - "\n", - "# If you want to use a version of the library from a specific branch on GitHub,\n", - "# say, from the \"devel\" branch, uncomment the line below instead\n", - "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", - "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected.\n", - "\n", - "We construct the simplicial 2-complex by adding triangles to the graph. The triangles can be provided by users. If not provided, we look for all the 2-cliques in the graph and add them to the simplicial 2-complex.\n", - "\n", - "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", - "\n", - "We use the **PyTorch** backend here.\n", - "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Contents\n", - "- [**Basics**](#Basics)\n", - " - [Defining a Space](#Defining-a-Space)\n", - " - [Defining a Kernel](#Defining-a-Kernel)\n", - " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", - " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", - "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", - " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", - " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", - "- [**Citation**](#Citation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NaG9OvVp-Ryf", - "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): Torch backend enabled.\n" - ] - } - ], - "source": [ - "# Import a backend, we use jax in this example.\n", - "import torch\n", - "import numpy as np\n", - "# Import the geometric_kernels backend.\n", - "import geometric_kernels\n", - "\n", - "# Note: if you are using a backend other than numpy,\n", - "# you _must_ uncomment one of the following lines\n", - "# import geometric_kernels.tensorflow\n", - "import geometric_kernels.torch\n", - "# from geometric_kernels import jax\n", - "\n", - "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", - "\n", - "# We use networkx to visualize graphs\n", - "import networkx as nx\n", - "\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Space" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First we create and visualize a simple *5-node, 6-edge graph* using `networkx`" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "PM1H-As8-KF7" - }, - "outputs": [], - "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the triangle set " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "triangles = [(1,2,3)]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the positions of the nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the graph." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", - "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "# shade the area of the triangle\n", - "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the sets of nodes, edges and triangles. \n", - "\n", - "**Note that**: \n", - "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", - "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "triangles: [(1, 2, 3)]\n" - ] - } - ], - "source": [ - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('triangles:', triangles)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", - "\n", - "The `G` parameter is a 'networkx.classes.graph.Graph' object, from which we build the node-to-edge incidence matrix.\n", - "\n", - "The 'triangle_list' parameter is a list of tuples, where each tuple is a triangle in the graph. If provided, this will be used to construct a simplicial 2-complex.\n", - "\n", - "The 'sc_lifting' parameter is a boolean that determines if to build a simplicial 2-complex. \n", - "- If True and 'triangle_list' is not None, the edge space of a simplicial 2-complex will be built based on the provided triangles. \n", - "- If True and 'triangle_list' is None, the edge space of a simplicial 2-complex with all the 2-cliques as 2-simplices will be built. \n", - "- If False and no 'triangle_list' provided, the edge space of the graph will be built.\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define the Simplicial 2-Complex " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "B1 = nx.incidence_matrix(G).toarray()\n", - "B2 = np.array([[ 1.],\n", - " [1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "sc = GraphEdge(B1,B2)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([1, 2, 3, 4, 5],\n", - " [(1, 2), (1, 3), (1, 4), (2, 3), (3, 5), (4, 5)],\n", - " [(1, 2, 3)])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sc.nodes, sc.edges, sc.triangles" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the incidence matrices" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "node-to-edge incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", - "edge-to-triangle incidence matrix:\n", - " [[ 1.]\n", - " [-1.]\n", - " [ 0.]\n", - " [ 1.]\n", - " [ 0.]\n", - " [ 0.]]\n" - ] - } - ], - "source": [ - "print('node-to-edge incidence matrix:\\n', sc.incidence_matrices[0])\n", - "print('edge-to-triangle incidence matrix:\\n', sc.incidence_matrices[1])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the computed Laplacians" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hodge Laplacian:\n", - " [[ 3. 0. 1. 0. 0. 0.]\n", - " [ 0. 3. 1. 0. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [ 0. 0. 0. 3. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Down Hodge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Up Hodge Laplacian:\n", - " [[ 1. -1. 0. 1. 0. 0.]\n", - " [-1. 1. 0. -1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 1. -1. 0. 1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]]\n" - ] - } - ], - "source": [ - "print('Hodge Laplacian:\\n', sc.hodge_laplacian)\n", - "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc._down_edge_laplacian)\n", - "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc._up_edge_laplacian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Defining a Kernel" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we create a generic Matérn kernel.\n", - "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `sc` we have just created above.\n", - "\n", - "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", - "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", - "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using Hodge compositional kernel!\n" - ] - } - ], - "source": [ - "use_hodge_composition=True\n", - "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", - "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", - "\n", - "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", - "\n", - "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: {'harmonic': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}}\n" - ] - } - ], - "source": [ - "params = kernel.init_params()\n", - "print('params:', params)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", - "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Note**: for the Hodge-compositional kernel, we need to specify the parameters for each Hodge subspace. " - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "import copy\n", - "\n", - "if use_hodge_composition:\n", - " params[\"harmonic\"][\"lengthscale\"], params[\"gradient\"][\"lengthscale\"], params[\"curl\"][\"lengthscale\"] = torch.tensor([0.5]), torch.tensor([2.0]), torch.tensor([1.0])\n", - " params_hodge_1 = copy.deepcopy(params)\n", - " params_hodge_2 = copy.deepcopy(params)\n", - " del params\n", - " params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = torch.tensor([3/2]), torch.tensor([3/2]), torch.tensor([3/2])\n", - " params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = torch.tensor([torch.inf]), torch.tensor([torch.inf]), torch.tensor([torch.inf])\n", - " \n", - "else:\n", - " params[\"lengthscale\"] = torch.tensor([2.0])\n", - " params_32 = params.copy()\n", - " params_inf = params.copy()\n", - " del params\n", - " params_32[\"nu\"] = torch.tensor([3/2])\n", - " params_inf[\"nu\"] = torch.tensor([torch.inf])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Check the eigenvalues of the kernels" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eigenvalues for the first set of parameters:\n", - "{'harmonic': tensor([[0.0241]]), 'gradient': tensor([[0.3212],\n", - " [0.1804],\n", - " [0.1095],\n", - " [0.0804]]), 'curl': tensor([[0.0680]])}\n", - "\n", - "Eigenvalues for the second set of parameters:\n", - "{'harmonic': tensor([[1.]]), 'gradient': tensor([[6.3043e-02],\n", - " [8.5320e-03],\n", - " [7.2014e-04],\n", - " [9.7460e-05]]), 'curl': tensor([[0.2231]])}\n" - ] - } - ], - "source": [ - "if use_hodge_composition:\n", - " # Evaluate the eigenvalues for the first set of parameters\n", - " eigenvalues_hodge_1 = kernel.eigenvalues(params_hodge_1, normalize=False)\n", - " # Evaluate the eigenvalues for the second set of parameters\n", - " eigenvalues_hodge_2 = kernel.eigenvalues(params_hodge_2, normalize=False)\n", - " # Print the results\n", - " print(\"Eigenvalues for the first set of parameters:\")\n", - " print(eigenvalues_hodge_1)\n", - " print(\"\\nEigenvalues for the second set of parameters:\")\n", - " print(eigenvalues_hodge_2)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Evaluating Kernels on Random Inputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We start by sampling `3` (uniformly) random points on the edge space of our simplicial complex.\n", - "An explicit `key` parameter is needed to support JAX as one of the backends.\n", - "\n", - "**Note:** the here `xs` are the **indicex** of the sampled edges, not the edges themselves." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[(3, 5), (1, 3), (1, 2)]\n" - ] - } - ], - "source": [ - "key = torch.Generator()\n", - "key.manual_seed(123)\n", - "\n", - "key, random_sampled_edges, xs = sc.random(key, 3)\n", - "print(random_sampled_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If users prefer input the edges directly, we would need to obtain the indices of the edges in the edge space of the simplicial complex. This can be done by calling `sc.get_edge_index(input_edges)`.\n", - "\n", - "Below we verify that the indices of the sampled edges are correct." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[4],\n", - " [1],\n", - " [0]], dtype=torch.int32)\n", - "tensor([[4],\n", - " [1],\n", - " [0]])\n" - ] - } - ], - "source": [ - "print(xs)\n", - "input_indices = sc.get_edge_index(random_sampled_edges)\n", - "input_indices = torch.tensor(input_indices).reshape(-1, 1)\n", - "print(input_indices)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we evaluate the two kernel matrices." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "if use_hodge_composition:\n", - " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs, normalize=False)\n", - " kernel_mat_inf = kernel.K(params_hodge_2, xs, xs, normalize=False)\n", - "else:\n", - " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - " kernel_mat_inf = kernel.K(params_inf, xs, xs)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we visualize these matrices using `imshow`." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# find common range of values\n", - "minmin = min([torch.min(kernel_mat_32), torch.min(kernel_mat_inf)])\n", - "maxmax = max([torch.max(kernel_mat_32), torch.max(kernel_mat_inf)])\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax1.set_title('k_32')\n", - "ax1.set_axis_off()\n", - "\n", - "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", - "ax2.set_title('k_inf')\n", - "ax2.set_axis_off()\n", - "\n", - "# add space for color bar\n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", - "\n", - "# add colorbar\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", - "fig.colorbar(sm, cax=cbar_ax)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(tensor([[ 0.4923, 0.1711, 0.0171],\n", - " [ 0.1711, 0.5515, -0.2242],\n", - " [ 0.0171, -0.2242, 0.5094]]),\n", - " tensor([[ 0.5921, 0.1899, -0.0975],\n", - " [ 0.1899, 0.4823, -0.2588],\n", - " [-0.0975, -0.2588, 0.4945]]))" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "kernel_mat_32, kernel_mat_inf" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualizing Kernels" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we visualize $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges`.\n", - "We define `base_edge` and `other_edges` in the next cell." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "base_edge = [(1,2)]\n", - "base_edge_idx = sc.get_edge_index(base_edge)[0]\n", - "other_edges = torch.arange(sc.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "if use_hodge_composition:\n", - " values_32 = kernel.K(params_hodge_1, torch.tensor([[base_edge_idx]]), other_edges).flatten()\n", - " values_inf = kernel.K(params_hodge_2, torch.tensor([[base_edge_idx]]), other_edges).flatten()\n", - "else:\n", - " values_32 = kernel.K(params_32, torch.tensor([[base_edge_idx]]),\n", - " other_edges).flatten()\n", - " values_inf = kernel.K(params_inf, torch.tensor([[base_edge_idx]]),\n", - " other_edges).flatten()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# Get prior variances k(*, *) for * in nodes:\n", - "if use_hodge_composition:\n", - " variance_32 = kernel.K_diag(params_hodge_1, other_edges)\n", - " variance_inf = kernel.K_diag(params_hodge_2, other_edges)\n", - "else:\n", - " variance_32 = kernel.K_diag(params_32, other_edges)\n", - " variance_inf = kernel.K_diag(params_inf, other_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here are the actual visualization routines.\n", - "\n", - "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "\n", - "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", - "\n", - "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", - "# shade the area of the triangle\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", - "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", - "\n", - "\n", - "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", - "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax3)\n", - "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", - "\n", - "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", - "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", - "cbar = plt.colorbar(sm, ax=ax4)\n", - "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "check the eigenbasis and their types being either gradient, curl or harmonic" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Variance in the edge (1,2) is 0.51,\n", - "Variance in the edge (1,3) is 0.55,\n", - "The average variance is 0.50.\n" - ] - } - ], - "source": [ - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", - "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", - "print('The average variance is %0.2f.' % torch.mean(variance_32))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Feature Maps and Sampling\n", - "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", - "$$\n", - "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", - "$$\n", - "This might be useful for speeding up computations.\n", - "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", - "\n", - "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "### Defining a Feature Map" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", - "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", - "Below we rely on the default value of `num`." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "from geometric_kernels.kernels import default_feature_map\n", - "\n", - "feature_map = default_feature_map(kernel=kernel)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", - "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", - "For the edge sapce of graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", - "\n", - "`feature_map` outputs a tuple.\n", - "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", - "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", - "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\n", - "\n", - "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", - "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xs (shape = torch.Size([3, 1])):\n", - "tensor([[4],\n", - " [1],\n", - " [0]], dtype=torch.int32)\n", - "\n", - "harmonic emedding (shape = torch.Size([3, 1])):\n", - "tensor([[0.5222],\n", - " [0.3482],\n", - " [0.1741]])\n", - "gradient emedding (shape = torch.Size([3, 4])):\n", - "tensor([[-4.0994e-01, 7.6033e-02, 1.4795e-01, -1.5442e-01],\n", - " [-4.5399e-16, 2.4605e-01, -3.5347e-16, 1.9088e-01],\n", - " [ 2.5336e-01, 1.2302e-01, 2.3938e-01, 9.5438e-02]])\n", - "curl emedding (shape = torch.Size([3, 1])):\n", - "tensor([[ 3.8858e-16],\n", - " [-5.7735e-01],\n", - " [ 5.7735e-01]])\n", - "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = tensor(1.4901e-08)\n" - ] - } - ], - "source": [ - "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", - "print('')\n", - "\n", - "if use_hodge_composition:\n", - " _, harmonic_embedding = feature_map(xs, params_hodge_1['harmonic'], hodge_type='harmonic') \n", - " _, gradient_embedding = feature_map(xs, params_hodge_1['gradient'],hodge_type='gradient')\n", - " _, curl_embedding = feature_map(xs, params_hodge_1['curl'], hodge_type='curl')\n", - " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", - " kernel_mat_32_alt = torch.matmul(harmonic_embedding, harmonic_embedding.T) + torch.matmul(gradient_embedding, gradient_embedding.T) + torch.matmul(curl_embedding, curl_embedding.T) \n", - " print('harmonic emedding (shape = %s):\\n%s' % (harmonic_embedding.shape, harmonic_embedding))\n", - " print('gradient emedding (shape = %s):\\n%s' % (gradient_embedding.shape, gradient_embedding))\n", - " print('curl emedding (shape = %s):\\n%s' % (curl_embedding.shape, curl_embedding))\n", - "else:\n", - " # xs are random points from above\n", - " _, embedding = feature_map(xs, params_32, normalize=True)\n", - " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - " kernel_mat_32_alt = torch.matmul(embedding, embedding.T)\n", - " print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", - " \n", - "print('')\n", - "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', torch.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Efficient Sampling using Feature Maps\n", - "\n", - "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", - "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", - "\n", - "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", - "It returns a function we name `sample_paths`.\n", - "\n", - "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", - "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", - "`sample_paths` returns a tuple.\n", - "Its first element is the updated `key`.\n", - "Its second element is an array containing the value of samples evaluated at the input points." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Two samples evaluated at the xs are:\n", - "tensor([[-0.1916, 0.0824],\n", - " [-0.3929, 0.2983],\n", - " [-0.3407, -0.4310]])\n" - ] - } - ], - "source": [ - "from geometric_kernels.sampling import sampler\n", - "\n", - "sample_paths = sampler(feature_map, s=2)\n", - "\n", - "# introduce random state for reproducibility (optional)\n", - "# `key` is jax's terminology\n", - "key = torch.Generator()\n", - "key.manual_seed(123)\n", - "\n", - "# new random state is returned along with the samples\n", - "if use_hodge_composition:\n", - " key, samples_harmonic = sample_paths(xs, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", - " key, samples_gradient = sample_paths(xs, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", - " key, samples_curl = sample_paths(xs, params_hodge_1['curl'], key=key, hodge_type='curl')\n", - " samples = samples_harmonic + samples_gradient + samples_curl\n", - "else:\n", - " key, samples = sample_paths(xs, params_32, key=key)\n", - "\n", - "print('Two samples evaluated at the xs are:')\n", - "print(samples)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Visualizing Samples\n", - "Here we visualize samples as functions on the edges of a graph." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "key = torch.Generator()\n", - "key.manual_seed(1234)\n", - "if use_hodge_composition:\n", - " key, samples_harmonic = sample_paths(other_edges, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", - " key, samples_gradient = sample_paths(other_edges, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", - " key, samples_curl = sample_paths(other_edges, params_hodge_1['curl'], key=key, hodge_type='curl')\n", - " samples = samples_harmonic + samples_gradient + samples_curl\n", - "else:\n", - " key, samples = sample_paths(other_edges, params_32, key=key)\n", - "\n", - "sample1 = samples[:, 0]\n", - "sample2 = samples[:, 1]\n", - "\n", - "cmap = plt.get_cmap('viridis')\n", - "\n", - "# Set the colorbar limits:\n", - "vmin = min(sample1.min(), sample2.min())\n", - "vmax = max(sample1.max(), sample2.max())\n", - " \n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", - "\n", - "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(sample1),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax1)\n", - "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "\n", - "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(sample2),\n", - " vmin=vmin, vmax=vmax, **options)\n", - "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", - "sm = plt.cm.ScalarMappable(cmap=cmap,\n", - " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", - "cbar = plt.colorbar(sm, ax=ax2)\n", - "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Citation\n", - "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", - "\n", - "```\n", - "@article{mostowsky2024,\n", - " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", - " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", - " year = {2024},\n", - " journal = {arXiv:2407.08086},\n", - "}\n", - "```\n", - "\n", - "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", - "}\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "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.11.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tests/spaces/test_graph_edge.py b/tests/spaces/test_graph_edges.py similarity index 100% rename from tests/spaces/test_graph_edge.py rename to tests/spaces/test_graph_edges.py From e538fb7d23d2038e0c8e2e61ee17e139ec951671 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Mon, 16 Dec 2024 20:37:02 +0100 Subject: [PATCH 14/30] Major revision of graph_edge.py [continued 3, working prototype] --- docs/examples/GraphEdges.nblink | 1 + .../feature_maps/deterministic.py | 16 +- .../feature_maps/random_phase.py | 2 +- .../kernels/hodge_compositional.py | 2 +- geometric_kernels/kernels/matern_kernel.py | 2 +- geometric_kernels/sampling/samplers.py | 9 +- geometric_kernels/spaces/eigenfunctions.py | 13 +- geometric_kernels/spaces/graph_edges.py | 142 +++- notebooks/Graph.ipynb | 5 +- notebooks/GraphEdges.ipynb | 748 ++++++++---------- 10 files changed, 467 insertions(+), 473 deletions(-) create mode 100644 docs/examples/GraphEdges.nblink diff --git a/docs/examples/GraphEdges.nblink b/docs/examples/GraphEdges.nblink new file mode 100644 index 00000000..7b184917 --- /dev/null +++ b/docs/examples/GraphEdges.nblink @@ -0,0 +1 @@ +{"path": "../../notebooks/GraphEdges.ipynb"} \ No newline at end of file diff --git a/geometric_kernels/feature_maps/deterministic.py b/geometric_kernels/feature_maps/deterministic.py index 0f515d17..b9af3472 100644 --- a/geometric_kernels/feature_maps/deterministic.py +++ b/geometric_kernels/feature_maps/deterministic.py @@ -10,11 +10,8 @@ from geometric_kernels.feature_maps.base import FeatureMap from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel -from geometric_kernels.spaces import ( - DiscreteSpectrumSpace, - Eigenfunctions, - HodgeDiscreteSpectrumSpace, -) +from geometric_kernels.spaces import DiscreteSpectrumSpace, HodgeDiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import Eigenfunctions class DeterministicFeatureMapCompact(FeatureMap): @@ -182,11 +179,12 @@ def __call__( ) ) - return B.concat( + return None, B.concat( coeffs[0] - * self.feature_map_harmonic(X, params["harmonic"], normalize, **kwargs), + * self.feature_map_harmonic(X, params["harmonic"], normalize, **kwargs)[1], coeffs[1] - * self.feature_map_gradient(X, params["gradient"], normalize, **kwargs), - coeffs[2] * self.feature_map_curl(X, params["curl"], normalize, **kwargs), + * self.feature_map_gradient(X, params["gradient"], normalize, **kwargs)[1], + coeffs[2] + * self.feature_map_curl(X, params["curl"], normalize, **kwargs)[1], axis=-1, ) diff --git a/geometric_kernels/feature_maps/random_phase.py b/geometric_kernels/feature_maps/random_phase.py index d7d7cdbb..a3dd1664 100644 --- a/geometric_kernels/feature_maps/random_phase.py +++ b/geometric_kernels/feature_maps/random_phase.py @@ -42,7 +42,7 @@ def __init__( num_levels: int, num_random_phases: int = 3000, ): - from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel + pass self.space = space self.num_levels = num_levels diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py index 76760db6..cd253af8 100644 --- a/geometric_kernels/kernels/hodge_compositional.py +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -156,7 +156,7 @@ def K_diag( params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} coeffs = B.softmax( B.stack( - [params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], axis=0, ) ) diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 8a63aafb..231a7632 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -211,7 +211,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) elif isinstance(space, GraphEdges): - return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) + return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.n_edges) elif isinstance(space, HypercubeGraph): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index 5f75900f..5d74b2b2 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -90,9 +90,12 @@ def sample_at( num_features = B.shape(features)[-1] - key, random_weights = B.randn( - key, B.dtype(params["lengthscale"]), num_features, s - ) # [M, S] + if "lengthscale" in params: + dtype = B.dtype(params["lengthscale"]) + else: + dtype = B.dtype(params["gradient"]["lengthscale"]) + + key, random_weights = B.randn(key, dtype, num_features, s) # [M, S] random_sample = B.matmul(features, random_weights) # [N, S] diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 5ad7b8f6..6b082295 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -264,10 +264,15 @@ class EigenfunctionsFromEigenvectors(Eigenfunctions): :param eigenvectors: Array of shape [D, J] containing J eigenvectors of dimension D. + + :param index_from_one: + If True, the indices are assumed to be 1-based. If False, they are + assumed to be 0-based. Defaults to False. """ - def __init__(self, eigenvectors: B.Numeric): + def __init__(self, eigenvectors: B.Numeric, index_from_one: bool = False): self.eigenvectors = eigenvectors + self.index_from_one = index_from_one def weighted_outerproduct( self, @@ -323,7 +328,11 @@ def __call__(self, X: B.Numeric, **kwargs) -> B.Numeric: corresponds to the X[n]-th element of the j-th eigenvector. """ indices = B.cast(B.dtype_int(X), X) - Phi = take_along_axis(self.eigenvectors, indices, axis=0) + if self.index_from_one: + assert B.all(indices >= 1) + else: + assert B.all(indices >= 0) + Phi = take_along_axis(self.eigenvectors, indices - 1, axis=0) return Phi @property diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 1ea4c8b1..093c9e8b 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -5,7 +5,7 @@ import lab as B import numpy as np from beartype.typing import Dict, List, Optional, Tuple, Union -from scipy.sparse import csr_array, lil_array, coo_matrix, spmatrix +from scipy.sparse import csr_array, lil_array, sparray, spmatrix from geometric_kernels.lab_extras import dtype_integer, eigenpairs, int_like from geometric_kernels.spaces.base import HodgeDiscreteSpectrumSpace @@ -166,10 +166,10 @@ def __init__( if oriented_triangles is not None: if do_checks: self._checks_oriented_triangles( - oriented_triangles, self.n_edges, comprehensive_checks + oriented_triangles, comprehensive_checks ) if comprehensive_checks: - self._checks_compatible(oriented_edges, oriented_triangles, n_nodes) + self._checks_compatible(oriented_triangles) self.n_triangles = oriented_triangles.shape[0] else: self.n_triangles = 0 @@ -245,6 +245,9 @@ def _checks_oriented_edges( assert B.any( oriented_edges[i, :] != oriented_edges[j, :] ), "The oriented_edges array must not contain duplicate edges." + assert B.any( + oriented_edges[i, :] != oriented_edges[j, ::-1] + ), "The oriented_edges array must not contain duplicate edges." assert set(range(self.n_nodes)) == set( B.to_numpy(B.flatten(oriented_edges)) @@ -275,11 +278,11 @@ def _checks_oriented_triangles( oriented_triangles ), "The oriented_triangles must be an array of integers." assert B.all( - oriented_triangles >= 1 - ), "The oriented_triangles array must contain only strictly positive values." + B.abs(oriented_triangles) >= 1 + ), "The oriented_triangles array must contain only non-zero values." assert B.all( - oriented_triangles <= self.n_edges - ), "The values in the oriented_triangles array must be <= self.n_edges." + B.abs(oriented_triangles) <= self.n_edges + ), "The absolute values in the oriented_triangles array must be <= self.n_edges." assert B.all( B.abs(oriented_triangles) < self.n_edges @@ -322,7 +325,7 @@ def _checks_compatible( n_triangles = oriented_triangles.shape[0] for t in range(n_triangles): - resolved_edges = self.resolve_edge(oriented_triangles[t, :]) + resolved_edges = self.resolve_edges(oriented_triangles[t, :]) assert ( resolved_edges[0, 1] == resolved_edges[1, 0] ), "The edges in the triangle must be connected." @@ -337,21 +340,29 @@ def _check_index(self, index: csr_array): edges = [] for e in range(1, self.oriented_edges.shape[0] + 1): i, j = self.oriented_edges[e - 1, :] - assert index[i, j] == e, "The index matrix must be compatible with oriented_edges." - assert index[j, i] == -e, "The index matrix must be compatible with oriented_edges." + assert ( + index[i, j] == e + ), "The index matrix must be compatible with oriented_edges." + assert ( + index[j, i] == -e + ), "The index matrix must be compatible with oriented_edges." edges.append((min(i, j), max(i, j))) for i in range(self.n_nodes): for j in range(i + 1, self.n_nodes): if (i, j) not in edges: - assert index[i, j] == 0, "The index matrix must be compatible with oriented_edges." - assert index[j, i] == 0, "The index matrix must be compatible with oriented_edges." - - def resolve_edge(self, e: B.Int) -> B.Int: + assert ( + index[i, j] == 0 + ), "The index matrix must be compatible with oriented_edges." + assert ( + index[j, i] == 0 + ), "The index matrix must be compatible with oriented_edges." + + def resolve_edges(self, es: B.Int) -> B.Int: """ Resolve the signed edge indices to node indices. - :param e: + :param es: A 1-dimensional array of edge indices. Each edge index is a number from 1 to the number of edges (incl.). @@ -359,22 +370,44 @@ def resolve_edge(self, e: B.Int) -> B.Int: A 2-dimensional array `result` such that `result[e, :]` is `[i, j]` where |e| = (i, j) if e > 0 and |e| = (j, i) if e < 0. """ - assert B.rank(e) == 1 - assert B.all(B.abs(e) >= 1) and B.all(B.abs(e) <= self.n_edges) - - result = self.edges[B.abs(e) - 1] - # TODO: will not work with TF/JAX - result[e < 0] = result[e < 0][::-1] + assert B.rank(es) == 1 + assert B.all(B.abs(es) >= 1) and B.all(B.abs(es) <= self.n_edges) + result = self.oriented_edges[B.abs(es) - 1] + result = B.where(B.expand_dims(es > 0, axis=-1), result, result[:, ::-1]) return result + def resolve_triangles(self, ts: B.Int) -> B.Int: + """ + Resolve the triangle indices to node indices. + + :param ts: + A 1-dimensional array of triangle indices. Each triangle index is a + number from 0 to the number of triangles. + + :return: + A 3-dimensional array `result` such that `result[t, :]` is `[i, j, k]` + where i = e1[0], j = e2[0], k = e3[0], and e1, e2, e3 are the + oriented edges constituting the triangle `t`. + """ + assert B.rank(ts) == 1 + assert B.all(B.abs(ts) >= 0) and B.all(B.abs(ts) < self.n_triangles) + + edge_indices = B.flatten( + self.oriented_triangles[ts] + ) # [N,] -> [N, 3] -> [N*3,] + edges = B.reshape( + self.resolve_edges(edge_indices), len(ts), 3, 2 + ) # [N*3,] -> [N*3, 2] -> [N, 3, 2] + return edges[:, :, 0] # [N, 3, 2] -> [N, 3] + @classmethod def from_adjacency( cls, adjacency_matrix: Union[B.NPNumeric, sparray, spmatrix], type_reference: B.RandomState, - triangles: Optional[List[Tuple[int, int, int]]] = None, *, + triangles: Optional[List[Tuple[int, int, int]]] = None, checks_mode: str = "simple", ) -> "GraphEdges": """ @@ -418,18 +451,18 @@ def from_adjacency( oriented_edges = B.zeros(dtype_integer(type_reference), number_of_edges, 2) - cur_edge_ind = 0 + cur_edge_ind = 1 for i in range(number_of_nodes): for j in range(i + 1, number_of_nodes): if index[i, j] == 1: - oriented_edges[cur_edge_ind, 0] = i - oriented_edges[cur_edge_ind, 1] = j + oriented_edges[cur_edge_ind - 1, 0] = i + oriented_edges[cur_edge_ind - 1, 1] = j # We also store cur_edge_ind in the index matrix for later use - index[i, j] = cur_edge_ind + 1 + index[i, j] = cur_edge_ind index[j, i] = -index[i, j] cur_edge_ind += 1 assert ( - cur_edge_ind == number_of_edges + cur_edge_ind == number_of_edges + 1 ) # double check that we have the right number of edges if triangles is None: @@ -471,6 +504,7 @@ def _set_laplacian(self): Construct the appropriate graph Laplacian from the adjacency matrix. """ + # This does node_to_edge_incidence.T @ node_to_edge_incidence # TODO: make this more efficient, avoid for loops. self._down_laplacian = B.zeros( B.dtype(self.oriented_edges), self.n_edges, self.n_edges @@ -478,13 +512,22 @@ def _set_laplacian(self): for i in range(self.n_edges): for j in range(self.n_edges): self._down_laplacian[i, j] = ( - self.oriented_edges[i, 0] - == self.oriented_edges[j, 0] + self.oriented_edges[i, 1] - == self.oriented_edges[j, 1] - self.oriented_edges[i, 0] - == self.oriented_edges[j, 1] - self.oriented_edges[i, 1] - == self.oriented_edges[j, 0] + int(self.oriented_edges[i, 0] == self.oriented_edges[j, 0]) + + int(self.oriented_edges[i, 1] == self.oriented_edges[j, 1]) + - int(self.oriented_edges[i, 0] == self.oriented_edges[j, 1]) + - int(self.oriented_edges[i, 1] == self.oriented_edges[j, 0]) ) + # node_to_edge_incidence = B.zeros( + # B.dtype(self.oriented_edges), self.n_nodes, self.n_edges + # ) + # for i in range(self.n_edges): + # node_to_edge_incidence[self.oriented_edges[i, 0], i] = -1 + # node_to_edge_incidence[self.oriented_edges[i, 1], i] = 1 + # down_laplacian_alt = B.matmul(node_to_edge_incidence, node_to_edge_incidence, tr_a=True) + # assert B.all(down_laplacian_alt == self._down_laplacian) + + # This does edge_to_triangle_incidence @ edge_to_triangle_incidence.T # TODO: make this more efficient, avoid for loops. self._up_laplacian = B.zeros( B.dtype(self.oriented_edges), self.n_edges, self.n_edges @@ -492,16 +535,28 @@ def _set_laplacian(self): for i in range(self.n_edges): for j in range(self.n_edges): for t in range(self.n_triangles): - cur_triangle = set(B.to_numpy(self.oriented_triangles[t, 0])) - if (i in cur_triangle and j in cur_triangle) or ( - -i in cur_triangle and -j in cur_triangle + cur_triangle = set(B.to_numpy(self.oriented_triangles[t, :])) + if (i + 1 in cur_triangle and j + 1 in cur_triangle) or ( + -i - 1 in cur_triangle and -j - 1 in cur_triangle ): self._up_laplacian[i, j] += 1 - if (i in cur_triangle and -j in cur_triangle) or ( - -i in cur_triangle and j in cur_triangle + if (i + 1 in cur_triangle and -j - 1 in cur_triangle) or ( + -i - 1 in cur_triangle and j + 1 in cur_triangle ): self._up_laplacian[i, j] += -1 + # edge_to_triangle_incidence = B.zeros( + # B.dtype(self.oriented_triangles), self.n_edges, self.n_triangles + # ) + # for i in range(self.n_triangles): + # edge_indices = B.abs(self.oriented_triangles[i, :]) + # signs = self.oriented_triangles[i, :] / edge_indices + # edge_to_triangle_incidence[edge_indices[0] - 1, i] = signs[0] + # edge_to_triangle_incidence[edge_indices[1] - 1, i] = signs[1] + # edge_to_triangle_incidence[edge_indices[2] - 1, i] = signs[2] + # up_laplacian_alt = B.matmul(edge_to_triangle_incidence, edge_to_triangle_incidence, tr_b=True) + # assert B.all(up_laplacian_alt == self._up_laplacian) + self._hodge_laplacian = self._down_laplacian + self._up_laplacian def get_eigensystem(self, num): @@ -578,18 +633,20 @@ def get_eigensystem(self, num): # We concatenate the eigenvalues and eigenvectors of harmonic, curl, and # gradient types into a single array. - evals = B.concatenate( + evals = B.concat( evals_hodge[evals_hodge < eps], evals_up[evals_up >= eps], evals_down[evals_down >= eps], ) - evecs = B.concatenate( + evecs = B.concat( evecs_hodge[:, evals_hodge < eps], evecs_up[:, evals_up >= eps], evecs_down[:, evals_down >= eps], axis=1, ) + evecs *= B.sqrt(self.n_edges) # to make sure average variance is 1. + # We get the indices that would sort the eigenvalues in ascending order. sorted_indices = B.argsort(evals) @@ -647,7 +704,9 @@ def get_eigenfunctions( if hodge_type is not None else list(range(num)) ) - eigenfunctions = EigenfunctionsFromEigenvectors(eigensystem["evecs"][:, idx]) + eigenfunctions = EigenfunctionsFromEigenvectors( + eigensystem["evecs"][:, idx], index_from_one=True + ) return eigenfunctions def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numeric: @@ -662,6 +721,9 @@ def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numer :param num: Number of levels. + :param hodge_type: + The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. + :return: (n, 1)-shaped array containing the eigenvalues. n <= num. diff --git a/notebooks/Graph.ipynb b/notebooks/Graph.ipynb index 8c18fd17..4322ff23 100644 --- a/notebooks/Graph.ipynb +++ b/notebooks/Graph.ipynb @@ -30,8 +30,9 @@ "\n", "We use the **numpy** backend here.\n", "\n", - "**Important:** if you want to model a **signal on the edges** of a graph $G$, you can consider modeling the signal on the nodes of the [line graph](https://en.wikipedia.org/wiki/Line_graph). The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the [line_graph](https://networkx.org/documentation/stable/reference/generated/networkx.generators.line.line_graph.html#line-graph) function of `networkx`. Alternatively, especially for the flow-type data, you might want to use specialized edge kernels, see [Yang et al. (2023)](https://arxiv.org/abs/2310.19450) and [Alain et al. (2023)](https://arxiv.org/abs/2311.01198>).\n", - "These are not implemented in GeometricKernels at the moment.\n" + "**Important:** if you want to model a **signal on the edges** of a graph $G$, you can consider modeling the signal on the nodes of the [line graph](https://en.wikipedia.org/wiki/Line_graph). The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the [line_graph](https://networkx.org/documentation/stable/reference/generated/networkx.generators.line.line_graph.html#line-graph) function of `networkx`. Alternatively, especially for the flow-type data, you might want to use specialized edge kernels.\n", + "For these, take a look into [GraphEdges.ipynb](https://geometric-kernels.github.io/GeometricKernels/examples/GraphEdges.html).\n", + "If you want to model a singal on a metric graph, take a look into [Bolin et al. (2023)](https://arxiv.org/abs/2304.10372) —owever, the machinery from this paper is not currently implemented in GeometricKernels." ] }, { diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index d1ff5da8..2bfb475e 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -20,18 +20,31 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Matérn and Heat Kernels on Simplicial 2-Complexes (i.e., Graphs + Triangles)\n", - "This notebook shows how to define and evaluate kernels on the edge space of a simplicial 2-complex, which is essentially a graph + a set of triangles.\n", - "By this we mean kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is a vertex set of a graph.\n", - "The graph **must be** undirected.\n", + "# Matérn and Heat Kernels on The Edge Set of a Graph (Simplicial 2-complex)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a graph, i.e. kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is the edge set of some user-provided graph $G$. \n", + "Formally, we work with a simplicial 2-complex, which is essentially a graph $G = (V, E)$, where $V$ is the node set and $E$ is the edge set, together with a set of triangles $T$.\n", + "However, if you don't know how to set $T$, you don't need to worry, as we have a reasonable default for it, allowing you to regard this space as just a graph.\n", "\n", - "We construct the simplicial 2-complex by adding triangles to the graph. The triangles can be provided by users. If not provided, we look for all the 2-cliques in the graph and add them to the simplicial 2-complex.\n", + "The graph $G$ **must be** unweigted, undirected, and without loops.\n", + "\n", + "The edges are indexed from $1$ to $|E|$ (inclusive), i.e. $E = \\{1, 2, ..., |E|\\}$.\n", + "The graph is **oriented** (not to be confused with *directed*): for each $e \\in E$, we have $e = (i, j)$ with $i, j \\in V$, and where $(i, j)$ is an **ordered** tuple defining the positive orientation of the edge.\n", + "The edge $(j, i)$ is then considered to be negatively oriented, and is sometimes referred to as $-e$.\n", + "This is why we start indexing edges from $1$: to always be able to take $-e$.\n", + "The functions $f: E \\to \\mathbb{R}$ are assumed to be automatically extended to $E \\cup -E$ by $f(-e) = -f(e)$.\n", + "\n", + "**Note:** orientation and ordering of edges do not change the geometry of the space.\n", + "However, they affect the way in which you represent the data.\n", "\n", "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", "\n", "We use the **numpy** backend here.\n", "\n", - "**Important:** the goal of these kernels are to model the covariance between edges for the flow-type data, e.g., water flows, information flows. The original paper [Yang et al. 2024](https://arxiv.org/abs/2310.19450) has modelled edge flows and built Hodge-compositional kernels for them, particularly on the edge space of **simplicial 2-complexes**. Here we only consider the edge space of graphs, which is a special case of **simplicial 1-complexes**. For the general case, please refer to the original paper, as well as the [code](https://github.com/cookbook-ms/Hodge-Edge-GP)." + "**Important:** the goal of these kernels is to model the covariance between edges for the flow-type data, e.g., water flows, information flows.\n", + "If you want to model a **signal on the nodes** of a graph $G$, take a look into [Graph.ipynb](https://geometric-kernels.github.io/GeometricKernels/examples/Graph.html).\n", + "If you are interested in more general cellular complexes, you might want to look into [Alain et al. (2023)](https://arxiv.org/abs/2311.01198).\n", + "If you want to model a singal on a metric graph, take a look into [Bolin et al. (2023)](https://arxiv.org/abs/2304.10372).\n", + "However, the machinery from the latter two papers is not currently implemented in GeometricKernels." ] }, { @@ -80,8 +93,6 @@ } ], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", "# Import a backend, we use numpy in this example.\n", "import numpy as np\n", "\n", @@ -95,7 +106,7 @@ "# import geometric_kernels.jax\n", "\n", "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces.graph_edge import GraphEdge\n", + "from geometric_kernels.spaces import GraphEdges\n", "from geometric_kernels.kernels import MaternGeometricKernel\n", "\n", "# We use networkx to visualize graphs\n", @@ -127,36 +138,61 @@ }, "outputs": [], "source": [ - "G = nx.Graph()\n", - "G.add_edge(1, 2)\n", - "G.add_edge(1, 3)\n", - "G.add_edge(1, 5)\n", - "G.add_edge(2, 3)\n", - "G.add_edge(3, 4)\n", - "G.add_edge(4, 5)\n" + "nx_graph = nx.Graph()\n", + "nx_graph.add_edges_from([(0, 1), (0, 2), (0, 4), (1, 2), (1, 3), (2, 3), (3, 4)])\n", + "\n", + "# explicitly set node positions for visualization\n", + "pos = {0: (0, 0), 1: (-1, 0.3), 2: (2, 0.17), 3: (4, 0.255), 4: (5, 0.03)}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Define the triangle set " + "Visualize the graph." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "triangles = [(1,2,3)]" + "graph_vis_options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Define the positions of the nodes" + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdges` space.\n", + "\n", + "For this, we use the `GraphEdges.from_adjacency` static method, which is the easiest way to do this.\n", + "\n", + "**Note:** it requires a random generator `type_reference` which determines the backend to be used for the space's internal computations.\n", + "Here we use `numpy`." ] }, { @@ -165,33 +201,32 @@ "metadata": {}, "outputs": [], "source": [ - "# explicitly set positions\n", - "pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)}\n" + "type_reference = np.random.RandomState()\n", + "# \"nodelist=...\" below allows us to preserve the node labels we've used to create the graph\n", + "adj_matrix = nx.to_numpy_array(nx_graph, nodelist=range(nx_graph.number_of_nodes()))\n", + "\n", + "graph_edges = GraphEdges.from_adjacency(adj_matrix, type_reference, checks_mode=\"comprehensive\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Visualize the graph." + "By default, `GraphEdges.from_adjacency` assumes that all admissible triples of nodes form triangles.\n", + "A triple of nodes $(i, j, k)$ is admissible if all edges $(i, j), (j, k), (k, i)$ exist.\n", + "\n", + "In the next cell, we fill the triangles in the resulting `graph_edges` space with gray.\n", + "The triangles are used to define the *curl* operator on $G$, and thus determine the Hodge decomposition." ] }, { "cell_type": "code", "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 516 - }, - "id": "-J-2rY-D-rgY", - "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", - "scrolled": true - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -201,20 +236,19 @@ } ], "source": [ - "options = {\n", - " \"font_size\": 12,\n", - " \"node_size\": 300,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": 1,\n", - " \"width\": 2,\n", - " \"with_labels\": True, \n", - "}\n", "plt.figure(figsize=(4,4))\n", - "nx.draw(G, pos, **options)\n", - "# shade the area of the triangle\n", - "plt.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.25)\n", - "plt.axis(\"off\")\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", + "\n", + "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.n_triangles))\n", + "for t in range(graph_edges.n_triangles):\n", + " i, j, k = triangles[t, :]\n", + " plt.fill(\n", + " [pos[i][0], pos[j][0], pos[k][0]],\n", + " [pos[i][1], pos[j][1], pos[k][1]],\n", + " \"gray\",\n", + " alpha=0.25\n", + " ) \n", "plt.show()" ] }, @@ -222,11 +256,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Check the sets of nodes, edges and triangles. \n", - "\n", - "**Note that**: \n", - "- $(i,j)$ indicates an oriented edge from $i$ to $j$.\n", - "- $(i,j,k)$ indicates an oriented triangle with vertices $i,j,k$." + "You can always use `resolve_edges` and `resolve_triangles` methods to determine the ordering and orientation of edges and triangles." ] }, { @@ -238,46 +268,54 @@ "name": "stdout", "output_type": "stream", "text": [ - "nodes: [1, 2, 3, 5, 4]\n", - "edges: [(1, 2), (1, 3), (1, 5), (2, 3), (3, 4), (5, 4)]\n", - "triangles: [(1, 2, 3)]\n" + "Edges:\n", + "Edge index 1 corresponds to the edge (0, 1), while edge index -1 corresponds to the edge (1, 0)\n", + "Edge index 2 corresponds to the edge (0, 2), while edge index -2 corresponds to the edge (2, 0)\n", + "Edge index 3 corresponds to the edge (0, 4), while edge index -3 corresponds to the edge (4, 0)\n", + "Edge index 4 corresponds to the edge (1, 2), while edge index -4 corresponds to the edge (2, 1)\n", + "Edge index 5 corresponds to the edge (1, 3), while edge index -5 corresponds to the edge (3, 1)\n", + "Edge index 6 corresponds to the edge (2, 3), while edge index -6 corresponds to the edge (3, 2)\n", + "Edge index 7 corresponds to the edge (3, 4), while edge index -7 corresponds to the edge (4, 3)\n", + "\n", + "Triangles:\n", + "Triangle index 0 corresponds to edge indices (1, 4, -2) and is composed of nodes (0, 1, 2)\n", + "Triangle index 1 corresponds to edge indices (4, 6, -5) and is composed of nodes (1, 2, 3)\n" ] } ], "source": [ - "print('nodes:', G.nodes)\n", - "print('edges:', G.edges)\n", - "print('triangles:', triangles)" + "print(\"Edges:\")\n", + "for edge_index in range(1, graph_edges.n_edges + 1):\n", + " edge = graph_edges.resolve_edges(np.array([edge_index,])).flatten() # a bit ugly because resolve_edges is supposed to work with batches\n", + " edge_opposite = graph_edges.resolve_edges(np.array([-edge_index,])).flatten()\n", + " print(f\"Edge index {edge_index} corresponds to the edge ({edge[0]}, {edge[1]})\"\n", + " f\", while edge index {-edge_index} corresponds to the edge ({edge_opposite[0]}, {edge_opposite[1]})\")\n", + "\n", + "print()\n", + "print(\"Triangles:\")\n", + "for triangle_index in range(graph_edges.n_triangles):\n", + " triangle_edges = graph_edges.oriented_triangles[triangle_index, :]\n", + " triangle_nodes = graph_edges.resolve_triangles(np.array([triangle_index,])).flatten() # a bit ugly because resolve_triangles is supposed to work with batches\n", + " print(f\"Triangle index {triangle_index} corresponds to\"\n", + " f\" edge indices ({triangle_edges[0]}, {triangle_edges[1]}, {triangle_edges[2]})\"\n", + " f\" and is composed of nodes ({triangle_nodes[0]}, {triangle_nodes[1]}, {triangle_nodes[2]})\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdge` space --- the edge space of a simplicial 2-complex.\n", - "\n", - "The `G` parameter is a 'networkx.classes.graph.Graph' object, from which we build the node-to-edge incidence matrix.\n", - "\n", - "The 'triangle_list' parameter is a list of tuples, where each tuple is a triangle in the graph. If provided, this will be used to construct a simplicial 2-complex.\n", - "\n", - "The 'sc_lifting' parameter is a boolean that determines if to build a simplicial 2-complex. \n", - "- If True and 'triangle_list' is not None, the edge space of a simplicial 2-complex will be built based on the provided triangles. \n", - "- If True and 'triangle_list' is None, the edge space of a simplicial 2-complex with all the 2-cliques as 2-simplices will be built. \n", - "- If False and no 'triangle_list' provided, the edge space of the graph will be built.\n", - "\n", - "\n", - "\n", - "\n" + "#### Manually Defining the Set of Triangles" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Define the Simplicial 2-Complex " + "You can also manually define the triangles and provide them as an optional argument to the `GraphEdges.from_adjacency` method.\n", + "\n", + "They should be represented by a list of triples of node indices, like below.\n", + "Note, that all triples $(i, j, k)$ must still be adissible, i.e. all edges $(i, j), (j, k), (k, i)$ must exist." ] }, { @@ -286,83 +324,84 @@ "metadata": {}, "outputs": [], "source": [ - "B1 = nx.incidence_matrix(G).toarray()\n", - "B2 = np.array([[ 1.],\n", - " [1.],\n", - " [ 0.],\n", - " [ 1.],\n", - " [ 0.],\n", - " [ 0.]])" + "triangles = [(0,1,2)]\n", + "# nx_graph = nx.Graph()\n", + "# nx_graph.add_edges_from([(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)])\n", + "# adj_matrix = nx.to_numpy_array(nx_graph, nodelist=range(nx_graph.number_of_nodes()))\n", + "graph_edges = GraphEdges.from_adjacency(adj_matrix, type_reference, triangles=triangles, checks_mode=\"comprehensive\")" ] }, { - "cell_type": "code", - "execution_count": 9, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "sc = GraphEdge(B1,B2)" + "Now, if we visualize the space, it will look like this:" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "([1, 2, 3, 4, 5],\n", - " [(1, 2), (1, 3), (1, 4), (2, 3), (3, 5), (4, 5)],\n", - " [(1, 2, 3)])" + "
" ] }, - "execution_count": 10, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "sc.nodes, sc.edges, sc.triangles" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the incidence matrices" + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", + "\n", + "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.n_triangles))\n", + "for t in range(graph_edges.n_triangles):\n", + " i, j, k = triangles[t, :]\n", + " plt.fill(\n", + " [pos[i][0], pos[j][0], pos[k][0]],\n", + " [pos[i][1], pos[j][1], pos[k][1]],\n", + " \"gray\",\n", + " alpha=0.25\n", + " ) \n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "node-to-edge incidence matrix:\n", - " [[-1. -1. -1. 0. 0. 0.]\n", - " [ 1. 0. 0. -1. 0. 0.]\n", - " [ 0. 1. 0. 1. -1. 0.]\n", - " [ 0. 0. 1. 0. 0. -1.]\n", - " [ 0. 0. 0. 0. 1. 1.]]\n", - "edge-to-triangle incidence matrix:\n", - " [[ 1.]\n", - " [-1.]\n", - " [ 0.]\n", - " [ 1.]\n", - " [ 0.]\n", - " [ 0.]]\n" + "Triangles:\n", + "Triangle index 0 corresponds to edge indices (1, 4, -2) and is composed of nodes (0, 1, 2)\n" ] } ], "source": [ - "print('node-to-edge incidence matrix:\\n', sc.incidence_matrices[0])\n", - "print('edge-to-triangle incidence matrix:\\n', sc.incidence_matrices[1])" + "print(\"Triangles:\")\n", + "for triangle_index in range(graph_edges.n_triangles):\n", + " triangle_edges = graph_edges.oriented_triangles[triangle_index, :]\n", + " triangle_nodes = graph_edges.resolve_triangles(np.array([triangle_index,])).flatten() # a bit ugly because resolve_triangles is supposed to work with batches\n", + " print(f\"Triangle index {triangle_index} corresponds to\"\n", + " f\" edge indices ({triangle_edges[0]}, {triangle_edges[1]}, {triangle_edges[2]})\"\n", + " f\" and is composed of nodes ({triangle_nodes[0]}, {triangle_nodes[1]}, {triangle_nodes[2]})\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -370,74 +409,96 @@ "Check the computed Laplacians" ] }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# print(graph_edges.oriented_edges)" + ] + }, { "cell_type": "code", "execution_count": 12, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hodge Laplacian:\n", - " [[ 3. 0. 1. 0. 0. 0.]\n", - " [ 0. 3. 1. 0. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [ 0. 0. 0. 3. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Down Hodge Laplacian:\n", - " [[ 2. 1. 1. -1. 0. 0.]\n", - " [ 1. 2. 1. 1. -1. 0.]\n", - " [ 1. 1. 2. 0. 0. -1.]\n", - " [-1. 1. 0. 2. -1. 0.]\n", - " [ 0. -1. 0. -1. 2. 1.]\n", - " [ 0. 0. -1. 0. 1. 2.]]\n", - "\n", - "\n", - "Up Hodge Laplacian:\n", - " [[ 1. -1. 0. 1. 0. 0.]\n", - " [-1. 1. 0. -1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 1. -1. 0. 1. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0.]]\n" - ] - } - ], + "outputs": [], "source": [ - "print('Hodge Laplacian:\\n', sc.hodge_laplacian)\n", - "print('\\n')\n", - "print('Down Hodge Laplacian:\\n', sc._down_edge_laplacian)\n", - "print('\\n')\n", - "print('Up Hodge Laplacian:\\n', sc._up_edge_laplacian)" + "# print('Hodge Laplacian:\\n', graph_edges._hodge_laplacian)\n", + "# print('\\n')\n", + "# print('Down Hodge Laplacian:\\n', graph_edges._down_laplacian)\n", + "# print('\\n')\n", + "# print('Up Hodge Laplacian:\\n', graph_edges._up_laplacian)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[6.21724894e-15],\n", - " [1.38196601e+00],\n", - " [2.38196601e+00],\n", - " [3.00000000e+00],\n", - " [3.61803399e+00],\n", - " [4.61803399e+00]])" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], + "source": [ + "# for hodge_type in [\"harmonic\", \"gradient\", \"curl\"]:\n", + "# print(f\"The spectrum (hodge_type={hodge_type}):\")\n", + " \n", + "# eigenvalues = graph_edges.get_eigenvalues(7, hodge_type=hodge_type)\n", + "# print(\"Eigenvalues:\", eigenvalues.flatten())\n", + " \n", + "# print(\"\")\n", + " \n", + "# print(\"Eigenvectors:\")\n", + "# eigenfunctions = graph_edges.get_eigenfunctions(7, hodge_type=hodge_type)\n", + "# eigenvectors = eigenfunctions(np.arange(1, graph_edges.n_edges + 1)[:, None])\n", + "# print(eigenvectors)\n", + " \n", + "# print(\"\")\n", + "# print(\"shapes:\", eigenvalues.shape, eigenvectors.shape)\n", + "# print(\"\")\n", + " \n", + "# diff = np.linalg.norm(graph_edges._hodge_laplacian @ eigenvectors - eigenvectors @ np.diag(eigenvalues.flatten()))\n", + "# print(\"||Hodge Laplacian @ eigenvectors - eigenvectors @ diag(eigenvalues)|| =\", diff)\n", + "# print(diff)\n", + "# print(\"\")\n", + "# print(\"=============================================\")\n", + "# print(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# evecs = graph_edges.get_eigensystem(graph_edges.n_edges)[\"evecs\"]\n", + "# evals = graph_edges.get_eigensystem(graph_edges.n_edges)[\"evals\"]\n", + "\n", + "# diff = np.linalg.norm(graph_edges._hodge_laplacian @ evecs - evecs @ np.diag(evals.flatten()))\n", + "\n", + "# # print(diff)\n", + "# print((graph_edges._hodge_laplacian @ evecs)[:, 2])\n", + "# print('')\n", + "# print(2*evecs[:, 2])\n", + "\n", + "# # 0, 0, 2" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], "source": [ - "sc.get_eigenvalues(6)" + "# print(\"Gradient part:\")\n", + "# graph_edges.get_eigenvalues(7, hodge_type=\"gradient\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# print(\"Curl part:\")\n", + "# graph_edges.get_eigenvalues(7, hodge_type=\"curl\")" ] }, { @@ -470,20 +531,11 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using Hodge compositional kernel!\n" - ] - } - ], + "outputs": [], "source": [ - "use_hodge_composition=True\n", - "kernel = MaternGeometricKernel(sc, use_hodge_composition=use_hodge_composition)" + "kernel = MaternGeometricKernel(graph_edges)" ] }, { @@ -508,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -544,27 +596,20 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ - "import copy\n", + "params[\"harmonic\"][\"lengthscale\"] = np.array([0.5])\n", + "params[\"gradient\"][\"lengthscale\"] = np.array([2.0])\n", + "params[\"curl\"][\"lengthscale\"] = np.array([1.0])\n", "\n", - "if use_hodge_composition:\n", - " params[\"harmonic\"][\"lengthscale\"], params[\"gradient\"][\"lengthscale\"], params[\"curl\"][\"lengthscale\"] = np.array([0.5]), np.array([2.0]), np.array([1.0])\n", - " params_hodge_1 = copy.deepcopy(params)\n", - " params_hodge_2 = copy.deepcopy(params)\n", - " del params\n", - " params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = np.array([3/2]), np.array([3/2]), np.array([3/2])\n", - " params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = np.array([np.inf]), np.array([np.inf]), np.array([np.inf])\n", + "params_hodge_1 = params.copy()\n", + "params_hodge_2 = params.copy()\n", + "del params\n", "\n", - "else:\n", - " params[\"lengthscale\"] = np.array([2.0])\n", - " params_32 = params.copy()\n", - " params_inf = params.copy()\n", - " del params\n", - " params_32[\"nu\"] = np.array([3/2])\n", - " params_inf[\"nu\"] = np.array([np.inf])" + "params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = np.array([3/2]), np.array([3/2]), np.array([3/2])\n", + "params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = np.array([np.inf]), np.array([np.inf]), np.array([np.inf])" ] }, { @@ -574,49 +619,6 @@ "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs (i.e., edges)." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Check the eigenvalues of the kernels" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eigenvalues for the first set of parameters:\n", - "{'harmonic': array([[0.02405626]]), 'gradient': array([[0.32123998],\n", - " [0.18041575],\n", - " [0.10953956],\n", - " [0.0804039 ]]), 'curl': array([[0.06804138]])}\n", - "\n", - "Eigenvalues for the second set of parameters:\n", - "{'harmonic': array([[1.]]), 'gradient': array([[6.30433923e-02],\n", - " [8.53199536e-03],\n", - " [7.20137798e-04],\n", - " [9.74600529e-05]]), 'curl': array([[0.22313016]])}\n" - ] - } - ], - "source": [ - "if use_hodge_composition:\n", - " # Evaluate the eigenvalues for the first set of parameters\n", - " eigenvalues_hodge_1 = kernel.eigenvalues(params_hodge_1, normalize=False)\n", - " # Evaluate the eigenvalues for the second set of parameters\n", - " eigenvalues_hodge_2 = kernel.eigenvalues(params_hodge_2, normalize=False)\n", - " # Print the results\n", - " print(\"Eigenvalues for the first set of parameters:\")\n", - " print(eigenvalues_hodge_1)\n", - " print(\"\\nEigenvalues for the second set of parameters:\")\n", - " print(eigenvalues_hodge_2)\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -634,54 +636,37 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[(2, 3), (4, 5), (3, 5)]\n" + "xs:\n", + "[[4]\n", + " [7]\n", + " [6]]\n", + "\n", + "The edge indices in xs correspond to the following edges:\n", + "[[1 2]\n", + " [3 4]\n", + " [2 3]]\n" ] } ], "source": [ "key = np.random.RandomState(1234)\n", "\n", - "key, randopm_sampled_edges, xs = sc.random(key, 3)\n", + "key, xs = graph_edges.random(key, 3)\n", "\n", - "print(randopm_sampled_edges)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If users prefer input the edges directly, we would need to obtain the indices of the edges in the edge space of the simplicial complex. This can be done by calling `sc.get_edge_index(input_edges)`.\n", - "\n", - "Below we verify that the indices of the sampled edges are correct." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[3]\n", - " [5]\n", - " [4]]\n", - "[3, 5, 4]\n" - ] - } - ], - "source": [ + "print(\"xs:\")\n", "print(xs)\n", - "input_indices = sc.get_edge_index(randopm_sampled_edges)\n", - "print(input_indices)" + "\n", + "print(\"\")\n", + "\n", + "print(\"The edge indices in xs correspond to the following edges:\")\n", + "print(graph_edges.resolve_edges(xs.squeeze()))" ] }, { @@ -693,16 +678,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "if use_hodge_composition:\n", - " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs, normalize=False)\n", - " kernel_mat_inf = kernel.K(params_hodge_2, xs, xs, normalize=False)\n", - "else:\n", - " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - " kernel_mat_inf = kernel.K(params_inf, xs, xs)" + "kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_hodge_2, xs, xs)" ] }, { @@ -714,12 +695,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -756,31 +737,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([[ 0.50937497, -0.05318978, 0.15397211],\n", - " [-0.05318978, 0.44513908, -0.22424068],\n", - " [ 0.15397211, -0.22424068, 0.49229617]]),\n", - " array([[ 0.49452715, -0.0689119 , 0.28746792],\n", - " [-0.0689119 , 0.34449472, -0.25884074],\n", - " [ 0.28746792, -0.25884074, 0.59206623]]))" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "kernel_mat_32, kernel_mat_inf" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -800,12 +756,19 @@ "cell_type": "code", "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "base_edge_idx=1 corresponds to the edge [0 1]\n" + ] + } + ], "source": [ - "base_edge = (1,2)\n", - "base_edge_idx = list(G.edges).index(base_edge)\n", - "other_edges = np.arange(sc.num_edges)[:, None]\n", - "edges = [e for e in G.edges()]" + "base_edge_idx = 1\n", + "print(f\"base_edge_idx={base_edge_idx} corresponds to the edge {graph_edges.resolve_edges(np.array([base_edge_idx])).flatten()}\")\n", + "other_edges_idx = np.arange(1, graph_edges.n_edges + 1)[:, None]" ] }, { @@ -821,14 +784,8 @@ "metadata": {}, "outputs": [], "source": [ - "if use_hodge_composition:\n", - " values_32 = kernel.K(params_hodge_1, np.array([[base_edge_idx]]), other_edges).flatten()\n", - " values_inf = kernel.K(params_hodge_2, np.array([[base_edge_idx]]), other_edges).flatten()\n", - "else:\n", - " values_32 = kernel.K(params_32, np.array([[base_edge_idx]]),\n", - " other_edges).flatten()\n", - " values_inf = kernel.K(params_inf, np.array([[base_edge_idx]]),\n", - " other_edges).flatten()" + "values_32 = kernel.K(params_hodge_1, np.array([[base_edge_idx]]), other_edges_idx).flatten()\n", + "values_inf = kernel.K(params_hodge_2, np.array([[base_edge_idx]]), other_edges_idx).flatten()" ] }, { @@ -845,12 +802,8 @@ "outputs": [], "source": [ "# Get prior variances k(*, *) for * in nodes:\n", - "if use_hodge_composition:\n", - " variance_32 = kernel.K_diag(params_hodge_1, other_edges)\n", - " variance_inf = kernel.K_diag(params_hodge_2, other_edges)\n", - "else:\n", - " variance_32 = kernel.K_diag(params_32, other_edges)\n", - " variance_inf = kernel.K_diag(params_inf, other_edges)" + "variance_32 = kernel.K_diag(params_hodge_1, other_edges_idx)\n", + "variance_inf = kernel.K_diag(params_hodge_2, other_edges_idx)" ] }, { @@ -871,13 +824,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/mmaosheng/miniconda3/lib/python3.11/site-packages/networkx/drawing/nx_pylab.py:450: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + "/Users/vabor112/anaconda3/envs/gkconda_updated_sh/lib/python3.10/site-packages/networkx/drawing/nx_pylab.py:437: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", " node_collection = ax.scatter(\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -888,14 +841,15 @@ ], "source": [ "cmap = plt.get_cmap('viridis')\n", + "edges = [e for e in nx_graph.edges()]\n", "\n", "# Set the colorbar limits:\n", "\n", "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", + " vmin=variance_32.min(), vmax=values_32.max(), **graph_vis_options)\n", "# shade the area of the triangle\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -904,11 +858,11 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", + "nx.draw(nx_graph, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", " vmin=values_32.min(), vmax=values_32.max(), \n", - " **options)\n", + " **graph_vis_options)\n", "# add a label at the base edge \n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "nx.draw_networkx_edge_labels(nx_graph, pos, edge_labels={(edges[base_edge_idx-1][0], edges[base_edge_idx-1][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", @@ -917,8 +871,8 @@ "\n", "\n", "# Plot variance inf\n", - "nx.draw(G, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", + " vmin=variance_inf.min(), vmax=variance_inf.max(), **graph_vis_options)\n", "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", @@ -926,10 +880,10 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(G, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", + "nx.draw(nx_graph, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", " vmin=values_inf.min(), vmax=values_inf.max(),\n", - " **options)\n", - "nx.draw_networkx_edge_labels(G, pos, edge_labels={(edges[base_edge_idx][0], edges[base_edge_idx][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + " **graph_vis_options)\n", + "nx.draw_networkx_edge_labels(nx_graph, pos, edge_labels={(edges[base_edge_idx-1][0], edges[base_edge_idx-1][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", @@ -967,9 +921,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Variance in the edge (1,2) is 0.51,\n", - "Variance in the edge (1,3) is 0.55,\n", - "The average variance is 0.50.\n" + "Variance in the edge (0,1) is 1.21,\n", + "Variance in the edge (0,2) is 1.21,\n", + "The average variance is 1.00.\n" ] } ], @@ -1051,24 +1005,19 @@ "output_type": "stream", "text": [ "xs (shape = (3, 1)):\n", - "[[3]\n", - " [5]\n", - " [4]]\n", + "[[4]\n", + " [7]\n", + " [6]]\n", "\n", - "harmonic emedding (shape = (3, 1)):\n", - "[[ 0.17407766]\n", - " [-0.52223297]\n", - " [ 0.52223297]]\n", - "gradient emedding (shape = (3, 4)):\n", - "[[-2.53358943e-01 1.23024295e-01 -2.39383702e-01 9.54375058e-02]\n", - " [-1.06600907e-15 3.98114982e-01 -2.95201183e-16 -1.17967245e-01]\n", - " [-4.09943381e-01 7.60331958e-02 1.47947264e-01 -1.54421128e-01]]\n", - "curl emedding (shape = (3, 1)):\n", - "[[5.77350269e-01]\n", - " [3.21964677e-15]\n", - " [3.88578059e-16]]\n", + "emedding (shape = (3, 7)):\n", + "[[-3.03600927e-01 -1.93535802e-01 2.53503344e-02 2.52011583e-16\n", + " -1.58889012e-16 -2.29413138e-01 2.79559815e-17]\n", + " [-2.73700955e-01 4.29356549e-01 0.00000000e+00 3.08830295e-01\n", + " 1.70071397e-01 -1.89576728e-16 -1.03153517e-01]\n", + " [-5.92251869e-01 -7.56254279e-02 0.00000000e+00 1.54415148e-01\n", + " -1.70071397e-01 1.14706569e-01 1.03153517e-01]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 8.355534721610419e-17\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 1.174825712241954\n" ] } ], @@ -1076,21 +1025,11 @@ "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", "print('')\n", "\n", - "if use_hodge_composition:\n", - " _, harmonic_embedding = feature_map(xs, params_hodge_1['harmonic'], hodge_type='harmonic') \n", - " _, gradient_embedding = feature_map(xs, params_hodge_1['gradient'],hodge_type='gradient')\n", - " _, curl_embedding = feature_map(xs, params_hodge_1['curl'], hodge_type='curl')\n", - " kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", - " kernel_mat_32_alt = np.matmul(harmonic_embedding, harmonic_embedding.T) + np.matmul(gradient_embedding, gradient_embedding.T) + np.matmul(curl_embedding, curl_embedding.T) \n", - " print('harmonic emedding (shape = %s):\\n%s' % (harmonic_embedding.shape, harmonic_embedding))\n", - " print('gradient emedding (shape = %s):\\n%s' % (gradient_embedding.shape, gradient_embedding))\n", - " print('curl emedding (shape = %s):\\n%s' % (curl_embedding.shape, curl_embedding))\n", - "else:\n", - " # xs are random points from above\n", - " _, embedding = feature_map(xs, params_32, normalize=True)\n", - " kernel_mat_32 = kernel.K(params_32, xs, xs)\n", - " kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", - " print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_hodge_1)\n", + "kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", " \n", "print('')\n", "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" @@ -1125,9 +1064,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[ 0.09012729 0.49207089]\n", - " [-0.53492781 1.23972299]\n", - " [-0.27116852 -0.17419733]]\n" + "[[-0.70250871 0.21701509]\n", + " [ 0.65590758 -0.17776272]\n", + " [-0.02723808 0.91741289]]\n" ] } ], @@ -1141,13 +1080,7 @@ "key = np.random.RandomState(seed=1234)\n", "\n", "# new random state is returned along with the samples\n", - "if use_hodge_composition:\n", - " key, samples_harmonic = sample_paths(xs, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", - " key, samples_gradient = sample_paths(xs, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", - " key, samples_curl = sample_paths(xs, params_hodge_1['curl'], key=key, hodge_type='curl')\n", - " samples = samples_harmonic + samples_gradient + samples_curl\n", - "else:\n", - " key, samples = sample_paths(xs, params_32, key=key)\n", + "key, samples = sample_paths(xs, params_hodge_1, key=key)\n", "\n", "print('Two samples evaluated at the xs are:')\n", "print(samples)" @@ -1168,7 +1101,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1179,13 +1112,7 @@ ], "source": [ "key = np.random.RandomState(seed=1234)\n", - "if use_hodge_composition:\n", - " key, samples_harmonic = sample_paths(other_edges, params_hodge_1['harmonic'], key=key, hodge_type='harmonic')\n", - " key, samples_gradient = sample_paths(other_edges, params_hodge_1['gradient'], key=key, hodge_type='gradient')\n", - " key, samples_curl = sample_paths(other_edges, params_hodge_1['curl'], key=key, hodge_type='curl')\n", - " samples = samples_harmonic + samples_gradient + samples_curl\n", - "else:\n", - " key, samples = sample_paths(other_edges, params_32, key=key)\n", + "key, samples = sample_paths(other_edges_idx, params_hodge_1, key=key)\n", "\n", "sample1 = samples[:, 0]\n", "sample2 = samples[:, 1]\n", @@ -1200,8 +1127,8 @@ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", "\n", "# Plot sample #1\n", - "nx.draw(G, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", - " vmin=vmin, vmax=vmax, **options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", + " vmin=vmin, vmax=vmax, **graph_vis_options)\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -1210,8 +1137,8 @@ "\n", "\n", "# Plot sample #2\n", - "nx.draw(G, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", - " vmin=vmin, vmax=vmax, **options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", + " vmin=vmin, vmax=vmax, **graph_vis_options)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -1239,18 +1166,11 @@ "```\n", "\n", "```\n", - "@InProceedings{pmlr-v238-yang24e,\n", - " title = \t {Hodge-Compositional Edge {G}aussian Processes},\n", - " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", - " booktitle = \t {Proceedings of The 27th International Conference on Artificial Intelligence and Statistics},\n", - " pages = \t {3754--3762},\n", - " year = \t {2024},\n", - " volume = \t {238},\n", - " series = \t {Proceedings of Machine Learning Research},\n", - " month = \t {02--04 May},\n", - " publisher = {PMLR},\n", - " pdf = \t {https://proceedings.mlr.press/v238/yang24e/yang24e.pdf},\n", - " url = \t {https://proceedings.mlr.press/v238/yang24e.html}\n", + "@inproceedings{yang2024,\n", + " title = {Hodge-Compositional Edge Gaussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle={International Conference on Artificial Intelligence and Statistics},\n", + " year = {2024},\n", "}\n", "```" ] @@ -1268,9 +1188,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "gkconda_updated_sh", "language": "python", - "name": "python3" + "name": "gkconda_updated_sh" }, "language_info": { "codemirror_mode": { @@ -1282,7 +1202,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.10.13" } }, "nbformat": 4, From 4a9187a48e6a10064d020d560eb1737e01afe30e Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 14:01:45 +0100 Subject: [PATCH 15/30] New tests/spaces/test_graph_edges.py and various fixes related to it --- .../kernels/hodge_compositional.py | 22 +- geometric_kernels/spaces/graph_edges.py | 174 ++++++--- notebooks/GraphEdges.ipynb | 139 +------ tests/data.py | 63 +++ tests/spaces/test_graph_edges.py | 362 ++++++++++++++++-- 5 files changed, 535 insertions(+), 225 deletions(-) diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py index cd253af8..9652ce7b 100644 --- a/geometric_kernels/kernels/hodge_compositional.py +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -63,7 +63,7 @@ def __init__( for hodge_type in ["harmonic", "curl", "gradient"]: eigenvalues = self.space.get_eigenvalues(self.num_levels, hodge_type) eigenfunctions = self.space.get_eigenfunctions(self.num_levels, hodge_type) - num_levels_per_type = eigenvalues.shape[0] + num_levels_per_type = len(eigenvalues) setattr( self, f"kernel_{hodge_type}", @@ -127,12 +127,12 @@ def K( # Copy the parameters to avoid modifying the original dict. params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} - coeffs = B.softmax( - B.stack( - *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], - axis=0, - ) + + coeffs = B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, ) + coeffs = coeffs / B.sum(coeffs) return ( coeffs[0] * self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs) @@ -154,12 +154,12 @@ def K_diag( # Copy the parameters to avoid modifying the original dict. params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} - coeffs = B.softmax( - B.stack( - *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], - axis=0, - ) + + coeffs = B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, ) + coeffs = coeffs / B.sum(coeffs) return ( coeffs[0] * self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs) diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 093c9e8b..75efb0e0 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -7,7 +7,14 @@ from beartype.typing import Dict, List, Optional, Tuple, Union from scipy.sparse import csr_array, lil_array, sparray, spmatrix -from geometric_kernels.lab_extras import dtype_integer, eigenpairs, int_like +from geometric_kernels.lab_extras import ( + count_nonzero, + dtype_integer, + eigenpairs, + float_like, + int_like, + take_along_axis, +) from geometric_kernels.spaces.base import HodgeDiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import ( Eigenfunctions, @@ -436,6 +443,10 @@ def from_adjacency( index = csr_array(adjacency_matrix, dtype=int) elif isinstance(adjacency_matrix, (sparray, spmatrix)): index = csr_array(adjacency_matrix, dtype=int, copy=True) + else: + raise ValueError( + f"The adjacency matrix must be a numpy array or a scipy sparse matrix not {type(adjacency_matrix)}. Use `type_reference` to specify the backend." + ) if len(index.shape) != 2: raise ValueError("Adjacency matrix must be a square matrix.") @@ -449,7 +460,7 @@ def from_adjacency( number_of_nodes = index.shape[0] number_of_edges = np.sum(index.data) // 2 - oriented_edges = B.zeros(dtype_integer(type_reference), number_of_edges, 2) + oriented_edges = np.zeros((number_of_edges, 2), dtype=np.int32) cur_edge_ind = 1 for i in range(number_of_nodes): @@ -464,6 +475,7 @@ def from_adjacency( assert ( cur_edge_ind == number_of_edges + 1 ) # double check that we have the right number of edges + oriented_edges = B.cast(dtype_integer(type_reference), oriented_edges) if triangles is None: triangles = [] @@ -474,14 +486,13 @@ def from_adjacency( triangles.append((i, j, k)) number_of_triangles = len(triangles) - oriented_triangles = B.zeros( - dtype_integer(type_reference), number_of_triangles, 3 - ) + oriented_triangles = np.zeros((number_of_triangles, 3), dtype=np.int32) for triangle_index, triangle in enumerate(triangles): i, j, k = sorted(triangle) # sort the nodes in the triangle oriented_triangles[triangle_index, 0] = index[i, j] oriented_triangles[triangle_index, 1] = index[j, k] oriented_triangles[triangle_index, 2] = index[k, i] + oriented_triangles = B.cast(dtype_integer(type_reference), oriented_triangles) return cls( number_of_nodes, @@ -506,9 +517,7 @@ def _set_laplacian(self): # This does node_to_edge_incidence.T @ node_to_edge_incidence # TODO: make this more efficient, avoid for loops. - self._down_laplacian = B.zeros( - B.dtype(self.oriented_edges), self.n_edges, self.n_edges - ) + self._down_laplacian = np.zeros((self.n_edges, self.n_edges), dtype=np.int32) for i in range(self.n_edges): for j in range(self.n_edges): self._down_laplacian[i, j] = ( @@ -517,21 +526,13 @@ def _set_laplacian(self): - int(self.oriented_edges[i, 0] == self.oriented_edges[j, 1]) - int(self.oriented_edges[i, 1] == self.oriented_edges[j, 0]) ) - - # node_to_edge_incidence = B.zeros( - # B.dtype(self.oriented_edges), self.n_nodes, self.n_edges - # ) - # for i in range(self.n_edges): - # node_to_edge_incidence[self.oriented_edges[i, 0], i] = -1 - # node_to_edge_incidence[self.oriented_edges[i, 1], i] = 1 - # down_laplacian_alt = B.matmul(node_to_edge_incidence, node_to_edge_incidence, tr_a=True) - # assert B.all(down_laplacian_alt == self._down_laplacian) + self._down_laplacian = B.cast( + float_like(self.oriented_edges), self._down_laplacian + ) # This does edge_to_triangle_incidence @ edge_to_triangle_incidence.T # TODO: make this more efficient, avoid for loops. - self._up_laplacian = B.zeros( - B.dtype(self.oriented_edges), self.n_edges, self.n_edges - ) + self._up_laplacian = np.zeros((self.n_edges, self.n_edges), dtype=np.int32) for i in range(self.n_edges): for j in range(self.n_edges): for t in range(self.n_triangles): @@ -544,18 +545,7 @@ def _set_laplacian(self): -i - 1 in cur_triangle and j + 1 in cur_triangle ): self._up_laplacian[i, j] += -1 - - # edge_to_triangle_incidence = B.zeros( - # B.dtype(self.oriented_triangles), self.n_edges, self.n_triangles - # ) - # for i in range(self.n_triangles): - # edge_indices = B.abs(self.oriented_triangles[i, :]) - # signs = self.oriented_triangles[i, :] / edge_indices - # edge_to_triangle_incidence[edge_indices[0] - 1, i] = signs[0] - # edge_to_triangle_incidence[edge_indices[1] - 1, i] = signs[1] - # edge_to_triangle_incidence[edge_indices[2] - 1, i] = signs[2] - # up_laplacian_alt = B.matmul(edge_to_triangle_incidence, edge_to_triangle_incidence, tr_b=True) - # assert B.all(up_laplacian_alt == self._up_laplacian) + self._up_laplacian = B.cast(float_like(self.oriented_edges), self._up_laplacian) self._hodge_laplacian = self._down_laplacian + self._up_laplacian @@ -628,8 +618,10 @@ def get_eigensystem(self, num): evals_down, evecs_down = eigenpairs(self._down_laplacian, self.n_edges) # We count the number of eigenpairs of each type for future reference. - n_harm = B.sum(evals_hodge < eps) - n_curl, n_grad = B.sum(evals_up >= eps), B.sum(evals_down >= eps) + n_harm = count_nonzero(evals_hodge < eps) + n_curl, n_grad = count_nonzero(evals_up >= eps), count_nonzero( + evals_down >= eps + ) # We concatenate the eigenvalues and eigenvectors of harmonic, curl, and # gradient types into a single array. @@ -638,35 +630,55 @@ def get_eigensystem(self, num): evals_up[evals_up >= eps], evals_down[evals_down >= eps], ) + evecs = B.concat( - evecs_hodge[:, evals_hodge < eps], - evecs_up[:, evals_up >= eps], - evecs_down[:, evals_down >= eps], - axis=1, + B.reshape( + evecs_hodge[ + B.broadcast_to(evals_hodge < eps, self.n_edges, self.n_edges) + ], + self.n_edges, + -1, + ), + B.reshape( + evecs_up[ + B.broadcast_to(evals_up >= eps, self.n_edges, self.n_edges) + ], + self.n_edges, + -1, + ), + B.reshape( + evecs_down[ + B.broadcast_to(evals_down >= eps, self.n_edges, self.n_edges) + ], + self.n_edges, + -1, + ), + axis=-1, ) evecs *= B.sqrt(self.n_edges) # to make sure average variance is 1. # We get the indices that would sort the eigenvalues in ascending order. sorted_indices = B.argsort(evals) + # And the indices that would inverse the sorting using sorted_indices. + sorted_sorted_indices = B.argsort(sorted_indices) # In harmonic_idx, gradient_idx, and curl_idx, we store the indices of # the eigenvalues and eigenvectors of harmonic, gradient, and curl types. # We also make sure that the indices are not greater than `num`. - def filter_inds(inds: B.Int, num: int) -> List[int]: - return [i for i in inds if i < num] - - harmonic_idx = filter_inds(sorted_indices[:n_harm], num) - curl_idx = filter_inds(sorted_indices[n_harm : n_harm + n_curl], num) - grad_idx = filter_inds( - sorted_indices[n_harm + n_curl : n_harm + n_curl + n_grad], num - ) + harmonic_idx = sorted_sorted_indices[:n_harm] + harmonic_idx = harmonic_idx[harmonic_idx < num] + curl_idx = sorted_sorted_indices[n_harm : n_harm + n_curl] + curl_idx = curl_idx[curl_idx < num] + grad_idx = sorted_sorted_indices[n_harm + n_curl : n_harm + n_curl + n_grad] + grad_idx = grad_idx[grad_idx < num] # We sort the eigenvalues and eigenvectors in ascending order of # eigenvalues, keeping only `num` of the first eigenpairs. sorted_indices = sorted_indices[:num] - evals = evals[sorted_indices] - evecs = evecs[:, sorted_indices] + + evals = take_along_axis(evals, sorted_indices) + evecs = take_along_axis(evecs, sorted_indices[None, :], axis=-1) self.cache[num] = { "evals": evals, @@ -678,6 +690,22 @@ def filter_inds(inds: B.Int, num: int) -> List[int]: return self.cache[num] + def get_number_of_eigenpairs(self, num: int, hodge_type: str) -> int: + """ + Returns the number of eigenpairs of a particular type. + + :param num: + Number of levels. + + :param hodge_type: + The type of the eigenpairs. It can be 'harmonic', 'gradient', or 'curl'. + + :return: + The number of eigenpairs of the specified type. + """ + eigensystem = self.get_eigensystem(num) + return len(eigensystem[f"{hodge_type}_idx"]) + def get_eigenfunctions( self, num: int, hodge_type: Optional[str] = None ) -> Eigenfunctions: @@ -705,10 +733,46 @@ def get_eigenfunctions( else list(range(num)) ) eigenfunctions = EigenfunctionsFromEigenvectors( - eigensystem["evecs"][:, idx], index_from_one=True + take_along_axis( + eigensystem["evecs"], + B.cast(int_like(eigensystem["evecs"]), np.array(idx)[None, :]), + axis=-1, + ), + index_from_one=True, ) return eigenfunctions + def get_eigenvectors(self, num: int, hodge_type: Optional[str] = None) -> B.Numeric: + """ + Eigenvectors of the Laplacian corresponding to the first `num` levels + (i.e., in this case, `num` eigenpairs). If `type` is specified, returns + only the eigenvectors of that type. + + :param num: + Number of eigenvectors to return. + + :param hodge_type: + The type of the eigenpairs. It can be 'harmonic', 'gradient', or 'curl'. + + :return: + (n, 1)-shaped array containing the eigenvalues. n <= num. + """ + eigensystem = self.get_eigensystem(num) + + idx = ( + eigensystem[f"{hodge_type}_idx"] + if hodge_type is not None + else list(range(num)) + ) + + eigenvectors = take_along_axis( + eigensystem["evecs"], + B.cast(int_like(eigensystem["evecs"]), np.array(idx)[None, :]), + axis=-1, + ) + + return eigenvectors + def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numeric: """ Eigenvalues of the Laplacian corresponding to the first `num` levels @@ -722,22 +786,22 @@ def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numer Number of levels. :param hodge_type: - The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. + The type of the eigenpairs. It can be 'harmonic', 'gradient', or 'curl'. :return: (n, 1)-shaped array containing the eigenvalues. n <= num. - - .. note:: - The notion of *levels* is discussed in the documentation of the - :class:`~.kernels.MaternKarhunenLoeveKernel`. """ eigensystem = self.get_eigensystem(num) + idx = ( eigensystem[f"{hodge_type}_idx"] if hodge_type is not None else list(range(num)) ) - eigenvalues = eigensystem["evals"][idx] + + eigenvalues = take_along_axis( + eigensystem["evals"], B.cast(int_like(eigensystem["evals"]), np.array(idx)) + ) return eigenvalues[:, None] diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index 2bfb475e..1d226fb2 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -325,9 +325,6 @@ "outputs": [], "source": [ "triangles = [(0,1,2)]\n", - "# nx_graph = nx.Graph()\n", - "# nx_graph.add_edges_from([(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)])\n", - "# adj_matrix = nx.to_numpy_array(nx_graph, nodelist=range(nx_graph.number_of_nodes()))\n", "graph_edges = GraphEdges.from_adjacency(adj_matrix, type_reference, triangles=triangles, checks_mode=\"comprehensive\")" ] }, @@ -395,112 +392,6 @@ " f\" and is composed of nodes ({triangle_nodes[0]}, {triangle_nodes[1]}, {triangle_nodes[2]})\")" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check the computed Laplacians" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# print(graph_edges.oriented_edges)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# print('Hodge Laplacian:\\n', graph_edges._hodge_laplacian)\n", - "# print('\\n')\n", - "# print('Down Hodge Laplacian:\\n', graph_edges._down_laplacian)\n", - "# print('\\n')\n", - "# print('Up Hodge Laplacian:\\n', graph_edges._up_laplacian)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# for hodge_type in [\"harmonic\", \"gradient\", \"curl\"]:\n", - "# print(f\"The spectrum (hodge_type={hodge_type}):\")\n", - " \n", - "# eigenvalues = graph_edges.get_eigenvalues(7, hodge_type=hodge_type)\n", - "# print(\"Eigenvalues:\", eigenvalues.flatten())\n", - " \n", - "# print(\"\")\n", - " \n", - "# print(\"Eigenvectors:\")\n", - "# eigenfunctions = graph_edges.get_eigenfunctions(7, hodge_type=hodge_type)\n", - "# eigenvectors = eigenfunctions(np.arange(1, graph_edges.n_edges + 1)[:, None])\n", - "# print(eigenvectors)\n", - " \n", - "# print(\"\")\n", - "# print(\"shapes:\", eigenvalues.shape, eigenvectors.shape)\n", - "# print(\"\")\n", - " \n", - "# diff = np.linalg.norm(graph_edges._hodge_laplacian @ eigenvectors - eigenvectors @ np.diag(eigenvalues.flatten()))\n", - "# print(\"||Hodge Laplacian @ eigenvectors - eigenvectors @ diag(eigenvalues)|| =\", diff)\n", - "# print(diff)\n", - "# print(\"\")\n", - "# print(\"=============================================\")\n", - "# print(\"\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# evecs = graph_edges.get_eigensystem(graph_edges.n_edges)[\"evecs\"]\n", - "# evals = graph_edges.get_eigensystem(graph_edges.n_edges)[\"evals\"]\n", - "\n", - "# diff = np.linalg.norm(graph_edges._hodge_laplacian @ evecs - evecs @ np.diag(evals.flatten()))\n", - "\n", - "# # print(diff)\n", - "# print((graph_edges._hodge_laplacian @ evecs)[:, 2])\n", - "# print('')\n", - "# print(2*evecs[:, 2])\n", - "\n", - "# # 0, 0, 2" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# print(\"Gradient part:\")\n", - "# graph_edges.get_eigenvalues(7, hodge_type=\"gradient\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# print(\"Curl part:\")\n", - "# graph_edges.get_eigenvalues(7, hodge_type=\"curl\")" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -531,7 +422,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -560,7 +451,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -596,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -636,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -678,7 +569,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -695,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -754,7 +645,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -780,7 +671,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -797,7 +688,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -817,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -914,7 +805,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -969,7 +860,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -997,7 +888,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1056,7 +947,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1096,7 +987,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 25, "metadata": {}, "outputs": [ { diff --git a/tests/data.py b/tests/data.py index b267e894..6205ecae 100644 --- a/tests/data.py +++ b/tests/data.py @@ -45,3 +45,66 @@ ).astype( np.float64 ) # corresponds to TEST_GRAPH_ADJACENCY, normalized Laplacian + +TEST_GRAPH_EDGES_NUM_NODES = 5 + +TEST_GRAPH_EDGES_ADJACENCY = np.array( + [ + [0, 1, 1, 0, 1], + [1, 0, 1, 1, 0], + [1, 1, 0, 1, 0], + [0, 1, 1, 0, 1], + [1, 0, 0, 1, 0], + ] +).astype(np.int32) + +TEST_GRAPH_EDGES_UP_LAPLACIAN = np.array( + [ + [1, -1, 0, 1, 0, 0, 0], + [-1, 1, 0, -1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + [1, -1, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + ] +).astype(np.float64) + +TEST_GRAPH_EDGES_DOWN_LAPLACIAN = np.array( + [ + [2, 1, 1, -1, -1, 0, 0], + [1, 2, 1, 1, 0, -1, 0], + [1, 1, 2, 0, 0, 0, 1], + [-1, 1, 0, 2, 1, -1, 0], + [-1, 0, 0, 1, 2, 1, -1], + [0, -1, 0, -1, 1, 2, -1], + [0, 0, 1, 0, -1, -1, 2], + ] +).astype(np.float64) + +TEST_GRAPH_EDGES_ORIENTED_EDGES = np.array( + [ + [0, 1], + [0, 2], + [0, 4], + [1, 2], + [1, 3], + [2, 3], + [3, 4], + ] +).astype(np.int32) + +TEST_GRAPH_EDGES_TRIANGLES = [(0, 1, 2)] + +TEST_GRAPH_EDGES_ORIENTED_TRIANGLES = np.array( + [ + [1, 4, -2], + ] +).astype(np.int32) + +TEST_GRAPH_EDGES_ORIENTED_TRIANGLES_AUTO = np.array( + [ + [1, 4, -2], + [4, 6, -5], + ] +).astype(np.int32) diff --git a/tests/spaces/test_graph_edges.py b/tests/spaces/test_graph_edges.py index edc3317f..8231e999 100644 --- a/tests/spaces/test_graph_edges.py +++ b/tests/spaces/test_graph_edges.py @@ -1,42 +1,334 @@ -import warnings - -import networkx as nx +import lab as B import numpy as np +import pytest from geometric_kernels.jax import * # noqa +from geometric_kernels.kernels import ( + MaternGeometricKernel, + MaternHodgeCompositionalKernel, + MaternKarhunenLoeveKernel, +) from geometric_kernels.spaces import GraphEdges +from geometric_kernels.tensorflow import * # noqa from geometric_kernels.torch import * # noqa -warnings.filterwarnings("ignore", category=RuntimeWarning, module="scipy") - -G = nx.Graph() -G.add_edge(1, 2) -G.add_edge(1, 3) -G.add_edge(1, 5) -G.add_edge(2, 3) -G.add_edge(3, 4) -G.add_edge(4, 5) - -triangles = [(1, 2, 3)] -B1 = nx.incidence_matrix(G).toarray() -B2 = np.array([[1.0], [1.0], [0.0], [1.0], [0.0], [0.0]]) -sc = GraphEdges(B1, B2) -m = sc.num_edges -eigs = np.array( +from ..data import ( + TEST_GRAPH_EDGES_ADJACENCY, + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES_AUTO, + TEST_GRAPH_EDGES_TRIANGLES, + TEST_GRAPH_EDGES_UP_LAPLACIAN, +) +from ..helper import check_function_with_backend, create_random_state, np_to_backend + + +@pytest.mark.parametrize( + "triangles, oriented_triangles", + [ + (None, TEST_GRAPH_EDGES_ORIENTED_TRIANGLES_AUTO), + (TEST_GRAPH_EDGES_TRIANGLES, TEST_GRAPH_EDGES_ORIENTED_TRIANGLES), + ], +) +@pytest.mark.parametrize( + "backend", ["numpy", "tensorflow", "torch", "jax", "scipy_sparse"] +) +def test_from_adjacency(backend, triangles, oriented_triangles): + + type_reference = create_random_state(backend) + + # check that oriented_edges array is correctly computed from adjacency + B.all( + TEST_GRAPH_EDGES_ORIENTED_EDGES + == GraphEdges.from_adjacency( + TEST_GRAPH_EDGES_ADJACENCY, type_reference, triangles=triangles + ).oriented_edges + ) + + # check that oriented_triangles array is correctly computed from adjacency + B.all( + oriented_triangles + == GraphEdges.from_adjacency( + TEST_GRAPH_EDGES_ADJACENCY, type_reference, triangles=triangles + ).oriented_triangles + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_laplacian(backend): + + check_function_with_backend( + backend, + TEST_GRAPH_EDGES_UP_LAPLACIAN, + lambda or_e, or_t: GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t + )._up_laplacian, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + check_function_with_backend( + backend, + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + lambda or_e, or_t: GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t + )._down_laplacian, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + check_function_with_backend( + backend, + TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + lambda or_e, or_t: GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t + )._hodge_laplacian, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + +@pytest.mark.parametrize( + "L", [ - [6.21724894e-15], - [1.38196601e00], - [2.38196601e00], - [3.00000000e00], - [3.61803399e00], - [4.61803399e00], - ] -) - - -def test_get_eigenvalues(tol=1e-7): - ############################################## - # Eigendecomposition checks - evals = sc.get_eigenvalues(m) - # check vals - np.testing.assert_allclose(evals, eigs, atol=tol, rtol=tol) + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] // 2, + ], +) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_eigendecomposition(L, backend): + hodge_laplacian = np_to_backend( + TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + backend, + ) + + def eigendiff(or_e, or_t): + graph_edges = GraphEdges(TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t) + + eigenvalue_mat = B.diag_construct(graph_edges.get_eigenvalues(L)[:, 0]) + eigenvectors = graph_edges.get_eigenvectors(L) + + laplace_x_eigvecs = hodge_laplacian @ eigenvectors + eigvals_x_eigvecs = eigenvectors @ eigenvalue_mat + return laplace_x_eigvecs - eigvals_x_eigvecs + + check_function_with_backend( + backend, + np.zeros((TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], L)), + eigendiff, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + +@pytest.mark.parametrize( + "hodge_type, projection_matrix, projection_matrix_id", + [ + ("harmonic", TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ("harmonic", TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ("gradient", TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ("curl", TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ], + ids=lambda x: x if isinstance(x, str) else "", +) +@pytest.mark.parametrize( + "L", + [ + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] // 2, + ], +) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hodge_decomposition( + hodge_type, projection_matrix, projection_matrix_id, L, backend +): + # projection_matrix_id we only use for the ids of the test + + n = GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ).get_number_of_eigenpairs(L, hodge_type=hodge_type) + + def proj(or_e, or_t, proj_mat): + graph_edges = GraphEdges(TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t) + proj_mat = np_to_backend(proj_mat, backend) + + eigenvectors = graph_edges.get_eigenvectors(L, hodge_type=hodge_type) + + result = proj_mat @ eigenvectors + return result + + # Check that the eigenvectors of type `hodge_type` lie in the null space + # of the projection matrix (are harmonic / divergence-free / curl-free). + check_function_with_backend( + backend, + np.zeros((TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], n)), + proj, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + projection_matrix, + ) + + +@pytest.mark.parametrize("nu, lengthscale", [(1.0, 1.0), (2.0, 1.0), (np.inf, 1.0)]) +@pytest.mark.parametrize("sparse_adj", [True, False]) +@pytest.mark.parametrize("hodge_compositional", [True, False]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_matern_kernels(nu, lengthscale, hodge_compositional, sparse_adj, backend): + + hodge_laplacian = TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN + n_edges = hodge_laplacian.shape[0] + + evals_np, evecs_np = np.linalg.eigh(hodge_laplacian) + evecs_np *= np.sqrt(hodge_laplacian.shape[0]) + + type_reference = create_random_state(backend) + + def evaluate_kernel(nu, lengthscale, xs): + adj = TEST_GRAPH_EDGES_ADJACENCY + if sparse_adj: + adj = np_to_backend(B.to_numpy(TEST_GRAPH_EDGES_ADJACENCY), "scipy_sparse") + graph_edges = GraphEdges.from_adjacency( + adj, type_reference, triangles=TEST_GRAPH_EDGES_TRIANGLES + ) + + if hodge_compositional: + kernel = MaternHodgeCompositionalKernel(graph_edges, num_levels=n_edges) + + # We want MaternHodgeCompositionalKernel to coincide with + # MaternKarhunenLoeveKernel in this case. For this, we need to + # set the right coefficients for the three hodge types. + + a = B.reshape( + B.sum( + MaternKarhunenLoeveKernel.spectrum( + graph_edges.get_eigenvalues(n_edges, hodge_type="harmonic"), + nu, + lengthscale, + 0, + ) + ), + 1, + ) + + b = B.reshape( + B.sum( + MaternKarhunenLoeveKernel.spectrum( + graph_edges.get_eigenvalues(n_edges, hodge_type="gradient"), + nu, + lengthscale, + 0, + ) + ), + 1, + ) + + c = B.reshape( + B.sum( + MaternKarhunenLoeveKernel.spectrum( + graph_edges.get_eigenvalues(n_edges, hodge_type="curl"), + nu, + lengthscale, + 0, + ) + ), + 1, + ) + + params = { + "harmonic": {"logit": a, "nu": nu, "lengthscale": lengthscale}, + "gradient": {"logit": b, "nu": nu, "lengthscale": lengthscale}, + "curl": {"logit": c, "nu": nu, "lengthscale": lengthscale}, + } + else: + kernel = MaternKarhunenLoeveKernel(graph_edges, num_levels=n_edges) + params = {"nu": nu, "lengthscale": lengthscale} + + return kernel.K(params, xs) + + if nu < np.inf: + K = ( + evecs_np + @ np.diag(np.power(evals_np + 2 * nu / lengthscale**2, -nu)) + @ evecs_np.T + ) + else: + K = evecs_np @ np.diag(np.exp(-(lengthscale**2) / 2 * evals_np)) @ evecs_np.T + K = K / np.mean(K.diagonal()) + + # Check that the kernel matrix is correctly computed. For the Hodge + # compositional kernel, we only check the case when the hyperparameters + # make it coincide with the Karhunen-Loève kernel. + check_function_with_backend( + backend, + K, + evaluate_kernel, + np.array([nu]), + np.array([lengthscale]), + np.arange(1, n_edges + 1)[:, None], + ) + + +@pytest.mark.parametrize( + "coeffs, projection_matrix, projection_matrix_id", + [ + ([1.0, 0.0, 0.0], TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ([1.0, 0.0, 0.0], TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ([0.0, 1.0, 0.0], TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ([0.0, 0.0, 1.0], TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ], + ids=lambda x: x if isinstance(x, str) else "", +) +@pytest.mark.parametrize("nu, lengthscale", [(1.0, 1.0), (2.0, 1.0), (np.inf, 1.0)]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_kernels_hodge_type( + coeffs, projection_matrix, projection_matrix_id, nu, lengthscale, backend +): + # projection_matrix_id we only use for the ids of the test + + def proj_kernel( + or_e, + or_t, + coeff_harmonic, + coeff_gradient, + coeff_curl, + nu, + lengthscale, + xs, + projection_matrix, + ): + graph_edges = GraphEdges(TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t) + + kernel = MaternGeometricKernel(graph_edges) + + params = { + "harmonic": {"logit": coeff_harmonic, "nu": nu, "lengthscale": lengthscale}, + "gradient": {"logit": coeff_gradient, "nu": nu, "lengthscale": lengthscale}, + "curl": {"logit": coeff_curl, "nu": nu, "lengthscale": lengthscale}, + } + + return projection_matrix @ kernel.K(params, xs) + + n_edges = TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] + + # Check that the image of the Hodge compositional kernel lies in the null + # space of the projection matrix. Makes sure that buy setting the + # coefficients of the other two types to zero, the kernel is harmonic / + # divergence-free / curl-free. + check_function_with_backend( + backend, + np.zeros((n_edges, n_edges)), + proj_kernel, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + np.array([coeffs[0]]), + np.array([coeffs[1]]), + np.array([coeffs[2]]), + np.array([nu]), + np.array([lengthscale]), + np.arange(1, n_edges + 1)[:, None], + projection_matrix, + ) From 56d97024058bd69f6c8a2b261be29ebac030bbe9 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 14:04:13 +0100 Subject: [PATCH 16/30] Fix bool_like in torch/extras.py --- geometric_kernels/lab_extras/torch/extras.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index b16a5759..2f80d42c 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -258,7 +258,7 @@ def dtype_bool(reference: B.TorchRandomState): # type: ignore @dispatch -def bool_like(reference: B.NPNumeric): +def bool_like(reference: B.TorchNumeric): """ Return the type of the reference if it is of boolean type. Otherwise return `bool` dtype of a backend based on the reference. From 8ccc6bb9aeaf1ac7065e585ca75547ecaa37127e Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 14:05:36 +0100 Subject: [PATCH 17/30] Move MaternKarhunenLoeveKernel import inside __call__ in feature_maps/random_phase.py --- geometric_kernels/feature_maps/random_phase.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/geometric_kernels/feature_maps/random_phase.py b/geometric_kernels/feature_maps/random_phase.py index a3dd1664..2956a6a4 100644 --- a/geometric_kernels/feature_maps/random_phase.py +++ b/geometric_kernels/feature_maps/random_phase.py @@ -42,8 +42,6 @@ def __init__( num_levels: int, num_random_phases: int = 3000, ): - pass - self.space = space self.num_levels = num_levels self.num_random_phases = num_random_phases @@ -92,6 +90,8 @@ def __call__( `key` is the updated random key for `jax`, or the similar random state (generator) for any other backends. """ + from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel + key, random_phases = self.space.random(key, self.num_random_phases) # [O, D] eigenvalues = self.space.get_eigenvalues(self.num_levels) From 9c767eec926b3a216c12b13d4c0aa6dd9a4bfba8 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 14:06:31 +0100 Subject: [PATCH 18/30] Add additional comments to tests/spaces/test_graph.py --- tests/spaces/test_graph.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/spaces/test_graph.py b/tests/spaces/test_graph.py index a31fa42a..887a2ca2 100644 --- a/tests/spaces/test_graph.py +++ b/tests/spaces/test_graph.py @@ -68,6 +68,7 @@ def eigendiff(adj): eigvals_x_eigvecs = eigenvectors @ eigenvalue_mat return laplace_x_eigvecs - eigvals_x_eigvecs + # Check that the computed eigenpairs are actually eigenpairs check_function_with_backend( backend, np.zeros((TEST_GRAPH_ADJACENCY.shape[0], L)), @@ -112,6 +113,7 @@ def evaluate_kernel(adj, nu, lengthscale): K = evecs_np @ np.diag(np.exp(-(lengthscale**2) / 2 * evals_np)) @ evecs_np.T K = K / np.mean(K.diagonal()) + # Check that the kernel matrix is correctly computed check_function_with_backend( backend, K, From 90dd316efbdbd7fe5972cbebaefb99003fe5ee7d Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 21:25:33 +0100 Subject: [PATCH 19/30] Simplify eigenvalues of MaternKarhunenLoeveKernel by removing the normalize parameter --- geometric_kernels/kernels/karhunen_loeve.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index 75a6a10a..48f38e96 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -168,9 +168,7 @@ def eigenvalues_laplacian(self) -> B.Numeric: """ return self._eigenvalues_laplacian - def eigenvalues( - self, params: Dict[str, B.Numeric], normalize: Optional[bool] = None - ) -> B.Numeric: + def eigenvalues(self, params: Dict[str, B.Numeric]) -> B.Numeric: """ Eigenvalues of the kernel. @@ -178,11 +176,6 @@ def eigenvalues( Parameters of the kernel. Must contain keys `"lengthscale"` and `"nu"`. The shapes of `params["lengthscale"]` and `params["nu"]` are `(1,)`. - :param normalize: - Whether to normalize kernel to have unit average variance. - If None, uses `self.normalize` to decide. - - Defaults to None. :return: An [L, 1]-shaped array. @@ -198,8 +191,8 @@ def eigenvalues( lengthscale=params["lengthscale"], dimension=self.space.dimension, ) - normalize = normalize or (normalize is None and self.normalize) - if normalize: + + if self.normalize: normalizer = B.sum( spectral_values * B.cast( From 02158fbfdf14f5d565967fe174123459e88bd14e Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 21:27:20 +0100 Subject: [PATCH 20/30] Further testing of GraphEdges and related fixes --- .../feature_maps/deterministic.py | 31 ++++++--- .../kernels/hodge_compositional.py | 5 ++ geometric_kernels/spaces/base.py | 6 +- geometric_kernels/spaces/eigenfunctions.py | 3 +- geometric_kernels/spaces/graph_edges.py | 6 +- notebooks/GraphEdges.ipynb | 68 ++++++++----------- tests/helper.py | 21 +++++- tests/spaces/test_basics.py | 5 ++ 8 files changed, 90 insertions(+), 55 deletions(-) diff --git a/geometric_kernels/feature_maps/deterministic.py b/geometric_kernels/feature_maps/deterministic.py index b9af3472..39875d79 100644 --- a/geometric_kernels/feature_maps/deterministic.py +++ b/geometric_kernels/feature_maps/deterministic.py @@ -9,7 +9,6 @@ from beartype.typing import Dict, Optional, Tuple from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel from geometric_kernels.spaces import DiscreteSpectrumSpace, HodgeDiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import Eigenfunctions @@ -87,6 +86,8 @@ def __call__( interface: for some other subclasses of :class:`FeatureMap`, this first element may be an updated random key. """ + from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel + spectrum = MaternKarhunenLoeveKernel.spectrum( self._repeated_eigenvalues, nu=params["nu"], @@ -125,9 +126,9 @@ def __init__(self, space: HodgeDiscreteSpectrumSpace, num_levels: int): self.num_levels, hodge_type ) eigenfunctions = self.space.get_eigenfunctions(self.num_levels, hodge_type) - num_levels_per_type = self.space.get_eigenvalues( - self.num_levels, hodge_type - ).shape[0] + num_levels_per_type = len( + self.space.get_eigenvalues(self.num_levels, hodge_type) + ) setattr( self, f"feature_map_{hodge_type}", @@ -139,11 +140,21 @@ def __init__(self, space: HodgeDiscreteSpectrumSpace, num_levels: int): ), ) + self.feature_map_harmonic: ( + DeterministicFeatureMapCompact # for mypy to know the type + ) + self.feature_map_gradient: ( + DeterministicFeatureMapCompact # for mypy to know the type + ) + self.feature_map_curl: ( + DeterministicFeatureMapCompact # for mypy to know the type + ) + def __call__( self, X: B.Numeric, params: Dict[str, Dict[str, B.Numeric]], - normalize: bool = None, + normalize: bool = True, **kwargs, ) -> Tuple[None, B.Numeric]: """ @@ -172,12 +183,12 @@ def __call__( # Copy the parameters to avoid modifying the original dict. params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} - coeffs = B.softmax( - B.stack( - *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], - axis=0, - ) + coeffs = B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, ) + coeffs = coeffs / B.sum(coeffs) + coeffs = B.sqrt(coeffs) return None, B.concat( coeffs[0] diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py index 9652ce7b..f7fe8891 100644 --- a/geometric_kernels/kernels/hodge_compositional.py +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -75,6 +75,11 @@ def __init__( eigenfunctions=eigenfunctions, ), ) + + self.kernel_harmonic: MaternKarhunenLoeveKernel # for mypy to know the type + self.kernel_gradient: MaternKarhunenLoeveKernel # for mypy to know the type + self.kernel_curl: MaternKarhunenLoeveKernel # for mypy to know the type + self.normalize = normalize @property diff --git a/geometric_kernels/spaces/base.py b/geometric_kernels/spaces/base.py index 94344d46..ca8dc7d7 100644 --- a/geometric_kernels/spaces/base.py +++ b/geometric_kernels/spaces/base.py @@ -201,7 +201,7 @@ def get_eigenfunctions( raise NotImplementedError @abc.abstractmethod - def get_eigenvalues(self, num: int, type: str) -> B.Numeric: + def get_eigenvalues(self, num: int, type: Optional[str] = None) -> B.Numeric: """ Eigenvalues of the Laplacian corresponding to the first `num` levels. If `type` is specified, returns only the eigenvalues corresponding to @@ -223,7 +223,9 @@ def get_eigenvalues(self, num: int, type: str) -> B.Numeric: raise NotImplementedError @abc.abstractmethod - def get_repeated_eigenvalues(self, num: int, type: str) -> B.Numeric: + def get_repeated_eigenvalues( + self, num: int, type: Optional[str] = None + ) -> B.Numeric: """ Eigenvalues of the Laplacian corresponding to the first `num` levels, repeated according to their multiplicity within levels. If `type` is diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 6b082295..4b2e4384 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -330,9 +330,10 @@ def __call__(self, X: B.Numeric, **kwargs) -> B.Numeric: indices = B.cast(B.dtype_int(X), X) if self.index_from_one: assert B.all(indices >= 1) + Phi = take_along_axis(self.eigenvectors, indices - 1, axis=0) else: assert B.all(indices >= 0) - Phi = take_along_axis(self.eigenvectors, indices - 1, axis=0) + Phi = take_along_axis(self.eigenvectors, indices, axis=0) return Phi @property diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 75efb0e0..eb26ca19 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -89,6 +89,7 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): user has full control over the orientation and ordering of the edges. .. admonition:: Complexity + The current implementation of the GraphEdges space is supposed to occupy O(n_edges^2) memory and take O(n_edges^3) time to compute the eigensystem. @@ -191,6 +192,9 @@ def __init__( self._set_laplacian() + def __str__(self): + return f"GraphEdges({self.n_edges})" + @staticmethod def compute_index(n_nodes: int, oriented_edges: B.Numeric) -> csr_array: """ @@ -409,7 +413,7 @@ def resolve_triangles(self, ts: B.Int) -> B.Int: return edges[:, :, 0] # [N, 3, 2] -> [N, 3] @classmethod - def from_adjacency( + def from_adjacency( # noqa: C901 cls, adjacency_matrix: Union[B.NPNumeric, sparray, spmatrix], type_reference: B.RandomState, diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index 1d226fb2..c43ae303 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -711,14 +711,6 @@ "execution_count": 20, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/vabor112/anaconda3/envs/gkconda_updated_sh/lib/python3.10/site-packages/networkx/drawing/nx_pylab.py:437: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, { "data": { "image/png": "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", @@ -739,8 +731,8 @@ "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", "\n", "# Plot variance 32\n", - "nx.draw(nx_graph, pos=pos, ax=ax1, cmap=cmap, edge_color=np.array(variance_32),\n", - " vmin=variance_32.min(), vmax=values_32.max(), **graph_vis_options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax1, edge_cmap=cmap, edge_color=np.array(variance_32),\n", + " edge_vmin=variance_32.min(), edge_vmax=values_32.max(), **graph_vis_options)\n", "# shade the area of the triangle\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", @@ -749,9 +741,8 @@ "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values 32\n", - "nx.draw(nx_graph, pos=pos, ax=ax2, cmap=cmap, edge_color=np.array(values_32),\n", - " vmin=values_32.min(), vmax=values_32.max(), \n", - " **graph_vis_options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax2, edge_cmap=cmap, edge_color=np.array(values_32),\n", + " edge_vmin=values_32.min(), edge_vmax=values_32.max(), **graph_vis_options)\n", "# add a label at the base edge \n", "nx.draw_networkx_edge_labels(nx_graph, pos, edge_labels={(edges[base_edge_idx-1][0], edges[base_edge_idx-1][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", @@ -762,8 +753,8 @@ "\n", "\n", "# Plot variance inf\n", - "nx.draw(nx_graph, pos=pos, ax=ax3, cmap=cmap, edge_color=np.array(variance_inf),\n", - " vmin=variance_inf.min(), vmax=variance_inf.max(), **graph_vis_options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax3, edge_cmap=cmap, edge_color=np.array(variance_inf),\n", + " edge_vmin=variance_inf.min(), edge_vmax=variance_inf.max(), **graph_vis_options)\n", "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", @@ -771,8 +762,8 @@ "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", "\n", "# Plot kernel values inf\n", - "nx.draw(nx_graph, pos=pos, ax=ax4, cmap=cmap, edge_color=np.array(values_inf),\n", - " vmin=values_inf.min(), vmax=values_inf.max(),\n", + "nx.draw(nx_graph, pos=pos, ax=ax4, edge_cmap=cmap, edge_color=np.array(values_inf),\n", + " edge_vmin=values_inf.min(), edge_vmax=values_inf.max(),\n", " **graph_vis_options)\n", "nx.draw_networkx_edge_labels(nx_graph, pos, edge_labels={(edges[base_edge_idx-1][0], edges[base_edge_idx-1][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", @@ -789,18 +780,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### A Note on Prior Variance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that the **variance changes from edge to edge** on this graph.\n", - "\n", - "For example, for the **unnormalized Edge Laplacian**, the variance is related to the expected *return time of a random walk*: how many steps, on average, does it take a particle\n", - "randomly walking over the edge space of the graph and starting in edge x to return back to edge x.\n", - "This argument is inspired by [Yang et al. 2024](https://arxiv.org/abs/2310.19450)." + "**Note:** variance changes from edge to edge, this is normal behavior." ] }, { @@ -901,14 +881,14 @@ " [6]]\n", "\n", "emedding (shape = (3, 7)):\n", - "[[-3.03600927e-01 -1.93535802e-01 2.53503344e-02 2.52011583e-16\n", - " -1.58889012e-16 -2.29413138e-01 2.79559815e-17]\n", - " [-2.73700955e-01 4.29356549e-01 0.00000000e+00 3.08830295e-01\n", - " 1.70071397e-01 -1.89576728e-16 -1.03153517e-01]\n", - " [-5.92251869e-01 -7.56254279e-02 0.00000000e+00 1.54415148e-01\n", - " -1.70071397e-01 1.14706569e-01 1.03153517e-01]]\n", + "[[-3.71833679e-01 -2.37031980e-01 8.81917104e-01 4.85467264e-16\n", + " -3.06078844e-16 -4.41934324e-01 5.38535320e-17]\n", + " [-3.35213842e-01 5.25852231e-01 0.00000000e+00 5.94921063e-01\n", + " 3.27620242e-01 -3.65194704e-16 -1.98711721e-01]\n", + " [-7.25357439e-01 -9.26218550e-02 0.00000000e+00 2.97460531e-01\n", + " -3.27620242e-01 2.20967162e-01 1.98711721e-01]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 1.174825712241954\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 3.178777788932899e-16\n" ] } ], @@ -955,9 +935,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-0.70250871 0.21701509]\n", - " [ 0.65590758 -0.17776272]\n", - " [-0.02723808 0.91741289]]\n" + "[[-1.21678079 0.37588116]\n", + " [ 1.13606525 -0.30789406]\n", + " [-0.04717773 1.58900573]]\n" ] } ], @@ -990,9 +970,17 @@ "execution_count": 25, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/vabor112/anaconda3/envs/gkconda_updated_sh/lib/python3.10/site-packages/networkx/drawing/nx_pylab.py:437: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", + " node_collection = ax.scatter(\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/tests/helper.py b/tests/helper.py index 9c3613ad..f0f67af5 100644 --- a/tests/helper.py +++ b/tests/helper.py @@ -10,6 +10,8 @@ CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, + GraphEdges, + HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, Hypersphere, @@ -22,7 +24,13 @@ SymmetricPositiveDefiniteMatrices, ) -from .data import TEST_GRAPH_ADJACENCY, TEST_MESH_PATH +from .data import ( + TEST_GRAPH_ADJACENCY, + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + TEST_MESH_PATH, +) EagerTensor = ModuleType("tensorflow.python.framework.ops", "EagerTensor") @@ -46,6 +54,16 @@ def product_discrete_spectrum_spaces() -> List[ProductDiscreteSpectrumSpace]: ] +def hodge_discrete_spectrum_spaces() -> List[HodgeDiscreteSpectrumSpace]: + return [ + GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ), + ] + + def discrete_spectrum_spaces() -> List[DiscreteSpectrumSpace]: return ( [ @@ -62,6 +80,7 @@ def discrete_spectrum_spaces() -> List[DiscreteSpectrumSpace]: ] + compact_matrix_lie_groups() + product_discrete_spectrum_spaces() + + hodge_discrete_spectrum_spaces() ) diff --git a/tests/spaces/test_basics.py b/tests/spaces/test_basics.py index a0e300ee..74477feb 100644 --- a/tests/spaces/test_basics.py +++ b/tests/spaces/test_basics.py @@ -7,6 +7,7 @@ from ..helper import ( compact_matrix_lie_groups, discrete_spectrum_spaces, + hodge_discrete_spectrum_spaces, noncompact_symmetric_spaces, product_discrete_spectrum_spaces, spaces, @@ -16,6 +17,10 @@ @pytest.mark.parametrize( "fun, cls", [ + ( + hodge_discrete_spectrum_spaces, + geometric_kernels.spaces.HodgeDiscreteSpectrumSpace, + ), (compact_matrix_lie_groups, geometric_kernels.spaces.CompactMatrixLieGroup), ( product_discrete_spectrum_spaces, From c90b4b5f39b0f347da7aa2a8c3899f3cc0a98e68 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 22:03:28 +0100 Subject: [PATCH 21/30] Documentation-level improvements around GraphEdges --- docs/examples/examples.rst | 1 + docs/theory/hodge.rst | 5 +++ docs/theory/index.rst | 1 + .../kernels/hodge_compositional.py | 37 +++++++++++++------ geometric_kernels/spaces/base.py | 4 +- geometric_kernels/spaces/graph_edges.py | 26 ++++++------- notebooks/GraphEdges.ipynb | 22 ++++------- 7 files changed, 55 insertions(+), 41 deletions(-) create mode 100644 docs/theory/hodge.rst diff --git a/docs/examples/examples.rst b/docs/examples/examples.rst index 4a442a08..df7a60b5 100644 --- a/docs/examples/examples.rst +++ b/docs/examples/examples.rst @@ -7,6 +7,7 @@ Spaces :titlesonly: Graph + GraphEdges Hyperbolic HypercubeGraph Hypersphere diff --git a/docs/theory/hodge.rst b/docs/theory/hodge.rst new file mode 100644 index 00000000..1fb57fb7 --- /dev/null +++ b/docs/theory/hodge.rst @@ -0,0 +1,5 @@ +#################### + Hodge Decomposition +#################### + +TODO diff --git a/docs/theory/index.rst b/docs/theory/index.rst index 71916b75..82900ebe 100644 --- a/docs/theory/index.rst +++ b/docs/theory/index.rst @@ -14,3 +14,4 @@ Product kernels Feature maps and sampling Hypercube graph space + Hodge Decomposition diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py index f7fe8891..d35034d7 100644 --- a/geometric_kernels/kernels/hodge_compositional.py +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -1,6 +1,7 @@ """ -This module provides the :class:`MaternKarhunenLoeveKernel` kernel, the basic -kernel for discrete spectrum spaces, subclasses of :class:`DiscreteSpectrumSpace`. +This module provides the :class:`~.kernels.MaternHodgeCompositionalKernel` +kernel, for discrete spectrum spaces with Hodge decomposition, subclasses +of :class:`~.spaces.HodgeDiscreteSpectrumSpace`. """ import lab as B @@ -14,9 +15,9 @@ class MaternHodgeCompositionalKernel(BaseGeometricKernel): r""" - This class is similar to :class:`MaternKarhunenLoeveKernel`, but provides - a more expressive family of kernels on the spaces where Hodge decomposition - is available. + This class is similar to :class:`~.kernels.MaternKarhunenLoeveKernel`, but + provides a more expressive family of kernels on the spaces where Hodge + decomposition is available. The resulting kernel is a sum of three kernels, @@ -24,26 +25,28 @@ class MaternHodgeCompositionalKernel(BaseGeometricKernel): where $a, b, c$ are weights $a, b, c \geq 0$ and $a + b + c = 1$, and $k_{\text{harmonic}}$, $k_{\text{gradient}}$, $k_{\text{curl}}$ are the - instances of :class:`MaternKarhunenLoeveKernel` that only use the eigenpairs - of the Laplacian corresponding to a single part of the Hodge decomposition. + instances of :class:`~.kernels.MaternKarhunenLoeveKernel` that only use the + eigenpairs of the Laplacian corresponding to a single part of the Hodge + decomposition. The parameters of this kernel are represented by a dict with three keys: `"harmonic"`, `"gradient"`, `"curl"`, each corresponding to a dict with keys `"logit"`, `"nu"`, `"lengthscale"`, where `"nu"` and `"lengthscale"` - are the parameters of the respective :class:`MaternKarhunenLoeveKernel`, + are the parameters of the respective :class:`~.kernels.MaternKarhunenLoeveKernel`, while the `"logit"` parameters determine the weights $a, b, c$ in the - formula above: $a, b, c$ are the softmax of the three `"logit"` parameters. + formula above: $a, b, c$ are the `"logit"` parameters normalized to + satisfy $a + b + c = 1$. - Same as for :class:`MaternKarhunenLoeveKernel`, these kernels can sometimes + Same as for :class:`~.kernels.MaternKarhunenLoeveKernel`, these kernels can sometimes be computed more efficiently using addition theorems. .. note:: A brief introduction into the theory behind - :class:`MaternHodgeCompositionalKernel` can be found in + :class:`~.kernels.MaternHodgeCompositionalKernel` can be found in :doc:`this ` documentation page. :param space: - The space to define the kernel upon, a subclass of :class:`HodgeDiscreteSpectrumSpace`. + The space to define the kernel upon, a subclass of :class:`~.spaces.HodgeDiscreteSpectrumSpace`. :param num_levels: Number of levels to include in the summation. @@ -121,6 +124,10 @@ def K( X2: Optional[B.Numeric] = None, **kwargs, ) -> B.Numeric: + """ + Compute the cross-covariance matrix between two batches of vectors of + inputs, or batches of matrices of inputs, depending on the space. + """ assert all( key in params for key in ["harmonic", "gradient", "curl"] @@ -148,6 +155,12 @@ def K( def K_diag( self, params: Dict[str, Dict[str, B.NPNumeric]], X: B.Numeric, **kwargs ) -> B.Numeric: + """ + Returns the diagonal of the covariance matrix `self.K(params, X, X)`, + typically in a more efficient way than actually computing the full + covariance matrix with `self.K(params, X, X)` and then extracting its + diagonal. + """ assert all( key in params for key in ["harmonic", "gradient", "curl"] diff --git a/geometric_kernels/spaces/base.py b/geometric_kernels/spaces/base.py index ca8dc7d7..7a2909b1 100644 --- a/geometric_kernels/spaces/base.py +++ b/geometric_kernels/spaces/base.py @@ -169,7 +169,9 @@ class HodgeDiscreteSpectrumSpace(DiscreteSpectrumSpace): of compact Riemannian manifolds. .. note:: - TODO (docs theory page). + Hodge decomposition is briefly discussed on :doc:`this ` + documentation page. + .. note:: Typically used with :class:`~.kernels.MaternHodgeCompositionalKernel`. """ diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index eb26ca19..0caad5f1 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -188,7 +188,7 @@ def __init__( self._check_index(index) self.index = index else: - self.index = self.compute_index(n_nodes, oriented_edges) + self.index = self._compute_index(n_nodes, oriented_edges) self._set_laplacian() @@ -196,7 +196,7 @@ def __str__(self): return f"GraphEdges({self.n_edges})" @staticmethod - def compute_index(n_nodes: int, oriented_edges: B.Numeric) -> csr_array: + def _compute_index(n_nodes: int, oriented_edges: B.Numeric) -> csr_array: """ Construct the index matrix from the oriented edges. @@ -370,7 +370,7 @@ def _check_index(self, index: csr_array): ), "The index matrix must be compatible with oriented_edges." def resolve_edges(self, es: B.Int) -> B.Int: - """ + r""" Resolve the signed edge indices to node indices. :param es: @@ -379,7 +379,7 @@ def resolve_edges(self, es: B.Int) -> B.Int: :return: A 2-dimensional array `result` such that `result[e, :]` is `[i, j]` - where |e| = (i, j) if e > 0 and |e| = (j, i) if e < 0. + where \|e\| = (i, j) if e > 0 and \|e\| = (j, i) if e < 0. """ assert B.rank(es) == 1 assert B.all(B.abs(es) >= 1) and B.all(B.abs(es) <= self.n_edges) @@ -553,7 +553,7 @@ def _set_laplacian(self): self._hodge_laplacian = self._down_laplacian + self._up_laplacian - def get_eigensystem(self, num): + def _get_eigensystem(self, num): """ Returns the first `num` eigenvalues and eigenvectors of the Hodge Laplacian. Caches the solution to prevent re-computing the same values. @@ -702,12 +702,12 @@ def get_number_of_eigenpairs(self, num: int, hodge_type: str) -> int: Number of levels. :param hodge_type: - The type of the eigenpairs. It can be 'harmonic', 'gradient', or 'curl'. + The type of the eigenpairs. It can be "harmonic", "gradient", or "curl". :return: The number of eigenpairs of the specified type. """ - eigensystem = self.get_eigensystem(num) + eigensystem = self._get_eigensystem(num) return len(eigensystem[f"{hodge_type}_idx"]) def get_eigenfunctions( @@ -721,7 +721,7 @@ def get_eigenfunctions( Number of levels. :param hodge_type: - The type of the eigenbasis. It can be 'harmonic', 'gradient', or 'curl'. + The type of the eigenbasis. It can be "harmonic", "gradient", or "curl". :return: EigenfunctionsFromEigenvectors object. @@ -730,7 +730,7 @@ def get_eigenfunctions( The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel`. """ - eigensystem = self.get_eigensystem(num) + eigensystem = self._get_eigensystem(num) idx = ( eigensystem[f"{hodge_type}_idx"] if hodge_type is not None @@ -756,12 +756,12 @@ def get_eigenvectors(self, num: int, hodge_type: Optional[str] = None) -> B.Nume Number of eigenvectors to return. :param hodge_type: - The type of the eigenpairs. It can be 'harmonic', 'gradient', or 'curl'. + The type of the eigenpairs. It can be "harmonic", "gradient", or "curl". :return: (n, 1)-shaped array containing the eigenvalues. n <= num. """ - eigensystem = self.get_eigensystem(num) + eigensystem = self._get_eigensystem(num) idx = ( eigensystem[f"{hodge_type}_idx"] @@ -790,12 +790,12 @@ def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numer Number of levels. :param hodge_type: - The type of the eigenpairs. It can be 'harmonic', 'gradient', or 'curl'. + The type of the eigenpairs. It can be "harmonic", "gradient", or "curl". :return: (n, 1)-shaped array containing the eigenvalues. n <= num. """ - eigensystem = self.get_eigensystem(num) + eigensystem = self._get_eigensystem(num) idx = ( eigensystem[f"{hodge_type}_idx"] diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index c43ae303..0ad2286c 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -58,7 +58,6 @@ " - [Defining a Kernel](#Defining-a-Kernel)\n", " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", " - [Visualizing Kernels](#Visualizing-Kernels)\n", - " - [A Note on Prior Variance](#A-Note-on-Prior-Variance)\n", "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", @@ -410,7 +409,8 @@ "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html). **This is to be updated. I could write a brief documentation page on edge kernels.**" + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html).\n", + "For graph edges specifically, the *Hodge decomposition* plays a key role, which is briefly discussed on [another documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hodge.html)." ] }, { @@ -970,17 +970,9 @@ "execution_count": 25, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/vabor112/anaconda3/envs/gkconda_updated_sh/lib/python3.10/site-packages/networkx/drawing/nx_pylab.py:437: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'vmin', 'vmax' will be ignored\n", - " node_collection = ax.scatter(\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1006,8 +998,8 @@ "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", "\n", "# Plot sample #1\n", - "nx.draw(nx_graph, pos=pos, ax=ax1, cmap=cmap, edge_color=sample1,\n", - " vmin=vmin, vmax=vmax, **graph_vis_options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax1, edge_cmap=cmap, edge_color=sample1,\n", + " edge_vmin=vmin, edge_vmax=vmax, **graph_vis_options)\n", "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", @@ -1016,8 +1008,8 @@ "\n", "\n", "# Plot sample #2\n", - "nx.draw(nx_graph, pos=pos, ax=ax2, cmap=cmap, edge_color=sample2,\n", - " vmin=vmin, vmax=vmax, **graph_vis_options)\n", + "nx.draw(nx_graph, pos=pos, ax=ax2, edge_cmap=cmap, edge_color=sample2,\n", + " edge_vmin=vmin, edge_vmax=vmax, **graph_vis_options)\n", "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", "sm = plt.cm.ScalarMappable(cmap=cmap,\n", " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", From 0d1d25baf7667e2a7b51bec3288868733a371985 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 22:38:21 +0100 Subject: [PATCH 22/30] Fix notebooks/frontends/GPflow.ipynb by removing some asserts --- geometric_kernels/spaces/eigenfunctions.py | 6 ++- notebooks/frontends/GPflow.ipynb | 54 ++++++++++------------ 2 files changed, 29 insertions(+), 31 deletions(-) diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 4b2e4384..9ecf61ef 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -329,10 +329,12 @@ def __call__(self, X: B.Numeric, **kwargs) -> B.Numeric: """ indices = B.cast(B.dtype_int(X), X) if self.index_from_one: - assert B.all(indices >= 1) + # assert B.all(indices >= 1) removed because of tensorflow's + # OperatorNotAllowedInGraphError Phi = take_along_axis(self.eigenvectors, indices - 1, axis=0) else: - assert B.all(indices >= 0) + # assert B.all(indices >= 0) removed because of tensorflow's + # OperatorNotAllowedInGraphError Phi = take_along_axis(self.eigenvectors, indices, axis=0) return Phi diff --git a/notebooks/frontends/GPflow.ipynb b/notebooks/frontends/GPflow.ipynb index 73177699..c0975f39 100644 --- a/notebooks/frontends/GPflow.ipynb +++ b/notebooks/frontends/GPflow.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "tags": [] }, @@ -36,7 +36,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", "INFO (geometric_kernels): Tensorflow backend enabled.\n" ] } @@ -82,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "tags": [] }, @@ -135,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "tags": [] }, @@ -162,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "tags": [] }, @@ -208,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "tags": [] }, @@ -232,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "tags": [] }, @@ -278,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "tags": [] }, @@ -301,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "tags": [] }, @@ -321,7 +322,7 @@ "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼────────────────────────┤\n", "│ GPR.likelihood.variance │ Parameter │ Softplus + Shift │ │ True │ () │ float64 │ 0.00010000000000000011 │\n", "╘═════════════════════════╧═══════════╧══════════════════╧═════════╧═════════════╧═════════╧═════════╧════════════════════════╛\n", - "Initial negative log marginal likelihood: 37.38342468456912\n" + "Initial negative log marginal likelihood: 139298.86264833246\n" ] } ], @@ -346,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "tags": [] }, @@ -357,16 +358,16 @@ "text": [ "Starting training...\n", "Final model:\n", - "╒═════════════════════════╤═══════════╤══════════════════╤═════════╤═════════════╤═════════╤═════════╤═══════════════════════╕\n", - "│ name │ class │ transform │ prior │ trainable │ shape │ dtype │ value │\n", - "╞═════════════════════════╪═══════════╪══════════════════╪═════════╪═════════════╪═════════╪═════════╪═══════════════════════╡\n", - "│ GPR.kernel.lengthscales │ Parameter │ Softplus │ │ True │ (1,) │ float64 │ [5.72748] │\n", - "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼───────────────────────┤\n", - "│ GPR.kernel.variance │ Parameter │ Softplus │ │ True │ () │ float64 │ 0.922966133049915 │\n", - "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼───────────────────────┤\n", - "│ GPR.likelihood.variance │ Parameter │ Softplus + Shift │ │ True │ () │ float64 │ 0.0009066831659221346 │\n", - "╘═════════════════════════╧═══════════╧══════════════════╧═════════╧═════════════╧═════════╧═════════╧═══════════════════════╛\n", - "Final negative log marginal likelihood: 36.34231795388164\n" + "╒═════════════════════════╤═══════════╤══════════════════╤═════════╤═════════════╤═════════╤═════════╤════════════╕\n", + "│ name │ class │ transform │ prior │ trainable │ shape │ dtype │ value │\n", + "╞═════════════════════════╪═══════════╪══════════════════╪═════════╪═════════════╪═════════╪═════════╪════════════╡\n", + "│ GPR.kernel.lengthscales │ Parameter │ Softplus │ │ True │ (1,) │ float64 │ [5.16664] │\n", + "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼────────────┤\n", + "│ GPR.kernel.variance │ Parameter │ Softplus │ │ True │ () │ float64 │ 5895.29149 │\n", + "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼────────────┤\n", + "│ GPR.likelihood.variance │ Parameter │ Softplus + Shift │ │ True │ () │ float64 │ 1e-06 │\n", + "╘═════════════════════════╧═══════════╧══════════════════╧═════════╧═════════════╧═════════╧═════════╧════════════╛\n", + "Final negative log marginal likelihood: 256.78736390084214\n" ] } ], @@ -391,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "tags": [] }, @@ -408,14 +409,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -560,11 +561,6 @@ "}\n", "```" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { From 7fb7d1610891477fddf6a1ac368fb1062c5bcd98 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 17 Dec 2024 22:39:03 +0100 Subject: [PATCH 23/30] Rename n_nodes, n_edges, n_triangles to num_nodes, num_edges, num_triangles in GraphEdges --- geometric_kernels/kernels/matern_kernel.py | 2 +- geometric_kernels/spaces/graph_edges.py | 124 +++++++++++---------- notebooks/GraphEdges.ipynb | 16 +-- tests/spaces/test_graph_edges.py | 20 ++-- 4 files changed, 84 insertions(+), 78 deletions(-) diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 231a7632..8a63aafb 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -211,7 +211,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) elif isinstance(space, GraphEdges): - return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.n_edges) + return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) elif isinstance(space, HypercubeGraph): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 0caad5f1..4cf9ff28 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -40,7 +40,7 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): respective change in the way you represent the data. For this space, each individual eigenfunction constitutes a *level*. If - possible, we recommend using num=n_edges levels. Since the current + possible, we recommend using num=num_edges levels. Since the current implementation does not support sparse eigensolvers anyway, this should not create too much time/memory overhead during the precomputations and will also ensure that all types of eigenfunctions are present in the @@ -91,17 +91,17 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): .. admonition:: Complexity The current implementation of the GraphEdges space is supposed to occupy - O(n_edges^2) memory and take O(n_edges^3) time to compute the eigensystem. + O(num_edges^2) memory and take O(num_edges^3) time to compute the eigensystem. Currently, it does not support sparse eigensolvers, which would allow storing the Laplacian matrices in a sparse format and potentially reduce - the O(n_edges^3) complexity to O(n_edges) with a large constant. + the O(num_edges^3) complexity to O(num_edges) with a large constant. - :param n_nodes: + :param num_nodes: The number of nodes in the graph. :param oriented_edges: - A 2D array of shape [n_edges, 2], where n_edges is the number of edges + A 2D array of shape [num_edges, 2], where num_edges is the number of edges in the graph. Each row of the array represents an oriented edge, i.e., a pair of node indices. If `oriented_edges[e]` is `[i, j]`, then the edge with index e+1 (edge indexing starts from 1) represents an edge @@ -113,7 +113,7 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): internal computations. :param oriented_triangles: - A 2D array of shape [n_triangles, 3], where n_triangles is the number + A 2D array of shape [num_triangles, 3], where num_triangles is the number of triangles in the graph. Each row of the array represents an oriented triangle, i.e., a triple of signed edge indices. If `oriented_triangles[t]` is `[i, j, k]`, then `t` consists of the edges @@ -134,7 +134,7 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): debugging but can be slow for large graphs. :param index: - Optional. A sparse matrix of shape [n_nodes, n_nodes] such that + Optional. A sparse matrix of shape [num_nodes, num_nodes] such that `index[i, j]` is the index of the edge `(i, j)` in the `oriented_edges`. `index[i, j]` is positive if (i, j) corresponds to positive orientation of the edge, and negative if it corresponds to the negative orientation. @@ -148,7 +148,7 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): def __init__( self, - n_nodes: int, + num_nodes: int, oriented_edges: B.Int, oriented_triangles: Optional[B.Int], *, @@ -164,11 +164,11 @@ def __init__( comprehensive_checks = checks_mode == "comprehensive" self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} - self.n_nodes = n_nodes + self.num_nodes = num_nodes if do_checks: - self._checks_oriented_edges(oriented_edges, n_nodes, comprehensive_checks) - self.n_edges = oriented_edges.shape[0] + self._checks_oriented_edges(oriented_edges, num_nodes, comprehensive_checks) + self.num_edges = oriented_edges.shape[0] self.oriented_edges = oriented_edges if oriented_triangles is not None: @@ -178,9 +178,9 @@ def __init__( ) if comprehensive_checks: self._checks_compatible(oriented_triangles) - self.n_triangles = oriented_triangles.shape[0] + self.num_triangles = oriented_triangles.shape[0] else: - self.n_triangles = 0 + self.num_triangles = 0 self.oriented_triangles = oriented_triangles if index is not None: @@ -188,36 +188,36 @@ def __init__( self._check_index(index) self.index = index else: - self.index = self._compute_index(n_nodes, oriented_edges) + self.index = self._compute_index(num_nodes, oriented_edges) self._set_laplacian() def __str__(self): - return f"GraphEdges({self.n_edges})" + return f"GraphEdges({self.num_edges})" @staticmethod - def _compute_index(n_nodes: int, oriented_edges: B.Numeric) -> csr_array: + def _compute_index(num_nodes: int, oriented_edges: B.Numeric) -> csr_array: """ Construct the index matrix from the oriented edges. - :param n_nodes: + :param num_nodes: The number of nodes in the graph. :param oriented_edges: The oriented edges array. :return: - The index matrix. A scipy csr_array of shape [n_nodes, n_nodes] such + The index matrix. A scipy csr_array of shape [num_nodes, num_nodes] such that `index[i, j]` is the index of the edge `(i, j)`. """ - result = lil_array((n_nodes, n_nodes), dtype=int) + result = lil_array((num_nodes, num_nodes), dtype=int) for i in range(oriented_edges.shape[0]): result[oriented_edges[i, 0], oriented_edges[i, 1]] = i + 1 result[oriented_edges[i, 1], oriented_edges[i, 0]] = -i - 1 return result.tocsr() def _checks_oriented_edges( - self, oriented_edges: B.Numeric, n_nodes: int, comprehensive: bool = False + self, oriented_edges: B.Numeric, num_nodes: int, comprehensive: bool = False ): """ Checks if `oriented_edges` is of appropriate structure. @@ -242,17 +242,17 @@ def _checks_oriented_edges( oriented_edges >= 0 ), "The oriented_edges array must contain only non-negative values." assert B.all( - oriented_edges < self.n_nodes - ), "The values in the oriented_edges array must be < self.n_nodes." + oriented_edges < self.num_nodes + ), "The values in the oriented_edges array must be < self.num_nodes." assert B.all( oriented_edges[:, 0] - oriented_edges[:, 1] != 0 ), "Loops are not allowed." if comprehensive: - n_edges = oriented_edges.shape[0] + num_edges = oriented_edges.shape[0] - for i in range(n_edges): - for j in range(i + 1, n_edges): + for i in range(num_edges): + for j in range(i + 1, num_edges): assert B.any( oriented_edges[i, :] != oriented_edges[j, :] ), "The oriented_edges array must not contain duplicate edges." @@ -260,7 +260,7 @@ def _checks_oriented_edges( oriented_edges[i, :] != oriented_edges[j, ::-1] ), "The oriented_edges array must not contain duplicate edges." - assert set(range(self.n_nodes)) == set( + assert set(range(self.num_nodes)) == set( B.to_numpy(B.flatten(oriented_edges)) ), "The oriented_edges array must contain all nodes." @@ -292,12 +292,12 @@ def _checks_oriented_triangles( B.abs(oriented_triangles) >= 1 ), "The oriented_triangles array must contain only non-zero values." assert B.all( - B.abs(oriented_triangles) <= self.n_edges - ), "The absolute values in the oriented_triangles array must be <= self.n_edges." + B.abs(oriented_triangles) <= self.num_edges + ), "The absolute values in the oriented_triangles array must be <= self.num_edges." assert B.all( - B.abs(oriented_triangles) < self.n_edges - ), "The absolute values in the oriented_triangles array must be less than self.n_edges." + B.abs(oriented_triangles) < self.num_edges + ), "The absolute values in the oriented_triangles array must be less than self.num_edges." assert ( B.all( B.abs(oriented_triangles[:, 0]) - B.abs(oriented_triangles[:, 1]) != 0 @@ -311,10 +311,10 @@ def _checks_oriented_triangles( ), "Triangles must consist of 3 different edges." if comprehensive: - n_triangles = oriented_triangles.shape[0] + num_triangles = oriented_triangles.shape[0] - for i in range(n_triangles): - for j in range(i + 1, n_triangles): + for i in range(num_triangles): + for j in range(i + 1, num_triangles): assert B.any( oriented_triangles[i, :] != oriented_triangles[j, :] ), "The oriented_triangles array must not contain duplicate triangles." @@ -334,8 +334,8 @@ def _checks_compatible( oriented_triangles ), "The oriented_edges and oriented_triangles arrays must have the same dtype." - n_triangles = oriented_triangles.shape[0] - for t in range(n_triangles): + num_triangles = oriented_triangles.shape[0] + for t in range(num_triangles): resolved_edges = self.resolve_edges(oriented_triangles[t, :]) assert ( resolved_edges[0, 1] == resolved_edges[1, 0] @@ -359,8 +359,8 @@ def _check_index(self, index: csr_array): ), "The index matrix must be compatible with oriented_edges." edges.append((min(i, j), max(i, j))) - for i in range(self.n_nodes): - for j in range(i + 1, self.n_nodes): + for i in range(self.num_nodes): + for j in range(i + 1, self.num_nodes): if (i, j) not in edges: assert ( index[i, j] == 0 @@ -382,7 +382,7 @@ def resolve_edges(self, es: B.Int) -> B.Int: where \|e\| = (i, j) if e > 0 and \|e\| = (j, i) if e < 0. """ assert B.rank(es) == 1 - assert B.all(B.abs(es) >= 1) and B.all(B.abs(es) <= self.n_edges) + assert B.all(B.abs(es) >= 1) and B.all(B.abs(es) <= self.num_edges) result = self.oriented_edges[B.abs(es) - 1] result = B.where(B.expand_dims(es > 0, axis=-1), result, result[:, ::-1]) @@ -402,7 +402,7 @@ def resolve_triangles(self, ts: B.Int) -> B.Int: oriented edges constituting the triangle `t`. """ assert B.rank(ts) == 1 - assert B.all(B.abs(ts) >= 0) and B.all(B.abs(ts) < self.n_triangles) + assert B.all(B.abs(ts) >= 0) and B.all(B.abs(ts) < self.num_triangles) edge_indices = B.flatten( self.oriented_triangles[ts] @@ -426,7 +426,7 @@ def from_adjacency( # noqa: C901 :param adjacency_matrix: Adjacency matrix of a graph. A numpy array of shape - `[n_nodes, n_nodes]` where `n_nodes` is the number of nodes in the + `[num_nodes, num_nodes]` where `num_nodes` is the number of nodes in the graph. `adjacency_matrix[i, j]` can only be 0 or 1. :param type_reference: @@ -521,9 +521,11 @@ def _set_laplacian(self): # This does node_to_edge_incidence.T @ node_to_edge_incidence # TODO: make this more efficient, avoid for loops. - self._down_laplacian = np.zeros((self.n_edges, self.n_edges), dtype=np.int32) - for i in range(self.n_edges): - for j in range(self.n_edges): + self._down_laplacian = np.zeros( + (self.num_edges, self.num_edges), dtype=np.int32 + ) + for i in range(self.num_edges): + for j in range(self.num_edges): self._down_laplacian[i, j] = ( int(self.oriented_edges[i, 0] == self.oriented_edges[j, 0]) + int(self.oriented_edges[i, 1] == self.oriented_edges[j, 1]) @@ -536,10 +538,10 @@ def _set_laplacian(self): # This does edge_to_triangle_incidence @ edge_to_triangle_incidence.T # TODO: make this more efficient, avoid for loops. - self._up_laplacian = np.zeros((self.n_edges, self.n_edges), dtype=np.int32) - for i in range(self.n_edges): - for j in range(self.n_edges): - for t in range(self.n_triangles): + self._up_laplacian = np.zeros((self.num_edges, self.num_edges), dtype=np.int32) + for i in range(self.num_edges): + for j in range(self.num_edges): + for t in range(self.num_triangles): cur_triangle = set(B.to_numpy(self.oriented_triangles[t, :])) if (i + 1 in cur_triangle and j + 1 in cur_triangle) or ( -i - 1 in cur_triangle and -j - 1 in cur_triangle @@ -567,7 +569,7 @@ def _get_eigensystem(self, num): """ # The current implementation computes the complete set of eigenpairs of - # three n_edges x n_edges Laplacian matrices. Since we don't currently + # three num_edges x num_edges Laplacian matrices. Since we don't currently # support sparse Laplacians, this should not be a major bottleneck. # # Here are some important points for anyone who wants to add proper @@ -614,12 +616,12 @@ def _get_eigensystem(self, num): if num not in self.cache: # We use Hodge Laplacian to find the eigenpairs of harmonic type, # these are the ones associated to zero eigenvalues. - evals_hodge, evecs_hodge = eigenpairs(self._hodge_laplacian, self.n_edges) + evals_hodge, evecs_hodge = eigenpairs(self._hodge_laplacian, self.num_edges) # We use up and down Laplacians to find the eigenpairs of curl and # gradient types. These are the ones associated to non-zero eigenvalues. - evals_up, evecs_up = eigenpairs(self._up_laplacian, self.n_edges) - evals_down, evecs_down = eigenpairs(self._down_laplacian, self.n_edges) + evals_up, evecs_up = eigenpairs(self._up_laplacian, self.num_edges) + evals_down, evecs_down = eigenpairs(self._down_laplacian, self.num_edges) # We count the number of eigenpairs of each type for future reference. n_harm = count_nonzero(evals_hodge < eps) @@ -638,29 +640,33 @@ def _get_eigensystem(self, num): evecs = B.concat( B.reshape( evecs_hodge[ - B.broadcast_to(evals_hodge < eps, self.n_edges, self.n_edges) + B.broadcast_to( + evals_hodge < eps, self.num_edges, self.num_edges + ) ], - self.n_edges, + self.num_edges, -1, ), B.reshape( evecs_up[ - B.broadcast_to(evals_up >= eps, self.n_edges, self.n_edges) + B.broadcast_to(evals_up >= eps, self.num_edges, self.num_edges) ], - self.n_edges, + self.num_edges, -1, ), B.reshape( evecs_down[ - B.broadcast_to(evals_down >= eps, self.n_edges, self.n_edges) + B.broadcast_to( + evals_down >= eps, self.num_edges, self.num_edges + ) ], - self.n_edges, + self.num_edges, -1, ), axis=-1, ) - evecs *= B.sqrt(self.n_edges) # to make sure average variance is 1. + evecs *= B.sqrt(self.num_edges) # to make sure average variance is 1. # We get the indices that would sort the eigenvalues in ascending order. sorted_indices = B.argsort(evals) @@ -827,7 +833,7 @@ def random(self, key, number): number, 1, lower=1, - upper=self.n_edges + 1, + upper=self.num_edges + 1, ) return key, random_edges diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index 0ad2286c..298e59f8 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -239,8 +239,8 @@ "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", "\n", "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", - "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.n_triangles))\n", - "for t in range(graph_edges.n_triangles):\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.num_triangles))\n", + "for t in range(graph_edges.num_triangles):\n", " i, j, k = triangles[t, :]\n", " plt.fill(\n", " [pos[i][0], pos[j][0], pos[k][0]],\n", @@ -284,7 +284,7 @@ ], "source": [ "print(\"Edges:\")\n", - "for edge_index in range(1, graph_edges.n_edges + 1):\n", + "for edge_index in range(1, graph_edges.num_edges + 1):\n", " edge = graph_edges.resolve_edges(np.array([edge_index,])).flatten() # a bit ugly because resolve_edges is supposed to work with batches\n", " edge_opposite = graph_edges.resolve_edges(np.array([-edge_index,])).flatten()\n", " print(f\"Edge index {edge_index} corresponds to the edge ({edge[0]}, {edge[1]})\"\n", @@ -292,7 +292,7 @@ "\n", "print()\n", "print(\"Triangles:\")\n", - "for triangle_index in range(graph_edges.n_triangles):\n", + "for triangle_index in range(graph_edges.num_triangles):\n", " triangle_edges = graph_edges.oriented_triangles[triangle_index, :]\n", " triangle_nodes = graph_edges.resolve_triangles(np.array([triangle_index,])).flatten() # a bit ugly because resolve_triangles is supposed to work with batches\n", " print(f\"Triangle index {triangle_index} corresponds to\"\n", @@ -355,8 +355,8 @@ "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", "\n", "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", - "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.n_triangles))\n", - "for t in range(graph_edges.n_triangles):\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.num_triangles))\n", + "for t in range(graph_edges.num_triangles):\n", " i, j, k = triangles[t, :]\n", " plt.fill(\n", " [pos[i][0], pos[j][0], pos[k][0]],\n", @@ -383,7 +383,7 @@ ], "source": [ "print(\"Triangles:\")\n", - "for triangle_index in range(graph_edges.n_triangles):\n", + "for triangle_index in range(graph_edges.num_triangles):\n", " triangle_edges = graph_edges.oriented_triangles[triangle_index, :]\n", " triangle_nodes = graph_edges.resolve_triangles(np.array([triangle_index,])).flatten() # a bit ugly because resolve_triangles is supposed to work with batches\n", " print(f\"Triangle index {triangle_index} corresponds to\"\n", @@ -659,7 +659,7 @@ "source": [ "base_edge_idx = 1\n", "print(f\"base_edge_idx={base_edge_idx} corresponds to the edge {graph_edges.resolve_edges(np.array([base_edge_idx])).flatten()}\")\n", - "other_edges_idx = np.arange(1, graph_edges.n_edges + 1)[:, None]" + "other_edges_idx = np.arange(1, graph_edges.num_edges + 1)[:, None]" ] }, { diff --git a/tests/spaces/test_graph_edges.py b/tests/spaces/test_graph_edges.py index 8231e999..89eb6104 100644 --- a/tests/spaces/test_graph_edges.py +++ b/tests/spaces/test_graph_edges.py @@ -180,7 +180,7 @@ def proj(or_e, or_t, proj_mat): def test_matern_kernels(nu, lengthscale, hodge_compositional, sparse_adj, backend): hodge_laplacian = TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN - n_edges = hodge_laplacian.shape[0] + num_edges = hodge_laplacian.shape[0] evals_np, evecs_np = np.linalg.eigh(hodge_laplacian) evecs_np *= np.sqrt(hodge_laplacian.shape[0]) @@ -196,7 +196,7 @@ def evaluate_kernel(nu, lengthscale, xs): ) if hodge_compositional: - kernel = MaternHodgeCompositionalKernel(graph_edges, num_levels=n_edges) + kernel = MaternHodgeCompositionalKernel(graph_edges, num_levels=num_edges) # We want MaternHodgeCompositionalKernel to coincide with # MaternKarhunenLoeveKernel in this case. For this, we need to @@ -205,7 +205,7 @@ def evaluate_kernel(nu, lengthscale, xs): a = B.reshape( B.sum( MaternKarhunenLoeveKernel.spectrum( - graph_edges.get_eigenvalues(n_edges, hodge_type="harmonic"), + graph_edges.get_eigenvalues(num_edges, hodge_type="harmonic"), nu, lengthscale, 0, @@ -217,7 +217,7 @@ def evaluate_kernel(nu, lengthscale, xs): b = B.reshape( B.sum( MaternKarhunenLoeveKernel.spectrum( - graph_edges.get_eigenvalues(n_edges, hodge_type="gradient"), + graph_edges.get_eigenvalues(num_edges, hodge_type="gradient"), nu, lengthscale, 0, @@ -229,7 +229,7 @@ def evaluate_kernel(nu, lengthscale, xs): c = B.reshape( B.sum( MaternKarhunenLoeveKernel.spectrum( - graph_edges.get_eigenvalues(n_edges, hodge_type="curl"), + graph_edges.get_eigenvalues(num_edges, hodge_type="curl"), nu, lengthscale, 0, @@ -244,7 +244,7 @@ def evaluate_kernel(nu, lengthscale, xs): "curl": {"logit": c, "nu": nu, "lengthscale": lengthscale}, } else: - kernel = MaternKarhunenLoeveKernel(graph_edges, num_levels=n_edges) + kernel = MaternKarhunenLoeveKernel(graph_edges, num_levels=num_edges) params = {"nu": nu, "lengthscale": lengthscale} return kernel.K(params, xs) @@ -268,7 +268,7 @@ def evaluate_kernel(nu, lengthscale, xs): evaluate_kernel, np.array([nu]), np.array([lengthscale]), - np.arange(1, n_edges + 1)[:, None], + np.arange(1, num_edges + 1)[:, None], ) @@ -312,7 +312,7 @@ def proj_kernel( return projection_matrix @ kernel.K(params, xs) - n_edges = TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] + num_edges = TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] # Check that the image of the Hodge compositional kernel lies in the null # space of the projection matrix. Makes sure that buy setting the @@ -320,7 +320,7 @@ def proj_kernel( # divergence-free / curl-free. check_function_with_backend( backend, - np.zeros((n_edges, n_edges)), + np.zeros((num_edges, num_edges)), proj_kernel, TEST_GRAPH_EDGES_ORIENTED_EDGES, TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, @@ -329,6 +329,6 @@ def proj_kernel( np.array([coeffs[2]]), np.array([nu]), np.array([lengthscale]), - np.arange(1, n_edges + 1)[:, None], + np.arange(1, num_edges + 1)[:, None], projection_matrix, ) From b93cf1f84e332bd36450953856ab5ac90e4f125c Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Wed, 18 Dec 2024 16:04:01 +0100 Subject: [PATCH 24/30] init docs for GraphEdge --- docs/theory/graphs.rst | 67 +++++++++++++++++++++++++++++++++++++++++- docs/theory/hodge.rst | 22 +++++++++++++- 2 files changed, 87 insertions(+), 2 deletions(-) diff --git a/docs/theory/graphs.rst b/docs/theory/graphs.rst index 059ca471..4c9c35fe 100644 --- a/docs/theory/graphs.rst +++ b/docs/theory/graphs.rst @@ -86,6 +86,71 @@ if you want to model a **signal on the edges** of a graph $G$, you can consider Alternatively, especially for the flow-type data, you might want to use specialized edge kernels, see :cite:t:`yang2024` and :cite:t:`alain2023`. These are, however, not implemented in GeometricKernels at the moment. + +Consider a simplicial 2-complex with $N_0$ nodes, $N_1$ edges and $N_2$ triangular faces (triangles). +We additionally assign reference orientations [#]_ to the edges and triangles according to the increaseing order of their node labels. +An oriented edge, denoted as $e=[i,j]$ is an ordering of $\{i,j\}$. +**Note that** this is not a directed edge allowing flow only from $i$ to $j$, but rather an assignment of the sign of the flow: from $i$ to $j$ it is positive and the reverse is negative. +Same goes for oriented triangles, denoted as $t=[i,j,k]$ and we have $t=[i,j,k] = [j,k,i] = [k,i,j] = -[i,k,j] = -[k,j,i] = -[j,i,k]$. + +In a simplicial 2-complex, the functions, $f_1:E\to\mathbb{R}$, on its edges $E$ are required to be _alternating_ :cite:p:`lim2020hodge`. +By collecting the edge functions on $E$ into a vector $\mathbf{f}_1=[f_1(e_1),\dots,f_1(e_{N_1}]^\top\in\mathbb{R}^{N_1}$, we then obtain an **edge flow**. + +Given a simplicial 2-complex, we can define the discrete **Hodge Laplacian**, which operates on the space of edge flows, as +$$ +\mathbf{L} = \mathbf{B}_1^\top \mathbf{B}_1 + \mathbf{B}_2 \mathbf{B}_2^\top := \mathbf{L}_{\text{d}} + \mathbf{L}_{\text{u}}, +$$ +where $\mathbf{B}_1$ is the *oriented* node-to-edge incidence matrix of dimension $N_0\times N_1$, and $\mathbf{B}_2$ is the *oriented* edge-to-triangle incidence matrix of dimension $N_1\times N_2$. +For $\mathbf{B}_2$, its entries are $[ \mathbf{B}_2 ]_{e t} = 1$, for $e = [i, j]$ or $e = [j, k]$, and $[ \mathbf{B}_2 ]_{e t} = -1$ for $e = [i, k]$, if a triangle $t = [i, j, k]$ exists, and zero otherwise. + +Thus, the Hodge Laplacian $\mathbf{L}$ describes the connectivity of edges where the *down* part $\mathbf{L}_d$ and the *up* part $\mathbf{L}_u$ encode how edges are adjacent, respectively, through nodes and via triangles. +Matrix $\mathbf{L}$ is positive semi-definite, admitting an eigendecomposition $\mathbf{L} = \mathbf{U} \boldsymbol{\Lambda} \mathbf{U}^{T}$ where diagonal matrix $\boldsymbol{\Lambda} = \text{diag}(\lambda_1, \dots, \lambda_N)$ collects the eigenvalues and $\mathbf{U}$ is the eigenvector matrix. +Here, we consider the unweighted $\mathbf{L}$ but it also holds for the weighted variants. + +The eigenvectors provide an orthonormal basis for the space of edge flows. +Furthermore, the :doc:`Hodge decomposition ` says that the space of edge flows can be decomposed into harmonic, gradient and curl subspaces. +Moreover, :cite:t:`yang2022simplicial` showed that the eigenspace of the Hodge Laplacian can be reorganized in terms of the three Hodge subspaces as +$$ +\mathbf{U} = \begin{bmatrix} \mathbf{U}_{H} & \mathbf{U}_{G} & \mathbf{U}_{C} \end{bmatrix}, +$$ +where $\mathbf{U}_H$ is the eigenvector matrix associated to zero eigenvalues $\boldsymbol{\Lambda}_H = 0$ of $\mathbf{L}_1$, $\mathbf{U}_G$ is associated to the nonzero eigenvalues $\boldsymbol{\Lambda}_G$ of $\mathbf{L}_d$, and $\mathbf{U}_C$ is associated to the nonzero eigenvalues $\boldsymbol{\Lambda}_C$ of $\mathbf{L}_u$. +That is, they span the Hodge subspaces: +$$ +\mathrm{span}(\mathbf{U}_H) = \ker(\mathbf{L}_1), \quad \mathrm{span}(\mathbf{U}_G) = \mathrm{im}(\mathbf{B}_1^{\top}), \quad +\mathrm{span}(\mathbf{U}_C) = \mathrm{im}(\mathbf{B}_2) +$$ +where $\mathrm{span}(\bullet)$ denotes all possible linear combinations of columns of $\bullet$. + +The Hodge-compositional edge kernel is built to enable separable control on the different Hodge subspaces. +Specifically, the kernel is defined as +$$ +\mathbf{K}_{\nu,\kappa} = \mathbf{K}_{H} + \mathbf{K}_{G} + \mathbf{K}_{C}, +\quad +\text{where} +\quad +\mathbf{K}_{\Box} = \mathbf{U}_{\Box} \Phi_{\Box}(\boldsymbol{\Lambda}_{\Box}) \mathbf{U}_{\Box}^\top +$$ +for $\Box = H,G,C$, with $\Phi_{\Box}(\boldsymbol{\Lambda}_{\Box})$ having diagonal entries +$$ +\Phi_{\Box}({\lambda}_{\Box}) += +\begin{cases} +\sigma_{\Box}^2 +\left(\frac{2\nu_{\Box}}{\kappa_{\Box}^2} + \lambda_{\Box}\right)^{-\nu_{\Box}} +& +\text{ — Matérn} +\\ +\sigma_{\Box}^2 +e^{-\frac{\kappa_{\Box}^2}{2} \lambda_{\Box}} +& +\text{ — Heat (RBF)} +\end{cases} +$$ + +That is, each $\mathbf{K}_{\Box}$ encodes the covariance between edge functions *individually* for the three Hodge subspaces and the three sub-kernels do not share hyperparameters. + + .. rubric:: Footnotes -.. [#] The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel` and :class:`~.Eigenfunctions` classes. \ No newline at end of file +.. [#] The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel` and :class:`~.Eigenfunctions` classes. +.. [#] The orientation of a general simplex is an equivalence class of permutations of its labels. Two orientations are equivalent (respectively, opposite) if they differ by an even (respectively, odd) permutation :cite:p:`lim2020hodge`. \ No newline at end of file diff --git a/docs/theory/hodge.rst b/docs/theory/hodge.rst index 1fb57fb7..a33a838b 100644 --- a/docs/theory/hodge.rst +++ b/docs/theory/hodge.rst @@ -2,4 +2,24 @@ Hodge Decomposition #################### -TODO +In a simplicial 2-complex, for an edge flow $\mathbf{f}$, we have the following discrete operations to measure its variational properties: + +* The *divergence* operation: $\mathbf{B}_1 \mathbf{f}$, which measures the netflow of edge flows passing through each node. A divergence-free flow has zero netflow at each node, indicating that the in-flow and out-flow are balanced. + +* The *curl* operation: $\mathbf{B}_2^\top \mathbf{f}$, which measures the circulation of edge flows around each triangle. A curl-free flow has zero circulation around each triangle, indicating that the flow is irrotational. + +For a node function $\mathbf{f}_0$, we have the *gradient* operation: $\mathbf{B}_1^\top \mathbf{f}_0$, which measures the change in the function value along each edge. A gradient-free function has zero change in value along each edge, indicating that the function is constant along each edge. + +Given a simplicial 2-complex, the space of edge flows $\mathbb{R}^N_1$ is a direct sum of three subspaces +$$ +\mathbb{R}^{N_1} = \text{im}(\mathbf{B}_1^\top) \oplus \ker(\mathbf{L}) \oplus \text{im}(\mathbf{B}_2), +$$ +where $\text{im}(\mathbf{B}_1^\top)$ is the *gradient* space, $\ker(\mathbf{L})$ is the *harmonic* space, and $\text{im}(\mathbf{B}_2)$ is the *curl* space. + +It states that any edge flow is composed of three orthogonal components: a gradient component, a harmonic component, and a curl component. + +* The gradient component is the flow that is induced by a node function, which is curl-free. + +* The curl component is the flow that is induced by a triangle function, which is divergence-free. + +* The harmonic component is the flow that is divergence-free and curl-free. From 4eb74003af94e7deb34c5ef016277394ce18dbb7 Mon Sep 17 00:00:00 2001 From: cookbook-ms Date: Wed, 18 Dec 2024 16:05:40 +0100 Subject: [PATCH 25/30] init docs for GraphEdge --- docs/theory/graphs.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/theory/graphs.rst b/docs/theory/graphs.rst index 4c9c35fe..7883081d 100644 --- a/docs/theory/graphs.rst +++ b/docs/theory/graphs.rst @@ -94,7 +94,7 @@ An oriented edge, denoted as $e=[i,j]$ is an ordering of $\{i,j\}$. Same goes for oriented triangles, denoted as $t=[i,j,k]$ and we have $t=[i,j,k] = [j,k,i] = [k,i,j] = -[i,k,j] = -[k,j,i] = -[j,i,k]$. In a simplicial 2-complex, the functions, $f_1:E\to\mathbb{R}$, on its edges $E$ are required to be _alternating_ :cite:p:`lim2020hodge`. -By collecting the edge functions on $E$ into a vector $\mathbf{f}_1=[f_1(e_1),\dots,f_1(e_{N_1}]^\top\in\mathbb{R}^{N_1}$, we then obtain an **edge flow**. +By collecting the edge functions on $E$ into a vector $\mathbf{f}_1=[f_1(e_1),\dots,f_1(e_{N_1})]^\top\in\mathbb{R}^{N_1}$, we then obtain an **edge flow**. Given a simplicial 2-complex, we can define the discrete **Hodge Laplacian**, which operates on the space of edge flows, as $$ From 7f606003c485a3677e446e65470a95c00bd2adea Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Thu, 19 Dec 2024 17:05:06 +0100 Subject: [PATCH 26/30] Improve theory/graphs.rst and theory/hodge.rst --- docs/theory/graphs.rst | 48 ++++++++++++++++++++++++++++-------------- docs/theory/hodge.rst | 4 ++-- 2 files changed, 34 insertions(+), 18 deletions(-) diff --git a/docs/theory/graphs.rst b/docs/theory/graphs.rst index 7883081d..bcfc133e 100644 --- a/docs/theory/graphs.rst +++ b/docs/theory/graphs.rst @@ -81,43 +81,59 @@ The notation here is as follows. Edge Set of a Graph ========================== -if you want to model a **signal on the edges** of a graph $G$, you can consider modeling the signal on the nodes of the `line graph `_. The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the `line_graph `_ function from `networkx `_. +If you want to model a signal on the edges of a graph $G$, you can consider modeling the signal on the nodes of the `line graph `_. +The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. +To build the line graph, you can use the `line_graph `_ function from `networkx `_. +Alternatively, especially for the **flow-type data**, you might want to use specialized edge kernels that we briefly describe below. -Alternatively, especially for the flow-type data, you might want to use specialized edge kernels, see :cite:t:`yang2024` and :cite:t:`alain2023`. -These are, however, not implemented in GeometricKernels at the moment. +To define kernels for flow-type data on graph edges, the graph is extended to a *simplicial 2-complex*. +You can ignore the concept of a simplicial 2-complex and treat the space as a graph as GeometricKernels can automatically extend your graph to a simplicial 2-complex in a sensible way. +If you ignore the simplicial 2-complex, disregard the rest of this section as it relies on that concept. +Simplicial 2-complexes +---------------------- -Consider a simplicial 2-complex with $N_0$ nodes, $N_1$ edges and $N_2$ triangular faces (triangles). -We additionally assign reference orientations [#]_ to the edges and triangles according to the increaseing order of their node labels. +A *simplicial 2-complex* is a collection of $N_0$ nodes, $N_1$ edges, and $N_2$ triangles such that each triangle is a subset of three nodes and each edge is a subset of two nodes. +The edges are not directed, but they are oriented [#]_. An oriented edge, denoted as $e=[i,j]$ is an ordering of $\{i,j\}$. -**Note that** this is not a directed edge allowing flow only from $i$ to $j$, but rather an assignment of the sign of the flow: from $i$ to $j$ it is positive and the reverse is negative. -Same goes for oriented triangles, denoted as $t=[i,j,k]$ and we have $t=[i,j,k] = [j,k,i] = [k,i,j] = -[i,k,j] = -[k,j,i] = -[j,i,k]$. +This is not a directed edge allowing flow only from $i$ to $j$, but rather an assignment of the sign of the flow: from $i$ to $j$ it is positive and the reverse is negative. +Same goes for oriented triangles, denoted as $t=[i,j,k]$, with +$$ +t=[i,j,k] = [j,k,i] = [k,i,j] = -[i,k,j] = -[k,j,i] = -[j,i,k] +. +$$ + +A function $f_1:E \to \mathbb{R}$ on the edge set $E$ of a simplicial 2-complex is required to be alternating, i.e. $f_1(-e) = -f_1(e)$ for all $e \in E$. +Such a function may be identified with the vector +$$ +\mathbf{f}_1=[f_1(e_1),\dots,f_1(e_{N_1})]^\top\in\mathbb{R}^{N_1} +$$ +of its values on all positively oriented edges $e_i$ which we call an **edge flow**. -In a simplicial 2-complex, the functions, $f_1:E\to\mathbb{R}$, on its edges $E$ are required to be _alternating_ :cite:p:`lim2020hodge`. -By collecting the edge functions on $E$ into a vector $\mathbf{f}_1=[f_1(e_1),\dots,f_1(e_{N_1})]^\top\in\mathbb{R}^{N_1}$, we then obtain an **edge flow**. - Given a simplicial 2-complex, we can define the discrete **Hodge Laplacian**, which operates on the space of edge flows, as $$ \mathbf{L} = \mathbf{B}_1^\top \mathbf{B}_1 + \mathbf{B}_2 \mathbf{B}_2^\top := \mathbf{L}_{\text{d}} + \mathbf{L}_{\text{u}}, $$ where $\mathbf{B}_1$ is the *oriented* node-to-edge incidence matrix of dimension $N_0\times N_1$, and $\mathbf{B}_2$ is the *oriented* edge-to-triangle incidence matrix of dimension $N_1\times N_2$. -For $\mathbf{B}_2$, its entries are $[ \mathbf{B}_2 ]_{e t} = 1$, for $e = [i, j]$ or $e = [j, k]$, and $[ \mathbf{B}_2 ]_{e t} = -1$ for $e = [i, k]$, if a triangle $t = [i, j, k]$ exists, and zero otherwise. +For every positively oriented edge $[i, j]$, we have $[ \mathbf{B}_1 ]_{i e} = 1$ and $[ \mathbf{B}_1 ]_{j e} = -1$. +All the other entries of $\mathbf{B}_1$ are zero. +If an edge $e$ is aligned with the triangle $t$, we have $[ \mathbf{B}_2 ]_{e t} = 1$, if $-e$ is aligned with $t$, we have $[ \mathbf{B}_2 ]_{e t} = -1$. +All the other entries of $\mathbf{B}_2$ are zero. -Thus, the Hodge Laplacian $\mathbf{L}$ describes the connectivity of edges where the *down* part $\mathbf{L}_d$ and the *up* part $\mathbf{L}_u$ encode how edges are adjacent, respectively, through nodes and via triangles. +The Hodge Laplacian $\mathbf{L}$ describes the connectivity of edges where the *down* part $\mathbf{L}_d$ and the *up* part $\mathbf{L}_u$ encode how edges are adjacent, respectively, through nodes and via triangles. Matrix $\mathbf{L}$ is positive semi-definite, admitting an eigendecomposition $\mathbf{L} = \mathbf{U} \boldsymbol{\Lambda} \mathbf{U}^{T}$ where diagonal matrix $\boldsymbol{\Lambda} = \text{diag}(\lambda_1, \dots, \lambda_N)$ collects the eigenvalues and $\mathbf{U}$ is the eigenvector matrix. -Here, we consider the unweighted $\mathbf{L}$ but it also holds for the weighted variants. The eigenvectors provide an orthonormal basis for the space of edge flows. Furthermore, the :doc:`Hodge decomposition ` says that the space of edge flows can be decomposed into harmonic, gradient and curl subspaces. -Moreover, :cite:t:`yang2022simplicial` showed that the eigenspace of the Hodge Laplacian can be reorganized in terms of the three Hodge subspaces as +Moreover, the eigenspace of the Hodge Laplacian can be reorganized in terms of the three Hodge subspaces as $$ \mathbf{U} = \begin{bmatrix} \mathbf{U}_{H} & \mathbf{U}_{G} & \mathbf{U}_{C} \end{bmatrix}, $$ where $\mathbf{U}_H$ is the eigenvector matrix associated to zero eigenvalues $\boldsymbol{\Lambda}_H = 0$ of $\mathbf{L}_1$, $\mathbf{U}_G$ is associated to the nonzero eigenvalues $\boldsymbol{\Lambda}_G$ of $\mathbf{L}_d$, and $\mathbf{U}_C$ is associated to the nonzero eigenvalues $\boldsymbol{\Lambda}_C$ of $\mathbf{L}_u$. That is, they span the Hodge subspaces: $$ -\mathrm{span}(\mathbf{U}_H) = \ker(\mathbf{L}_1), \quad \mathrm{span}(\mathbf{U}_G) = \mathrm{im}(\mathbf{B}_1^{\top}), \quad -\mathrm{span}(\mathbf{U}_C) = \mathrm{im}(\mathbf{B}_2) +\mathrm{span}(\mathbf{U}_H) = \ker(\mathbf{L}), \quad \mathrm{span}(\mathbf{U}_G) = \mathrm{im}(\mathbf{B}_1^{\top}) = \mathrm{im}(\mathbf{L}_d), \quad +\mathrm{span}(\mathbf{U}_C) = \mathrm{im}(\mathbf{B}_2) = \mathrm{im}(\mathbf{L}_u) $$ where $\mathrm{span}(\bullet)$ denotes all possible linear combinations of columns of $\bullet$. diff --git a/docs/theory/hodge.rst b/docs/theory/hodge.rst index a33a838b..426fb65e 100644 --- a/docs/theory/hodge.rst +++ b/docs/theory/hodge.rst @@ -1,6 +1,6 @@ -#################### +##################### Hodge Decomposition -#################### +##################### In a simplicial 2-complex, for an edge flow $\mathbf{f}$, we have the following discrete operations to measure its variational properties: From 1eaba14c391e8994dba0ea343db4af6058779e6a Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Thu, 19 Dec 2024 17:12:04 +0100 Subject: [PATCH 27/30] Solving Python 3.8 issues with scipy sparse arrays --- geometric_kernels/spaces/graph_edges.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 4cf9ff28..618eb4a7 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -5,9 +5,10 @@ import lab as B import numpy as np from beartype.typing import Dict, List, Optional, Tuple, Union -from scipy.sparse import csr_array, lil_array, sparray, spmatrix +from scipy.sparse import csr_matrix, lil_matrix from geometric_kernels.lab_extras import ( + SparseArray, count_nonzero, dtype_integer, eigenpairs, @@ -153,7 +154,7 @@ def __init__( oriented_triangles: Optional[B.Int], *, checks_mode: str = "simple", - index: Optional[csr_array] = None, + index: Optional[csr_matrix] = None, ): if checks_mode not in ["simple", "comprehensive", "skip"]: raise ValueError( @@ -196,7 +197,7 @@ def __str__(self): return f"GraphEdges({self.num_edges})" @staticmethod - def _compute_index(num_nodes: int, oriented_edges: B.Numeric) -> csr_array: + def _compute_index(num_nodes: int, oriented_edges: B.Numeric) -> csr_matrix: """ Construct the index matrix from the oriented edges. @@ -207,10 +208,10 @@ def _compute_index(num_nodes: int, oriented_edges: B.Numeric) -> csr_array: The oriented edges array. :return: - The index matrix. A scipy csr_array of shape [num_nodes, num_nodes] such + The index matrix. A scipy csr_matrix of shape [num_nodes, num_nodes] such that `index[i, j]` is the index of the edge `(i, j)`. """ - result = lil_array((num_nodes, num_nodes), dtype=int) + result = lil_matrix((num_nodes, num_nodes), dtype=int) for i in range(oriented_edges.shape[0]): result[oriented_edges[i, 0], oriented_edges[i, 1]] = i + 1 result[oriented_edges[i, 1], oriented_edges[i, 0]] = -i - 1 @@ -347,7 +348,7 @@ def _checks_compatible( resolved_edges[2, 1] == resolved_edges[0, 0] ), "The edges in the triangle must be connected." - def _check_index(self, index: csr_array): + def _check_index(self, index: csr_matrix): edges = [] for e in range(1, self.oriented_edges.shape[0] + 1): i, j = self.oriented_edges[e - 1, :] @@ -415,7 +416,7 @@ def resolve_triangles(self, ts: B.Int) -> B.Int: @classmethod def from_adjacency( # noqa: C901 cls, - adjacency_matrix: Union[B.NPNumeric, sparray, spmatrix], + adjacency_matrix: Union[B.NPNumeric, SparseArray], type_reference: B.RandomState, *, triangles: Optional[List[Tuple[int, int, int]]] = None, @@ -444,9 +445,9 @@ def from_adjacency( # noqa: C901 A constructed instance of the GraphEdges space. """ if isinstance(adjacency_matrix, np.ndarray): - index = csr_array(adjacency_matrix, dtype=int) - elif isinstance(adjacency_matrix, (sparray, spmatrix)): - index = csr_array(adjacency_matrix, dtype=int, copy=True) + index = csr_matrix(adjacency_matrix, dtype=int) + elif isinstance(adjacency_matrix, SparseArray): + index = csr_matrix(adjacency_matrix, dtype=int, copy=True) else: raise ValueError( f"The adjacency matrix must be a numpy array or a scipy sparse matrix not {type(adjacency_matrix)}. Use `type_reference` to specify the backend." From 07da52cb6a107f9c4bbde6c6c3655c66bcd567ae Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 22 Dec 2024 17:40:32 +0100 Subject: [PATCH 28/30] Fix lint --- geometric_kernels/spaces/graph_edges.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 618eb4a7..75417e35 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -4,6 +4,7 @@ import lab as B import numpy as np +from beartype.door import is_bearable from beartype.typing import Dict, List, Optional, Tuple, Union from scipy.sparse import csr_matrix, lil_matrix @@ -446,7 +447,7 @@ def from_adjacency( # noqa: C901 """ if isinstance(adjacency_matrix, np.ndarray): index = csr_matrix(adjacency_matrix, dtype=int) - elif isinstance(adjacency_matrix, SparseArray): + elif is_bearable(adjacency_matrix, SparseArray): index = csr_matrix(adjacency_matrix, dtype=int, copy=True) else: raise ValueError( From d1fc6462c2a77573314f880dff5a896b2c5e6efd Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 22 Dec 2024 23:25:59 +0100 Subject: [PATCH 29/30] Revise theory for GraphEdges space and MaternHodgeCompositionalKernel --- docs/theory/graphs.rst | 149 ++++++++++++++---- docs/theory/hodge.rst | 25 --- docs/theory/index.rst | 1 - .../kernels/hodge_compositional.py | 2 +- geometric_kernels/spaces/base.py | 2 +- geometric_kernels/spaces/graph_edges.py | 2 +- notebooks/GraphEdges.ipynb | 2 +- 7 files changed, 119 insertions(+), 64 deletions(-) delete mode 100644 docs/theory/hodge.rst diff --git a/docs/theory/graphs.rst b/docs/theory/graphs.rst index bcfc133e..664c9b62 100644 --- a/docs/theory/graphs.rst +++ b/docs/theory/graphs.rst @@ -3,7 +3,7 @@ #################### .. warning:: - You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. + You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following :doc:`this example notebook ` if you are modeling a function of nodes, or :doc:`this example notebook ` if you are modeling a function of edges. This is optional material meant to explain the basic theory and based mainly on :cite:t:`borovitskiy2021`. @@ -84,69 +84,147 @@ Edge Set of a Graph If you want to model a signal on the edges of a graph $G$, you can consider modeling the signal on the nodes of the `line graph `_. The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the `line_graph `_ function from `networkx `_. -Alternatively, especially for the **flow-type data**, you might want to use specialized edge kernels that we briefly describe below. +Alternatively, especially for the **flow-type data**, you might want to use **specialized edge kernels that we briefly describe below**. To define kernels for flow-type data on graph edges, the graph is extended to a *simplicial 2-complex*. -You can ignore the concept of a simplicial 2-complex and treat the space as a graph as GeometricKernels can automatically extend your graph to a simplicial 2-complex in a sensible way. -If you ignore the simplicial 2-complex, disregard the rest of this section as it relies on that concept. +You can ignore the concept of a simplicial 2-complex and treat the space as a graph because GeometricKernels can automatically extend your graph to a simplicial 2-complex in a sensible way. +However, if you prefer to ignore this concept, you may want to disregard the rest of this section too. Simplicial 2-complexes ---------------------- -A *simplicial 2-complex* is a collection of $N_0$ nodes, $N_1$ edges, and $N_2$ triangles such that each triangle is a subset of three nodes and each edge is a subset of two nodes. -The edges are not directed, but they are oriented [#]_. +A *simplicial 2-complex* is a collection of $N_0$ nodes, $N_1$ edges, and $N_2$ triangles such that each triangle is a triplet of nodes and each edge is a pair of nodes. +**The edges are not directed, but they are oriented** [#]_. An oriented edge, denoted as $e=[i,j]$ is an ordering of $\{i,j\}$. This is not a directed edge allowing flow only from $i$ to $j$, but rather an assignment of the sign of the flow: from $i$ to $j$ it is positive and the reverse is negative. -Same goes for oriented triangles, denoted as $t=[i,j,k]$, with +For $e=[i,j]$, we denote the same edge with reverse orientation by $-e=[j,i]$. +Same goes for oriented triangles, denoted as $t=[i,j,k]$, where $i, j, k$ are nodes, with $$ t=[i,j,k] = [j,k,i] = [k,i,j] = -[i,k,j] = -[k,j,i] = -[j,i,k] . $$ -A function $f_1:E \to \mathbb{R}$ on the edge set $E$ of a simplicial 2-complex is required to be alternating, i.e. $f_1(-e) = -f_1(e)$ for all $e \in E$. +A function $f : E \to \mathbb{R}$ on the edge set $E$ of a simplicial 2-complex is required to be **alternating**, i.e. $f(-e) = -f(e)$ for all $e \in E$. Such a function may be identified with the vector $$ -\mathbf{f}_1=[f_1(e_1),\dots,f_1(e_{N_1})]^\top\in\mathbb{R}^{N_1} +\mathbf{f}=[f(e_1),\dots,f(e_{N_1})]^\top\in\mathbb{R}^{N_1} $$ -of its values on all positively oriented edges $e_i$ which we call an **edge flow**. +of its values on all positively oriented edges $e_i$. +We call this vector an **edge flow**. + +Hodge Laplacian +--------------- Given a simplicial 2-complex, we can define the discrete **Hodge Laplacian**, which operates on the space of edge flows, as $$ \mathbf{L} = \mathbf{B}_1^\top \mathbf{B}_1 + \mathbf{B}_2 \mathbf{B}_2^\top := \mathbf{L}_{\text{d}} + \mathbf{L}_{\text{u}}, $$ where $\mathbf{B}_1$ is the *oriented* node-to-edge incidence matrix of dimension $N_0\times N_1$, and $\mathbf{B}_2$ is the *oriented* edge-to-triangle incidence matrix of dimension $N_1\times N_2$. -For every positively oriented edge $[i, j]$, we have $[ \mathbf{B}_1 ]_{i e} = 1$ and $[ \mathbf{B}_1 ]_{j e} = -1$. +For every positively oriented edge $e=[i, j]$, we have $[ \mathbf{B}_1 ]_{i e} = -1$ and $[ \mathbf{B}_1 ]_{j e} = 1$. All the other entries of $\mathbf{B}_1$ are zero. If an edge $e$ is aligned with the triangle $t$, we have $[ \mathbf{B}_2 ]_{e t} = 1$, if $-e$ is aligned with $t$, we have $[ \mathbf{B}_2 ]_{e t} = -1$. All the other entries of $\mathbf{B}_2$ are zero. The Hodge Laplacian $\mathbf{L}$ describes the connectivity of edges where the *down* part $\mathbf{L}_d$ and the *up* part $\mathbf{L}_u$ encode how edges are adjacent, respectively, through nodes and via triangles. -Matrix $\mathbf{L}$ is positive semi-definite, admitting an eigendecomposition $\mathbf{L} = \mathbf{U} \boldsymbol{\Lambda} \mathbf{U}^{T}$ where diagonal matrix $\boldsymbol{\Lambda} = \text{diag}(\lambda_1, \dots, \lambda_N)$ collects the eigenvalues and $\mathbf{U}$ is the eigenvector matrix. - -The eigenvectors provide an orthonormal basis for the space of edge flows. -Furthermore, the :doc:`Hodge decomposition ` says that the space of edge flows can be decomposed into harmonic, gradient and curl subspaces. -Moreover, the eigenspace of the Hodge Laplacian can be reorganized in terms of the three Hodge subspaces as +Matrix $\mathbf{L}$ is positive semi-definite, admitting an orthonormal basis of eigenvectors $\mathbf{f}_1, \ldots, \mathbf{f}_{N_1}$ with eigenvalues $\lambda_l$: $$ -\mathbf{U} = \begin{bmatrix} \mathbf{U}_{H} & \mathbf{U}_{G} & \mathbf{U}_{C} \end{bmatrix}, +\mathbf{L} \mathbf{f}_l = \lambda_l \mathbf{f}_l +\qquad +\lambda_l \geq 0 +. $$ -where $\mathbf{U}_H$ is the eigenvector matrix associated to zero eigenvalues $\boldsymbol{\Lambda}_H = 0$ of $\mathbf{L}_1$, $\mathbf{U}_G$ is associated to the nonzero eigenvalues $\boldsymbol{\Lambda}_G$ of $\mathbf{L}_d$, and $\mathbf{U}_C$ is associated to the nonzero eigenvalues $\boldsymbol{\Lambda}_C$ of $\mathbf{L}_u$. -That is, they span the Hodge subspaces: +The eigenvalues are assumed to be in ascending order: $\lambda_1 \leq \ldots \leq \lambda_{N_1}$. +Each $\mathbf{f}_l$ defines a function $f_l: E \to \mathbb{R}$ with $f_l(e) = \left(\mathbf{f}_l\right)_{e}$ if $e$ is positively oriented and $f_l(e) = -f_l(-e)$ otherwise. + +Matérn Karhunen–Loève Kernel +----------------------------- + +The eigenpairs $\lambda_l, f_l$ of the Hodge Laplacian can be used to define the :class:`~.kernels.MaternKarhunenLoeveKernel` on the set $E$ of graph edges. +Much like for the node set of a graph, this kernel is given by the formula $$ -\mathrm{span}(\mathbf{U}_H) = \ker(\mathbf{L}), \quad \mathrm{span}(\mathbf{U}_G) = \mathrm{im}(\mathbf{B}_1^{\top}) = \mathrm{im}(\mathbf{L}_d), \quad -\mathrm{span}(\mathbf{U}_C) = \mathrm{im}(\mathbf{B}_2) = \mathrm{im}(\mathbf{L}_u) +k_{\nu, \kappa}(e,e') +\!=\! +\frac{1}{C_{\nu, \kappa}} \sum_{l=1}^{L} \Phi_{\nu, \kappa}(\lambda_l) f_l(e) f_l(e') +\quad +\Phi_{\nu, \kappa}(\lambda) += +\begin{cases} +\left(\frac{2\nu}{\kappa^2} + \lambda\right)^{-\nu} +& +\nu < \infty \text{ — Matérn} +\\ +e^{-\frac{\kappa^2}{2} \lambda} +& +\nu = \infty \text{ — Heat (RBF)} +\end{cases} $$ -where $\mathrm{span}(\bullet)$ denotes all possible linear combinations of columns of $\bullet$. -The Hodge-compositional edge kernel is built to enable separable control on the different Hodge subspaces. -Specifically, the kernel is defined as +Where $L$ is the user-defined truncation parameter, and $C_{\nu, \kappa}$ is the normalizing constant making sure that $1/N_1 \sum k_{\nu, \kappa}(e, e) = 1$ where the summation is over all edges $e$ in positive orientation. + +Matérn Hodge Compositional Kernel +--------------------------------- + +Edge flows can be thought of as discrete analogs of vector fields. +Much like for vector fields, you can define the gradient, divergence and curl of an edge flow: $$ -\mathbf{K}_{\nu,\kappa} = \mathbf{K}_{H} + \mathbf{K}_{G} + \mathbf{K}_{C}, -\quad -\text{where} -\quad -\mathbf{K}_{\Box} = \mathbf{U}_{\Box} \Phi_{\Box}(\boldsymbol{\Lambda}_{\Box}) \mathbf{U}_{\Box}^\top -$$ -for $\Box = H,G,C$, with $\Phi_{\Box}(\boldsymbol{\Lambda}_{\Box})$ having diagonal entries +\begin{aligned} +\operatorname{div} \mathbf{f} &= \mathbf{B}_1 \mathbf{f}, +&& +\mathbf{f} \in \mathbb{R}^{N_1}, +&& +\operatorname{div} \mathbf{f} \in \mathbb{R}^{N_0}, +\\ +\operatorname{curl} \mathbf{f} &= \mathbf{B}_2^{\top} \mathbf{f}, +&& +\mathbf{f} \in \mathbb{R}^{N_1}, +&& +\operatorname{curl} \mathbf{f} \in \mathbb{R}^{N_2}. +\end{aligned} +$$ +We can also define the gradient $\operatorname{grad}$, that takes a node function ($\mathbb{R}^{N_0}$ vector) returning an edge flow, and the curl-adjoint $\operatorname{curl}^*$, that takes a triangle function ($\mathbb{R}^{N_2}$ vector) returning an edge flow: +$$ +\begin{aligned} +\operatorname{grad} \mathbf{g} &= \mathbf{B}_1^{\top} \mathbf{g}, +&& +\mathbf{g} \in \mathbb{R}^{N_0}, +&& +\operatorname{grad} \mathbf{g} \in \mathbb{R}^{N_1}, +\\ +\operatorname{curl}^* \mathbf{h} &= \mathbf{B}_2 \mathbf{h}, +&& +\mathbf{h} \in \mathbb{R}^{N_2}, +&& +\operatorname{curl}^* \mathbf{h} \in \mathbb{R}^{N_1}. +\end{aligned} +$$ +In some applications, only divergence-free or curl-free flows are of interest. +The **Hodge decomposition** provides a way to decompose edge flows into gradient (curl-free), curl-adjoint (divergence-free), and harmonic (curl-free and divergence-free at the same time) components. +The curl-adjoint component we typically just call the curl component. +It motivates the :class:`~.kernels.MaternHodgeCompositionalKernel` kernel, which is the underlying kernel for the :class:`~.kernels.MaternGeometricKernel` on the :class:`~.spaces.GraphEdges` space. + +Hodge decomposition implies that eigenvectors of the Hodge Laplacian can be chosen in such a way that they form three groups. + +- The eigenvectors from the first group are denoted by $f_l^H$ and called harmonic. + They satisfy $\mathbf{L} f_l^H = \operatorname{div} f_l^H = \operatorname{curl} f_l^H = 0$, corresponding to $\lambda_l^H = 0$ eigenvalues of the Hodge Laplacian $\mathbf{L}$. +- The eigenvectors from the second group are denoted by $f_l^G$ and called gradient. + They are curl-free: $\operatorname{curl} f_l^G = 0$, corresponding to nonzero eigenvalues $\lambda_l^G$ of the down Laplacian $\mathbf{L}_d$. +- The eigenvectors from the third group are denoted by $f_l^C$ and called curl(-adjoint). + They are divergence-free: $\operatorname{div} f_l^C = 0$, corresponding to nonzero eigenvalues $\lambda_l^C$ of the up Laplacian $\mathbf{L}_u$. + +The Hodge-compositional kernel is built to enable separable control on the different Hodge subspaces. +For the truncation parameter $L$, one obtains $L$ eigenpairs of the Hodge Laplacian corresponding to the lowest eigenvalues. +Of them, $L_H$ are associated with zero eigenvalues, $L_G$ with nonzero eigenvalues of the down Laplacian, and $L_C$ with nonzero eigenvalues of the up Laplacian. +The kernel has three vector hyperparameters: $\mathbf{\nu} = (\nu_H, \nu_G, \nu_C)$; $\mathbf{\kappa} = (\kappa_H, \kappa_G, \kappa_C)$; and $\mathbf{\alpha} = (\alpha_H, \alpha_G, \alpha_C)$. +It is given by the formula +$$ +k_{\mathbf{\nu}, \mathbf{\kappa}, \mathbf{\alpha}}(e,e') +\propto +\sum_{\Box \in {H,G,C}} +\alpha_{\Box} +\sum_{l=1}^{L_{\Box}} \Phi_{\nu_{\Box}, \kappa_{\Box}}(\lambda_l^{\Box}) f_l^{\Box}(e) f_l^{\Box}(e') +$$ +where the proportionality constant is chosen to ensure that the average variance is equal to $1$. +We have $$ \Phi_{\Box}({\lambda}_{\Box}) = @@ -162,11 +240,14 @@ e^{-\frac{\kappa_{\Box}^2}{2} \lambda_{\Box}} \text{ — Heat (RBF)} \end{cases} $$ +Each of the inner sums is a kernel whose range lies only in one Hodge subspace. -That is, each $\mathbf{K}_{\Box}$ encodes the covariance between edge functions *individually* for the three Hodge subspaces and the three sub-kernels do not share hyperparameters. - +- By setting $\alpha_{\Box} = 0$, you can effectively "turn off" the corresponding subspace. +- By using equal $\nu_{\Box}$ and $\kappa_{\Box}$ for all $\Box$ and choosing appropriate $\alpha_{\Box}$, you can recover the Matérn Karhunen–Loève kernel, which is a special case of the Hodge-compositional Matérn kernel. [#]_ +- You can also automatically infer $\mathbf{\alpha}$ from data. .. rubric:: Footnotes .. [#] The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel` and :class:`~.Eigenfunctions` classes. -.. [#] The orientation of a general simplex is an equivalence class of permutations of its labels. Two orientations are equivalent (respectively, opposite) if they differ by an even (respectively, odd) permutation :cite:p:`lim2020hodge`. \ No newline at end of file +.. [#] The orientation of a general simplex is an equivalence class of permutations of its labels. Two orientations are equivalent (respectively, opposite) if they differ by an even (respectively, odd) permutation. +.. [#] Although the formula on this page recovers the Matérn Karhunen–Loève kernel for $\alpha_H = \alpha_G = \alpha_C = 1$, the implementation is a bit different because of normalization considerations. \ No newline at end of file diff --git a/docs/theory/hodge.rst b/docs/theory/hodge.rst deleted file mode 100644 index 426fb65e..00000000 --- a/docs/theory/hodge.rst +++ /dev/null @@ -1,25 +0,0 @@ -##################### - Hodge Decomposition -##################### - -In a simplicial 2-complex, for an edge flow $\mathbf{f}$, we have the following discrete operations to measure its variational properties: - -* The *divergence* operation: $\mathbf{B}_1 \mathbf{f}$, which measures the netflow of edge flows passing through each node. A divergence-free flow has zero netflow at each node, indicating that the in-flow and out-flow are balanced. - -* The *curl* operation: $\mathbf{B}_2^\top \mathbf{f}$, which measures the circulation of edge flows around each triangle. A curl-free flow has zero circulation around each triangle, indicating that the flow is irrotational. - -For a node function $\mathbf{f}_0$, we have the *gradient* operation: $\mathbf{B}_1^\top \mathbf{f}_0$, which measures the change in the function value along each edge. A gradient-free function has zero change in value along each edge, indicating that the function is constant along each edge. - -Given a simplicial 2-complex, the space of edge flows $\mathbb{R}^N_1$ is a direct sum of three subspaces -$$ -\mathbb{R}^{N_1} = \text{im}(\mathbf{B}_1^\top) \oplus \ker(\mathbf{L}) \oplus \text{im}(\mathbf{B}_2), -$$ -where $\text{im}(\mathbf{B}_1^\top)$ is the *gradient* space, $\ker(\mathbf{L})$ is the *harmonic* space, and $\text{im}(\mathbf{B}_2)$ is the *curl* space. - -It states that any edge flow is composed of three orthogonal components: a gradient component, a harmonic component, and a curl component. - -* The gradient component is the flow that is induced by a node function, which is curl-free. - -* The curl component is the flow that is induced by a triangle function, which is divergence-free. - -* The harmonic component is the flow that is divergence-free and curl-free. diff --git a/docs/theory/index.rst b/docs/theory/index.rst index 82900ebe..71916b75 100644 --- a/docs/theory/index.rst +++ b/docs/theory/index.rst @@ -14,4 +14,3 @@ Product kernels Feature maps and sampling Hypercube graph space - Hodge Decomposition diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py index d35034d7..1180c67d 100644 --- a/geometric_kernels/kernels/hodge_compositional.py +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -43,7 +43,7 @@ class MaternHodgeCompositionalKernel(BaseGeometricKernel): .. note:: A brief introduction into the theory behind :class:`~.kernels.MaternHodgeCompositionalKernel` can be found in - :doc:`this ` documentation page. + :doc:`this ` documentation page. :param space: The space to define the kernel upon, a subclass of :class:`~.spaces.HodgeDiscreteSpectrumSpace`. diff --git a/geometric_kernels/spaces/base.py b/geometric_kernels/spaces/base.py index 7a2909b1..95954350 100644 --- a/geometric_kernels/spaces/base.py +++ b/geometric_kernels/spaces/base.py @@ -169,7 +169,7 @@ class HodgeDiscreteSpectrumSpace(DiscreteSpectrumSpace): of compact Riemannian manifolds. .. note:: - Hodge decomposition is briefly discussed on :doc:`this ` + Hodge decomposition is briefly discussed on :doc:`this ` documentation page. .. note:: diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py index 75417e35..5df4c39d 100644 --- a/geometric_kernels/spaces/graph_edges.py +++ b/geometric_kernels/spaces/graph_edges.py @@ -59,7 +59,7 @@ class GraphEdges(HodgeDiscreteSpectrumSpace): the functions satisfying the condition f(e) = -f(-e) are called 1-cochains. These admit a Hodge decomposition into the harmonic, gradient, and curl parts. You can find more about Hodge decomposition - on :doc:`this page `. + on :doc:`this page `. .. admonition:: Construction diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index 298e59f8..b85e895f 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -410,7 +410,7 @@ "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", "\n", "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html).\n", - "For graph edges specifically, the *Hodge decomposition* plays a key role, which is briefly discussed on [another documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hodge.html)." + "For graph edges specifically, the *Hodge decomposition* plays a key role, which is briefly discussed on the same documentation page." ] }, { From 49532ba0a83e6c03e615a4978bbee80b069ee5e7 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Mon, 27 Jan 2025 19:26:47 +0100 Subject: [PATCH 30/30] Update notebooks/GraphEdges.ipynb based on the review --- notebooks/GraphEdges.ipynb | 74 ++++++++++++++++++++++++++++++-------- 1 file changed, 60 insertions(+), 14 deletions(-) diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb index b85e895f..f77bbdc5 100644 --- a/notebooks/GraphEdges.ipynb +++ b/notebooks/GraphEdges.ipynb @@ -200,7 +200,7 @@ "metadata": {}, "outputs": [], "source": [ - "type_reference = np.random.RandomState()\n", + "type_reference = np.random.RandomState() # defines the backend, never used for random number generation\n", "# \"nodelist=...\" below allows us to preserve the node labels we've used to create the graph\n", "adj_matrix = nx.to_numpy_array(nx_graph, nodelist=range(nx_graph.number_of_nodes()))\n", "\n", @@ -331,7 +331,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now, if we visualize the space, it will look like this:" + "Now, if we visualize the space, it will look differently. (Notice that the triangle composed of nodes (1, 2, 3) is now missing)" ] }, { @@ -446,7 +446,8 @@ "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", "\n", "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", - "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant.\n", + "An example of this can be found in [frontends/GPyTorch.ipynb](https://geometric-kernels.github.io/GeometricKernels/examples/frontends/GPyTorch.html), where we use `gpytorch.kernels.ScaleKernel` for this." ] }, { @@ -564,13 +565,58 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we evaluate the two kernel matrices." + "In the following cell, we highlight the sampled edges in green." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sampled_edges_nx = set()\n", + "for u, v in graph_edges.resolve_edges(xs.squeeze()):\n", + " sampled_edges_nx.update([(u, v), (v, u)])\n", + "edge_color = ['green' if x in sampled_edges_nx else 'black' for x in nx_graph.edges]\n", + "\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options, edge_color=edge_color)\n", + "\n", + "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.num_triangles))\n", + "for t in range(graph_edges.num_triangles):\n", + " i, j, k = triangles[t, :]\n", + " plt.fill(\n", + " [pos[i][0], pos[j][0], pos[k][0]],\n", + " [pos[i][1], pos[j][1], pos[k][1]],\n", + " \"gray\",\n", + " alpha=0.25\n", + " ) \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", @@ -586,7 +632,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -645,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -671,7 +717,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -688,7 +734,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -708,7 +754,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -785,7 +831,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -840,7 +886,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -868,7 +914,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -927,7 +973,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -967,7 +1013,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": {}, "outputs": [ {