From 7a848ec306097f71c5dd617a2d2565ab1716397c Mon Sep 17 00:00:00 2001 From: Samuel Burbulla Date: Fri, 1 Mar 2024 16:27:22 +0100 Subject: [PATCH 1/4] Add stopping criteria. --- src/continuity/trainer/callbacks.py | 44 +++++++++++++------------- src/continuity/trainer/criterion.py | 48 +++++++++++++++++++++++++++++ src/continuity/trainer/logs.py | 21 +++++++++++++ src/continuity/trainer/trainer.py | 38 ++++++++++++++++------- tests/trainer/test_trainer.py | 11 +++---- 5 files changed, 122 insertions(+), 40 deletions(-) create mode 100644 src/continuity/trainer/criterion.py create mode 100644 src/continuity/trainer/logs.py diff --git a/src/continuity/trainer/callbacks.py b/src/continuity/trainer/callbacks.py index 322e83cc..adb411f5 100644 --- a/src/continuity/trainer/callbacks.py +++ b/src/continuity/trainer/callbacks.py @@ -5,8 +5,9 @@ """ from abc import ABC, abstractmethod -from typing import Optional, List, Dict +from typing import Optional, List import matplotlib.pyplot as plt +from .logs import Logs class Callback(ABC): @@ -15,13 +16,12 @@ class Callback(ABC): """ @abstractmethod - def __call__(self, epoch, logs: Dict[str, float]): + def __call__(self, logs: Logs): """Callback function. Called at the end of each epoch. Args: - epoch: Current epoch. - logs: Dictionary of logs. + logs: Training logs. """ raise NotImplementedError @@ -42,20 +42,17 @@ class PrintTrainingLoss(Callback): def __init__(self): super().__init__() - def __call__(self, epoch: int, logs: Dict[str, float]): + def __call__(self, logs: Logs): """Callback function. Called at the end of each epoch. Args: - epoch: Current epoch. - logs: Dictionary of logs. + logs: Training logs. """ - loss_train = logs["loss/train"] - seconds_per_epoch = logs["seconds_per_epoch"] - print( - f"\rEpoch {epoch}: loss/train = {loss_train:.4e} " - f"({seconds_per_epoch:.3g} s/epoch)", + f"\rEpoch {logs.epoch}: " + f"loss/train = {logs.loss_train:.4e} " + f"({logs.seconds_per_epoch:.3f} s/epoch)", end="", ) @@ -72,28 +69,30 @@ class LearningCurve(Callback): Callback to plot learning curve. Args: - keys: List of keys to plot. Default is ["loss/train"]. + keys: List of keys to plot. Default is ["loss_train"]. """ def __init__(self, keys: Optional[List[str]] = None): if keys is None: - keys = ["loss/train"] + keys = ["loss_train"] self.keys = keys self.on_train_begin() super().__init__() - def __call__(self, epoch: int, logs: Dict[str, float]): + def __call__(self, logs: Logs): """Callback function. Called at the end of each epoch. Args: - epoch: Current epoch. - logs: Dictionary of logs. + logs: Training logs. """ for key in self.keys: - if key in logs: - self.losses[key].append(logs[key]) + try: + val = logs.__getattribute__(key) + self.losses[key].append(val) + except AttributeError: + pass def on_train_begin(self): """Called at the beginning of training.""" @@ -125,15 +124,14 @@ def __init__(self, trial): self.trial = trial super().__init__() - def __call__(self, epoch: int, logs: Dict[str, float]): + def __call__(self, logs: Logs): """Callback function. Called at the end of each epoch. Args: - epoch: Current epoch. - logs: Dictionary of logs. + logs: Training logs. """ - self.trial.report(logs["loss/train"], step=epoch) + self.trial.report(logs.loss_train, step=logs.epoch) def on_train_begin(self): """Called at the beginning of training.""" diff --git a/src/continuity/trainer/criterion.py b/src/continuity/trainer/criterion.py new file mode 100644 index 00000000..899050ff --- /dev/null +++ b/src/continuity/trainer/criterion.py @@ -0,0 +1,48 @@ +""" +`continuity.trainer.criterion` + +Stopping criterion for Trainer in Continuity. +""" + +from abc import ABC, abstractmethod +from .logs import Logs + + +class Criterion(ABC): + """ + Stopping criterion base class for `fit` method of `Trainer`. + """ + + @abstractmethod + def __call__(self, logs: Logs): + """Evaluate stopping criterion. + Called at the end of each epoch. + + Args: + logs: Training logs. + + Returns: + bool: Whether to stop training. + """ + raise NotImplementedError + + +class TrainingLossCriterion(Criterion): + """ + Stopping criterion based on training loss. + """ + + def __init__(self, threshold: float): + self.threshold = threshold + + def __call__(self, logs: Logs): + """Callback function. + Called at the end of each epoch. + + Args: + logs: Training logs. + + Returns: + bool: True if training loss is below threshold. + """ + return logs.loss_train < self.threshold diff --git a/src/continuity/trainer/logs.py b/src/continuity/trainer/logs.py new file mode 100644 index 00000000..5a639459 --- /dev/null +++ b/src/continuity/trainer/logs.py @@ -0,0 +1,21 @@ +""" +`continuity.trainer.logs` +""" + +from dataclasses import dataclass + + +@dataclass +class Logs: + """ + Logs for callbacks and criteria within Trainer in Continuity. + + Attributes: + epoch: Current epoch. + loss_train: Training loss. + time: Time taken for epoch. + """ + + epoch: int + loss_train: float + seconds_per_epoch: float diff --git a/src/continuity/trainer/trainer.py b/src/continuity/trainer/trainer.py index 5bd3ab59..6ef1dc5e 100644 --- a/src/continuity/trainer/trainer.py +++ b/src/continuity/trainer/trainer.py @@ -12,8 +12,10 @@ from continuity.data import OperatorDataset from continuity.operators import Operator from continuity.operators.losses import Loss, MSELoss -from continuity.trainer.callbacks import Callback, PrintTrainingLoss from continuity.trainer.device import get_device +from .callbacks import Callback, PrintTrainingLoss +from .criterion import Criterion, TrainingLossCriterion +from .logs import Logs class Trainer: @@ -27,12 +29,12 @@ class Trainer: optimizer = torch.optim.Adam(operator.parameters(), lr=1e-3) loss_fn = MSELoss() trainer = Trainer(operator, optimizer, loss_fn, device="cuda:0") - trainer.fit(data_loader, epochs=100) + trainer.fit(dataset, tol=1e-3, epochs=1000) ``` Args: operator: Operator to be trained. - optimizer: Torch-like optimizer. Default is Adam. + optimizer: Torch-like optimizer. Default is Adam with learning rate 1e-3. loss_fn: Loss function taking (op, x, u, y, v). Default is MSELoss. device: Device to train on. Default is CPU. verbose: Print model parameters and use PrintTrainingLoss callback by default. Default is True. @@ -62,8 +64,10 @@ def __init__( def fit( self, dataset: OperatorDataset, - epochs: int = 100, + tol: float = 1e-5, + epochs: int = 1000, callbacks: Optional[List[Callback]] = None, + criterion: Optional[Criterion] = None, batch_size: int = 32, shuffle: bool = True, ): @@ -71,8 +75,10 @@ def fit( Args: dataset: Data set. - epochs: Number of epochs. - callbacks: List of callbacks. + tol: Tolerance for stopping criterion. Ignored if criterion is not None. + epochs: Maximum number of epochs. + callbacks: List of callbacks. Defaults to [PrintTrainingLoss] if verbose. + criterion: Stopping criterion. Defaults to TrainingLossCriteria(tol). batch_size: Batch size. shuffle: Shuffle data set. """ @@ -83,6 +89,10 @@ def fit( else: callbacks = [] + # Default criterion + if criterion is None: + criterion = TrainingLossCriterion(tol) + # Print number of model parameters if self.verbose: num_params = sum(p.numel() for p in self.operator.parameters()) @@ -142,13 +152,19 @@ def closure(x=x, u=u, y=y, v=v): loss_train /= len(data_loader) # Callbacks - logs = { - "loss/train": loss_train, - "seconds_per_epoch": seconds_per_epoch, - } + logs = Logs( + epoch=epoch + 1, + loss_train=loss_train, + seconds_per_epoch=seconds_per_epoch, + ) for callback in callbacks: - callback(epoch + 1, logs) + callback(logs) + + # Stopping criterion + if criterion is not None: + if criterion(logs): + break # Call on_train_end for callback in callbacks: diff --git a/tests/trainer/test_trainer.py b/tests/trainer/test_trainer.py index 50a7d22f..7ec500d7 100644 --- a/tests/trainer/test_trainer.py +++ b/tests/trainer/test_trainer.py @@ -6,15 +6,14 @@ def train(): dataset = Sine(num_sensors=32, size=256) - operator = DeepONet(dataset.shapes) + operator = DeepONet(dataset.shapes, trunk_depth=16) - trainer = Trainer(operator) - trainer.fit(dataset, epochs=100) + Trainer(operator).fit(dataset, tol=1e-3) # Make sure we can use operator output on cpu again - x, u, y, v = dataset[0] - v_pred = operator(x.unsqueeze(0), u.unsqueeze(0), y.unsqueeze(0)).squeeze(0) - assert ((v_pred - v.to("cpu")) ** 2).mean() < 0.1 + x, u, y, v = dataset.x, dataset.u, dataset.y, dataset.v + v_pred = operator(x, u, y) + assert ((v_pred - v.to("cpu")) ** 2).mean() < 1e-3 @pytest.mark.slow From 5fd31c6e787d8331c202f6ef44d649f3a14797bd Mon Sep 17 00:00:00 2001 From: Samuel Burbulla Date: Fri, 1 Mar 2024 16:53:29 +0100 Subject: [PATCH 2/4] Speed up all operator tests. --- tests/operators/test_belnet.py | 24 +++++------------------- tests/operators/test_deeponet.py | 18 +++--------------- tests/operators/test_neuraloperator.py | 17 +++-------------- tests/test_optuna.py | 16 +++++++++------- 4 files changed, 20 insertions(+), 55 deletions(-) diff --git a/tests/operators/test_belnet.py b/tests/operators/test_belnet.py index b1389076..9f4cf606 100644 --- a/tests/operators/test_belnet.py +++ b/tests/operators/test_belnet.py @@ -1,8 +1,6 @@ import torch -import matplotlib.pyplot as plt import pytest -from continuity.plotting import plot, plot_evaluation from continuity.operators import BelNet from continuity.data import OperatorDataset from continuity.data.sine import OperatorDataset, Sine @@ -52,26 +50,14 @@ def test_belnet(): dataset = Sine(num_sensors, size=1) # Operator - operator = BelNet( - dataset.shapes, - ) - - # Train self-supervised - optimizer = torch.optim.Adam(operator.parameters(), lr=1e-3) - trainer = Trainer(operator, optimizer) - trainer.fit(dataset, epochs=1000, batch_size=1, shuffle=True) + operator = BelNet(dataset.shapes) - # Plotting - fig, ax = plt.subplots(1, 1) - x, u, _, _ = dataset[0] - plot(x, u, ax=ax) - plot_evaluation(operator, x, u, ax=ax) - fig.savefig(f"test_belnet.png") + # Train + Trainer(operator).fit(dataset, tol=1e-3, batch_size=1) # Check solution - x = x.unsqueeze(0) - u = u.unsqueeze(0) - assert MSELoss()(operator, x, u, x, u) < 1e-2 + x, u = dataset.x, dataset.u + assert MSELoss()(operator, x, u, x, u) < 1e-3 if __name__ == "__main__": diff --git a/tests/operators/test_deeponet.py b/tests/operators/test_deeponet.py index ba1d35ef..3c25c488 100644 --- a/tests/operators/test_deeponet.py +++ b/tests/operators/test_deeponet.py @@ -1,8 +1,6 @@ import torch -import matplotlib.pyplot as plt import pytest -from continuity.plotting import plot, plot_evaluation from continuity.operators import DeepONet from continuity.data import OperatorDataset from continuity.data.sine import Sine @@ -61,21 +59,11 @@ def test_deeponet(): basis_functions=4, ) - # Train self-supervised - optimizer = torch.optim.Adam(operator.parameters(), lr=1e-3) - trainer = Trainer(operator, optimizer) - trainer.fit(dataset, epochs=1000, batch_size=1, shuffle=True) - - # Plotting - fig, ax = plt.subplots(1, 1) - x, u, _, _ = dataset[0] - plot(x, u, ax=ax) - plot_evaluation(operator, x, u, ax=ax) - fig.savefig(f"test_deeponet.png") + # Train + Trainer(operator).fit(dataset, tol=1e-3, batch_size=1) # Check solution - x = x.unsqueeze(0) - u = u.unsqueeze(0) + x, u = dataset.x, dataset.u assert MSELoss()(operator, x, u, x, u) < 1e-3 diff --git a/tests/operators/test_neuraloperator.py b/tests/operators/test_neuraloperator.py index a02a729c..8c7f1338 100644 --- a/tests/operators/test_neuraloperator.py +++ b/tests/operators/test_neuraloperator.py @@ -1,9 +1,7 @@ import pytest import torch -import matplotlib.pyplot as plt from continuity.data.sine import Sine from continuity.operators import NeuralOperator -from continuity.plotting import plot, plot_evaluation from continuity.trainer import Trainer from continuity.operators.losses import MSELoss @@ -24,21 +22,12 @@ def test_neuraloperator(): kernel_depth=3, ) - # Train self-supervised + # Train optimizer = torch.optim.Adam(operator.parameters(), lr=1e-2) - trainer = Trainer(operator, optimizer) - trainer.fit(dataset, epochs=400) - - # Plotting - fig, ax = plt.subplots(1, 1) - x, u, _, _ = dataset[0] - plot(x, u, ax=ax) - plot_evaluation(operator, x, u, ax=ax) - fig.savefig(f"test_neuraloperator.png") + Trainer(operator, optimizer).fit(dataset, tol=1e-3) # Check solution - x = x.unsqueeze(0) - u = u.unsqueeze(0) + x, u = dataset.x, dataset.u assert MSELoss()(operator, x, u, x, u) < 1e-3 diff --git a/tests/test_optuna.py b/tests/test_optuna.py index e60d7775..6d7f0262 100644 --- a/tests/test_optuna.py +++ b/tests/test_optuna.py @@ -2,7 +2,7 @@ import torch from continuity.benchmarks.sine import SineBenchmark from continuity.trainer import Trainer -from continuity.trainer.callbacks import OptunaCallback +from continuity.trainer.callbacks import OptunaCallback, PrintTrainingLoss from continuity.data import split, dataset_loss from continuity.operators import DeepONet import optuna @@ -11,9 +11,8 @@ @pytest.mark.slow def test_optuna(): def objective(trial): - trunk_width = trial.suggest_int("trunk_width", 4, 16) - trunk_depth = trial.suggest_int("trunk_depth", 4, 16) - num_epochs = trial.suggest_int("num_epochs", 1, 10) + trunk_width = trial.suggest_int("trunk_width", 32, 64) + trunk_depth = trial.suggest_int("trunk_depth", 4, 8) lr = trial.suggest_float("lr", 1e-4, 1e-3) # Data set @@ -32,8 +31,12 @@ def objective(trial): # Optimizer optimizer = torch.optim.Adam(operator.parameters(), lr=lr) - trainer = Trainer(operator, optimizer, verbose=False) - trainer.fit(train_dataset, epochs=num_epochs, callbacks=[OptunaCallback(trial)]) + trainer = Trainer(operator, optimizer) + trainer.fit( + train_dataset, + tol=1e-2, + callbacks=[PrintTrainingLoss(), OptunaCallback(trial)], + ) loss_val = dataset_loss(val_dataset, operator, benchmark.metric()) print(f"loss/val: {loss_val:.4e}") @@ -45,7 +48,6 @@ def objective(trial): study = optuna.create_study( direction="minimize", study_name=name, - storage=f"sqlite:///{name}.db", load_if_exists=True, ) study.optimize(objective, n_trials=3) From 2159303f165501f357dfc4bc5428f7bff8c1a24a Mon Sep 17 00:00:00 2001 From: Samuel Burbulla Date: Fri, 1 Mar 2024 17:08:52 +0100 Subject: [PATCH 3/4] Remove plotting everywhere else. --- examples/selfsupervised.ipynb | 26 ++++---- src/continuity/__init__.py | 4 -- src/continuity/plotting/__init__.py | 9 --- src/continuity/plotting/plot.py | 89 -------------------------- tests/data/test_dataset.py | 7 -- tests/operators/test_integralkernel.py | 8 --- 6 files changed, 15 insertions(+), 128 deletions(-) delete mode 100644 src/continuity/plotting/__init__.py delete mode 100644 src/continuity/plotting/plot.py diff --git a/examples/selfsupervised.ipynb b/examples/selfsupervised.ipynb index 8653cfa4..31bf15aa 100644 --- a/examples/selfsupervised.ipynb +++ b/examples/selfsupervised.ipynb @@ -35,7 +35,6 @@ "from continuity.data.sine import Sine\n", "from continuity.data.selfsupervised import SelfSupervisedOperatorDataset\n", "from continuity.operators.integralkernel import NaiveIntegralKernel, NeuralNetworkKernel\n", - "from continuity.plotting import plot_evaluation, plot\n", "from continuity.trainer import Trainer" ] }, @@ -183,8 +182,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Model parameters: 165633\n", - "Epoch 100: loss/train = 4.4726e-03 (0.577 s/epoch)\n" + "Model parameters: 149121\n", + "Device: mps\n", + "Epoch 100: loss/train = 3.9671e-03 (0.543 s/epoch)\n" ] } ], @@ -205,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2024-02-14T14:16:34.861630744Z", @@ -218,7 +218,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -233,8 +233,10 @@ "fig, axs = plt.subplots(1, 4, figsize=(16, 3))\n", "for i in range(size):\n", " x, u = sine.x[i], sine.u[i]\n", - " plot_evaluation(operator, x, u, ax=axs[i]) \n", - " plot(x, u, ax=axs[i])\n", + " y = torch.linspace(-1, 1, 100).reshape(-1, 1)\n", + " v = operator(x.unsqueeze(0), u.unsqueeze(0), y.unsqueeze(0)).squeeze(0).detach()\n", + " axs[i].plot(y, v, 'k-', label='Prediction')\n", + " axs[i].plot(x, u, 'g.', label='Sensors')\n", " axs[i].set_title(f\"$k = {i}$\")" ] }, @@ -249,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2024-02-14T14:16:35.104424737Z", @@ -262,7 +264,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEpCAYAAABssbJEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxl0lEQVR4nO3deZxcVZn/8c83YZOlE8MWIISwRNYgm2ETTFjCvgqCMEo0Ao44DuIGP0eSBp2goxhnmFE2QZRNUPYlghJ2wr7JviQQIECApNkSIHl+f5xz05Veq7rr1qm69bxfr+JyK/d2PV1d/fS55z7nHJkZzjnnimFA6gCcc85Vjyd155wrEE/qzjlXIJ7UnXOuQDypO+dcgXhSd865AvGk7pxzBeJJ3TnnCsSTunPOFYgndVdYklaUtEjSd1PH4lyteFJ3RbYZIODxWr1g/EPSKulGSW9LMknjyzx3TDy+q8d2OYfuCmKp1AE4l6NRcftYDV9zFeBk4CXgEWBMH77GfwP3dXjuuf6F5ZqFJ3VXZKOAOWY2u4av+RqwhpnNlrQNnZNzOW43s8urHJdrEt794opsFPDP0ickHS3pI0lTJA2s9gua2YJq/BGRtJIkb3S5ivmHxhXZKOBigJggpwDHAMeZ2dmlB0paGhhU5td928wWVTHOjs4DVgQWSrod+IGZ3Z/j67kC8aTuCknSGsDKwOOShgCXAVsA48xsWhen7AjcUuaXXxeY0f8oO/kI+AtwPTAH2AT4PnC7pB3M7KEcXtMVjCd1V1Sbx60R+rU/ArY1s+5uOD4C7F7m186lj97M7gLuKnnqakmXA48Ck4E983hdVyye1F1RZZUvZwD3A3ub2dzuDjazd4CbaxBXRczsOUlXAQdLGmhmC1PH5OqbJ3VXVKOAmcDzhHr1FYG53R0saRlgSJlf+80aJ9eXgWWAFYC2Gr6ua0Ce1F1RjQIeBo4mtNSvkLSTmc3v5vgdSN+n3p31gPnAezV8TdegPKm7womlihsD15nZm5IOBu4Afgt8rZvTatqnLml5YDihjn5OfG5VM3uzw3GfBfYHbsi54sYVhCd1V0QjgeWII0nN7AFJ/wqcJ+kBMzuj4wnV7FOX9G1gMLBmfGo/ScPi//+Pmc0DRhOuDFqBSfHfLpX0IeFm6RuE6pdjgA+AE6sRmys+T+quiLKbpIvnfDGz8yV9Djhd0qNmdluOr/99YJ2S/YPjA+BPwLxuzrsSOBI4AWgB3gT+CrT2ULXj3BJkZqljcM45VyU+TYBzzhWIJ3XnnCsQT+rOOVcgntSdc65APKk751yBeFJ3zrkCKVyduiQRBn28mzoW55yropWAV62XOvTCJXVCQp+VOgjnnMvBMOCVng4oYlLPWujD8Na6c64YViI0VnvNaUVM6pl3zcynKXXONbzQq1wev1HqnHMF4kndOecKxJO6c84ViCd155wrEE/qzjlXIJ7UnXOuQDypO9fkJK0uaWNVUjfn6lauSV3SzpKukfSqJJN0YBnnjJH0oKQFkp6TND7PGJ1rFpIGStpQ0kaSNpC0l6S/EkYoPgE8I6lV0oi0kbr+yHvw0QqEVdp/T1hrsUeS1gWuA35HWKtxV+AcSa+Z2dQ8A1WrhhEWLH7WJppPM+AKIba+dwO+BOwPrNbNoR8BGwAnAydI2snMHq5JkK6qarZGqSQDDjKzK3s45ufAPma2WclzlwCDzWzPMl+nhbCw76ByR5SqVROAswhXLouAY2yinVvOuc7VM0knApNLnvoAmE9o0H0AXMpormYHluUq1udFxgNbE4akjzaz12ods+uskrxWb33q2wM3d3huany+S5KWldSSPQhzJJQtttCzhE7cnhmfd65hSdqZFn7GCGBV/gyMIzSQVjazQWa2BpN4jL25icFcz1H8hu9zPvAUYe6kqyUtn+47cH1Rb0l9KPB6h+deB1okfaqbc04i/AXLHpV2nYyk8/swkHAp6lxDkrQq23AVxzOA8cC3OIRJDDezjxcf01WDZkWm8Hm+AbwFbANcJqmihpJLq96Sel9MBgaVPCptYT9L6HIptRB4rv+hOVd7kgYwhEvZm8GLf8PV5RVo1w2a3VgaOAhYAOwN3CNpZO6Bu6qot6Q+G1i9w3OrA21m9mFXJ5jZAjNryx5UON1uvCl6DCGRE7fHZjdLJX06VgwIQutGrRrr3TOujv0/WhjbxW93xyvQbhs0ZnY7MBZ4FdgEuE/SHvmE66qp3pL63YSKl1K7x+dzE2+KjiB8iEdkN0ljaddjhD7GF7SbbsKYCfwDmBlvsDpXN2LiPYW3AaNjFcQSV6C9NWjM7G7CTdM7CVfBV0sal+934Por1+oXSSvS3jJ4CDgBuAV428xekjQZWMvMvhqPXxd4HPhfQhnkLsB/Eypiyipp7Ev1SzdfZw3gdmB9AFqA41nyz6CxEDHCSyBdPYiNkAeAIcBZTOJe4ExCCz1L2J2quuJV5wbAc119liUtA1wMHAx8COxtZtNy+jZcFyrJa3kn9TGEJN7RH8xsvKTzgRFmNqbDOb8mXPLNAk41s/MreM1+J3VJQ4BpwChgBjCOXTiMnTm108HP8WX7o13Sl9dxrlokrQDcBmwF3AfsZGYLekvYFXz9ZQhjTfYB3gfGmtl9/Y/claNuknoKVUrqlwNfJPTxf97Mno+/HDMpbasvAqYwlzYONbOOpZjO1URMuFcDewBzgK3N7KWqvkarhvE+m3AuP+ZtdgbuBbbrbRFkVx2NXKeenKS1CHf+AfY1s+ehi/5HYyF/YwZtDAamSjoqQbiuyUkaAJxHSOgfAPvlkNAnADNZgan8G59nKz4CRsfXdHXGk3pnRxHelzvM7IHSf1jihqoYwT1sDPwhHv/fklatdbCu6f0COAL4BPiimd1TzS/eqZZdDGA/lqYFgIk+CVj98aReIrZ6soqWc7o6xibaLJto02yizTKz+cDXgYcJt1JPrkmgzgGSNge+F3ePMrMbc3iZzrXsQgzhI2A7OlerucQ8qS/pC8B6hFr3y8s5wcwW0f6L9U1JG+YUm3NLWpnTGAGswjVmdlFOr9J1LfsH/Cn+v7fW64wn9SV9I24vMrP3yz3JzP4BXEuYJOnneQTmXClN0CSOYy/GA8exT15jJrqrZecNTibM7Ph5wvgOVye8+qX9vE8DrwHLEmanq6hcS9LGhIFKA4ExZnZrJec7Vy61ahjGyyzZPl4I+Y2Z6Ko0UtL/At8CppmZJ/YcefVL3xxJSOiPAvdXerKZPUm4oQR0Uc/uXLU8zD507vDIdRK60ntJJU+fBnwMjJG0c16v7SrjSb3dAXF7bj9qb39GuCTdSdIXqhOWcx3czkGderkTTEJnZi8TRn4D/KSWr+2650m93d6EYdB/6u3A7pjZK0A2DNs/5K7qJK3LW4zjGsAWp/Yl5mypsdMI5ZS7Sep23QNXO57UIzP72MyuMLO3+/mlfk4LnzCCXTVKB/R+uHMVORYQD3ETYh06TEJXa2Y2gzBWA7whUxf8Rmm1X79VEzDORggDxDd8aTxXDZKWI8yHtDK9LA1ZS5LWB54m9OtvX+0BUM5vlCazePSd4m0sAcZZPve6q5JDCQn9ZUIJbV2IU2lcEHf/y+vW0/KkXl1djb4bgC+N56rjuLg908w+SRpJZycTpuX9PHBg2lCamyf16uo8+m4R8GdWSRKNKwxJWwPbEkoIu5zCIiUzmwX8Ku7+XNLSKeNpZp7Uq6jT6LtFGNcAT3C8X5K6fvpO3F5uZh0XZ68XvwDeIFyxHps4lqblSb3KlpjJ8R4+x0PMB3YE9koamGtYkjYgDI4D+E3KWHpiZu+yNr9mBDCIU+LKZ67GvPol/3h+AfyAMJPj1nECMOfKJuk8YDxwg5ntnTicbsXKr7MQA1gEPML5dqV9LXVcReArH9VXUl8ZeBFYibDoxnWJQ3INpEO54HZmNj1xSF3qdmWwAazta/j2n5c01hEze4v2G1vHpIzFNaQfExL6DfWa0KPOlV8DgH+yW5Jompgn9do4O273jcvlOder2Er/atxtTRlLGbqu/LqNHZJE08Q8qddAnMHxdsL7/fXE4bjGcQKhlX5jnbfSu1rDdxHXAK9zkKRlU8bWbDyp1042Le8ESQOTRuLqnqSVgK/E3V+mjKVcS1R+tbEeD/EqsAqwf9LAmozfKK0RSZ8CXgUGA3vltJ6kKwgN14kMZDJzeYG5bNCP6aCTkfRTwj2Bv5nZHqnjaWRe/VKHSR1A0m8Ig0iuMLODU8fj6pMmaQLGOQwADEMc3YiTwklaD3geMGBNM5udOKSG5dUv9Su7Ybq/pNWSRuLq0uJJ4bLfzDA53JmNOCmcmb0A3EuY2s4bMTXiSb2GzOxx4AHCza+DEofj6tPIOAlcqVyXqsvZZXF7aNIomogn9drzD7nr3v28VQ9L1VXR5XG7s6TVk0bSJDyp1172IR8jadWkkbj6cy1f4BpKK75TLlXXb3FlpPsIuca7YGrAk3qNxQUFHiJcUh+YNhpXhw7mIeBcWkm8VF0V+dVpDXn1SwKSTgL+Ey/1ciXildtsQmNr3djKbXiS1gVeIFx/rGFmbyQOqeF49Uv9u5wWYAS76UBtljoYVzf2J/xOPliUhA5gZi8C9+NdMDXhST2FSezM8cB4BrAFj6pVE1KH5OpClvD+mjSKfGRdMF9KGkUT8O6XGutyitJwM2xEo94Mc/0naRBh1aBlgE3ifEGFIWkEYQpqI3QtzUwbUWPx7pf61nmK0sauQ3bVsTchoT9VtIQOi6tgbiEMRPpqz0e7/vCkXnudpyg1FtG4dciuOorc9ZI5L27HS/LckxN/Y2usi8Wp4Sae866X5hUne8uWqStyUv8r8C6wHrBT4lgKy5N6AounKJ3Bl5iCcRefkTQ8dVwumb2A5Qn3Wh5MHEtuzOx94M9x19cuzYkn9URsos2y8+wy2rgtPnV40oBcSl+O20sbcYrdCmVdMIfGOeNdlXlST++iuD0iaRQuiZjY9o27l6SMpUbuYjAvMILlWYejUwdTRF7SmJiklYHXgKWBTc3sicQhuRqSdCTwJ+AZYKOit9TVqgkYZyPEImAA3yjANAi5q7uSRknHSZohab6k6ZJG93DseEnW4TG/FnGmYGZvAdkqSF/u6VhXSFm32yVNkNDDXPFhjnjiIiANOVd8Pcs9qUs6DDidsBr6VsAjwNReFoloA9YoeayTd5yJZV0wX5akpJG4mpE0BMjm/rk0ZSw10nmMhnyMRrXVoqV+AnC2mZ0Xuxa+CXwAfL2Hc8zMZpc8Xq9BnCldA3wIrE/4w+eaw8GEbrdHm6TbrfMYjbDnYzSqKNekLmkZYGvg5uw5M1sU97fv4dQVJc2U9LKkqyRt2sNrLCupJXsADXdHPZZ6XRt3fW6M5rG46yVpFDXS5RiNa4BJXrBRTXm/masQhsB3bGm/Dgzt5pynCa34A4B/IcR4l9Rtv9tJhBsI2aNRB/Fkl99f8i6Y4pM0lDBfOjRH1wtQMkYDxvI/3MNDgDdkqqru/kKa2d1mdoGZPWxmtxIuUd8Eju3mlMnAoJJHo950uQF4n/CB7/ZGsiuMwwm/f/fEBZqbhk20WTbRpvEOf4xPHZY0oILJO6nPIVxqdVybcHXCYgC9MrOPCSsFdXkzxcwWmFlb9iAMQ244ZvYBcHXc9ZZL8R0ZtxcmjSKtywmdMNtI8pulVZJrUjezj4AHgF2z5+JEPrsCd5fzNSQNBEYRarmLrrQLpu6uolx1aAftxAi2oYWFtA+bbzpxBaR/xF1f6q5KapE4TgeOlnSUpI2B3wIrEIcLS7pA0uTsYEknSxonaT1JWxEGZqwDnFODWFObSijnHAZslzgWlwO1agLjuJXxwHcZyCT2Sx1TYtkEZnsljaJAck/qZnYp8H3gFOBhYAtgz5IyxeGEWvTMp4GzgSeB64EWYIdmKPkys/nAVXHXu2AKRq0ahpUMvgn/bfbBN1Pjdoe4UIjrJ58moM5IOhC4grBQ7wZFH2XYTNSqsbR3N5QaaxNtWo3DqRuSngY+A3zRzIo89XCf1d00Aa4iNwMfE+acHpk4Flddz2J0/CO9EB98c0Pc7pk0ioLwpF5nzOw9WDwd7949HesazCRe5TraSsZULgSO9QVSFs99tJeP0eg/T+r16fq49ZtHxbIV9zOIKbzPh+xOWGzcZyiEW4H5hAKBTRLH0vA8qdenLKmPkbRC0khcNYV509u40U6zm72FHpjZh8C0uOtdMP3kSb0+PQ28SFhdfpfEsbjqyRbDuC5pFPUp64LxpN5PntTrUKx4yVrr3q9eAJLWIExuB+0/W9cuS+o7+9Vp/3hSr1/X0wKsz0H6SVPXMRdF9sf53iaYSrovnqH96nRsL8e6HnhSr1cnsg7HA19hdQYyU62akDok1y9Z18u1PR7VpOLVaVbauE/KWBqdJ/U6pFYNYznOWPzTEQPwkYcNS9JywO5x1/vTu5f9wdvXSxv7zpN6feq87Be+7FcD+wJhvqNXIc4g7royjbAC2DBg87ShNC5P6vWp87Jf5iMPG9jiqhef9qF7sbQxWyVt356Odd3zpF6Hulz26wl+63XNjSd2I2Q3Sb3rpXeLu2CSRtHAPKnXqcXLfl3BFUwBLmPpxCG5vtmAMI/Px3Q9mZdbUvaHb1tJqyaNpEF5Uq9jNtFm8QjnEuZk29NvHjWkbDDNHWbWkKty1ZKZvUK47yB8mow+8aRe/24BFhAWCtkocSyucllSv6HHo1yprLXuXTB94Em9zsW1S2+Nuz6EuoHEUsZsIM2NPR3rlpD1q+8haZmkkTQgT+qNIWvl+eVoY9kZ+BTwCvB44lgayX0MYg4jaGEjDk4dTKNZKnUAriw3Ar8GviBpBTN7P3VArizZldWNXspYgUl8DWNlBBgXqVUr+BTF5fOWemN4GpiBz4vRaLIrK+96KVMcNV26jqswH01dCU/qDSC28rKbR82++nxDkDSCcGN7Ie0DalzvOo+mlo+mroQn9cZxTdzuK8l/bvVvj7i928zmpgykwXQ1mtrw0dRl8+TQOKYB7wFrAlulDcWVISvH866XCnQ5mvpGXvHR1OXzpN4gzGwBMDXuehdMHZO0Iu2zMl6ZMJSGtHg09WwOYAoLmc4wSeumjqtReFJvLFfH7f5Jo3C92QNYltBl8ETiWBqSTbRZ9lu7mjZuj08dkDSgBuJJvbFcT7gg3ULS8NTBuG4dGLdXeiljv10ZtwcmjKGheFJvIGY2B7gr7voQ6jokaWnafzZXJgylKK6K250kDUkaSYPwpN54vAumnm3EwYxgMIN4C7gndTiNzsxmELqwBgC7pI2mMXhSbzxZaeNYSSsljcQtQa2awGFczHjgeIYwifGJQyqKv8XtHj0e5QBP6o3oacINuGWAXRPH4iK1ahjWYSSkrytbLVnV1ziffrp3ntQbTIfRpXv3dKyrqZFxgfBSPhKyOm4jTD89HNgwcSx1z5N6Y8pmbdzbWy5149k48rGUrytbBXH66ay0cVzKWBqBJ/XGdCth1fW1gFGJY3HEkZBTeblkgPtC4FgfCVk13q9eJk/qDcjM5gN/j7veBVMHJK3NPQxnCsarHAiM8OliqyrrVx8jadmkkdQ5T+qN6/q49aReH0Jteht325l2lbfQq+4xYDawPLBj4ljqmif1xpX1q+8g6dNJI3HQPm7g6h6Pcn0SCwSyLhjvV++BJ/UGFQdlPEmosNi956NdnuIEXtnAmGt6Otb1S9YF4/3qPfCk3tiupwUYxde8Hjqp3QnjBl4g/KF1+cgWG9lC0qpJI6ljntQb2REYxwNfZE+MmWrVhNQhNalsKuRrfAKv/JjZG8AjcdenDOiGJ/UGpVYNYyQnLP4JhoEvPoKxxuIqVPvEXe96yV/WWt8taRR1zJN64/IRjPXhc8BqQBvtA2RcfrKkvrsPvOtaTZK6pOMkzZA0X9J0SaN7Of5QSU/F4x+T5GV7nXVey9FHMKaQ3bS7ycw+ShpJc7gd+BhYB1gvcSx1KfekLukw4HSglbC25iPAVEmrdXP8DsDFwLnAloQ5qa+UtFnesTaSxWs5Wkzsi4CPOM7ro2suqzy6KWkUTcLM3qd9TQHvgumC8r6vI2k6cJ+ZfTvuDwBeBv7HzE7r4vhLgRXMbN+S5+4BHjazb5bxei3APGCQmbVV6duoW/qJhnERjzKHT9PGGDO7NXVMzSJOffw2sBSwnpm9mDikpiDpP4BTgb+Y2SGp46mFSvJari11ScsAW9PeD4aZLYr723dz2valx0dTuzte0rKSWrIH0FRzjNupNosXuIHwY/aWS22NIST05z2h11SWH3aRNDBpJHUo7+6XVQg3717v8PzrwNBuzhla4fEnEf6CZY9m7H7wioA0vOsljfsJN6Y/TeiidSWKUP0yGRhU8mjGkr5scq/RkgYljaS5eFJPwMw+AW6Ju96Q6SDvpD6HUJGxeofnVydMztOV2ZUcb2YLzKwtewDv9iPehmRmLwHPEH6eY9JG0xwkrQ1sRLhF/Y/E4TSjm2kBNuJLPjZjSbkm9Vji9QAly67FG6W7And3c9rddF6mbfcejneBd8HUVtZKv9fM5qYMpCl9k5U4HjicLX009ZJq0f1yOnC0pKMkbQz8FlgBOA9A0gWSJpcc/xtgT0nfk7SRpEnANsAZNYi1kS0elJE0iubhXS+JqFXDGMpPfTR115bK+wXM7NI4+c4phJudDwN7mll2M3Q4JYNozOwuSUcAPwX+kzDI5kAzezzvWBvcLYSurg0ljYizOLocxKvN7Irobz0d63Ixks4N0mw0dTMWSiwh96QOYGZn0E1L28zGdPHcZcBlOYdVKGY2V9LdwOcJoxzPTBxSkW1JqOx6D5ieOJZmlI2mbk/sxkLko6mhGNUvrt2Ncbtn0iiKb6+4vdnMPk4aSRMqGU29EAjp/SV+5qOpA0/qxZKthrRbHPjl8pEl9et7PMrlxibauYgRXMqdTAHOw/+4Rp7Ui+Vh4A1gRWCHtKEUk6QhwHZx94aejnX5sok2iyf5QxxNvU8vhzcNT+oFEqdgyJb88i6YfIwj/N48buaX+3Ugu1raVtIqSSOpE57UiydrPXpSz0fW9eKt9DpgZq8QZn4V/pkHPKkX0U2AAZ+VtGbqYIpEJ2lt1mN/WgDvT68n18Wtd8HgSb1wzGwOcF/c9VXXq0StmsCyzOCrDOZ44D/4TOqY3GJZUt9TUk3KtOuZJ/Viykob9+rxKFeWOFLxrMXLBw4AluL/fARj3ZgOvAUMpvspvZuGJ/ViKm25LJs0kmLoaQSjS8zMFtLekGn6LhhP6sV0P/AaYcGQsYljKYJnFy8b2M7Xg60v3q8eeVIvoFjaeFXcPSBlLEVgE20WD/GnkrS+EDjWRzDWlamEsaWbSRqeOpiUPKkX1+KkHiegcv1xNaszBbiOs4ERNtHOTRyRK2Fmb9O+IHVTt9b9l724biEsGLIGYepi10eSBgO70gbcxy+9hV63vAsGT+qFZWYLaB8g410w/bMvYUbTf5rZM6mDcd3KkvqukpZPGklCntSLLeuCOTBlEAVwcNxekTQK15vHgZeB5WjiAgFP6sV2PfAJLWyiI/QvXlddOUkr0D78/K8pY3E9MzOjvbXetAPvPKkXmJnNZUee4XhgQ/4IvpZjH+wBfAqYQZgF09W3bCWqcUmjSMiTeoGpVcPYjY1Lfsq+lmPlsq6Xv8aWoKtvpcs6rpM6mBQ8qRfbSIQ6POcjIcskaWnaKym8P70BmNlc2pcYbMpF2D2pF1u2lmMpHwlZvh0I84m8BdydNhRXgabugvGkXmAlazmGboNFGD4SshL7xu31cX4R1xiypL6bpIFJI0lAResmlNQCzAMGmVlb6njqgTbSkSzgT7zDbOaxpvcNl0fSU8CGwGFm9ufU8bjyxOl35wCDgG3N7N7EIfVbJXnNW+rN4Gn+wgw+ZB5DgVGpw2kEkkYSEvontC8R6BqAmX0C/D3uNl0XjCf1JmBm84F/xF2fY7082Q3S28xsXtJIXF80bb+6J/XmkU0ZsHfSKBrHfnF7TdIoXF9lSX372HXRNDypN48sqe8oaVDSSOpcfH92jrvXpozF9Y2ZvQg8RwtLsQvfaaaxGZ7Um4SZvQA8TahTb8r63QrsQZjA6ykz8/LPRrULL3E8sDOn0kSjqT2pN5estd6082KUKStl9FZ6g1KrhrETY5txNLUn9eayeEFqSR1HmjogLiiSTeB1XU/HurrWtKOpPak3l1uBD4G1gE0Tx1KvtgJWJSwwcmfiWFzfNe1oak/qTSSWNk6Lu3v2cGgzy0o+bzazj5NG4vqsZDR1SOzhv00xmtqTevPJumA8qXctS+o39HiUq3s20c5lGjtyPjCFhUxqjvnwPak3nyyp7yRpxaSR1BlJKwPbxV1P6gVg0+weZvAEbQykSQYieVJvPs8CLwLLAGPShlJ3xgECHjcr/mV6E8lueDfFwDtP6k0mTublXTBd866XYro+bveK1U2FVvhv0HXJk3oHOklrsx77EQaUe1IvljuBNkJV03a9HNvwPKk3p1uAj4H142yETU2tmsCyzOCrDOZ44Mc0/XtSJLGK6eq4e2jKWGrBk3oTMrN3CTXrAIekjCW1OMLwLBR/FwYAS/N/zTDysMlcHreHFL0LptDfnOvRJXF7eNIo0htJ59+Dphh52GSmAu8Bw4DRiWPJVa5JXdIQSRdKapM0V9K5vZXRSZomyTo8fpdnnE3qCkIXzOaSNkkdTELPLh6g0q4pRh42kzjwLptGudBdMHm31C8kDEffnTBJ0s7AWWWcdzawRsnjh3kF2KzM7G3aV/Rp2ta6TbRZ3MXUkrS+kCYZediELovbQ4o891FuSV3SxoTqim+Y2XQzuwP4N+BwSWv2cvoHZja75OFrjebj4rg9vMgf8p5IEjexCVOAaUwCRthEOzdtVC4nNwLvA8OBzyWOJTd5ttS3B+aa2f0lz91MmIVh217OPVLSHEmPS5osafncomxuVxMm+BoJbJk4llS2A9ahjfeYxn95C724zOxD2qdTLmwXTJ5JfSjwRukTcUHYt+O/deci4F+AscBk4CvAn7o7WNKyklqyB7BSfwNvFmb2Hu0f8i+njCWhrOvpKjP7IGkkrhYK3wVTcVKXdFoXNzI7Pjbqa0BmdpaZTTWzx8zsQuCrwEGS1u/mlJOAeSUPb2lVJnTBDOIInaxdmqmUT9JA4Etx9+KejnWFcQPwATCCMM1y4fSlpf4rYONeHi8As4HVSk+UtBQwJP5buabHbXclZpOBQSWPpklKVXIDW/Mh/86aDOTvNNGyX4S5b4YC7wA3pQ3F1UK8GsumDfhiyljyUnFSN7M3zeypXh4fAXcDgyVtXXL6LvE1p3f5xbu2Rdy+1k08C8ysLXsQFjdw5ZrEKuzLcs247BdwVNxeFj+zrjn8JW4PLWIXTG596mb2JOFu89mSRkvaETgDuMTMXgWQtJakpySNjvvrS/qJpK0ljZC0P3ABcJuZPZpXrE2uKZf9ivdfstG056WMxdXcdcACwmd8VOJYqi7vOvUjgaeAvxMuee4Ajin596WBDYGsuuUjYDfgb/G8XxH+qu6Xc5zNrFkH3xwCfAp4msquHF2Di9NkZJPaFa4LRmEm1uKILbB5wCCvby+PWjUB42yEWIQxgKOLXqst6Xbg88BJZnZa6nhcbUn6CqEX4Akzq/v1eivJa57UHQD6nHZjDjfxNh/RxlAzeyd1THmRtAHtCxMPN7NXEofkakzSYELJ9dLAJrG7uG5Vktd8Qi8HgN1nNzODR2ljGYo/c2N2g/RvntCbk5nNJQyGhIJ1wXhSd6WyQV5fSRpFjmJtepbUz08YiksvTMc7mMPVqrFFqfjy7he3mKRhwMtxd00z67KMtJFJGkNYJGQeMDTO3ueakKSV2ZI32I8BsXm7CDimHu8nefeL65O42HJWCXJAylhylHUt/dUTepObxKdKEjoUZIyGJ3XX0RVxe1DSKHIQV7w5OO7+padjXVMY2UUGbPgxGp7UXUdZUt8lVggUyfaE+fnbaL9J5ppXIcdoeFJ3SzCzZ4AngKWAfRKHU21Z18vVZrYgaSQuOZtosxDHLE7rIcE3/AIpS6UOwNWlK4BNCF0wFyaOpSpi10uW1C/v6VjXPGyinathWpulmUgb99pb9XeTtFJe/eI6iZOw3U+YonSVuLhAQ5O0LXAPYfHh1YrwPbnqkLQOMINQ/bKGmb3R8xm159Uvrr8eBF4izMmze+JY+k2tGsaWHE8LANd6QnelzGwm8AAhHx6YNpr+86TuOrFw+ZbdMD24p2PrXZzXZiYHcDjHA4fwduqYXF3KqqGOSBpFFXj3i+uSpJ2A2wjz068Zl75rKLHeeCaljRdjIWJEo98Mc9UlaW1CF8wAYMNYMFA3vPvFVcMdhNKulWhf8q3RjKTjZ1yNX4fsqs/MXqZ9RaRjejq23nlSd12KXTBnx91G/ZAXsg7Z5easuB0vadmkkfSDJ3XXkz8AnwDbSto8dTCVsok2i4e5oKQOeSEFqEN2ubmBsHD9yjTwvSRP6q5bZvY6cGXcPTphKH13FZ9hCnAdZ8W+9IavQ3b5MLNPgOzz0ahXp36j1PVM0jhgKjCXCXyOtVkbeLYRWruSNgKeJHS5rF3EWSdddXW4YbqRmT2dNqLAb5S6aroZmMGWDGYYzwD/AGaqVRMSx1WOr8ft9Z7QXTk63DD9dspY+sqTuuuRmS1iTS5lP0AoPl33U5TGlk2W1H+fMhbXcKbE7TckrZYykL7wpO56dxB3NuAUpT8g3PB6Grg2cSyusfwDuBdYDjg+bSiV86TuercqD2F0vPlSt6WBktYAToi7J8UbYM6VJZbz/mfcPU7SoJTxVMqTuuuVTbRZLOC4Bpqi9GTCvDX30F6941wlrgH+CbQA30ocS0W8+sWVTcP1IwZyGu/wFvNY18zeTR1TR5I+Q5gPfiDwBTO7LXFIrkFJOpKwGPubfI0dWCdd5ZdXv7h8vMzpzOA55rEycFzqcLpxCiGhX+sJ3fXTpcCLbMmqDG+cyi9P6q5sZvYx8NO4+21JS6eMpyNJI4FD4+6PU8biGp+ZfcLanFPNyi9Jh0v6lqRVqhZoB57UXaUuAV4H1qL+hlL/gPCZvtbMHk0djCuAQ3mwypVfJwL/S46/O57UXUXi2p6/i7v/njKWUpLWBI6Ku6eljMUVSAuPV6vyS9KmwGeBj8lxSUVP6q4vfkf4YG4vaXTqYKLjgWWAO8zszsSxuIKwiTaLeXyvSpVf2QIcN5hZbou1+MLTrmJmNlvSxcBXCa31I1PFolYN4022pIVvEWoCvJXuqsp+bb/WatqGFTiCd7nJ5lQ+KZwk0Z7UL6puhB1ey0saXV9I2oqwruMnwDpm9mrNYwhVCGcBA1gETGUW0xluRftQu+RKJocz4LNm9liF5+8A3ElY+Hx1M/ugwvO9pNHly8weBG4nXO2d0MvhVRerD0JCJ/53T9ZkEmvVOhZXfGb2FKEfXMAZseVdiayVfkWlCb1SntRdf0yO23+VtGqNX7urpeoGUN/z0bjG9n3gQ2Bn4MvlnhRLfw+LuxfmENcSPKm7/rgRuJ8wJP8ECC1otWpsDWZw9KXqXE2Z2UzgZ3H3l7FLpBy7AasAbwB/zyO2Up7UXZ/FvutT4u639T19B5hJDUbe2USbxaP83peqczX2S0LDYQ1gYm8Hx26arPT30lpMLuc3Sl2/xA/tg7SwBd/FSkbeQWg5j8gj0UoaADxKC5vyGc5mX07xhO5qQdJetC+kcRrwk+6StaRDgMuAj4DNzOzZPr6m3yh1tRFb66cyBDokdMh3zvWvAJvSxrvczw89obtaMbMbgJ/H3ROBqV0tpiFpJdoX3Ditrwm9Up7UXTVcyTwe69TDnVMft6TdgbPj7ulmNrfar+FcT8zsROBw4H1gF+BJDVOrfqhxJfeTWgnTabxADcdPePeLqwpJazKaB9mT1RlA6OMWx9rEygdq9PI62wDTgBUIl7VfNrOF1XwN58olaRPgErZkFPtB/OzD33mUO9iUcLW6l5nd2M/XKTuveVJ3VSNpTQZzO4NZj3d4mXlsV81BSZI2JyyEvSqhimCfOBeNc8noBK1DCy8u0f24iNDx0sblZnZod+eW/Rr10Kcu6ceS7pL0gaS5ZZ4jSadIek3Sh5JujtOpugZgZq8yl52YwbPMY21CX+On+/K1OpZGStoRuJWQ0B8ADvKE7urCINbrdD9pALAlrcD4WoeTZ5/6MoTL499WcM4Pge8A3wS2JfRXTZW0XPXDc3mILfNxwGvAZsA1kpYvPaa3WvZYCtleGnm4pgA3AYMJQ613r8dVl1zTeha6GDMxlnPM7P1aB5N794uk8cAUMxvcy3ECXgV+ZWa/jM8NIszdPd7MLinz9bz7pQ5IGgXcRkjEVxNa1ouWmK8l/CIcU9rvHhP9TEobHO2XstcDh+Y9zNq5SsXP9ZmEPvRszESn+0nx8z2SCpfFq4vulz5YFxhK6DMFwMzmAdOB7VMF5fomTni0L7AA2B/4Qaf5WrpeRabz8P8BwFrcCRzoCd3Vo5jARwBjCWMzukroS16B5jQ4r56m3h0at693eP71kn/rRNKywLIlT61U5bhcH5nZnZL+jZDIf8a9zGd0p4ZEVsuetVqyS9klW+qjONqesI/zj9q5vokt7y5b3z00aKZWe4xFRS11SadJsl4eG1UzwDKcRLgsyR4+CKW+nAP8ERjInZzUab4WYyEP8tbi3Yk2i0/45uLVZhYBL3GqXWpP1jBm56qt8xVoToPzKm2p/wo4v5djXuhbKMyO29UJN9ko2X+4h/MmA6eX7K+EJ/a6YWYm6V+BrZnHJlyNLa7nXQRcy0Ie5FFJTxL63t8DjqEFMQT4hJPtZTs13XfgXFV0vgLNaXBeRUndzN4E3qx2ENGLhMS+KzGJx5sD29JDBU0sa1tc2lb5NMcub2b2vqSDgUt5iM/yPDAEeBtoY5l42MbxEbQxhzZOx1cycgVgE22WWnUMnW+mVn9epLyqXyQNJ/zq7k9Y5X2n+E/Pmdl78ZingJPM7Iq4/yPCXApHEZL8qcDmwCZmNr/M1/XqlzomaQ3CZ2FzQuvlXsJ9k3HAfsDKhOW+/lzuz9y5RhH71jcAnsur+iXPpH4+7au7lxprZtPiMQZ8zczOj/sizJdwDKEU7g7gW2b2TAWv60ndOVcodZHUU/Gk7pwrmkatU3fOOddPntSdc65APKk751yBeFJ3zrkC8aTunHMF4kndOecKpJ4m9Kq2lXx0qXOuIMqeqLCIST375n3+F+dc0awENN3gIwFrApWujJNNBDasD+cWnb83XfP3pXv+3nStP+/LSsCr1kvSLlxLPX7Dr1R6XklXzbs+EnVJ/t50zd+X7vl707V+vi9lHe83Sp1zrkA8qTvnXIF4Um+3gDBD5ILeDmxC/t50zd+X7vl707Xc35fC3Sh1zrlm5i1155wrEE/qzjlXIJ7UnXOuQDypO+dcgTR1Upf0Y0l3SfpA0twyz5GkUyS9JulDSTdLGplzqDUnaYikCyW1SZor6VxJK/ZyzjRJ1uHxu1rFnAdJx0maIWm+pOmSRvdy/KGSnorHPyZp71rFWmuVvDeSxnfx2SjcwuKSdpZ0jaRX4/d4YBnnjJH0oKQFkp6TNL4/MTR1UgeWAS4DflvBOT8EvgN8E9gWeB+YKmm56oeX1IXApsDuwL7AzsBZZZx3NrBGyeOHeQWYN0mHAacTStC2Ah4h/KxX6+b4HYCLgXOBLYErgSslbVaTgGuo0vcmamPJz8Y6eceZwAqE9+K4cg6WtC5wHXALsAUwBThH0h59jsDMmv4BjAfmlnGcgNeA75c8NwiYDxye+vuo4vuxMWDANiXP7QksAtbs4bxpwJTU8VfxfZgOnFGyP4AwBcWJ3Rx/KXBth+fuAX6X+nupg/emrN+xIj3i79CBvRzzc+DxDs9dAtzY19dt9pZ6pdYFhgI3Z0+Y2TzCB3z7VEHlYHvCL+D9Jc/dTEjq2/Zy7pGS5kh6XNJkScvnFmWOJC0DbM2SP+tFcb+7n/X2pcdHU3s4viH18b0BWFHSTEkvS7pK0qY5h9oIqv6ZKdyEXjkbGrevd3j+9ZJ/K4KhwBulT5jZJ5Lepufv8yJgJvAqsDmhFbIhcHBOceZpFWAgXf+sN+rmnKHdHF+kzwb07b15Gvg68Cjh6vb7wF2SNjWzZp4mu7vPTIukT5nZh5V+wcIldUmnAT/q5bCNzeypWsRTT8p9b/r69c2stM/9MUmvAX+XtL6ZPd/Xr+san5ndDdyd7Uu6C3gSOBb4Saq4iqhwSR34FXB+L8e80MevPTtuVyf0rVOy/3Afv2YtlfvezAaWuOElaSlgCO3vQTmmx+0GQKMl9TnAQsLPttTqdP8ezK7w+EbVl/dmCWb2saSHCJ+NZtbdZ6atL610KGBSN7M3gTdz+vIvEn4IuxKTuKQWQj9zJRU0SZT73ki6GxgsaWszeyA+vQvhZtj07s/sZIu4fa2ng+qRmX0k6QHCz/pKAEkD4v4Z3Zx2d/z3KSXP7U5JC7UI+vjeLEHSQGAUcH1OYTaKu4GOZa/9+8ykvkOc+O70cELiOZmwCskW8bFiyTFPAQeV7P8IeAfYn/ChvJLQul0u9fdT5ffmBuBBYDSwI/AMcFHJv68V35vRcX99wmX01sCI+P48D9ya+nvpx3twGKGy6ShCt9SZ8We/evz3C4DJJcfvAHwMfI/QtzwJ+AjYLPX3UgfvzcnAOGA9QgnkxcCHwCapv5cqvy8rluQRA74b/394/PfJwAUlx69LKIv+RfzMfAv4BNijzzGkfhMS/wDOj298x8eYkmMMGF+yL+AUQot9PuHO9WdSfy85vDdDCDc+3wXmAb/v8MduROl7BawN3Aq8Fd+XZ+MHtSX199LP9+HbhJu/CwhXKduW/Ns04PwOxx9KuCm4AHgc2Dv191AP7w3w65JjZxNqs7dM/T3k8J6M6SannB///XxgWhfnPBTfm+dL801fHj71rnPOFYjXqTvnXIF4UnfOuQLxpO6ccwXiSd055wrEk7pzzhWIJ3XnnCsQT+rOOVcgntSdc65APKk751yBeFJ3zrkC8aTunHMF4kndOecK5P8DxITaforQSUcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -278,8 +280,10 @@ "i_test = (size-1) / 2\n", "\n", "x, u = sine.generate_observation(i_test)\n", - "plot_evaluation(operator, x, u, ax=ax)\n", - "plot(x, u, ax=ax)\n", + "y = torch.linspace(-1, 1, 100).reshape(-1, 1)\n", + "v = operator(x.unsqueeze(0), u.unsqueeze(0), y.unsqueeze(0)).squeeze(0).detach()\n", + "ax.plot(y, v, 'k-', label='Prediction')\n", + "ax.plot(x, u, 'g.', label='Sensors')\n", "ax.set_title(f\"$k = {i_test}$\")\n", "plt.show()" ] diff --git a/src/continuity/__init__.py b/src/continuity/__init__.py index d5e956cb..9f9b8b53 100644 --- a/src/continuity/__init__.py +++ b/src/continuity/__init__.py @@ -25,10 +25,6 @@ content: Loss functions for physics-informed training. url: pde/index.md -- title: Plotting - content: Plotting utilities. - url: plotting/index.md - - title: Trainer content: Default training loop for operator models. url: trainer/index.md diff --git a/src/continuity/plotting/__init__.py b/src/continuity/plotting/__init__.py deleted file mode 100644 index 9cd16d93..00000000 --- a/src/continuity/plotting/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -""" -`continuity.plotting` - -Plotting utilities for Continuity. -""" - -from .plot import plot, plot_evaluation - -__all__ = ["plot", "plot_evaluation"] diff --git a/src/continuity/plotting/plot.py b/src/continuity/plotting/plot.py deleted file mode 100644 index c23f24b0..00000000 --- a/src/continuity/plotting/plot.py +++ /dev/null @@ -1,89 +0,0 @@ -""" -`continuity.plotting.plot` - -Plot functions and operator evaluations. -""" - -import torch -import numpy as np -from typing import Optional -from matplotlib.axis import Axis -import matplotlib.pyplot as plt -from continuity.operators import Operator - - -def plot(x: torch.Tensor, u: torch.Tensor, ax: Optional[Axis] = None): - """Plots a function $u(x)$. - - Currently only supports coordinate dimensions of $d = 1,2$. - - Args: - x: Spatial coordinates of shape (n, d) - u: Function values of shape (n, m) - ax: Axis object. If None, `plt.gca()` is used. - """ - if ax is None: - ax = plt.gca() - - dim = x.shape[-1] - assert dim in [1, 2], "Only supports `d = 1,2`" - - # Move to cpu - x = x.cpu().detach().numpy() - u = u.cpu().detach().numpy() - - if dim == 1: - ax.plot(x, u, ".") - - if dim == 2: - xx, yy = x[:, 0], x[:, 1] - s = 50000 / len(xx) - ax.scatter(xx, yy, marker="s", s=s, c=u, cmap="jet") - ax.set_aspect("equal") - - -def plot_evaluation( - operator: Operator, x: torch.Tensor, u: torch.Tensor, ax: Optional[Axis] = None -): - """Plots the mapped function `operator(observation)` evaluated on a $[-1, 1]^d$ grid. - - Currently only supports coordinate dimensions of $d = 1,2$. - - Args: - operator: Operator object - x: Collocation points of shape (n, d) - u: Function values of shape (n, c) - ax: Axis object. If None, `plt.gca()` is used. - """ - if ax is None: - ax = plt.gca() - - dim = x.shape[-1] - assert dim in [1, 2], "Only supports `d = 1,2`" - - if dim == 1: - n = 200 - y = torch.linspace(-1, 1, n).unsqueeze(-1) - x = x.unsqueeze(0) - u = u.unsqueeze(0) - y = y.unsqueeze(0) - v = operator(x, u, y).detach() - ax.plot(y.cpu().flatten(), v.cpu().flatten(), "k-") - - if dim == 2: - n = 128 - a = np.linspace(-1, 1, n) - xx, yy = np.meshgrid(a, a) - y = torch.tensor( - np.array( - [np.array([xx[i, j], yy[i, j]]) for i in range(n) for j in range(n)] - ), - dtype=u.dtype, - ).unsqueeze(0) - x = x.unsqueeze(0) - u = u.unsqueeze(0) - y = y.unsqueeze(0) - u = operator(x, u, y).detach().cpu() - u = np.reshape(u, (n, n)) - ax.contourf(xx, yy, u, cmap="jet", levels=100) - ax.set_aspect("equal") diff --git a/tests/data/test_dataset.py b/tests/data/test_dataset.py index 585b0233..223a8327 100644 --- a/tests/data/test_dataset.py +++ b/tests/data/test_dataset.py @@ -1,8 +1,6 @@ import torch from torch.utils.data import DataLoader -import matplotlib.pyplot as plt from continuity.data.selfsupervised import SelfSupervisedOperatorDataset -from continuity.plotting import plot def test_dataset(): @@ -15,11 +13,6 @@ def test_dataset(): x = torch.Tensor(range(num_sensors)).reshape(-1, 1) u = f(x) - # Test plotting - fig, ax = plt.subplots(1, 1) - plot(x, u, ax=ax) - fig.savefig(f"test_dataset.png") - # Dataset dataset = SelfSupervisedOperatorDataset(x.unsqueeze(0), u.unsqueeze(0)) dataloader = DataLoader(dataset, batch_size=1, shuffle=True) diff --git a/tests/operators/test_integralkernel.py b/tests/operators/test_integralkernel.py index 7eb83240..4e5fd018 100644 --- a/tests/operators/test_integralkernel.py +++ b/tests/operators/test_integralkernel.py @@ -1,5 +1,4 @@ import torch -import matplotlib.pyplot as plt from continuity.data.sine import Sine from continuity.data.shape import DatasetShapes, TensorShape from continuity.operators.integralkernel import NeuralNetworkKernel, NaiveIntegralKernel @@ -68,13 +67,6 @@ def forward(self, x, y): # Apply operator v = operator(x.reshape((1, -1, 1)), u.reshape((1, -1, 1)), y.reshape((1, -1, 1))) - # Plotting - fig, ax = plt.subplots(1, 1) - x_plot = x[0].squeeze().detach().numpy() - ax.plot(x_plot, u[0].squeeze().detach().numpy(), "x-") - ax.plot(x_plot, v[0].squeeze().detach().numpy(), "--") - fig.savefig(f"test_naiveintegralkernel.png") - # For num_sensors == num_evals, we get v = u / num_sensors. if num_sensors == num_evals: v_expected = u / num_sensors From 1132f67c6232bbaf6be57be073486e1c5882f535 Mon Sep 17 00:00:00 2001 From: Samuel Burbulla Date: Fri, 1 Mar 2024 17:10:33 +0100 Subject: [PATCH 4/4] Update CHANGELOG. --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3db26f5c..8cd38067 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ - Add `Sampler`, `BoxSampler`, `UniformBoxSampler`, and `RegularGridSampler` classes. - Moved `DataLoader` into the `fit` method of the `Trainer`. Therefore, `Trainer.fit` expects an `OperatorDataset` now. +- A `Criterion` now enables stopping the training loop. +- The `plotting` module has been removed. ## 0.0.0 (2024-02-22)