From 7bdb3e8b9d5bc7e788a62469be358fc74124c601 Mon Sep 17 00:00:00 2001 From: Franck Mamalet <49721198+franckma31@users.noreply.github.com> Date: Mon, 8 Sep 2025 15:15:40 +0200 Subject: [PATCH 1/4] add several empirical evaluation of the Lipschitz constant of a model --- deel/torchlip/utils/__init__.py | 51 +---- deel/torchlip/utils/evaluate_lip_const.py | 229 ++++++++++++++++++++++ 2 files changed, 230 insertions(+), 50 deletions(-) create mode 100644 deel/torchlip/utils/evaluate_lip_const.py diff --git a/deel/torchlip/utils/__init__.py b/deel/torchlip/utils/__init__.py index 97b8140..f2cee9d 100644 --- a/deel/torchlip/utils/__init__.py +++ b/deel/torchlip/utils/__init__.py @@ -27,14 +27,7 @@ """ Contains utility functions. """ -from typing import Optional -import torch - -if torch.__version__.startswith("1."): - import functorch as tfc -else: - import torch.func as tfc from .bjorck_norm import bjorck_norm from .bjorck_norm import remove_bjorck_norm @@ -43,49 +36,7 @@ from .lconv_norm import lconv_norm from .lconv_norm import remove_lconv_norm from .sqrt_eps import sqrt_with_gradeps # noqa: F401 - - -def evaluate_lip_const( - model: torch.nn.Module, - x: torch.Tensor, - eps: float = 1e-4, - seed: Optional[int] = None, -) -> float: - """ - Evaluate the Lipschitz constant of a model, using the Jacobian of the model. - Please note that the estimation of the lipschitz constant is done locally around - input samples. This may not correctly estimate the behaviour in the whole domain. - - Args: - model: built keras model used to make predictions - x: inputs used to compute the lipschitz constant - - Returns: - float: the empirically evaluated Lipschitz constant. The computation might also - be inaccurate in high dimensional space. - - """ - - # Define a function that computes the model output - def model_func(x): - # using vmap torchfunc method induce a single sample input - # so we need to unsqueeze the input - y = model(torch.unsqueeze(x, dim=0)) # Forward pass - return y - - x_src = x.clone().detach().requires_grad_(True) - - # Compute the Jacobian using jacrev - batch_jacobian = tfc.vmap(tfc.jacrev(model_func))(x_src) - - # Reshape the Jacobian to match the desired shape - batch_size = x.shape[0] - xdim = torch.prod(torch.tensor(x.shape[1:])).item() - batch_jacobian = batch_jacobian.view(batch_size, -1, xdim) - - # Compute singular values and check Lipschitz property - lip_cst = torch.linalg.norm(batch_jacobian, ord=2, dim=(-2, -1)) - return float(torch.max(lip_cst).item()) +from .evaluate_lip_const import evaluate_lip_const __all__ = [ diff --git a/deel/torchlip/utils/evaluate_lip_const.py b/deel/torchlip/utils/evaluate_lip_const.py new file mode 100644 index 0000000..867079d --- /dev/null +++ b/deel/torchlip/utils/evaluate_lip_const.py @@ -0,0 +1,229 @@ +# -*- coding: utf-8 -*- +# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All +# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry, +# CRIAQ and ANITI - https://www.deel.ai/ +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All +# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry, +# CRIAQ and ANITI - https://www.deel.ai/ +# ===================================================================================== + +from typing import Optional, Union +import torch + +if torch.__version__.startswith("1."): + import functorch as tfc +else: + import torch.func as tfc + + +def evaluate_lip_const( + model: torch.nn.Module, + x: Optional[torch.Tensor] = None, # can be torch tensor or None + evaluation_type: Union[str, list[str]] = "jacobian_norm", + input_shape=None, + expected_value=None, + **kwargs, +) -> float: + type2fct = { + "jacobian_norm": evaluate_lip_const_jacobian_norm, + "noise_norm": evaluate_lip_const_noise_norm, + "attack": evaluate_lip_const_attack, + } + device = "cpu" + if len(list(model.parameters())) > 0: + device = next(model.parameters()).device + + if evaluation_type == "all": + evaluation_type = list(type2fct.keys()) + if isinstance(evaluation_type, list): + lip_csts = [] + for etype in evaluation_type: + lip_csts.append( + evaluate_lip_const( + model, x, etype, input_shape, expected_value, **kwargs + ) + ) + return float(torch.max(torch.tensor(lip_csts)).item()) + + if evaluation_type not in type2fct: + raise ValueError( + f"Unknown evaluation_type {evaluation_type}. " + f"Available types are {list(type2fct.keys())}" + ) + if x is None: + if input_shape is None: + raise ValueError("If x is None, input_shape must be provided") + x = torch.randn(input_shape) + x = x.to(device) + val_lip_const = type2fct[evaluation_type](model, x, **kwargs) + print( + f"Empirical lipschitz constant is {val_lip_const} with method {evaluation_type}" + ) + if expected_value is not None: + assert ( + val_lip_const <= expected_value + ), f"Empirical lipschitz constant {val_lip_const} is \ + higher than expected value {expected_value}" + return val_lip_const + + +def evaluate_lip_const_noise_norm( + model: torch.nn.Module, + x: torch.Tensor, + num_noisy_samples: int = 10, + **kwargs, +) -> float: + + with torch.no_grad(): + model.eval() + pred = model(x) + lip_csts = [] + for _ in range(num_noisy_samples): # random sampling + noise = torch.randn_like(x) * torch.rand(1).to(x.device) + noisy_input = x + noise + noisy_pred = model(noisy_input) + pred_diff_norm = torch.linalg.norm( + (pred - noisy_pred).view(pred.shape[0], -1), dim=1 + ) + input_diff_norm = torch.linalg.norm(noise.view(pred.shape[0], -1), dim=1) + lip_cst = pred_diff_norm / input_diff_norm + lip_csts.append(lip_cst) + lip_csts = torch.cat(lip_csts, dim=0) + print(lip_csts) + return float(torch.max(lip_csts).item()) + + +def evaluate_lip_const_jacobian_norm( + model: torch.nn.Module, + x: torch.Tensor, + **kwargs, +) -> float: + """ + Evaluate the Lipschitz constant of a model, using the Jacobian of the model. + Please note that the estimation of the lipschitz constant is done locally around + input samples. This may not correctly estimate the behaviour in the whole domain. + + Args: + model: built keras model used to make predictions + x: inputs used to compute the lipschitz constant + + Returns: + float: the empirically evaluated Lipschitz constant. The computation might also + be inaccurate in high dimensional space. + + """ + + # Define a function that computes the model output + def model_func(x): + # using vmap torchfunc method induce a single sample input + # so we need to unsqueeze the input + y = model(torch.unsqueeze(x, dim=0)) # Forward pass + return y + + x_src = x.clone().detach().requires_grad_(True) + + # Compute the Jacobian using jacrev + batch_jacobian = tfc.vmap(tfc.jacrev(model_func))(x_src) + + # Reshape the Jacobian to match the desired shape + batch_size = x.shape[0] + xdim = torch.prod(torch.tensor(x.shape[1:])).item() + batch_jacobian = batch_jacobian.view(batch_size, -1, xdim) + + # Compute singular values and check Lipschitz property + lip_cst = torch.linalg.norm(batch_jacobian, ord=2, dim=(-2, -1)) + return float(torch.max(lip_cst).item()) + + +def evaluate_lip_const_attack( + model: torch.nn.Module, + x: torch.Tensor, + num_iterations: int = 100, + step_size: float = 1e-2, + double_attack: bool = False, + **kwargs, +) -> float: + """ + Evaluate the Lipschitz constant of a model, using an adversarial attack. + Please note that the estimation of the lipschitz constant is done locally around + input samples. This may not correctly estimate the behaviour in the whole domain. + + Args: + model: built keras model used to make predictions + x: inputs used to compute the lipschitz constant + num_iterations: number of iterations for the attack + step_size: step size for each iteration + double_attack: if True, perform a second attack starting from the worst case + found during the first attack. This can improve the estimation of the + Lipschitz constant at the cost of doubling the computation time. + + Returns: + float: the empirically evaluated Lipschitz constant. The computation might also + be inaccurate in high dimensional space. + + """ + + def attack_lip_const(model, x, step_size, num_iterations): + model.eval() + with torch.no_grad(): + ref_output = model(x).detach() + noise = (torch.randn_like(x) * torch.rand(1).to(x.device)).detach() + for _ in range(num_iterations): + noise = noise.requires_grad_(True) + noisy_input = x + noise + noisy_pred = model(noisy_input) + + pred_diff_norm = torch.linalg.norm( + (ref_output - noisy_pred).view(ref_output.shape[0], -1), dim=1 + ) + input_diff_norm = torch.linalg.norm( + noise.view(ref_output.shape[0], -1), dim=1 + ) + lip_cst = pred_diff_norm / input_diff_norm + loss = lip_cst.mean() + + grad = torch.autograd.grad(loss, noise)[0] + noise = noise + step_size * grad.sign() + noise = noise.detach() + + noisy_input = x + noise + noisy_pred = model(noisy_input) + pred_diff_norm = torch.linalg.norm( + (ref_output - noisy_pred).view(ref_output.shape[0], -1), dim=1 + ) + input_diff_norm = torch.linalg.norm(noise.view(ref_output.shape[0], -1), dim=1) + lip_cst = pred_diff_norm / input_diff_norm + return noise, lip_cst + + if double_attack: + print( + "Warning : double_attack is set to True, \ + the computation time will be doubled" + ) + noise, lip_cst = attack_lip_const(model, x, step_size, num_iterations) + + if not double_attack: + return float(torch.max(lip_cst).item()) + + # double attack + + noise2, lip_cst2 = attack_lip_const(model, x + noise, step_size, num_iterations) + return float(torch.max(torch.cat([lip_cst, lip_cst2], dim=0)).item()) From 837e86953ac936f1bc30a2e9017819324365d97d Mon Sep 17 00:00:00 2001 From: Franck Mamalet <49721198+franckma31@users.noreply.github.com> Date: Wed, 10 Sep 2025 09:40:38 +0200 Subject: [PATCH 2/4] add support for disjoint neurons and update notebooks --- deel/torchlip/utils/evaluate_lip_const.py | 69 +++- .../wasserstein_classification_MNIST08.ipynb | 155 +++----- ...serstein_classification_fashionMNIST.ipynb | 229 ++++++------ .../wasserstein_classification_MNIST08.rst | 132 +++---- ...asserstein_classification_fashionMNIST.rst | 330 +++++------------- ...stein_classification_fashionMNIST_16_0.png | Bin 107422 -> 0 bytes ...stein_classification_fashionMNIST_20_0.png | Bin 0 -> 103044 bytes 7 files changed, 344 insertions(+), 571 deletions(-) delete mode 100644 docs/source/wasserstein_classification_fashionMNIST_files/wasserstein_classification_fashionMNIST_16_0.png create mode 100644 docs/source/wasserstein_classification_fashionMNIST_files/wasserstein_classification_fashionMNIST_20_0.png diff --git a/deel/torchlip/utils/evaluate_lip_const.py b/deel/torchlip/utils/evaluate_lip_const.py index 867079d..1d20ef8 100644 --- a/deel/torchlip/utils/evaluate_lip_const.py +++ b/deel/torchlip/utils/evaluate_lip_const.py @@ -38,6 +38,7 @@ def evaluate_lip_const( model: torch.nn.Module, x: Optional[torch.Tensor] = None, # can be torch tensor or None evaluation_type: Union[str, list[str]] = "jacobian_norm", + disjoint_neurons=False, input_shape=None, expected_value=None, **kwargs, @@ -58,7 +59,13 @@ def evaluate_lip_const( for etype in evaluation_type: lip_csts.append( evaluate_lip_const( - model, x, etype, input_shape, expected_value, **kwargs + model, + x, + etype, + disjoint_neurons, + input_shape, + expected_value, + **kwargs, ) ) return float(torch.max(torch.tensor(lip_csts)).item()) @@ -73,7 +80,7 @@ def evaluate_lip_const( raise ValueError("If x is None, input_shape must be provided") x = torch.randn(input_shape) x = x.to(device) - val_lip_const = type2fct[evaluation_type](model, x, **kwargs) + val_lip_const = type2fct[evaluation_type](model, x, disjoint_neurons, **kwargs) print( f"Empirical lipschitz constant is {val_lip_const} with method {evaluation_type}" ) @@ -88,6 +95,7 @@ def evaluate_lip_const( def evaluate_lip_const_noise_norm( model: torch.nn.Module, x: torch.Tensor, + disjoint_neurons=False, num_noisy_samples: int = 10, **kwargs, ) -> float: @@ -100,20 +108,28 @@ def evaluate_lip_const_noise_norm( noise = torch.randn_like(x) * torch.rand(1).to(x.device) noisy_input = x + noise noisy_pred = model(noisy_input) - pred_diff_norm = torch.linalg.norm( - (pred - noisy_pred).view(pred.shape[0], -1), dim=1 - ) + if not disjoint_neurons: + pred_diff_norm = torch.linalg.norm( + (pred - noisy_pred).view(pred.shape[0], -1), dim=1 + ) + else: + # each output neuron is a 1Lipschitz function + diff_pred = pred - noisy_pred + diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) + pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) + pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values + input_diff_norm = torch.linalg.norm(noise.view(pred.shape[0], -1), dim=1) lip_cst = pred_diff_norm / input_diff_norm lip_csts.append(lip_cst) lip_csts = torch.cat(lip_csts, dim=0) - print(lip_csts) return float(torch.max(lip_csts).item()) def evaluate_lip_const_jacobian_norm( model: torch.nn.Module, x: torch.Tensor, + disjoint_neurons=False, **kwargs, ) -> float: """ @@ -138,15 +154,25 @@ def model_func(x): y = model(torch.unsqueeze(x, dim=0)) # Forward pass return y + # assert disjoint_neurons is False, "disjoint_neurons=True not implemented yet" x_src = x.clone().detach().requires_grad_(True) # Compute the Jacobian using jacrev batch_jacobian = tfc.vmap(tfc.jacrev(model_func))(x_src) - # Reshape the Jacobian to match the desired shape batch_size = x.shape[0] xdim = torch.prod(torch.tensor(x.shape[1:])).item() - batch_jacobian = batch_jacobian.view(batch_size, -1, xdim) + + if not disjoint_neurons: + batch_jacobian = batch_jacobian.view(batch_size, -1, xdim) + else: + # each output neuron is a 1Lipschitz function: + # compute the norm of each output neuron + outdim = len(batch_jacobian.shape) - len(x.shape[1:]) - 1 + outsize = batch_jacobian.shape[outdim] + # switch outdim to be the first dimension + batch_jacobian = batch_jacobian.moveaxis(outdim, 0) + batch_jacobian = batch_jacobian.reshape(outsize * batch_size, -1, xdim) # Compute singular values and check Lipschitz property lip_cst = torch.linalg.norm(batch_jacobian, ord=2, dim=(-2, -1)) @@ -156,6 +182,7 @@ def model_func(x): def evaluate_lip_const_attack( model: torch.nn.Module, x: torch.Tensor, + disjoint_neurons=False, num_iterations: int = 100, step_size: float = 1e-2, double_attack: bool = False, @@ -191,9 +218,16 @@ def attack_lip_const(model, x, step_size, num_iterations): noisy_input = x + noise noisy_pred = model(noisy_input) - pred_diff_norm = torch.linalg.norm( - (ref_output - noisy_pred).view(ref_output.shape[0], -1), dim=1 - ) + if not disjoint_neurons: + pred_diff_norm = torch.linalg.norm( + (ref_output - noisy_pred).view(ref_output.shape[0], -1), dim=1 + ) + else: + # each output neuron is a 1Lipschitz function: attack the maximum + diff_pred = ref_output - noisy_pred + diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) + pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) + pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values input_diff_norm = torch.linalg.norm( noise.view(ref_output.shape[0], -1), dim=1 ) @@ -206,9 +240,16 @@ def attack_lip_const(model, x, step_size, num_iterations): noisy_input = x + noise noisy_pred = model(noisy_input) - pred_diff_norm = torch.linalg.norm( - (ref_output - noisy_pred).view(ref_output.shape[0], -1), dim=1 - ) + if not disjoint_neurons: + pred_diff_norm = torch.linalg.norm( + (ref_output - noisy_pred).view(ref_output.shape[0], -1), dim=1 + ) + else: + # each output neuron is a 1Lipschitz function: attack the maximum + diff_pred = ref_output - noisy_pred + diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) + pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) + pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values input_diff_norm = torch.linalg.norm(noise.view(ref_output.shape[0], -1), dim=1) lip_cst = pred_diff_norm / input_diff_norm return noise, lip_cst diff --git a/docs/notebooks/wasserstein_classification_MNIST08.ipynb b/docs/notebooks/wasserstein_classification_MNIST08.ipynb index 81f8b3d..5d7d518 100644 --- a/docs/notebooks/wasserstein_classification_MNIST08.ipynb +++ b/docs/notebooks/wasserstein_classification_MNIST08.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -109,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -158,7 +158,7 @@ ")" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -201,25 +201,25 @@ "output_type": "stream", "text": [ "Epoch 1/10\n", - "loss: -0.0340 - KR: 1.2288 - acc: 0.8649 - val_loss: -0.0363 - val_KR: 2.3215 - val_acc: 0.9928\n", + "loss: -0.0334 - KR: 1.4000 - acc: 0.9440 - val_loss: -0.0348 - val_KR: 2.1309 - val_acc: 0.9933\n", "Epoch 2/10\n", - "loss: -0.0630 - KR: 2.8186 - acc: 0.9943 - val_loss: -0.0607 - val_KR: 3.4102 - val_acc: 0.9939\n", + "loss: -0.0526 - KR: 2.5103 - acc: 0.9951 - val_loss: -0.0500 - val_KR: 2.9728 - val_acc: 0.9918\n", "Epoch 3/10\n", - "loss: -0.0901 - KR: 3.8766 - acc: 0.9960 - val_loss: -0.0805 - val_KR: 4.4241 - val_acc: 0.9939\n", + "loss: -0.0717 - KR: 3.3810 - acc: 0.9963 - val_loss: -0.0688 - val_KR: 3.8197 - val_acc: 0.9944\n", "Epoch 4/10\n", - "loss: -0.0964 - KR: 4.7411 - acc: 0.9965 - val_loss: -0.0957 - val_KR: 5.1178 - val_acc: 0.9933\n", + "loss: -0.0867 - KR: 4.2664 - acc: 0.9963 - val_loss: -0.0875 - val_KR: 4.6475 - val_acc: 0.9949\n", "Epoch 5/10\n", - "loss: -0.1084 - KR: 5.3850 - acc: 0.9957 - val_loss: -0.1036 - val_KR: 5.7095 - val_acc: 0.9923\n", + "loss: -0.0910 - KR: 5.0504 - acc: 0.9957 - val_loss: -0.1006 - val_KR: 5.4983 - val_acc: 0.9918\n", "Epoch 6/10\n", - "loss: -0.1095 - KR: 5.8155 - acc: 0.9954 - val_loss: -0.1126 - val_KR: 6.0285 - val_acc: 0.9944\n", + "loss: -0.1174 - KR: 5.6524 - acc: 0.9966 - val_loss: -0.1053 - val_KR: 5.8443 - val_acc: 0.9913\n", "Epoch 7/10\n", - "loss: -0.1090 - KR: 6.1108 - acc: 0.9960 - val_loss: -0.1178 - val_KR: 6.3084 - val_acc: 0.9933\n", + "loss: -0.1093 - KR: 6.0423 - acc: 0.9960 - val_loss: -0.1174 - val_KR: 6.2047 - val_acc: 0.9939\n", "Epoch 8/10\n", - "loss: -0.1266 - KR: 6.3128 - acc: 0.9959 - val_loss: -0.1192 - val_KR: 6.4553 - val_acc: 0.9923\n", + "loss: -0.1140 - KR: 6.2552 - acc: 0.9961 - val_loss: -0.1200 - val_KR: 6.4036 - val_acc: 0.9933\n", "Epoch 9/10\n", - "loss: -0.1263 - KR: 6.4460 - acc: 0.9966 - val_loss: -0.1208 - val_KR: 6.4837 - val_acc: 0.9939\n", + "loss: -0.1103 - KR: 6.4285 - acc: 0.9960 - val_loss: -0.1229 - val_KR: 6.4758 - val_acc: 0.9949\n", "Epoch 10/10\n", - "loss: -0.1316 - KR: 6.5416 - acc: 0.9967 - val_loss: -0.1240 - val_KR: 6.6313 - val_acc: 0.9933\n" + "loss: -0.1309 - KR: 6.5515 - acc: 0.9961 - val_loss: -0.1242 - val_KR: 6.6517 - val_acc: 0.9933\n" ] } ], @@ -314,75 +314,57 @@ " \\frac{\\Vert{}F(x + \\epsilon) - F(x)\\Vert{}}{\\Vert{}\\epsilon\\Vert{}}\n", "$$\n", "\n", - "for various inputs." + "for various inputs.\n", + "\n", + "The deel.torchlip.utils.evaluate_lip_const implements several methods to evaluate this constant, either by adding random noise $x+\\epsilon$ and evaluating $\\frac{\\Vert{}F(x + \\epsilon) - F(x)\\Vert{}}{\\Vert{}\\epsilon\\Vert{}}$, or by an adversarial attack on $\\epsilon$ to increase this value, or by computing the jacobian norm $||\\nabla_x F(x)||$" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor(0.1420)\n" - ] - } - ], + "outputs": [], "source": [ - "from scipy.spatial.distance import pdist\n", - "\n", - "wass.eval()\n", - "\n", - "p = []\n", - "for _ in range(64):\n", - " eps = 1e-3\n", - " batch, _ = next(iter(train_loader))\n", - " dist = torch.distributions.Uniform(-eps, +eps).sample(batch.shape)\n", - " y1 = wass(batch.to(device)).detach().cpu()\n", - " y2 = wass((batch + dist).to(device)).detach().cpu()\n", - "\n", - " p.append(\n", - " torch.max(\n", - " torch.norm(y2 - y1, dim=1)\n", - " / torch.norm(dist.reshape(dist.shape[0], -1), dim=1)\n", - " )\n", - " )\n", - "print(torch.tensor(p).max())" + "from deel.torchlip.utils import evaluate_lip_const" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.8950, dtype=torch.float64)\n" + "Empirical lipschitz constant is 0.9999996423721313 with method jacobian_norm\n", + "Empirical lipschitz constant is 0.16946269571781158 with method noise_norm\n", + "Warning : double_attack is set to True, the computation time will be doubled\n", + "Empirical lipschitz constant is 0.9967113137245178 with method attack\n" ] + }, + { + "data": { + "text/plain": [ + "0.9999996423721313" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "p = []\n", - "for batch, _ in train_loader:\n", - " x = batch.numpy()\n", - " y = wass(batch.to(device)).detach().cpu().numpy()\n", - " xd = pdist(x.reshape(batch.shape[0], -1))\n", - " yd = pdist(y.reshape(batch.shape[0], -1))\n", - "\n", - " p.append((yd / xd).max())\n", - "print(torch.tensor(p).max())" + "x,y = next(iter(test_loader))\n", + "evaluate_lip_const(wass, x.to(device), evaluation_type=\"all\", disjoint_neurons=False, double_attack=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As we can see, using the $\\epsilon$-version, we greatly under-estimate the Lipschitz constant.\n", - "Using the train dataset, we find a Lipschitz constant close to 0.9, which is better, but our network should be 1-Lipschitz." + "As we can see, each method provide an underestimation of the Lipschitz constant.\n", + "The adversarial attack method and jacobian norm find values very close to one." ] }, { @@ -396,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -404,41 +386,10 @@ "output_type": "stream", "text": [ "=== Before export ===\n", - "ParametrizedSpectralLinear(\n", - " in_features=784, out_features=128, bias=True\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _SpectralNorm()\n", - " (1): _BjorckNorm()\n", - " )\n", - " )\n", - "), min=0.9999998211860657, max=1.0\n", - "ParametrizedSpectralLinear(\n", - " in_features=128, out_features=64, bias=True\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _SpectralNorm()\n", - " (1): _BjorckNorm()\n", - " )\n", - " )\n", - "), min=0.9999998211860657, max=1.000000238418579\n", - "ParametrizedSpectralLinear(\n", - " in_features=64, out_features=32, bias=True\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _SpectralNorm()\n", - " (1): _BjorckNorm()\n", - " )\n", - " )\n", - "), min=0.9999998807907104, max=1.0\n", - "ParametrizedFrobeniusLinear(\n", - " in_features=32, out_features=1, bias=True\n", - " (parametrizations): ModuleDict(\n", - " (weight): ParametrizationList(\n", - " (0): _FrobeniusNorm()\n", - " )\n", - " )\n", - "), min=0.9999998807907104, max=0.9999998807907104\n" + ", min=0.9999998211860657, max=1.0\n", + ", min=0.9999998211860657, max=1.0000118017196655\n", + ", min=0.9999998211860657, max=1.0\n", + ", min=0.9999998211860657, max=0.9999998211860657\n" ] } ], @@ -449,7 +400,7 @@ " if hasattr(layer, \"weight\"):\n", " w = layer.weight\n", " u, s, v = torch.svd(w)\n", - " print(f\"{layer}, min={s.min()}, max={s.max()}\")" + " print(f\"{type(layer)}, min={s.min()}, max={s.max()}\")" ] }, { @@ -492,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -500,10 +451,10 @@ "output_type": "stream", "text": [ "=== After export ===\n", - "Linear(in_features=784, out_features=128, bias=True), min=0.9999998211860657, max=1.0\n", - "Linear(in_features=128, out_features=64, bias=True), min=0.9999998211860657, max=1.000000238418579\n", - "Linear(in_features=64, out_features=32, bias=True), min=0.9999998807907104, max=1.0\n", - "Linear(in_features=32, out_features=1, bias=True), min=0.9999998807907104, max=0.9999998807907104\n" + ", min=0.9999998211860657, max=1.0\n", + ", min=0.9999998211860657, max=1.0000118017196655\n", + ", min=0.9999998211860657, max=1.0\n", + ", min=0.9999998211860657, max=0.9999998211860657\n" ] } ], @@ -516,7 +467,7 @@ " if hasattr(layer, \"weight\"):\n", " w = layer.weight\n", " u, s, v = torch.svd(w)\n", - " print(f\"{layer}, min={s.min()}, max={s.max()}\")" + " print(f\"{type(layer)}, min={s.min()}, max={s.max()}\")" ] }, { @@ -536,7 +487,7 @@ ], "metadata": { "kernelspec": { - "display_name": "deel-pt1.10", + "display_name": "deel-pt2.4.1", "language": "python", "name": "python3" }, @@ -550,7 +501,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" + "version": "3.11.0" } }, "nbformat": 4, diff --git a/docs/notebooks/wasserstein_classification_fashionMNIST.ipynb b/docs/notebooks/wasserstein_classification_fashionMNIST.ipynb index c7e9880..3965410 100644 --- a/docs/notebooks/wasserstein_classification_fashionMNIST.ipynb +++ b/docs/notebooks/wasserstein_classification_fashionMNIST.ipynb @@ -220,112 +220,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1/50\n", - "loss: 0.1143 - acc: 0.8028 - KR: 0.5592 - val_loss: 0.0130 - val_acc: 0.8087 - val_KR: 0.9613\n", - "Epoch 2/50\n", - "loss: -0.5722 - acc: 0.8465 - KR: 1.2609 - val_loss: -0.3393 - val_acc: 0.8501 - val_KR: 1.5603\n", - "Epoch 3/50\n", - "loss: -0.5658 - acc: 0.8523 - KR: 1.7437 - val_loss: -0.5611 - val_acc: 0.8565 - val_KR: 1.8574\n", - "Epoch 4/50\n", - "loss: -0.4784 - acc: 0.8593 - KR: 1.9847 - val_loss: -0.6535 - val_acc: 0.8647 - val_KR: 2.0086\n", - "Epoch 5/50\n", - "loss: -1.0324 - acc: 0.8627 - KR: 2.0640 - val_loss: -0.7032 - val_acc: 0.8611 - val_KR: 2.0630\n", - "Epoch 6/50\n", - "loss: -1.0510 - acc: 0.8622 - KR: 2.1230 - val_loss: -0.7123 - val_acc: 0.8626 - val_KR: 2.0648\n", - "Epoch 7/50\n", - "loss: -0.8545 - acc: 0.8663 - KR: 2.1496 - val_loss: -0.7847 - val_acc: 0.8579 - val_KR: 2.1603\n", - "Epoch 8/50\n", - "loss: -0.6467 - acc: 0.8686 - KR: 2.1711 - val_loss: -0.7975 - val_acc: 0.8611 - val_KR: 2.1437\n", - "Epoch 9/50\n", - "loss: -1.1468 - acc: 0.8678 - KR: 2.1972 - val_loss: -0.7979 - val_acc: 0.8590 - val_KR: 2.1462\n", - "Epoch 10/50\n", - "loss: -1.1795 - acc: 0.8699 - KR: 2.2124 - val_loss: -0.8491 - val_acc: 0.8651 - val_KR: 2.1691\n", - "Epoch 11/50\n", - "loss: -1.0536 - acc: 0.8726 - KR: 2.2280 - val_loss: -0.8602 - val_acc: 0.8655 - val_KR: 2.2416\n", - "Epoch 12/50\n", - "loss: -0.7020 - acc: 0.8725 - KR: 2.2523 - val_loss: -0.8739 - val_acc: 0.8608 - val_KR: 2.2376\n", - "Epoch 13/50\n", - "loss: -1.1509 - acc: 0.8736 - KR: 2.2529 - val_loss: -0.8627 - val_acc: 0.8668 - val_KR: 2.2465\n", - "Epoch 14/50\n", - "loss: -1.4558 - acc: 0.8745 - KR: 2.2689 - val_loss: -0.9192 - val_acc: 0.8703 - val_KR: 2.2423\n", - "Epoch 15/50\n", - "loss: -0.8483 - acc: 0.8787 - KR: 2.2796 - val_loss: -0.9156 - val_acc: 0.8647 - val_KR: 2.2541\n", - "Epoch 16/50\n", - "loss: -1.1417 - acc: 0.8783 - KR: 2.2773 - val_loss: -0.9071 - val_acc: 0.8645 - val_KR: 2.2815\n", - "Epoch 17/50\n", - "loss: -0.9901 - acc: 0.8793 - KR: 2.2826 - val_loss: -0.8992 - val_acc: 0.8508 - val_KR: 2.2884\n", - "Epoch 18/50\n", - "loss: -1.4158 - acc: 0.8802 - KR: 2.2870 - val_loss: -0.9603 - val_acc: 0.8712 - val_KR: 2.2755\n", - "Epoch 19/50\n", - "loss: -0.8219 - acc: 0.8803 - KR: 2.2909 - val_loss: -0.9188 - val_acc: 0.8620 - val_KR: 2.2752\n", - "Epoch 20/50\n", - "loss: -0.9367 - acc: 0.8816 - KR: 2.2952 - val_loss: -0.9593 - val_acc: 0.8744 - val_KR: 2.2830\n", - "Epoch 21/50\n", - "loss: -1.1548 - acc: 0.8825 - KR: 2.3036 - val_loss: -0.9834 - val_acc: 0.8759 - val_KR: 2.2927\n", - "Epoch 22/50\n", - "loss: -0.2817 - acc: 0.8816 - KR: 2.3021 - val_loss: -0.9607 - val_acc: 0.8705 - val_KR: 2.3175\n", - "Epoch 23/50\n", - "loss: -1.3967 - acc: 0.8834 - KR: 2.3093 - val_loss: -0.9761 - val_acc: 0.8746 - val_KR: 2.2919\n", - "Epoch 24/50\n", - "loss: -1.2609 - acc: 0.8832 - KR: 2.3112 - val_loss: -0.9663 - val_acc: 0.8701 - val_KR: 2.2768\n", - "Epoch 25/50\n", - "loss: -0.8542 - acc: 0.8831 - KR: 2.3132 - val_loss: -1.0023 - val_acc: 0.8759 - val_KR: 2.2672\n", - "Epoch 26/50\n", - "loss: -0.5109 - acc: 0.8842 - KR: 2.3147 - val_loss: -0.9687 - val_acc: 0.8724 - val_KR: 2.2834\n", - "Epoch 27/50\n", - "loss: -1.0551 - acc: 0.8845 - KR: 2.3177 - val_loss: -0.9992 - val_acc: 0.8765 - val_KR: 2.2700\n", - "Epoch 28/50\n", - "loss: -0.5680 - acc: 0.8840 - KR: 2.3223 - val_loss: -0.9859 - val_acc: 0.8727 - val_KR: 2.2740\n", - "Epoch 29/50\n", - "loss: -0.7407 - acc: 0.8861 - KR: 2.3183 - val_loss: -0.9990 - val_acc: 0.8746 - val_KR: 2.3205\n", - "Epoch 30/50\n", - "loss: -0.9009 - acc: 0.8860 - KR: 2.3272 - val_loss: -1.0062 - val_acc: 0.8736 - val_KR: 2.2985\n", - "Epoch 31/50\n", - "loss: -0.8558 - acc: 0.8866 - KR: 2.3306 - val_loss: -1.0032 - val_acc: 0.8766 - val_KR: 2.3080\n", - "Epoch 32/50\n", - "loss: -0.8700 - acc: 0.8858 - KR: 2.3272 - val_loss: -1.0271 - val_acc: 0.8758 - val_KR: 2.3387\n", - "Epoch 33/50\n", - "loss: -1.1969 - acc: 0.8870 - KR: 2.3358 - val_loss: -1.0264 - val_acc: 0.8786 - val_KR: 2.2936\n", - "Epoch 34/50\n", - "loss: -0.9355 - acc: 0.8870 - KR: 2.3349 - val_loss: -0.9799 - val_acc: 0.8714 - val_KR: 2.2941\n", - "Epoch 35/50\n", - "loss: -0.3424 - acc: 0.8861 - KR: 2.3347 - val_loss: -0.9964 - val_acc: 0.8765 - val_KR: 2.3131\n", - "Epoch 36/50\n", - "loss: -0.7138 - acc: 0.8875 - KR: 2.3414 - val_loss: -0.9838 - val_acc: 0.8679 - val_KR: 2.3104\n", - "Epoch 37/50\n", - "loss: -0.5697 - acc: 0.8869 - KR: 2.3425 - val_loss: -0.9909 - val_acc: 0.8770 - val_KR: 2.3115\n", - "Epoch 38/50\n", - "loss: -1.1715 - acc: 0.8877 - KR: 2.3392 - val_loss: -1.0121 - val_acc: 0.8756 - val_KR: 2.3249\n", - "Epoch 39/50\n", - "loss: -1.1520 - acc: 0.8875 - KR: 2.3387 - val_loss: -1.0119 - val_acc: 0.8760 - val_KR: 2.3086\n", - "Epoch 40/50\n", - "loss: -1.2317 - acc: 0.8884 - KR: 2.3398 - val_loss: -1.0162 - val_acc: 0.8784 - val_KR: 2.3025\n", - "Epoch 41/50\n", - "loss: -1.6164 - acc: 0.8882 - KR: 2.3335 - val_loss: -1.0265 - val_acc: 0.8706 - val_KR: 2.3493\n", - "Epoch 42/50\n", - "loss: -0.7563 - acc: 0.8874 - KR: 2.3469 - val_loss: -1.0356 - val_acc: 0.8758 - val_KR: 2.3192\n", - "Epoch 43/50\n", - "loss: -0.8511 - acc: 0.8888 - KR: 2.3455 - val_loss: -1.0013 - val_acc: 0.8692 - val_KR: 2.3379\n", - "Epoch 44/50\n", - "loss: -1.4416 - acc: 0.8887 - KR: 2.3458 - val_loss: -1.0286 - val_acc: 0.8741 - val_KR: 2.3288\n", - "Epoch 45/50\n", - "loss: -0.9940 - acc: 0.8883 - KR: 2.3474 - val_loss: -1.0385 - val_acc: 0.8757 - val_KR: 2.3507\n", - "Epoch 46/50\n", - "loss: -1.3196 - acc: 0.8898 - KR: 2.3540 - val_loss: -1.0151 - val_acc: 0.8728 - val_KR: 2.3284\n", - "Epoch 47/50\n", - "loss: -1.2358 - acc: 0.8892 - KR: 2.3503 - val_loss: -1.0267 - val_acc: 0.8738 - val_KR: 2.3299\n", - "Epoch 48/50\n", - "loss: -1.7127 - acc: 0.8894 - KR: 2.3495 - val_loss: -1.0311 - val_acc: 0.8739 - val_KR: 2.3416\n", - "Epoch 49/50\n", - "loss: -0.8118 - acc: 0.8897 - KR: 2.3514 - val_loss: -1.0220 - val_acc: 0.8688 - val_KR: 2.3330\n", - "Epoch 50/50\n", - "loss: -1.0478 - acc: 0.8896 - KR: 2.3471 - val_loss: -1.0567 - val_acc: 0.8761 - val_KR: 2.3370\n" + "Epoch 1/5\n", + "loss: -0.2979 - acc: 0.8044 - KR: 0.6106 - val_loss: -0.0886 - val_acc: 0.8329 - val_KR: 1.0160\n", + "Epoch 2/5\n", + "loss: -0.6470 - acc: 0.8462 - KR: 1.2746 - val_loss: -0.3422 - val_acc: 0.8482 - val_KR: 1.4850\n", + "Epoch 3/5\n", + "loss: -0.1734 - acc: 0.8511 - KR: 1.6570 - val_loss: -0.4591 - val_acc: 0.8467 - val_KR: 1.7513\n", + "Epoch 4/5\n", + "loss: -0.6604 - acc: 0.8576 - KR: 1.8790 - val_loss: -0.5561 - val_acc: 0.8480 - val_KR: 1.9212\n", + "Epoch 5/5\n", + "loss: -1.0596 - acc: 0.8631 - KR: 1.9943 - val_loss: -0.6679 - val_acc: 0.8570 - val_KR: 2.0105\n" ] } ], "source": [ "loss_choice = \"LseHKRMulticlassLoss\" # \"HKRMulticlassLoss\" or \"SoftHKRMulticlassLoss\"or \"LseHKRMulticlassLoss\"\n", - "epochs = 50\n", + "epochs = 10\n", "\n", "optimizer = torch.optim.Adam(lr=1e-3, params=model.parameters())\n", "hkr_loss = None\n", @@ -401,6 +311,56 @@ " print(\" - \".join(metrics))\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate lip constant for sanity check\n", + "The deel.torchlip.utils.evaluate_lip_const implements several methods to evaluate this constant, either by adding random noise $x+\\epsilon$ and evaluating $\\frac{\\Vert{}F(x + \\epsilon) - F(x)\\Vert{}}{\\Vert{}\\epsilon\\Vert{}}$, or by an adversarial attack on $\\epsilon$ to increase this value, or by computing the jacobian norm $||\\nabla_x F(x)||$\n", + "\n", + "It can be evaluated several times" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from deel.torchlip.utils import evaluate_lip_const" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empirical lipschitz constant is 0.7392665147781372 with method jacobian_norm\n", + "Empirical lipschitz constant is 0.31911221146583557 with method noise_norm\n", + "Warning : double_attack is set to True, the computation time will be doubled\n", + "Empirical lipschitz constant is 0.7712617516517639 with method attack\n" + ] + }, + { + "data": { + "text/plain": [ + "0.7712617516517639" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x,y = next(iter(test_loader))\n", + "evaluate_lip_const(model, x.to(device), evaluation_type=\"all\", disjoint_neurons=True, double_attack=True, expected_value=1.0)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -441,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -450,10 +410,10 @@ "Sequential(\n", " (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=same)\n", " (1): GroupSort2()\n", - " (2): ScaledL2NormPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0)\n", + " (2): LPPool2d(norm_type=2, kernel_size=(2, 2), stride=None, ceil_mode=False)\n", " (3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=same)\n", " (4): GroupSort2()\n", - " (5): ScaledL2NormPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0)\n", + " (5): LPPool2d(norm_type=2, kernel_size=(2, 2), stride=None, ceil_mode=False)\n", " (6): Flatten(start_dim=1, end_dim=-1)\n", " (7): Linear(in_features=1568, out_features=64, bias=True)\n", " (8): GroupSort2()\n", @@ -461,7 +421,7 @@ ")" ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -472,6 +432,37 @@ "vanilla_model.to(device)\n" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empirical lipschitz constant is 0.7392665147781372 with method jacobian_norm\n", + "Empirical lipschitz constant is 0.3411133289337158 with method noise_norm\n", + "Warning : double_attack is set to True, the computation time will be doubled\n", + "Empirical lipschitz constant is 0.6551326513290405 with method attack\n" + ] + }, + { + "data": { + "text/plain": [ + "0.7392665147781372" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x,y = next(iter(test_loader))\n", + "evaluate_lip_const(vanilla_model, x.to(device), evaluation_type=\"all\", disjoint_neurons=True, double_attack=True, expected_value=1.0)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -489,7 +480,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -542,7 +533,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -551,16 +542,16 @@ "text": [ "Image # Certificate Distance to adversarial\n", "---------------------------------------------------\n", - "Image 0 0.349 1.43\n", - "Image 1 1.783 4.59\n", - "Image 2 0.368 1.47\n", - "Image 3 0.647 2.16\n", - "Image 4 0.166 0.56\n", - "Image 5 0.244 0.99\n", - "Image 6 0.108 0.55\n", - "Image 7 0.362 1.31\n", - "Image 8 1.514 3.90\n", - "Image 9 0.217 0.91\n" + "Image 0 0.245 1.13\n", + "Image 1 2.729 5.09\n", + "Image 2 0.414 2.06\n", + "Image 3 0.739 3.56\n", + "Image 4 0.062 0.30\n", + "Image 5 0.428 0.99\n", + "Image 6 0.086 0.50\n", + "Image 7 0.649 1.45\n", + "Image 8 1.493 2.45\n", + "Image 9 0.328 0.91\n" ] } ], @@ -605,12 +596,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/source/wasserstein_classification_MNIST08.rst b/docs/source/wasserstein_classification_MNIST08.rst index c872af4..b4cc946 100644 --- a/docs/source/wasserstein_classification_MNIST08.rst +++ b/docs/source/wasserstein_classification_MNIST08.rst @@ -242,61 +242,61 @@ convolutional layers. .. parsed-literal:: Epoch 1/10 - loss: -0.0272 - KR: 1.4492 - acc: 0.9184 - val_loss: -0.0367 - val_KR: 2.3308 - val_acc: 0.9939 + loss: -0.0341 - KR: 1.2932 - acc: 0.8849 - val_loss: -0.0332 - val_KR: 2.2678 - val_acc: 0.9918 .. parsed-literal:: Epoch 2/10 - loss: -0.0518 - KR: 2.7784 - acc: 0.9926 - val_loss: -0.0574 - val_KR: 3.3190 - val_acc: 0.9939 + loss: -0.0578 - KR: 2.7714 - acc: 0.9918 - val_loss: -0.0588 - val_KR: 3.3804 - val_acc: 0.9928 .. parsed-literal:: Epoch 3/10 - loss: -0.0782 - KR: 3.6303 - acc: 0.9938 - val_loss: -0.0751 - val_KR: 4.1403 - val_acc: 0.9939 + loss: -0.0787 - KR: 3.8889 - acc: 0.9930 - val_loss: -0.0777 - val_KR: 4.5303 - val_acc: 0.9903 .. parsed-literal:: Epoch 4/10 - loss: -0.0978 - KR: 4.5607 - acc: 0.9952 - val_loss: -0.0927 - val_KR: 4.9920 - val_acc: 0.9933 + loss: -0.0989 - KR: 4.8591 - acc: 0.9946 - val_loss: -0.0949 - val_KR: 5.2321 - val_acc: 0.9928 .. parsed-literal:: Epoch 5/10 - loss: -0.0873 - KR: 5.2546 - acc: 0.9958 - val_loss: -0.1037 - val_KR: 5.5868 - val_acc: 0.9944 + loss: -0.1063 - KR: 5.4602 - acc: 0.9948 - val_loss: -0.1064 - val_KR: 5.7756 - val_acc: 0.9923 .. parsed-literal:: Epoch 6/10 - loss: -0.1186 - KR: 5.7066 - acc: 0.9960 - val_loss: -0.1081 - val_KR: 5.9397 - val_acc: 0.9913 + loss: -0.1025 - KR: 5.8678 - acc: 0.9946 - val_loss: -0.1123 - val_KR: 6.0558 - val_acc: 0.9928 .. parsed-literal:: Epoch 7/10 - loss: -0.1189 - KR: 6.0129 - acc: 0.9955 - val_loss: -0.1161 - val_KR: 6.1834 - val_acc: 0.9933 + loss: -0.1155 - KR: 6.0850 - acc: 0.9958 - val_loss: -0.1178 - val_KR: 6.2237 - val_acc: 0.9939 .. parsed-literal:: Epoch 8/10 - loss: -0.1281 - KR: 6.2577 - acc: 0.9958 - val_loss: -0.1151 - val_KR: 6.3653 - val_acc: 0.9923 + loss: -0.0989 - KR: 6.2505 - acc: 0.9957 - val_loss: -0.1193 - val_KR: 6.3435 - val_acc: 0.9933 .. parsed-literal:: Epoch 9/10 - loss: -0.1292 - KR: 6.4227 - acc: 0.9967 - val_loss: -0.1216 - val_KR: 6.5185 - val_acc: 0.9933 + loss: -0.1330 - KR: 6.3675 - acc: 0.9956 - val_loss: -0.1218 - val_KR: 6.4925 - val_acc: 0.9939 .. parsed-literal:: Epoch 10/10 - loss: -0.1375 - KR: 6.5687 - acc: 0.9965 - val_loss: -0.1253 - val_KR: 6.6100 - val_acc: 0.9939 + loss: -0.1272 - KR: 6.4819 - acc: 0.9966 - val_loss: -0.1148 - val_KR: 6.5502 - val_acc: 0.9862 4. Evaluate the Lipschitz constant of our networks @@ -315,56 +315,46 @@ We can estimate the Lipschitz constant by evaluating for various inputs. +The deel.torchlip.utils.evaluate_lip_const implements several methods to +evaluate this constant, either by adding random noise :math:`x+\epsilon` +and evaluating +:math:`\frac{\Vert{}F(x + \epsilon) - F(x)\Vert{}}{\Vert{}\epsilon\Vert{}}`, +or by an adversarial attack on :math:`\epsilon` to increase this value, +or by computing the jacobian norm :math:`||\nabla_x F(x)||` + .. code:: ipython3 - from scipy.spatial.distance import pdist - - wass.eval() - - p = [] - for _ in range(64): - eps = 1e-3 - batch, _ = next(iter(train_loader)) - dist = torch.distributions.Uniform(-eps, +eps).sample(batch.shape) - y1 = wass(batch.to(device)).detach().cpu() - y2 = wass((batch + dist).to(device)).detach().cpu() - - p.append( - torch.max( - torch.norm(y2 - y1, dim=1) - / torch.norm(dist.reshape(dist.shape[0], -1), dim=1) - ) - ) - print(torch.tensor(p).max()) + from deel.torchlip.utils import evaluate_lip_const + +.. code:: ipython3 + + x,y = next(iter(test_loader)) + evaluate_lip_const(wass, x.to(device), evaluation_type="all", disjoint_neurons=False, double_attack=True) .. parsed-literal:: - tensor(0.1420) + Empirical lipschitz constant is 1.0000001192092896 with method jacobian_norm + Empirical lipschitz constant is 0.16324962675571442 with method noise_norm + Warning : double_attack is set to True, the computation time will be doubled -.. code:: ipython3 +.. parsed-literal:: + + Empirical lipschitz constant is 0.9863337874412537 with method attack + - p = [] - for batch, _ in train_loader: - x = batch.numpy() - y = wass(batch.to(device)).detach().cpu().numpy() - xd = pdist(x.reshape(batch.shape[0], -1)) - yd = pdist(y.reshape(batch.shape[0], -1)) - - p.append((yd / xd).max()) - print(torch.tensor(p).max()) .. parsed-literal:: - tensor(0.8841, dtype=torch.float64) + 1.0000001192092896 + -As we can see, using the :math:`\epsilon`-version, we greatly -under-estimate the Lipschitz constant. Using the train dataset, we find -a Lipschitz constant close to 0.9, which is better, but our network -should be 1-Lipschitz. +As we can see, each method provide an underestimation of the Lipschitz +constant. The adversarial attack method and jacobian norm find values +very close to one. 4.1. Singular-Value Decomposition ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -382,47 +372,16 @@ are 1. if hasattr(layer, "weight"): w = layer.weight u, s, v = torch.svd(w) - print(f"{layer}, min={s.min()}, max={s.max()}") + print(f"{type(layer)}, min={s.min()}, max={s.max()}") .. parsed-literal:: === Before export === - ParametrizedSpectralLinear( - in_features=784, out_features=128, bias=True - (parametrizations): ModuleDict( - (weight): ParametrizationList( - (0): _SpectralNorm() - (1): _BjorckNorm() - ) - ) - ), min=0.9999998211860657, max=1.0 - ParametrizedSpectralLinear( - in_features=128, out_features=64, bias=True - (parametrizations): ModuleDict( - (weight): ParametrizationList( - (0): _SpectralNorm() - (1): _BjorckNorm() - ) - ) - ), min=1.000001072883606, max=1.000012755393982 - ParametrizedSpectralLinear( - in_features=64, out_features=32, bias=True - (parametrizations): ModuleDict( - (weight): ParametrizationList( - (0): _SpectralNorm() - (1): _BjorckNorm() - ) - ) - ), min=0.9999998807907104, max=1.0 - ParametrizedFrobeniusLinear( - in_features=32, out_features=1, bias=True - (parametrizations): ModuleDict( - (weight): ParametrizationList( - (0): _FrobeniusNorm() - ) - ) - ), min=1.0000001192092896, max=1.0000001192092896 + , min=0.9999998807907104, max=1.0 + , min=1.000000238418579, max=1.000009536743164 + , min=0.9999998807907104, max=1.0 + , min=0.9999998211860657, max=0.9999998211860657 4.2 Model export @@ -468,17 +427,18 @@ torchlip.SpectralConv2d(…), …) if hasattr(layer, "weight"): w = layer.weight u, s, v = torch.svd(w) - print(f"{layer}, min={s.min()}, max={s.max()}") + print(f"{type(layer)}, min={s.min()}, max={s.max()}") .. parsed-literal:: === After export === - Linear(in_features=784, out_features=128, bias=True), min=0.9999998211860657, max=1.0 - Linear(in_features=128, out_features=64, bias=True), min=1.000001072883606, max=1.000012755393982 - Linear(in_features=64, out_features=32, bias=True), min=0.9999998807907104, max=1.0 - Linear(in_features=32, out_features=1, bias=True), min=1.0000001192092896, max=1.0000001192092896 + , min=0.9999998807907104, max=1.0 + , min=1.000000238418579, max=1.000009536743164 + , min=0.9999998807907104, max=1.0 + , min=0.9999998211860657, max=0.9999998211860657 As we can see, all our singular values are very close to one. +.. container:: alert alert-block alert-danger diff --git a/docs/source/wasserstein_classification_fashionMNIST.rst b/docs/source/wasserstein_classification_fashionMNIST.rst index 4b66f5c..03076a5 100644 --- a/docs/source/wasserstein_classification_fashionMNIST.rst +++ b/docs/source/wasserstein_classification_fashionMNIST.rst @@ -189,8 +189,8 @@ network (proxy of the average certificate). .. code:: ipython3 - loss_choice = "HKRMulticlassLoss" # "HKRMulticlassLoss" or "SoftHKRMulticlassLoss" - epochs = 50 + loss_choice = "LseHKRMulticlassLoss" # "HKRMulticlassLoss" or "SoftHKRMulticlassLoss"or "LseHKRMulticlassLoss" + epochs = 10 optimizer = torch.optim.Adam(lr=1e-3, params=model.parameters()) hkr_loss = None @@ -199,6 +199,8 @@ network (proxy of the average certificate). #hkr_loss = torchlip.HKRMulticlassLoss(alpha=0.999, min_margin=0.10) #Accurate if loss_choice == "SoftHKRMulticlassLoss": hkr_loss = torchlip.SoftHKRMulticlassLoss(alpha=0.995, min_margin=0.10, temperature=50.0) + if loss_choice == "LseHKRMulticlassLoss": + hkr_loss = torchlip.LseHKRMulticlassLoss(alpha=0.9, min_margin=1.0, temperature=10.0) assert hkr_loss is not None, "Please choose a valid loss function" kr_multiclass_loss = torchlip.KRMulticlassLoss() @@ -267,302 +269,104 @@ network (proxy of the average certificate). .. parsed-literal:: - Epoch 1/50 - loss: 0.0161 - acc: 0.7948 - KR: 0.8425 - val_loss: 0.0234 - val_acc: 0.8237 - val_KR: 1.1728 + Epoch 1/10 + loss: -0.2693 - acc: 0.7972 - KR: 0.5558 - val_loss: -0.0116 - val_acc: 0.8260 - val_KR: 0.9576 .. parsed-literal:: - Epoch 2/50 - loss: 0.0144 - acc: 0.8425 - KR: 1.3253 - val_loss: 0.0181 - val_acc: 0.8474 - val_KR: 1.4679 + Epoch 2/10 + loss: -0.1993 - acc: 0.8452 - KR: 1.2355 - val_loss: -0.2956 - val_acc: 0.8405 - val_KR: 1.4672 .. parsed-literal:: - Epoch 3/50 - loss: 0.0040 - acc: 0.8522 - KR: 1.6386 - val_loss: 0.0191 - val_acc: 0.8214 - val_KR: 1.7816 + Epoch 3/10 + loss: 0.2777 - acc: 0.8492 - KR: 1.6947 - val_loss: -0.4993 - val_acc: 0.8537 - val_KR: 1.8740 .. parsed-literal:: - Epoch 4/50 - loss: 0.0046 - acc: 0.8574 - KR: 1.9427 - val_loss: 0.0098 - val_acc: 0.8596 - val_KR: 2.0056 + Epoch 4/10 + loss: -0.8064 - acc: 0.8587 - KR: 1.9901 - val_loss: -0.6347 - val_acc: 0.8482 - val_KR: 2.1012 .. parsed-literal:: - Epoch 5/50 - loss: 0.0000 - acc: 0.8605 - KR: 2.1595 - val_loss: 0.0079 - val_acc: 0.8680 - val_KR: 2.1441 + Epoch 5/10 + loss: -0.3866 - acc: 0.8620 - KR: 2.1168 - val_loss: -0.6561 - val_acc: 0.8511 - val_KR: 2.1361 .. parsed-literal:: - Epoch 6/50 - loss: 0.0049 - acc: 0.8642 - KR: 2.2765 - val_loss: 0.0063 - val_acc: 0.8634 - val_KR: 2.3429 + Epoch 6/10 + loss: -0.7448 - acc: 0.8661 - KR: 2.1675 - val_loss: -0.7269 - val_acc: 0.8569 - val_KR: 2.1996 .. parsed-literal:: - Epoch 7/50 - loss: -0.0053 - acc: 0.8670 - KR: 2.3516 - val_loss: 0.0051 - val_acc: 0.8664 - val_KR: 2.3691 + Epoch 7/10 + loss: -1.1040 - acc: 0.8690 - KR: 2.1988 - val_loss: -0.8093 - val_acc: 0.8603 - val_KR: 2.1904 .. parsed-literal:: - Epoch 8/50 - loss: -0.0021 - acc: 0.8708 - KR: 2.4078 - val_loss: 0.0031 - val_acc: 0.8698 - val_KR: 2.4568 + Epoch 8/10 + loss: -0.8349 - acc: 0.8711 - KR: 2.2264 - val_loss: -0.8304 - val_acc: 0.8632 - val_KR: 2.2228 .. parsed-literal:: - Epoch 9/50 - loss: -0.0072 - acc: 0.8731 - KR: 2.4747 - val_loss: 0.0031 - val_acc: 0.8688 - val_KR: 2.5106 + Epoch 9/10 + loss: -0.6550 - acc: 0.8733 - KR: 2.2433 - val_loss: -0.8590 - val_acc: 0.8683 - val_KR: 2.2457 .. parsed-literal:: - Epoch 10/50 - loss: 0.0009 - acc: 0.8726 - KR: 2.5210 - val_loss: 0.0026 - val_acc: 0.8685 - val_KR: 2.5051 + Epoch 10/10 + loss: -0.5963 - acc: 0.8763 - KR: 2.2583 - val_loss: -0.8937 - val_acc: 0.8685 - val_KR: 2.2552 -.. parsed-literal:: - - Epoch 11/50 - loss: -0.0028 - acc: 0.8751 - KR: 2.5462 - val_loss: 0.0022 - val_acc: 0.8730 - val_KR: 2.5741 - - -.. parsed-literal:: - - Epoch 12/50 - loss: -0.0035 - acc: 0.8751 - KR: 2.5864 - val_loss: 0.0025 - val_acc: 0.8707 - val_KR: 2.5648 - - -.. parsed-literal:: - - Epoch 13/50 - loss: -0.0027 - acc: 0.8764 - KR: 2.5977 - val_loss: 0.0019 - val_acc: 0.8718 - val_KR: 2.6368 - - -.. parsed-literal:: - - Epoch 14/50 - loss: -0.0047 - acc: 0.8789 - KR: 2.6347 - val_loss: 0.0044 - val_acc: 0.8539 - val_KR: 2.6234 - - -.. parsed-literal:: - - Epoch 15/50 - loss: 0.0189 - acc: 0.8788 - KR: 2.6543 - val_loss: 0.0003 - val_acc: 0.8723 - val_KR: 2.5902 - - -.. parsed-literal:: - - Epoch 16/50 - loss: 0.0142 - acc: 0.8793 - KR: 2.6534 - val_loss: 0.0006 - val_acc: 0.8673 - val_KR: 2.6843 - - -.. parsed-literal:: - - Epoch 17/50 - loss: -0.0018 - acc: 0.8809 - KR: 2.6729 - val_loss: 0.0014 - val_acc: 0.8670 - val_KR: 2.7061 - - -.. parsed-literal:: - - Epoch 18/50 - loss: 0.0005 - acc: 0.8805 - KR: 2.6892 - val_loss: 0.0002 - val_acc: 0.8692 - val_KR: 2.6683 - - -.. parsed-literal:: - - Epoch 19/50 - loss: 0.0144 - acc: 0.8814 - KR: 2.7032 - val_loss: 0.0006 - val_acc: 0.8754 - val_KR: 2.6909 - - -.. parsed-literal:: - - Epoch 20/50 - loss: 0.0095 - acc: 0.8827 - KR: 2.7164 - val_loss: 0.0001 - val_acc: 0.8707 - val_KR: 2.7713 - - -.. parsed-literal:: - - Epoch 21/50 - loss: -0.0062 - acc: 0.8815 - KR: 2.7312 - val_loss: -0.0008 - val_acc: 0.8776 - val_KR: 2.7397 - - -.. parsed-literal:: - - Epoch 22/50 - loss: -0.0057 - acc: 0.8834 - KR: 2.7449 - val_loss: -0.0002 - val_acc: 0.8638 - val_KR: 2.7346 - - -.. parsed-literal:: - - Epoch 23/50 - loss: -0.0109 - acc: 0.8844 - KR: 2.7543 - val_loss: -0.0016 - val_acc: 0.8781 - val_KR: 2.7080 - - -.. parsed-literal:: - - Epoch 24/50 - loss: -0.0091 - acc: 0.8844 - KR: 2.7597 - val_loss: -0.0006 - val_acc: 0.8731 - val_KR: 2.7509 - - -.. parsed-literal:: - - Epoch 25/50 - loss: 0.0054 - acc: 0.8839 - KR: 2.7827 - val_loss: -0.0021 - val_acc: 0.8789 - val_KR: 2.7414 - - -.. parsed-literal:: - - Epoch 26/50 - loss: -0.0093 - acc: 0.8865 - KR: 2.7827 - val_loss: -0.0024 - val_acc: 0.8815 - val_KR: 2.7571 - - -.. parsed-literal:: - - Epoch 27/50 - loss: -0.0028 - acc: 0.8854 - KR: 2.7891 - val_loss: -0.0007 - val_acc: 0.8671 - val_KR: 2.8054 - - -.. parsed-literal:: - - Epoch 28/50 - loss: 0.0045 - acc: 0.8848 - KR: 2.8087 - val_loss: -0.0005 - val_acc: 0.8765 - val_KR: 2.7992 - - -.. parsed-literal:: - - Epoch 29/50 - loss: -0.0050 - acc: 0.8855 - KR: 2.8126 - val_loss: -0.0003 - val_acc: 0.8716 - val_KR: 2.7960 - - -.. parsed-literal:: - - Epoch 30/50 - loss: -0.0090 - acc: 0.8858 - KR: 2.8186 - val_loss: -0.0015 - val_acc: 0.8727 - val_KR: 2.7698 - +Evaluate lip constant for sanity check +-------------------------------------- -.. parsed-literal:: - - Epoch 31/50 - loss: -0.0086 - acc: 0.8882 - KR: 2.8209 - val_loss: -0.0029 - val_acc: 0.8752 - val_KR: 2.8335 - - -.. parsed-literal:: - - Epoch 32/50 - loss: -0.0064 - acc: 0.8871 - KR: 2.8258 - val_loss: -0.0030 - val_acc: 0.8820 - val_KR: 2.8266 - - -.. parsed-literal:: - - Epoch 33/50 - loss: -0.0086 - acc: 0.8882 - KR: 2.8410 - val_loss: -0.0025 - val_acc: 0.8742 - val_KR: 2.8252 - - -.. parsed-literal:: - - Epoch 34/50 - loss: -0.0157 - acc: 0.8873 - KR: 2.8518 - val_loss: -0.0021 - val_acc: 0.8736 - val_KR: 2.7995 - - -.. parsed-literal:: - - Epoch 35/50 - loss: 0.0009 - acc: 0.8877 - KR: 2.8418 - val_loss: -0.0028 - val_acc: 0.8739 - val_KR: 2.8467 - - -.. parsed-literal:: - - Epoch 36/50 - loss: -0.0137 - acc: 0.8882 - KR: 2.8552 - val_loss: -0.0023 - val_acc: 0.8778 - val_KR: 2.8063 - - -.. parsed-literal:: - - Epoch 37/50 - loss: -0.0103 - acc: 0.8881 - KR: 2.8597 - val_loss: -0.0023 - val_acc: 0.8720 - val_KR: 2.8331 - - -.. parsed-literal:: - - Epoch 38/50 - loss: -0.0100 - acc: 0.8897 - KR: 2.8594 - val_loss: -0.0033 - val_acc: 0.8811 - val_KR: 2.8638 +The deel.torchlip.utils.evaluate_lip_const implements several methods to +evaluate this constant, either by adding random noise :math:`x+\epsilon` +and evaluating +:math:`\frac{\Vert{}F(x + \epsilon) - F(x)\Vert{}}{\Vert{}\epsilon\Vert{}}`, +or by an adversarial attack on :math:`\epsilon` to increase this value, +or by computing the jacobian norm :math:`||\nabla_x F(x)||` +It can be evaluated several times -.. parsed-literal:: - - Epoch 39/50 - loss: -0.0047 - acc: 0.8887 - KR: 2.8630 - val_loss: -0.0035 - val_acc: 0.8801 - val_KR: 2.8755 - - -.. parsed-literal:: - - Epoch 40/50 - loss: -0.0047 - acc: 0.8902 - KR: 2.8691 - val_loss: -0.0023 - val_acc: 0.8752 - val_KR: 2.8752 - - -.. parsed-literal:: - - Epoch 41/50 - loss: -0.0085 - acc: 0.8897 - KR: 2.8753 - val_loss: -0.0018 - val_acc: 0.8756 - val_KR: 2.8190 - - -.. parsed-literal:: - - Epoch 42/50 - loss: -0.0170 - acc: 0.8892 - KR: 2.8745 - val_loss: -0.0034 - val_acc: 0.8807 - val_KR: 2.8524 - - -.. parsed-literal:: - - Epoch 43/50 - loss: -0.0025 - acc: 0.8909 - KR: 2.8805 - val_loss: -0.0030 - val_acc: 0.8811 - val_KR: 2.8388 - - -.. parsed-literal:: - - Epoch 44/50 - loss: -0.0093 - acc: 0.8922 - KR: 2.8824 - val_loss: -0.0034 - val_acc: 0.8805 - val_KR: 2.8573 +.. code:: ipython3 + from deel.torchlip.utils import evaluate_lip_const -.. parsed-literal:: +.. code:: ipython3 - Epoch 45/50 - loss: -0.0065 - acc: 0.8898 - KR: 2.8861 - val_loss: -0.0027 - val_acc: 0.8763 - val_KR: 2.8508 + x,y = next(iter(test_loader)) + evaluate_lip_const(model, x.to(device), evaluation_type="all", disjoint_neurons=True, double_attack=True, expected_value=1.0) .. parsed-literal:: - Epoch 46/50 - loss: -0.0046 - acc: 0.8908 - KR: 2.8799 - val_loss: -0.0038 - val_acc: 0.8808 - val_KR: 2.8540 + Empirical lipschitz constant is 0.7989310622215271 with method jacobian_norm + Empirical lipschitz constant is 0.2884121835231781 with method noise_norm + Warning : double_attack is set to True, the computation time will be doubled .. parsed-literal:: - Epoch 47/50 - loss: -0.0141 - acc: 0.8902 - KR: 2.8932 - val_loss: -0.0037 - val_acc: 0.8794 - val_KR: 2.8714 + Empirical lipschitz constant is 0.6641454100608826 with method attack -.. parsed-literal:: - - Epoch 48/50 - loss: -0.0101 - acc: 0.8912 - KR: 2.8959 - val_loss: -0.0033 - val_acc: 0.8789 - val_KR: 2.8827 .. parsed-literal:: - Epoch 49/50 - loss: -0.0111 - acc: 0.8918 - KR: 2.8873 - val_loss: -0.0040 - val_acc: 0.8859 - val_KR: 2.9193 - - -.. parsed-literal:: + 0.7989310622215271 - Epoch 50/50 - loss: -0.0008 - acc: 0.8933 - KR: 2.9104 - val_loss: -0.0041 - val_acc: 0.8818 - val_KR: 2.8705 4. Model export @@ -625,6 +429,32 @@ torchlip.SpectralConv2d(…), …) +.. code:: ipython3 + + x,y = next(iter(test_loader)) + evaluate_lip_const(vanilla_model, x.to(device), evaluation_type="all", disjoint_neurons=True, double_attack=True, expected_value=1.0) + + +.. parsed-literal:: + + Empirical lipschitz constant is 0.7989310622215271 with method jacobian_norm + Empirical lipschitz constant is 0.3023391366004944 with method noise_norm + Warning : double_attack is set to True, the computation time will be doubled + + +.. parsed-literal:: + + Empirical lipschitz constant is 0.7989276051521301 with method attack + + + + +.. parsed-literal:: + + 0.7989310622215271 + + + 5. Robustness evaluation: certificate generation and adversarial attacks ------------------------------------------------------------------------ @@ -710,16 +540,16 @@ gradient norm preserving, other attacks gives very similar results. Image # Certificate Distance to adversarial --------------------------------------------------- - Image 0 0.309 1.29 - Image 1 1.864 4.65 - Image 2 0.397 1.56 - Image 3 0.527 2.81 - Image 4 0.105 0.44 - Image 5 0.188 0.82 - Image 6 0.053 0.26 - Image 7 0.450 1.62 - Image 8 1.488 3.91 - Image 9 0.161 0.69 + Image 0 0.422 1.62 + Image 1 3.149 5.18 + Image 2 0.339 1.70 + Image 3 0.852 1.57 + Image 4 0.176 0.80 + Image 5 0.443 0.94 + Image 6 0.101 0.66 + Image 7 0.858 1.76 + Image 8 2.034 3.98 + Image 9 0.336 0.90 Finally, we can take a visual look at the obtained images. When looking @@ -797,5 +627,5 @@ properties: -.. image:: wasserstein_classification_fashionMNIST_files/wasserstein_classification_fashionMNIST_16_0.png +.. image:: wasserstein_classification_fashionMNIST_files/wasserstein_classification_fashionMNIST_20_0.png diff --git a/docs/source/wasserstein_classification_fashionMNIST_files/wasserstein_classification_fashionMNIST_16_0.png b/docs/source/wasserstein_classification_fashionMNIST_files/wasserstein_classification_fashionMNIST_16_0.png deleted file mode 100644 index f0c4e8cddf01a47cf7b436e37064e625924873e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 107422 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 literal 0 HcmV?d00001 From 783f27f3a8bc1098a1bbd8b785dcb7ddb29f9cac Mon Sep 17 00:00:00 2001 From: Franck Mamalet <49721198+franckma31@users.noreply.github.com> Date: Fri, 17 Oct 2025 21:43:52 +0200 Subject: [PATCH 3/4] add docstring, mutualize disjoint neuron computation in _compute_disjoint_neurons_lip_const --- deel/torchlip/utils/evaluate_lip_const.py | 66 ++++++++++++++++++----- 1 file changed, 54 insertions(+), 12 deletions(-) diff --git a/deel/torchlip/utils/evaluate_lip_const.py b/deel/torchlip/utils/evaluate_lip_const.py index 1d20ef8..b1427c0 100644 --- a/deel/torchlip/utils/evaluate_lip_const.py +++ b/deel/torchlip/utils/evaluate_lip_const.py @@ -43,6 +43,23 @@ def evaluate_lip_const( expected_value=None, **kwargs, ) -> float: + """ + Evaluate the Lipschitz constant of a model, using different methods. + Please note that the estimation of the lipschitz constant is done locally around + input samples. This may not correctly estimate the behaviour in the whole domain. + Args: + model: built torch model used to make predictions + x: inputs used to compute the lipschitz constant. If None, input_shape must be + provided to generate random inputs. (shape: (batch_size, ...)) + evaluation_type: method used to evaluate the lipschitz constant. Can be one of + "jacobian_norm", "noise_norm", "attack" or "all". + disjoint_neurons: if True, each output neuron is considered as a separate + 1-Lipschitz function. + input_shape: shape of the input tensor, used if x is None. + expected_value: if provided, the computed lipschitz constant is compared to + this value and an assertion error is raised if the computed value is higher + (warning the assertion is strict). + """ type2fct = { "jacobian_norm": evaluate_lip_const_jacobian_norm, "noise_norm": evaluate_lip_const_noise_norm, @@ -97,15 +114,29 @@ def evaluate_lip_const_noise_norm( x: torch.Tensor, disjoint_neurons=False, num_noisy_samples: int = 10, + epsilon_noise: float = 1.0, **kwargs, ) -> float: - + """ + Evaluate the Lipschitz constant of a model, using random noise added to the input. + Please note that the estimation of the lipschitz constant is done locally around + input samples. This may not correctly estimate the behaviour in the whole domain. + Args: + model: built torch model used to make predictions + x: inputs used to compute the lipschitz constant (shape: (batch_size, ...)) + disjoint_neurons: if True, each output neuron is considered as a separate + 1-Lipschitz function. + num_noisy_samples: number of random noise samples to use for the estimation + epsilon_noise: standard deviation of the gaussian noise added to the input + Returns: + float: the empirically evaluated Lipschitz constant (max over batch). + """ with torch.no_grad(): model.eval() pred = model(x) lip_csts = [] for _ in range(num_noisy_samples): # random sampling - noise = torch.randn_like(x) * torch.rand(1).to(x.device) + noise = epsilon_noise * torch.randn_like(x) * torch.rand(1).to(x.device) noisy_input = x + noise noisy_pred = model(noisy_input) if not disjoint_neurons: @@ -138,8 +169,10 @@ def evaluate_lip_const_jacobian_norm( input samples. This may not correctly estimate the behaviour in the whole domain. Args: - model: built keras model used to make predictions + model: built torch model used to make predictions x: inputs used to compute the lipschitz constant + disjoint_neurons: if True, each output neuron is considered as a separate + 1-Lipschitz function. Returns: float: the empirically evaluated Lipschitz constant. The computation might also @@ -179,6 +212,17 @@ def model_func(x): return float(torch.max(lip_cst).item()) +def _compute_disjoint_neurons_lip_const( + ref_output: torch.Tensor, noisy_pred: torch.Tensor +) -> torch.Tensor: + # each output neuron is a 1Lipschitz function: attack the maximum + diff_pred = ref_output - noisy_pred + diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) + pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) + pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values + return pred_diff_norm + + def evaluate_lip_const_attack( model: torch.nn.Module, x: torch.Tensor, @@ -194,8 +238,10 @@ def evaluate_lip_const_attack( input samples. This may not correctly estimate the behaviour in the whole domain. Args: - model: built keras model used to make predictions + model: built torch model used to make predictions x: inputs used to compute the lipschitz constant + disjoint_neurons: if True, each output neuron is considered as a separate + 1-Lipschitz function. num_iterations: number of iterations for the attack step_size: step size for each iteration double_attack: if True, perform a second attack starting from the worst case @@ -224,10 +270,9 @@ def attack_lip_const(model, x, step_size, num_iterations): ) else: # each output neuron is a 1Lipschitz function: attack the maximum - diff_pred = ref_output - noisy_pred - diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) - pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) - pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values + pred_diff_norm = _compute_disjoint_neurons_lip_const( + ref_output, noisy_pred + ) input_diff_norm = torch.linalg.norm( noise.view(ref_output.shape[0], -1), dim=1 ) @@ -246,10 +291,7 @@ def attack_lip_const(model, x, step_size, num_iterations): ) else: # each output neuron is a 1Lipschitz function: attack the maximum - diff_pred = ref_output - noisy_pred - diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) - pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) - pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values + pred_diff_norm = _compute_disjoint_neurons_lip_const(ref_output, noisy_pred) input_diff_norm = torch.linalg.norm(noise.view(ref_output.shape[0], -1), dim=1) lip_cst = pred_diff_norm / input_diff_norm return noise, lip_cst From 2ff6b635ee69c43115b48a750912205fbd1380a7 Mon Sep 17 00:00:00 2001 From: Franck Mamalet <49721198+franckma31@users.noreply.github.com> Date: Sun, 19 Oct 2025 20:53:39 +0000 Subject: [PATCH 4/4] change disjoint_neuron to keep channel dimension (1) --- deel/torchlip/utils/evaluate_lip_const.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/deel/torchlip/utils/evaluate_lip_const.py b/deel/torchlip/utils/evaluate_lip_const.py index b1427c0..0411038 100644 --- a/deel/torchlip/utils/evaluate_lip_const.py +++ b/deel/torchlip/utils/evaluate_lip_const.py @@ -217,9 +217,9 @@ def _compute_disjoint_neurons_lip_const( ) -> torch.Tensor: # each output neuron is a 1Lipschitz function: attack the maximum diff_pred = ref_output - noisy_pred - diff_pred = diff_pred.view(diff_pred.shape[0], -1, diff_pred.shape[-1]) - pred_diff_norm = torch.linalg.norm(diff_pred, dim=1) - pred_diff_norm = torch.max(pred_diff_norm, dim=-1).values + diff_pred = diff_pred.view(diff_pred.shape[0], diff_pred.shape[1], -1) + pred_diff_norm = torch.linalg.norm(diff_pred, dim=-1) + pred_diff_norm = torch.max(pred_diff_norm, dim=1).values return pred_diff_norm