{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Implementing new CVs via subclassing\n", "\n", "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/luigibonati/mlcolvar/blob/main/docs/notebooks/tutorials/adv_newcv_subclass.ipynb)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "In this tutorial we illustrate how to implement a new CV starting from one of the existing one. This reflects the situation when one wants to implement a variation of a CV by adding, for instance, a term in the loss function. \n", "\n", "We will consider the specific case of EncoderMap, which is a method which combines an autoencoder, optimized with the reconstruction loss, with the sketch-map loss regularizing the latent space." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Setup" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Colab setup\n", "import os\n", "\n", "if os.getenv(\"COLAB_RELEASE_TAG\"):\n", " import subprocess\n", " subprocess.run('wget https://raw.githubusercontent.com/luigibonati/mlcolvar/main/colab_setup.sh', shell=True)\n", " cmd = subprocess.run('bash colab_setup.sh TUTORIAL', shell=True, stdout=subprocess.PIPE)\n", " print(cmd.stdout.decode('utf-8'))\n", " \n", "import mlcolvar\n", "import torch\n", "from torch import nn\n", "import lightning\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "# IMPORT HELPER FUNCTIONS\n", "from mlcolvar.utils.plot import muller_brown_potential, plot_isolines_2D, plot_metrics\n", "\n", "# Set seed for reproducibility\n", "torch.manual_seed(42)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Implementing EncoderMap CV" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Sketch-map loss function" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Sketch-map is a multidimensional scaling-like algorithm that aims to preserve the structural similarity, i.e. to reproduce in low-dimensional space the pairwise distances between points in the high-dimensional space\n", "$$\n", "\\ell_{SketchMap}(\\mathbf{x},\\mathbf{s}) =\\mathbb{E} \\left[ \\left(\\sigma(||\\textbf{x}_i-\\textbf{x}_j||) - \\sigma(||\\textbf{s}_i-\\textbf{s}_j||)\\right)^2 \\right]\n", "$$\n", "where the expectation value is over all possible pairwise distances between inputs $i$ and $j$. The pairwise distances are first transformed into sigmoid functions $\\sigma$, with parameters $(x_0, a, b)$ chosen in order to focus on intermediate distances:\n", "$$ \\sigma_{x_0, a, b}(x) = 1 -\\left[1+ ( 2^{a/b}-1) \\left(\\frac{x}{x_0}\\right) ^a \\right]^{-b/a}$$" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We first create a new `SketchMapLoss` class, which in the costructror takes the dictionaries containing the sigmoid parameters (both high and low dimensional space). The forward method computes the the cost function, first computing the pairwise distances and evaluating the equation above." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def sigmoid(x,sigma,a,b):\n", " return 1 - (1+(2**(a/b) -1)*( x/sigma)) **(-b/a)\n", "\n", "class SketchMapLoss(torch.nn.Module):\n", " \"\"\"Sketch-map loss function\"\"\"\n", "\n", " def __init__(self, high_dim_params = None, low_dim_params = None, **kwargs) -> None:\n", " \"\"\"Constructor.\n", "\n", " Parameters\n", " ----------\n", " high_dim_params : dict, optional\n", " parameters for sigmoid acting on high-dim data, by default dict(sigma=0.75, a=12, b=6)\n", " low_dim_params : dict, optional\n", " parameters for sigmoid acting on low-dim data, by default dict(sigma=1, a=2, b=6)\n", " \"\"\"\n", " super().__init__(**kwargs)\n", " \n", " # Parameters for sigmoid functions (default values)\n", " self.high_dim_params = high_dim_params if high_dim_params is not None else dict(sigma=0.75, a=12, b=6)\n", " self.low_dim_params = low_dim_params if low_dim_params is not None else dict(sigma=1, a=2, b=6)\n", "\n", " def forward(self, X : torch.Tensor , s : torch.Tensor) -> torch.Tensor:\n", " \"\"\"Compute\n", "\n", " Parameters\n", " ----------\n", " X : torch.Tensor\n", " high-dim points\n", " s : torch.Tensor\n", " low-dim points\n", "\n", " Returns\n", " -------\n", " torch.Tensor\n", " scalar loss \n", " \"\"\"\n", "\n", " # compute pairwise distances\n", " X_ij = torch.cdist(X,X)\n", " s_ij = torch.cdist(s,s)\n", " n_dist = (X.shape[0]-1)**2\n", "\n", " # compute sketch-map cost\n", " loss = 1/n_dist * torch.sum( ( sigmoid(X_ij, **self.high_dim_params ) - sigmoid(s_ij, **self.low_dim_params ) )**2 ) \n", "\n", " return loss" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Defining the CV" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We can now define an `EncoderMap` CV by subclassing the `AutoEncoderCV` class. This allows us to retain all of the methods already implemented for the autoencoder and just add the sketch-map loss. \n", "\n", "**init**\n", "\n", "The constructor, besides the usual arguments of `AutoEncoderCV` which are repeated for convenience, takes the following arguments:\n", "- `losses_ratio` which set the relative weighting of the sketch-map/reconstruction loss.\n", "- `high_dim_params` and `low_dim_params` which set the parameters of the sigmoid functions in the high/low dimensional spaces\n", "\n", "An instance of the SketchMapLoss is saved into `sketchmap_fn`, which allows us to modify the sigmoid default parameters after initialization.\n", "\n", "**training_step**\n", "\n", "Here we first compute a complete pass of the network (encoder+decoder) to evaluate the reconstruction loss. This is done by calling the method of the `super` class. \n", "Then we evaluate the sketch map loss based on the inputs as well as the latent space and sum them. " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from mlcolvar.cvs import AutoEncoderCV\n", "\n", "class EncoderMap(AutoEncoderCV):\n", " \n", " def __init__(self, encoder_layers: list, decoder_layers: list = None, \n", " losses_ratio : float = 100, \n", " high_dim_params: dict = None,\n", " low_dim_params: dict = None,\n", " options: dict = None, **kwargs):\n", " \n", " \"\"\"EncoderMap CV built from an AutoEncoderCV, optimized with both reconstruction and\n", " sketch-map losses.\n", "\n", " Parameters\n", " ----------\n", " losses_ratio : float, optional\n", " ratio of sketch-map vs MSE loss, by default 100\n", " high_dim_params : dict, optional\n", " dictionary of sigmoid parameters (input space)\n", " low_dim_params: dict, optional\n", " dictionary of sigmoid parameters (latent space)\n", "\n", " See also\n", " --------\n", " mlcolvar.cvs.AutoEncoderCV\n", "\n", " \"\"\"\n", " super().__init__(encoder_layers=encoder_layers, decoder_layers=decoder_layers, options=options, **kwargs)\n", "\n", " # LOSS FUNCTIONS\n", " # Note: Autoencoder has MSE as primary loss, i.e., self.loss_fn = MSELoss()\n", " # here we add also the sketch-map loss (params can be set by changing its members)\n", " self.sketchmap_fn = SketchMapLoss()\n", "\n", " # PARAMETERS\n", " self.losses_ratio = losses_ratio\n", "\n", " def training_step(self, train_batch, batch_idx):\n", " \"\"\"Training step\"\"\"\n", " # 1) this computes reconstruction loss\n", " rec_loss = super().training_step(train_batch, batch_idx)\n", "\n", " # 2) compute sketch-map loss\n", " X = train_batch['data']\n", " s = self.forward_cv(X)\n", " sketchmap_loss = self.sketchmap_fn(X,s)\n", "\n", " # 3) sum them to get total loss\n", " loss = rec_loss + self.losses_ratio * sketchmap_loss\n", "\n", " # log metrics\n", " name = 'train' if self.training else 'valid' \n", " self.log(f'{name}_sketchmap_loss', loss, on_epoch=True)\n", " self.log(f'{name}_total_loss', loss, on_epoch=True)\n", " return loss " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "That's it! Now we can simply use it" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Test the new CV" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Load modified Muller-Brown 3 states data" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Class 0 dataframe shape: (5001, 12)\n", "\n", " - Loaded dataframe (5001, 12): ['time', 'p.x', 'p.y', 'p.z', 'ene', 'pot.bias', 'pot.ene_bias', 'lwall.bias', 'lwall.force2', 'uwall.bias', 'uwall.force2', 'walker']\n", " - Descriptors (5001, 2): ['p.x', 'p.y']\n" ] } ], "source": [ "from mlcolvar.utils.io import create_dataset_from_files\n", "from mlcolvar.data import DictModule\n", "\n", "dataset = create_dataset_from_files(\"data/muller-brown-3states/unbiased/high-temp/COLVAR\",filter_args=dict(regex='p.x|p.y') )\n", "datamodule = DictModule(dataset)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "To choose the value for sigma we can compute an histogram of the distances, here we use 0.2. \n", "Please refer to the sketch-map/encodermap literature for how to select the parameters." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGdCAYAAAD+JxxnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAyrElEQVR4nO3de3BUZZ7G8SeJdMKtOwOYWxEExQEilywBQnsbGCOtRkvWWAtqQcQgC5VQkoxcMkNF0amJg6uAwyU7645hd2QFdgYciQZjEKiBABrIctGklMEJFnRAJd0QJYHk7B9WztAQIB1y7fP9VJ0qu8+vT95+PXY/vuc9bwcZhmEIAADAgoI7ugEAAAAdhSAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAEAAAsiyAEAAAs66aObkBn1tDQoBMnTqh3794KCgrq6OYAAIBmMAxDZ8+eVUxMjIKDrz3mQxC6hhMnTig2NrajmwEAAFrg+PHj6t+//zVrCELX0Lt3b0k/dqTdbu/g1gAAgObwer2KjY01v8evhSB0DY2Xw+x2O0EIAIAupjnTWpgsDQAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALIsgBAAALOumjm4AWt/ARQVXPPfVK8kd0BIAADo3ghCADnV5cCe0A2hPXBoDAACWRRACAACWxaUxAJ0Kc9wAtCdGhAAAgGUxIhQAmvo/aAAAcH1+jQitWbNGI0eOlN1ul91ul9Pp1AcffGDunzBhgoKCgny22bNn+xyjsrJSycnJ6tGjhyIiIjR//nxdvHjRp2b79u0aPXq0QkNDNXjwYOXn51/RllWrVmngwIEKCwtTYmKi9u3b57P//PnzSk9PV9++fdWrVy+lpKSoqqrKn7cLAAACnF8jQv3799crr7yi22+/XYZhaO3atXr00Ud14MAB3XHHHZKkZ599Vi+99JL5mh49epj/XF9fr+TkZEVFRWn37t06efKkpk+frm7duuk3v/mNJOnYsWNKTk7W7Nmz9fbbb6u4uFgzZ85UdHS0XC6XJGn9+vXKyspSXl6eEhMTtXz5crlcLlVUVCgiIkKSlJmZqYKCAm3cuFEOh0MZGRl67LHHtGvXrhvrMQAtxuglgM4myDAM40YO0KdPH7366qtKS0vThAkTFB8fr+XLlzdZ+8EHH+jhhx/WiRMnFBkZKUnKy8vTwoULdfr0adlsNi1cuFAFBQU6fPiw+bqpU6equrpahYWFkqTExESNHTtWK1eulCQ1NDQoNjZWc+fO1aJFi+TxeHTzzTdr3bp1evzxxyVJ5eXlGjZsmEpKSjR+/PhmvTev1yuHwyGPxyO73d7SLmpzzflyYbIpOoOWBiHOXwD+8Of7u8WTpevr6/XOO++opqZGTqfTfP7tt99Wv379NHz4cGVnZ+v7778395WUlGjEiBFmCJIkl8slr9erI0eOmDVJSUk+f8vlcqmkpESSVFdXp9LSUp+a4OBgJSUlmTWlpaW6cOGCT83QoUM1YMAAswYAAMDvydKHDh2S0+nU+fPn1atXL23atElxcXGSpCeffFK33HKLYmJidPDgQS1cuFAVFRX685//LElyu90+IUiS+djtdl+zxuv16ocfftCZM2dUX1/fZE15ebl5DJvNpvDw8CtqGv9OU2pra1VbW2s+9nq9ze2WTo/VewEAuJLfQWjIkCEqKyuTx+PR//7v/yo1NVU7duxQXFycZs2aZdaNGDFC0dHRuu+++3T06FHddtttrdrwtpCbm6slS5Z0dDMAAEA78fvSmM1m0+DBg5WQkKDc3FyNGjVKK1asaLI2MTFRkvTll19KkqKioq64c6vxcVRU1DVr7Ha7unfvrn79+ikkJKTJmkuPUVdXp+rq6qvWNCU7O1sej8fcjh8/fq2uAAAAXdwNL6jY0NDgcznpUmVlZZKk6OhoSZLT6dShQ4d06tQps6aoqEh2u928vOZ0OlVcXOxznKKiInMeks1mU0JCgk9NQ0ODiouLzZqEhAR169bNp6aiokKVlZU+85kuFxoaai4N0LgBAIDA5delsezsbD344IMaMGCAzp49q3Xr1mn79u3aunWrjh49qnXr1umhhx5S3759dfDgQWVmZuree+/VyJEjJUmTJk1SXFycpk2bpqVLl8rtdmvx4sVKT09XaGioJGn27NlauXKlFixYoGeeeUbbtm3Thg0bVFDwjzkuWVlZSk1N1ZgxYzRu3DgtX75cNTU1mjFjhiTJ4XAoLS1NWVlZ6tOnj+x2u+bOnSun09nsO8YAdB7McQPQVvwKQqdOndL06dN18uRJORwOjRw5Ulu3btX999+v48eP66OPPjJDSWxsrFJSUrR48WLz9SEhIdqyZYvmzJkjp9Opnj17KjU11WfdoUGDBqmgoECZmZlasWKF+vfvrzfffNNcQ0iSpkyZotOnTysnJ0dut1vx8fEqLCz0mUC9bNkyBQcHKyUlRbW1tXK5XFq9evWN9BUAAAgwN7yOUCALpHWELsf/UaMjtNaCipy/AK6lXdYRAgAA6OoIQgAAwLIIQgAAwLL8XlARAJqLH1kF0NkxIgQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLBRUtqqmF7vghSwCA1TAiBAAALIsgBAAALItLY10Mv90EAEDrYUQIAABYFkEIAABYFpfGAHQ53PUIoLUwIgQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLdYQAtAp+/gVAV8SIEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCwWVITp8gXxvnoluYNaAgBA+2BECAAAWBZBCAAAWJZfQWjNmjUaOXKk7Ha77Ha7nE6nPvjgA3P/+fPnlZ6err59+6pXr15KSUlRVVWVzzEqKyuVnJysHj16KCIiQvPnz9fFixd9arZv367Ro0crNDRUgwcPVn5+/hVtWbVqlQYOHKiwsDAlJiZq3759Pvub0xYAAGBtfgWh/v3765VXXlFpaak+/fRT/fznP9ejjz6qI0eOSJIyMzP13nvvaePGjdqxY4dOnDihxx57zHx9fX29kpOTVVdXp927d2vt2rXKz89XTk6OWXPs2DElJydr4sSJKisr07x58zRz5kxt3brVrFm/fr2ysrL0wgsvaP/+/Ro1apRcLpdOnTpl1lyvLQAAAEGGYRg3coA+ffro1Vdf1eOPP66bb75Z69at0+OPPy5JKi8v17Bhw1RSUqLx48frgw8+0MMPP6wTJ04oMjJSkpSXl6eFCxfq9OnTstlsWrhwoQoKCnT48GHzb0ydOlXV1dUqLCyUJCUmJmrs2LFauXKlJKmhoUGxsbGaO3euFi1aJI/Hc922NIfX65XD4ZDH45Hdbr+Rbmo17fkL30yWhj86+tfnOV8BNPLn+7vFc4Tq6+v1zjvvqKamRk6nU6Wlpbpw4YKSkpLMmqFDh2rAgAEqKSmRJJWUlGjEiBFmCJIkl8slr9drjiqVlJT4HKOxpvEYdXV1Ki0t9akJDg5WUlKSWdOctjSltrZWXq/XZwMAAIHL7yB06NAh9erVS6GhoZo9e7Y2bdqkuLg4ud1u2Ww2hYeH+9RHRkbK7XZLktxut08IatzfuO9aNV6vVz/88IO++eYb1dfXN1lz6TGu15am5ObmyuFwmFtsbGzzOgUAAHRJfgehIUOGqKysTHv37tWcOXOUmpqqzz77rC3a1u6ys7Pl8XjM7fjx4x3dJAAA0Ib8XlDRZrNp8ODBkqSEhAR98sknWrFihaZMmaK6ujpVV1f7jMRUVVUpKipKkhQVFXXF3V2Nd3JdWnP53V1VVVWy2+3q3r27QkJCFBIS0mTNpce4XluaEhoaqtDQUD96AwAAdGU3vI5QQ0ODamtrlZCQoG7duqm4uNjcV1FRocrKSjmdTkmS0+nUoUOHfO7uKioqkt1uV1xcnFlz6TEaaxqPYbPZlJCQ4FPT0NCg4uJis6Y5bQEQWAYuKvDZAKA5/BoRys7O1oMPPqgBAwbo7NmzWrdunbZv366tW7fK4XAoLS1NWVlZ6tOnj+x2u+bOnSun02nepTVp0iTFxcVp2rRpWrp0qdxutxYvXqz09HRzJGb27NlauXKlFixYoGeeeUbbtm3Thg0bVFDwjw+2rKwspaamasyYMRo3bpyWL1+umpoazZgxQ5Ka1RYAAAC/gtCpU6c0ffp0nTx5Ug6HQyNHjtTWrVt1//33S5KWLVum4OBgpaSkqLa2Vi6XS6tXrzZfHxISoi1btmjOnDlyOp3q2bOnUlNT9dJLL5k1gwYNUkFBgTIzM7VixQr1799fb775plwul1kzZcoUnT59Wjk5OXK73YqPj1dhYaHPBOrrtQUAAOCG1xEKZKwjxLosaL7OdjmK8xewrnZZRwgAAKCr8/uuMQCQOt8IEAC0BCNCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAsghCAADAslhHCFfV1DoxrNYLAAgkjAgBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADLIggBAADL4tfnO7mmfgEeAAC0DkaEAACAZRGEAACAZRGEAACAZRGEAACAZTFZGsB1dcVJ+021+atXkjugJQA6M0aEAACAZRGEAACAZRGEAACAZRGEAACAZTFZGn65fAIqk08BAF0ZI0IAAMCyCEIAAMCyCEIAAMCyCEIAAMCy/ApCubm5Gjt2rHr37q2IiAhNnjxZFRUVPjUTJkxQUFCQzzZ79myfmsrKSiUnJ6tHjx6KiIjQ/PnzdfHiRZ+a7du3a/To0QoNDdXgwYOVn59/RXtWrVqlgQMHKiwsTImJidq3b5/P/vPnzys9PV19+/ZVr169lJKSoqqqKn/eMgAACGB+BaEdO3YoPT1de/bsUVFRkS5cuKBJkyappqbGp+7ZZ5/VyZMnzW3p0qXmvvr6eiUnJ6uurk67d+/W2rVrlZ+fr5ycHLPm2LFjSk5O1sSJE1VWVqZ58+Zp5syZ2rp1q1mzfv16ZWVl6YUXXtD+/fs1atQouVwunTp1yqzJzMzUe++9p40bN2rHjh06ceKEHnvsMb87CQAABKYgwzCMlr749OnTioiI0I4dO3TvvfdK+nFEKD4+XsuXL2/yNR988IEefvhhnThxQpGRkZKkvLw8LVy4UKdPn5bNZtPChQtVUFCgw4cPm6+bOnWqqqurVVhYKElKTEzU2LFjtXLlSklSQ0ODYmNjNXfuXC1atEgej0c333yz1q1bp8cff1ySVF5ermHDhqmkpETjx4+/7vvzer1yOBzyeDyy2+0t7aYb0tl/44nb562hs5+HzcX5CliDP9/fNzRHyOPxSJL69Onj8/zbb7+tfv36afjw4crOztb3339v7ispKdGIESPMECRJLpdLXq9XR44cMWuSkpJ8julyuVRSUiJJqqurU2lpqU9NcHCwkpKSzJrS0lJduHDBp2bo0KEaMGCAWXO52tpaeb1enw0AAASuFi+o2NDQoHnz5umuu+7S8OHDzeeffPJJ3XLLLYqJidHBgwe1cOFCVVRU6M9//rMkye12+4QgSeZjt9t9zRqv16sffvhBZ86cUX19fZM15eXl5jFsNpvCw8OvqGn8O5fLzc3VkiVL/OwJAADQVbU4CKWnp+vw4cP661//6vP8rFmzzH8eMWKEoqOjdd999+no0aO67bbbWt7SdpCdna2srCzzsdfrVWxsbAe2CAAAtKUWXRrLyMjQli1b9PHHH6t///7XrE1MTJQkffnll5KkqKioK+7canwcFRV1zRq73a7u3burX79+CgkJabLm0mPU1dWpurr6qjWXCw0Nld1u99kAAEDg8isIGYahjIwMbdq0Sdu2bdOgQYOu+5qysjJJUnR0tCTJ6XTq0KFDPnd3FRUVyW63Ky4uzqwpLi72OU5RUZGcTqckyWazKSEhwaemoaFBxcXFZk1CQoK6devmU1NRUaHKykqzBgAAWJtfl8bS09O1bt06vfvuu+rdu7c518bhcKh79+46evSo1q1bp4ceekh9+/bVwYMHlZmZqXvvvVcjR46UJE2aNElxcXGaNm2ali5dKrfbrcWLFys9PV2hoaGSpNmzZ2vlypVasGCBnnnmGW3btk0bNmxQQcE/7lzJyspSamqqxowZo3Hjxmn58uWqqanRjBkzzDalpaUpKytLffr0kd1u19y5c+V0Opt1xxgAAAh8fgWhNWvWSPrxFvlLvfXWW3r66adls9n00UcfmaEkNjZWKSkpWrx4sVkbEhKiLVu2aM6cOXI6nerZs6dSU1P10ksvmTWDBg1SQUGBMjMztWLFCvXv319vvvmmXC6XWTNlyhSdPn1aOTk5crvdio+PV2Fhoc8E6mXLlik4OFgpKSmqra2Vy+XS6tWr/eogAAAQuG5oHaFAxzpC18e6LNbQ2c/D5uJ8Bayh3dYRAgAA6MoIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLJa/FtjAAJXoNwuDwDXQxDCDWnqC5O1WgAAXQWXxgAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGURhAAAgGVx+zwAy7h8uQeWegDAiBAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALAsghAAALCsmzq6AQg8AxcVXPHcV68kd0BLAAC4NkaEAACAZRGEAACAZRGEAACAZTFHCLC4puZ0AYBVMCIEAAAsiyAEAAAsiyAEAAAsy68glJubq7Fjx6p3796KiIjQ5MmTVVFR4VNz/vx5paenq2/fvurVq5dSUlJUVVXlU1NZWank5GT16NFDERERmj9/vi5evOhTs337do0ePVqhoaEaPHiw8vPzr2jPqlWrNHDgQIWFhSkxMVH79u3zuy0AAMC6/ApCO3bsUHp6uvbs2aOioiJduHBBkyZNUk1NjVmTmZmp9957Txs3btSOHTt04sQJPfbYY+b++vp6JScnq66uTrt379batWuVn5+vnJwcs+bYsWNKTk7WxIkTVVZWpnnz5mnmzJnaunWrWbN+/XplZWXphRde0P79+zVq1Ci5XC6dOnWq2W0BAADWFmQYhtHSF58+fVoRERHasWOH7r33Xnk8Ht18881at26dHn/8cUlSeXm5hg0bppKSEo0fP14ffPCBHn74YZ04cUKRkZGSpLy8PC1cuFCnT5+WzWbTwoULVVBQoMOHD5t/a+rUqaqurlZhYaEkKTExUWPHjtXKlSslSQ0NDYqNjdXcuXO1aNGiZrXlerxerxwOhzwej+x2e0u76YYEyh09rCzdeQXKOdYSnJdAYPLn+/uG5gh5PB5JUp8+fSRJpaWlunDhgpKSksyaoUOHasCAASopKZEklZSUaMSIEWYIkiSXyyWv16sjR46YNZceo7Gm8Rh1dXUqLS31qQkODlZSUpJZ05y2AAAAa2vxOkINDQ2aN2+e7rrrLg0fPlyS5Ha7ZbPZFB4e7lMbGRkpt9tt1lwaghr3N+67Vo3X69UPP/ygM2fOqL6+vsma8vLyZrflcrW1taqtrTUfe73e63UDAADowlo8IpSenq7Dhw/rnXfeac32dKjc3Fw5HA5zi42N7egmAQCANtSiIJSRkaEtW7bo448/Vv/+/c3no6KiVFdXp+rqap/6qqoqRUVFmTWX37nV+Ph6NXa7Xd27d1e/fv0UEhLSZM2lx7heWy6XnZ0tj8djbsePH29GbwAAgK7KryBkGIYyMjK0adMmbdu2TYMGDfLZn5CQoG7duqm4uNh8rqKiQpWVlXI6nZIkp9OpQ4cO+dzdVVRUJLvdrri4OLPm0mM01jQew2azKSEhwaemoaFBxcXFZk1z2nK50NBQ2e12nw0AAAQuv+YIpaena926dXr33XfVu3dvc66Nw+FQ9+7d5XA4lJaWpqysLPXp00d2u11z586V0+k079KaNGmS4uLiNG3aNC1dulRut1uLFy9Wenq6QkNDJUmzZ8/WypUrtWDBAj3zzDPatm2bNmzYoIKCf9zdkpWVpdTUVI0ZM0bjxo3T8uXLVVNToxkzZphtul5bAACAtfkVhNasWSNJmjBhgs/zb731lp5++mlJ0rJlyxQcHKyUlBTV1tbK5XJp9erVZm1ISIi2bNmiOXPmyOl0qmfPnkpNTdVLL71k1gwaNEgFBQXKzMzUihUr1L9/f7355ptyuVxmzZQpU3T69Gnl5OTI7XYrPj5ehYWFPhOor9cWAABgbTe0jlCgYx2h1sN6LZ1XoJxjLcF5CQSmdltHCAAAoCtr8TpCANDVNTUaxigRYC0EIbSLy79w+LIBAHQGXBoDAACWRRACAACWRRACAACWRRACAACWRRACAACWRRACAACWRRACAACWRRACAACWRRACAACWxcrSgMVY+UdWAeByjAgBAADLIggBAADL4tJYJ8IlCwAA2hcjQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLIIQgAAwLK4fR4doqmlAr56JbkDWgIAsDJGhAAAgGURhAAAgGURhAAAgGURhAAAgGUxWRoAYHncwGFdjAgBAADLIggBAADLIggBAADLIggBAADLYrI0AMBympocDWsiCAHAJS7/guTOISCwEYQAAGgCodgamCMEAAAsixEhIIAxDwIAro0RIQAAYFl+B6GdO3fqkUceUUxMjIKCgrR582af/U8//bSCgoJ8tgceeMCn5rvvvtNTTz0lu92u8PBwpaWl6dy5cz41Bw8e1D333KOwsDDFxsZq6dKlV7Rl48aNGjp0qMLCwjRixAi9//77PvsNw1BOTo6io6PVvXt3JSUl6YsvvvD3LQMAgADldxCqqanRqFGjtGrVqqvWPPDAAzp58qS5/c///I/P/qeeekpHjhxRUVGRtmzZop07d2rWrFnmfq/Xq0mTJumWW25RaWmpXn31Vb344ov6/e9/b9bs3r1bTzzxhNLS0nTgwAFNnjxZkydP1uHDh82apUuX6o033lBeXp727t2rnj17yuVy6fz58/6+bQAAEICCDMMwWvzioCBt2rRJkydPNp97+umnVV1dfcVIUaPPP/9ccXFx+uSTTzRmzBhJUmFhoR566CF9/fXXiomJ0Zo1a/SrX/1KbrdbNptNkrRo0SJt3rxZ5eXlkqQpU6aopqZGW7ZsMY89fvx4xcfHKy8vT4ZhKCYmRr/4xS/0/PPPS5I8Ho8iIyOVn5+vqVOnXvf9eb1eORwOeTwe2e32lnSRX5jP4Ys7NG4c59SN4zwMTC35b4Nzoevw5/u7TeYIbd++XRERERoyZIjmzJmjb7/91txXUlKi8PBwMwRJUlJSkoKDg7V3716z5t577zVDkCS5XC5VVFTozJkzZk1SUpLP33W5XCopKZEkHTt2TG6326fG4XAoMTHRrLlcbW2tvF6vzwYAAAJXqwehBx54QP/1X/+l4uJi/fa3v9WOHTv04IMPqr6+XpLkdrsVERHh85qbbrpJffr0kdvtNmsiIyN9ahofX6/m0v2Xvq6pmsvl5ubK4XCYW2xsrN/vHwAAdB2tfvv8pZecRowYoZEjR+q2227T9u3bdd9997X2n2tV2dnZysrKMh97vV7CEAAAAazNb5+/9dZb1a9fP3355ZeSpKioKJ06dcqn5uLFi/ruu+8UFRVl1lRVVfnUND6+Xs2l+y99XVM1lwsNDZXdbvfZAABA4GrzIPT111/r22+/VXR0tCTJ6XSqurpapaWlZs22bdvU0NCgxMREs2bnzp26cOGCWVNUVKQhQ4boJz/5iVlTXFzs87eKiorkdDolSYMGDVJUVJRPjdfr1d69e80aAABgbX4HoXPnzqmsrExlZWWSfpyUXFZWpsrKSp07d07z58/Xnj179NVXX6m4uFiPPvqoBg8eLJfLJUkaNmyYHnjgAT377LPat2+fdu3apYyMDE2dOlUxMTGSpCeffFI2m01paWk6cuSI1q9frxUrVvhctnruuedUWFio1157TeXl5XrxxRf16aefKiMjQ9KPd7TNmzdPv/71r/WXv/xFhw4d0vTp0xUTE+NzlxsAALAuv+cIffrpp5o4caL5uDGcpKamas2aNTp48KDWrl2r6upqxcTEaNKkSXr55ZcVGhpqvubtt99WRkaG7rvvPgUHByslJUVvvPGGud/hcOjDDz9Uenq6EhIS1K9fP+Xk5PisNXTnnXdq3bp1Wrx4sX75y1/q9ttv1+bNmzV8+HCzZsGCBaqpqdGsWbNUXV2tu+++W4WFhQoLC/P3bQMAgAB0Q+sIBTrWEepYrNlx4zinbhznYWBiHaHA5s/3Nz+6CgAIaPwPAa6FH10FAACWRRACAACWRRACAACWRRACAACWxWRpAACaoalJ19xJ1vUxIgQAACyLESF0WvzfFwCgrTEiBAAALIsRISCAsHAcAPiHESEAAGBZBCEAAGBZXBoDgGtg0j4Q2BgRAgAAlkUQAgAAlkUQAgAAlkUQAgAAlkUQAgAAlkUQAgAAlkUQAgAAlkUQAgAAlkUQAgAAlsXK0uhSLl/llxV+AQA3ghEhAABgWQQhAABgWVwaAwAElKZ+KBe4GkaEAACAZRGEAACAZRGEAACAZTFHCOiimAcBADeOESEAAGBZBCEAAGBZXBoDAKCFWO2+62NECAAAWBZBCAAAWBaXxtClNXXnFEPTAIDmYkQIAABYFkEIAABYlt9BaOfOnXrkkUcUExOjoKAgbd682We/YRjKyclRdHS0unfvrqSkJH3xxRc+Nd99952eeuop2e12hYeHKy0tTefOnfOpOXjwoO655x6FhYUpNjZWS5cuvaItGzdu1NChQxUWFqYRI0bo/fff97stAADAuvwOQjU1NRo1apRWrVrV5P6lS5fqjTfeUF5envbu3auePXvK5XLp/PnzZs1TTz2lI0eOqKioSFu2bNHOnTs1a9Ysc7/X69WkSZN0yy23qLS0VK+++qpefPFF/f73vzdrdu/erSeeeEJpaWk6cOCAJk+erMmTJ+vw4cN+tQUA/DVwUYHPBqDrCjIMw2jxi4OCtGnTJk2ePFnSjyMwMTEx+sUvfqHnn39ekuTxeBQZGan8/HxNnTpVn3/+ueLi4vTJJ59ozJgxkqTCwkI99NBD+vrrrxUTE6M1a9boV7/6ldxut2w2myRp0aJF2rx5s8rLyyVJU6ZMUU1NjbZs2WK2Z/z48YqPj1deXl6z2nI9Xq9XDodDHo9Hdru9pd3UbHygtg6rTJbmfOk8rHLOdRUd+d8G50Ln4M/3d6vOETp27JjcbreSkpLM5xwOhxITE1VSUiJJKikpUXh4uBmCJCkpKUnBwcHau3evWXPvvfeaIUiSXC6XKioqdObMGbPm0r/TWNP4d5rTlsvV1tbK6/X6bAAAIHC1ahByu92SpMjISJ/nIyMjzX1ut1sRERE++2+66Sb16dPHp6apY1z6N65Wc+n+67Xlcrm5uXI4HOYWGxvbjHcNAAC6Ku4au0R2drY8Ho+5HT9+vKObBAAA2lCrBqGoqChJUlVVlc/zVVVV5r6oqCidOnXKZ//Fixf13Xff+dQ0dYxL/8bVai7df722XC40NFR2u91nAwAAgatVg9CgQYMUFRWl4uJi8zmv16u9e/fK6XRKkpxOp6qrq1VaWmrWbNu2TQ0NDUpMTDRrdu7cqQsXLpg1RUVFGjJkiH7yk5+YNZf+ncaaxr/TnLYAXQl3KgFA6/M7CJ07d05lZWUqKyuT9OOk5LKyMlVWViooKEjz5s3Tr3/9a/3lL3/RoUOHNH36dMXExJh3lg0bNkwPPPCAnn32We3bt0+7du1SRkaGpk6dqpiYGEnSk08+KZvNprS0NB05ckTr16/XihUrlJWVZbbjueeeU2FhoV577TWVl5frxRdf1KeffqqMjAxJalZbAACAtfn9W2OffvqpJk6caD5uDCepqanKz8/XggULVFNTo1mzZqm6ulp33323CgsLFRYWZr7m7bffVkZGhu677z4FBwcrJSVFb7zxhrnf4XDoww8/VHp6uhISEtSvXz/l5OT4rDV05513at26dVq8eLF++ctf6vbbb9fmzZs1fPhws6Y5bUHguXy0hNtZAQBXc0PrCAU61hEKDIEShDg/Oq9AOccCBesIocPWEQIAAOhKCEIAAMCyCEIAAMCyCEIAAMCy/L5rDACAzoKbCHCjGBECAACWRRACAACWRRACAACWxRwhBLym5hB09kXPmPcAAO2DESEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZTJYGgBvUFSfko21wLnQ9jAgBAADLIggBAADLIggBAADLYo4QLOny6/gdfQ2fBRQBoGMwIgQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyLIAQAACyL2+cBsSw+AFgVQQhoZ6wZBACdB5fGAACAZRGEAACAZXFpDADQZXBpGa2NINSB+A8aAICORRACrqK1fpiVwGtNne2HfQE0jTlCAADAsghCAADAsrg0BjRTcxZd5DIYAHQtBCHgBhB8AKBr49IYAACwLIIQAACwrFYPQi+++KKCgoJ8tqFDh5r7z58/r/T0dPXt21e9evVSSkqKqqqqfI5RWVmp5ORk9ejRQxEREZo/f74uXrzoU7N9+3aNHj1aoaGhGjx4sPLz869oy6pVqzRw4ECFhYUpMTFR+/bta+23CwAAurA2mSN0xx136KOPPvrHH7npH38mMzNTBQUF2rhxoxwOhzIyMvTYY49p165dkqT6+nolJycrKipKu3fv1smTJzV9+nR169ZNv/nNbyRJx44dU3JysmbPnq23335bxcXFmjlzpqKjo+VyuSRJ69evV1ZWlvLy8pSYmKjly5fL5XKpoqJCERERbfG2AQC4AmtKdW5tcmnspptuUlRUlLn169dPkuTxePSf//mfev311/Xzn/9cCQkJeuutt7R7927t2bNHkvThhx/qs88+0x//+EfFx8frwQcf1Msvv6xVq1aprq5OkpSXl6dBgwbptdde07Bhw5SRkaHHH39cy5YtM9vw+uuv69lnn9WMGTMUFxenvLw89ejRQ3/4wx/a4i0DAIAuqE2C0BdffKGYmBjdeuuteuqpp1RZWSlJKi0t1YULF5SUlGTWDh06VAMGDFBJSYkkqaSkRCNGjFBkZKRZ43K55PV6deTIEbPm0mM01jQeo66uTqWlpT41wcHBSkpKMmsAAABa/dJYYmKi8vPzNWTIEJ08eVJLlizRPffco8OHD8vtdstmsyk8PNznNZGRkXK73ZIkt9vtE4Ia9zfuu1aN1+vVDz/8oDNnzqi+vr7JmvLy8qu2vba2VrW1teZjr9fr35sHAABdSqsHoQcffND855EjRyoxMVG33HKLNmzYoO7du7f2n2tVubm5WrJkSUc3AwAAtJM2v30+PDxcP/3pT/Xll18qKipKdXV1qq6u9qmpqqpSVFSUJCkqKuqKu8gaH1+vxm63q3v37urXr59CQkKarGk8RlOys7Pl8XjM7fjx4y16zwAAoGto8yB07tw5HT16VNHR0UpISFC3bt1UXFxs7q+oqFBlZaWcTqckyel06tChQzp16pRZU1RUJLvdrri4OLPm0mM01jQew2azKSEhwaemoaFBxcXFZk1TQkNDZbfbfTYAABC4Wj0IPf/889qxY4e++uor7d69W//8z/+skJAQPfHEE3I4HEpLS1NWVpY+/vhjlZaWasaMGXI6nRo/frwkadKkSYqLi9O0adP0f//3f9q6dasWL16s9PR0hYaGSpJmz56tv/3tb1qwYIHKy8u1evVqbdiwQZmZmWY7srKy9B//8R9au3atPv/8c82ZM0c1NTWaMWNGa79lAADQRbX6HKGvv/5aTzzxhL799lvdfPPNuvvuu7Vnzx7dfPPNkqRly5YpODhYKSkpqq2tlcvl0urVq83Xh4SEaMuWLZozZ46cTqd69uyp1NRUvfTSS2bNoEGDVFBQoMzMTK1YsUL9+/fXm2++aa4hJElTpkzR6dOnlZOTI7fbrfj4eBUWFl4xgRoA2kNzfrQXQPsLMgzD6OhGdFZer1cOh0Mej6dNLpPxg52AtRGE/BcIn5v8e297/nx/81tjAADAstrkJzYAALhRgTD6g86PESEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZBCEAAGBZLKgIAB3k8gUD+ekFa+B35zoXRoQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlEYQAAIBlcdcYAKBTaOpuKqCtMSIEAAAsixEhAOgkWF8GaH+MCAEAAMsiCAEAAMsiCAEAAMsiCAEAAMtisjQAAB2MH+DtOAQhAOjE+IIE2haXxgAAgGUxIgQAaHesIo3OghEhAABgWQQhAABgWVwaA4AuhJ/hAFoXI0IAAMCyGBECAKCTYeSv/RCEAABtjrvE0FkRhACgi2PRRaDlmCMEAAAsiyAEAAAsi0tjABBgOnqiLfOB2gaXQNsGQQgALIAvUaBplghCq1at0quvviq3261Ro0bpd7/7ncaNG9fRzQKAgMAIELqygA9C69evV1ZWlvLy8pSYmKjly5fL5XKpoqJCERERHd08AOgQhJeur6MvgQaKIMMwjI5uRFtKTEzU2LFjtXLlSklSQ0ODYmNjNXfuXC1atOiar/V6vXI4HPJ4PLLb7a3eNj6IAABtyarByJ/v74AeEaqrq1Npaamys7PN54KDg5WUlKSSkpIr6mtra1VbW2s+9ng8kn7s0LbQUPt9mxwXAABJGpC58YrnDi9xdUBL2lfj93ZzxnoCOgh98803qq+vV2RkpM/zkZGRKi8vv6I+NzdXS5YsueL52NjYNmsjAADtybG8o1vQfs6ePSuHw3HNmoAOQv7Kzs5WVlaW+bihoUHfffed+vbtq6CgoFb9W16vV7GxsTp+/HibXHazKvq1bdCvrY8+bRv0a9voav1qGIbOnj2rmJiY69YGdBDq16+fQkJCVFVV5fN8VVWVoqKirqgPDQ1VaGioz3Ph4eFt2UTZ7fYucVJ1NfRr26BfWx992jbo17bRlfr1eiNBjQJ6ZWmbzaaEhAQVFxebzzU0NKi4uFhOp7MDWwYAADqDgB4RkqSsrCylpqZqzJgxGjdunJYvX66amhrNmDGjo5sGAAA6WMAHoSlTpuj06dPKycmR2+1WfHy8CgsLr5hA3d5CQ0P1wgsvXHEpDjeGfm0b9Gvro0/bBv3aNgK5XwN+HSEAAICrCeg5QgAAANdCEAIAAJZFEAIAAJZFEAIAAJZFEGpDq1at0sCBAxUWFqbExETt27fvmvUbN27U0KFDFRYWphEjRuj9999vp5Z2Lf70a35+voKCgny2sLCwdmxt57dz50498sgjiomJUVBQkDZv3nzd12zfvl2jR49WaGioBg8erPz8/DZvZ1fjb79u3779inM1KChIbre7fRrcBeTm5mrs2LHq3bu3IiIiNHnyZFVUVFz3dXy2XltL+jWQPlsJQm1k/fr1ysrK0gsvvKD9+/dr1KhRcrlcOnXqVJP1u3fv1hNPPKG0tDQdOHBAkydP1uTJk3X48OF2bnnn5m+/Sj+uhHry5Elz+/vf/96OLe78ampqNGrUKK1atapZ9ceOHVNycrImTpyosrIyzZs3TzNnztTWrVvbuKVdi7/92qiiosLnfI2IiGijFnY9O3bsUHp6uvbs2aOioiJduHBBkyZNUk1NzVVfw2fr9bWkX6UA+mw10CbGjRtnpKenm4/r6+uNmJgYIzc3t8n6f/mXfzGSk5N9nktMTDT+9V//tU3b2dX4269vvfWW4XA42ql1XZ8kY9OmTdesWbBggXHHHXf4PDdlyhTD5XK1Ycu6tub068cff2xIMs6cOdMubQoEp06dMiQZO3bsuGoNn63+a06/BtJnKyNCbaCurk6lpaVKSkoynwsODlZSUpJKSkqafE1JSYlPvSS5XK6r1ltRS/pVks6dO6dbbrlFsbGxevTRR3XkyJH2aG7A4lxtW/Hx8YqOjtb999+vXbt2dXRzOjWPxyNJ6tOnz1VrOF/915x+lQLns5Ug1Aa++eYb1dfXX7F6dWRk5FWv97vdbr/qragl/TpkyBD94Q9/0Lvvvqs//vGPamho0J133qmvv/66PZockK52rnq9Xv3www8d1KquLzo6Wnl5efrTn/6kP/3pT4qNjdWECRO0f//+jm5ap9TQ0KB58+bprrvu0vDhw69ax2erf5rbr4H02RrwP7EBa3M6nT4/sHvnnXdq2LBh+vd//3e9/PLLHdgywNeQIUM0ZMgQ8/Gdd96po0ePatmyZfrv//7vDmxZ55Senq7Dhw/rr3/9a0c3JaA0t18D6bOVEaE20K9fP4WEhKiqqsrn+aqqKkVFRTX5mqioKL/qragl/Xq5bt266Z/+6Z/05ZdftkUTLeFq56rdblf37t07qFWBady4cZyrTcjIyNCWLVv08ccfq3///tes5bO1+fzp18t15c9WglAbsNlsSkhIUHFxsflcQ0ODiouLfRL0pZxOp0+9JBUVFV213opa0q+Xq6+v16FDhxQdHd1WzQx4nKvtp6ysjHP1EoZhKCMjQ5s2bdK2bds0aNCg676G8/X6WtKvl+vSn60dPVs7UL3zzjtGaGiokZ+fb3z22WfGrFmzjPDwcMPtdhuGYRjTpk0zFi1aZNbv2rXLuOmmm4x/+7d/Mz7//HPjhRdeMLp162YcOnSoo95Cp+Rvvy5ZssTYunWrcfToUaO0tNSYOnWqERYWZhw5cqSj3kKnc/bsWePAgQPGgQMHDEnG66+/bhw4cMD4+9//bhiGYSxatMiYNm2aWf+3v/3N6NGjhzF//nzj888/N1atWmWEhIQYhYWFHfUWOiV/+3XZsmXG5s2bjS+++MI4dOiQ8dxzzxnBwcHGRx991FFvodOZM2eO4XA4jO3btxsnT540t++//96s4bPVfy3p10D6bCUItaHf/e53xoABAwybzWaMGzfO2LNnj7nvZz/7mZGamupTv2HDBuOnP/2pYbPZjDvuuMMoKCho5xZ3Df7067x588zayMhI46GHHjL279/fAa3uvBpv2758a+zH1NRU42c/+9kVr4mPjzdsNptx6623Gm+99Va7t7uz87dff/vb3xq33XabERYWZvTp08eYMGGCsW3bto5pfCfVVH9K8jn/+Gz1X0v6NZA+W4MMwzDab/wJAACg82COEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsCyCEAAAsKz/B2Zw9avDuqSpAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "X = dataset['data']\n", "X_ij = torch.cdist(X,X)\n", "\n", "ind = torch.triu_indices(X_ij.shape[0], X_ij.shape[1], offset=1)\n", "dist = X_ij[ind[0],ind[1]].numpy()\n", "\n", "plt.hist(dist,bins=100)\n", "plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Define the CV and optimize it" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "/home/lbonati@iit.local/software/anaconda3/envs/pytorch2.0/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", " warning_cache.warn(\n", "/home/lbonati@iit.local/software/anaconda3/envs/pytorch2.0/lib/python3.10/site-packages/lightning/pytorch/loops/utilities.py:70: PossibleUserWarning: `max_epochs` was not set. Setting it to 1000 epochs. To train without an epoch limit, set `max_epochs=-1`.\n", " rank_zero_warn(\n", "You are using a CUDA device ('NVIDIA GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params | In sizes | Out sizes\n", "----------------------------------------------------------------------\n", "0 | loss_fn | MSELoss | 0 | ? | ? \n", "1 | norm_in | Normalization | 0 | [2] | [2] \n", "2 | encoder | FeedForward | 162 | [2] | [2] \n", "3 | decoder | FeedForward | 162 | ? | ? \n", "4 | sketchmap_fn | SketchMapLoss | 0 | ? | ? \n", "----------------------------------------------------------------------\n", "324 Trainable params\n", "0 Non-trainable params\n", "324 Total params\n", "0.001 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " " ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/lbonati@iit.local/software/anaconda3/envs/pytorch2.0/lib/python3.10/site-packages/lightning/pytorch/loops/fit_loop.py:280: PossibleUserWarning: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n", " rank_zero_warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch 214: 100%|██████████| 1/1 [00:00<00:00, 44.38it/s, v_num=48] \n" ] } ], "source": [ "from lightning.pytorch.callbacks.early_stopping import EarlyStopping\n", "from mlcolvar.utils.trainer import MetricsCallback\n", "\n", "# define model and set sketch-map parameters\n", "nn_kwargs = dict(activation='shifted_softplus')\n", "options = {'encoder': nn_kwargs, 'decoder':nn_kwargs }\n", "\n", "model = EncoderMap( encoder_layers=[2,10,10,2],\n", " losses_ratio = 100,\n", " high_dim_params = dict(sigma=0.2, a=6, b=6),\n", " low_dim_params = dict(sigma=1.00, a=3, b=6),\n", " options=options ) \n", "\n", "# define callbacks and trainer\n", "metrics = MetricsCallback()\n", "early_stopping = EarlyStopping(monitor=\"valid_loss\", mode='min', min_delta=1e-3, patience=20)\n", "trainer = lightning.Trainer(callbacks=[metrics,early_stopping],\n", " max_epochs=None, logger=None, enable_checkpointing=False)\n", "\n", "# fit\n", "trainer.fit( model, datamodule )" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We can also monitor the learning curves" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "model.eval()\n", "\n", "keys = [k for k in metrics.metrics.keys() if 'valid' in k]\n", "\n", "ax = plot_metrics(metrics.metrics, \n", " keys=keys,\n", " linestyles=['--' for _ in keys],\n", " yscale='log')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "n_components = 1\n", "\n", "fig,axs = plt.subplots( 1, n_components, figsize=(5*n_components,4) )\n", "if n_components == 1:\n", " axs = [axs]\n", "for i in range(n_components):\n", " ax = axs[i]\n", " plot_isolines_2D(muller_brown_potential,levels=np.linspace(0,24,12),mode='contour',ax=ax)\n", " plot_isolines_2D(model, component=i, levels=25, ax=ax)\n", " plot_isolines_2D(model, component=i, mode='contour', levels=25, ax=ax)" ] } ], "metadata": { "kernelspec": { "display_name": "pytorch", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.10" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "1cbeac1d7079eaeba64f3210ccac5ee24400128e300a45ae35eee837885b08b3" } } }, "nbformat": 4, "nbformat_minor": 2 }