From b9043fd7ea9b7e41683dca83f44c56aa79a82570 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 15 Jul 2022 13:57:26 +0100 Subject: [PATCH 01/37] Initial kernel change for pytorch --- alibi_detect/utils/pytorch/kernels.py | 241 ++++++++++++++++++++++++-- 1 file changed, 231 insertions(+), 10 deletions(-) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 7d01005b8..3ca2555ca 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -29,12 +29,66 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. return sigma -class GaussianRBF(nn.Module): +class BaseKernel(nn.Module): + """ + The base class for all kernels. + Args: + nn (_type_): _description_ + """ + def __init__(self) -> None: + super().__init__() + self.parameter_dict: dict = {} + self.active_dims: Optional[list] = None + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + raise NotImplementedError + + +class SumKernel(nn.Module): + """ + Construct a kernel by summing two kernels. + Args: + nn (_type_): _description_ + """ def __init__( self, - sigma: Optional[torch.Tensor] = None, - init_sigma_fn: Callable = sigma_median, - trainable: bool = False + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return self.kernel_a(x, y) + self.kernel_b(x, y) + + +class ProductKernel(nn.Module): + """ + Construct a kernel by multiplying two kernels. + Args: + nn (_type_): _description_ + """ + def __init__( + self, + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return self.kernel_a(x, y) * self.kernel_b(x, y) + + +class GaussianRBF(BaseKernel): + def __init__( + self, + sigma: Optional[torch.Tensor] = None, + init_fn_sigma: Callable = sigma_median, + trainable: bool = False, + active_dims: Optional[list] = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -54,28 +108,28 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. """ super().__init__() + self.parameter_dict['sigma'] = 'bandwidth' if sigma is None: self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) self.init_required = True else: - sigma = sigma.reshape(-1) # [Ns,] self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) self.init_required = False - self.init_sigma_fn = init_sigma_fn - self.trainable = trainable + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims @property def sigma(self) -> torch.Tensor: return self.log_sigma.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_sigma: bool = False) -> torch.Tensor: + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] - if infer_sigma or self.init_required: - if self.trainable and infer_sigma: + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") sigma = self.init_sigma_fn(x, y, dist) with torch.no_grad(): @@ -88,6 +142,173 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat.mean(dim=0) # [Nx, Ny] +class RationalQuadratic(nn.Module): + def __init__( + self, + alpha: torch.Tensor = None, + init_fn_alpha: Callable = None, + sigma: torch.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + alpha + Exponent parameter of the kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['alpha'] = 'exponent' + self.parameter_dict['sigma'] = 'bandwidth' + if alpha is None: + self.alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.alpha = alpha + self.init_required = False + if sigma is None: + self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) + self.init_required = False + self.init_fn_alpha = init_fn_alpha + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + + @property + def sigma(self) -> torch.Tensor: + return self.log_sigma.exp() + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + return kernel_mat + + +class Periodic(nn.Module): + def __init__( + self, + tau: torch.Tensor = None, + init_fn_tau: Callable = None, + sigma: torch.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + + @property + def tau(self) -> torch.Tensor: + return self.log_tau.exp() + + @property + def sigma(self) -> torch.Tensor: + return self.log_sigma.exp() + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) + return kernel_mat + + +class LocalPeriodic(nn.Module): + def __init__( + self, + tau: torch.Tensor = None, + init_fn_tau: Callable = None, + sigma: torch.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Local periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + + @property + def tau(self) -> torch.Tensor: + return self.log_tau.exp() + + @property + def sigma(self) -> torch.Tensor: + return self.log_sigma.exp() + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ + torch.exp(-0.5 * torch.square(dist / self.tau)) + return kernel_mat + + class DeepKernel(nn.Module): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). From b5f48c5173870b77b407cb5f4ffd0d84548463ce Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 21 Jul 2022 11:17:54 +0100 Subject: [PATCH 02/37] Change torch kernel-based methods to support new kernel behaviours. --- alibi_detect/cd/base.py | 20 ++++---- alibi_detect/cd/context_aware.py | 7 ++- alibi_detect/cd/lsdd.py | 3 +- alibi_detect/cd/lsdd_online.py | 4 +- alibi_detect/cd/pytorch/context_aware.py | 60 +++++++++++++----------- alibi_detect/cd/pytorch/lsdd.py | 27 ++++++----- alibi_detect/cd/pytorch/lsdd_online.py | 23 +++++---- alibi_detect/cd/pytorch/mmd.py | 27 ++++++----- alibi_detect/cd/pytorch/mmd_online.py | 17 ++++--- alibi_detect/utils/pytorch/kernels.py | 20 +++++--- 10 files changed, 120 insertions(+), 88 deletions(-) diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index 690bc39f9..1e88189a0 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -462,7 +462,7 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -502,12 +502,13 @@ def __init__( if p_val is None: logger.warning('No p-value set for the drift threshold. Need to set it to detect data drift.') - self.infer_sigma = configure_kernel_from_x_ref - if configure_kernel_from_x_ref and isinstance(sigma, np.ndarray): - self.infer_sigma = False - logger.warning('`sigma` is specified for the kernel and `configure_kernel_from_x_ref` ' - 'is set to True. `sigma` argument takes priority over ' - '`configure_kernel_from_x_ref` (set to False).') + self.infer_parameter = configure_kernel_from_x_ref + # self.infer_sigma = configure_kernel_from_x_ref + # if configure_kernel_from_x_ref and isinstance(sigma, np.ndarray): + # self.infer_sigma = False + # logger.warning('`sigma` is specified for the kernel and `configure_kernel_from_x_ref` ' + # 'is set to True. `sigma` argument takes priority over ' + # '`configure_kernel_from_x_ref` (set to False).') # optionally already preprocess reference data self.p_val = p_val @@ -612,7 +613,8 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # kernel: BaseKernel = None, + # sigma: Optional[np.ndarray] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -665,7 +667,7 @@ def __init__( self.x_ref = preprocess_fn(x_ref) else: self.x_ref = x_ref - self.sigma = sigma + # self.sigma = sigma self.preprocess_x_ref = preprocess_x_ref self.update_x_ref = update_x_ref self.preprocess_fn = preprocess_fn diff --git a/alibi_detect/cd/context_aware.py b/alibi_detect/cd/context_aware.py index 4037242a3..06f282008 100644 --- a/alibi_detect/cd/context_aware.py +++ b/alibi_detect/cd/context_aware.py @@ -2,6 +2,7 @@ import numpy as np from typing import Callable, Dict, Optional, Union, Tuple from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow +from alibi_detect.utils.pytorch.kernels import BaseKernel if has_pytorch: from alibi_detect.cd.pytorch.context_aware import ContextMMDDriftTorch @@ -22,8 +23,10 @@ def __init__( preprocess_x_ref: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: Callable = None, - c_kernel: Callable = None, + # x_kernel: Callable = None, + x_kernel: BaseKernel = None, + # c_kernel: Callable = None, + c_kernel: BaseKernel = None, n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, diff --git a/alibi_detect/cd/lsdd.py b/alibi_detect/cd/lsdd.py index bed6f7a1e..d182a976e 100644 --- a/alibi_detect/cd/lsdd.py +++ b/alibi_detect/cd/lsdd.py @@ -18,7 +18,8 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + # kernel: BaseKernel = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index 7a572acf8..4914c4681 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -1,6 +1,7 @@ import numpy as np from typing import Any, Callable, Dict, Optional, Union from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow +from alibi_detect.utils.pytorch.kernels import BaseKernel if has_pytorch: from alibi_detect.cd.pytorch.lsdd_online import LSDDDriftOnlineTorch @@ -17,7 +18,8 @@ def __init__( window_size: int, backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index cda6c12fe..b737b71dc 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -4,13 +4,36 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseContextMMDDrift from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.cd._domain_clf import _SVCDomainClf from tqdm import tqdm logger = logging.getLogger(__name__) +def _sigma_median_diag(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + """ + Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.pytorch.kernels.sigma_median`, + with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The computed bandwidth, `sigma`. + """ + n_median = np.prod(dist.shape) // 2 + sigma = (.5 * dist.flatten().sort().values[n_median].unsqueeze(dim=-1)) ** .5 + return sigma + + class ContextMMDDriftTorch(BaseContextMMDDrift): lams: Optional[Tuple[torch.Tensor, torch.Tensor]] = None @@ -22,8 +45,10 @@ def __init__( preprocess_x_ref: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: Callable = GaussianRBF, - c_kernel: Callable = GaussianRBF, + # x_kernel: Callable = GaussianRBF, + x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), + # c_kernel: Callable = GaussianRBF, + c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -98,8 +123,10 @@ def __init__( self.device = get_device(device) # initialize kernel - self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel + # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + self.x_kernel = x_kernel + self.c_kernel = c_kernel # Initialize classifier (hardcoded for now) self.clf = _SVCDomainClf(self.c_kernel) @@ -244,26 +271,3 @@ def _pick_lam(self, lams: torch.Tensor, K: torch.Tensor, L: torch.Tensor, n_fold kxx = torch.ones_like(lWk).to(lWk.device) * torch.max(K) losses += (lWKWl + kxx - 2*lWk).sum(-1) return lams[torch.argmin(losses)] - - -def _sigma_median_diag(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: - """ - Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.pytorch.kernels.sigma_median`, - with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. - - Parameters - ---------- - x - Tensor of instances with dimension [Nx, features]. - y - Tensor of instances with dimension [Ny, features]. - dist - Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. - - Returns - ------- - The computed bandwidth, `sigma`. - """ - n_median = np.prod(dist.shape) // 2 - sigma = (.5 * dist.flatten().sort().values[n_median].unsqueeze(dim=-1)) ** .5 - return sigma diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 640c8bc48..43d417ca0 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -3,7 +3,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.pytorch.distance import permed_lsdds @@ -15,7 +15,8 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -67,7 +68,8 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, + # kernel=kernel, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -83,24 +85,25 @@ def __init__( # in the method signature, so we can't cast it to torch.Tensor unless we change the signature # to also accept torch.Tensor. We also can't redefine it's type as that would involve enabling # --allow-redefinitions in mypy settings (which we might do eventually). + self.kernel = kernel if self.preprocess_x_ref or self.preprocess_fn is None: x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) # type: ignore[arg-type] + # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - def _initialize_kernel(self, x_ref: torch.Tensor): - if self.sigma is None: - self.kernel = GaussianRBF() - _ = self.kernel(x_ref, x_ref, infer_sigma=True) - else: - sigma = torch.from_numpy(self.sigma) - self.kernel = GaussianRBF(sigma) + # def _initialize_kernel(self, x_ref: torch.Tensor): + # if self.sigma is None: + # self.kernel = GaussianRBF() + # _ = self.kernel(x_ref, x_ref, infer_sigma=True) + # else: + # sigma = torch.from_numpy(self.sigma) + # self.kernel = GaussianRBF(sigma) def _configure_normalization(self, x_ref: torch.Tensor, eps: float = 1e-12): x_ref_means = x_ref.mean(0) @@ -140,7 +143,7 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_x_ref is False: self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) # type: ignore[arg-type] + # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index f526deb89..7cecbeaf3 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -4,7 +4,8 @@ from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch import GaussianRBF, permed_lsdds, quantile +from alibi_detect.utils.pytorch import permed_lsdds, quantile +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF class LSDDDriftOnlineTorch(BaseMultiDriftOnline): @@ -14,7 +15,8 @@ def __init__( ert: float, window_size: int, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -86,14 +88,15 @@ def __init__( self._configure_normalization() # initialize kernel - if sigma is None: - x_ref = torch.from_numpy(self.x_ref).to(self.device) # type: ignore[assignment] - self.kernel = GaussianRBF() - _ = self.kernel(x_ref, x_ref, infer_sigma=True) - else: - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] + # if sigma is None: + # x_ref = torch.from_numpy(self.x_ref).to(self.device) # type: ignore[assignment] + # self.kernel = GaussianRBF() + # _ = self.kernel(x_ref, x_ref, infer_sigma=True) + # else: + # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] + # np.ndarray) else None + # self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] + self.kernel = kernel if self.n_kernel_centers is None: self.n_kernel_centers = 2 * window_size diff --git a/alibi_detect/cd/pytorch/mmd.py b/alibi_detect/cd/pytorch/mmd.py index 1bb6ffe0b..72dd62fce 100644 --- a/alibi_detect/cd/pytorch/mmd.py +++ b/alibi_detect/cd/pytorch/mmd.py @@ -5,7 +5,7 @@ from alibi_detect.cd.base import BaseMMDDrift from alibi_detect.utils.pytorch import get_device from alibi_detect.utils.pytorch.distance import mmd2_from_kernel_matrix -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF logger = logging.getLogger(__name__) @@ -18,8 +18,9 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + # kernel: Callable = GaussianRBF, + kernel: BaseKernel = GaussianRBF(), + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -66,7 +67,7 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -78,21 +79,23 @@ def __init__( self.device = get_device(device) # initialize kernel - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] + # np.ndarray) else None + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data - if self.infer_sigma or isinstance(sigma, torch.Tensor): + # if self.infer_sigma or isinstance(sigma, torch.Tensor): + if self.infer_parameter: x = torch.from_numpy(self.x_ref).to(self.device) - self.k_xx = self.kernel(x, x, infer_sigma=self.infer_sigma) - self.infer_sigma = False + self.k_xx = self.kernel(x, x, infer_parameter=self.infer_parameter) + self.infer_parameter = False else: - self.k_xx, self.infer_sigma = None, True + self.k_xx, self.infer_parameter = None, True def kernel_matrix(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """ Compute and return full kernel matrix between arrays x and y. """ - k_xy = self.kernel(x, y, self.infer_sigma) + k_xy = self.kernel(x, y, self.infer_parameter) k_xx = self.k_xx if self.k_xx is not None and self.update_x_ref is None else self.kernel(x, x) k_yy = self.kernel(y, y) kernel_mat = torch.cat([torch.cat([k_xx, k_xy], 1), torch.cat([k_xy.T, k_yy], 1)], 0) diff --git a/alibi_detect/cd/pytorch/mmd_online.py b/alibi_detect/cd/pytorch/mmd_online.py index bc925c259..b0a9acf07 100644 --- a/alibi_detect/cd/pytorch/mmd_online.py +++ b/alibi_detect/cd/pytorch/mmd_online.py @@ -4,7 +4,7 @@ from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.pytorch import zero_diag, quantile @@ -15,8 +15,9 @@ def __init__( ert: float, window_size: int, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), + # kernel: Callable = GaussianRBF, + # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -75,13 +76,15 @@ def __init__( self.device = get_device(device) # initialize kernel - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] + # np.ndarray) else None + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data self.x_ref = torch.from_numpy(self.x_ref).to(self.device) - self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() self._initialise() diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 3ca2555ca..7e6b442ba 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -117,6 +117,7 @@ def __init__( self.init_required = False self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable @property def sigma(self) -> torch.Tensor: @@ -131,7 +132,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch if infer_parameter or self.init_required: if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_sigma_fn(x, y, dist) + sigma = self.init_fn_sigma(x, y, dist) with torch.no_grad(): self.log_sigma.copy_(sigma.log().clone()) self.init_required = False @@ -142,7 +143,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat.mean(dim=0) # [Nx, Ny] -class RationalQuadratic(nn.Module): +class RationalQuadratic(BaseKernel): def __init__( self, alpha: torch.Tensor = None, @@ -168,10 +169,10 @@ def __init__( self.parameter_dict['alpha'] = 'exponent' self.parameter_dict['sigma'] = 'bandwidth' if alpha is None: - self.alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.raw_alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) self.init_required = True else: - self.alpha = alpha + self.raw_alpha = nn.Parameter(alpha, requires_grad=trainable) self.init_required = False if sigma is None: self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) @@ -182,6 +183,11 @@ def __init__( self.init_fn_alpha = init_fn_alpha self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable + + @property + def alpha(self) -> torch.Tensor: + return self.raw_alpha @property def sigma(self) -> torch.Tensor: @@ -194,7 +200,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat -class Periodic(nn.Module): +class Periodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, @@ -234,6 +240,7 @@ def __init__( self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable @property def tau(self) -> torch.Tensor: @@ -251,7 +258,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat -class LocalPeriodic(nn.Module): +class LocalPeriodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, @@ -291,6 +298,7 @@ def __init__( self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable @property def tau(self) -> torch.Tensor: From 27be93b079da6ef9eab3c4cd6d5d95c99e7e8afb Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 25 Jul 2022 22:32:08 +0100 Subject: [PATCH 03/37] Initial TF implementation added. --- alibi_detect/cd/mmd.py | 4 +- alibi_detect/cd/tensorflow/context_aware.py | 60 +++-- alibi_detect/cd/tensorflow/lsdd.py | 26 +- alibi_detect/cd/tensorflow/lsdd_online.py | 19 +- alibi_detect/cd/tensorflow/mmd.py | 24 +- alibi_detect/cd/tensorflow/mmd_online.py | 17 +- alibi_detect/utils/tensorflow/kernels.py | 283 +++++++++++++++++++- 7 files changed, 357 insertions(+), 76 deletions(-) diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 0da0dec5b..1e645d0d7 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -22,7 +22,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: Callable = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -84,7 +84,7 @@ def __init__( from alibi_detect.utils.tensorflow.kernels import GaussianRBF else: from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore - kwargs.update({'kernel': GaussianRBF}) + kwargs.update({'kernel': GaussianRBF()}) if backend == 'tensorflow' and has_tensorflow: kwargs.pop('device', None) diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index fffaf3f53..c4a48d983 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -4,13 +4,36 @@ import tensorflow_probability as tfp from typing import Callable, Dict, Optional, Tuple, Union, List from alibi_detect.cd.base import BaseContextMMDDrift -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel from alibi_detect.cd._domain_clf import _SVCDomainClf from tqdm import tqdm logger = logging.getLogger(__name__) +def _sigma_median_diag(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + """ + Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`, + with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The computed bandwidth, `sigma`. + """ + n_median = tf.math.reduce_prod(dist.shape) // 2 + sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) + return sigma + + class ContextMMDDriftTF(BaseContextMMDDrift): lams: Optional[Tuple[tf.Tensor, tf.Tensor]] @@ -22,8 +45,10 @@ def __init__( preprocess_x_ref: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: Callable = GaussianRBF, - c_kernel: Callable = GaussianRBF, + # x_kernel: Callable = GaussianRBF, + x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), + # c_kernel: Callable = GaussianRBF, + c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -91,8 +116,10 @@ def __init__( self.meta.update({'backend': 'tensorflow'}) # initialize kernel - self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel + # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + self.x_kernel = x_kernel + self.c_kernel = c_kernel # Initialize classifier (hardcoded for now) self.clf = _SVCDomainClf(self.c_kernel) @@ -261,26 +288,3 @@ def _split_chunks(n: int, p: int) -> List[int]: else: chunks = [n // p + 1] * (n % p) + [n // p] * (p - n % p) return chunks - - -def _sigma_median_diag(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: - """ - Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`, - with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. - - Parameters - ---------- - x - Tensor of instances with dimension [Nx, features]. - y - Tensor of instances with dimension [Ny, features]. - dist - Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. - - Returns - ------- - The computed bandwidth, `sigma`. - """ - n_median = tf.math.reduce_prod(dist.shape) // 2 - sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) - return sigma diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index 4b87092b8..e74a0acec 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -2,7 +2,7 @@ import tensorflow as tf from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.tensorflow.distance import permed_lsdds @@ -14,7 +14,8 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -62,7 +63,7 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -71,24 +72,25 @@ def __init__( ) self.meta.update({'backend': 'tensorflow'}) + self.kernel = kernel if self.preprocess_x_ref or self.preprocess_fn is None: x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) + # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - def _initialize_kernel(self, x_ref: tf.Tensor): - if self.sigma is None: - self.kernel = GaussianRBF() - _ = self.kernel(x_ref, x_ref, infer_sigma=True) - else: - sigma = tf.convert_to_tensor(self.sigma) - self.kernel = GaussianRBF(sigma) + # def _initialize_kernel(self, x_ref: tf.Tensor): + # if self.sigma is None: + # self.kernel = GaussianRBF() + # _ = self.kernel(x_ref, x_ref, infer_sigma=True) + # else: + # sigma = tf.convert_to_tensor(self.sigma) + # self.kernel = GaussianRBF(sigma) def _configure_normalization(self, x_ref: tf.Tensor, eps: float = 1e-12): x_ref_means = tf.reduce_mean(x_ref, axis=0) @@ -126,7 +128,7 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_x_ref is False: self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) + # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index 87b4ae1e1..445e3f4cf 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -3,7 +3,8 @@ import tensorflow as tf from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline -from alibi_detect.utils.tensorflow import GaussianRBF, quantile, permed_lsdds +from alibi_detect.utils.tensorflow import quantile, permed_lsdds +from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel class LSDDDriftOnlineTF(BaseMultiDriftOnline): @@ -13,7 +14,8 @@ def __init__( ert: float, window_size: int, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -78,12 +80,13 @@ def __init__( self._configure_normalization() # initialize kernel - if sigma is None: - self.kernel = GaussianRBF() - _ = self.kernel(self.x_ref, self.x_ref, infer_sigma=True) - else: - sigma = tf.convert_to_tensor(sigma) - self.kernel = GaussianRBF(sigma) + # if sigma is None: + # self.kernel = GaussianRBF() + # _ = self.kernel(self.x_ref, self.x_ref, infer_sigma=True) + # else: + # sigma = tf.convert_to_tensor(sigma) + # self.kernel = GaussianRBF(sigma) + self.kernel = kernel if self.n_kernel_centers is None: self.n_kernel_centers = 2*window_size diff --git a/alibi_detect/cd/tensorflow/mmd.py b/alibi_detect/cd/tensorflow/mmd.py index 9712a75b9..9c64ece45 100644 --- a/alibi_detect/cd/tensorflow/mmd.py +++ b/alibi_detect/cd/tensorflow/mmd.py @@ -4,7 +4,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseMMDDrift from alibi_detect.utils.tensorflow.distance import mmd2_from_kernel_matrix -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel logger = logging.getLogger(__name__) @@ -17,8 +17,9 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + # kernel: Callable = GaussianRBF, + kernel: BaseKernel = GaussianRBF(), + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -61,7 +62,7 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -70,20 +71,21 @@ def __init__( self.meta.update({'backend': 'tensorflow'}) # initialize kernel - if isinstance(sigma, np.ndarray): - sigma = tf.convert_to_tensor(sigma) - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel - + # if isinstance(sigma, np.ndarray): + # sigma = tf.convert_to_tensor(sigma) + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data - if self.infer_sigma or isinstance(sigma, tf.Tensor): - self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=self.infer_sigma) + # if self.infer_sigma or isinstance(sigma, tf.Tensor): + if self.infer_parameter: + self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.infer_parameter) self.infer_sigma = False else: self.k_xx, self.infer_sigma = None, True def kernel_matrix(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor]) -> tf.Tensor: """ Compute and return full kernel matrix between arrays x and y. """ - k_xy = self.kernel(x, y, self.infer_sigma) + k_xy = self.kernel(x, y, self.infer_parameter) k_xx = self.k_xx if self.k_xx is not None and self.update_x_ref is None else self.kernel(x, x) k_yy = self.kernel(y, y) kernel_mat = tf.concat([tf.concat([k_xx, k_xy], 1), tf.concat([tf.transpose(k_xy, (1, 0)), k_yy], 1)], 0) diff --git a/alibi_detect/cd/tensorflow/mmd_online.py b/alibi_detect/cd/tensorflow/mmd_online.py index 7cf6c2987..6978cb9b1 100644 --- a/alibi_detect/cd/tensorflow/mmd_online.py +++ b/alibi_detect/cd/tensorflow/mmd_online.py @@ -3,7 +3,7 @@ import tensorflow as tf from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.tensorflow import zero_diag, quantile, subset_matrix @@ -14,8 +14,9 @@ def __init__( ert: float, window_size: int, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), + # kernel: Callable = GaussianRBF, + # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, verbose: bool = True, input_shape: Optional[tuple] = None, @@ -67,12 +68,14 @@ def __init__( self.meta.update({'backend': 'tensorflow'}) # initialize kernel - if isinstance(sigma, np.ndarray): - sigma = tf.convert_to_tensor(sigma) - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + # if isinstance(sigma, np.ndarray): + # sigma = tf.convert_to_tensor(sigma) + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data - self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() self._initialise() diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index b6b692237..54c9f0a7f 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -29,12 +29,66 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: return sigma -class GaussianRBF(tf.keras.Model): +class BaseKernel(tf.keras.Model): + """_summary_ + The base class for all kernels. + Args: + nn (_type_): _description_ + """ + def __init__(self) -> None: + super().__init__() + self.parameter_dict: dict = {} + self.active_dims: Optional[list] = None + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return NotImplementedError + + +class SumKernel(tf.keras.Model): + """ + Construct a kernel by summing two kernels. + Args: + nn (_type_): _description_ + """ + def __init__( + self, + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) + + +class ProductKernel(tf.keras.Model): + """ + Construct a kernel by multiplying two kernels. + Args: + nn (_type_): _description_ + """ + def __init__( + self, + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) + + +class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[tf.Tensor] = None, - init_sigma_fn: Callable = sigma_median, - trainable: bool = False + init_fn_sigma: Callable = sigma_median, + trainable: bool = False, + active_dims: Optional[list] = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -55,6 +109,7 @@ def __init__( """ super().__init__() self.config = {'sigma': sigma, 'trainable': trainable} + self.parameter_dict['sigma'] = 'bandwidth' if sigma is None: self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) self.init_required = True @@ -62,22 +117,23 @@ def __init__( sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) self.init_required = False - self.init_sigma_fn = init_sigma_fn + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims self.trainable = trainable @property def sigma(self) -> tf.Tensor: return tf.math.exp(self.log_sigma) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_sigma: bool = False) -> tf.Tensor: + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] - if infer_sigma or self.init_required: - if self.trainable and infer_sigma: + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_sigma_fn(x, y, dist) + sigma = self.init_fn_sigma(x, y, dist) self.log_sigma.assign(tf.math.log(sigma)) self.init_required = False @@ -94,6 +150,217 @@ def from_config(cls, config): return cls(**config) +class RationalQuadratic(BaseKernel): + def __init__( + self, + alpha: tf.Tensor = None, + init_fn_alpha: Callable = None, + sigma: tf.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + alpha + Exponent parameter of the kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['alpha'] = 'exponent' + self.parameter_dict['sigma'] = 'bandwidth' + if alpha is None: + self.raw_alpha = tf.Variable(np.ones(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + self.raw_alpha = tf.cast(tf.reshape(alpha, (-1,)), dtype=tf.keras.backend.floatx()) + self.init_required = False + if sigma is None: + self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] + self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) + self.init_required = False + self.init_fn_alpha = init_fn_alpha + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + self.trainable = trainable + + @property + def sigma(self) -> tf.Tensor: + return tf.math.exp(self.log_sigma) + + @property + def alpha(self) -> tf.Tensor: + return self.raw_alpha + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) + dist = distance.squared_pairwise_distance(x, y) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + self.log_sigma.assign(tf.math.log(sigma)) + alpha = self.init_fn_alpha(x, y, dist) + self.raw_alpha.assign(alpha) + + kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + return kernel_mat + + +class Periodic(BaseKernel): + def __init__( + self, + tau: tf.Tensor = None, + init_fn_tau: Callable = None, + sigma: tf.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.init_required = True + else: + tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) + self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] + self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + self.trainable = trainable + + @property + def tau(self) -> tf.Tensor: + return tf.math.exp(self.log_tau) + + @property + def sigma(self) -> tf.Tensor: + return tf.math.exp(self.log_sigma) + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) + dist = distance.squared_pairwise_distance(x, y) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + self.log_sigma.assign(tf.math.log(sigma)) + tau = self.init_fn_tau(x, y, dist) + self.log_tau.assign(tf.math.log(tau)) + + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) + + return kernel_mat + + +class LocalPeriodic(BaseKernel): + def __init__( + self, + tau: tf.Tensor = None, + init_fn_tau: Callable = None, + sigma: tf.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Local periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.init_required = True + else: + tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) + self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] + self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + self.trainable = trainable + + @property + def tau(self) -> tf.Tensor: + return tf.math.exp(self.log_tau) + + @property + def sigma(self) -> tf.Tensor: + return tf.math.exp(self.log_sigma) + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) + dist = distance.squared_pairwise_distance(x, y) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + self.log_sigma.assign(tf.math.log(sigma)) + tau = self.init_fn_tau(x, y, dist) + self.log_tau.assign(tf.math.log(tau)) + + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ + tf.math.exp(-0.5 * tf.square(dist / self.tau)) + + return kernel_mat + + class DeepKernel(tf.keras.Model): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). From e05ee057c4a02f76ac12130d40477b92fcfac6a0 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Wed, 27 Jul 2022 09:51:45 +0100 Subject: [PATCH 04/37] Modify generic detector class and associated tests. --- alibi_detect/cd/lsdd_online.py | 4 ++-- alibi_detect/cd/mmd.py | 4 +++- alibi_detect/cd/mmd_online.py | 8 +++++--- alibi_detect/utils/pytorch/kernels.py | 1 + alibi_detect/utils/pytorch/tests/test_kernels_pt.py | 10 +++++----- alibi_detect/utils/saving.py | 4 ++-- alibi_detect/utils/tensorflow/tests/test_kernels_tf.py | 10 +++++----- 7 files changed, 23 insertions(+), 18 deletions(-) diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index 4914c4681..bae4b82a6 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -1,7 +1,6 @@ import numpy as np from typing import Any, Callable, Dict, Optional, Union from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow -from alibi_detect.utils.pytorch.kernels import BaseKernel if has_pytorch: from alibi_detect.cd.pytorch.lsdd_online import LSDDDriftOnlineTorch @@ -13,13 +12,14 @@ class LSDDDriftOnline: def __init__( self, + x_ref: Union[np.ndarray, list], ert: float, window_size: int, backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = None, + # kernel: BaseKernel = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 1e645d0d7..4c879ab1b 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -5,9 +5,11 @@ if has_pytorch: from alibi_detect.cd.pytorch.mmd import MMDDriftTorch + from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernelTorch if has_tensorflow: from alibi_detect.cd.tensorflow.mmd import MMDDriftTF + from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernelTF logger = logging.getLogger(__name__) @@ -21,7 +23,7 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = None, + kernel: Union[BaseKernelTorch, BaseKernelTF] = None, # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, diff --git a/alibi_detect/cd/mmd_online.py b/alibi_detect/cd/mmd_online.py index 8c07b90e2..5604cf4bb 100644 --- a/alibi_detect/cd/mmd_online.py +++ b/alibi_detect/cd/mmd_online.py @@ -4,9 +4,11 @@ if has_pytorch: from alibi_detect.cd.pytorch.mmd_online import MMDDriftOnlineTorch + from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernelTorch if has_tensorflow: from alibi_detect.cd.tensorflow.mmd_online import MMDDriftOnlineTF + from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernelTF class MMDDriftOnline: @@ -17,8 +19,8 @@ def __init__( window_size: int, backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, - kernel: Callable = None, - sigma: Optional[np.ndarray] = None, + kernel: Union[BaseKernelTorch, BaseKernelTF] = None, + # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -82,7 +84,7 @@ def __init__( from alibi_detect.utils.tensorflow.kernels import GaussianRBF else: from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore - kwargs.update({'kernel': GaussianRBF}) + kwargs.update({'kernel': GaussianRBF()}) if backend == 'tensorflow' and has_tensorflow: kwargs.pop('device', None) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 7e6b442ba..d72625f8a 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -113,6 +113,7 @@ def __init__( self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) self.init_required = True else: + sigma = sigma.reshape(-1) self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) self.init_required = False self.init_fn_sigma = init_fn_sigma diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index ba351678d..45e84df90 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -27,13 +27,13 @@ def test_gaussian_kernel(gaussian_kernel_params): y = torch.from_numpy(np.random.random(yshape)).float() kernel = GaussianRBF(sigma=sigma, trainable=trainable) - infer_sigma = True if sigma is None else False - if trainable and infer_sigma: + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: with pytest.raises(Exception): - kernel(x, y, infer_sigma=infer_sigma) + kernel(x, y, infer_parameter=infer_parameter) else: - k_xy = kernel(x, y, infer_sigma=infer_sigma).detach().numpy() - k_xx = kernel(x, x, infer_sigma=infer_sigma).detach().numpy() + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) assert (k_xx > 0.).all() and (k_xy > 0.).all() diff --git a/alibi_detect/utils/saving.py b/alibi_detect/utils/saving.py index 7b65bccde..950028731 100644 --- a/alibi_detect/utils/saving.py +++ b/alibi_detect/utils/saving.py @@ -442,7 +442,7 @@ def state_mmddrift(cd: MMDDrift) -> Tuple[ preprocess_step_drift(cd._detector) if not isinstance(cd._detector.kernel, GaussianRBF): logger.warning('Currently only the default GaussianRBF kernel is supported.') - sigma = cd._detector.kernel.sigma.numpy() if not cd._detector.infer_sigma else None + # sigma = cd._detector.kernel.sigma.numpy() if not cd._detector.infer_sigma else None state_dict = { 'args': { @@ -453,7 +453,7 @@ def state_mmddrift(cd: MMDDrift) -> Tuple[ 'p_val': cd._detector.p_val, 'preprocess_x_ref': False, 'update_x_ref': cd._detector.update_x_ref, - 'sigma': sigma, + # 'sigma': sigma, 'configure_kernel_from_x_ref': not cd._detector.infer_sigma, 'n_permutations': cd._detector.n_permutations, 'input_shape': cd._detector.input_shape, diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index 20f26962a..ee90d6e72 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -26,13 +26,13 @@ def test_gaussian_kernel(gaussian_kernel_params): y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) kernel = GaussianRBF(sigma=sigma, trainable=trainable) - infer_sigma = True if sigma is None else False - if trainable and infer_sigma: + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: with pytest.raises(Exception): - kernel(x, y, infer_sigma=infer_sigma) + kernel(x, y, infer_parameter=infer_parameter) else: - k_xy = kernel(x, y, infer_sigma=infer_sigma).numpy() - k_xx = kernel(x, x, infer_sigma=infer_sigma).numpy() + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) assert (k_xx > 0.).all() and (k_xy > 0.).all() From 753ba72c27edc2f4a32c1c51c23a358384d0d316 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Sun, 31 Jul 2022 15:49:09 +0100 Subject: [PATCH 05/37] Fixed prediction behaviour for torch gpu with new base kernel. --- alibi_detect/cd/mmd.py | 2 +- alibi_detect/utils/pytorch/prediction.py | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 4c879ab1b..ab7ec05d6 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -23,7 +23,7 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Union[BaseKernelTorch, BaseKernelTF] = None, + kernel: Callable = None, # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, diff --git a/alibi_detect/utils/pytorch/prediction.py b/alibi_detect/utils/pytorch/prediction.py index 05aded4aa..49aab1110 100644 --- a/alibi_detect/utils/pytorch/prediction.py +++ b/alibi_detect/utils/pytorch/prediction.py @@ -48,6 +48,8 @@ def predict_batch(x: Union[list, np.ndarray, torch.Tensor], model: Union[Callabl x_batch = x[istart:istop] if isinstance(preprocess_fn, Callable): # type: ignore x_batch = preprocess_fn(x_batch) + if hasattr(model, 'to'): + model.to(device) preds_tmp = model(x_batch.to(device)) # type: ignore if isinstance(preds_tmp, (list, tuple)): if len(preds) == 0: # init tuple with lists to store predictions From 8832beff1965d2277a63d5f1360a1caec9913565 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 5 Aug 2022 09:32:28 +0100 Subject: [PATCH 06/37] Fixed feature dimension selection function. --- alibi_detect/utils/pytorch/kernels.py | 117 ++++++++++++++++++----- alibi_detect/utils/tensorflow/kernels.py | 49 +++++++--- 2 files changed, 131 insertions(+), 35 deletions(-) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index d72625f8a..698473c13 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -5,6 +5,10 @@ from typing import Optional, Union, Callable +def pseudo_init_fn(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + return torch.ones(1, dtype=x.dtype, device=x.device) + + def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: """ Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. @@ -39,8 +43,9 @@ def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} self.active_dims: Optional[list] = None + self.feature_axis: int = -1 - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: raise NotImplementedError @@ -59,8 +64,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - return self.kernel_a(x, y) + self.kernel_b(x, y) + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) class ProductKernel(nn.Module): @@ -78,8 +83,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - return self.kernel_a(x, y) * self.kernel_b(x, y) + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) class GaussianRBF(BaseKernel): @@ -88,7 +93,8 @@ def __init__( sigma: Optional[torch.Tensor] = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -117,7 +123,11 @@ def __init__( self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) self.init_required = False self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -128,6 +138,9 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] if infer_parameter or self.init_required: @@ -148,11 +161,12 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: torch.Tensor = None, - init_fn_alpha: Callable = None, + init_fn_alpha: Callable = pseudo_init_fn, sigma: torch.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -183,7 +197,11 @@ def __init__( self.init_required = False self.init_fn_alpha = init_fn_alpha self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -194,9 +212,24 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + alpha = self.init_fn_alpha(x, y, dist) + with torch.no_grad(): + self.log_sigma.copy_(sigma.log().clone()) + self.raw_alpha.copy_(alpha.clone()) + self.init_required = False + kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) return kernel_mat @@ -205,11 +238,12 @@ class Periodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: torch.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = . @@ -240,7 +274,11 @@ def __init__( self.init_required = False self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -251,9 +289,24 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + tau = self.init_fn_tau(x, y, dist) + with torch.no_grad(): + self.log_sigma.copy_(sigma.log().clone()) + self.log_tau.copy_(tau.log().clone()) + self.init_required = False + kernel_mat = torch.exp(-2 * torch.square( torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) return kernel_mat @@ -263,11 +316,12 @@ class LocalPeriodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: torch.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Local periodic kernel: k(x,y) = . @@ -298,7 +352,11 @@ def __init__( self.init_required = False self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -309,9 +367,24 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + tau = self.init_fn_tau(x, y, dist) + with torch.no_grad(): + self.log_sigma.copy_(sigma.log().clone()) + self.log_tau.copy_(tau.log().clone()) + self.init_required = False + kernel_mat = torch.exp(-2 * torch.square( torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ torch.exp(-0.5 * torch.square(dist / self.tau)) diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 54c9f0a7f..5278b1200 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -5,6 +5,10 @@ from scipy.special import logit +def pseudo_init_fn(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + return tf.ones(1, dtype=x.dtype) + + def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: """ Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. @@ -39,6 +43,7 @@ def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} self.active_dims: Optional[list] = None + self.feature_axis: int = -1 def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return NotImplementedError @@ -88,7 +93,8 @@ def __init__( sigma: Optional[tf.Tensor] = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -119,6 +125,7 @@ def __init__( self.init_required = False self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.feature_axis = feature_axis self.trainable = trainable @property @@ -127,6 +134,9 @@ def sigma(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] @@ -154,11 +164,12 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: tf.Tensor = None, - init_fn_alpha: Callable = None, + init_fn_alpha: Callable = pseudo_init_fn, sigma: tf.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -191,6 +202,7 @@ def __init__( self.init_fn_alpha = init_fn_alpha self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.feature_axis = feature_axis self.trainable = trainable @property @@ -203,6 +215,9 @@ def alpha(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -222,11 +237,12 @@ class Periodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: tf.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = . @@ -244,11 +260,11 @@ def __init__( self.parameter_dict['tau'] = 'period' self.parameter_dict['sigma'] = 'bandwidth' if tau is None: - self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.log_tau = tf.Variable(np.empty(1), trainable=trainable) self.init_required = True else: tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) self.init_required = False if sigma is None: self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) @@ -260,6 +276,7 @@ def __init__( self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.feature_axis = feature_axis self.trainable = trainable @property @@ -272,6 +289,9 @@ def sigma(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -293,9 +313,9 @@ class LocalPeriodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: tf.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, active_dims: Optional[list] = None ) -> None: @@ -315,11 +335,11 @@ def __init__( self.parameter_dict['tau'] = 'period' self.parameter_dict['sigma'] = 'bandwidth' if tau is None: - self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.log_tau = tf.Variable(np.empty(1), trainable=trainable) self.init_required = True else: tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) self.init_required = False if sigma is None: self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) @@ -343,6 +363,9 @@ def sigma(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) From d53984f5b9dce79f03b9a911e6b26b127661d345 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 8 Aug 2022 10:54:24 +0100 Subject: [PATCH 07/37] Added support to passing multiple kernel parameters. Doc string refinements. --- alibi_detect/cd/lsdd_online.py | 1 - alibi_detect/cd/mmd.py | 2 - alibi_detect/utils/pytorch/kernels.py | 84 ++++++++++++++++++------ alibi_detect/utils/tensorflow/kernels.py | 74 ++++++++++++++++----- 4 files changed, 120 insertions(+), 41 deletions(-) diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index bae4b82a6..eca0d3b39 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -12,7 +12,6 @@ class LSDDDriftOnline: def __init__( self, - x_ref: Union[np.ndarray, list], ert: float, window_size: int, diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index ab7ec05d6..1e645d0d7 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -5,11 +5,9 @@ if has_pytorch: from alibi_detect.cd.pytorch.mmd import MMDDriftTorch - from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernelTorch if has_tensorflow: from alibi_detect.cd.tensorflow.mmd import MMDDriftTF - from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernelTF logger = logging.getLogger(__name__) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 698473c13..70241d039 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -6,6 +6,9 @@ def pseudo_init_fn(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + """ + A pseudo-initialization function for the kernel parameter. + """ return torch.ones(1, dtype=x.dtype, device=x.device) @@ -36,8 +39,6 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. class BaseKernel(nn.Module): """ The base class for all kernels. - Args: - nn (_type_): _description_ """ def __init__(self) -> None: super().__init__() @@ -51,9 +52,14 @@ def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = Fals class SumKernel(nn.Module): """ - Construct a kernel by summing two kernels. - Args: - nn (_type_): _description_ + Construct a kernel by averaging two kernels. + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -65,14 +71,19 @@ def __init__( self.kernel_b = kernel_b def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) + return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 class ProductKernel(nn.Module): """ Construct a kernel by multiplying two kernels. - Args: - nn (_type_): _description_ + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -212,14 +223,14 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) if self.active_dims is not None: x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) - + if infer_parameter or self.init_required: if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") @@ -229,8 +240,18 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch self.log_sigma.copy_(sigma.log().clone()) self.raw_alpha.copy_(alpha.clone()) self.init_required = False - - kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + + if len(self.sigma) > 1: + if len(self.sigma) == len(self.alpha): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append((1 + torch.square(dist) + / (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) + kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) return kernel_mat @@ -296,7 +317,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) - + if infer_parameter or self.init_required: if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") @@ -306,9 +327,19 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch self.log_sigma.copy_(sigma.log().clone()) self.log_tau.copy_(tau.log().clone()) self.init_required = False - - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) + + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2))) + kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) return kernel_mat @@ -374,7 +405,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) - + if infer_parameter or self.init_required: if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") @@ -384,10 +415,21 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch self.log_sigma.copy_(sigma.log().clone()) self.log_tau.copy_(tau.log().clone()) self.init_required = False - - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ - torch.exp(-0.5 * torch.square(dist / self.tau)) + + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + torch.exp(-0.5 * torch.square(dist / self.tau[i]))) + kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ + torch.exp(-0.5 * torch.square(dist / self.tau)) return kernel_mat diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 5278b1200..602805515 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -6,6 +6,9 @@ def pseudo_init_fn(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + """ + A pseudo-initialization function for the kernel parameter. + """ return tf.ones(1, dtype=x.dtype) @@ -34,10 +37,8 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: class BaseKernel(tf.keras.Model): - """_summary_ + """ The base class for all kernels. - Args: - nn (_type_): _description_ """ def __init__(self) -> None: super().__init__() @@ -51,9 +52,14 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. class SumKernel(tf.keras.Model): """ - Construct a kernel by summing two kernels. - Args: - nn (_type_): _description_ + Construct a kernel by averaging two kernels. + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -65,14 +71,19 @@ def __init__( self.kernel_b = kernel_b def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) + return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 class ProductKernel(tf.keras.Model): """ Construct a kernel by multiplying two kernels. - Args: - nn (_type_): _description_ + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -229,7 +240,17 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. alpha = self.init_fn_alpha(x, y, dist) self.raw_alpha.assign(alpha) - kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + if len(self.sigma) > 1: + if len(self.sigma) == len(self.alpha): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append((1 + tf.square(dist) / + (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) + kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) return kernel_mat @@ -303,9 +324,18 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. tau = self.init_fn_tau(x, y, dist) self.log_tau.assign(tf.math.log(tau)) - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) - + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2))) + kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) return kernel_mat @@ -377,10 +407,20 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. tau = self.init_fn_tau(x, y, dist) self.log_tau.assign(tf.math.log(tau)) - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ - tf.math.exp(-0.5 * tf.square(dist / self.tau)) - + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + tf.math.exp(-0.5 * tf.square(dist / self.tau[i]))) + kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ + tf.math.exp(-0.5 * tf.square(dist / self.tau)) return kernel_mat From 657e7b844f4e7e99d9fb76dbfe0db70d79aa9d67 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 18 Aug 2022 11:35:55 +0100 Subject: [PATCH 08/37] (1) refine various points according to the review. (2) re-design the parameter implementation for the general kernel class. (3) added an initial example notebook. --- alibi_detect/cd/pytorch/lsdd.py | 6 +- alibi_detect/cd/pytorch/lsdd_online.py | 6 +- alibi_detect/cd/tensorflow/lsdd.py | 6 +- alibi_detect/cd/tensorflow/lsdd_online.py | 6 +- alibi_detect/utils/pytorch/kernels.py | 358 +++++++-------- alibi_detect/utils/pytorch/prediction.py | 2 - alibi_detect/utils/tensorflow/kernels.py | 335 +++++++------- doc/source/examples/cd_combined_kernel.ipynb | 459 +++++++++++++++++++ doc/source/examples/cd_mmd_cifar10.ipynb | 12 +- examples/cd_combined_kernel.ipynb | 1 + 10 files changed, 791 insertions(+), 400 deletions(-) create mode 100644 doc/source/examples/cd_combined_kernel.ipynb create mode 100644 examples/cd_combined_kernel.ipynb diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 43d417ca0..965985fb8 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -3,7 +3,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF +from alibi_detect.utils.pytorch.kernels import GaussianRBF from alibi_detect.utils.pytorch.distance import permed_lsdds @@ -16,7 +16,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -85,7 +85,7 @@ def __init__( # in the method signature, so we can't cast it to torch.Tensor unless we change the signature # to also accept torch.Tensor. We also can't redefine it's type as that would involve enabling # --allow-redefinitions in mypy settings (which we might do eventually). - self.kernel = kernel + self.kernel = GaussianRBF() if self.preprocess_x_ref or self.preprocess_fn is None: x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index 7cecbeaf3..b1ac3f837 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -5,7 +5,7 @@ from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.pytorch import get_device from alibi_detect.utils.pytorch import permed_lsdds, quantile -from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF +from alibi_detect.utils.pytorch.kernels import GaussianRBF class LSDDDriftOnlineTorch(BaseMultiDriftOnline): @@ -16,7 +16,7 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -96,7 +96,7 @@ def __init__( # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] # np.ndarray) else None # self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] - self.kernel = kernel + self.kernel = GaussianRBF() if self.n_kernel_centers is None: self.n_kernel_centers = 2 * window_size diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index e74a0acec..76329defe 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -2,7 +2,7 @@ import tensorflow as tf from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift -from alibi_detect.utils.tensorflow.kernels import BaseKernel, GaussianRBF +from alibi_detect.utils.tensorflow.kernels import GaussianRBF from alibi_detect.utils.tensorflow.distance import permed_lsdds @@ -15,7 +15,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -72,7 +72,7 @@ def __init__( ) self.meta.update({'backend': 'tensorflow'}) - self.kernel = kernel + self.kernel = GaussianRBF() if self.preprocess_x_ref or self.preprocess_fn is None: x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index 445e3f4cf..cc3b8756c 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -4,7 +4,7 @@ from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.tensorflow import quantile, permed_lsdds -from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel +from alibi_detect.utils.tensorflow.kernels import GaussianRBF class LSDDDriftOnlineTF(BaseMultiDriftOnline): @@ -15,7 +15,7 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -86,7 +86,7 @@ def __init__( # else: # sigma = tf.convert_to_tensor(sigma) # self.kernel = GaussianRBF(sigma) - self.kernel = kernel + self.kernel = GaussianRBF() if self.n_kernel_centers is None: self.n_kernel_centers = 2*window_size diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 70241d039..a6283aba0 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -5,11 +5,32 @@ from typing import Optional, Union, Callable -def pseudo_init_fn(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: +def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): """ - A pseudo-initialization function for the kernel parameter. + Infer the kernel parameter from the data. + + Parameters + ---------- + kernel + The kernel function. + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + infer_parameter + Whether to infer the kernel parameter. """ - return torch.ones(1, dtype=x.dtype, device=x.device) + if kernel.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + for parameter in kernel.parameter_dict.values(): + if parameter.requires_init: + if parameter.init_fn is not None: + with torch.no_grad(): + parameter.value.data = parameter.init_fn(x, y, dist).reshape(-1) + parameter.requires_init = False + kernel.init_required = False def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: @@ -27,13 +48,32 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. Returns ------- - The computed bandwidth, `sigma`. + The logrithm of the computed bandwidth, `log-sigma`. """ n = min(x.shape[0], y.shape[0]) n = n if (x[:n] == y[:n]).all() and x.shape == y.shape else 0 n_median = n + (np.prod(dist.shape) - n) // 2 - 1 sigma = (.5 * dist.flatten().sort().values[n_median].unsqueeze(dim=-1)) ** .5 - return sigma + return sigma.log() + + +class KernelParameter(object): + """ + Parameter class for kernels. + """ + + def __init__( + self, + value: torch.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False + ) -> None: + super().__init__() + self.value = nn.Parameter(value if value is not None else torch.ones(1), + requires_grad=requires_grad) + self.init_fn = init_fn + self.requires_init = requires_init class BaseKernel(nn.Module): @@ -43,23 +83,41 @@ class BaseKernel(nn.Module): def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} - self.active_dims: Optional[list] = None - self.feature_axis: int = -1 - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: raise NotImplementedError -class SumKernel(nn.Module): +class DimensionSelectKernel(nn.Module): + """ + Select a subset of the feature diomensions before apply a given kernel. + """ + def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: + super().__init__() + self.kernel = kernel + self.active_dims = torch.as_tensor(active_dims) + self.feature_axis = feature_axis + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) + return self.kernel(x, y, infer_parameter) + + +class AveragedKernel(nn.Module): """ Construct a kernel by averaging two kernels. Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be averaged. kernel_b - the second kernel to be summed. + the second kernel to be averaged. """ def __init__( self, @@ -70,7 +128,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 @@ -81,9 +140,9 @@ class ProductKernel(nn.Module): Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be multiplied. kernel_b - the second kernel to be summed. + the second kernel to be multiplied. """ def __init__( self, @@ -94,7 +153,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) @@ -103,9 +163,7 @@ def __init__( self, sigma: Optional[torch.Tensor] = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -125,42 +183,27 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. """ super().__init__() - self.parameter_dict['sigma'] = 'bandwidth' - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - sigma = sigma.reshape(-1) - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False, + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.init_required = False + infer_kernel_parameter(self, x, y, dist, infer_parameter) gamma = 1. / (2. * self.sigma ** 2) # [Ns,] # TODO: do matrix multiplication after all? @@ -172,12 +215,10 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: torch.Tensor = None, - init_fn_alpha: Callable = pseudo_init_fn, + init_fn_alpha: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -192,82 +233,56 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['alpha'] = 'exponent' - self.parameter_dict['sigma'] = 'bandwidth' - if alpha is None: - self.raw_alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.raw_alpha = nn.Parameter(alpha, requires_grad=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_alpha = init_fn_alpha - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['alpha'] = KernelParameter( + value=alpha.reshape(-1) if alpha is not None else None, + init_fn=init_fn_alpha, + requires_grad=trainable, + requires_init=True if alpha is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def alpha(self) -> torch.Tensor: - return self.raw_alpha + return self.parameter_dict['alpha'].value @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - alpha = self.init_fn_alpha(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.raw_alpha.copy_(alpha.clone()) - self.init_required = False - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.alpha): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append((1 + torch.square(dist) - / (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) - kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) - return kernel_mat + if infer_parameter or self.init_required: + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = torch.stack([(1 + torch.square(dist) / + (2 * self.alpha[i] * (self.sigma[i] ** 2))) + ** (-self.alpha[i]) for i in range(len(self.sigma))], dim=0) + + return kernel_mat.mean(dim=0) class Periodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 ) -> None: """ - Periodic kernel: k(x,y) = . + Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -279,83 +294,54 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['log-tau'] = KernelParameter( + value=tau.log().reshape(-1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> torch.Tensor: - return self.log_tau.exp() + return self.parameter_dict['log-tau'].value.exp() @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - tau = self.init_fn_tau(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.log_tau.copy_(tau.log().clone()) - self.init_required = False - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2))) - kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = torch.stack([torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) + for i in range(len(self.sigma))], dim=0) + return kernel_mat.mean(dim=0) class LocalPeriodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ - Local periodic kernel: k(x,y) = . + Local periodic kernel: k(x,y) = k_rbf(x, y) * k_period(x, y). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -367,70 +353,42 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['log-tau'] = KernelParameter( + value=tau.log().reshape(-1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> torch.Tensor: - return self.log_tau.exp() + return self.parameter_dict['log-tau'].value.exp() @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - tau = self.init_fn_tau(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.log_tau.copy_(tau.log().clone()) - self.init_required = False - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - torch.exp(-0.5 * torch.square(dist / self.tau[i]))) - kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ - torch.exp(-0.5 * torch.square(dist / self.tau)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = torch.stack([torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + torch.exp(-0.5 * torch.square(dist / self.tau[i])) + for i in range(len(self.sigma))], dim=0) + return kernel_mat.mean(dim=0) class DeepKernel(nn.Module): diff --git a/alibi_detect/utils/pytorch/prediction.py b/alibi_detect/utils/pytorch/prediction.py index 49aab1110..05aded4aa 100644 --- a/alibi_detect/utils/pytorch/prediction.py +++ b/alibi_detect/utils/pytorch/prediction.py @@ -48,8 +48,6 @@ def predict_batch(x: Union[list, np.ndarray, torch.Tensor], model: Union[Callabl x_batch = x[istart:istop] if isinstance(preprocess_fn, Callable): # type: ignore x_batch = preprocess_fn(x_batch) - if hasattr(model, 'to'): - model.to(device) preds_tmp = model(x_batch.to(device)) # type: ignore if isinstance(preds_tmp, (list, tuple)): if len(preds) == 0: # init tuple with lists to store predictions diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 602805515..1712708df 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -5,11 +5,31 @@ from scipy.special import logit -def pseudo_init_fn(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: +def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): """ - A pseudo-initialization function for the kernel parameter. + Infer the kernel parameter from the data. + + Parameters + ---------- + kernel + The kernel function. + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + infer_parameter + Whether to infer the kernel parameter. """ - return tf.ones(1, dtype=x.dtype) + if kernel.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + for parameter in kernel.parameter_dict.values(): + if parameter.requires_init: + if parameter.init_fn is not None: + parameter.value.assign(tf.reshape(parameter.init_fn(x, y, dist), -1)) + parameter.requires_init = False + kernel.init_required = False def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: @@ -27,13 +47,32 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: Returns ------- - The computed bandwidth, `sigma`. + The logrithm of the computed bandwidth, `log-sigma`. """ n = min(x.shape[0], y.shape[0]) n = n if tf.reduce_all(x[:n] == y[:n]) and x.shape == y.shape else 0 n_median = n + (tf.math.reduce_prod(dist.shape) - n) // 2 - 1 sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) - return sigma + return tf.math.log(sigma) + + +class KernelParameter(object): + """ + Parameter class for kernels. + """ + def __init__(self, + value: tf.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False): + self.value = tf.Variable(value if value is not None + else tf.ones(1, dtype=tf.keras.backend.floatx()), + trainable=requires_grad) + self.init_fn = init_fn + self.requires_init = requires_init + + def __repr__(self) -> str: + return self.value.__repr__() class BaseKernel(tf.keras.Model): @@ -43,23 +82,38 @@ class BaseKernel(tf.keras.Model): def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} - self.active_dims: Optional[list] = None - self.feature_axis: int = -1 def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return NotImplementedError -class SumKernel(tf.keras.Model): +class DimensionSelectKernel(tf.keras.Model): + """ + Select a subset of the feature diomensions before apply a given kernel. + """ + def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: + super().__init__() + self.kernel = kernel + self.active_dims = active_dims + self.feature_axis = feature_axis + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) + return self.kernel(x, y, infer_parameter) + + +class AveragedKernel(tf.keras.Model): """ Construct a kernel by averaging two kernels. Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be averaged. kernel_b - the second kernel to be summed. + the second kernel to be averaged. """ def __init__( self, @@ -81,9 +135,9 @@ class ProductKernel(tf.keras.Model): Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be multiplied. kernel_b - the second kernel to be summed. + the second kernel to be multiplied. """ def __init__( self, @@ -103,9 +157,7 @@ def __init__( self, sigma: Optional[tf.Tensor] = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -126,37 +178,27 @@ def __init__( """ super().__init__() self.config = {'sigma': sigma, 'trainable': trainable} - self.parameter_dict['sigma'] = 'bandwidth' - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims - self.feature_axis = feature_axis + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - self.init_required = False + infer_kernel_parameter(self, x, y, dist, infer_parameter) gamma = tf.constant(1. / (2. * self.sigma ** 2), dtype=x.dtype) # [Ns,] # TODO: do matrix multiplication after all? @@ -175,12 +217,10 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: tf.Tensor = None, - init_fn_alpha: Callable = pseudo_init_fn, + init_fn_alpha: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -195,78 +235,56 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['alpha'] = 'exponent' - self.parameter_dict['sigma'] = 'bandwidth' - if alpha is None: - self.raw_alpha = tf.Variable(np.ones(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - self.raw_alpha = tf.cast(tf.reshape(alpha, (-1,)), dtype=tf.keras.backend.floatx()) - self.init_required = False - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_alpha = init_fn_alpha - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims - self.feature_axis = feature_axis + self.parameter_dict['alpha'] = KernelParameter( + value=tf.reshape( + tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, + init_fn=init_fn_alpha, + requires_grad=trainable, + requires_init=True if alpha is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) @property def alpha(self) -> tf.Tensor: - return self.raw_alpha + return self.parameter_dict['alpha'].value def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - alpha = self.init_fn_alpha(x, y, dist) - self.raw_alpha.assign(alpha) - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.alpha): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append((1 + tf.square(dist) / - (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) - kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = tf.stack([(1 + tf.square(dist) / + (2 * self.alpha[i] * (self.sigma[i] ** 2))) + ** (-self.alpha[i]) for i in range(len(self.sigma))], axis=0) + return tf.reduce_mean(kernel_mat, axis=0) class Periodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ - Periodic kernel: k(x,y) = . + Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -278,79 +296,56 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = tf.Variable(np.empty(1), trainable=trainable) - self.init_required = True - else: - tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims - self.feature_axis = feature_axis + self.parameter_dict['log-tau'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> tf.Tensor: - return tf.math.exp(self.log_tau) + return tf.math.exp(self.parameter_dict['log-tau'].value) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - tau = self.init_fn_tau(x, y, dist) - self.log_tau.assign(tf.math.log(tau)) - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2))) - kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = tf.stack([tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) + for i in range(len(self.sigma))], axis=0) + return tf.reduce_mean(kernel_mat, axis=0) class LocalPeriodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None ) -> None: """ - Local periodic kernel: k(x,y) = . + Local periodic kernel: k(x,y) = k(x,y) = k_rbf(x, y) * k_period(x, y). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -362,66 +357,44 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = tf.Variable(np.empty(1), trainable=trainable) - self.init_required = True - else: - tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + self.parameter_dict['log-tau'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> tf.Tensor: - return tf.math.exp(self.log_tau) + return tf.math.exp(self.parameter_dict['log-tau'].value) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - tau = self.init_fn_tau(x, y, dist) - self.log_tau.assign(tf.math.log(tau)) - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - tf.math.exp(-0.5 * tf.square(dist / self.tau[i]))) - kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ - tf.math.exp(-0.5 * tf.square(dist / self.tau)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = tf.stack([tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + tf.math.exp(-0.5 * tf.square(dist / self.tau[i])) + for i in range(len(self.sigma))], axis=0) + return tf.reduce_mean(kernel_mat, axis=0) class DeepKernel(tf.keras.Model): diff --git a/doc/source/examples/cd_combined_kernel.ipynb b/doc/source/examples/cd_combined_kernel.ipynb new file mode 100644 index 000000000..5c985d772 --- /dev/null +++ b/doc/source/examples/cd_combined_kernel.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create sum and product kernels with exsisting kernels\n", + "\n", + "\n", + "### Combine different kernels for better test power on certain data types" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:30.140646Z", + "iopub.status.busy": "2022-08-17T22:48:30.139694Z", + "iopub.status.idle": "2022-08-17T22:48:42.261216Z", + "shell.execute_reply": "2022-08-17T22:48:42.258215Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-18 11:16:03.693515: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:03.693561: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", + "2022-08-18 11:16:09.361482: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n", + "Your kernel may have been built without NUMA support.\n", + "2022-08-18 11:16:09.361658: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361739: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361808: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361874: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361939: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362005: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362069: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362133: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362145: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", + "Skipping registering GPU devices...\n", + "2022-08-18 11:16:09.362441: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import scipy.stats as stats\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "backend = 'pytorch'\n", + "\n", + "from alibi_detect.cd import MMDDrift\n", + "if backend == 'pytorch':\n", + " from alibi_detect.utils.pytorch.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + "elif backend == 'tensorflow':\n", + " from alibi_detect.utils.tensorflow.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + "else:\n", + " raise ValueError('Backend {} not supported'.format(backend))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.268753Z", + "iopub.status.busy": "2022-08-17T22:48:42.267268Z", + "iopub.status.idle": "2022-08-17T22:48:42.287665Z", + "shell.execute_reply": "2022-08-17T22:48:42.283443Z" + } + }, + "outputs": [], + "source": [ + "def get_sin(N):\n", + " c_0 = np.random.uniform(0, 168, N)\n", + " x_0 = np.sin(c_0 / (12 / np.pi)) + np.random.normal(0, 0.1, N)\n", + "\n", + " c_1 = stats.beta.rvs(a=1.2, b=1.2, size=N) * 24 + np.random.choice([0, 24, 48, 72, 96, 120, 144], size=N)\n", + " x_1 = np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) < 12) + \\\n", + " np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) >= 12) * 1.25 + \\\n", + " + np.random.normal(0, 0.1, N)\n", + " \n", + " x_ref = np.hstack([c_0.reshape(-1, 1), x_0.reshape(-1, 1)])\n", + " x_test = np.hstack([c_1.reshape(-1, 1), x_1.reshape(-1, 1)]) \n", + " \n", + " return x_ref, x_test" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.296254Z", + "iopub.status.busy": "2022-08-17T22:48:42.295141Z", + "iopub.status.idle": "2022-08-17T22:48:42.307361Z", + "shell.execute_reply": "2022-08-17T22:48:42.304563Z" + } + }, + "outputs": [], + "source": [ + "x_ref, x_test = get_sin(N=1000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Here we create two simple datasets with waves and therefore have two features, the test data shows clear drift around the wave through." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.315487Z", + "iopub.status.busy": "2022-08-17T22:48:42.314280Z", + "iopub.status.idle": "2022-08-17T22:48:42.627643Z", + "shell.execute_reply": "2022-08-17T22:48:42.626213Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.5, 1.5)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 3), dpi=128)\n", + "plt.plot(x_ref[:, 0], x_ref[:, 1], 'bo', alpha=0.5, markersize=2.5, label='Reference')\n", + "plt.plot(x_test[:, 0], x_test[:, 1], 'ro', alpha=0.5, markersize=2.5, label='Test')\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### If we use standard RBF kernel on both features with the MMD drift detector, we can see that the drift is not detected." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "Kernel_RBF = GaussianRBF()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "cd_RBF = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=Kernel_RBF)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 0,\n", + " 'distance': -0.00032591944848670007,\n", + " 'p_val': 0.5600000023841858,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00219562, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds_RBF = cd_RBF.predict(x_test)\n", + "preds_RBF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### To facilitate our knowledge that the data contain waves, we use a combined kernel that is averaged from two kernels. The first kernel is a periodic kernel with a specified period of 24 and only working on the first feature. The second kernel is a RBF kernel with a infered bandwidth and only working on the second feature." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.633012Z", + "iopub.status.busy": "2022-08-17T22:48:42.632420Z", + "iopub.status.idle": "2022-08-17T22:48:42.663421Z", + "shell.execute_reply": "2022-08-17T22:48:42.661867Z" + } + }, + "outputs": [], + "source": [ + "if backend == 'pytorch':\n", + " Kernel_0 = DimensionSelectKernel(Periodic(tau=torch.tensor([24.0])), active_dims=[0])\n", + " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])\n", + "elif backend == 'tensorflow':\n", + " Kernel_0 = DimensionSelectKernel(Periodic(tau=tf.convert_to_tensor([24.0])), active_dims=[0])\n", + " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.682278Z", + "iopub.status.busy": "2022-08-17T22:48:42.681366Z", + "iopub.status.idle": "2022-08-17T22:48:42.695138Z", + "shell.execute_reply": "2022-08-17T22:48:42.692762Z" + } + }, + "outputs": [], + "source": [ + "Kernel_avg = AveragedKernel(Kernel_0, Kernel_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.702931Z", + "iopub.status.busy": "2022-08-17T22:48:42.700551Z", + "iopub.status.idle": "2022-08-17T22:48:43.049891Z", + "shell.execute_reply": "2022-08-17T22:48:43.048438Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "cd_avg = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=Kernel_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We can see the drift is detected with the combined kernel." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 1,\n", + " 'distance': 0.006368878019042512,\n", + " 'p_val': 0.0,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00098101, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds_avg = cd_avg.predict(x_test)\n", + "preds_avg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The kernel, its compments and asscociated parameters can be inspected as follows:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:43.055921Z", + "iopub.status.busy": "2022-08-17T22:48:43.055518Z", + "iopub.status.idle": "2022-08-17T22:48:43.064586Z", + "shell.execute_reply": "2022-08-17T22:48:43.063483Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AveragedKernel(\n", + " (kernel_a): DimensionSelectKernel(\n", + " (kernel): Periodic()\n", + " )\n", + " (kernel_b): DimensionSelectKernel(\n", + " (kernel): GaussianRBF()\n", + " )\n", + ")\n", + "DimensionSelectKernel(\n", + " (kernel): Periodic()\n", + ")\n", + "Periodic()\n" + ] + } + ], + "source": [ + "print(cd_avg._detector.kernel)\n", + "print(cd_avg._detector.kernel.kernel_a)\n", + "print(cd_avg._detector.kernel.kernel_a.kernel)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:44.915230Z", + "iopub.status.busy": "2022-08-17T22:48:44.914553Z", + "iopub.status.idle": "2022-08-17T22:48:44.924660Z", + "shell.execute_reply": "2022-08-17T22:48:44.923360Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([24.])\n", + "tensor([4.9818], dtype=torch.float64)\n" + ] + } + ], + "source": [ + "print(Kernel_avg.kernel_a.kernel.tau)\n", + "print(Kernel_avg.kernel_a.kernel.sigma)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:44.928919Z", + "iopub.status.busy": "2022-08-17T22:48:44.928266Z", + "iopub.status.idle": "2022-08-17T22:48:44.938336Z", + "shell.execute_reply": "2022-08-17T22:48:44.936929Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.5243], dtype=torch.float64)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Kernel_avg.kernel_b.kernel.sigma" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('detect_cpu_py38')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/source/examples/cd_mmd_cifar10.ipynb b/doc/source/examples/cd_mmd_cifar10.ipynb index 211b4908b..994a4bce7 100644 --- a/doc/source/examples/cd_mmd_cifar10.ipynb +++ b/doc/source/examples/cd_mmd_cifar10.ipynb @@ -765,11 +765,8 @@ } ], "metadata": { - "interpreter": { - "hash": "ffba93b5284319fb7a107c8eacae647f441487dcc7e0323a4c0d3feb66ea8c5e" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.8.13 ('detect_cpu_py38')", "language": "python", "name": "python3" }, @@ -783,7 +780,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.11" + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" + } } }, "nbformat": 4, diff --git a/examples/cd_combined_kernel.ipynb b/examples/cd_combined_kernel.ipynb new file mode 100644 index 000000000..d713eeff1 --- /dev/null +++ b/examples/cd_combined_kernel.ipynb @@ -0,0 +1 @@ +../doc/source/examples/cd_combined_kernel.ipynb \ No newline at end of file From 83223302fd3ce55b70dd3ff268952be2155328dc Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 18 Aug 2022 12:12:23 +0100 Subject: [PATCH 09/37] revert mmd_cifar10 notebook --- doc/source/examples/cd_mmd_cifar10.ipynb | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/doc/source/examples/cd_mmd_cifar10.ipynb b/doc/source/examples/cd_mmd_cifar10.ipynb index 994a4bce7..211b4908b 100644 --- a/doc/source/examples/cd_mmd_cifar10.ipynb +++ b/doc/source/examples/cd_mmd_cifar10.ipynb @@ -765,8 +765,11 @@ } ], "metadata": { + "interpreter": { + "hash": "ffba93b5284319fb7a107c8eacae647f441487dcc7e0323a4c0d3feb66ea8c5e" + }, "kernelspec": { - "display_name": "Python 3.8.13 ('detect_cpu_py38')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -780,12 +783,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" - } + "version": "3.8.11" } }, "nbformat": 4, From 0199bac4ea0ce931856d41891c7e585c9ca03244 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Sun, 4 Sep 2022 21:24:02 +0100 Subject: [PATCH 10/37] This commit includes a major re-design of the base kernel class, it now allows: (1) any sum and product with the direct add and multiply equation. (2) the dimension selection is built-in with the main class. (3) the deep kernel is also implemented with the new base class and the user can access it as a single composite kernel. --- alibi_detect/utils/pytorch/__init__.py | 3 +- alibi_detect/utils/pytorch/kernels.py | 306 ++++++++++-------- .../utils/pytorch/tests/test_kernels_pt.py | 6 +- alibi_detect/utils/tensorflow/__init__.py | 3 +- alibi_detect/utils/tensorflow/kernels.py | 304 +++++++++-------- .../utils/tensorflow/tests/test_kernels_tf.py | 6 +- 6 files changed, 352 insertions(+), 276 deletions(-) diff --git a/alibi_detect/utils/pytorch/__init__.py b/alibi_detect/utils/pytorch/__init__.py index 215b7825f..708bad8ca 100644 --- a/alibi_detect/utils/pytorch/__init__.py +++ b/alibi_detect/utils/pytorch/__init__.py @@ -1,6 +1,6 @@ from .distance import mmd2, mmd2_from_kernel_matrix, squared_pairwise_distance from .distance import permed_lsdds, batch_compute_kernel_matrix -from .kernels import GaussianRBF, DeepKernel +from .kernels import GaussianRBF, DeepKernel, BaseKernel from .prediction import predict_batch, predict_batch_transformer from .misc import get_device, quantile, zero_diag @@ -9,6 +9,7 @@ "mmd2", "mmd2_from_kernel_matrix", "squared_pairwise_distance", + "BaseKernel", "GaussianRBF", "DeepKernel", "permed_lsdds", diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index a6283aba0..a1870f01e 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -3,6 +3,7 @@ from torch import nn from . import distance from typing import Optional, Union, Callable +from copy import deepcopy def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): @@ -57,7 +58,7 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. return sigma.log() -class KernelParameter(object): +class KernelParameter: """ Parameter class for kernels. """ @@ -70,7 +71,7 @@ def __init__( requires_init: bool = False ) -> None: super().__init__() - self.value = nn.Parameter(value if value is not None else torch.ones(1), + self.value = nn.Parameter(value if value is not None else torch.ones(1), requires_grad=requires_grad) self.init_fn = init_fn self.requires_init = requires_init @@ -80,82 +81,157 @@ class BaseKernel(nn.Module): """ The base class for all kernels. """ - def __init__(self) -> None: + def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: super().__init__() self.parameter_dict: dict = {} + if active_dims is not None: + self.active_dims = torch.as_tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis + self.init_required = False - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: raise NotImplementedError - -class DimensionSelectKernel(nn.Module): - """ - Select a subset of the feature diomensions before apply a given kernel. - """ - def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: - super().__init__() - self.kernel = kernel - self.active_dims = torch.as_tensor(active_dims) - self.feature_axis = feature_axis - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) if self.active_dims is not None: x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) - return self.kernel(x, y, infer_parameter) + return self.kernel_function(x, y, infer_parameter) + + def __add__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other:nn.Module) -> nn.Module: + return self.__add__(other) + + def __mul__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_factors'): + other.kernel_factors.append(self) + return other + elif hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + sum_kernel.kernel_list.append(self * k) + return sum_kernel + else: + prod_kernel = ProductKernel() + prod_kernel.kernel_factors.append(self) + prod_kernel.kernel_factors.append(other) + return prod_kernel + + def __rmul__(self, other:nn.Module) -> nn.Module: + return self.__mul__(other) -class AveragedKernel(nn.Module): +class SumKernel(nn.Module): """ - Construct a kernel by averaging two kernels. + Construct a kernel by summing different kernels. Parameters: - ---------- - kernel_a - the first kernel to be averaged. - kernel_b - the second kernel to be averaged. + ---------------- """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_list = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 + value_list = [] + for k in self.kernel_list: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + return torch.sum(torch.stack(value_list), dim=0) + + def __add__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + for k in other.kernel_list: + self.kernel_list.append(k) + else: + self.kernel_list.append(other) + return self + + def __radd__(self, other:nn.Module) -> nn.Module: + return self.__add__(other) + + def __mul__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for ki in self.kernel_list: + for kj in other.kernel_list: + sum_kernel.kernel_list.append(ki * kj) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + return other * self + else: + sum_kernel = SumKernel() + for ki in self.kernel_list: + sum_kernel.kernel_list.append(other * ki) + return sum_kernel + def __rmul__(self, other:nn.Module) -> nn.Module: + return self.__mul__(other) -class ProductKernel(nn.Module): - """ - Construct a kernel by multiplying two kernels. - Parameters: - ---------- - kernel_a - the first kernel to be multiplied. - kernel_b - the second kernel to be multiplied. - """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: +class ProductKernel(nn.Module): + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_factors = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) + value_list = [] + for k in self.kernel_factors: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + return torch.prod(torch.stack(value_list), dim=0) + + def __add__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other:nn.Module) -> nn.Module: + return self.__add__(other) + + def __mul__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + tmp_prod_kernel = deepcopy(self) + tmp_prod_kernel.kernel_factors.append(k) + sum_kernel.kernel_list.append(tmp_prod_kernel) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + for k in other.kernel_factors: + self.kernel_factors.append(k) + return self + else: + self.kernel_factors.append(other) + return self + + def __rmul__(self, other:nn.Module) -> nn.Module: + return self.__mul__(other) class GaussianRBF(BaseKernel): @@ -163,7 +239,9 @@ def __init__( self, sigma: Optional[torch.Tensor] = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -182,7 +260,7 @@ def __init__( trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else None, init_fn=init_fn_sigma, @@ -196,8 +274,8 @@ def __init__( def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] @@ -218,7 +296,9 @@ def __init__( init_fn_alpha: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -232,7 +312,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( value=alpha.reshape(-1) if alpha is not None else None, init_fn=init_fn_alpha, @@ -256,14 +336,14 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: - if infer_parameter or self.init_required: - infer_kernel_parameter(self, x, y, dist, infer_parameter) + infer_kernel_parameter(self, x, y, dist, infer_parameter) kernel_mat = torch.stack([(1 + torch.square(dist) / (2 * self.alpha[i] * (self.sigma[i] ** 2))) @@ -280,6 +360,8 @@ def __init__( sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -293,7 +375,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( value=tau.log().reshape(-1) if tau is not None else None, init_fn=init_fn_tau, @@ -317,8 +399,8 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) @@ -331,67 +413,34 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat.mean(dim=0) -class LocalPeriodic(BaseKernel): +class ProjKernel(BaseKernel): + """ + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. + + Parameters: + ---------- + proj + The projection to be applied to the inputs before applying raw_kernel + raw_kernel + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + """ def __init__( self, - tau: torch.Tensor = None, - init_fn_tau: Callable = None, - sigma: torch.Tensor = None, - init_fn_sigma: Callable = sigma_median, - trainable: bool = False + proj: nn.Module, + raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: - """ - Local periodic kernel: k(x,y) = k_rbf(x, y) * k_period(x, y). - A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] - and returns the kernel matrix [Nx, Ny]. - - Parameters - ---------- - tau - Period of the periodic kernel. - sigma - Bandwidth used for the kernel. - """ super().__init__() - self.parameter_dict['log-tau'] = KernelParameter( - value=tau.log().reshape(-1) if tau is not None else None, - init_fn=init_fn_tau, - requires_grad=trainable, - requires_init=True if tau is None else False - ) - self.parameter_dict['log-sigma'] = KernelParameter( - value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_fn_sigma, - requires_grad=trainable, - requires_init=True if sigma is None else False - ) - self.trainable = trainable - self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) - - @property - def tau(self) -> torch.Tensor: - return self.parameter_dict['log-tau'].value.exp() - - @property - def sigma(self) -> torch.Tensor: - return self.parameter_dict['log-sigma'].value.exp() - - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: - x, y = torch.as_tensor(x), torch.as_tensor(y) - dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + self.proj = proj + self.raw_kernel = raw_kernel + self.init_required = False - if infer_parameter or self.init_required: - infer_kernel_parameter(self, x, y, dist, infer_parameter) - - kernel_mat = torch.stack([torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - torch.exp(-0.5 * torch.square(dist / self.tau[i])) - for i in range(len(self.sigma))], dim=0) - return kernel_mat.mean(dim=0) + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) -class DeepKernel(nn.Module): +class DeepKernel(BaseKernel): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). A forward pass takes a batch of instances x [Nx, features] and y [Ny, features] and returns @@ -414,17 +463,17 @@ class DeepKernel(nn.Module): def __init__( self, proj: nn.Module, - kernel_a: nn.Module = GaussianRBF(trainable=True), - kernel_b: Optional[nn.Module] = GaussianRBF(trainable=True), + kernel_a: BaseKernel = GaussianRBF(trainable=True), + kernel_b: BaseKernel = GaussianRBF(trainable=True), eps: Union[float, str] = 'trainable' ) -> None: super().__init__() - - self.kernel_a = kernel_a - self.kernel_b = kernel_b - self.proj = proj + proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) + self.comp_kernel = (1-self.logit_eps.sigmoid() )*proj_kernel + self.logit_eps.sigmoid()*kernel_b + else: + self.comp_kernel = proj_kernel def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -436,12 +485,5 @@ def _init_eps(self, eps: Union[float, str]) -> None: else: raise NotImplementedError("eps should be 'trainable' or a float in (0,1)") - @property - def eps(self) -> torch.Tensor: - return self.logit_eps.sigmoid() if self.kernel_b is not None else torch.tensor(0.) - - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - similarity = self.kernel_a(self.proj(x), self.proj(y)) - if self.kernel_b is not None: - similarity = (1-self.eps)*similarity + self.eps*self.kernel_b(x, y) - return similarity + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parmeter=False) -> torch.Tensor: + return self.comp_kernel(x, y, infer_parmeter) diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index 45e84df90..e19ca6629 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -3,7 +3,7 @@ import pytest import torch from torch import nn -from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel +from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -39,12 +39,12 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() -class MyKernel(nn.Module): # TODO: Support then test models using keras functional API +class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() self.linear = nn.Linear(n_features, 20) - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter) -> torch.Tensor: return torch.einsum('ji,ki->jk', self.linear(x), self.linear(y)) diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index 42a2d6b99..2f77c3030 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -1,6 +1,6 @@ from .distance import mmd2, mmd2_from_kernel_matrix, batch_compute_kernel_matrix from .distance import relative_euclidean_distance, squared_pairwise_distance, permed_lsdds -from .kernels import GaussianRBF, DeepKernel +from .kernels import GaussianRBF, DeepKernel, BaseKernel from .prediction import predict_batch, predict_batch_transformer from .misc import zero_diag, quantile, subset_matrix @@ -11,6 +11,7 @@ "relative_euclidean_distance", "squared_pairwise_distance", "GaussianRBF", + "BaseKernel", "DeepKernel", "permed_lsdds", "predict_batch", diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 1712708df..270f5f80a 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -1,8 +1,10 @@ +from lib2to3.pytree import Base import tensorflow as tf import numpy as np from . import distance from typing import Optional, Union, Callable from scipy.special import logit +from copy import deepcopy def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): @@ -60,11 +62,13 @@ class KernelParameter(object): """ Parameter class for kernels. """ - def __init__(self, - value: tf.Tensor = None, - init_fn: Optional[Callable] = None, - requires_grad: bool = False, - requires_init: bool = False): + def __init__( + self, + value: tf.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False + ) -> None: self.value = tf.Variable(value if value is not None else tf.ones(1, dtype=tf.keras.backend.floatx()), trainable=requires_grad) @@ -79,77 +83,152 @@ class BaseKernel(tf.keras.Model): """ The base class for all kernels. """ - def __init__(self) -> None: + def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: super().__init__() self.parameter_dict: dict = {} - - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return NotImplementedError - - -class DimensionSelectKernel(tf.keras.Model): - """ - Select a subset of the feature diomensions before apply a given kernel. - """ - def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: - super().__init__() - self.kernel = kernel self.active_dims = active_dims self.feature_axis = feature_axis + self.init_required = False + + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return NotImplementedError def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) - return self.kernel(x, y, infer_parameter) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) + return self.kernel_function(x, y, infer_parameter) + + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other:tf.keras.Model) -> tf.keras.Model: + return self.__add__(other) + + def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_factors'): + other.kernel_factors.append(self) + return other + elif hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + sum_kernel.kernel_list.append(self * k) + return sum_kernel + else: + prod_kernel = ProductKernel() + prod_kernel.kernel_factors.append(self) + prod_kernel.kernel_factors.append(other) + return prod_kernel + + def __rmul__(self, other:tf.keras.Model) -> tf.keras.Model: + return self.__mul__(other) -class AveragedKernel(tf.keras.Model): +class SumKernel(tf.keras.Model): """ - Construct a kernel by averaging two kernels. + Construct a kernel by summing different kernels. Parameters: - ---------- - kernel_a - the first kernel to be averaged. - kernel_b - the second kernel to be averaged. + ---------------- """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_list = [] + + def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], + infer_parameter: bool = False) -> tf.Tensor: + value_list = [] + for k in self.kernel_list: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + return tf.reduce_sum(tf.stack(value_list), axis=0) + + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + for k in other.kernel_list: + self.kernel_list.append(k) + else: + self.kernel_list.append(other) + return self + + def __radd__(self, other:tf.keras.Model) -> tf.keras.Model: + return self.__add__(other) + + def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for ki in self.kernel_list: + for kj in other.kernel_list: + sum_kernel.kernel_list.append(ki * kj) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + return other * self + else: + sum_kernel = SumKernel() + for ki in self.kernel_list: + sum_kernel.kernel_list.append(other * ki) + return sum_kernel - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 + def __rmul__(self, other:tf.keras.Model) -> tf.keras.Model: + return self.__mul__(other) class ProductKernel(tf.keras.Model): - """ - Construct a kernel by multiplying two kernels. - - Parameters: - ---------- - kernel_a - the first kernel to be multiplied. - kernel_b - the second kernel to be multiplied. - """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_factors = [] + + def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], + infer_parameter: bool = False) -> tf.Tensor: + value_list = [] + for k in self.kernel_factors: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + return tf.reduce_prod(tf.stack(value_list), axis=0) + + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other:tf.keras.Model) -> tf.keras.Model: + return self.__add__(other) + + def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + tmp_prod_kernel = deepcopy(self) + tmp_prod_kernel.kernel_factors.append(k) + sum_kernel.kernel_list.append(tmp_prod_kernel) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + for k in other.kernel_factors: + self.kernel_factors.append(k) + return self + else: + self.kernel_factors.append(other) + return self - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) + def __rmul__(self, other:tf.keras.Model) -> tf.keras.Model: + return self.__mul__(other) class GaussianRBF(BaseKernel): @@ -157,7 +236,9 @@ def __init__( self, sigma: Optional[tf.Tensor] = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -176,7 +257,7 @@ def __init__( trainable Whether or not to track gradients w.r.t. sigma to allow it to be trained. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.config = {'sigma': sigma, 'trainable': trainable} self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( @@ -192,7 +273,7 @@ def __init__( def sigma(self) -> tf.Tensor: return tf.math.exp(self.parameter_dict['log-sigma'].value) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] @@ -220,7 +301,9 @@ def __init__( init_fn_alpha: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -234,7 +317,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( value=tf.reshape( tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, @@ -260,7 +343,7 @@ def sigma(self) -> tf.Tensor: def alpha(self) -> tf.Tensor: return self.parameter_dict['alpha'].value - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -281,7 +364,9 @@ def __init__( init_fn_tau: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -295,7 +380,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, @@ -321,7 +406,7 @@ def tau(self) -> tf.Tensor: def sigma(self) -> tf.Tensor: return tf.math.exp(self.parameter_dict['log-sigma'].value) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -335,69 +420,22 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. return tf.reduce_mean(kernel_mat, axis=0) -class LocalPeriodic(BaseKernel): +class ProjKernel(BaseKernel): def __init__( self, - tau: tf.Tensor = None, - init_fn_tau: Callable = None, - sigma: tf.Tensor = None, - init_fn_sigma: Callable = sigma_median, - trainable: bool = False, + proj: tf.keras.Model, + raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: - """ - Local periodic kernel: k(x,y) = k(x,y) = k_rbf(x, y) * k_period(x, y). - A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] - and returns the kernel matrix [Nx, Ny]. - - Parameters - ---------- - tau - Period of the periodic kernel. - sigma - Bandwidth used for the kernel. - """ super().__init__() - self.parameter_dict['log-tau'] = KernelParameter( - value=tf.reshape(tf.math.log( - tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, - init_fn=init_fn_tau, - requires_grad=trainable, - requires_init=True if tau is None else False - ) - self.parameter_dict['log-sigma'] = KernelParameter( - value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, - init_fn=init_fn_sigma, - requires_grad=trainable, - requires_init=True if sigma is None else False - ) - self.trainable = trainable - self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) - - @property - def tau(self) -> tf.Tensor: - return tf.math.exp(self.parameter_dict['log-tau'].value) - - @property - def sigma(self) -> tf.Tensor: - return tf.math.exp(self.parameter_dict['log-sigma'].value) - - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - y = tf.cast(y, x.dtype) - x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) - dist = distance.squared_pairwise_distance(x, y) - - if infer_parameter or self.init_required: - infer_kernel_parameter(self, x, y, dist, infer_parameter) + self.proj = proj + self.raw_kernel = raw_kernel + self.init_required = False - kernel_mat = tf.stack([tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - tf.math.exp(-0.5 * tf.square(dist / self.tau[i])) - for i in range(len(self.sigma))], axis=0) - return tf.reduce_mean(kernel_mat, axis=0) + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) -class DeepKernel(tf.keras.Model): +class DeepKernel(BaseKernel): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). A forward pass takes a batch of instances x [Nx, features] and y [Ny, features] and returns @@ -420,21 +458,18 @@ class DeepKernel(tf.keras.Model): def __init__( self, proj: tf.keras.Model, - kernel_a: Union[tf.keras.Model, str] = 'rbf', - kernel_b: Optional[Union[tf.keras.Model, str]] = 'rbf', + kernel_a: BaseKernel = GaussianRBF(trainable=True), + kernel_b: BaseKernel = GaussianRBF(trainable=True), eps: Union[float, str] = 'trainable' ) -> None: super().__init__() - if kernel_a == 'rbf': - kernel_a = GaussianRBF(trainable=True) - if kernel_b == 'rbf': - kernel_b = GaussianRBF(trainable=True) - self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} - self.kernel_a = kernel_a - self.kernel_b = kernel_b - self.proj = proj + proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) + self.comp_kernel = (1-tf.sigmoid(self.logit_eps))*proj_kernel + tf.sigmoid(self.logit_eps)*kernel_b + else: + self.comp_kernel = proj_kernel + self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -451,11 +486,8 @@ def _init_eps(self, eps: Union[float, str]) -> None: def eps(self) -> tf.Tensor: return tf.math.sigmoid(self.logit_eps) if self.kernel_b is not None else tf.constant(0.) - def call(self, x: tf.Tensor, y: tf.Tensor) -> tf.Tensor: - similarity = self.kernel_a(self.proj(x), self.proj(y)) # type: ignore - if self.kernel_b is not None: - similarity = (1-self.eps)*similarity + self.eps*self.kernel_b(x, y) # type: ignore - return similarity + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.comp_kernel(x, y, infer_parameter) def get_config(self) -> dict: return self.config diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index ee90d6e72..a12a30d41 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -3,7 +3,7 @@ import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input -from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel +from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -38,12 +38,12 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() -class MyKernel(tf.keras.Model): # TODO: Support then test models using keras functional API +class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() self.dense = Dense(20) - def call(self, x: tf.Tensor, y: tf.Tensor) -> tf.Tensor: + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter) -> tf.Tensor: return tf.einsum('ji,ki->jk', self.dense(x), self.dense(y)) From 3d235fb25d6b58670b274dcd05522bb2931ec6c0 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 8 Sep 2022 16:51:25 +0100 Subject: [PATCH 11/37] Refine the behaviour of the new base kernel class, added further error messages on unsupported operations. Also added new notebook on creating user-defined kernels for drift detectors. --- alibi_detect/utils/pytorch/kernels.py | 84 +++- alibi_detect/utils/tensorflow/kernels.py | 64 ++- doc/source/examples/cd_combined_kernel.ipynb | 142 +++---- .../cd_create_customised_kernel.ipynb | 375 ++++++++++++++++++ 4 files changed, 544 insertions(+), 121 deletions(-) create mode 100644 doc/source/examples/cd_create_customised_kernel.ipynb diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index a1870f01e..c14b2e45c 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -71,7 +71,7 @@ def __init__( requires_init: bool = False ) -> None: super().__init__() - self.value = nn.Parameter(value if value is not None else torch.ones(1), + self.value = nn.Parameter(value if value is not None else torch.ones(1), requires_grad=requires_grad) self.init_fn = init_fn self.requires_init = requires_init @@ -101,8 +101,11 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch if self.active_dims is not None: x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) - return self.kernel_function(x, y, infer_parameter) - + if len(self.parameter_dict) > 0: + return self.kernel_function(x, y, infer_parameter) + else: + return self.kernel_function(x, y) + def __add__(self, other: nn.Module) -> nn.Module: if hasattr(other, 'kernel_list'): other.kernel_list.append(self) @@ -113,7 +116,7 @@ def __add__(self, other: nn.Module) -> nn.Module: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other:nn.Module) -> nn.Module: + def __radd__(self, other: nn.Module) -> nn.Module: return self.__add__(other) def __mul__(self, other: nn.Module) -> nn.Module: @@ -131,9 +134,24 @@ def __mul__(self, other: nn.Module) -> nn.Module: prod_kernel.kernel_factors.append(other) return prod_kernel - def __rmul__(self, other:nn.Module) -> nn.Module: + def __rmul__(self, other: nn.Module) -> nn.Module: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class SumKernel(nn.Module): """ @@ -155,7 +173,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch else: value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) return torch.sum(torch.stack(value_list), dim=0) - + def __add__(self, other: nn.Module) -> nn.Module: if hasattr(other, 'kernel_list'): for k in other.kernel_list: @@ -163,8 +181,8 @@ def __add__(self, other: nn.Module) -> nn.Module: else: self.kernel_list.append(other) return self - - def __radd__(self, other:nn.Module) -> nn.Module: + + def __radd__(self, other: nn.Module) -> nn.Module: return self.__add__(other) def __mul__(self, other: nn.Module) -> nn.Module: @@ -182,9 +200,24 @@ def __mul__(self, other: nn.Module) -> nn.Module: sum_kernel.kernel_list.append(other * ki) return sum_kernel - def __rmul__(self, other:nn.Module) -> nn.Module: + def __rmul__(self, other: nn.Module) -> nn.Module: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class ProductKernel(nn.Module): def __init__(self) -> None: @@ -200,7 +233,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch else: value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) return torch.prod(torch.stack(value_list), dim=0) - + def __add__(self, other: nn.Module) -> nn.Module: if hasattr(other, 'kernel_list'): other.kernel_list.append(self) @@ -211,7 +244,7 @@ def __add__(self, other: nn.Module) -> nn.Module: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other:nn.Module) -> nn.Module: + def __radd__(self, other: nn.Module) -> nn.Module: return self.__add__(other) def __mul__(self, other: nn.Module) -> nn.Module: @@ -230,9 +263,24 @@ def __mul__(self, other: nn.Module) -> nn.Module: self.kernel_factors.append(other) return self - def __rmul__(self, other:nn.Module) -> nn.Module: + def __rmul__(self, other: nn.Module) -> nn.Module: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class GaussianRBF(BaseKernel): def __init__( @@ -297,8 +345,8 @@ def __init__( sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -360,8 +408,8 @@ def __init__( sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -418,7 +466,7 @@ class ProjKernel(BaseKernel): A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. - + Parameters: ---------- proj @@ -471,7 +519,7 @@ def __init__( proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) - self.comp_kernel = (1-self.logit_eps.sigmoid() )*proj_kernel + self.logit_eps.sigmoid()*kernel_b + self.comp_kernel = (1-self.logit_eps.sigmoid())*proj_kernel + self.logit_eps.sigmoid()*kernel_b else: self.comp_kernel = proj_kernel diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 270f5f80a..12f821a49 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -1,4 +1,3 @@ -from lib2to3.pytree import Base import tensorflow as tf import numpy as np from . import distance @@ -110,7 +109,7 @@ def __add__(self, other: tf.keras.Model) -> tf.keras.Model: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other:tf.keras.Model) -> tf.keras.Model: + def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__add__(other) def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: @@ -128,9 +127,24 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: prod_kernel.kernel_factors.append(other) return prod_kernel - def __rmul__(self, other:tf.keras.Model) -> tf.keras.Model: + def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class SumKernel(tf.keras.Model): """ @@ -152,7 +166,7 @@ def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], else: value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) return tf.reduce_sum(tf.stack(value_list), axis=0) - + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: if hasattr(other, 'kernel_list'): for k in other.kernel_list: @@ -160,8 +174,8 @@ def __add__(self, other: tf.keras.Model) -> tf.keras.Model: else: self.kernel_list.append(other) return self - - def __radd__(self, other:tf.keras.Model) -> tf.keras.Model: + + def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__add__(other) def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: @@ -179,9 +193,24 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: sum_kernel.kernel_list.append(other * ki) return sum_kernel - def __rmul__(self, other:tf.keras.Model) -> tf.keras.Model: + def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class ProductKernel(tf.keras.Model): def __init__(self) -> None: @@ -197,7 +226,7 @@ def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], else: value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) return tf.reduce_prod(tf.stack(value_list), axis=0) - + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: if hasattr(other, 'kernel_list'): other.kernel_list.append(self) @@ -208,7 +237,7 @@ def __add__(self, other: tf.keras.Model) -> tf.keras.Model: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other:tf.keras.Model) -> tf.keras.Model: + def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__add__(other) def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: @@ -227,9 +256,24 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: self.kernel_factors.append(other) return self - def __rmul__(self, other:tf.keras.Model) -> tf.keras.Model: + def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class GaussianRBF(BaseKernel): def __init__( diff --git a/doc/source/examples/cd_combined_kernel.ipynb b/doc/source/examples/cd_combined_kernel.ipynb index 5c985d772..6742c5d9d 100644 --- a/doc/source/examples/cd_combined_kernel.ipynb +++ b/doc/source/examples/cd_combined_kernel.ipynb @@ -7,7 +7,7 @@ "# Create sum and product kernels with exsisting kernels\n", "\n", "\n", - "### Combine different kernels for better test power on certain data types" + "### From time to time, out dataset might contain values and features that might be of different types or scales. For instance, a temperture dataset might have two features with one being the timestamp and the other being the reading. As a result, we might want to apply differnt kernels on these two features respectively, and use the combined kernel for the drift detectors for a better test power." ] }, { @@ -21,30 +21,7 @@ "shell.execute_reply": "2022-08-17T22:48:42.258215Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-18 11:16:03.693515: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:03.693561: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", - "2022-08-18 11:16:09.361482: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n", - "Your kernel may have been built without NUMA support.\n", - "2022-08-18 11:16:09.361658: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361739: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361808: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361874: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361939: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362005: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362069: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362133: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362145: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", - "Skipping registering GPU devices...\n", - "2022-08-18 11:16:09.362441: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", - "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import scipy.stats as stats\n", @@ -52,13 +29,13 @@ "import matplotlib.pyplot as plt\n", "import tensorflow as tf\n", "\n", - "backend = 'pytorch'\n", + "backend = 'tensorflow'\n", "\n", "from alibi_detect.cd import MMDDrift\n", "if backend == 'pytorch':\n", - " from alibi_detect.utils.pytorch.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + " from alibi_detect.utils.pytorch.kernels import GaussianRBF, Periodic\n", "elif backend == 'tensorflow':\n", - " from alibi_detect.utils.tensorflow.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + " from alibi_detect.utils.tensorflow.kernels import GaussianRBF, Periodic\n", "else:\n", " raise ValueError('Backend {} not supported'.format(backend))\n", "\n", @@ -114,7 +91,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Here we create two simple datasets with waves and therefore have two features, the test data shows clear drift around the wave through." + "### Here, we create two simple datasets with waves and have two features. The test data shows apparent drift around the wave through." ] }, { @@ -141,7 +118,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -164,7 +141,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### If we use standard RBF kernel on both features with the MMD drift detector, we can see that the drift is not detected." + "### If we use the standard RBF kernel on both features with the MMD drift detector, we can see that the drift is not detected." ] }, { @@ -180,15 +157,7 @@ "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU detected, fall back on CPU.\n" - ] - } - ], + "outputs": [], "source": [ "cd_RBF = MMDDrift(x_ref=x_ref,\n", " backend=backend,\n", @@ -204,15 +173,15 @@ "data": { "text/plain": [ "{'data': {'is_drift': 0,\n", - " 'distance': -0.00032591944848670007,\n", - " 'p_val': 0.5600000023841858,\n", + " 'distance': 0.0006610155,\n", + " 'p_val': 0.24,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': array(0.00219562, dtype=float32)},\n", - " 'meta': {'name': 'MMDDriftTorch',\n", + " 'distance_threshold': 0.0027906895},\n", + " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", " 'version': '0.9.2dev',\n", - " 'backend': 'pytorch'}}" + " 'backend': 'tensorflow'}}" ] }, "execution_count": 7, @@ -229,7 +198,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### To facilitate our knowledge that the data contain waves, we use a combined kernel that is averaged from two kernels. The first kernel is a periodic kernel with a specified period of 24 and only working on the first feature. The second kernel is a RBF kernel with a infered bandwidth and only working on the second feature." + "### To facilitate our knowledge that the data contain waves, we use a combined kernel averaged from two kernels. The first kernel is a periodic kernel with a specified period of 24 and only works on the first feature. The second kernel is an RBF kernel with an inferred bandwidth and only works on the second feature." ] }, { @@ -246,11 +215,11 @@ "outputs": [], "source": [ "if backend == 'pytorch':\n", - " Kernel_0 = DimensionSelectKernel(Periodic(tau=torch.tensor([24.0])), active_dims=[0])\n", - " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])\n", + " Kernel_0 = Periodic(tau=torch.tensor([24.0]), active_dims=[0])\n", + " Kernel_1 = GaussianRBF(active_dims=[1])\n", "elif backend == 'tensorflow':\n", - " Kernel_0 = DimensionSelectKernel(Periodic(tau=tf.convert_to_tensor([24.0])), active_dims=[0])\n", - " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])" + " Kernel_0 = Periodic(tau=tf.convert_to_tensor([24.0]), active_dims=[0])\n", + " Kernel_1 = GaussianRBF(active_dims=[1])" ] }, { @@ -266,7 +235,7 @@ }, "outputs": [], "source": [ - "Kernel_avg = AveragedKernel(Kernel_0, Kernel_1)" + "Kernel_avg = (Kernel_0 + Kernel_1) / 2" ] }, { @@ -280,15 +249,7 @@ "shell.execute_reply": "2022-08-17T22:48:43.048438Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU detected, fall back on CPU.\n" - ] - } - ], + "outputs": [], "source": [ "cd_avg = MMDDrift(x_ref=x_ref,\n", " backend=backend,\n", @@ -311,15 +272,15 @@ "data": { "text/plain": [ "{'data': {'is_drift': 1,\n", - " 'distance': 0.006368878019042512,\n", + " 'distance': 0.006862521,\n", " 'p_val': 0.0,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': array(0.00098101, dtype=float32)},\n", - " 'meta': {'name': 'MMDDriftTorch',\n", + " 'distance_threshold': 0.0007869005},\n", + " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", " 'version': '0.9.2dev',\n", - " 'backend': 'pytorch'}}" + " 'backend': 'tensorflow'}}" ] }, "execution_count": 11, @@ -336,7 +297,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### The kernel, its compments and asscociated parameters can be inspected as follows:\n" + "### The kernel, its components and associated parameters can be inspected as follows:" ] }, { @@ -355,25 +316,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "AveragedKernel(\n", - " (kernel_a): DimensionSelectKernel(\n", - " (kernel): Periodic()\n", - " )\n", - " (kernel_b): DimensionSelectKernel(\n", - " (kernel): GaussianRBF()\n", - " )\n", - ")\n", - "DimensionSelectKernel(\n", - " (kernel): Periodic()\n", - ")\n", - "Periodic()\n" + "\n", + "ListWrapper([, 0.5])\n", + "ListWrapper([, 0.5])\n" ] } ], "source": [ "print(cd_avg._detector.kernel)\n", - "print(cd_avg._detector.kernel.kernel_a)\n", - "print(cd_avg._detector.kernel.kernel_a.kernel)" + "print(cd_avg._detector.kernel.kernel_list[0].kernel_factors)\n", + "print(cd_avg._detector.kernel.kernel_list[1].kernel_factors)" ] }, { @@ -392,14 +344,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "tensor([24.])\n", - "tensor([4.9818], dtype=torch.float64)\n" + "tf.Tensor([24.], shape=(1,), dtype=float32)\n", + "tf.Tensor([34.31387], shape=(1,), dtype=float32)\n" ] } ], "source": [ - "print(Kernel_avg.kernel_a.kernel.tau)\n", - "print(Kernel_avg.kernel_a.kernel.sigma)" + "print(Kernel_avg.kernel_list[0].kernel_factors[0].tau)\n", + "print(Kernel_avg.kernel_list[0].kernel_factors[0].sigma)" ] }, { @@ -415,24 +367,28 @@ }, "outputs": [ { - "data": { - "text/plain": [ - "tensor([0.5243], dtype=torch.float64)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "tf.Tensor([0.50738114], shape=(1,), dtype=float32)\n" + ] } ], "source": [ - "Kernel_avg.kernel_b.kernel.sigma" + "print(Kernel_avg.kernel_list[1].kernel_factors[0].sigma)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('detect_cpu_py38')", + "display_name": "Python 3.8.13", "language": "python", "name": "python3" }, diff --git a/doc/source/examples/cd_create_customised_kernel.ipynb b/doc/source/examples/cd_create_customised_kernel.ipynb new file mode 100644 index 000000000..1eca99936 --- /dev/null +++ b/doc/source/examples/cd_create_customised_kernel.ipynb @@ -0,0 +1,375 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create customised kernel to be used with drift detectors\n", + "\n", + "### Sometimes we might prefer to use some prior knowledge or pre-trained embeddings to build a customised kernel (distance) function instead. In this notebook, we will demonstrate how to implement a user-defined kernel with either a customised distance function or a specific feature projection function. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:30.140646Z", + "iopub.status.busy": "2022-08-17T22:48:30.139694Z", + "iopub.status.idle": "2022-08-17T22:48:42.261216Z", + "shell.execute_reply": "2022-08-17T22:48:42.258215Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.stats as stats\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "backend = 'pytorch'\n", + "\n", + "from alibi_detect.cd import MMDDrift\n", + "if backend == 'pytorch':\n", + " from alibi_detect.utils.pytorch.kernels import BaseKernel, ProjKernel, GaussianRBF\n", + "elif backend == 'tensorflow':\n", + " from alibi_detect.utils.tensorflow.kernels import BaseKernel, ProjKernel, GaussianRBF\n", + "else:\n", + " raise ValueError('Backend {} not supported'.format(backend))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We first consider to create a kernel that uses a user specified distance function. For instance, we can write a periodic kernel's distance function with the Trigonometric functions: $k(x,y) = exp(-2 \\cdot \\frac{sin(pi \\cdot \\frac{|x - y|}{\\tau})^2}{\\sigma^2})$. To do so, the easiest way is to import and inherit the BaseKernel class from the corresponding backend (here we use Pytorch), and overload the kernelfunction method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### For this example, we manually specified the kernel's parameters in the kernel function. To implement these parameters as variables for training or initialisation heuristics, please refer to the implementations in the built-in kernels." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class PeriodicKernel(BaseKernel):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def kernel_function(self, x, y):\n", + " tau = 24.0 # period parameter\n", + " sigma = 0.05 # bandwidth parameter\n", + " x, y = torch.as_tensor(x), torch.as_tensor(y)\n", + " x2 = x.pow(2).sum(dim=-1, keepdim=True)\n", + " y2 = y.pow(2).sum(dim=-1, keepdim=True)\n", + " dist = torch.addmm(y2.transpose(-2, -1), x, y.transpose(-2, -1), alpha=-2).add_(x2)\n", + " kernel_mat = torch.exp(-2 * torch.square(torch.sin(torch.as_tensor(np.pi) * dist / tau)) / (sigma ** 2))\n", + " return kernel_mat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we create a toy dataset to test our new kernel, where the test data shows an apparent drift around the wave through." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_sin(N):\n", + " c_0 = np.random.uniform(0, 168, N)\n", + " x_0 = np.sin(c_0 / (12 / np.pi)) + np.random.normal(0, 0.1, N)\n", + "\n", + " c_1 = stats.beta.rvs(a=1.2, b=1.2, size=N) * 24 + np.random.choice([0, 24, 48, 72, 96, 120, 144], size=N)\n", + " x_1 = np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) < 12) + \\\n", + " np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) >= 12) * 1.25 + \\\n", + " + np.random.normal(0, 0.1, N)\n", + " \n", + " x_ref = np.hstack([c_0.reshape(-1, 1), x_0.reshape(-1, 1)])\n", + " x_test = np.hstack([c_1.reshape(-1, 1), x_1.reshape(-1, 1)]) \n", + " \n", + " return x_ref, x_test" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "x_ref, x_test = get_sin(N=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.5, 1.5)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 3), dpi=128)\n", + "plt.plot(x_ref[:, 0], x_ref[:, 1], 'bo', alpha=0.5, markersize=2.5, label='Reference')\n", + "plt.plot(x_test[:, 0], x_test[:, 1], 'ro', alpha=0.5, markersize=2.5, label='Test')\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We can now create an instance of the periodic kernel implemented above and use it with the MMD detector. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "kernel_period = PeriodicKernel()\n", + "\n", + "cd = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=kernel_period)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 1,\n", + " 'distance': 0.0006290622733601328,\n", + " 'p_val': 0.029999999329447746,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00055086, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds = cd.predict(x_test)\n", + "preds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Alternatively, we might consider using a projection function (which could be anything from a straightforward linear transform to a deep net) to imply our knowledge about the dataset. In this case, we can consider implementing the kernel with the ProjKernel class, where we can define the projection function using the model class from the corresponding backend (i.e. torch.nn.Module)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "class MyProj(torch.nn.Module):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def forward(self, x):\n", + " x = torch.as_tensor(x)\n", + " return torch.cat([torch.remainder(x[:, 0], 24).reshape(-1, 1), x[:, 1].reshape(-1, 1)], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### As indicated by the code above, here we create a simple projection function by getting the remainder of the first feature after dividing by 24, while the second feature is kept." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.5, 1.5)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "proj = MyProj()\n", + "\n", + "x_proj_ref = proj(x_ref)\n", + "\n", + "x_proj_test = proj(x_test)\n", + "\n", + "plt.figure(figsize=(4, 3), dpi=128)\n", + "plt.plot(x_proj_ref[:, 0], x_proj_ref[:, 1], 'bo', alpha=0.5, markersize=2.5, label='Reference')\n", + "plt.plot(x_proj_test[:, 0], x_proj_test[:, 1], 'ro', alpha=0.5, markersize=2.5, label='Test')\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We can then create the kernel with the projection model and a base RBF kernel and use it together with the MMD detector. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "kernel_proj = ProjKernel(proj = proj,\n", + " raw_kernel= GaussianRBF(sigma=torch.as_tensor(0.05)))\n", + "\n", + "cd_proj = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=kernel_proj)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 1,\n", + " 'distance': 0.0009441937452792366,\n", + " 'p_val': 0.0,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00010083, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds_proj = cd_proj.predict(x_test)\n", + "preds_proj" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 4587499093fab70903fb188b7b4cc002d2ca5297 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Tue, 20 Sep 2022 09:17:45 +0100 Subject: [PATCH 12/37] Added extra treatments for different kernel class. Also refine the type hint for various methods and attributes for better consistency. --- alibi_detect/utils/pytorch/kernels.py | 146 ++++++++++++------ .../utils/pytorch/tests/test_kernels_pt.py | 4 +- alibi_detect/utils/tensorflow/kernels.py | 131 ++++++++++------ .../utils/tensorflow/tests/test_kernels_tf.py | 2 +- 4 files changed, 190 insertions(+), 93 deletions(-) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index c14b2e45c..cf29d9663 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -2,7 +2,7 @@ import torch from torch import nn from . import distance -from typing import Optional, Union, Callable +from typing import Optional, Union, Callable, List from copy import deepcopy @@ -92,7 +92,7 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.init_required = False def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + infer_parameter: Optional[bool] = False) -> torch.Tensor: raise NotImplementedError def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], @@ -106,24 +106,34 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch else: return self.kernel_function(x, y) - def __add__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other - else: + elif (isinstance(other, BaseKernel) or + isinstance(other, ProductKernel) or + isinstance(other, torch.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) return sum_kernel + else: + raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: nn.Module) -> nn.Module: + def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_factors'): + def __mul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other - elif hasattr(other, 'kernel_list'): + elif isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) @@ -134,12 +144,15 @@ def __mul__(self, other: nn.Module) -> nn.Module: prod_kernel.kernel_factors.append(other) return prod_kernel - def __rmul__(self, other: nn.Module) -> nn.Module: + def __rmul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): - return self.__mul__(1 / other) + def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, torch.Tensor): + return self.__mul__(1. / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -162,49 +175,62 @@ class SumKernel(nn.Module): """ def __init__(self) -> None: super().__init__() - self.kernel_list = [] + self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - value_list = [] + value_list: List[torch.Tensor] = [] for k in self.kernel_list: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, torch.Tensor): value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by SumKernel.') return torch.sum(torch.stack(value_list), dim=0) - def __add__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): for k in other.kernel_list: self.kernel_list.append(k) else: self.kernel_list.append(other) - return self + return self - def __radd__(self, other: nn.Module) -> nn.Module: + def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: for kj in other.kernel_list: - sum_kernel.kernel_list.append(ki * kj) + sum_kernel.kernel_list.append((ki * kj)) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): return other * self - else: + elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') - def __rmul__(self, other: nn.Module) -> nn.Module: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -222,20 +248,25 @@ def __rsub__(self, other): class ProductKernel(nn.Module): def __init__(self) -> None: super().__init__() - self.kernel_factors = [] + self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - value_list = [] + value_list: List[torch.Tensor] = [] for k in self.kernel_factors: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, torch.Tensor): value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by ProductKernel.') return torch.prod(torch.stack(value_list), dim=0) - def __add__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other else: @@ -244,30 +275,41 @@ def __add__(self, other: nn.Module) -> nn.Module: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other: nn.Module) -> nn.Module: + def __radd__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: tmp_prod_kernel = deepcopy(self) tmp_prod_kernel.kernel_factors.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): for k in other.kernel_factors: self.kernel_factors.append(k) - return self - else: + return self + elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): self.kernel_factors.append(other) return self + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') - def __rmul__(self, other: nn.Module) -> nn.Module: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -484,7 +526,12 @@ def __init__( self.raw_kernel = raw_kernel self.init_required = False - def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def kernel_function( + self, + x: Union[np.ndarray, torch.Tensor], + y: Union[np.ndarray, torch.Tensor], + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) @@ -533,5 +580,10 @@ def _init_eps(self, eps: Union[float, str]) -> None: else: raise NotImplementedError("eps should be 'trainable' or a float in (0,1)") - def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parmeter=False) -> torch.Tensor: - return self.comp_kernel(x, y, infer_parmeter) + def kernel_function( + self, + x: Union[np.ndarray, torch.Tensor], + y: Union[np.ndarray, torch.Tensor], + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: + return self.comp_kernel(x, y, infer_parameter) diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index e19ca6629..22cb2298e 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -3,6 +3,7 @@ import pytest import torch from torch import nn +from typing import Union from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] @@ -44,7 +45,8 @@ def __init__(self, n_features: int): super().__init__() self.linear = nn.Linear(n_features, 20) - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: return torch.einsum('ji,ki->jk', self.linear(x), self.linear(y)) diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 12f821a49..9336d5b82 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -1,7 +1,7 @@ import tensorflow as tf import numpy as np from . import distance -from typing import Optional, Union, Callable +from typing import Optional, Union, Callable, List from scipy.special import logit from copy import deepcopy @@ -89,7 +89,8 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.feature_axis = feature_axis self.init_required = False - def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, + infer_parameter: Optional[bool] = False) -> tf.Tensor: return NotImplementedError def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: @@ -99,24 +100,34 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. y = tf.gather(y, self.active_dims, axis=self.feature_axis) return self.kernel_function(x, y, infer_parameter) - def __add__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other - else: + elif (isinstance(other, BaseKernel) or + isinstance(other, ProductKernel) or + isinstance(other, tf.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) return sum_kernel + else: + raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_factors'): + def __mul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other - elif hasattr(other, 'kernel_list'): + elif isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) @@ -127,12 +138,15 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: prod_kernel.kernel_factors.append(other) return prod_kernel - def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + def __rmul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): - return self.__mul__(1 / other) + def __truediv__(self, other: tf.Tensor) -> 'ProductKernel': + if isinstance(other, tf.Tensor): + return self.__mul__(1. / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -155,49 +169,62 @@ class SumKernel(tf.keras.Model): """ def __init__(self) -> None: super().__init__() - self.kernel_list = [] + self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: - value_list = [] + value_list: List[tf.Tensor] = [] for k in self.kernel_list: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, tf.Tensor): value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by SumKernel.') return tf.reduce_sum(tf.stack(value_list), axis=0) - def __add__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): for k in other.kernel_list: self.kernel_list.append(k) else: self.kernel_list.append(other) - return self + return self - def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: for kj in other.kernel_list: - sum_kernel.kernel_list.append(ki * kj) + sum_kernel.kernel_list.append((ki * kj)) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): return other * self - else: + elif isinstance(other, BaseKernel) or isinstance(other, tf.Tensor): sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') - def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + def __truediv__(self, other: tf.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, tf.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -215,20 +242,25 @@ def __rsub__(self, other): class ProductKernel(tf.keras.Model): def __init__(self) -> None: super().__init__() - self.kernel_factors = [] + self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: - value_list = [] + value_list: List[tf.Tensor] = [] for k in self.kernel_factors: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, tf.Tensor): value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by ProductKernel.') return tf.reduce_prod(tf.stack(value_list), axis=0) - def __add__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other else: @@ -237,30 +269,41 @@ def __add__(self, other: tf.keras.Model) -> tf.keras.Model: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + def __radd__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: tmp_prod_kernel = deepcopy(self) tmp_prod_kernel.kernel_factors.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): for k in other.kernel_factors: self.kernel_factors.append(k) - return self - else: + return self + elif isinstance(other, BaseKernel) or isinstance(other, tf.Tensor): self.kernel_factors.append(other) return self + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') - def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + def __truediv__(self, other: tf.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, tf.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index a12a30d41..edad5dfd3 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -43,7 +43,7 @@ def __init__(self, n_features: int): super().__init__() self.dense = Dense(20) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter) -> tf.Tensor: + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return tf.einsum('ji,ki->jk', self.dense(x), self.dense(y)) From bd1dde9fc1bc9bc5e2724a8cc2cf404feb22283a Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 14 Oct 2022 22:06:38 +0100 Subject: [PATCH 13/37] Add additional tests for the new kernels, and fix notebooks with new divide input types. --- alibi_detect/utils/pytorch/__init__.py | 4 +- .../utils/pytorch/tests/test_kernels_pt.py | 129 +++++++++++++++- alibi_detect/utils/tensorflow/__init__.py | 2 +- .../utils/tensorflow/tests/test_kernels_tf.py | 122 ++++++++++++++- doc/source/examples/cd_combined_kernel.ipynb | 140 ++++-------------- .../cd_create_customised_kernel.ipynb | 16 +- 6 files changed, 284 insertions(+), 129 deletions(-) diff --git a/alibi_detect/utils/pytorch/__init__.py b/alibi_detect/utils/pytorch/__init__.py index 708bad8ca..ec230bc43 100644 --- a/alibi_detect/utils/pytorch/__init__.py +++ b/alibi_detect/utils/pytorch/__init__.py @@ -1,6 +1,6 @@ from .distance import mmd2, mmd2_from_kernel_matrix, squared_pairwise_distance from .distance import permed_lsdds, batch_compute_kernel_matrix -from .kernels import GaussianRBF, DeepKernel, BaseKernel +from .kernels import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic from .prediction import predict_batch, predict_batch_transformer from .misc import get_device, quantile, zero_diag @@ -11,6 +11,8 @@ "squared_pairwise_distance", "BaseKernel", "GaussianRBF", + "RationalQuadratic", + "Periodic", "DeepKernel", "permed_lsdds", "predict_batch", diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index 22cb2298e..a4f405b54 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -4,7 +4,7 @@ import torch from torch import nn from typing import Union -from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel +from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -40,6 +40,133 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +sigma = [None, np.array([1.]), np.array([2.])] +alpha = [None, np.array([1.]), np.array([2.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_rqk = list(product(sigma, alpha, n_features, n_instances, trainable)) +n_tests_rqk = len(tests_rqk) + + +@pytest.fixture +def rationalquadratic_kernel_params(request): + return tests_rqk[request.param] + + +@pytest.mark.parametrize('rationalquadratic_kernel_params', list(range(n_tests_rqk)), indirect=True) +def test_rationalquadratic_kernel(rationalquadratic_kernel_params): + sigma, alpha, n_features, n_instances, trainable = rationalquadratic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + sigma = sigma if sigma is None else torch.from_numpy(sigma) + alpha = alpha if alpha is None else torch.from_numpy(alpha) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + kernel = RationalQuadratic(sigma=sigma, alpha=alpha, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma = [None, np.array([1.]), np.array([2.])] +tau = [None, np.array([8.]), np.array([24.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_pk = list(product(sigma, tau, n_features, n_instances, trainable)) +n_tests_pk = len(tests_pk) + + +@pytest.fixture +def periodic_kernel_params(request): + return tests_pk[request.param] + + +@pytest.mark.parametrize('periodic_kernel_params', list(range(n_tests_pk)), indirect=True) +def test_periodic_kernel(periodic_kernel_params): + sigma, tau, n_features, n_instances, trainable = periodic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + sigma = sigma if sigma is None else torch.from_numpy(sigma) + tau = tau if tau is None else torch.from_numpy(tau) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + kernel = Periodic(sigma=sigma, tau=tau, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma_0 = [None, np.array([1.])] +sigma_1 = [None, np.array([1.])] +sigma_2 = [None, np.array([1.])] +operation_0 = ['*', '+'] +operation_1 = ['*', '+'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_ck = list(product(sigma_0, sigma_1, sigma_2, + operation_0, operation_1, n_features, n_instances, trainable)) +n_tests_ck = len(tests_ck) + + +@pytest.fixture +def comp_kernel_params(request): + return tests_ck[request.param] + + +@pytest.mark.parametrize('comp_kernel_params', list(range(n_tests_ck)), indirect=True) +def test_comp_kernel(comp_kernel_params): + (sigma_0, sigma_1, sigma_2, operation_0, operation_1, + n_features, n_instances, trainable) = comp_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + sigma_0 = sigma_0 if sigma_0 is None else torch.from_numpy(sigma_0) + sigma_1 = sigma_1 if sigma_1 is None else torch.from_numpy(sigma_1) + sigma_2 = sigma_2 if sigma_2 is None else torch.from_numpy(sigma_2) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + kernel_0 = GaussianRBF(sigma=sigma_0, trainable=trainable) + kernel_1 = GaussianRBF(sigma=sigma_1, trainable=trainable) + kernel_2 = GaussianRBF(sigma=sigma_2, trainable=trainable) + if operation_0 == '*' and operation_1 == '*': + kernel = kernel_0 * kernel_1 * kernel_2 + elif operation_0 == '*' and operation_1 == '+': + kernel = (kernel_0 * kernel_1 + kernel_2) / torch.tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '*': + kernel = (kernel_0 + kernel_1 * kernel_2) / torch.tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '+': + kernel = (kernel_0 + kernel_1 + kernel_2) / torch.tensor(3.0) # ensure k(x, x) = 1 + else: + with pytest.raises(Exception): + raise Exception('Invalid operation') + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index 2f77c3030..b217e4035 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -1,6 +1,6 @@ from .distance import mmd2, mmd2_from_kernel_matrix, batch_compute_kernel_matrix from .distance import relative_euclidean_distance, squared_pairwise_distance, permed_lsdds -from .kernels import GaussianRBF, DeepKernel, BaseKernel +from .kernels import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic from .prediction import predict_batch, predict_batch_transformer from .misc import zero_diag, quantile, subset_matrix diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index edad5dfd3..f73c7c302 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -3,7 +3,7 @@ import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input -from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel +from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -38,6 +38,126 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +sigma = [None, np.array([1.]), np.array([2.])] +alpha = [None, np.array([1.]), np.array([2.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_rqk = list(product(sigma, alpha, n_features, n_instances, trainable)) +n_tests_rqk = len(tests_rqk) + + +@pytest.fixture +def rationalquadratic_kernel_params(request): + return tests_rqk[request.param] + + +@pytest.mark.parametrize('rationalquadratic_kernel_params', list(range(n_tests_rqk)), indirect=True) +def test_rationalquadratic_kernel(rationalquadratic_kernel_params): + sigma, alpha, n_features, n_instances, trainable = rationalquadratic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + kernel = RationalQuadratic(sigma=sigma, alpha=alpha, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma = [None, np.array([1.]), np.array([2.])] +tau = [None, np.array([8.]), np.array([24.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_pk = list(product(sigma, tau, n_features, n_instances, trainable)) +n_tests_pk = len(tests_pk) + + +@pytest.fixture +def periodic_kernel_params(request): + return tests_pk[request.param] + + +@pytest.mark.parametrize('periodic_kernel_params', list(range(n_tests_pk)), indirect=True) +def test_periodic_kernel(periodic_kernel_params): + sigma, tau, n_features, n_instances, trainable = periodic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + kernel = Periodic(sigma=sigma, tau=tau, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma_0 = [None, np.array([1.])] +sigma_1 = [None, np.array([1.])] +sigma_2 = [None, np.array([1.])] +operation_0 = ['*', '+'] +operation_1 = ['*', '+'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_ck = list(product(sigma_0, sigma_1, sigma_2, + operation_0, operation_1, n_features, n_instances, trainable)) +n_tests_ck = len(tests_ck) + + +@pytest.fixture +def comp_kernel_params(request): + return tests_ck[request.param] + + +@pytest.mark.parametrize('comp_kernel_params', list(range(n_tests_ck)), indirect=True) +def test_comp_kernel(comp_kernel_params): + (sigma_0, sigma_1, sigma_2, operation_0, operation_1, + n_features, n_instances, trainable) = comp_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + kernel_0 = GaussianRBF(sigma=sigma_0, trainable=trainable) + kernel_1 = GaussianRBF(sigma=sigma_1, trainable=trainable) + kernel_2 = GaussianRBF(sigma=sigma_2, trainable=trainable) + if operation_0 == '*' and operation_1 == '*': + kernel = kernel_0 * kernel_1 * kernel_2 + elif operation_0 == '*' and operation_1 == '+': + kernel = (kernel_0 * kernel_1 + kernel_2) / tf.convert_to_tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '*': + kernel = (kernel_0 + kernel_1 * kernel_2) / tf.convert_to_tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '+': + kernel = (kernel_0 + kernel_1 + kernel_2) / tf.convert_to_tensor(3.0) # ensure k(x, x) = 1 + else: + with pytest.raises(Exception): + raise Exception('Invalid operation') + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() diff --git a/doc/source/examples/cd_combined_kernel.ipynb b/doc/source/examples/cd_combined_kernel.ipynb index 6742c5d9d..773fa9aed 100644 --- a/doc/source/examples/cd_combined_kernel.ipynb +++ b/doc/source/examples/cd_combined_kernel.ipynb @@ -13,14 +13,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:30.140646Z", - "iopub.status.busy": "2022-08-17T22:48:30.139694Z", - "iopub.status.idle": "2022-08-17T22:48:42.261216Z", - "shell.execute_reply": "2022-08-17T22:48:42.258215Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -46,14 +39,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.268753Z", - "iopub.status.busy": "2022-08-17T22:48:42.267268Z", - "iopub.status.idle": "2022-08-17T22:48:42.287665Z", - "shell.execute_reply": "2022-08-17T22:48:42.283443Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "def get_sin(N):\n", @@ -74,14 +60,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.296254Z", - "iopub.status.busy": "2022-08-17T22:48:42.295141Z", - "iopub.status.idle": "2022-08-17T22:48:42.307361Z", - "shell.execute_reply": "2022-08-17T22:48:42.304563Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "x_ref, x_test = get_sin(N=1000)" @@ -97,14 +76,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.315487Z", - "iopub.status.busy": "2022-08-17T22:48:42.314280Z", - "iopub.status.idle": "2022-08-17T22:48:42.627643Z", - "shell.execute_reply": "2022-08-17T22:48:42.626213Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -118,7 +90,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -173,10 +145,10 @@ "data": { "text/plain": [ "{'data': {'is_drift': 0,\n", - " 'distance': 0.0006610155,\n", - " 'p_val': 0.24,\n", + " 'distance': -0.000772655,\n", + " 'p_val': 0.8,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': 0.0027906895},\n", + " 'distance_threshold': 0.0021861196},\n", " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", @@ -204,51 +176,23 @@ { "cell_type": "code", "execution_count": 8, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.633012Z", - "iopub.status.busy": "2022-08-17T22:48:42.632420Z", - "iopub.status.idle": "2022-08-17T22:48:42.663421Z", - "shell.execute_reply": "2022-08-17T22:48:42.661867Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "if backend == 'pytorch':\n", " Kernel_0 = Periodic(tau=torch.tensor([24.0]), active_dims=[0])\n", " Kernel_1 = GaussianRBF(active_dims=[1])\n", + " Kernel_avg = (Kernel_0 + Kernel_1) / torch.tensor(2.0)\n", "elif backend == 'tensorflow':\n", " Kernel_0 = Periodic(tau=tf.convert_to_tensor([24.0]), active_dims=[0])\n", - " Kernel_1 = GaussianRBF(active_dims=[1])" + " Kernel_1 = GaussianRBF(active_dims=[1])\n", + " Kernel_avg = (Kernel_0 + Kernel_1) / tf.convert_to_tensor(2.0)" ] }, { "cell_type": "code", "execution_count": 9, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.682278Z", - "iopub.status.busy": "2022-08-17T22:48:42.681366Z", - "iopub.status.idle": "2022-08-17T22:48:42.695138Z", - "shell.execute_reply": "2022-08-17T22:48:42.692762Z" - } - }, - "outputs": [], - "source": [ - "Kernel_avg = (Kernel_0 + Kernel_1) / 2" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.702931Z", - "iopub.status.busy": "2022-08-17T22:48:42.700551Z", - "iopub.status.idle": "2022-08-17T22:48:43.049891Z", - "shell.execute_reply": "2022-08-17T22:48:43.048438Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "cd_avg = MMDDrift(x_ref=x_ref,\n", @@ -265,17 +209,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'data': {'is_drift': 1,\n", - " 'distance': 0.006862521,\n", + " 'distance': 0.0052251816,\n", " 'p_val': 0.0,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': 0.0007869005},\n", + " 'distance_threshold': 0.0009160042},\n", " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", @@ -283,7 +227,7 @@ " 'backend': 'tensorflow'}}" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -302,23 +246,16 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:43.055921Z", - "iopub.status.busy": "2022-08-17T22:48:43.055518Z", - "iopub.status.idle": "2022-08-17T22:48:43.064586Z", - "shell.execute_reply": "2022-08-17T22:48:43.063483Z" - } - }, + "execution_count": 11, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "ListWrapper([, 0.5])\n", - "ListWrapper([, 0.5])\n" + "\n", + "ListWrapper([, ])\n", + "ListWrapper([, ])\n" ] } ], @@ -330,22 +267,15 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:44.915230Z", - "iopub.status.busy": "2022-08-17T22:48:44.914553Z", - "iopub.status.idle": "2022-08-17T22:48:44.924660Z", - "shell.execute_reply": "2022-08-17T22:48:44.923360Z" - } - }, + "execution_count": 12, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tf.Tensor([24.], shape=(1,), dtype=float32)\n", - "tf.Tensor([34.31387], shape=(1,), dtype=float32)\n" + "tf.Tensor([34.68171], shape=(1,), dtype=float32)\n" ] } ], @@ -356,21 +286,14 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:44.928919Z", - "iopub.status.busy": "2022-08-17T22:48:44.928266Z", - "iopub.status.idle": "2022-08-17T22:48:44.938336Z", - "shell.execute_reply": "2022-08-17T22:48:44.936929Z" - } - }, + "execution_count": 13, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tf.Tensor([0.50738114], shape=(1,), dtype=float32)\n" + "tf.Tensor([0.5185638], shape=(1,), dtype=float32)\n" ] } ], @@ -388,7 +311,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -403,11 +326,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" - } } }, "nbformat": 4, diff --git a/doc/source/examples/cd_create_customised_kernel.ipynb b/doc/source/examples/cd_create_customised_kernel.ipynb index 1eca99936..c3a8052aa 100644 --- a/doc/source/examples/cd_create_customised_kernel.ipynb +++ b/doc/source/examples/cd_create_customised_kernel.ipynb @@ -12,14 +12,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:30.140646Z", - "iopub.status.busy": "2022-08-17T22:48:30.139694Z", - "iopub.status.idle": "2022-08-17T22:48:42.261216Z", - "shell.execute_reply": "2022-08-17T22:48:42.258215Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -348,7 +341,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -363,11 +356,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" - } } }, "nbformat": 4, From 52486da823760257c1c6b7086c8e1bd426b006a3 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 17 Oct 2022 01:12:02 +0100 Subject: [PATCH 14/37] Address reviewer comments on: (1) doc string, (2) outdated comments, (3) type hints and (4) misc fixes. --- alibi_detect/cd/base.py | 7 -- alibi_detect/cd/pytorch/context_aware.py | 5 - alibi_detect/cd/pytorch/lsdd.py | 14 --- alibi_detect/cd/pytorch/lsdd_online.py | 11 -- alibi_detect/cd/pytorch/mmd.py | 8 -- alibi_detect/cd/pytorch/mmd_online.py | 7 -- alibi_detect/cd/tensorflow/context_aware.py | 5 - alibi_detect/cd/tensorflow/lsdd.py | 13 --- alibi_detect/cd/tensorflow/lsdd_online.py | 9 -- alibi_detect/cd/tensorflow/mmd.py | 8 -- alibi_detect/cd/tensorflow/mmd_online.py | 7 -- alibi_detect/utils/pytorch/kernels.py | 105 ++++++++++++++------ alibi_detect/utils/tensorflow/__init__.py | 2 + alibi_detect/utils/tensorflow/kernels.py | 90 ++++++++++++++--- 14 files changed, 155 insertions(+), 136 deletions(-) diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index 1e88189a0..17a39db71 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -462,7 +462,6 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -503,12 +502,6 @@ def __init__( logger.warning('No p-value set for the drift threshold. Need to set it to detect data drift.') self.infer_parameter = configure_kernel_from_x_ref - # self.infer_sigma = configure_kernel_from_x_ref - # if configure_kernel_from_x_ref and isinstance(sigma, np.ndarray): - # self.infer_sigma = False - # logger.warning('`sigma` is specified for the kernel and `configure_kernel_from_x_ref` ' - # 'is set to True. `sigma` argument takes priority over ' - # '`configure_kernel_from_x_ref` (set to False).') # optionally already preprocess reference data self.p_val = p_val diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index b737b71dc..e87877edd 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -45,9 +45,7 @@ def __init__( preprocess_x_ref: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # x_kernel: Callable = GaussianRBF, x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), - # c_kernel: Callable = GaussianRBF, c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, @@ -122,9 +120,6 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel self.x_kernel = x_kernel self.c_kernel = c_kernel diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 965985fb8..5f609a665 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -15,8 +15,6 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -68,8 +66,6 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, - # kernel=kernel, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -90,21 +86,12 @@ def __init__( x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - # def _initialize_kernel(self, x_ref: torch.Tensor): - # if self.sigma is None: - # self.kernel = GaussianRBF() - # _ = self.kernel(x_ref, x_ref, infer_sigma=True) - # else: - # sigma = torch.from_numpy(self.sigma) - # self.kernel = GaussianRBF(sigma) - def _configure_normalization(self, x_ref: torch.Tensor, eps: float = 1e-12): x_ref_means = x_ref.mean(0) x_ref_stds = x_ref.std(0) @@ -143,7 +130,6 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_x_ref is False: self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index b1ac3f837..26f763328 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -15,8 +15,6 @@ def __init__( ert: float, window_size: int, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -87,15 +85,6 @@ def __init__( self._configure_normalization() - # initialize kernel - # if sigma is None: - # x_ref = torch.from_numpy(self.x_ref).to(self.device) # type: ignore[assignment] - # self.kernel = GaussianRBF() - # _ = self.kernel(x_ref, x_ref, infer_sigma=True) - # else: - # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - # np.ndarray) else None - # self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] self.kernel = GaussianRBF() if self.n_kernel_centers is None: diff --git a/alibi_detect/cd/pytorch/mmd.py b/alibi_detect/cd/pytorch/mmd.py index 72dd62fce..269b21ea0 100644 --- a/alibi_detect/cd/pytorch/mmd.py +++ b/alibi_detect/cd/pytorch/mmd.py @@ -18,9 +18,7 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # kernel: Callable = GaussianRBF, kernel: BaseKernel = GaussianRBF(), - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -67,7 +65,6 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -78,14 +75,9 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - # np.ndarray) else None - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data - # if self.infer_sigma or isinstance(sigma, torch.Tensor): if self.infer_parameter: x = torch.from_numpy(self.x_ref).to(self.device) self.k_xx = self.kernel(x, x, infer_parameter=self.infer_parameter) diff --git a/alibi_detect/cd/pytorch/mmd_online.py b/alibi_detect/cd/pytorch/mmd_online.py index b0a9acf07..f55e5cbb4 100644 --- a/alibi_detect/cd/pytorch/mmd_online.py +++ b/alibi_detect/cd/pytorch/mmd_online.py @@ -16,8 +16,6 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, kernel: BaseKernel = GaussianRBF(), - # kernel: Callable = GaussianRBF, - # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -75,15 +73,10 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - # np.ndarray) else None - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data self.x_ref = torch.from_numpy(self.x_ref).to(self.device) - # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index c4a48d983..f3a90a911 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -45,9 +45,7 @@ def __init__( preprocess_x_ref: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # x_kernel: Callable = GaussianRBF, x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), - # c_kernel: Callable = GaussianRBF, c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, @@ -115,9 +113,6 @@ def __init__( ) self.meta.update({'backend': 'tensorflow'}) - # initialize kernel - # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel self.x_kernel = x_kernel self.c_kernel = c_kernel diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index 76329defe..085123331 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -14,8 +14,6 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -63,7 +61,6 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -77,21 +74,12 @@ def __init__( x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - # def _initialize_kernel(self, x_ref: tf.Tensor): - # if self.sigma is None: - # self.kernel = GaussianRBF() - # _ = self.kernel(x_ref, x_ref, infer_sigma=True) - # else: - # sigma = tf.convert_to_tensor(self.sigma) - # self.kernel = GaussianRBF(sigma) - def _configure_normalization(self, x_ref: tf.Tensor, eps: float = 1e-12): x_ref_means = tf.reduce_mean(x_ref, axis=0) x_ref_stds = tf.math.reduce_std(x_ref, axis=0) @@ -128,7 +116,6 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_x_ref is False: self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index cc3b8756c..90efc461a 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -14,8 +14,6 @@ def __init__( ert: float, window_size: int, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -79,13 +77,6 @@ def __init__( self._configure_normalization() - # initialize kernel - # if sigma is None: - # self.kernel = GaussianRBF() - # _ = self.kernel(self.x_ref, self.x_ref, infer_sigma=True) - # else: - # sigma = tf.convert_to_tensor(sigma) - # self.kernel = GaussianRBF(sigma) self.kernel = GaussianRBF() if self.n_kernel_centers is None: diff --git a/alibi_detect/cd/tensorflow/mmd.py b/alibi_detect/cd/tensorflow/mmd.py index 9c64ece45..1c06a670f 100644 --- a/alibi_detect/cd/tensorflow/mmd.py +++ b/alibi_detect/cd/tensorflow/mmd.py @@ -17,9 +17,7 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # kernel: Callable = GaussianRBF, kernel: BaseKernel = GaussianRBF(), - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -62,7 +60,6 @@ def __init__( preprocess_x_ref=preprocess_x_ref, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -70,13 +67,8 @@ def __init__( ) self.meta.update({'backend': 'tensorflow'}) - # initialize kernel - # if isinstance(sigma, np.ndarray): - # sigma = tf.convert_to_tensor(sigma) - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data - # if self.infer_sigma or isinstance(sigma, tf.Tensor): if self.infer_parameter: self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.infer_parameter) self.infer_sigma = False diff --git a/alibi_detect/cd/tensorflow/mmd_online.py b/alibi_detect/cd/tensorflow/mmd_online.py index 6978cb9b1..d05822df2 100644 --- a/alibi_detect/cd/tensorflow/mmd_online.py +++ b/alibi_detect/cd/tensorflow/mmd_online.py @@ -15,8 +15,6 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, kernel: BaseKernel = GaussianRBF(), - # kernel: Callable = GaussianRBF, - # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, verbose: bool = True, input_shape: Optional[tuple] = None, @@ -67,14 +65,9 @@ def __init__( ) self.meta.update({'backend': 'tensorflow'}) - # initialize kernel - # if isinstance(sigma, np.ndarray): - # sigma = tf.convert_to_tensor(sigma) - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data - # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index cf29d9663..d705c8173 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -1,3 +1,4 @@ +from abc import abstractmethod import numpy as np import torch from torch import nn @@ -6,7 +7,13 @@ from copy import deepcopy -def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): +def infer_kernel_parameter( + kernel: 'BaseKernel', + x: torch.Tensor, + y: torch.Tensor, + dist: torch.Tensor, + infer_parameter: bool = True +) -> None: """ Infer the kernel parameter from the data. @@ -59,10 +66,6 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. class KernelParameter: - """ - Parameter class for kernels. - """ - def __init__( self, value: torch.Tensor = None, @@ -70,6 +73,20 @@ def __init__( requires_grad: bool = False, requires_init: bool = False ) -> None: + """ + Parameter class for kernels. + + Parameters + ---------- + value + The pre-specified value of the parameter. + init_fn + The function used to initialize the parameter. + requires_grad + Whether the parameter requires gradient. + requires_init + Whether the parameter requires initialization. + """ super().__init__() self.value = nn.Parameter(value if value is not None else torch.ones(1), requires_grad=requires_grad) @@ -78,10 +95,17 @@ def __init__( class BaseKernel(nn.Module): - """ - The base class for all kernels. - """ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + """ + The base class for all kernels. + + Parameters + ---------- + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. + """ super().__init__() self.parameter_dict: dict = {} if active_dims is not None: @@ -91,6 +115,7 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.feature_axis = feature_axis self.init_required = False + @abstractmethod def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: Optional[bool] = False) -> torch.Tensor: raise NotImplementedError @@ -166,14 +191,11 @@ def __rsub__(self, other): raise ValueError('Kernels do not support substraction.') -class SumKernel(nn.Module): - """ - Construct a kernel by summing different kernels. - - Parameters: - ---------------- - """ +class SumKernel(torch.nn.Module): def __init__(self) -> None: + """ + Construct a kernel by summing different kernels. + """ super().__init__() self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] @@ -245,8 +267,11 @@ def __rsub__(self, other): raise ValueError('Kernels do not support substraction.') -class ProductKernel(nn.Module): +class ProductKernel(torch.nn.Module): def __init__(self) -> None: + """ + Construct a kernel by multiplying different kernels. + """ super().__init__() self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] @@ -349,6 +374,10 @@ def __init__( meaning that it should take in the tensors `x`, `y` and `dist` and return `sigma`. trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['log-sigma'] = KernelParameter( @@ -399,8 +428,18 @@ def __init__( ---------- alpha Exponent parameter of the kernel. + init_alpha_fn + Function used to compute the exponent parameter `alpha`. Used when `alpha` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( @@ -462,8 +501,18 @@ def __init__( ---------- tau Period of the periodic kernel. + init_tau_fn + Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( @@ -504,23 +553,23 @@ def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarra class ProjKernel(BaseKernel): - """ - A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as - k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and - y [Ny, features] and returns the kernel matrix [Nx, Ny]. - - Parameters: - ---------- - proj - The projection to be applied to the inputs before applying raw_kernel - raw_kernel - The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. - """ def __init__( self, proj: nn.Module, raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: + """ + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. + + Parameters: + ---------- + proj + The projection to be applied to the inputs before applying raw_kernel + raw_kernel + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + """ super().__init__() self.proj = proj self.raw_kernel = raw_kernel diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index b217e4035..fa8b4fe8d 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -12,6 +12,8 @@ "squared_pairwise_distance", "GaussianRBF", "BaseKernel", + "RationalQuadratic", + "Periodic", "DeepKernel", "permed_lsdds", "predict_batch", diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 9336d5b82..17e2d4446 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -1,3 +1,4 @@ +from abc import abstractmethod import tensorflow as tf import numpy as np from . import distance @@ -6,7 +7,13 @@ from copy import deepcopy -def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): +def infer_kernel_parameter( + kernel: 'BaseKernel', + x: tf.Tensor, + y: tf.Tensor, + dist: tf.Tensor, + infer_parameter: bool = True, +) -> None: """ Infer the kernel parameter from the data. @@ -57,10 +64,7 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: return tf.math.log(sigma) -class KernelParameter(object): - """ - Parameter class for kernels. - """ +class KernelParameter: def __init__( self, value: tf.Tensor = None, @@ -68,6 +72,20 @@ def __init__( requires_grad: bool = False, requires_init: bool = False ) -> None: + """ + Parameter class for kernels. + + Parameters + ---------- + value + The pre-specified value of the parameter. If `None`, the parameter is set to 1 by default. + init_fn + The function used to initialize the parameter. + requires_grad + Whether the parameter requires gradient. + requires_init + Whether the parameter requires initialization. + """ self.value = tf.Variable(value if value is not None else tf.ones(1, dtype=tf.keras.backend.floatx()), trainable=requires_grad) @@ -79,16 +97,24 @@ def __repr__(self) -> str: class BaseKernel(tf.keras.Model): - """ - The base class for all kernels. - """ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + """ + The base class for all kernels. + + Parameters + ---------- + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. + """ super().__init__() self.parameter_dict: dict = {} self.active_dims = active_dims self.feature_axis = feature_axis self.init_required = False + @abstractmethod def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: Optional[bool] = False) -> tf.Tensor: return NotImplementedError @@ -161,13 +187,10 @@ def __rsub__(self, other): class SumKernel(tf.keras.Model): - """ - Construct a kernel by summing different kernels. - - Parameters: - ---------------- - """ def __init__(self) -> None: + """ + Construct a kernel by summing different kernels. + """ super().__init__() self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] @@ -241,6 +264,9 @@ def __rsub__(self, other): class ProductKernel(tf.keras.Model): def __init__(self) -> None: + """ + Construct a kernel by multiplying different kernels. + """ super().__init__() self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] @@ -343,6 +369,10 @@ def __init__( meaning that it should take in the tensors `x`, `y` and `dist` and return `sigma`. trainable Whether or not to track gradients w.r.t. sigma to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.config = {'sigma': sigma, 'trainable': trainable} @@ -401,8 +431,18 @@ def __init__( ---------- alpha Exponent parameter of the kernel. + init_alpha_fn + Function used to compute the exponent parameter `alpha`. Used when `alpha` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( @@ -464,8 +504,18 @@ def __init__( ---------- tau Period of the periodic kernel. + init_tau_fn + Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( @@ -513,6 +563,18 @@ def __init__( proj: tf.keras.Model, raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: + """ + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. + + Parameters: + ---------- + proj + The projection to be applied to the inputs before applying raw_kernel + raw_kernel + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + """ super().__init__() self.proj = proj self.raw_kernel = raw_kernel From d6af592003ec4b8d47654c49d76ca1beea7af311 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 11 Nov 2022 09:35:36 +0000 Subject: [PATCH 15/37] Address some discussion and comments from the reviewer, mainly on : (1) modify the type of composite kernels as BaseKernel, and change the type signatures accordingly. (2) remove the feature dimension option in BaseKernel. (3) add specific tests on parameter inference. (4) remove numpy inputs from kernels with pytorch backend. (5) misc minor fixes following previous comments. --- alibi_detect/cd/_domain_clf.py | 28 ++- alibi_detect/cd/base.py | 3 - alibi_detect/cd/context_aware.py | 2 - alibi_detect/cd/lsdd.py | 2 - alibi_detect/cd/lsdd_online.py | 2 - alibi_detect/cd/mmd.py | 1 - alibi_detect/cd/mmd_online.py | 1 - alibi_detect/cd/pytorch/context_aware.py | 14 +- alibi_detect/cd/pytorch/lsdd.py | 5 +- alibi_detect/cd/tensorflow/context_aware.py | 14 +- alibi_detect/cd/tensorflow/lsdd.py | 5 +- .../cd/tensorflow/tests/test_lsdd_tf.py | 1 - alibi_detect/utils/pytorch/__init__.py | 5 +- alibi_detect/utils/pytorch/distance.py | 4 +- alibi_detect/utils/pytorch/kernels.py | 161 +++++++++--------- alibi_detect/utils/pytorch/prediction.py | 2 + .../utils/pytorch/tests/test_kernels_pt.py | 52 +++++- alibi_detect/utils/tensorflow/__init__.py | 5 +- alibi_detect/utils/tensorflow/kernels.py | 108 ++++++------ .../utils/tensorflow/tests/test_kernels_tf.py | 52 +++++- 20 files changed, 289 insertions(+), 178 deletions(-) diff --git a/alibi_detect/cd/_domain_clf.py b/alibi_detect/cd/_domain_clf.py index 84e540e7d..524da105f 100644 --- a/alibi_detect/cd/_domain_clf.py +++ b/alibi_detect/cd/_domain_clf.py @@ -34,7 +34,6 @@ def predict(self, x: np.ndarray) -> np.ndarray: class _SVCDomainClf(_DomainClf): def __init__(self, - kernel: Callable, cal_method: str = 'sigmoid', clf_kwargs: dict = None): """ @@ -52,52 +51,51 @@ def __init__(self, clf_kwargs A dictionary of keyword arguments to be passed to the :py:class:`~sklearn.svm.SVC` classifier. """ - self.kernel = kernel self.cal_method = cal_method clf_kwargs = clf_kwargs or {} - self.clf = SVC(kernel=self.kernel, **clf_kwargs) + self.clf = SVC(kernel='precomputed', **clf_kwargs) - def fit(self, x: np.ndarray, y: np.ndarray): + def fit(self, K_x: np.ndarray, y: np.ndarray): """ Method to fit the classifier. Parameters ---------- - x - Array containing conditioning variables for each instance. + K_x + Kernel matrix on the conditioning variables. y Boolean array marking the domain each instance belongs to (`0` for reference, `1` for test). """ clf = self.clf - clf.fit(x, y) + clf.fit(K_x, y) self.clf = clf - def calibrate(self, x: np.ndarray, y: np.ndarray): + def calibrate(self, K_x: np.ndarray, y: np.ndarray): """ Method to calibrate the classifier's predicted probabilities. Parameters ---------- - x - Array containing conditioning variables for each instance. + K_x + Kernel matrix on the conditioning variables. y Boolean array marking the domain each instance belongs to (`0` for reference, `1` for test). """ clf = CalibratedClassifierCV(self.clf, method=self.cal_method, cv='prefit') - clf.fit(x, y) + clf.fit(K_x, y) self.clf = clf - def predict(self, x: np.ndarray) -> np.ndarray: + def predict(self, K_x: np.ndarray) -> np.ndarray: """ The classifier's predict method. Parameters ---------- - x - Array containing conditioning variables for each instance. + K_x + Kernel matrix on the conditioning variables. Returns ------- Propensity scores (the probability of being test instances). """ - return self.clf.predict_proba(x)[:, 1] + return self.clf.predict_proba(K_x)[:, 1] diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index 17a39db71..12d7e379b 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -606,8 +606,6 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # kernel: BaseKernel = None, - # sigma: Optional[np.ndarray] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -660,7 +658,6 @@ def __init__( self.x_ref = preprocess_fn(x_ref) else: self.x_ref = x_ref - # self.sigma = sigma self.preprocess_x_ref = preprocess_x_ref self.update_x_ref = update_x_ref self.preprocess_fn = preprocess_fn diff --git a/alibi_detect/cd/context_aware.py b/alibi_detect/cd/context_aware.py index 06f282008..b0d575b08 100644 --- a/alibi_detect/cd/context_aware.py +++ b/alibi_detect/cd/context_aware.py @@ -23,9 +23,7 @@ def __init__( preprocess_x_ref: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # x_kernel: Callable = None, x_kernel: BaseKernel = None, - # c_kernel: Callable = None, c_kernel: BaseKernel = None, n_permutations: int = 1000, prop_c_held: float = 0.25, diff --git a/alibi_detect/cd/lsdd.py b/alibi_detect/cd/lsdd.py index d182a976e..f3de2d978 100644 --- a/alibi_detect/cd/lsdd.py +++ b/alibi_detect/cd/lsdd.py @@ -18,8 +18,6 @@ def __init__( preprocess_x_ref: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index eca0d3b39..9f020ae88 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -17,8 +17,6 @@ def __init__( window_size: int, backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 1e645d0d7..25fad0196 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -22,7 +22,6 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: Callable = None, - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, diff --git a/alibi_detect/cd/mmd_online.py b/alibi_detect/cd/mmd_online.py index 5604cf4bb..595f184ba 100644 --- a/alibi_detect/cd/mmd_online.py +++ b/alibi_detect/cd/mmd_online.py @@ -20,7 +20,6 @@ def __init__( backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, kernel: Union[BaseKernelTorch, BaseKernelTF] = None, - # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index e87877edd..32a672dd3 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -123,8 +123,6 @@ def __init__( self.x_kernel = x_kernel self.c_kernel = c_kernel - # Initialize classifier (hardcoded for now) - self.clf = _SVCDomainClf(self.c_kernel) def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: @@ -148,6 +146,9 @@ def score(self, # type: ignore[override] x_ref, x = self.preprocess(x) x_ref = torch.from_numpy(x_ref).to(self.device) # type: ignore[assignment] c_ref = torch.from_numpy(self.c_ref).to(self.device) # type: ignore[assignment] + + # Initialize classifier (hardcoded for now) + self.clf = _SVCDomainClf() # Hold out a portion of contexts for conditioning on n, n_held = len(c), int(len(c)*self.prop_c_held) @@ -167,12 +168,13 @@ def score(self, # type: ignore[override] L_held = self.c_kernel(c_held, c_all) # Fit and calibrate the domain classifier - c_all_np, bools_np = c_all.cpu().numpy(), bools.cpu().numpy() - self.clf.fit(c_all_np, bools_np) - self.clf.calibrate(c_all_np, bools_np) + bools_np = bools.cpu().numpy() + K_c_all_np = self.c_kernel(c_all, c_all).cpu().numpy() + self.clf.fit(K_c_all_np, bools_np) + self.clf.calibrate(K_c_all_np, bools_np) # Obtain n_permutations conditional reassignments - prop_scores = torch.as_tensor(self.clf.predict(c_all_np)) + prop_scores = torch.as_tensor(self.clf.predict(K_c_all_np)) self.redrawn_bools = [torch.bernoulli(prop_scores) for _ in range(self.n_permutations)] iters = tqdm(self.redrawn_bools, total=self.n_permutations) if self.verbose else self.redrawn_bools diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 5f609a665..428619683 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -81,11 +81,12 @@ def __init__( # in the method signature, so we can't cast it to torch.Tensor unless we change the signature # to also accept torch.Tensor. We also can't redefine it's type as that would involve enabling # --allow-redefinitions in mypy settings (which we might do eventually). - self.kernel = GaussianRBF() if self.preprocess_x_ref or self.preprocess_fn is None: x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) @@ -130,6 +131,8 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_x_ref is False: self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index f3a90a911..6e94c1f1c 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -116,8 +116,6 @@ def __init__( self.x_kernel = x_kernel self.c_kernel = c_kernel - # Initialize classifier (hardcoded for now) - self.clf = _SVCDomainClf(self.c_kernel) def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: @@ -139,6 +137,9 @@ def score(self, # type: ignore[override] (W_{ref,ref}, W_{test,test}, W_{ref,test}). """ x_ref, x = self.preprocess(x) + + # Initialize classifier (hardcoded for now) + self.clf = _SVCDomainClf() # Hold out a portion of contexts for conditioning on n, n_held = len(c), int(len(c)*self.prop_c_held) @@ -157,12 +158,13 @@ def score(self, # type: ignore[override] L_held = self.c_kernel(c_held, c_all) # Fit and calibrate the domain classifier - c_all_np, bools_np = c_all.numpy(), bools.numpy() - self.clf.fit(c_all_np, bools_np) - self.clf.calibrate(c_all_np, bools_np) + bools_np = bools.numpy() + K_c_all_np = self.c_kernel(c_all, c_all).numpy() + self.clf.fit(K_c_all_np, bools_np) + self.clf.calibrate(K_c_all_np, bools_np) # Obtain n_permutations conditional reassignments - prop_scores = self.clf.predict(c_all_np) + prop_scores = self.clf.predict(K_c_all_np) self.redrawn_bools = [tfp.distributions.Bernoulli(probs=prop_scores).sample() for _ in range(self.n_permutations)] iters = tqdm(self.redrawn_bools, total=self.n_permutations) if self.verbose else self.redrawn_bools diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index 085123331..3c306492d 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -69,11 +69,12 @@ def __init__( ) self.meta.update({'backend': 'tensorflow'}) - self.kernel = GaussianRBF() if self.preprocess_x_ref or self.preprocess_fn is None: x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) @@ -116,6 +117,8 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_x_ref is False: self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py b/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py index ba5cea57b..84eff2ea3 100644 --- a/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py +++ b/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py @@ -40,7 +40,6 @@ def preprocess_list(x: List[np.ndarray]) -> np.ndarray: n_permutations, update_x_ref, preprocess_x_ref)) n_tests = len(tests_lsdddrift) - @pytest.fixture def lsdd_params(request): return tests_lsdddrift[request.param] diff --git a/alibi_detect/utils/pytorch/__init__.py b/alibi_detect/utils/pytorch/__init__.py index ec230bc43..03e449ba3 100644 --- a/alibi_detect/utils/pytorch/__init__.py +++ b/alibi_detect/utils/pytorch/__init__.py @@ -1,6 +1,6 @@ from .distance import mmd2, mmd2_from_kernel_matrix, squared_pairwise_distance from .distance import permed_lsdds, batch_compute_kernel_matrix -from .kernels import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic +from .kernels import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic, log_sigma_median from .prediction import predict_batch, predict_batch_transformer from .misc import get_device, quantile, zero_diag @@ -19,5 +19,6 @@ "predict_batch_transformer", "get_device", "quantile", - "zero_diag" + "zero_diag", + "log_sigma_median" ] diff --git a/alibi_detect/utils/pytorch/distance.py b/alibi_detect/utils/pytorch/distance.py index b5b5e85de..86b1b0aa8 100644 --- a/alibi_detect/utils/pytorch/distance.py +++ b/alibi_detect/utils/pytorch/distance.py @@ -24,8 +24,8 @@ def squared_pairwise_distance(x: torch.Tensor, y: torch.Tensor, a_min: float = 1 ------- Pairwise squared Euclidean distance [Nx, Ny]. """ - x2 = x.pow(2).sum(dim=-1, keepdim=True) - y2 = y.pow(2).sum(dim=-1, keepdim=True) + x2 = torch.square(x).sum(dim=-1, keepdim=True) + y2 = torch.square(y).sum(dim=-1, keepdim=True) dist = torch.addmm(y2.transpose(-2, -1), x, y.transpose(-2, -1), alpha=-2).add_(x2) return dist.clamp_min_(a_min) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index d705c8173..3fee988cc 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -56,13 +56,33 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. Returns ------- - The logrithm of the computed bandwidth, `log-sigma`. + The computed bandwidth, `log-sigma`. """ n = min(x.shape[0], y.shape[0]) n = n if (x[:n] == y[:n]).all() and x.shape == y.shape else 0 n_median = n + (np.prod(dist.shape) - n) // 2 - 1 sigma = (.5 * dist.flatten().sort().values[n_median].unsqueeze(dim=-1)) ** .5 - return sigma.log() + return sigma + + +def log_sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + """ + Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The logrithm of the computed bandwidth, `log-sigma`. + """ + return torch.log(sigma_median(x, y, dist)) class KernelParameter: @@ -95,7 +115,7 @@ def __init__( class BaseKernel(nn.Module): - def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + def __init__(self, active_dims: list = None) -> None: """ The base class for all kernels. @@ -103,8 +123,6 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: ---------- active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__() self.parameter_dict: dict = {} @@ -112,20 +130,18 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.active_dims = torch.as_tensor(active_dims) else: self.active_dims = None - self.feature_axis = feature_axis self.init_required = False @abstractmethod - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: Optional[bool] = False) -> torch.Tensor: raise NotImplementedError - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - x, y = torch.as_tensor(x), torch.as_tensor(y) if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) + x = torch.index_select(x, -1, self.active_dims) + y = torch.index_select(y, -1, self.active_dims) if len(self.parameter_dict) > 0: return self.kernel_function(x, y, infer_parameter) else: @@ -133,14 +149,12 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch def __add__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] + other: Union['BaseKernel', torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) return other - elif (isinstance(other, BaseKernel) or - isinstance(other, ProductKernel) or - isinstance(other, torch.Tensor)): + elif isinstance(other, (BaseKernel, ProductKernel, torch.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) @@ -148,13 +162,13 @@ def __add__( else: raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: 'BaseKernel') -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union['BaseKernel', torch.Tensor] + ) -> 'BaseKernel': if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other @@ -171,11 +185,11 @@ def __mul__( def __rmul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: 'BaseKernel' + ) -> 'BaseKernel': return self.__mul__(other) - def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: torch.Tensor) -> 'BaseKernel': if isinstance(other, torch.Tensor): return self.__mul__(1. / other) else: @@ -185,25 +199,25 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') -class SumKernel(torch.nn.Module): +class SumKernel(BaseKernel): def __init__(self) -> None: """ Construct a kernel by summing different kernels. """ super().__init__() - self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] + self.kernel_list: List[Union[BaseKernel, torch.Tensor]] = [] - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] for k in self.kernel_list: - if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): + if isinstance(k, (BaseKernel, SumKernel, ProductKernel)): value_list.append(k(x, y, infer_parameter)) elif isinstance(k, torch.Tensor): value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) @@ -213,7 +227,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch def __add__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + other: Union[BaseKernel, torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): for k in other.kernel_list: @@ -222,13 +236,13 @@ def __add__( self.kernel_list.append(other) return self - def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: BaseKernel) -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union[BaseKernel, torch.Tensor] + ) -> BaseKernel: if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: @@ -247,11 +261,11 @@ def __mul__( def __rmul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: BaseKernel + ) -> BaseKernel: return self.__mul__(other) - def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: torch.Tensor) -> BaseKernel: if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: @@ -261,22 +275,22 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') -class ProductKernel(torch.nn.Module): +class ProductKernel(BaseKernel): def __init__(self) -> None: """ Construct a kernel by multiplying different kernels. """ super().__init__() - self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] + self.kernel_factors: List[Union[BaseKernel, torch.Tensor]] = [] - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] for k in self.kernel_factors: if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): @@ -289,7 +303,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch def __add__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + other: Union[BaseKernel, torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) @@ -302,14 +316,14 @@ def __add__( def __radd__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + other: BaseKernel ) -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union[BaseKernel, torch.Tensor] + ) -> BaseKernel: if isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: @@ -329,11 +343,11 @@ def __mul__( def __rmul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: BaseKernel + ) -> BaseKernel: return self.__mul__(other) - def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: torch.Tensor) -> BaseKernel: if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: @@ -343,20 +357,19 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[torch.Tensor] = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -379,7 +392,7 @@ def __init__( feature_axis Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else None, init_fn=init_fn_sigma, @@ -393,11 +406,10 @@ def __init__( def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - - x, y = torch.as_tensor(x), torch.as_tensor(y) - dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] + n_x, n_y = x.shape[0], y.shape[0] + dist = distance.squared_pairwise_distance(x.reshape(n_x, -1), y.reshape(n_y, -1)) # [Nx, Ny] if infer_parameter or self.init_required: infer_kernel_parameter(self, x, y, dist, infer_parameter) @@ -414,10 +426,9 @@ def __init__( alpha: torch.Tensor = None, init_fn_alpha: Callable = None, sigma: torch.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -438,10 +449,8 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['alpha'] = KernelParameter( value=alpha.reshape(-1) if alpha is not None else None, init_fn=init_fn_alpha, @@ -465,10 +474,8 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - - x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: @@ -487,10 +494,9 @@ def __init__( tau: torch.Tensor = None, init_fn_tau: Callable = None, sigma: torch.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -501,11 +507,11 @@ def __init__( ---------- tau Period of the periodic kernel. - init_tau_fn + init_fn_tau Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. - init_sigma_fn + init_fn_sigma Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. @@ -514,7 +520,7 @@ def __init__( feature_axis Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['log-tau'] = KernelParameter( value=tau.log().reshape(-1) if tau is not None else None, init_fn=init_fn_tau, @@ -538,10 +544,9 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - x, y = torch.as_tensor(x), torch.as_tensor(y) - dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) + dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: infer_kernel_parameter(self, x, y, dist, infer_parameter) @@ -631,8 +636,8 @@ def _init_eps(self, eps: Union[float, str]) -> None: def kernel_function( self, - x: Union[np.ndarray, torch.Tensor], - y: Union[np.ndarray, torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, infer_parameter: Optional[bool] = False ) -> torch.Tensor: return self.comp_kernel(x, y, infer_parameter) diff --git a/alibi_detect/utils/pytorch/prediction.py b/alibi_detect/utils/pytorch/prediction.py index 05aded4aa..d8c47dbe2 100644 --- a/alibi_detect/utils/pytorch/prediction.py +++ b/alibi_detect/utils/pytorch/prediction.py @@ -35,6 +35,8 @@ def predict_batch(x: Union[list, np.ndarray, torch.Tensor], model: Union[Callabl Numpy array, torch tensor or tuples of those with model outputs. """ device = get_device(device) + if isinstance(model, nn.Module): + model = model.to(device) if isinstance(x, np.ndarray): x = torch.from_numpy(x) n = len(x) diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index a4f405b54..21129e50e 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -4,7 +4,9 @@ import torch from torch import nn from typing import Union -from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic +from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic, \ + log_sigma_median +from alibi_detect.utils.pytorch.distance import squared_pairwise_distance sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -40,6 +42,54 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +def log_sigma_mean(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + sigma = (.5 * torch.mean(dist.flatten()) ** .5).unsqueeze(-1) + return torch.log(sigma) + + +kernel_ref = ['GaussianRBF', 'RationalQuadratic', 'Periodic'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +init_fn = [None, log_sigma_median, log_sigma_mean] +tests_init_fn = list(product(kernel_ref, n_features, n_instances, trainable, init_fn)) + + +@pytest.fixture +def init_fn_params(request): + return tests_init_fn[request.param] + + +@pytest.mark.parametrize('init_fn_params', list(range(len(tests_init_fn))), indirect=True) +def test_init_fn(init_fn_params): + kernel_ref, n_features, n_instances, trainable, init_fn = init_fn_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + if kernel_ref == 'GaussianRBF': + kernel = GaussianRBF(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'RationalQuadratic': + kernel = RationalQuadratic(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'Periodic': + kernel = Periodic(trainable=trainable, init_fn_sigma=init_fn) + else: + raise NotImplementedError + if trainable: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=True) + else: + k_xy = kernel(x, y, infer_parameter=True).numpy() + k_xx = kernel(x, x, infer_parameter=True).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + if init_fn is not None: + np.testing.assert_almost_equal(kernel.sigma.numpy(), + np.exp(init_fn(x, y, squared_pairwise_distance(x, y)).numpy()), + decimal=4) + + sigma = [None, np.array([1.]), np.array([2.])] alpha = [None, np.array([1.]), np.array([2.])] n_features = [5, 10] diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index fa8b4fe8d..2ac6b457b 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -1,6 +1,6 @@ from .distance import mmd2, mmd2_from_kernel_matrix, batch_compute_kernel_matrix from .distance import relative_euclidean_distance, squared_pairwise_distance, permed_lsdds -from .kernels import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic +from .kernels import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic, log_sigma_median from .prediction import predict_batch, predict_batch_transformer from .misc import zero_diag, quantile, subset_matrix @@ -20,5 +20,6 @@ "predict_batch_transformer", "quantile", "subset_matrix", - "zero_diag" + "zero_diag", + "log_sigma_median" ] diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 17e2d4446..bbfc8cb3d 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -61,7 +61,27 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: n = n if tf.reduce_all(x[:n] == y[:n]) and x.shape == y.shape else 0 n_median = n + (tf.math.reduce_prod(dist.shape) - n) // 2 - 1 sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) - return tf.math.log(sigma) + return sigma + + +def log_sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + """ + Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The logrithm of the computed bandwidth, `log-sigma`. + """ + return tf.math.log(sigma_median(x, y, dist)) class KernelParameter: @@ -97,7 +117,7 @@ def __repr__(self) -> str: class BaseKernel(tf.keras.Model): - def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + def __init__(self, active_dims: list = None) -> None: """ The base class for all kernels. @@ -105,13 +125,10 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: ---------- active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__() self.parameter_dict: dict = {} self.active_dims = active_dims - self.feature_axis = feature_axis self.init_required = False @abstractmethod @@ -128,14 +145,12 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. def __add__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] + other: Union['BaseKernel', tf.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) return other - elif (isinstance(other, BaseKernel) or - isinstance(other, ProductKernel) or - isinstance(other, tf.Tensor)): + elif isinstance(other, (BaseKernel, ProductKernel, tf.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) @@ -143,13 +158,13 @@ def __add__( else: raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: 'BaseKernel') -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union['BaseKernel', tf.Tensor] + ) -> 'BaseKernel': if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other @@ -166,8 +181,8 @@ def __mul__( def __rmul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: 'BaseKernel' + ) -> 'BaseKernel': return self.__mul__(other) def __truediv__(self, other: tf.Tensor) -> 'ProductKernel': @@ -180,19 +195,19 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') -class SumKernel(tf.keras.Model): +class SumKernel(BaseKernel): def __init__(self) -> None: """ Construct a kernel by summing different kernels. """ super().__init__() - self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] + self.kernel_list: List[Union[BaseKernel, tf.Tensor]] = [] def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: @@ -208,7 +223,7 @@ def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], def __add__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + other: Union[BaseKernel, tf.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): for k in other.kernel_list: @@ -217,13 +232,13 @@ def __add__( self.kernel_list.append(other) return self - def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: BaseKernel) -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union[BaseKernel, tf.Tensor] + ) -> BaseKernel: if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: @@ -242,11 +257,11 @@ def __mul__( def __rmul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: BaseKernel + ) -> BaseKernel: return self.__mul__(other) - def __truediv__(self, other: tf.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: tf.Tensor) -> BaseKernel: if isinstance(other, tf.Tensor): return self.__mul__(1 / other) else: @@ -256,10 +271,10 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') class ProductKernel(tf.keras.Model): @@ -338,20 +353,19 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[tf.Tensor] = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -371,14 +385,12 @@ def __init__( Whether or not to track gradients w.r.t. sigma to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.config = {'sigma': sigma, 'trainable': trainable} self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), init_fn=init_fn_sigma, requires_grad=trainable, requires_init=True if sigma is None else False @@ -417,10 +429,9 @@ def __init__( alpha: tf.Tensor = None, init_fn_alpha: Callable = None, sigma: tf.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -441,10 +452,8 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['alpha'] = KernelParameter( value=tf.reshape( tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, @@ -454,7 +463,7 @@ def __init__( ) self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), init_fn=init_fn_sigma, requires_grad=trainable, requires_init=True if sigma is None else False @@ -490,10 +499,9 @@ def __init__( tau: tf.Tensor = None, init_fn_tau: Callable = None, sigma: tf.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -514,20 +522,18 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['log-tau'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, + tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else tf.zeros(1), init_fn=init_fn_tau, requires_grad=trainable, requires_init=True if tau is None else False ) self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), init_fn=init_fn_sigma, requires_grad=trainable, requires_init=True if sigma is None else False diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index f73c7c302..c339112b8 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -3,7 +3,9 @@ import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input -from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic +from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic, \ + log_sigma_median +from alibi_detect.utils.tensorflow.distance import squared_pairwise_distance sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -38,6 +40,54 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +def log_sigma_mean(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + sigma = tf.expand_dims(.5 * tf.reduce_mean(tf.reshape(dist, (-1,))) ** .5, axis=0) + return tf.math.log(sigma) + + +kernel_ref = ['GaussianRBF', 'RationalQuadratic', 'Periodic'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +init_fn = [None, log_sigma_median, log_sigma_mean] +tests_init_fn = list(product(kernel_ref, n_features, n_instances, trainable, init_fn)) + + +@pytest.fixture +def init_fn_params(request): + return tests_init_fn[request.param] + + +@pytest.mark.parametrize('init_fn_params', list(range(len(tests_init_fn))), indirect=True) +def test_init_fn(init_fn_params): + kernel_ref, n_features, n_instances, trainable, init_fn = init_fn_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + if kernel_ref == 'GaussianRBF': + kernel = GaussianRBF(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'RationalQuadratic': + kernel = RationalQuadratic(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'Periodic': + kernel = Periodic(trainable=trainable, init_fn_sigma=init_fn) + else: + raise NotImplementedError + if trainable: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=True) + else: + k_xy = kernel(x, y, infer_parameter=True).numpy() + k_xx = kernel(x, x, infer_parameter=True).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + if init_fn is not None: + np.testing.assert_almost_equal(kernel.sigma.numpy(), + np.exp(init_fn(x, y, squared_pairwise_distance(x, y)).numpy()), + decimal=4) + + sigma = [None, np.array([1.]), np.array([2.])] alpha = [None, np.array([1.]), np.array([2.])] n_features = [5, 10] From 43b0b4c3cce697cc3559039c31e6e3845d072020 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 15 Dec 2022 13:41:01 +0000 Subject: [PATCH 16/37] pre-rebase minor fixes. --- alibi_detect/cd/_domain_clf.py | 1 - alibi_detect/cd/pytorch/context_aware.py | 3 +-- alibi_detect/cd/tensorflow/context_aware.py | 3 +-- alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py | 1 + 4 files changed, 3 insertions(+), 5 deletions(-) diff --git a/alibi_detect/cd/_domain_clf.py b/alibi_detect/cd/_domain_clf.py index 524da105f..942ef43fe 100644 --- a/alibi_detect/cd/_domain_clf.py +++ b/alibi_detect/cd/_domain_clf.py @@ -1,5 +1,4 @@ from abc import ABC, abstractmethod -from typing import Callable import numpy as np from sklearn.svm import SVC from sklearn.calibration import CalibratedClassifierCV diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index 32a672dd3..04a15441b 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -123,7 +123,6 @@ def __init__( self.x_kernel = x_kernel self.c_kernel = c_kernel - def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: """ @@ -146,7 +145,7 @@ def score(self, # type: ignore[override] x_ref, x = self.preprocess(x) x_ref = torch.from_numpy(x_ref).to(self.device) # type: ignore[assignment] c_ref = torch.from_numpy(self.c_ref).to(self.device) # type: ignore[assignment] - + # Initialize classifier (hardcoded for now) self.clf = _SVCDomainClf() diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index 6e94c1f1c..8aa6866ad 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -116,7 +116,6 @@ def __init__( self.x_kernel = x_kernel self.c_kernel = c_kernel - def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: """ @@ -137,7 +136,7 @@ def score(self, # type: ignore[override] (W_{ref,ref}, W_{test,test}, W_{ref,test}). """ x_ref, x = self.preprocess(x) - + # Initialize classifier (hardcoded for now) self.clf = _SVCDomainClf() diff --git a/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py b/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py index 84eff2ea3..ba5cea57b 100644 --- a/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py +++ b/alibi_detect/cd/tensorflow/tests/test_lsdd_tf.py @@ -40,6 +40,7 @@ def preprocess_list(x: List[np.ndarray]) -> np.ndarray: n_permutations, update_x_ref, preprocess_x_ref)) n_tests = len(tests_lsdddrift) + @pytest.fixture def lsdd_params(request): return tests_lsdddrift[request.param] From 335fe2c02982ca010b936636a20c56fbacfb4fee Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 15 Jul 2022 13:57:26 +0100 Subject: [PATCH 17/37] Initial kernel change for pytorch --- alibi_detect/utils/pytorch/kernels.py | 239 +++++++++++++++++++++++++- 1 file changed, 230 insertions(+), 9 deletions(-) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 78e730fb8..2c8512750 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -30,12 +30,66 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. return sigma -class GaussianRBF(nn.Module): +class BaseKernel(nn.Module): + """ + The base class for all kernels. + Args: + nn (_type_): _description_ + """ + def __init__(self) -> None: + super().__init__() + self.parameter_dict: dict = {} + self.active_dims: Optional[list] = None + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + raise NotImplementedError + + +class SumKernel(nn.Module): + """ + Construct a kernel by summing two kernels. + Args: + nn (_type_): _description_ + """ def __init__( self, - sigma: Optional[torch.Tensor] = None, - init_sigma_fn: Optional[Callable] = None, - trainable: bool = False + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return self.kernel_a(x, y) + self.kernel_b(x, y) + + +class ProductKernel(nn.Module): + """ + Construct a kernel by multiplying two kernels. + Args: + nn (_type_): _description_ + """ + def __init__( + self, + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return self.kernel_a(x, y) * self.kernel_b(x, y) + + +class GaussianRBF(BaseKernel): + def __init__( + self, + sigma: Optional[torch.Tensor] = None, + init_sigma_fn: Optional[Callable] = None, + trainable: bool = False, + active_dims: Optional[list] = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -58,28 +112,28 @@ def __init__( super().__init__() init_sigma_fn = sigma_median if init_sigma_fn is None else init_sigma_fn self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_sigma_fn} + self.parameter_dict['sigma'] = 'bandwidth' if sigma is None: self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) self.init_required = True else: - sigma = sigma.reshape(-1) # [Ns,] self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) self.init_required = False self.init_sigma_fn = init_sigma_fn - self.trainable = trainable + self.active_dims = active_dims @property def sigma(self) -> torch.Tensor: return self.log_sigma.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_sigma: bool = False) -> torch.Tensor: + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] - if infer_sigma or self.init_required: - if self.trainable and infer_sigma: + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") sigma = self.init_sigma_fn(x, y, dist) with torch.no_grad(): @@ -115,6 +169,173 @@ def from_config(cls, config): return cls(**config) +class RationalQuadratic(nn.Module): + def __init__( + self, + alpha: torch.Tensor = None, + init_fn_alpha: Callable = None, + sigma: torch.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + alpha + Exponent parameter of the kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['alpha'] = 'exponent' + self.parameter_dict['sigma'] = 'bandwidth' + if alpha is None: + self.alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.alpha = alpha + self.init_required = False + if sigma is None: + self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) + self.init_required = False + self.init_fn_alpha = init_fn_alpha + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + + @property + def sigma(self) -> torch.Tensor: + return self.log_sigma.exp() + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + return kernel_mat + + +class Periodic(nn.Module): + def __init__( + self, + tau: torch.Tensor = None, + init_fn_tau: Callable = None, + sigma: torch.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + + @property + def tau(self) -> torch.Tensor: + return self.log_tau.exp() + + @property + def sigma(self) -> torch.Tensor: + return self.log_sigma.exp() + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) + return kernel_mat + + +class LocalPeriodic(nn.Module): + def __init__( + self, + tau: torch.Tensor = None, + init_fn_tau: Callable = None, + sigma: torch.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Local periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.init_required = True + else: + self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + + @property + def tau(self) -> torch.Tensor: + return self.log_tau.exp() + + @property + def sigma(self) -> torch.Tensor: + return self.log_sigma.exp() + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ + torch.exp(-0.5 * torch.square(dist / self.tau)) + return kernel_mat + + class DeepKernel(nn.Module): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). From d059f6546cc79a1b5484e63cf588795822755101 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 21 Jul 2022 11:17:54 +0100 Subject: [PATCH 18/37] Change torch kernel-based methods to support new kernel behaviours. --- alibi_detect/cd/base.py | 20 ++++---- alibi_detect/cd/context_aware.py | 7 ++- alibi_detect/cd/lsdd.py | 3 +- alibi_detect/cd/lsdd_online.py | 4 +- alibi_detect/cd/pytorch/context_aware.py | 60 +++++++++++++----------- alibi_detect/cd/pytorch/lsdd.py | 27 ++++++----- alibi_detect/cd/pytorch/lsdd_online.py | 23 +++++---- alibi_detect/cd/pytorch/mmd.py | 27 ++++++----- alibi_detect/cd/pytorch/mmd_online.py | 17 ++++--- alibi_detect/utils/pytorch/kernels.py | 18 +++++-- 10 files changed, 119 insertions(+), 87 deletions(-) diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index ca050c462..b0604c25e 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -508,7 +508,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -553,12 +553,13 @@ def __init__( if p_val is None: logger.warning('No p-value set for the drift threshold. Need to set it to detect data drift.') - self.infer_sigma = configure_kernel_from_x_ref - if configure_kernel_from_x_ref and isinstance(sigma, np.ndarray): - self.infer_sigma = False - logger.warning('`sigma` is specified for the kernel and `configure_kernel_from_x_ref` ' - 'is set to True. `sigma` argument takes priority over ' - '`configure_kernel_from_x_ref` (set to False).') + self.infer_parameter = configure_kernel_from_x_ref + # self.infer_sigma = configure_kernel_from_x_ref + # if configure_kernel_from_x_ref and isinstance(sigma, np.ndarray): + # self.infer_sigma = False + # logger.warning('`sigma` is specified for the kernel and `configure_kernel_from_x_ref` ' + # 'is set to True. `sigma` argument takes priority over ' + # '`configure_kernel_from_x_ref` (set to False).') # x_ref preprocessing self.preprocess_at_init = preprocess_at_init @@ -668,7 +669,8 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # kernel: BaseKernel = None, + # sigma: Optional[np.ndarray] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -731,7 +733,7 @@ def __init__( # Other attributes self.p_val = p_val - self.sigma = sigma + # self.sigma = sigma self.update_x_ref = update_x_ref self.preprocess_fn = preprocess_fn self.n = len(x_ref) diff --git a/alibi_detect/cd/context_aware.py b/alibi_detect/cd/context_aware.py index bb02c2ad3..ef27cd5ef 100644 --- a/alibi_detect/cd/context_aware.py +++ b/alibi_detect/cd/context_aware.py @@ -4,6 +4,7 @@ from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow, BackendValidator, Framework from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.base import DriftConfigMixin +from alibi_detect.utils.pytorch.kernels import BaseKernel if has_pytorch: from alibi_detect.cd.pytorch.context_aware import ContextMMDDriftTorch @@ -26,8 +27,10 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: Callable = None, - c_kernel: Callable = None, + # x_kernel: Callable = None, + x_kernel: BaseKernel = None, + # c_kernel: Callable = None, + c_kernel: BaseKernel = None, n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, diff --git a/alibi_detect/cd/lsdd.py b/alibi_detect/cd/lsdd.py index e8a45d30f..dec318eb3 100644 --- a/alibi_detect/cd/lsdd.py +++ b/alibi_detect/cd/lsdd.py @@ -22,7 +22,8 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + # kernel: BaseKernel = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index d8d3d5bf6..725a9b04d 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -1,6 +1,7 @@ import numpy as np from typing import Any, Callable, Dict, Optional, Union from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow, BackendValidator, Framework +from alibi_detect.utils.pytorch.kernels import BaseKernel from alibi_detect.base import DriftConfigMixin if has_pytorch: from alibi_detect.cd.pytorch.lsdd_online import LSDDDriftOnlineTorch @@ -18,7 +19,8 @@ def __init__( backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index 7b63357ee..91c5f69a0 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -4,7 +4,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseContextMMDDrift from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework from alibi_detect.cd._domain_clf import _SVCDomainClf @@ -13,6 +13,29 @@ logger = logging.getLogger(__name__) +def _sigma_median_diag(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + """ + Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.pytorch.kernels.sigma_median`, + with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The computed bandwidth, `sigma`. + """ + n_median = np.prod(dist.shape) // 2 + sigma = (.5 * dist.flatten().sort().values[n_median].unsqueeze(dim=-1)) ** .5 + return sigma + + class ContextMMDDriftTorch(BaseContextMMDDrift): lams: Optional[Tuple[torch.Tensor, torch.Tensor]] = None @@ -26,8 +49,10 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: Callable = GaussianRBF, - c_kernel: Callable = GaussianRBF, + # x_kernel: Callable = GaussianRBF, + x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), + # c_kernel: Callable = GaussianRBF, + c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -108,8 +133,10 @@ def __init__( self.device = get_device(device) # initialize kernel - self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel + # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + self.x_kernel = x_kernel + self.c_kernel = c_kernel # Initialize classifier (hardcoded for now) self.clf = _SVCDomainClf(self.c_kernel) @@ -254,26 +281,3 @@ def _pick_lam(self, lams: torch.Tensor, K: torch.Tensor, L: torch.Tensor, n_fold kxx = torch.ones_like(lWk).to(lWk.device) * torch.max(K) losses += (lWKWl + kxx - 2*lWk).sum(-1) return lams[torch.argmin(losses)] - - -def _sigma_median_diag(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: - """ - Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.pytorch.kernels.sigma_median`, - with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. - - Parameters - ---------- - x - Tensor of instances with dimension [Nx, features]. - y - Tensor of instances with dimension [Ny, features]. - dist - Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. - - Returns - ------- - The computed bandwidth, `sigma`. - """ - n_median = np.prod(dist.shape) // 2 - sigma = (.5 * dist.flatten().sort().values[int(n_median)].unsqueeze(dim=-1)) ** .5 - return sigma diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index cae318f97..69c63468c 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -3,7 +3,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.pytorch.distance import permed_lsdds from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework @@ -19,7 +19,8 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -77,7 +78,8 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, + # kernel=kernel, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -93,24 +95,25 @@ def __init__( # in the method signature, so we can't cast it to torch.Tensor unless we change the signature # to also accept torch.Tensor. We also can't redefine it's type as that would involve enabling # --allow-redefinitions in mypy settings (which we might do eventually). + self.kernel = kernel if self.preprocess_at_init or self.preprocess_fn is None or self.x_ref_preprocessed: x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) # type: ignore[arg-type] + # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - def _initialize_kernel(self, x_ref: torch.Tensor): - if self.sigma is None: - self.kernel = GaussianRBF() - _ = self.kernel(x_ref, x_ref, infer_sigma=True) - else: - sigma = torch.from_numpy(self.sigma) - self.kernel = GaussianRBF(sigma) + # def _initialize_kernel(self, x_ref: torch.Tensor): + # if self.sigma is None: + # self.kernel = GaussianRBF() + # _ = self.kernel(x_ref, x_ref, infer_sigma=True) + # else: + # sigma = torch.from_numpy(self.sigma) + # self.kernel = GaussianRBF(sigma) def _configure_normalization(self, x_ref: torch.Tensor, eps: float = 1e-12): x_ref_means = x_ref.mean(0) @@ -152,7 +155,7 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_at_init is False and not self.x_ref_preprocessed: self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) # type: ignore[arg-type] + # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index a5c20ee40..1ba852868 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -4,7 +4,8 @@ from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch import GaussianRBF, permed_lsdds, quantile +from alibi_detect.utils.pytorch import permed_lsdds, quantile +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.frameworks import Framework from alibi_detect.base import DriftConfigMixin @@ -17,7 +18,8 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -94,14 +96,15 @@ def __init__( self._configure_normalization() # initialize kernel - if sigma is None: - x_ref = torch.from_numpy(self.x_ref).to(self.device) # type: ignore[assignment] - self.kernel = GaussianRBF() - _ = self.kernel(x_ref, x_ref, infer_sigma=True) - else: - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] + # if sigma is None: + # x_ref = torch.from_numpy(self.x_ref).to(self.device) # type: ignore[assignment] + # self.kernel = GaussianRBF() + # _ = self.kernel(x_ref, x_ref, infer_sigma=True) + # else: + # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] + # np.ndarray) else None + # self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] + self.kernel = kernel if self.n_kernel_centers is None: self.n_kernel_centers = 2 * window_size diff --git a/alibi_detect/cd/pytorch/mmd.py b/alibi_detect/cd/pytorch/mmd.py index 666942b6c..fe5c9fbe0 100644 --- a/alibi_detect/cd/pytorch/mmd.py +++ b/alibi_detect/cd/pytorch/mmd.py @@ -5,7 +5,7 @@ from alibi_detect.cd.base import BaseMMDDrift from alibi_detect.utils.pytorch import get_device from alibi_detect.utils.pytorch.distance import mmd2_from_kernel_matrix -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework @@ -22,8 +22,9 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + # kernel: Callable = GaussianRBF, + kernel: BaseKernel = GaussianRBF(), + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -76,7 +77,7 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -88,21 +89,23 @@ def __init__( self.device = get_device(device) # initialize kernel - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = kernel(sigma).to(self.device) if kernel == GaussianRBF else kernel + # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] + # np.ndarray) else None + # self.kernel = kernel(sigma).to(self.device) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data - if self.infer_sigma or isinstance(sigma, torch.Tensor): + # if self.infer_sigma or isinstance(sigma, torch.Tensor): + if self.infer_parameter: x = torch.from_numpy(self.x_ref).to(self.device) - self.k_xx = self.kernel(x, x, infer_sigma=self.infer_sigma) - self.infer_sigma = False + self.k_xx = self.kernel(x, x, infer_parameter=self.infer_parameter) + self.infer_parameter = False else: - self.k_xx, self.infer_sigma = None, True + self.k_xx, self.infer_parameter = None, True def kernel_matrix(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """ Compute and return full kernel matrix between arrays x and y. """ - k_xy = self.kernel(x, y, self.infer_sigma) + k_xy = self.kernel(x, y, self.infer_parameter) k_xx = self.k_xx if self.k_xx is not None and self.update_x_ref is None else self.kernel(x, x) k_yy = self.kernel(y, y) kernel_mat = torch.cat([torch.cat([k_xx, k_xy], 1), torch.cat([k_xy.T, k_yy], 1)], 0) diff --git a/alibi_detect/cd/pytorch/mmd_online.py b/alibi_detect/cd/pytorch/mmd_online.py index 808fe5c5d..9e0491994 100644 --- a/alibi_detect/cd/pytorch/mmd_online.py +++ b/alibi_detect/cd/pytorch/mmd_online.py @@ -4,7 +4,7 @@ from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import GaussianRBF +from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.pytorch import zero_diag, quantile from alibi_detect.utils.frameworks import Framework @@ -17,8 +17,9 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), + # kernel: Callable = GaussianRBF, + # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -82,13 +83,15 @@ def __init__( self.device = get_device(device) # initialize kernel - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] + # np.ndarray) else None + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data self.x_ref = torch.from_numpy(self.x_ref).to(self.device) - self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() self._initialise() diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 2c8512750..14486dc80 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -121,6 +121,7 @@ def __init__( self.init_required = False self.init_sigma_fn = init_sigma_fn self.active_dims = active_dims + self.trainable = trainable @property def sigma(self) -> torch.Tensor: @@ -169,7 +170,7 @@ def from_config(cls, config): return cls(**config) -class RationalQuadratic(nn.Module): +class RationalQuadratic(BaseKernel): def __init__( self, alpha: torch.Tensor = None, @@ -195,10 +196,10 @@ def __init__( self.parameter_dict['alpha'] = 'exponent' self.parameter_dict['sigma'] = 'bandwidth' if alpha is None: - self.alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) + self.raw_alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) self.init_required = True else: - self.alpha = alpha + self.raw_alpha = nn.Parameter(alpha, requires_grad=trainable) self.init_required = False if sigma is None: self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) @@ -209,6 +210,11 @@ def __init__( self.init_fn_alpha = init_fn_alpha self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable + + @property + def alpha(self) -> torch.Tensor: + return self.raw_alpha @property def sigma(self) -> torch.Tensor: @@ -221,7 +227,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat -class Periodic(nn.Module): +class Periodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, @@ -261,6 +267,7 @@ def __init__( self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable @property def tau(self) -> torch.Tensor: @@ -278,7 +285,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat -class LocalPeriodic(nn.Module): +class LocalPeriodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, @@ -318,6 +325,7 @@ def __init__( self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.trainable = trainable @property def tau(self) -> torch.Tensor: From a843973d5dc6a03b530f92258add6cd67ec2af06 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 25 Jul 2022 22:32:08 +0100 Subject: [PATCH 19/37] Initial TF implementation added. --- alibi_detect/cd/mmd.py | 4 +- alibi_detect/cd/tensorflow/context_aware.py | 60 ++-- alibi_detect/cd/tensorflow/lsdd.py | 26 +- alibi_detect/cd/tensorflow/lsdd_online.py | 19 +- alibi_detect/cd/tensorflow/mmd.py | 24 +- alibi_detect/cd/tensorflow/mmd_online.py | 17 +- alibi_detect/utils/tensorflow/kernels.py | 287 +++++++++++++++++++- 7 files changed, 359 insertions(+), 78 deletions(-) diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 3a0c289a5..567a03c80 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -29,7 +29,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: Callable = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, batch_size_permutations: int = 1000000, @@ -114,7 +114,7 @@ def __init__( from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore else: from alibi_detect.utils.keops.kernels import GaussianRBF # type: ignore - kwargs.update({'kernel': GaussianRBF}) + kwargs.update({'kernel': GaussianRBF()}) self._detector = detector(*args, **kwargs) # type: ignore self.meta = self._detector.meta diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index 6f9b773e4..f2f0ed10f 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -4,7 +4,7 @@ import tensorflow_probability as tfp from typing import Callable, Dict, Optional, Tuple, Union, List from alibi_detect.cd.base import BaseContextMMDDrift -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework from alibi_detect.cd._domain_clf import _SVCDomainClf @@ -13,6 +13,29 @@ logger = logging.getLogger(__name__) +def _sigma_median_diag(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + """ + Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`, + with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The computed bandwidth, `sigma`. + """ + n_median = tf.math.reduce_prod(dist.shape) // 2 + sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) + return sigma + + class ContextMMDDriftTF(BaseContextMMDDrift): lams: Optional[Tuple[tf.Tensor, tf.Tensor]] @@ -26,8 +49,10 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: Callable = GaussianRBF, - c_kernel: Callable = GaussianRBF, + # x_kernel: Callable = GaussianRBF, + x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), + # c_kernel: Callable = GaussianRBF, + c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -101,8 +126,10 @@ def __init__( self.meta.update({'backend': Framework.TENSORFLOW.value}) # initialize kernel - self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel + # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel + self.x_kernel = x_kernel + self.c_kernel = c_kernel # Initialize classifier (hardcoded for now) self.clf = _SVCDomainClf(self.c_kernel) @@ -271,26 +298,3 @@ def _split_chunks(n: int, p: int) -> List[int]: else: chunks = [n // p + 1] * (n % p) + [n // p] * (p - n % p) return chunks - - -def _sigma_median_diag(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: - """ - Private version of the bandwidth estimation function :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`, - with the +n (and -1) term excluded to account for the diagonal of the kernel matrix. - - Parameters - ---------- - x - Tensor of instances with dimension [Nx, features]. - y - Tensor of instances with dimension [Ny, features]. - dist - Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. - - Returns - ------- - The computed bandwidth, `sigma`. - """ - n_median = tf.math.reduce_prod(dist.shape) // 2 - sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) - return sigma diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index ef0335ae9..84d9893b4 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -2,7 +2,7 @@ import tensorflow as tf from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.tensorflow.distance import permed_lsdds from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework @@ -18,7 +18,8 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -72,7 +73,7 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -81,24 +82,25 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) + self.kernel = kernel if self.preprocess_at_init or self.preprocess_fn is None or self.x_ref_preprocessed: x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) + # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - def _initialize_kernel(self, x_ref: tf.Tensor): - if self.sigma is None: - self.kernel = GaussianRBF() - _ = self.kernel(x_ref, x_ref, infer_sigma=True) - else: - sigma = tf.convert_to_tensor(self.sigma) - self.kernel = GaussianRBF(sigma) + # def _initialize_kernel(self, x_ref: tf.Tensor): + # if self.sigma is None: + # self.kernel = GaussianRBF() + # _ = self.kernel(x_ref, x_ref, infer_sigma=True) + # else: + # sigma = tf.convert_to_tensor(self.sigma) + # self.kernel = GaussianRBF(sigma) def _configure_normalization(self, x_ref: tf.Tensor, eps: float = 1e-12): x_ref_means = tf.reduce_mean(x_ref, axis=0) @@ -137,7 +139,7 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and not self.preprocess_at_init and not self.x_ref_preprocessed: self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - self._initialize_kernel(x_ref) + # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index 540884c5f..8d460bbaf 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -3,7 +3,8 @@ import tensorflow as tf from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline -from alibi_detect.utils.tensorflow import GaussianRBF, quantile, permed_lsdds +from alibi_detect.utils.tensorflow import quantile, permed_lsdds +from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel from alibi_detect.utils.frameworks import Framework @@ -15,7 +16,8 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - sigma: Optional[np.ndarray] = None, + # sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -85,12 +87,13 @@ def __init__( self._configure_normalization() # initialize kernel - if sigma is None: - self.kernel = GaussianRBF() - _ = self.kernel(self.x_ref, self.x_ref, infer_sigma=True) - else: - sigma = tf.convert_to_tensor(sigma) - self.kernel = GaussianRBF(sigma) + # if sigma is None: + # self.kernel = GaussianRBF() + # _ = self.kernel(self.x_ref, self.x_ref, infer_sigma=True) + # else: + # sigma = tf.convert_to_tensor(sigma) + # self.kernel = GaussianRBF(sigma) + self.kernel = kernel if self.n_kernel_centers is None: self.n_kernel_centers = 2*window_size diff --git a/alibi_detect/cd/tensorflow/mmd.py b/alibi_detect/cd/tensorflow/mmd.py index 977e1d18c..2eb4b46e4 100644 --- a/alibi_detect/cd/tensorflow/mmd.py +++ b/alibi_detect/cd/tensorflow/mmd.py @@ -4,7 +4,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseMMDDrift from alibi_detect.utils.tensorflow.distance import mmd2_from_kernel_matrix -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework @@ -21,8 +21,9 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + # kernel: Callable = GaussianRBF, + kernel: BaseKernel = GaussianRBF(), + # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -71,7 +72,7 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, + # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -80,20 +81,21 @@ def __init__( self.meta.update({'backend': Framework.TENSORFLOW.value}) # initialize kernel - if isinstance(sigma, np.ndarray): - sigma = tf.convert_to_tensor(sigma) - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel - + # if isinstance(sigma, np.ndarray): + # sigma = tf.convert_to_tensor(sigma) + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data - if self.infer_sigma or isinstance(sigma, tf.Tensor): - self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=self.infer_sigma) + # if self.infer_sigma or isinstance(sigma, tf.Tensor): + if self.infer_parameter: + self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.infer_parameter) self.infer_sigma = False else: self.k_xx, self.infer_sigma = None, True def kernel_matrix(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor]) -> tf.Tensor: """ Compute and return full kernel matrix between arrays x and y. """ - k_xy = self.kernel(x, y, self.infer_sigma) + k_xy = self.kernel(x, y, self.infer_parameter) k_xx = self.k_xx if self.k_xx is not None and self.update_x_ref is None else self.kernel(x, x) k_yy = self.kernel(y, y) kernel_mat = tf.concat([tf.concat([k_xx, k_xy], 1), tf.concat([tf.transpose(k_xy, (1, 0)), k_yy], 1)], 0) diff --git a/alibi_detect/cd/tensorflow/mmd_online.py b/alibi_detect/cd/tensorflow/mmd_online.py index 3d4a6b57a..f253ff473 100644 --- a/alibi_detect/cd/tensorflow/mmd_online.py +++ b/alibi_detect/cd/tensorflow/mmd_online.py @@ -3,7 +3,7 @@ import tensorflow as tf from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline -from alibi_detect.utils.tensorflow.kernels import GaussianRBF +from alibi_detect.utils.tensorflow.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.tensorflow import zero_diag, quantile, subset_matrix from alibi_detect.utils.frameworks import Framework @@ -16,8 +16,9 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - kernel: Callable = GaussianRBF, - sigma: Optional[np.ndarray] = None, + kernel: BaseKernel = GaussianRBF(), + # kernel: Callable = GaussianRBF, + # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, verbose: bool = True, input_shape: Optional[tuple] = None, @@ -74,12 +75,14 @@ def __init__( self.meta.update({'backend': Framework.TENSORFLOW.value}) # initialize kernel - if isinstance(sigma, np.ndarray): - sigma = tf.convert_to_tensor(sigma) - self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + # if isinstance(sigma, np.ndarray): + # sigma = tf.convert_to_tensor(sigma) + # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel + self.kernel = kernel # compute kernel matrix for the reference data - self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) + self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() self._initialise() diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index b2ec3cb13..45bcf200d 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -30,12 +30,66 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: return sigma -class GaussianRBF(tf.keras.Model): +class BaseKernel(tf.keras.Model): + """_summary_ + The base class for all kernels. + Args: + nn (_type_): _description_ + """ + def __init__(self) -> None: + super().__init__() + self.parameter_dict: dict = {} + self.active_dims: Optional[list] = None + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return NotImplementedError + + +class SumKernel(tf.keras.Model): + """ + Construct a kernel by summing two kernels. + Args: + nn (_type_): _description_ + """ + def __init__( + self, + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) + + +class ProductKernel(tf.keras.Model): + """ + Construct a kernel by multiplying two kernels. + Args: + nn (_type_): _description_ + """ + def __init__( + self, + kernel_a: BaseKernel, + kernel_b: BaseKernel + ) -> None: + super().__init__() + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) + + +class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[tf.Tensor] = None, - init_sigma_fn: Optional[Callable] = None, - trainable: bool = False + init_fn_sigma: Optional[Callable] = None, + trainable: bool = False, + active_dims: Optional[list] = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -56,8 +110,9 @@ def __init__( Whether or not to track gradients w.r.t. sigma to allow it to be trained. """ super().__init__() - init_sigma_fn = sigma_median if init_sigma_fn is None else init_sigma_fn - self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_sigma_fn} + init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} + self.parameter_dict['sigma'] = 'bandwidth' if sigma is None: self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) self.init_required = True @@ -65,22 +120,23 @@ def __init__( sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) self.init_required = False - self.init_sigma_fn = init_sigma_fn + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims self.trainable = trainable @property def sigma(self) -> tf.Tensor: return tf.math.exp(self.log_sigma) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_sigma: bool = False) -> tf.Tensor: + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] - if infer_sigma or self.init_required: - if self.trainable and infer_sigma: + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_sigma_fn(x, y, dist) + sigma = self.init_fn_sigma(x, y, dist) self.log_sigma.assign(tf.math.log(sigma)) self.init_required = False @@ -113,6 +169,217 @@ def from_config(cls, config): return cls(**config) +class RationalQuadratic(BaseKernel): + def __init__( + self, + alpha: tf.Tensor = None, + init_fn_alpha: Callable = None, + sigma: tf.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + alpha + Exponent parameter of the kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['alpha'] = 'exponent' + self.parameter_dict['sigma'] = 'bandwidth' + if alpha is None: + self.raw_alpha = tf.Variable(np.ones(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + self.raw_alpha = tf.cast(tf.reshape(alpha, (-1,)), dtype=tf.keras.backend.floatx()) + self.init_required = False + if sigma is None: + self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] + self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) + self.init_required = False + self.init_fn_alpha = init_fn_alpha + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + self.trainable = trainable + + @property + def sigma(self) -> tf.Tensor: + return tf.math.exp(self.log_sigma) + + @property + def alpha(self) -> tf.Tensor: + return self.raw_alpha + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) + dist = distance.squared_pairwise_distance(x, y) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + self.log_sigma.assign(tf.math.log(sigma)) + alpha = self.init_fn_alpha(x, y, dist) + self.raw_alpha.assign(alpha) + + kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + return kernel_mat + + +class Periodic(BaseKernel): + def __init__( + self, + tau: tf.Tensor = None, + init_fn_tau: Callable = None, + sigma: tf.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.init_required = True + else: + tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) + self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] + self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + self.trainable = trainable + + @property + def tau(self) -> tf.Tensor: + return tf.math.exp(self.log_tau) + + @property + def sigma(self) -> tf.Tensor: + return tf.math.exp(self.log_sigma) + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) + dist = distance.squared_pairwise_distance(x, y) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + self.log_sigma.assign(tf.math.log(sigma)) + tau = self.init_fn_tau(x, y, dist) + self.log_tau.assign(tf.math.log(tau)) + + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) + + return kernel_mat + + +class LocalPeriodic(BaseKernel): + def __init__( + self, + tau: tf.Tensor = None, + init_fn_tau: Callable = None, + sigma: tf.Tensor = None, + init_fn_sigma: Callable = None, + trainable: bool = False, + active_dims: Optional[list] = None + ) -> None: + """ + Local periodic kernel: k(x,y) = . + A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] + and returns the kernel matrix [Nx, Ny]. + + Parameters + ---------- + tau + Period of the periodic kernel. + sigma + Bandwidth used for the kernel. + """ + super().__init__() + self.parameter_dict['tau'] = 'period' + self.parameter_dict['sigma'] = 'bandwidth' + if tau is None: + self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.init_required = True + else: + tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) + self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.init_required = False + if sigma is None: + self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) + self.init_required = True + else: + sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] + self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) + self.init_required = False + self.init_fn_tau = init_fn_tau + self.init_fn_sigma = init_fn_sigma + self.active_dims = active_dims + self.trainable = trainable + + @property + def tau(self) -> tf.Tensor: + return tf.math.exp(self.log_tau) + + @property + def sigma(self) -> tf.Tensor: + return tf.math.exp(self.log_sigma) + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) + dist = distance.squared_pairwise_distance(x, y) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + self.log_sigma.assign(tf.math.log(sigma)) + tau = self.init_fn_tau(x, y, dist) + self.log_tau.assign(tf.math.log(tau)) + + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ + tf.math.exp(-0.5 * tf.square(dist / self.tau)) + + return kernel_mat + + class DeepKernel(tf.keras.Model): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). From 50197ab3aacfce3c64747ea088bed41cd5430a0d Mon Sep 17 00:00:00 2001 From: Hao Song Date: Wed, 27 Jul 2022 09:51:45 +0100 Subject: [PATCH 20/37] Modify generic detector class and associated tests. --- alibi_detect/cd/lsdd_online.py | 3 +-- alibi_detect/cd/mmd.py | 4 +++- alibi_detect/cd/mmd_online.py | 8 +++++--- alibi_detect/utils/pytorch/kernels.py | 1 + alibi_detect/utils/pytorch/tests/test_kernels_pt.py | 10 +++++----- alibi_detect/utils/tensorflow/tests/test_kernels_tf.py | 10 +++++----- 6 files changed, 20 insertions(+), 16 deletions(-) diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index 725a9b04d..c1fc1ee6c 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -1,7 +1,6 @@ import numpy as np from typing import Any, Callable, Dict, Optional, Union from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow, BackendValidator, Framework -from alibi_detect.utils.pytorch.kernels import BaseKernel from alibi_detect.base import DriftConfigMixin if has_pytorch: from alibi_detect.cd.pytorch.lsdd_online import LSDDDriftOnlineTorch @@ -20,7 +19,7 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = None, + # kernel: BaseKernel = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 567a03c80..b3380f19d 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -7,9 +7,11 @@ if has_pytorch: from alibi_detect.cd.pytorch.mmd import MMDDriftTorch + from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernelTorch if has_tensorflow: from alibi_detect.cd.tensorflow.mmd import MMDDriftTF + from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernelTF if has_keops and has_pytorch: from alibi_detect.cd.keops.mmd import MMDDriftKeops @@ -28,7 +30,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = None, + kernel: Union[BaseKernelTorch, BaseKernelTF] = None, # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, diff --git a/alibi_detect/cd/mmd_online.py b/alibi_detect/cd/mmd_online.py index a26624955..90ae24c95 100644 --- a/alibi_detect/cd/mmd_online.py +++ b/alibi_detect/cd/mmd_online.py @@ -5,9 +5,11 @@ if has_pytorch: from alibi_detect.cd.pytorch.mmd_online import MMDDriftOnlineTorch + from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernelTorch if has_tensorflow: from alibi_detect.cd.tensorflow.mmd_online import MMDDriftOnlineTF + from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernelTF class MMDDriftOnline(DriftConfigMixin): @@ -19,8 +21,8 @@ def __init__( backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - kernel: Optional[Callable] = None, - sigma: Optional[np.ndarray] = None, + kernel: Optional[Union[BaseKernelTorch, BaseKernelTF]] = None, + # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -91,7 +93,7 @@ def __init__( from alibi_detect.utils.tensorflow.kernels import GaussianRBF else: from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore - kwargs.update({'kernel': GaussianRBF}) + kwargs.update({'kernel': GaussianRBF()}) if backend == Framework.TENSORFLOW: kwargs.pop('device', None) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 14486dc80..d89c901b9 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -117,6 +117,7 @@ def __init__( self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) self.init_required = True else: + sigma = sigma.reshape(-1) self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) self.init_required = False self.init_sigma_fn = init_sigma_fn diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index ba351678d..45e84df90 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -27,13 +27,13 @@ def test_gaussian_kernel(gaussian_kernel_params): y = torch.from_numpy(np.random.random(yshape)).float() kernel = GaussianRBF(sigma=sigma, trainable=trainable) - infer_sigma = True if sigma is None else False - if trainable and infer_sigma: + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: with pytest.raises(Exception): - kernel(x, y, infer_sigma=infer_sigma) + kernel(x, y, infer_parameter=infer_parameter) else: - k_xy = kernel(x, y, infer_sigma=infer_sigma).detach().numpy() - k_xx = kernel(x, x, infer_sigma=infer_sigma).detach().numpy() + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) assert (k_xx > 0.).all() and (k_xy > 0.).all() diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index 20f26962a..ee90d6e72 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -26,13 +26,13 @@ def test_gaussian_kernel(gaussian_kernel_params): y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) kernel = GaussianRBF(sigma=sigma, trainable=trainable) - infer_sigma = True if sigma is None else False - if trainable and infer_sigma: + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: with pytest.raises(Exception): - kernel(x, y, infer_sigma=infer_sigma) + kernel(x, y, infer_parameter=infer_parameter) else: - k_xy = kernel(x, y, infer_sigma=infer_sigma).numpy() - k_xx = kernel(x, x, infer_sigma=infer_sigma).numpy() + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) assert (k_xx > 0.).all() and (k_xy > 0.).all() From db824e841442a48d70b8552b33ced30421bd8d37 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Sun, 31 Jul 2022 15:49:09 +0100 Subject: [PATCH 21/37] Fixed prediction behaviour for torch gpu with new base kernel. --- alibi_detect/cd/mmd.py | 2 +- alibi_detect/utils/pytorch/prediction.py | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index b3380f19d..35185cfd5 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -30,7 +30,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Union[BaseKernelTorch, BaseKernelTF] = None, + kernel: Callable = None, # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, diff --git a/alibi_detect/utils/pytorch/prediction.py b/alibi_detect/utils/pytorch/prediction.py index 05aded4aa..49aab1110 100644 --- a/alibi_detect/utils/pytorch/prediction.py +++ b/alibi_detect/utils/pytorch/prediction.py @@ -48,6 +48,8 @@ def predict_batch(x: Union[list, np.ndarray, torch.Tensor], model: Union[Callabl x_batch = x[istart:istop] if isinstance(preprocess_fn, Callable): # type: ignore x_batch = preprocess_fn(x_batch) + if hasattr(model, 'to'): + model.to(device) preds_tmp = model(x_batch.to(device)) # type: ignore if isinstance(preds_tmp, (list, tuple)): if len(preds) == 0: # init tuple with lists to store predictions From d8c80835b07bd74ae9aa6a17f110d679a6b9494a Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 5 Aug 2022 09:32:28 +0100 Subject: [PATCH 22/37] Fixed feature dimension selection function. --- alibi_detect/cd/mmd.py | 2 - alibi_detect/utils/pytorch/kernels.py | 125 ++++++++++++++++++----- alibi_detect/utils/tensorflow/kernels.py | 49 ++++++--- 3 files changed, 135 insertions(+), 41 deletions(-) diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 35185cfd5..567a03c80 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -7,11 +7,9 @@ if has_pytorch: from alibi_detect.cd.pytorch.mmd import MMDDriftTorch - from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernelTorch if has_tensorflow: from alibi_detect.cd.tensorflow.mmd import MMDDriftTF - from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernelTF if has_keops and has_pytorch: from alibi_detect.cd.keops.mmd import MMDDriftKeops diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index d89c901b9..acbeb19df 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -6,6 +6,10 @@ from alibi_detect.utils.frameworks import Framework +def pseudo_init_fn(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + return torch.ones(1, dtype=x.dtype, device=x.device) + + def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: """ Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. @@ -40,8 +44,9 @@ def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} self.active_dims: Optional[list] = None + self.feature_axis: int = -1 - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: raise NotImplementedError @@ -60,8 +65,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - return self.kernel_a(x, y) + self.kernel_b(x, y) + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) class ProductKernel(nn.Module): @@ -79,17 +84,18 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - return self.kernel_a(x, y) * self.kernel_b(x, y) + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[torch.Tensor] = None, - init_sigma_fn: Optional[Callable] = None, + init_fn_sigma: Optional[Callable] = None, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -110,8 +116,8 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. """ super().__init__() - init_sigma_fn = sigma_median if init_sigma_fn is None else init_sigma_fn - self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_sigma_fn} + init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} self.parameter_dict['sigma'] = 'bandwidth' if sigma is None: self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) @@ -120,8 +126,12 @@ def __init__( sigma = sigma.reshape(-1) self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) self.init_required = False - self.init_sigma_fn = init_sigma_fn - self.active_dims = active_dims + self.init_fn_sigma = init_fn_sigma + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -132,6 +142,9 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] if infer_parameter or self.init_required: @@ -175,11 +188,12 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: torch.Tensor = None, - init_fn_alpha: Callable = None, + init_fn_alpha: Callable = pseudo_init_fn, sigma: torch.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -210,7 +224,11 @@ def __init__( self.init_required = False self.init_fn_alpha = init_fn_alpha self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -221,9 +239,24 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + alpha = self.init_fn_alpha(x, y, dist) + with torch.no_grad(): + self.log_sigma.copy_(sigma.log().clone()) + self.raw_alpha.copy_(alpha.clone()) + self.init_required = False + kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) return kernel_mat @@ -232,11 +265,12 @@ class Periodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: torch.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = . @@ -267,7 +301,11 @@ def __init__( self.init_required = False self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -278,9 +316,24 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + tau = self.init_fn_tau(x, y, dist) + with torch.no_grad(): + self.log_sigma.copy_(sigma.log().clone()) + self.log_tau.copy_(tau.log().clone()) + self.init_required = False + kernel_mat = torch.exp(-2 * torch.square( torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) return kernel_mat @@ -290,11 +343,12 @@ class LocalPeriodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: torch.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Local periodic kernel: k(x,y) = . @@ -325,7 +379,11 @@ def __init__( self.init_required = False self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + if active_dims is not None: + self.active_dims = torch.tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis self.trainable = trainable @property @@ -336,9 +394,24 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.log_sigma.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor]) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + + if infer_parameter or self.init_required: + if self.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + sigma = self.init_fn_sigma(x, y, dist) + tau = self.init_fn_tau(x, y, dist) + with torch.no_grad(): + self.log_sigma.copy_(sigma.log().clone()) + self.log_tau.copy_(tau.log().clone()) + self.init_required = False + kernel_mat = torch.exp(-2 * torch.square( torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ torch.exp(-0.5 * torch.square(dist / self.tau)) diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 45bcf200d..6686aa848 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -6,6 +6,10 @@ from alibi_detect.utils.frameworks import Framework +def pseudo_init_fn(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + return tf.ones(1, dtype=x.dtype) + + def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: """ Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. @@ -40,6 +44,7 @@ def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} self.active_dims: Optional[list] = None + self.feature_axis: int = -1 def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return NotImplementedError @@ -89,7 +94,8 @@ def __init__( sigma: Optional[tf.Tensor] = None, init_fn_sigma: Optional[Callable] = None, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -122,6 +128,7 @@ def __init__( self.init_required = False self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.feature_axis = feature_axis self.trainable = trainable @property @@ -130,6 +137,9 @@ def sigma(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] @@ -173,11 +183,12 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: tf.Tensor = None, - init_fn_alpha: Callable = None, + init_fn_alpha: Callable = pseudo_init_fn, sigma: tf.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -210,6 +221,7 @@ def __init__( self.init_fn_alpha = init_fn_alpha self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.feature_axis = feature_axis self.trainable = trainable @property @@ -222,6 +234,9 @@ def alpha(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -241,11 +256,12 @@ class Periodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: tf.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None + active_dims: Optional[list] = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = . @@ -263,11 +279,11 @@ def __init__( self.parameter_dict['tau'] = 'period' self.parameter_dict['sigma'] = 'bandwidth' if tau is None: - self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.log_tau = tf.Variable(np.empty(1), trainable=trainable) self.init_required = True else: tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) self.init_required = False if sigma is None: self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) @@ -279,6 +295,7 @@ def __init__( self.init_fn_tau = init_fn_tau self.init_fn_sigma = init_fn_sigma self.active_dims = active_dims + self.feature_axis = feature_axis self.trainable = trainable @property @@ -291,6 +308,9 @@ def sigma(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -312,9 +332,9 @@ class LocalPeriodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = None, + init_fn_tau: Callable = pseudo_init_fn, sigma: tf.Tensor = None, - init_fn_sigma: Callable = None, + init_fn_sigma: Callable = sigma_median, trainable: bool = False, active_dims: Optional[list] = None ) -> None: @@ -334,11 +354,11 @@ def __init__( self.parameter_dict['tau'] = 'period' self.parameter_dict['sigma'] = 'bandwidth' if tau is None: - self.log_tau = tf.Variable(np.empty(1), requires_grad=trainable) + self.log_tau = tf.Variable(np.empty(1), trainable=trainable) self.init_required = True else: tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.log(tau), requires_grad=trainable) + self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) self.init_required = False if sigma is None: self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) @@ -362,6 +382,9 @@ def sigma(self) -> tf.Tensor: def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) From 3de8f98739ac2dc863f06189e3e775b135ddc9b3 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 8 Aug 2022 10:54:24 +0100 Subject: [PATCH 23/37] Added support to passing multiple kernel parameters. Doc string refinements. --- alibi_detect/utils/pytorch/kernels.py | 70 +++++++++++++++++----- alibi_detect/utils/tensorflow/kernels.py | 74 ++++++++++++++++++------ 2 files changed, 113 insertions(+), 31 deletions(-) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index acbeb19df..63db2c963 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -7,6 +7,9 @@ def pseudo_init_fn(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + """ + A pseudo-initialization function for the kernel parameter. + """ return torch.ones(1, dtype=x.dtype, device=x.device) @@ -37,8 +40,6 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. class BaseKernel(nn.Module): """ The base class for all kernels. - Args: - nn (_type_): _description_ """ def __init__(self) -> None: super().__init__() @@ -52,9 +53,14 @@ def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = Fals class SumKernel(nn.Module): """ - Construct a kernel by summing two kernels. - Args: - nn (_type_): _description_ + Construct a kernel by averaging two kernels. + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -66,14 +72,19 @@ def __init__( self.kernel_b = kernel_b def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) + return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 class ProductKernel(nn.Module): """ Construct a kernel by multiplying two kernels. - Args: - nn (_type_): _description_ + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -257,7 +268,17 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch self.raw_alpha.copy_(alpha.clone()) self.init_required = False - kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + if len(self.sigma) > 1: + if len(self.sigma) == len(self.alpha): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append((1 + torch.square(dist) + / (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) + kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) return kernel_mat @@ -334,8 +355,18 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch self.log_tau.copy_(tau.log().clone()) self.init_required = False - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2))) + kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) return kernel_mat @@ -412,9 +443,20 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch self.log_tau.copy_(tau.log().clone()) self.init_required = False - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ - torch.exp(-0.5 * torch.square(dist / self.tau)) + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + torch.exp(-0.5 * torch.square(dist / self.tau[i]))) + kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ + torch.exp(-0.5 * torch.square(dist / self.tau)) return kernel_mat diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 6686aa848..187efd691 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -7,6 +7,9 @@ def pseudo_init_fn(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + """ + A pseudo-initialization function for the kernel parameter. + """ return tf.ones(1, dtype=x.dtype) @@ -35,10 +38,8 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: class BaseKernel(tf.keras.Model): - """_summary_ + """ The base class for all kernels. - Args: - nn (_type_): _description_ """ def __init__(self) -> None: super().__init__() @@ -52,9 +53,14 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. class SumKernel(tf.keras.Model): """ - Construct a kernel by summing two kernels. - Args: - nn (_type_): _description_ + Construct a kernel by averaging two kernels. + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -66,14 +72,19 @@ def __init__( self.kernel_b = kernel_b def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter) + return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 class ProductKernel(tf.keras.Model): """ Construct a kernel by multiplying two kernels. - Args: - nn (_type_): _description_ + + Parameters: + ---------- + kernel_a + the first kernel to be summed. + kernel_b + the second kernel to be summed. """ def __init__( self, @@ -248,7 +259,17 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. alpha = self.init_fn_alpha(x, y, dist) self.raw_alpha.assign(alpha) - kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) + if len(self.sigma) > 1: + if len(self.sigma) == len(self.alpha): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append((1 + tf.square(dist) / + (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) + kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) return kernel_mat @@ -322,9 +343,18 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. tau = self.init_fn_tau(x, y, dist) self.log_tau.assign(tf.math.log(tau)) - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) - + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2))) + kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) return kernel_mat @@ -396,10 +426,20 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. tau = self.init_fn_tau(x, y, dist) self.log_tau.assign(tf.math.log(tau)) - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ - tf.math.exp(-0.5 * tf.square(dist / self.tau)) - + if len(self.sigma) > 1: + if len(self.sigma) == len(self.tau): + kernel_mat = [] + for i in range(len(self.sigma)): + kernel_mat.append(tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + tf.math.exp(-0.5 * tf.square(dist / self.tau[i]))) + kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) + else: + raise ValueError("Length of sigma and alpha must be equal") + else: + kernel_mat = tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ + tf.math.exp(-0.5 * tf.square(dist / self.tau)) return kernel_mat From 0f63f61cd8dc400b111812d521a15cb3444468d3 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 18 Aug 2022 11:35:55 +0100 Subject: [PATCH 24/37] (1) refine various points according to the review. (2) re-design the parameter implementation for the general kernel class. (3) added an initial example notebook. --- alibi_detect/cd/pytorch/lsdd.py | 6 +- alibi_detect/cd/pytorch/lsdd_online.py | 6 +- alibi_detect/cd/tensorflow/lsdd.py | 6 +- alibi_detect/cd/tensorflow/lsdd_online.py | 6 +- alibi_detect/utils/pytorch/kernels.py | 358 +++++++-------- alibi_detect/utils/pytorch/prediction.py | 2 - alibi_detect/utils/tensorflow/kernels.py | 335 +++++++------- doc/source/examples/cd_combined_kernel.ipynb | 459 +++++++++++++++++++ doc/source/examples/cd_mmd_cifar10.ipynb | 12 +- examples/cd_combined_kernel.ipynb | 1 + 10 files changed, 791 insertions(+), 400 deletions(-) create mode 100644 doc/source/examples/cd_combined_kernel.ipynb create mode 100644 examples/cd_combined_kernel.ipynb diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 69c63468c..3250be11e 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -3,7 +3,7 @@ from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift from alibi_detect.utils.pytorch import get_device -from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF +from alibi_detect.utils.pytorch.kernels import GaussianRBF from alibi_detect.utils.pytorch.distance import permed_lsdds from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework @@ -20,7 +20,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -95,7 +95,7 @@ def __init__( # in the method signature, so we can't cast it to torch.Tensor unless we change the signature # to also accept torch.Tensor. We also can't redefine it's type as that would involve enabling # --allow-redefinitions in mypy settings (which we might do eventually). - self.kernel = kernel + self.kernel = GaussianRBF() if self.preprocess_at_init or self.preprocess_fn is None or self.x_ref_preprocessed: x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index 1ba852868..72e64c7d8 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -5,7 +5,7 @@ from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.pytorch import get_device from alibi_detect.utils.pytorch import permed_lsdds, quantile -from alibi_detect.utils.pytorch.kernels import BaseKernel, GaussianRBF +from alibi_detect.utils.pytorch.kernels import GaussianRBF from alibi_detect.utils.frameworks import Framework from alibi_detect.base import DriftConfigMixin @@ -19,7 +19,7 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -104,7 +104,7 @@ def __init__( # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] # np.ndarray) else None # self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] - self.kernel = kernel + self.kernel = GaussianRBF() if self.n_kernel_centers is None: self.n_kernel_centers = 2 * window_size diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index 84d9893b4..0a8916ee8 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -2,7 +2,7 @@ import tensorflow as tf from typing import Callable, Dict, Optional, Tuple, Union from alibi_detect.cd.base import BaseLSDDDrift -from alibi_detect.utils.tensorflow.kernels import BaseKernel, GaussianRBF +from alibi_detect.utils.tensorflow.kernels import GaussianRBF from alibi_detect.utils.tensorflow.distance import permed_lsdds from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.utils.frameworks import Framework @@ -19,7 +19,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -82,7 +82,7 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - self.kernel = kernel + self.kernel = GaussianRBF() if self.preprocess_at_init or self.preprocess_fn is None or self.x_ref_preprocessed: x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index 8d460bbaf..a181c6216 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -4,7 +4,7 @@ from typing import Any, Callable, Optional, Union from alibi_detect.cd.base_online import BaseMultiDriftOnline from alibi_detect.utils.tensorflow import quantile, permed_lsdds -from alibi_detect.utils.tensorflow.kernels import GaussianRBF, BaseKernel +from alibi_detect.utils.tensorflow.kernels import GaussianRBF from alibi_detect.utils.frameworks import Framework @@ -17,7 +17,7 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, # sigma: Optional[np.ndarray] = None, - kernel: BaseKernel = GaussianRBF(), + # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -93,7 +93,7 @@ def __init__( # else: # sigma = tf.convert_to_tensor(sigma) # self.kernel = GaussianRBF(sigma) - self.kernel = kernel + self.kernel = GaussianRBF() if self.n_kernel_centers is None: self.n_kernel_centers = 2*window_size diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 63db2c963..049d6a0ea 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -6,11 +6,32 @@ from alibi_detect.utils.frameworks import Framework -def pseudo_init_fn(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: +def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): """ - A pseudo-initialization function for the kernel parameter. + Infer the kernel parameter from the data. + + Parameters + ---------- + kernel + The kernel function. + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + infer_parameter + Whether to infer the kernel parameter. """ - return torch.ones(1, dtype=x.dtype, device=x.device) + if kernel.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + for parameter in kernel.parameter_dict.values(): + if parameter.requires_init: + if parameter.init_fn is not None: + with torch.no_grad(): + parameter.value.data = parameter.init_fn(x, y, dist).reshape(-1) + parameter.requires_init = False + kernel.init_required = False def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: @@ -28,13 +49,32 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. Returns ------- - The computed bandwidth, `sigma`. + The logrithm of the computed bandwidth, `log-sigma`. """ n = min(x.shape[0], y.shape[0]) n = n if (x[:n] == y[:n]).all() and x.shape == y.shape else 0 n_median = n + (np.prod(dist.shape) - n) // 2 - 1 sigma = (.5 * dist.flatten().sort().values[int(n_median)].unsqueeze(dim=-1)) ** .5 - return sigma + return sigma.log() + + +class KernelParameter(object): + """ + Parameter class for kernels. + """ + + def __init__( + self, + value: torch.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False + ) -> None: + super().__init__() + self.value = nn.Parameter(value if value is not None else torch.ones(1), + requires_grad=requires_grad) + self.init_fn = init_fn + self.requires_init = requires_init class BaseKernel(nn.Module): @@ -44,23 +84,41 @@ class BaseKernel(nn.Module): def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} - self.active_dims: Optional[list] = None - self.feature_axis: int = -1 - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: raise NotImplementedError -class SumKernel(nn.Module): +class DimensionSelectKernel(nn.Module): + """ + Select a subset of the feature diomensions before apply a given kernel. + """ + def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: + super().__init__() + self.kernel = kernel + self.active_dims = torch.as_tensor(active_dims) + self.feature_axis = feature_axis + + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) + if self.active_dims is not None: + x = torch.index_select(x, self.feature_axis, self.active_dims) + y = torch.index_select(y, self.feature_axis, self.active_dims) + return self.kernel(x, y, infer_parameter) + + +class AveragedKernel(nn.Module): """ Construct a kernel by averaging two kernels. Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be averaged. kernel_b - the second kernel to be summed. + the second kernel to be averaged. """ def __init__( self, @@ -71,7 +129,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 @@ -82,9 +141,9 @@ class ProductKernel(nn.Module): Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be multiplied. kernel_b - the second kernel to be summed. + the second kernel to be multiplied. """ def __init__( self, @@ -95,7 +154,8 @@ def __init__( self.kernel_a = kernel_a self.kernel_b = kernel_b - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) @@ -104,9 +164,7 @@ def __init__( self, sigma: Optional[torch.Tensor] = None, init_fn_sigma: Optional[Callable] = None, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -129,42 +187,27 @@ def __init__( super().__init__() init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} - self.parameter_dict['sigma'] = 'bandwidth' - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - sigma = sigma.reshape(-1) - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False, + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_sigma_fn(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.init_required = False + infer_kernel_parameter(self, x, y, dist, infer_parameter) gamma = 1. / (2. * self.sigma ** 2) # [Ns,] # TODO: do matrix multiplication after all? @@ -199,12 +242,10 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: torch.Tensor = None, - init_fn_alpha: Callable = pseudo_init_fn, + init_fn_alpha: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -219,82 +260,56 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['alpha'] = 'exponent' - self.parameter_dict['sigma'] = 'bandwidth' - if alpha is None: - self.raw_alpha = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.raw_alpha = nn.Parameter(alpha, requires_grad=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_alpha = init_fn_alpha - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['alpha'] = KernelParameter( + value=alpha.reshape(-1) if alpha is not None else None, + init_fn=init_fn_alpha, + requires_grad=trainable, + requires_init=True if alpha is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def alpha(self) -> torch.Tensor: - return self.raw_alpha + return self.parameter_dict['alpha'].value @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - alpha = self.init_fn_alpha(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.raw_alpha.copy_(alpha.clone()) - self.init_required = False - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.alpha): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append((1 + torch.square(dist) - / (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) - kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = (1 + torch.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) - return kernel_mat + if infer_parameter or self.init_required: + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = torch.stack([(1 + torch.square(dist) / + (2 * self.alpha[i] * (self.sigma[i] ** 2))) + ** (-self.alpha[i]) for i in range(len(self.sigma))], dim=0) + + return kernel_mat.mean(dim=0) class Periodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 ) -> None: """ - Periodic kernel: k(x,y) = . + Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -306,83 +321,54 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['log-tau'] = KernelParameter( + value=tau.log().reshape(-1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> torch.Tensor: - return self.log_tau.exp() + return self.parameter_dict['log-tau'].value.exp() @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - tau = self.init_fn_tau(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.log_tau.copy_(tau.log().clone()) - self.init_required = False - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2))) - kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = torch.stack([torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) + for i in range(len(self.sigma))], dim=0) + return kernel_mat.mean(dim=0) class LocalPeriodic(BaseKernel): def __init__( self, tau: torch.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ - Local periodic kernel: k(x,y) = . + Local periodic kernel: k(x,y) = k_rbf(x, y) * k_period(x, y). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -394,70 +380,42 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_tau = nn.Parameter(tau.log(), requires_grad=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - if active_dims is not None: - self.active_dims = torch.tensor(active_dims) - else: - self.active_dims = None - self.feature_axis = feature_axis + self.parameter_dict['log-tau'] = KernelParameter( + value=tau.log().reshape(-1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> torch.Tensor: - return self.log_tau.exp() + return self.parameter_dict['log-tau'].value.exp() @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) - if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - tau = self.init_fn_tau(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.log_tau.copy_(tau.log().clone()) - self.init_required = False - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - torch.exp(-0.5 * torch.square(dist / self.tau[i]))) - kernel_mat = torch.stack(kernel_mat, dim=0).mean(dim=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau)) / (self.sigma ** 2)) * \ - torch.exp(-0.5 * torch.square(dist / self.tau)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = torch.stack([torch.exp(-2 * torch.square( + torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + torch.exp(-0.5 * torch.square(dist / self.tau[i])) + for i in range(len(self.sigma))], dim=0) + return kernel_mat.mean(dim=0) class DeepKernel(nn.Module): diff --git a/alibi_detect/utils/pytorch/prediction.py b/alibi_detect/utils/pytorch/prediction.py index 49aab1110..05aded4aa 100644 --- a/alibi_detect/utils/pytorch/prediction.py +++ b/alibi_detect/utils/pytorch/prediction.py @@ -48,8 +48,6 @@ def predict_batch(x: Union[list, np.ndarray, torch.Tensor], model: Union[Callabl x_batch = x[istart:istop] if isinstance(preprocess_fn, Callable): # type: ignore x_batch = preprocess_fn(x_batch) - if hasattr(model, 'to'): - model.to(device) preds_tmp = model(x_batch.to(device)) # type: ignore if isinstance(preds_tmp, (list, tuple)): if len(preds) == 0: # init tuple with lists to store predictions diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 187efd691..f1a7a8a65 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -6,11 +6,31 @@ from alibi_detect.utils.frameworks import Framework -def pseudo_init_fn(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: +def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): """ - A pseudo-initialization function for the kernel parameter. + Infer the kernel parameter from the data. + + Parameters + ---------- + kernel + The kernel function. + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + infer_parameter + Whether to infer the kernel parameter. """ - return tf.ones(1, dtype=x.dtype) + if kernel.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + for parameter in kernel.parameter_dict.values(): + if parameter.requires_init: + if parameter.init_fn is not None: + parameter.value.assign(tf.reshape(parameter.init_fn(x, y, dist), -1)) + parameter.requires_init = False + kernel.init_required = False def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: @@ -28,13 +48,32 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: Returns ------- - The computed bandwidth, `sigma`. + The logrithm of the computed bandwidth, `log-sigma`. """ n = min(x.shape[0], y.shape[0]) n = n if tf.reduce_all(x[:n] == y[:n]) and x.shape == y.shape else 0 n_median = n + (tf.math.reduce_prod(dist.shape) - n) // 2 - 1 sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) - return sigma + return tf.math.log(sigma) + + +class KernelParameter(object): + """ + Parameter class for kernels. + """ + def __init__(self, + value: tf.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False): + self.value = tf.Variable(value if value is not None + else tf.ones(1, dtype=tf.keras.backend.floatx()), + trainable=requires_grad) + self.init_fn = init_fn + self.requires_init = requires_init + + def __repr__(self) -> str: + return self.value.__repr__() class BaseKernel(tf.keras.Model): @@ -44,23 +83,38 @@ class BaseKernel(tf.keras.Model): def __init__(self) -> None: super().__init__() self.parameter_dict: dict = {} - self.active_dims: Optional[list] = None - self.feature_axis: int = -1 def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return NotImplementedError -class SumKernel(tf.keras.Model): +class DimensionSelectKernel(tf.keras.Model): + """ + Select a subset of the feature diomensions before apply a given kernel. + """ + def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: + super().__init__() + self.kernel = kernel + self.active_dims = active_dims + self.feature_axis = feature_axis + + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + y = tf.cast(y, x.dtype) + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) + return self.kernel(x, y, infer_parameter) + + +class AveragedKernel(tf.keras.Model): """ Construct a kernel by averaging two kernels. Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be averaged. kernel_b - the second kernel to be summed. + the second kernel to be averaged. """ def __init__( self, @@ -82,9 +136,9 @@ class ProductKernel(tf.keras.Model): Parameters: ---------- kernel_a - the first kernel to be summed. + the first kernel to be multiplied. kernel_b - the second kernel to be summed. + the second kernel to be multiplied. """ def __init__( self, @@ -104,9 +158,7 @@ def __init__( self, sigma: Optional[tf.Tensor] = None, init_fn_sigma: Optional[Callable] = None, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -129,37 +181,27 @@ def __init__( super().__init__() init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} - self.parameter_dict['sigma'] = 'bandwidth' - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims - self.feature_axis = feature_axis + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - self.init_required = False + infer_kernel_parameter(self, x, y, dist, infer_parameter) gamma = tf.constant(1. / (2. * self.sigma ** 2), dtype=x.dtype) # [Ns,] # TODO: do matrix multiplication after all? @@ -194,12 +236,10 @@ class RationalQuadratic(BaseKernel): def __init__( self, alpha: tf.Tensor = None, - init_fn_alpha: Callable = pseudo_init_fn, + init_fn_alpha: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -214,78 +254,56 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['alpha'] = 'exponent' - self.parameter_dict['sigma'] = 'bandwidth' - if alpha is None: - self.raw_alpha = tf.Variable(np.ones(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - self.raw_alpha = tf.cast(tf.reshape(alpha, (-1,)), dtype=tf.keras.backend.floatx()) - self.init_required = False - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_alpha = init_fn_alpha - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims - self.feature_axis = feature_axis + self.parameter_dict['alpha'] = KernelParameter( + value=tf.reshape( + tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, + init_fn=init_fn_alpha, + requires_grad=trainable, + requires_init=True if alpha is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) @property def alpha(self) -> tf.Tensor: - return self.raw_alpha + return self.parameter_dict['alpha'].value def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - alpha = self.init_fn_alpha(x, y, dist) - self.raw_alpha.assign(alpha) - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.alpha): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append((1 + tf.square(dist) / - (2 * self.alpha[i] * (self.sigma[i] ** 2))) ** (-self.alpha[i])) - kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = (1 + tf.square(dist) / (2 * self.alpha * (self.sigma ** 2))) ** (-self.alpha) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = tf.stack([(1 + tf.square(dist) / + (2 * self.alpha[i] * (self.sigma[i] ** 2))) + ** (-self.alpha[i]) for i in range(len(self.sigma))], axis=0) + return tf.reduce_mean(kernel_mat, axis=0) class Periodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False, - active_dims: Optional[list] = None, - feature_axis: int = -1 + trainable: bool = False ) -> None: """ - Periodic kernel: k(x,y) = . + Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -297,79 +315,56 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = tf.Variable(np.empty(1), trainable=trainable) - self.init_required = True - else: - tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims - self.feature_axis = feature_axis + self.parameter_dict['log-tau'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> tf.Tensor: - return tf.math.exp(self.log_tau) + return tf.math.exp(self.parameter_dict['log-tau'].value) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - tau = self.init_fn_tau(x, y, dist) - self.log_tau.assign(tf.math.log(tau)) - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2))) - kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = tf.stack([tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) + for i in range(len(self.sigma))], axis=0) + return tf.reduce_mean(kernel_mat, axis=0) class LocalPeriodic(BaseKernel): def __init__( self, tau: tf.Tensor = None, - init_fn_tau: Callable = pseudo_init_fn, + init_fn_tau: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, - active_dims: Optional[list] = None ) -> None: """ - Local periodic kernel: k(x,y) = . + Local periodic kernel: k(x,y) = k(x,y) = k_rbf(x, y) * k_period(x, y). A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] and returns the kernel matrix [Nx, Ny]. @@ -381,66 +376,44 @@ def __init__( Bandwidth used for the kernel. """ super().__init__() - self.parameter_dict['tau'] = 'period' - self.parameter_dict['sigma'] = 'bandwidth' - if tau is None: - self.log_tau = tf.Variable(np.empty(1), trainable=trainable) - self.init_required = True - else: - tau = tf.cast(tf.reshape(tau, (-1,)), dtype=tf.keras.backend.floatx()) - self.log_tau = tf.Variable(tf.math.log(tau), trainable=trainable) - self.init_required = False - if sigma is None: - self.log_sigma = tf.Variable(np.empty(1), dtype=tf.keras.backend.floatx(), trainable=trainable) - self.init_required = True - else: - sigma = tf.cast(tf.reshape(sigma, (-1,)), dtype=tf.keras.backend.floatx()) # [Ns,] - self.log_sigma = tf.Variable(tf.math.log(sigma), trainable=trainable) - self.init_required = False - self.init_fn_tau = init_fn_tau - self.init_fn_sigma = init_fn_sigma - self.active_dims = active_dims + self.parameter_dict['log-tau'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, + init_fn=init_fn_tau, + requires_grad=trainable, + requires_init=True if tau is None else False + ) + self.parameter_dict['log-sigma'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + init_fn=init_fn_sigma, + requires_grad=trainable, + requires_init=True if sigma is None else False + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def tau(self) -> tf.Tensor: - return tf.math.exp(self.log_tau) + return tf.math.exp(self.parameter_dict['log-tau'].value) @property def sigma(self) -> tf.Tensor: - return tf.math.exp(self.log_sigma) + return tf.math.exp(self.parameter_dict['log-sigma'].value) def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) if infer_parameter or self.init_required: - if self.trainable and infer_parameter: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_fn_sigma(x, y, dist) - self.log_sigma.assign(tf.math.log(sigma)) - tau = self.init_fn_tau(x, y, dist) - self.log_tau.assign(tf.math.log(tau)) - - if len(self.sigma) > 1: - if len(self.sigma) == len(self.tau): - kernel_mat = [] - for i in range(len(self.sigma)): - kernel_mat.append(tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - tf.math.exp(-0.5 * tf.square(dist / self.tau[i]))) - kernel_mat = tf.reduce_mean(tf.stack(kernel_mat, axis=0), axis=0) - else: - raise ValueError("Length of sigma and alpha must be equal") - else: - kernel_mat = tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau)) / (self.sigma ** 2)) * \ - tf.math.exp(-0.5 * tf.square(dist / self.tau)) - return kernel_mat + infer_kernel_parameter(self, x, y, dist, infer_parameter) + + kernel_mat = tf.stack([tf.math.exp(-2 * tf.square( + tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * + tf.math.exp(-0.5 * tf.square(dist / self.tau[i])) + for i in range(len(self.sigma))], axis=0) + return tf.reduce_mean(kernel_mat, axis=0) class DeepKernel(tf.keras.Model): diff --git a/doc/source/examples/cd_combined_kernel.ipynb b/doc/source/examples/cd_combined_kernel.ipynb new file mode 100644 index 000000000..5c985d772 --- /dev/null +++ b/doc/source/examples/cd_combined_kernel.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create sum and product kernels with exsisting kernels\n", + "\n", + "\n", + "### Combine different kernels for better test power on certain data types" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:30.140646Z", + "iopub.status.busy": "2022-08-17T22:48:30.139694Z", + "iopub.status.idle": "2022-08-17T22:48:42.261216Z", + "shell.execute_reply": "2022-08-17T22:48:42.258215Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-18 11:16:03.693515: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:03.693561: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", + "2022-08-18 11:16:09.361482: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n", + "Your kernel may have been built without NUMA support.\n", + "2022-08-18 11:16:09.361658: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361739: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361808: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361874: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.361939: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362005: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362069: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362133: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n", + "2022-08-18 11:16:09.362145: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", + "Skipping registering GPU devices...\n", + "2022-08-18 11:16:09.362441: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import scipy.stats as stats\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "backend = 'pytorch'\n", + "\n", + "from alibi_detect.cd import MMDDrift\n", + "if backend == 'pytorch':\n", + " from alibi_detect.utils.pytorch.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + "elif backend == 'tensorflow':\n", + " from alibi_detect.utils.tensorflow.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + "else:\n", + " raise ValueError('Backend {} not supported'.format(backend))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.268753Z", + "iopub.status.busy": "2022-08-17T22:48:42.267268Z", + "iopub.status.idle": "2022-08-17T22:48:42.287665Z", + "shell.execute_reply": "2022-08-17T22:48:42.283443Z" + } + }, + "outputs": [], + "source": [ + "def get_sin(N):\n", + " c_0 = np.random.uniform(0, 168, N)\n", + " x_0 = np.sin(c_0 / (12 / np.pi)) + np.random.normal(0, 0.1, N)\n", + "\n", + " c_1 = stats.beta.rvs(a=1.2, b=1.2, size=N) * 24 + np.random.choice([0, 24, 48, 72, 96, 120, 144], size=N)\n", + " x_1 = np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) < 12) + \\\n", + " np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) >= 12) * 1.25 + \\\n", + " + np.random.normal(0, 0.1, N)\n", + " \n", + " x_ref = np.hstack([c_0.reshape(-1, 1), x_0.reshape(-1, 1)])\n", + " x_test = np.hstack([c_1.reshape(-1, 1), x_1.reshape(-1, 1)]) \n", + " \n", + " return x_ref, x_test" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.296254Z", + "iopub.status.busy": "2022-08-17T22:48:42.295141Z", + "iopub.status.idle": "2022-08-17T22:48:42.307361Z", + "shell.execute_reply": "2022-08-17T22:48:42.304563Z" + } + }, + "outputs": [], + "source": [ + "x_ref, x_test = get_sin(N=1000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Here we create two simple datasets with waves and therefore have two features, the test data shows clear drift around the wave through." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.315487Z", + "iopub.status.busy": "2022-08-17T22:48:42.314280Z", + "iopub.status.idle": "2022-08-17T22:48:42.627643Z", + "shell.execute_reply": "2022-08-17T22:48:42.626213Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.5, 1.5)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 3), dpi=128)\n", + "plt.plot(x_ref[:, 0], x_ref[:, 1], 'bo', alpha=0.5, markersize=2.5, label='Reference')\n", + "plt.plot(x_test[:, 0], x_test[:, 1], 'ro', alpha=0.5, markersize=2.5, label='Test')\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### If we use standard RBF kernel on both features with the MMD drift detector, we can see that the drift is not detected." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "Kernel_RBF = GaussianRBF()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "cd_RBF = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=Kernel_RBF)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 0,\n", + " 'distance': -0.00032591944848670007,\n", + " 'p_val': 0.5600000023841858,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00219562, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds_RBF = cd_RBF.predict(x_test)\n", + "preds_RBF" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### To facilitate our knowledge that the data contain waves, we use a combined kernel that is averaged from two kernels. The first kernel is a periodic kernel with a specified period of 24 and only working on the first feature. The second kernel is a RBF kernel with a infered bandwidth and only working on the second feature." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.633012Z", + "iopub.status.busy": "2022-08-17T22:48:42.632420Z", + "iopub.status.idle": "2022-08-17T22:48:42.663421Z", + "shell.execute_reply": "2022-08-17T22:48:42.661867Z" + } + }, + "outputs": [], + "source": [ + "if backend == 'pytorch':\n", + " Kernel_0 = DimensionSelectKernel(Periodic(tau=torch.tensor([24.0])), active_dims=[0])\n", + " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])\n", + "elif backend == 'tensorflow':\n", + " Kernel_0 = DimensionSelectKernel(Periodic(tau=tf.convert_to_tensor([24.0])), active_dims=[0])\n", + " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.682278Z", + "iopub.status.busy": "2022-08-17T22:48:42.681366Z", + "iopub.status.idle": "2022-08-17T22:48:42.695138Z", + "shell.execute_reply": "2022-08-17T22:48:42.692762Z" + } + }, + "outputs": [], + "source": [ + "Kernel_avg = AveragedKernel(Kernel_0, Kernel_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:42.702931Z", + "iopub.status.busy": "2022-08-17T22:48:42.700551Z", + "iopub.status.idle": "2022-08-17T22:48:43.049891Z", + "shell.execute_reply": "2022-08-17T22:48:43.048438Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "cd_avg = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=Kernel_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We can see the drift is detected with the combined kernel." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 1,\n", + " 'distance': 0.006368878019042512,\n", + " 'p_val': 0.0,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00098101, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds_avg = cd_avg.predict(x_test)\n", + "preds_avg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The kernel, its compments and asscociated parameters can be inspected as follows:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:43.055921Z", + "iopub.status.busy": "2022-08-17T22:48:43.055518Z", + "iopub.status.idle": "2022-08-17T22:48:43.064586Z", + "shell.execute_reply": "2022-08-17T22:48:43.063483Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AveragedKernel(\n", + " (kernel_a): DimensionSelectKernel(\n", + " (kernel): Periodic()\n", + " )\n", + " (kernel_b): DimensionSelectKernel(\n", + " (kernel): GaussianRBF()\n", + " )\n", + ")\n", + "DimensionSelectKernel(\n", + " (kernel): Periodic()\n", + ")\n", + "Periodic()\n" + ] + } + ], + "source": [ + "print(cd_avg._detector.kernel)\n", + "print(cd_avg._detector.kernel.kernel_a)\n", + "print(cd_avg._detector.kernel.kernel_a.kernel)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:44.915230Z", + "iopub.status.busy": "2022-08-17T22:48:44.914553Z", + "iopub.status.idle": "2022-08-17T22:48:44.924660Z", + "shell.execute_reply": "2022-08-17T22:48:44.923360Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([24.])\n", + "tensor([4.9818], dtype=torch.float64)\n" + ] + } + ], + "source": [ + "print(Kernel_avg.kernel_a.kernel.tau)\n", + "print(Kernel_avg.kernel_a.kernel.sigma)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:44.928919Z", + "iopub.status.busy": "2022-08-17T22:48:44.928266Z", + "iopub.status.idle": "2022-08-17T22:48:44.938336Z", + "shell.execute_reply": "2022-08-17T22:48:44.936929Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.5243], dtype=torch.float64)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Kernel_avg.kernel_b.kernel.sigma" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('detect_cpu_py38')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/source/examples/cd_mmd_cifar10.ipynb b/doc/source/examples/cd_mmd_cifar10.ipynb index 99347ff36..b4216887e 100644 --- a/doc/source/examples/cd_mmd_cifar10.ipynb +++ b/doc/source/examples/cd_mmd_cifar10.ipynb @@ -770,11 +770,8 @@ } ], "metadata": { - "interpreter": { - "hash": "ffba93b5284319fb7a107c8eacae647f441487dcc7e0323a4c0d3feb66ea8c5e" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.8.13 ('detect_cpu_py38')", "language": "python", "name": "python3" }, @@ -788,7 +785,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.11" + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" + } } }, "nbformat": 4, diff --git a/examples/cd_combined_kernel.ipynb b/examples/cd_combined_kernel.ipynb new file mode 100644 index 000000000..d713eeff1 --- /dev/null +++ b/examples/cd_combined_kernel.ipynb @@ -0,0 +1 @@ +../doc/source/examples/cd_combined_kernel.ipynb \ No newline at end of file From e9e987412dbcb6c938447d9f6ea02b5593ee70a6 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 18 Aug 2022 12:12:23 +0100 Subject: [PATCH 25/37] revert mmd_cifar10 notebook --- doc/source/examples/cd_mmd_cifar10.ipynb | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/doc/source/examples/cd_mmd_cifar10.ipynb b/doc/source/examples/cd_mmd_cifar10.ipynb index b4216887e..99347ff36 100644 --- a/doc/source/examples/cd_mmd_cifar10.ipynb +++ b/doc/source/examples/cd_mmd_cifar10.ipynb @@ -770,8 +770,11 @@ } ], "metadata": { + "interpreter": { + "hash": "ffba93b5284319fb7a107c8eacae647f441487dcc7e0323a4c0d3feb66ea8c5e" + }, "kernelspec": { - "display_name": "Python 3.8.13 ('detect_cpu_py38')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -785,12 +788,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" - } + "version": "3.8.11" } }, "nbformat": 4, From 61032e09a4272c20ab95d1d95440f8347be828ff Mon Sep 17 00:00:00 2001 From: Hao Song Date: Sun, 4 Sep 2022 21:24:02 +0100 Subject: [PATCH 26/37] This commit includes a major re-design of the base kernel class, it now allows: (1) any sum and product with the direct add and multiply equation. (2) the dimension selection is built-in with the main class. (3) the deep kernel is also implemented with the new base class and the user can access it as a single composite kernel. --- alibi_detect/utils/pytorch/__init__.py | 3 +- alibi_detect/utils/pytorch/kernels.py | 307 ++++++++++-------- .../utils/pytorch/tests/test_kernels_pt.py | 6 +- alibi_detect/utils/tensorflow/__init__.py | 3 +- alibi_detect/utils/tensorflow/kernels.py | 303 +++++++++-------- .../utils/tensorflow/tests/test_kernels_tf.py | 6 +- 6 files changed, 350 insertions(+), 278 deletions(-) diff --git a/alibi_detect/utils/pytorch/__init__.py b/alibi_detect/utils/pytorch/__init__.py index 35918f8a3..1269dd9e9 100644 --- a/alibi_detect/utils/pytorch/__init__.py +++ b/alibi_detect/utils/pytorch/__init__.py @@ -14,7 +14,7 @@ GaussianRBF, DeepKernel = import_optional( 'alibi_detect.utils.pytorch.kernels', - names=['GaussianRBF', 'DeepKernel'] + names=['GaussianRBF', 'DeepKernel, BaseKernel'] ) predict_batch, predict_batch_transformer = import_optional( @@ -32,6 +32,7 @@ "mmd2", "mmd2_from_kernel_matrix", "squared_pairwise_distance", + "BaseKernel", "GaussianRBF", "DeepKernel", "permed_lsdds", diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 049d6a0ea..26e2a0118 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -3,6 +3,7 @@ from torch import nn from . import distance from typing import Optional, Union, Callable +from copy import deepcopy from alibi_detect.utils.frameworks import Framework @@ -58,7 +59,7 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. return sigma.log() -class KernelParameter(object): +class KernelParameter: """ Parameter class for kernels. """ @@ -81,82 +82,157 @@ class BaseKernel(nn.Module): """ The base class for all kernels. """ - def __init__(self) -> None: + def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: super().__init__() self.parameter_dict: dict = {} + if active_dims is not None: + self.active_dims = torch.as_tensor(active_dims) + else: + self.active_dims = None + self.feature_axis = feature_axis + self.init_required = False - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: raise NotImplementedError - -class DimensionSelectKernel(nn.Module): - """ - Select a subset of the feature diomensions before apply a given kernel. - """ - def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: - super().__init__() - self.kernel = kernel - self.active_dims = torch.as_tensor(active_dims) - self.feature_axis = feature_axis - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) if self.active_dims is not None: x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) - return self.kernel(x, y, infer_parameter) + return self.kernel_function(x, y, infer_parameter) + + def __add__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other: nn.Module) -> nn.Module: + return self.__add__(other) + + def __mul__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_factors'): + other.kernel_factors.append(self) + return other + elif hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + sum_kernel.kernel_list.append(self * k) + return sum_kernel + else: + prod_kernel = ProductKernel() + prod_kernel.kernel_factors.append(self) + prod_kernel.kernel_factors.append(other) + return prod_kernel + def __rmul__(self, other: nn.Module) -> nn.Module: + return self.__mul__(other) -class AveragedKernel(nn.Module): + +class SumKernel(nn.Module): """ - Construct a kernel by averaging two kernels. + Construct a kernel by summing different kernels. Parameters: - ---------- - kernel_a - the first kernel to be averaged. - kernel_b - the second kernel to be averaged. + ---------------- """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_list = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 + value_list = [] + for k in self.kernel_list: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + return torch.sum(torch.stack(value_list), dim=0) + + def __add__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + for k in other.kernel_list: + self.kernel_list.append(k) + else: + self.kernel_list.append(other) + return self + + def __radd__(self, other: nn.Module) -> nn.Module: + return self.__add__(other) + + def __mul__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for ki in self.kernel_list: + for kj in other.kernel_list: + sum_kernel.kernel_list.append(ki * kj) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + return other * self + else: + sum_kernel = SumKernel() + for ki in self.kernel_list: + sum_kernel.kernel_list.append(other * ki) + return sum_kernel + def __rmul__(self, other: nn.Module) -> nn.Module: + return self.__mul__(other) -class ProductKernel(nn.Module): - """ - Construct a kernel by multiplying two kernels. - Parameters: - ---------- - kernel_a - the first kernel to be multiplied. - kernel_b - the second kernel to be multiplied. - """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: +class ProductKernel(nn.Module): + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_factors = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) + value_list = [] + for k in self.kernel_factors: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + return torch.prod(torch.stack(value_list), dim=0) + + def __add__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other: nn.Module) -> nn.Module: + return self.__add__(other) + + def __mul__(self, other: nn.Module) -> nn.Module: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + tmp_prod_kernel = deepcopy(self) + tmp_prod_kernel.kernel_factors.append(k) + sum_kernel.kernel_list.append(tmp_prod_kernel) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + for k in other.kernel_factors: + self.kernel_factors.append(k) + return self + else: + self.kernel_factors.append(other) + return self + + def __rmul__(self, other: nn.Module) -> nn.Module: + return self.__mul__(other) class GaussianRBF(BaseKernel): @@ -164,7 +240,9 @@ def __init__( self, sigma: Optional[torch.Tensor] = None, init_fn_sigma: Optional[Callable] = None, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -184,7 +262,7 @@ def __init__( trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. """ - super().__init__() + super().__init__(active_dims, feature_axis) init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} self.parameter_dict['log-sigma'] = KernelParameter( @@ -200,8 +278,8 @@ def __init__( def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] @@ -245,7 +323,9 @@ def __init__( init_fn_alpha: Callable = None, sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -259,7 +339,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( value=alpha.reshape(-1) if alpha is not None else None, init_fn=init_fn_alpha, @@ -283,14 +363,14 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: + x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: - if infer_parameter or self.init_required: - infer_kernel_parameter(self, x, y, dist, infer_parameter) + infer_kernel_parameter(self, x, y, dist, infer_parameter) kernel_mat = torch.stack([(1 + torch.square(dist) / (2 * self.alpha[i] * (self.sigma[i] ** 2))) @@ -307,6 +387,8 @@ def __init__( sigma: torch.Tensor = None, init_fn_sigma: Callable = sigma_median, trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -320,7 +402,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( value=tau.log().reshape(-1) if tau is not None else None, init_fn=init_fn_tau, @@ -344,8 +426,8 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: x, y = torch.as_tensor(x), torch.as_tensor(y) dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) @@ -358,67 +440,34 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch return kernel_mat.mean(dim=0) -class LocalPeriodic(BaseKernel): +class ProjKernel(BaseKernel): + """ + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. + + Parameters: + ---------- + proj + The projection to be applied to the inputs before applying raw_kernel + raw_kernel + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + """ def __init__( self, - tau: torch.Tensor = None, - init_fn_tau: Callable = None, - sigma: torch.Tensor = None, - init_fn_sigma: Callable = sigma_median, - trainable: bool = False + proj: nn.Module, + raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: - """ - Local periodic kernel: k(x,y) = k_rbf(x, y) * k_period(x, y). - A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] - and returns the kernel matrix [Nx, Ny]. - - Parameters - ---------- - tau - Period of the periodic kernel. - sigma - Bandwidth used for the kernel. - """ super().__init__() - self.parameter_dict['log-tau'] = KernelParameter( - value=tau.log().reshape(-1) if tau is not None else None, - init_fn=init_fn_tau, - requires_grad=trainable, - requires_init=True if tau is None else False - ) - self.parameter_dict['log-sigma'] = KernelParameter( - value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_fn_sigma, - requires_grad=trainable, - requires_init=True if sigma is None else False - ) - self.trainable = trainable - self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) - - @property - def tau(self) -> torch.Tensor: - return self.parameter_dict['log-tau'].value.exp() - - @property - def sigma(self) -> torch.Tensor: - return self.parameter_dict['log-sigma'].value.exp() - - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: - x, y = torch.as_tensor(x), torch.as_tensor(y) - dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) + self.proj = proj + self.raw_kernel = raw_kernel + self.init_required = False - if infer_parameter or self.init_required: - infer_kernel_parameter(self, x, y, dist, infer_parameter) - - kernel_mat = torch.stack([torch.exp(-2 * torch.square( - torch.sin(torch.as_tensor(np.pi) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - torch.exp(-0.5 * torch.square(dist / self.tau[i])) - for i in range(len(self.sigma))], dim=0) - return kernel_mat.mean(dim=0) + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) -class DeepKernel(nn.Module): +class DeepKernel(BaseKernel): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). A forward pass takes a batch of instances x [Nx, features] and y [Ny, features] and returns @@ -441,21 +490,18 @@ class DeepKernel(nn.Module): def __init__( self, proj: nn.Module, - kernel_a: Union[nn.Module, str] = 'rbf', - kernel_b: Optional[Union[nn.Module, str]] = 'rbf', + kernel_a: BaseKernel = GaussianRBF(trainable=True), + kernel_b: BaseKernel = GaussianRBF(trainable=True), eps: Union[float, str] = 'trainable' ) -> None: super().__init__() self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} - if kernel_a == 'rbf': - kernel_a = GaussianRBF(trainable=True) - if kernel_b == 'rbf': - kernel_b = GaussianRBF(trainable=True) - self.kernel_a = kernel_a - self.kernel_b = kernel_b - self.proj = proj + proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) + self.comp_kernel = (1-self.logit_eps.sigmoid())*proj_kernel + self.logit_eps.sigmoid()*kernel_b + else: + self.comp_kernel = proj_kernel def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -467,15 +513,8 @@ def _init_eps(self, eps: Union[float, str]) -> None: else: raise NotImplementedError("eps should be 'trainable' or a float in (0,1)") - @property - def eps(self) -> torch.Tensor: - return self.logit_eps.sigmoid() if self.kernel_b is not None else torch.tensor(0.) - - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - similarity = self.kernel_a(self.proj(x), self.proj(y)) # type: ignore[operator] - if self.kernel_b is not None: - similarity = (1-self.eps)*similarity + self.eps*self.kernel_b(x, y) # type: ignore[operator] - return similarity + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parmeter=False) -> torch.Tensor: + return self.comp_kernel(x, y, infer_parmeter) def get_config(self) -> dict: return self.config.copy() diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index 45e84df90..e19ca6629 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -3,7 +3,7 @@ import pytest import torch from torch import nn -from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel +from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -39,12 +39,12 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() -class MyKernel(nn.Module): # TODO: Support then test models using keras functional API +class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() self.linear = nn.Linear(n_features, 20) - def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter) -> torch.Tensor: return torch.einsum('ji,ki->jk', self.linear(x), self.linear(y)) diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index 25c182df4..13a302d92 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -10,7 +10,7 @@ GaussianRBF, DeepKernel = import_optional( 'alibi_detect.utils.tensorflow.kernels', - names=['GaussianRBF', 'DeepKernel'] + names=['GaussianRBF', 'DeepKernel, BaseKernel'] ) @@ -45,6 +45,7 @@ "relative_euclidean_distance", "squared_pairwise_distance", "GaussianRBF", + "BaseKernel", "DeepKernel", "permed_lsdds", "predict_batch", diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index f1a7a8a65..5a4941af9 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -3,6 +3,7 @@ from . import distance from typing import Optional, Union, Callable from scipy.special import logit +from copy import deepcopy from alibi_detect.utils.frameworks import Framework @@ -61,11 +62,13 @@ class KernelParameter(object): """ Parameter class for kernels. """ - def __init__(self, - value: tf.Tensor = None, - init_fn: Optional[Callable] = None, - requires_grad: bool = False, - requires_init: bool = False): + def __init__( + self, + value: tf.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False + ) -> None: self.value = tf.Variable(value if value is not None else tf.ones(1, dtype=tf.keras.backend.floatx()), trainable=requires_grad) @@ -80,77 +83,152 @@ class BaseKernel(tf.keras.Model): """ The base class for all kernels. """ - def __init__(self) -> None: + def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: super().__init__() self.parameter_dict: dict = {} - - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return NotImplementedError - - -class DimensionSelectKernel(tf.keras.Model): - """ - Select a subset of the feature diomensions before apply a given kernel. - """ - def __init__(self, kernel: BaseKernel, active_dims: list, feature_axis: int = -1) -> None: - super().__init__() - self.kernel = kernel self.active_dims = active_dims self.feature_axis = feature_axis + self.init_required = False + + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return NotImplementedError def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) - return self.kernel(x, y, infer_parameter) + if self.active_dims is not None: + x = tf.gather(x, self.active_dims, axis=self.feature_axis) + y = tf.gather(y, self.active_dims, axis=self.feature_axis) + return self.kernel_function(x, y, infer_parameter) + + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + return self.__add__(other) + + def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_factors'): + other.kernel_factors.append(self) + return other + elif hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + sum_kernel.kernel_list.append(self * k) + return sum_kernel + else: + prod_kernel = ProductKernel() + prod_kernel.kernel_factors.append(self) + prod_kernel.kernel_factors.append(other) + return prod_kernel + + def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + return self.__mul__(other) -class AveragedKernel(tf.keras.Model): +class SumKernel(tf.keras.Model): """ - Construct a kernel by averaging two kernels. + Construct a kernel by summing different kernels. Parameters: - ---------- - kernel_a - the first kernel to be averaged. - kernel_b - the second kernel to be averaged. + ---------------- """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_list = [] + + def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], + infer_parameter: bool = False) -> tf.Tensor: + value_list = [] + for k in self.kernel_list: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + return tf.reduce_sum(tf.stack(value_list), axis=0) + + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + for k in other.kernel_list: + self.kernel_list.append(k) + else: + self.kernel_list.append(other) + return self + + def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + return self.__add__(other) + + def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for ki in self.kernel_list: + for kj in other.kernel_list: + sum_kernel.kernel_list.append(ki * kj) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + return other * self + else: + sum_kernel = SumKernel() + for ki in self.kernel_list: + sum_kernel.kernel_list.append(other * ki) + return sum_kernel - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return (self.kernel_a(x, y, infer_parameter) + self.kernel_b(x, y, infer_parameter)) / 2 + def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + return self.__mul__(other) class ProductKernel(tf.keras.Model): - """ - Construct a kernel by multiplying two kernels. - - Parameters: - ---------- - kernel_a - the first kernel to be multiplied. - kernel_b - the second kernel to be multiplied. - """ - def __init__( - self, - kernel_a: BaseKernel, - kernel_b: BaseKernel - ) -> None: + def __init__(self) -> None: super().__init__() - self.kernel_a = kernel_a - self.kernel_b = kernel_b + self.kernel_factors = [] + + def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], + infer_parameter: bool = False) -> tf.Tensor: + value_list = [] + for k in self.kernel_factors: + if callable(k): + value_list.append(k(x, y, infer_parameter)) + else: + value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + return tf.reduce_prod(tf.stack(value_list), axis=0) + + def __add__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + return self.__add__(other) + + def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: + if hasattr(other, 'kernel_list'): + sum_kernel = SumKernel() + for k in other.kernel_list: + tmp_prod_kernel = deepcopy(self) + tmp_prod_kernel.kernel_factors.append(k) + sum_kernel.kernel_list.append(tmp_prod_kernel) + return sum_kernel + elif hasattr(other, 'kernel_factors'): + for k in other.kernel_factors: + self.kernel_factors.append(k) + return self + else: + self.kernel_factors.append(other) + return self - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - return self.kernel_a(x, y, infer_parameter) * self.kernel_b(x, y, infer_parameter) + def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + return self.__mul__(other) class GaussianRBF(BaseKernel): @@ -158,7 +236,9 @@ def __init__( self, sigma: Optional[tf.Tensor] = None, init_fn_sigma: Optional[Callable] = None, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -178,7 +258,7 @@ def __init__( trainable Whether or not to track gradients w.r.t. sigma to allow it to be trained. """ - super().__init__() + super().__init__(active_dims, feature_axis) init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} self.parameter_dict['log-sigma'] = KernelParameter( @@ -195,7 +275,7 @@ def __init__( def sigma(self) -> tf.Tensor: return tf.math.exp(self.parameter_dict['log-sigma'].value) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) # flatten dist = distance.squared_pairwise_distance(x, y) # [Nx, Ny] @@ -239,7 +319,9 @@ def __init__( init_fn_alpha: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -253,7 +335,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( value=tf.reshape( tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, @@ -279,7 +361,7 @@ def sigma(self) -> tf.Tensor: def alpha(self) -> tf.Tensor: return self.parameter_dict['alpha'].value - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -300,7 +382,9 @@ def __init__( init_fn_tau: Callable = None, sigma: tf.Tensor = None, init_fn_sigma: Callable = sigma_median, - trainable: bool = False + trainable: bool = False, + active_dims: list = None, + feature_axis: int = -1 ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -314,7 +398,7 @@ def __init__( sigma Bandwidth used for the kernel. """ - super().__init__() + super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, @@ -340,7 +424,7 @@ def tau(self) -> tf.Tensor: def sigma(self) -> tf.Tensor: return tf.math.exp(self.parameter_dict['log-sigma'].value) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) dist = distance.squared_pairwise_distance(x, y) @@ -354,69 +438,22 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. return tf.reduce_mean(kernel_mat, axis=0) -class LocalPeriodic(BaseKernel): +class ProjKernel(BaseKernel): def __init__( self, - tau: tf.Tensor = None, - init_fn_tau: Callable = None, - sigma: tf.Tensor = None, - init_fn_sigma: Callable = sigma_median, - trainable: bool = False, + proj: tf.keras.Model, + raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: - """ - Local periodic kernel: k(x,y) = k(x,y) = k_rbf(x, y) * k_period(x, y). - A forward pass takesa batch of instances x [Nx, features] and y [Ny, features] - and returns the kernel matrix [Nx, Ny]. - - Parameters - ---------- - tau - Period of the periodic kernel. - sigma - Bandwidth used for the kernel. - """ super().__init__() - self.parameter_dict['log-tau'] = KernelParameter( - value=tf.reshape(tf.math.log( - tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, - init_fn=init_fn_tau, - requires_grad=trainable, - requires_init=True if tau is None else False - ) - self.parameter_dict['log-sigma'] = KernelParameter( - value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, - init_fn=init_fn_sigma, - requires_grad=trainable, - requires_init=True if sigma is None else False - ) - self.trainable = trainable - self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) - - @property - def tau(self) -> tf.Tensor: - return tf.math.exp(self.parameter_dict['log-tau'].value) - - @property - def sigma(self) -> tf.Tensor: - return tf.math.exp(self.parameter_dict['log-sigma'].value) - - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: - y = tf.cast(y, x.dtype) - x, y = tf.reshape(x, (x.shape[0], -1)), tf.reshape(y, (y.shape[0], -1)) - dist = distance.squared_pairwise_distance(x, y) - - if infer_parameter or self.init_required: - infer_kernel_parameter(self, x, y, dist, infer_parameter) + self.proj = proj + self.raw_kernel = raw_kernel + self.init_required = False - kernel_mat = tf.stack([tf.math.exp(-2 * tf.square( - tf.math.sin(tf.cast(np.pi, x.dtype) * dist / self.tau[i])) / (self.sigma[i] ** 2)) * - tf.math.exp(-0.5 * tf.square(dist / self.tau[i])) - for i in range(len(self.sigma))], axis=0) - return tf.reduce_mean(kernel_mat, axis=0) + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) -class DeepKernel(tf.keras.Model): +class DeepKernel(BaseKernel): """ Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). A forward pass takes a batch of instances x [Nx, features] and y [Ny, features] and returns @@ -439,21 +476,18 @@ class DeepKernel(tf.keras.Model): def __init__( self, proj: tf.keras.Model, - kernel_a: Union[tf.keras.Model, str] = 'rbf', - kernel_b: Optional[Union[tf.keras.Model, str]] = 'rbf', + kernel_a: BaseKernel = GaussianRBF(trainable=True), + kernel_b: BaseKernel = GaussianRBF(trainable=True), eps: Union[float, str] = 'trainable' ) -> None: super().__init__() - self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} - if kernel_a == 'rbf': - kernel_a = GaussianRBF(trainable=True) - if kernel_b == 'rbf': - kernel_b = GaussianRBF(trainable=True) - self.kernel_a = kernel_a - self.kernel_b = kernel_b - self.proj = proj + proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) + self.comp_kernel = (1-tf.sigmoid(self.logit_eps))*proj_kernel + tf.sigmoid(self.logit_eps)*kernel_b + else: + self.comp_kernel = proj_kernel + self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -470,11 +504,8 @@ def _init_eps(self, eps: Union[float, str]) -> None: def eps(self) -> tf.Tensor: return tf.math.sigmoid(self.logit_eps) if self.kernel_b is not None else tf.constant(0.) - def call(self, x: tf.Tensor, y: tf.Tensor) -> tf.Tensor: - similarity = self.kernel_a(self.proj(x), self.proj(y)) # type: ignore[operator] - if self.kernel_b is not None: - similarity = (1-self.eps)*similarity + self.eps*self.kernel_b(x, y) # type: ignore[operator] - return similarity + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + return self.comp_kernel(x, y, infer_parameter) def get_config(self) -> dict: return self.config.copy() diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index ee90d6e72..a12a30d41 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -3,7 +3,7 @@ import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input -from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel +from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -38,12 +38,12 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() -class MyKernel(tf.keras.Model): # TODO: Support then test models using keras functional API +class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() self.dense = Dense(20) - def call(self, x: tf.Tensor, y: tf.Tensor) -> tf.Tensor: + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter) -> tf.Tensor: return tf.einsum('ji,ki->jk', self.dense(x), self.dense(y)) From 82d9dd4dfc9c0467b0b8e9e7bf614839342a13b6 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Thu, 8 Sep 2022 16:51:25 +0100 Subject: [PATCH 27/37] Refine the behaviour of the new base kernel class, added further error messages on unsupported operations. Also added new notebook on creating user-defined kernels for drift detectors. --- alibi_detect/utils/pytorch/kernels.py | 50 ++- alibi_detect/utils/tensorflow/kernels.py | 45 +++ doc/source/examples/cd_combined_kernel.ipynb | 142 +++---- .../cd_create_customised_kernel.ipynb | 375 ++++++++++++++++++ 4 files changed, 518 insertions(+), 94 deletions(-) create mode 100644 doc/source/examples/cd_create_customised_kernel.ipynb diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 26e2a0118..b32267315 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -102,7 +102,10 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch if self.active_dims is not None: x = torch.index_select(x, self.feature_axis, self.active_dims) y = torch.index_select(y, self.feature_axis, self.active_dims) - return self.kernel_function(x, y, infer_parameter) + if len(self.parameter_dict) > 0: + return self.kernel_function(x, y, infer_parameter) + else: + return self.kernel_function(x, y) def __add__(self, other: nn.Module) -> nn.Module: if hasattr(other, 'kernel_list'): @@ -135,6 +138,21 @@ def __mul__(self, other: nn.Module) -> nn.Module: def __rmul__(self, other: nn.Module) -> nn.Module: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class SumKernel(nn.Module): """ @@ -186,6 +204,21 @@ def __mul__(self, other: nn.Module) -> nn.Module: def __rmul__(self, other: nn.Module) -> nn.Module: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class ProductKernel(nn.Module): def __init__(self) -> None: @@ -234,6 +267,21 @@ def __mul__(self, other: nn.Module) -> nn.Module: def __rmul__(self, other: nn.Module) -> nn.Module: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class GaussianRBF(BaseKernel): def __init__( diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 5a4941af9..3e85d9d39 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -131,6 +131,21 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class SumKernel(tf.keras.Model): """ @@ -182,6 +197,21 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class ProductKernel(tf.keras.Model): def __init__(self) -> None: @@ -230,6 +260,21 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: return self.__mul__(other) + def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: + if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support substraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support substraction.') + class GaussianRBF(BaseKernel): def __init__( diff --git a/doc/source/examples/cd_combined_kernel.ipynb b/doc/source/examples/cd_combined_kernel.ipynb index 5c985d772..6742c5d9d 100644 --- a/doc/source/examples/cd_combined_kernel.ipynb +++ b/doc/source/examples/cd_combined_kernel.ipynb @@ -7,7 +7,7 @@ "# Create sum and product kernels with exsisting kernels\n", "\n", "\n", - "### Combine different kernels for better test power on certain data types" + "### From time to time, out dataset might contain values and features that might be of different types or scales. For instance, a temperture dataset might have two features with one being the timestamp and the other being the reading. As a result, we might want to apply differnt kernels on these two features respectively, and use the combined kernel for the drift detectors for a better test power." ] }, { @@ -21,30 +21,7 @@ "shell.execute_reply": "2022-08-17T22:48:42.258215Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-18 11:16:03.693515: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:03.693561: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", - "2022-08-18 11:16:09.361482: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n", - "Your kernel may have been built without NUMA support.\n", - "2022-08-18 11:16:09.361658: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361739: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublas.so.11'; dlerror: libcublas.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361808: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcublasLt.so.11'; dlerror: libcublasLt.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361874: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcufft.so.10'; dlerror: libcufft.so.10: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.361939: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcurand.so.10'; dlerror: libcurand.so.10: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362005: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusolver.so.11'; dlerror: libcusolver.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362069: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcusparse.so.11'; dlerror: libcusparse.so.11: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362133: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudnn.so.8'; dlerror: libcudnn.so.8: cannot open shared object file: No such file or directory\n", - "2022-08-18 11:16:09.362145: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1850] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", - "Skipping registering GPU devices...\n", - "2022-08-18 11:16:09.362441: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", - "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import scipy.stats as stats\n", @@ -52,13 +29,13 @@ "import matplotlib.pyplot as plt\n", "import tensorflow as tf\n", "\n", - "backend = 'pytorch'\n", + "backend = 'tensorflow'\n", "\n", "from alibi_detect.cd import MMDDrift\n", "if backend == 'pytorch':\n", - " from alibi_detect.utils.pytorch.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + " from alibi_detect.utils.pytorch.kernels import GaussianRBF, Periodic\n", "elif backend == 'tensorflow':\n", - " from alibi_detect.utils.tensorflow.kernels import GaussianRBF, Periodic, AveragedKernel, DimensionSelectKernel\n", + " from alibi_detect.utils.tensorflow.kernels import GaussianRBF, Periodic\n", "else:\n", " raise ValueError('Backend {} not supported'.format(backend))\n", "\n", @@ -114,7 +91,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Here we create two simple datasets with waves and therefore have two features, the test data shows clear drift around the wave through." + "### Here, we create two simple datasets with waves and have two features. The test data shows apparent drift around the wave through." ] }, { @@ -141,7 +118,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -164,7 +141,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### If we use standard RBF kernel on both features with the MMD drift detector, we can see that the drift is not detected." + "### If we use the standard RBF kernel on both features with the MMD drift detector, we can see that the drift is not detected." ] }, { @@ -180,15 +157,7 @@ "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU detected, fall back on CPU.\n" - ] - } - ], + "outputs": [], "source": [ "cd_RBF = MMDDrift(x_ref=x_ref,\n", " backend=backend,\n", @@ -204,15 +173,15 @@ "data": { "text/plain": [ "{'data': {'is_drift': 0,\n", - " 'distance': -0.00032591944848670007,\n", - " 'p_val': 0.5600000023841858,\n", + " 'distance': 0.0006610155,\n", + " 'p_val': 0.24,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': array(0.00219562, dtype=float32)},\n", - " 'meta': {'name': 'MMDDriftTorch',\n", + " 'distance_threshold': 0.0027906895},\n", + " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", " 'version': '0.9.2dev',\n", - " 'backend': 'pytorch'}}" + " 'backend': 'tensorflow'}}" ] }, "execution_count": 7, @@ -229,7 +198,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### To facilitate our knowledge that the data contain waves, we use a combined kernel that is averaged from two kernels. The first kernel is a periodic kernel with a specified period of 24 and only working on the first feature. The second kernel is a RBF kernel with a infered bandwidth and only working on the second feature." + "### To facilitate our knowledge that the data contain waves, we use a combined kernel averaged from two kernels. The first kernel is a periodic kernel with a specified period of 24 and only works on the first feature. The second kernel is an RBF kernel with an inferred bandwidth and only works on the second feature." ] }, { @@ -246,11 +215,11 @@ "outputs": [], "source": [ "if backend == 'pytorch':\n", - " Kernel_0 = DimensionSelectKernel(Periodic(tau=torch.tensor([24.0])), active_dims=[0])\n", - " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])\n", + " Kernel_0 = Periodic(tau=torch.tensor([24.0]), active_dims=[0])\n", + " Kernel_1 = GaussianRBF(active_dims=[1])\n", "elif backend == 'tensorflow':\n", - " Kernel_0 = DimensionSelectKernel(Periodic(tau=tf.convert_to_tensor([24.0])), active_dims=[0])\n", - " Kernel_1 = DimensionSelectKernel(GaussianRBF(), active_dims=[1])" + " Kernel_0 = Periodic(tau=tf.convert_to_tensor([24.0]), active_dims=[0])\n", + " Kernel_1 = GaussianRBF(active_dims=[1])" ] }, { @@ -266,7 +235,7 @@ }, "outputs": [], "source": [ - "Kernel_avg = AveragedKernel(Kernel_0, Kernel_1)" + "Kernel_avg = (Kernel_0 + Kernel_1) / 2" ] }, { @@ -280,15 +249,7 @@ "shell.execute_reply": "2022-08-17T22:48:43.048438Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU detected, fall back on CPU.\n" - ] - } - ], + "outputs": [], "source": [ "cd_avg = MMDDrift(x_ref=x_ref,\n", " backend=backend,\n", @@ -311,15 +272,15 @@ "data": { "text/plain": [ "{'data': {'is_drift': 1,\n", - " 'distance': 0.006368878019042512,\n", + " 'distance': 0.006862521,\n", " 'p_val': 0.0,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': array(0.00098101, dtype=float32)},\n", - " 'meta': {'name': 'MMDDriftTorch',\n", + " 'distance_threshold': 0.0007869005},\n", + " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", " 'version': '0.9.2dev',\n", - " 'backend': 'pytorch'}}" + " 'backend': 'tensorflow'}}" ] }, "execution_count": 11, @@ -336,7 +297,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### The kernel, its compments and asscociated parameters can be inspected as follows:\n" + "### The kernel, its components and associated parameters can be inspected as follows:" ] }, { @@ -355,25 +316,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "AveragedKernel(\n", - " (kernel_a): DimensionSelectKernel(\n", - " (kernel): Periodic()\n", - " )\n", - " (kernel_b): DimensionSelectKernel(\n", - " (kernel): GaussianRBF()\n", - " )\n", - ")\n", - "DimensionSelectKernel(\n", - " (kernel): Periodic()\n", - ")\n", - "Periodic()\n" + "\n", + "ListWrapper([, 0.5])\n", + "ListWrapper([, 0.5])\n" ] } ], "source": [ "print(cd_avg._detector.kernel)\n", - "print(cd_avg._detector.kernel.kernel_a)\n", - "print(cd_avg._detector.kernel.kernel_a.kernel)" + "print(cd_avg._detector.kernel.kernel_list[0].kernel_factors)\n", + "print(cd_avg._detector.kernel.kernel_list[1].kernel_factors)" ] }, { @@ -392,14 +344,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "tensor([24.])\n", - "tensor([4.9818], dtype=torch.float64)\n" + "tf.Tensor([24.], shape=(1,), dtype=float32)\n", + "tf.Tensor([34.31387], shape=(1,), dtype=float32)\n" ] } ], "source": [ - "print(Kernel_avg.kernel_a.kernel.tau)\n", - "print(Kernel_avg.kernel_a.kernel.sigma)" + "print(Kernel_avg.kernel_list[0].kernel_factors[0].tau)\n", + "print(Kernel_avg.kernel_list[0].kernel_factors[0].sigma)" ] }, { @@ -415,24 +367,28 @@ }, "outputs": [ { - "data": { - "text/plain": [ - "tensor([0.5243], dtype=torch.float64)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "tf.Tensor([0.50738114], shape=(1,), dtype=float32)\n" + ] } ], "source": [ - "Kernel_avg.kernel_b.kernel.sigma" + "print(Kernel_avg.kernel_list[1].kernel_factors[0].sigma)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('detect_cpu_py38')", + "display_name": "Python 3.8.13", "language": "python", "name": "python3" }, diff --git a/doc/source/examples/cd_create_customised_kernel.ipynb b/doc/source/examples/cd_create_customised_kernel.ipynb new file mode 100644 index 000000000..1eca99936 --- /dev/null +++ b/doc/source/examples/cd_create_customised_kernel.ipynb @@ -0,0 +1,375 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create customised kernel to be used with drift detectors\n", + "\n", + "### Sometimes we might prefer to use some prior knowledge or pre-trained embeddings to build a customised kernel (distance) function instead. In this notebook, we will demonstrate how to implement a user-defined kernel with either a customised distance function or a specific feature projection function. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2022-08-17T22:48:30.140646Z", + "iopub.status.busy": "2022-08-17T22:48:30.139694Z", + "iopub.status.idle": "2022-08-17T22:48:42.261216Z", + "shell.execute_reply": "2022-08-17T22:48:42.258215Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy.stats as stats\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import tensorflow as tf\n", + "\n", + "backend = 'pytorch'\n", + "\n", + "from alibi_detect.cd import MMDDrift\n", + "if backend == 'pytorch':\n", + " from alibi_detect.utils.pytorch.kernels import BaseKernel, ProjKernel, GaussianRBF\n", + "elif backend == 'tensorflow':\n", + " from alibi_detect.utils.tensorflow.kernels import BaseKernel, ProjKernel, GaussianRBF\n", + "else:\n", + " raise ValueError('Backend {} not supported'.format(backend))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We first consider to create a kernel that uses a user specified distance function. For instance, we can write a periodic kernel's distance function with the Trigonometric functions: $k(x,y) = exp(-2 \\cdot \\frac{sin(pi \\cdot \\frac{|x - y|}{\\tau})^2}{\\sigma^2})$. To do so, the easiest way is to import and inherit the BaseKernel class from the corresponding backend (here we use Pytorch), and overload the kernelfunction method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### For this example, we manually specified the kernel's parameters in the kernel function. To implement these parameters as variables for training or initialisation heuristics, please refer to the implementations in the built-in kernels." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class PeriodicKernel(BaseKernel):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def kernel_function(self, x, y):\n", + " tau = 24.0 # period parameter\n", + " sigma = 0.05 # bandwidth parameter\n", + " x, y = torch.as_tensor(x), torch.as_tensor(y)\n", + " x2 = x.pow(2).sum(dim=-1, keepdim=True)\n", + " y2 = y.pow(2).sum(dim=-1, keepdim=True)\n", + " dist = torch.addmm(y2.transpose(-2, -1), x, y.transpose(-2, -1), alpha=-2).add_(x2)\n", + " kernel_mat = torch.exp(-2 * torch.square(torch.sin(torch.as_tensor(np.pi) * dist / tau)) / (sigma ** 2))\n", + " return kernel_mat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we create a toy dataset to test our new kernel, where the test data shows an apparent drift around the wave through." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_sin(N):\n", + " c_0 = np.random.uniform(0, 168, N)\n", + " x_0 = np.sin(c_0 / (12 / np.pi)) + np.random.normal(0, 0.1, N)\n", + "\n", + " c_1 = stats.beta.rvs(a=1.2, b=1.2, size=N) * 24 + np.random.choice([0, 24, 48, 72, 96, 120, 144], size=N)\n", + " x_1 = np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) < 12) + \\\n", + " np.sin(c_1 / (12 / np.pi)) * (np.mod(c_1, 24) >= 12) * 1.25 + \\\n", + " + np.random.normal(0, 0.1, N)\n", + " \n", + " x_ref = np.hstack([c_0.reshape(-1, 1), x_0.reshape(-1, 1)])\n", + " x_test = np.hstack([c_1.reshape(-1, 1), x_1.reshape(-1, 1)]) \n", + " \n", + " return x_ref, x_test" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "x_ref, x_test = get_sin(N=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.5, 1.5)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 3), dpi=128)\n", + "plt.plot(x_ref[:, 0], x_ref[:, 1], 'bo', alpha=0.5, markersize=2.5, label='Reference')\n", + "plt.plot(x_test[:, 0], x_test[:, 1], 'ro', alpha=0.5, markersize=2.5, label='Test')\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We can now create an instance of the periodic kernel implemented above and use it with the MMD detector. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "kernel_period = PeriodicKernel()\n", + "\n", + "cd = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=kernel_period)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 1,\n", + " 'distance': 0.0006290622733601328,\n", + " 'p_val': 0.029999999329447746,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00055086, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds = cd.predict(x_test)\n", + "preds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Alternatively, we might consider using a projection function (which could be anything from a straightforward linear transform to a deep net) to imply our knowledge about the dataset. In this case, we can consider implementing the kernel with the ProjKernel class, where we can define the projection function using the model class from the corresponding backend (i.e. torch.nn.Module)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "class MyProj(torch.nn.Module):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + "\n", + " def forward(self, x):\n", + " x = torch.as_tensor(x)\n", + " return torch.cat([torch.remainder(x[:, 0], 24).reshape(-1, 1), x[:, 1].reshape(-1, 1)], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### As indicated by the code above, here we create a simple projection function by getting the remainder of the first feature after dividing by 24, while the second feature is kept." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.5, 1.5)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "proj = MyProj()\n", + "\n", + "x_proj_ref = proj(x_ref)\n", + "\n", + "x_proj_test = proj(x_test)\n", + "\n", + "plt.figure(figsize=(4, 3), dpi=128)\n", + "plt.plot(x_proj_ref[:, 0], x_proj_ref[:, 1], 'bo', alpha=0.5, markersize=2.5, label='Reference')\n", + "plt.plot(x_proj_test[:, 0], x_proj_test[:, 1], 'ro', alpha=0.5, markersize=2.5, label='Test')\n", + "plt.legend()\n", + "plt.ylim(-1.5, 1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We can then create the kernel with the projection model and a base RBF kernel and use it together with the MMD detector. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU detected, fall back on CPU.\n" + ] + } + ], + "source": [ + "kernel_proj = ProjKernel(proj = proj,\n", + " raw_kernel= GaussianRBF(sigma=torch.as_tensor(0.05)))\n", + "\n", + "cd_proj = MMDDrift(x_ref=x_ref,\n", + " backend=backend,\n", + " kernel=kernel_proj)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'data': {'is_drift': 1,\n", + " 'distance': 0.0009441937452792366,\n", + " 'p_val': 0.0,\n", + " 'threshold': 0.05,\n", + " 'distance_threshold': array(0.00010083, dtype=float32)},\n", + " 'meta': {'name': 'MMDDriftTorch',\n", + " 'detector_type': 'offline',\n", + " 'data_type': None,\n", + " 'version': '0.9.2dev',\n", + " 'backend': 'pytorch'}}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preds_proj = cd_proj.predict(x_test)\n", + "preds_proj" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7e64b57d98d912fd804d915fa87b4fe52e4baf86 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Tue, 20 Sep 2022 09:17:45 +0100 Subject: [PATCH 28/37] Added extra treatments for different kernel class. Also refine the type hint for various methods and attributes for better consistency. --- alibi_detect/utils/pytorch/kernels.py | 146 ++++++++++++------ .../utils/pytorch/tests/test_kernels_pt.py | 4 +- alibi_detect/utils/tensorflow/kernels.py | 131 ++++++++++------ .../utils/tensorflow/tests/test_kernels_tf.py | 2 +- 4 files changed, 190 insertions(+), 93 deletions(-) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index b32267315..351b01d3b 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -2,7 +2,7 @@ import torch from torch import nn from . import distance -from typing import Optional, Union, Callable +from typing import Optional, Union, Callable, List from copy import deepcopy from alibi_detect.utils.frameworks import Framework @@ -93,7 +93,7 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.init_required = False def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + infer_parameter: Optional[bool] = False) -> torch.Tensor: raise NotImplementedError def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], @@ -107,24 +107,34 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch else: return self.kernel_function(x, y) - def __add__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other - else: + elif (isinstance(other, BaseKernel) or + isinstance(other, ProductKernel) or + isinstance(other, torch.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) return sum_kernel + else: + raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: nn.Module) -> nn.Module: + def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_factors'): + def __mul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other - elif hasattr(other, 'kernel_list'): + elif isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) @@ -135,12 +145,15 @@ def __mul__(self, other: nn.Module) -> nn.Module: prod_kernel.kernel_factors.append(other) return prod_kernel - def __rmul__(self, other: nn.Module) -> nn.Module: + def __rmul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): - return self.__mul__(1 / other) + def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, torch.Tensor): + return self.__mul__(1. / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -163,49 +176,62 @@ class SumKernel(nn.Module): """ def __init__(self) -> None: super().__init__() - self.kernel_list = [] + self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - value_list = [] + value_list: List[torch.Tensor] = [] for k in self.kernel_list: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, torch.Tensor): value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by SumKernel.') return torch.sum(torch.stack(value_list), dim=0) - def __add__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): for k in other.kernel_list: self.kernel_list.append(k) else: self.kernel_list.append(other) - return self + return self - def __radd__(self, other: nn.Module) -> nn.Module: + def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: for kj in other.kernel_list: - sum_kernel.kernel_list.append(ki * kj) + sum_kernel.kernel_list.append((ki * kj)) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): return other * self - else: + elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') - def __rmul__(self, other: nn.Module) -> nn.Module: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -223,20 +249,25 @@ def __rsub__(self, other): class ProductKernel(nn.Module): def __init__(self) -> None: super().__init__() - self.kernel_factors = [] + self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: bool = False) -> torch.Tensor: - value_list = [] + value_list: List[torch.Tensor] = [] for k in self.kernel_factors: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, torch.Tensor): value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by ProductKernel.') return torch.prod(torch.stack(value_list), dim=0) - def __add__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other else: @@ -245,30 +276,41 @@ def __add__(self, other: nn.Module) -> nn.Module: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other: nn.Module) -> nn.Module: + def __radd__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: nn.Module) -> nn.Module: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: tmp_prod_kernel = deepcopy(self) tmp_prod_kernel.kernel_factors.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): for k in other.kernel_factors: self.kernel_factors.append(k) - return self - else: + return self + elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): self.kernel_factors.append(other) return self + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') - def __rmul__(self, other: nn.Module) -> nn.Module: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, torch.Tensor]) -> nn.Module: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, torch.Tensor): + def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -511,7 +553,12 @@ def __init__( self.raw_kernel = raw_kernel self.init_required = False - def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: + def kernel_function( + self, + x: Union[np.ndarray, torch.Tensor], + y: Union[np.ndarray, torch.Tensor], + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) @@ -561,8 +608,13 @@ def _init_eps(self, eps: Union[float, str]) -> None: else: raise NotImplementedError("eps should be 'trainable' or a float in (0,1)") - def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parmeter=False) -> torch.Tensor: - return self.comp_kernel(x, y, infer_parmeter) + def kernel_function( + self, + x: Union[np.ndarray, torch.Tensor], + y: Union[np.ndarray, torch.Tensor], + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: + return self.comp_kernel(x, y, infer_parameter) def get_config(self) -> dict: return self.config.copy() diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index e19ca6629..22cb2298e 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -3,6 +3,7 @@ import pytest import torch from torch import nn +from typing import Union from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] @@ -44,7 +45,8 @@ def __init__(self, n_features: int): super().__init__() self.linear = nn.Linear(n_features, 20) - def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter) -> torch.Tensor: + def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + infer_parameter: bool = False) -> torch.Tensor: return torch.einsum('ji,ki->jk', self.linear(x), self.linear(y)) diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 3e85d9d39..93b665909 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -1,7 +1,7 @@ import tensorflow as tf import numpy as np from . import distance -from typing import Optional, Union, Callable +from typing import Optional, Union, Callable, List from scipy.special import logit from copy import deepcopy from alibi_detect.utils.frameworks import Framework @@ -90,7 +90,8 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.feature_axis = feature_axis self.init_required = False - def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: + def kernel_function(self, x: tf.Tensor, y: tf.Tensor, + infer_parameter: Optional[bool] = False) -> tf.Tensor: return NotImplementedError def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: @@ -100,24 +101,34 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. y = tf.gather(y, self.active_dims, axis=self.feature_axis) return self.kernel_function(x, y, infer_parameter) - def __add__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other - else: + elif (isinstance(other, BaseKernel) or + isinstance(other, ProductKernel) or + isinstance(other, tf.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) return sum_kernel + else: + raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_factors'): + def __mul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other - elif hasattr(other, 'kernel_list'): + elif isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) @@ -128,12 +139,15 @@ def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: prod_kernel.kernel_factors.append(other) return prod_kernel - def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + def __rmul__( + self, + other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): - return self.__mul__(1 / other) + def __truediv__(self, other: tf.Tensor) -> 'ProductKernel': + if isinstance(other, tf.Tensor): + return self.__mul__(1. / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -156,49 +170,62 @@ class SumKernel(tf.keras.Model): """ def __init__(self) -> None: super().__init__() - self.kernel_list = [] + self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: - value_list = [] + value_list: List[tf.Tensor] = [] for k in self.kernel_list: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, tf.Tensor): value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by SumKernel.') return tf.reduce_sum(tf.stack(value_list), axis=0) - def __add__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): for k in other.kernel_list: self.kernel_list.append(k) else: self.kernel_list.append(other) - return self + return self - def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: for kj in other.kernel_list: - sum_kernel.kernel_list.append(ki * kj) + sum_kernel.kernel_list.append((ki * kj)) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): return other * self - else: + elif isinstance(other, BaseKernel) or isinstance(other, tf.Tensor): sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') - def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + def __truediv__(self, other: tf.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, tf.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') @@ -216,20 +243,25 @@ def __rsub__(self, other): class ProductKernel(tf.keras.Model): def __init__(self) -> None: super().__init__() - self.kernel_factors = [] + self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: - value_list = [] + value_list: List[tf.Tensor] = [] for k in self.kernel_factors: - if callable(k): + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) - else: + elif isinstance(k, tf.Tensor): value_list.append(k * tf.ones((x.shape[0], y.shape[0]))) + else: + raise ValueError(type(k) + 'is not supported by ProductKernel.') return tf.reduce_prod(tf.stack(value_list), axis=0) - def __add__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __add__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): other.kernel_list.append(self) return other else: @@ -238,30 +270,41 @@ def __add__(self, other: tf.keras.Model) -> tf.keras.Model: sum_kernel.kernel_list.append(other) return sum_kernel - def __radd__(self, other: tf.keras.Model) -> tf.keras.Model: + def __radd__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> 'SumKernel': return self.__add__(other) - def __mul__(self, other: tf.keras.Model) -> tf.keras.Model: - if hasattr(other, 'kernel_list'): + def __mul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + ) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: tmp_prod_kernel = deepcopy(self) tmp_prod_kernel.kernel_factors.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) return sum_kernel - elif hasattr(other, 'kernel_factors'): + elif isinstance(other, ProductKernel): for k in other.kernel_factors: self.kernel_factors.append(k) - return self - else: + return self + elif isinstance(other, BaseKernel) or isinstance(other, tf.Tensor): self.kernel_factors.append(other) return self + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') - def __rmul__(self, other: tf.keras.Model) -> tf.keras.Model: + def __rmul__( + self, + other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + ) -> Union['SumKernel', 'ProductKernel']: return self.__mul__(other) - def __truediv__(self, other: Union[int, float, tf.Tensor]) -> tf.keras.Model: - if isinstance(other, int) or isinstance(other, float) or isinstance(other, tf.Tensor): + def __truediv__(self, other: tf.Tensor) -> Union['SumKernel', 'ProductKernel']: + if isinstance(other, tf.Tensor): return self.__mul__(1 / other) else: raise ValueError('Kernels can only be divided by a constant.') diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index a12a30d41..edad5dfd3 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -43,7 +43,7 @@ def __init__(self, n_features: int): super().__init__() self.dense = Dense(20) - def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter) -> tf.Tensor: + def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return tf.einsum('ji,ki->jk', self.dense(x), self.dense(y)) From 10841804335c9b7496c4d268f9670e8346f9a6ef Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 14 Oct 2022 22:06:38 +0100 Subject: [PATCH 29/37] Add additional tests for the new kernels, and fix notebooks with new divide input types. --- alibi_detect/utils/pytorch/__init__.py | 4 +- .../utils/pytorch/tests/test_kernels_pt.py | 129 +++++++++++++++- alibi_detect/utils/tensorflow/__init__.py | 2 +- .../utils/tensorflow/tests/test_kernels_tf.py | 122 ++++++++++++++- doc/source/examples/cd_combined_kernel.ipynb | 140 ++++-------------- .../cd_create_customised_kernel.ipynb | 16 +- 6 files changed, 284 insertions(+), 129 deletions(-) diff --git a/alibi_detect/utils/pytorch/__init__.py b/alibi_detect/utils/pytorch/__init__.py index 1269dd9e9..63ec90520 100644 --- a/alibi_detect/utils/pytorch/__init__.py +++ b/alibi_detect/utils/pytorch/__init__.py @@ -14,7 +14,7 @@ GaussianRBF, DeepKernel = import_optional( 'alibi_detect.utils.pytorch.kernels', - names=['GaussianRBF', 'DeepKernel, BaseKernel'] + names=['GaussianRBF', 'DeepKernel, BaseKernel, RationalQuadratic, Periodic'] ) predict_batch, predict_batch_transformer = import_optional( @@ -34,6 +34,8 @@ "squared_pairwise_distance", "BaseKernel", "GaussianRBF", + "RationalQuadratic", + "Periodic", "DeepKernel", "permed_lsdds", "predict_batch", diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index 22cb2298e..a4f405b54 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -4,7 +4,7 @@ import torch from torch import nn from typing import Union -from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel +from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -40,6 +40,133 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +sigma = [None, np.array([1.]), np.array([2.])] +alpha = [None, np.array([1.]), np.array([2.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_rqk = list(product(sigma, alpha, n_features, n_instances, trainable)) +n_tests_rqk = len(tests_rqk) + + +@pytest.fixture +def rationalquadratic_kernel_params(request): + return tests_rqk[request.param] + + +@pytest.mark.parametrize('rationalquadratic_kernel_params', list(range(n_tests_rqk)), indirect=True) +def test_rationalquadratic_kernel(rationalquadratic_kernel_params): + sigma, alpha, n_features, n_instances, trainable = rationalquadratic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + sigma = sigma if sigma is None else torch.from_numpy(sigma) + alpha = alpha if alpha is None else torch.from_numpy(alpha) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + kernel = RationalQuadratic(sigma=sigma, alpha=alpha, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma = [None, np.array([1.]), np.array([2.])] +tau = [None, np.array([8.]), np.array([24.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_pk = list(product(sigma, tau, n_features, n_instances, trainable)) +n_tests_pk = len(tests_pk) + + +@pytest.fixture +def periodic_kernel_params(request): + return tests_pk[request.param] + + +@pytest.mark.parametrize('periodic_kernel_params', list(range(n_tests_pk)), indirect=True) +def test_periodic_kernel(periodic_kernel_params): + sigma, tau, n_features, n_instances, trainable = periodic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + sigma = sigma if sigma is None else torch.from_numpy(sigma) + tau = tau if tau is None else torch.from_numpy(tau) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + kernel = Periodic(sigma=sigma, tau=tau, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma_0 = [None, np.array([1.])] +sigma_1 = [None, np.array([1.])] +sigma_2 = [None, np.array([1.])] +operation_0 = ['*', '+'] +operation_1 = ['*', '+'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_ck = list(product(sigma_0, sigma_1, sigma_2, + operation_0, operation_1, n_features, n_instances, trainable)) +n_tests_ck = len(tests_ck) + + +@pytest.fixture +def comp_kernel_params(request): + return tests_ck[request.param] + + +@pytest.mark.parametrize('comp_kernel_params', list(range(n_tests_ck)), indirect=True) +def test_comp_kernel(comp_kernel_params): + (sigma_0, sigma_1, sigma_2, operation_0, operation_1, + n_features, n_instances, trainable) = comp_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + sigma_0 = sigma_0 if sigma_0 is None else torch.from_numpy(sigma_0) + sigma_1 = sigma_1 if sigma_1 is None else torch.from_numpy(sigma_1) + sigma_2 = sigma_2 if sigma_2 is None else torch.from_numpy(sigma_2) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + kernel_0 = GaussianRBF(sigma=sigma_0, trainable=trainable) + kernel_1 = GaussianRBF(sigma=sigma_1, trainable=trainable) + kernel_2 = GaussianRBF(sigma=sigma_2, trainable=trainable) + if operation_0 == '*' and operation_1 == '*': + kernel = kernel_0 * kernel_1 * kernel_2 + elif operation_0 == '*' and operation_1 == '+': + kernel = (kernel_0 * kernel_1 + kernel_2) / torch.tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '*': + kernel = (kernel_0 + kernel_1 * kernel_2) / torch.tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '+': + kernel = (kernel_0 + kernel_1 + kernel_2) / torch.tensor(3.0) # ensure k(x, x) = 1 + else: + with pytest.raises(Exception): + raise Exception('Invalid operation') + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).detach().numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).detach().numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index 13a302d92..ca8badf1a 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -10,7 +10,7 @@ GaussianRBF, DeepKernel = import_optional( 'alibi_detect.utils.tensorflow.kernels', - names=['GaussianRBF', 'DeepKernel, BaseKernel'] + names=['GaussianRBF', 'DeepKernel, BaseKernel, RationalQuadratic, Periodic'] ) diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index edad5dfd3..f73c7c302 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -3,7 +3,7 @@ import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input -from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel +from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -38,6 +38,126 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +sigma = [None, np.array([1.]), np.array([2.])] +alpha = [None, np.array([1.]), np.array([2.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_rqk = list(product(sigma, alpha, n_features, n_instances, trainable)) +n_tests_rqk = len(tests_rqk) + + +@pytest.fixture +def rationalquadratic_kernel_params(request): + return tests_rqk[request.param] + + +@pytest.mark.parametrize('rationalquadratic_kernel_params', list(range(n_tests_rqk)), indirect=True) +def test_rationalquadratic_kernel(rationalquadratic_kernel_params): + sigma, alpha, n_features, n_instances, trainable = rationalquadratic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + kernel = RationalQuadratic(sigma=sigma, alpha=alpha, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma = [None, np.array([1.]), np.array([2.])] +tau = [None, np.array([8.]), np.array([24.])] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_pk = list(product(sigma, tau, n_features, n_instances, trainable)) +n_tests_pk = len(tests_pk) + + +@pytest.fixture +def periodic_kernel_params(request): + return tests_pk[request.param] + + +@pytest.mark.parametrize('periodic_kernel_params', list(range(n_tests_pk)), indirect=True) +def test_periodic_kernel(periodic_kernel_params): + sigma, tau, n_features, n_instances, trainable = periodic_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + kernel = Periodic(sigma=sigma, tau=tau, trainable=trainable) + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + +sigma_0 = [None, np.array([1.])] +sigma_1 = [None, np.array([1.])] +sigma_2 = [None, np.array([1.])] +operation_0 = ['*', '+'] +operation_1 = ['*', '+'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +tests_ck = list(product(sigma_0, sigma_1, sigma_2, + operation_0, operation_1, n_features, n_instances, trainable)) +n_tests_ck = len(tests_ck) + + +@pytest.fixture +def comp_kernel_params(request): + return tests_ck[request.param] + + +@pytest.mark.parametrize('comp_kernel_params', list(range(n_tests_ck)), indirect=True) +def test_comp_kernel(comp_kernel_params): + (sigma_0, sigma_1, sigma_2, operation_0, operation_1, + n_features, n_instances, trainable) = comp_kernel_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + kernel_0 = GaussianRBF(sigma=sigma_0, trainable=trainable) + kernel_1 = GaussianRBF(sigma=sigma_1, trainable=trainable) + kernel_2 = GaussianRBF(sigma=sigma_2, trainable=trainable) + if operation_0 == '*' and operation_1 == '*': + kernel = kernel_0 * kernel_1 * kernel_2 + elif operation_0 == '*' and operation_1 == '+': + kernel = (kernel_0 * kernel_1 + kernel_2) / tf.convert_to_tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '*': + kernel = (kernel_0 + kernel_1 * kernel_2) / tf.convert_to_tensor(2.0) # ensure k(x, x) = 1 + elif operation_0 == '+' and operation_1 == '+': + kernel = (kernel_0 + kernel_1 + kernel_2) / tf.convert_to_tensor(3.0) # ensure k(x, x) = 1 + else: + with pytest.raises(Exception): + raise Exception('Invalid operation') + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=infer_parameter) + else: + k_xy = kernel(x, y, infer_parameter=infer_parameter).numpy() + k_xx = kernel(x, x, infer_parameter=infer_parameter).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + + class MyKernel(BaseKernel): # TODO: Support then test models using keras functional API def __init__(self, n_features: int): super().__init__() diff --git a/doc/source/examples/cd_combined_kernel.ipynb b/doc/source/examples/cd_combined_kernel.ipynb index 6742c5d9d..773fa9aed 100644 --- a/doc/source/examples/cd_combined_kernel.ipynb +++ b/doc/source/examples/cd_combined_kernel.ipynb @@ -13,14 +13,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:30.140646Z", - "iopub.status.busy": "2022-08-17T22:48:30.139694Z", - "iopub.status.idle": "2022-08-17T22:48:42.261216Z", - "shell.execute_reply": "2022-08-17T22:48:42.258215Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -46,14 +39,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.268753Z", - "iopub.status.busy": "2022-08-17T22:48:42.267268Z", - "iopub.status.idle": "2022-08-17T22:48:42.287665Z", - "shell.execute_reply": "2022-08-17T22:48:42.283443Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "def get_sin(N):\n", @@ -74,14 +60,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.296254Z", - "iopub.status.busy": "2022-08-17T22:48:42.295141Z", - "iopub.status.idle": "2022-08-17T22:48:42.307361Z", - "shell.execute_reply": "2022-08-17T22:48:42.304563Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "x_ref, x_test = get_sin(N=1000)" @@ -97,14 +76,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.315487Z", - "iopub.status.busy": "2022-08-17T22:48:42.314280Z", - "iopub.status.idle": "2022-08-17T22:48:42.627643Z", - "shell.execute_reply": "2022-08-17T22:48:42.626213Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -118,7 +90,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -173,10 +145,10 @@ "data": { "text/plain": [ "{'data': {'is_drift': 0,\n", - " 'distance': 0.0006610155,\n", - " 'p_val': 0.24,\n", + " 'distance': -0.000772655,\n", + " 'p_val': 0.8,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': 0.0027906895},\n", + " 'distance_threshold': 0.0021861196},\n", " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", @@ -204,51 +176,23 @@ { "cell_type": "code", "execution_count": 8, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.633012Z", - "iopub.status.busy": "2022-08-17T22:48:42.632420Z", - "iopub.status.idle": "2022-08-17T22:48:42.663421Z", - "shell.execute_reply": "2022-08-17T22:48:42.661867Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "if backend == 'pytorch':\n", " Kernel_0 = Periodic(tau=torch.tensor([24.0]), active_dims=[0])\n", " Kernel_1 = GaussianRBF(active_dims=[1])\n", + " Kernel_avg = (Kernel_0 + Kernel_1) / torch.tensor(2.0)\n", "elif backend == 'tensorflow':\n", " Kernel_0 = Periodic(tau=tf.convert_to_tensor([24.0]), active_dims=[0])\n", - " Kernel_1 = GaussianRBF(active_dims=[1])" + " Kernel_1 = GaussianRBF(active_dims=[1])\n", + " Kernel_avg = (Kernel_0 + Kernel_1) / tf.convert_to_tensor(2.0)" ] }, { "cell_type": "code", "execution_count": 9, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.682278Z", - "iopub.status.busy": "2022-08-17T22:48:42.681366Z", - "iopub.status.idle": "2022-08-17T22:48:42.695138Z", - "shell.execute_reply": "2022-08-17T22:48:42.692762Z" - } - }, - "outputs": [], - "source": [ - "Kernel_avg = (Kernel_0 + Kernel_1) / 2" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:42.702931Z", - "iopub.status.busy": "2022-08-17T22:48:42.700551Z", - "iopub.status.idle": "2022-08-17T22:48:43.049891Z", - "shell.execute_reply": "2022-08-17T22:48:43.048438Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "cd_avg = MMDDrift(x_ref=x_ref,\n", @@ -265,17 +209,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'data': {'is_drift': 1,\n", - " 'distance': 0.006862521,\n", + " 'distance': 0.0052251816,\n", " 'p_val': 0.0,\n", " 'threshold': 0.05,\n", - " 'distance_threshold': 0.0007869005},\n", + " 'distance_threshold': 0.0009160042},\n", " 'meta': {'name': 'MMDDriftTF',\n", " 'detector_type': 'offline',\n", " 'data_type': None,\n", @@ -283,7 +227,7 @@ " 'backend': 'tensorflow'}}" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -302,23 +246,16 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:43.055921Z", - "iopub.status.busy": "2022-08-17T22:48:43.055518Z", - "iopub.status.idle": "2022-08-17T22:48:43.064586Z", - "shell.execute_reply": "2022-08-17T22:48:43.063483Z" - } - }, + "execution_count": 11, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "ListWrapper([, 0.5])\n", - "ListWrapper([, 0.5])\n" + "\n", + "ListWrapper([, ])\n", + "ListWrapper([, ])\n" ] } ], @@ -330,22 +267,15 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:44.915230Z", - "iopub.status.busy": "2022-08-17T22:48:44.914553Z", - "iopub.status.idle": "2022-08-17T22:48:44.924660Z", - "shell.execute_reply": "2022-08-17T22:48:44.923360Z" - } - }, + "execution_count": 12, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tf.Tensor([24.], shape=(1,), dtype=float32)\n", - "tf.Tensor([34.31387], shape=(1,), dtype=float32)\n" + "tf.Tensor([34.68171], shape=(1,), dtype=float32)\n" ] } ], @@ -356,21 +286,14 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:44.928919Z", - "iopub.status.busy": "2022-08-17T22:48:44.928266Z", - "iopub.status.idle": "2022-08-17T22:48:44.938336Z", - "shell.execute_reply": "2022-08-17T22:48:44.936929Z" - } - }, + "execution_count": 13, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tf.Tensor([0.50738114], shape=(1,), dtype=float32)\n" + "tf.Tensor([0.5185638], shape=(1,), dtype=float32)\n" ] } ], @@ -388,7 +311,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -403,11 +326,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" - } } }, "nbformat": 4, diff --git a/doc/source/examples/cd_create_customised_kernel.ipynb b/doc/source/examples/cd_create_customised_kernel.ipynb index 1eca99936..c3a8052aa 100644 --- a/doc/source/examples/cd_create_customised_kernel.ipynb +++ b/doc/source/examples/cd_create_customised_kernel.ipynb @@ -12,14 +12,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "execution": { - "iopub.execute_input": "2022-08-17T22:48:30.140646Z", - "iopub.status.busy": "2022-08-17T22:48:30.139694Z", - "iopub.status.idle": "2022-08-17T22:48:42.261216Z", - "shell.execute_reply": "2022-08-17T22:48:42.258215Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -348,7 +341,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -363,11 +356,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" - }, - "vscode": { - "interpreter": { - "hash": "0bf6813663e5d6a57041ced0b693fc8c95fc127f42096670cce7c717570a4162" - } } }, "nbformat": 4, From 8af1c518754bb000f55a3fef44a750f46174489f Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 17 Oct 2022 01:12:02 +0100 Subject: [PATCH 30/37] Address reviewer comments on: (1) doc string, (2) outdated comments, (3) type hints and (4) misc fixes. --- alibi_detect/cd/base.py | 7 -- alibi_detect/cd/pytorch/context_aware.py | 5 - alibi_detect/cd/pytorch/lsdd.py | 14 --- alibi_detect/cd/pytorch/lsdd_online.py | 11 -- alibi_detect/cd/pytorch/mmd.py | 8 -- alibi_detect/cd/pytorch/mmd_online.py | 7 -- alibi_detect/cd/tensorflow/context_aware.py | 5 - alibi_detect/cd/tensorflow/lsdd.py | 13 --- alibi_detect/cd/tensorflow/lsdd_online.py | 9 -- alibi_detect/cd/tensorflow/mmd.py | 8 -- alibi_detect/cd/tensorflow/mmd_online.py | 7 -- alibi_detect/utils/pytorch/kernels.py | 105 ++++++++++++++------ alibi_detect/utils/tensorflow/__init__.py | 2 + alibi_detect/utils/tensorflow/kernels.py | 90 ++++++++++++++--- 14 files changed, 155 insertions(+), 136 deletions(-) diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index b0604c25e..73ce558d1 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -508,7 +508,6 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -554,12 +553,6 @@ def __init__( logger.warning('No p-value set for the drift threshold. Need to set it to detect data drift.') self.infer_parameter = configure_kernel_from_x_ref - # self.infer_sigma = configure_kernel_from_x_ref - # if configure_kernel_from_x_ref and isinstance(sigma, np.ndarray): - # self.infer_sigma = False - # logger.warning('`sigma` is specified for the kernel and `configure_kernel_from_x_ref` ' - # 'is set to True. `sigma` argument takes priority over ' - # '`configure_kernel_from_x_ref` (set to False).') # x_ref preprocessing self.preprocess_at_init = preprocess_at_init diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index 91c5f69a0..a5bc5bc45 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -49,9 +49,7 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # x_kernel: Callable = GaussianRBF, x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), - # c_kernel: Callable = GaussianRBF, c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, @@ -132,9 +130,6 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel self.x_kernel = x_kernel self.c_kernel = c_kernel diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 3250be11e..4f08095ee 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -19,8 +19,6 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -78,8 +76,6 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, - # kernel=kernel, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -100,21 +96,12 @@ def __init__( x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - # def _initialize_kernel(self, x_ref: torch.Tensor): - # if self.sigma is None: - # self.kernel = GaussianRBF() - # _ = self.kernel(x_ref, x_ref, infer_sigma=True) - # else: - # sigma = torch.from_numpy(self.sigma) - # self.kernel = GaussianRBF(sigma) - def _configure_normalization(self, x_ref: torch.Tensor, eps: float = 1e-12): x_ref_means = x_ref.mean(0) x_ref_stds = x_ref.std(0) @@ -155,7 +142,6 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_at_init is False and not self.x_ref_preprocessed: self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) # type: ignore[arg-type] self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index 72e64c7d8..3195d15a9 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -18,8 +18,6 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -95,15 +93,6 @@ def __init__( self._configure_normalization() - # initialize kernel - # if sigma is None: - # x_ref = torch.from_numpy(self.x_ref).to(self.device) # type: ignore[assignment] - # self.kernel = GaussianRBF() - # _ = self.kernel(x_ref, x_ref, infer_sigma=True) - # else: - # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - # np.ndarray) else None - # self.kernel = GaussianRBF(sigma) # type: ignore[arg-type] self.kernel = GaussianRBF() if self.n_kernel_centers is None: diff --git a/alibi_detect/cd/pytorch/mmd.py b/alibi_detect/cd/pytorch/mmd.py index fe5c9fbe0..ff2e394e9 100644 --- a/alibi_detect/cd/pytorch/mmd.py +++ b/alibi_detect/cd/pytorch/mmd.py @@ -22,9 +22,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # kernel: Callable = GaussianRBF, kernel: BaseKernel = GaussianRBF(), - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -77,7 +75,6 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -88,14 +85,9 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - # np.ndarray) else None - # self.kernel = kernel(sigma).to(self.device) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data - # if self.infer_sigma or isinstance(sigma, torch.Tensor): if self.infer_parameter: x = torch.from_numpy(self.x_ref).to(self.device) self.k_xx = self.kernel(x, x, infer_parameter=self.infer_parameter) diff --git a/alibi_detect/cd/pytorch/mmd_online.py b/alibi_detect/cd/pytorch/mmd_online.py index 9e0491994..9ad49e8f7 100644 --- a/alibi_detect/cd/pytorch/mmd_online.py +++ b/alibi_detect/cd/pytorch/mmd_online.py @@ -18,8 +18,6 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: BaseKernel = GaussianRBF(), - # kernel: Callable = GaussianRBF, - # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -82,15 +80,10 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - # sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - # np.ndarray) else None - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data self.x_ref = torch.from_numpy(self.x_ref).to(self.device) - # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index f2f0ed10f..a581eafb6 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -49,9 +49,7 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # x_kernel: Callable = GaussianRBF, x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), - # c_kernel: Callable = GaussianRBF, c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, @@ -125,9 +123,6 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - # initialize kernel - # self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel - # self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel self.x_kernel = x_kernel self.c_kernel = c_kernel diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index 0a8916ee8..39060104d 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -18,8 +18,6 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -73,7 +71,6 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, n_permutations=n_permutations, n_kernel_centers=n_kernel_centers, lambda_rd_max=lambda_rd_max, @@ -87,21 +84,12 @@ def __init__( x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc. self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) - # def _initialize_kernel(self, x_ref: tf.Tensor): - # if self.sigma is None: - # self.kernel = GaussianRBF() - # _ = self.kernel(x_ref, x_ref, infer_sigma=True) - # else: - # sigma = tf.convert_to_tensor(self.sigma) - # self.kernel = GaussianRBF(sigma) - def _configure_normalization(self, x_ref: tf.Tensor, eps: float = 1e-12): x_ref_means = tf.reduce_mean(x_ref, axis=0) x_ref_stds = tf.math.reduce_std(x_ref, axis=0) @@ -139,7 +127,6 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and not self.preprocess_at_init and not self.x_ref_preprocessed: self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - # self._initialize_kernel(x_ref) self._configure_kernel_centers(x_ref) self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index a181c6216..63316fc57 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -16,8 +16,6 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = GaussianRBF(), n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -86,13 +84,6 @@ def __init__( self._configure_normalization() - # initialize kernel - # if sigma is None: - # self.kernel = GaussianRBF() - # _ = self.kernel(self.x_ref, self.x_ref, infer_sigma=True) - # else: - # sigma = tf.convert_to_tensor(sigma) - # self.kernel = GaussianRBF(sigma) self.kernel = GaussianRBF() if self.n_kernel_centers is None: diff --git a/alibi_detect/cd/tensorflow/mmd.py b/alibi_detect/cd/tensorflow/mmd.py index 2eb4b46e4..6bc28a6a5 100644 --- a/alibi_detect/cd/tensorflow/mmd.py +++ b/alibi_detect/cd/tensorflow/mmd.py @@ -21,9 +21,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # kernel: Callable = GaussianRBF, kernel: BaseKernel = GaussianRBF(), - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -72,7 +70,6 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - # sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -80,13 +77,8 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - # initialize kernel - # if isinstance(sigma, np.ndarray): - # sigma = tf.convert_to_tensor(sigma) - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data - # if self.infer_sigma or isinstance(sigma, tf.Tensor): if self.infer_parameter: self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.infer_parameter) self.infer_sigma = False diff --git a/alibi_detect/cd/tensorflow/mmd_online.py b/alibi_detect/cd/tensorflow/mmd_online.py index f253ff473..6802bab2f 100644 --- a/alibi_detect/cd/tensorflow/mmd_online.py +++ b/alibi_detect/cd/tensorflow/mmd_online.py @@ -17,8 +17,6 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: BaseKernel = GaussianRBF(), - # kernel: Callable = GaussianRBF, - # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, verbose: bool = True, input_shape: Optional[tuple] = None, @@ -74,14 +72,9 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - # initialize kernel - # if isinstance(sigma, np.ndarray): - # sigma = tf.convert_to_tensor(sigma) - # self.kernel = kernel(sigma) if kernel == GaussianRBF else kernel self.kernel = kernel # compute kernel matrix for the reference data - # self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_sigma=(sigma is None)) self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) self._configure_thresholds() diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 351b01d3b..b2f914d33 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -1,3 +1,4 @@ +from abc import abstractmethod import numpy as np import torch from torch import nn @@ -7,7 +8,13 @@ from alibi_detect.utils.frameworks import Framework -def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): +def infer_kernel_parameter( + kernel: 'BaseKernel', + x: torch.Tensor, + y: torch.Tensor, + dist: torch.Tensor, + infer_parameter: bool = True +) -> None: """ Infer the kernel parameter from the data. @@ -60,10 +67,6 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. class KernelParameter: - """ - Parameter class for kernels. - """ - def __init__( self, value: torch.Tensor = None, @@ -71,6 +74,20 @@ def __init__( requires_grad: bool = False, requires_init: bool = False ) -> None: + """ + Parameter class for kernels. + + Parameters + ---------- + value + The pre-specified value of the parameter. + init_fn + The function used to initialize the parameter. + requires_grad + Whether the parameter requires gradient. + requires_init + Whether the parameter requires initialization. + """ super().__init__() self.value = nn.Parameter(value if value is not None else torch.ones(1), requires_grad=requires_grad) @@ -79,10 +96,17 @@ def __init__( class BaseKernel(nn.Module): - """ - The base class for all kernels. - """ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + """ + The base class for all kernels. + + Parameters + ---------- + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. + """ super().__init__() self.parameter_dict: dict = {} if active_dims is not None: @@ -92,6 +116,7 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.feature_axis = feature_axis self.init_required = False + @abstractmethod def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], infer_parameter: Optional[bool] = False) -> torch.Tensor: raise NotImplementedError @@ -167,14 +192,11 @@ def __rsub__(self, other): raise ValueError('Kernels do not support substraction.') -class SumKernel(nn.Module): - """ - Construct a kernel by summing different kernels. - - Parameters: - ---------------- - """ +class SumKernel(torch.nn.Module): def __init__(self) -> None: + """ + Construct a kernel by summing different kernels. + """ super().__init__() self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] @@ -246,8 +268,11 @@ def __rsub__(self, other): raise ValueError('Kernels do not support substraction.') -class ProductKernel(nn.Module): +class ProductKernel(torch.nn.Module): def __init__(self) -> None: + """ + Construct a kernel by multiplying different kernels. + """ super().__init__() self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] @@ -351,6 +376,10 @@ def __init__( :func:`~alibi_detect.utils.pytorch.kernels.sigma_median`. trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma @@ -426,8 +455,18 @@ def __init__( ---------- alpha Exponent parameter of the kernel. + init_alpha_fn + Function used to compute the exponent parameter `alpha`. Used when `alpha` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( @@ -489,8 +528,18 @@ def __init__( ---------- tau Period of the periodic kernel. + init_tau_fn + Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( @@ -531,23 +580,23 @@ def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarra class ProjKernel(BaseKernel): - """ - A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as - k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and - y [Ny, features] and returns the kernel matrix [Nx, Ny]. - - Parameters: - ---------- - proj - The projection to be applied to the inputs before applying raw_kernel - raw_kernel - The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. - """ def __init__( self, proj: nn.Module, raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: + """ + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. + + Parameters: + ---------- + proj + The projection to be applied to the inputs before applying raw_kernel + raw_kernel + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + """ super().__init__() self.proj = proj self.raw_kernel = raw_kernel diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index ca8badf1a..39d6105f8 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -46,6 +46,8 @@ "squared_pairwise_distance", "GaussianRBF", "BaseKernel", + "RationalQuadratic", + "Periodic", "DeepKernel", "permed_lsdds", "predict_batch", diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 93b665909..47966c249 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -1,3 +1,4 @@ +from abc import abstractmethod import tensorflow as tf import numpy as np from . import distance @@ -7,7 +8,13 @@ from alibi_detect.utils.frameworks import Framework -def infer_kernel_parameter(kernel, x, y, dist, infer_parameter): +def infer_kernel_parameter( + kernel: 'BaseKernel', + x: tf.Tensor, + y: tf.Tensor, + dist: tf.Tensor, + infer_parameter: bool = True, +) -> None: """ Infer the kernel parameter from the data. @@ -58,10 +65,7 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: return tf.math.log(sigma) -class KernelParameter(object): - """ - Parameter class for kernels. - """ +class KernelParameter: def __init__( self, value: tf.Tensor = None, @@ -69,6 +73,20 @@ def __init__( requires_grad: bool = False, requires_init: bool = False ) -> None: + """ + Parameter class for kernels. + + Parameters + ---------- + value + The pre-specified value of the parameter. If `None`, the parameter is set to 1 by default. + init_fn + The function used to initialize the parameter. + requires_grad + Whether the parameter requires gradient. + requires_init + Whether the parameter requires initialization. + """ self.value = tf.Variable(value if value is not None else tf.ones(1, dtype=tf.keras.backend.floatx()), trainable=requires_grad) @@ -80,16 +98,24 @@ def __repr__(self) -> str: class BaseKernel(tf.keras.Model): - """ - The base class for all kernels. - """ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + """ + The base class for all kernels. + + Parameters + ---------- + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. + """ super().__init__() self.parameter_dict: dict = {} self.active_dims = active_dims self.feature_axis = feature_axis self.init_required = False + @abstractmethod def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: Optional[bool] = False) -> tf.Tensor: return NotImplementedError @@ -162,13 +188,10 @@ def __rsub__(self, other): class SumKernel(tf.keras.Model): - """ - Construct a kernel by summing different kernels. - - Parameters: - ---------------- - """ def __init__(self) -> None: + """ + Construct a kernel by summing different kernels. + """ super().__init__() self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] @@ -242,6 +265,9 @@ def __rsub__(self, other): class ProductKernel(tf.keras.Model): def __init__(self) -> None: + """ + Construct a kernel by multiplying different kernels. + """ super().__init__() self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] @@ -345,6 +371,10 @@ def __init__( :func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. trainable Whether or not to track gradients w.r.t. sigma to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma @@ -420,8 +450,18 @@ def __init__( ---------- alpha Exponent parameter of the kernel. + init_alpha_fn + Function used to compute the exponent parameter `alpha`. Used when `alpha` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['alpha'] = KernelParameter( @@ -483,8 +523,18 @@ def __init__( ---------- tau Period of the periodic kernel. + init_tau_fn + Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. + init_sigma_fn + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. + trainable + Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ super().__init__(active_dims, feature_axis) self.parameter_dict['log-tau'] = KernelParameter( @@ -532,6 +582,18 @@ def __init__( proj: tf.keras.Model, raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: + """ + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. + + Parameters: + ---------- + proj + The projection to be applied to the inputs before applying raw_kernel + raw_kernel + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + """ super().__init__() self.proj = proj self.raw_kernel = raw_kernel From bdad9d350acd4143f599de50d2783867ada92cb7 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 11 Nov 2022 09:35:36 +0000 Subject: [PATCH 31/37] Address some discussion and comments from the reviewer, mainly on : (1) modify the type of composite kernels as BaseKernel, and change the type signatures accordingly. (2) remove the feature dimension option in BaseKernel. (3) add specific tests on parameter inference. (4) remove numpy inputs from kernels with pytorch backend. (5) misc minor fixes following previous comments. --- alibi_detect/cd/_domain_clf.py | 29 ++-- alibi_detect/cd/base.py | 3 - alibi_detect/cd/context_aware.py | 2 - alibi_detect/cd/lsdd.py | 2 - alibi_detect/cd/lsdd_online.py | 2 - alibi_detect/cd/mmd.py | 1 - alibi_detect/cd/mmd_online.py | 1 - alibi_detect/cd/pytorch/context_aware.py | 15 +- alibi_detect/cd/pytorch/lsdd.py | 5 +- alibi_detect/cd/tensorflow/context_aware.py | 15 +- alibi_detect/cd/tensorflow/lsdd.py | 5 +- alibi_detect/utils/pytorch/__init__.py | 3 +- alibi_detect/utils/pytorch/distance.py | 4 +- alibi_detect/utils/pytorch/kernels.py | 161 +++++++++--------- alibi_detect/utils/pytorch/prediction.py | 2 + .../utils/pytorch/tests/test_kernels_pt.py | 52 +++++- alibi_detect/utils/tensorflow/__init__.py | 3 +- alibi_detect/utils/tensorflow/kernels.py | 108 ++++++------ .../utils/tensorflow/tests/test_kernels_tf.py | 52 +++++- 19 files changed, 287 insertions(+), 178 deletions(-) diff --git a/alibi_detect/cd/_domain_clf.py b/alibi_detect/cd/_domain_clf.py index 84e540e7d..942ef43fe 100644 --- a/alibi_detect/cd/_domain_clf.py +++ b/alibi_detect/cd/_domain_clf.py @@ -1,5 +1,4 @@ from abc import ABC, abstractmethod -from typing import Callable import numpy as np from sklearn.svm import SVC from sklearn.calibration import CalibratedClassifierCV @@ -34,7 +33,6 @@ def predict(self, x: np.ndarray) -> np.ndarray: class _SVCDomainClf(_DomainClf): def __init__(self, - kernel: Callable, cal_method: str = 'sigmoid', clf_kwargs: dict = None): """ @@ -52,52 +50,51 @@ def __init__(self, clf_kwargs A dictionary of keyword arguments to be passed to the :py:class:`~sklearn.svm.SVC` classifier. """ - self.kernel = kernel self.cal_method = cal_method clf_kwargs = clf_kwargs or {} - self.clf = SVC(kernel=self.kernel, **clf_kwargs) + self.clf = SVC(kernel='precomputed', **clf_kwargs) - def fit(self, x: np.ndarray, y: np.ndarray): + def fit(self, K_x: np.ndarray, y: np.ndarray): """ Method to fit the classifier. Parameters ---------- - x - Array containing conditioning variables for each instance. + K_x + Kernel matrix on the conditioning variables. y Boolean array marking the domain each instance belongs to (`0` for reference, `1` for test). """ clf = self.clf - clf.fit(x, y) + clf.fit(K_x, y) self.clf = clf - def calibrate(self, x: np.ndarray, y: np.ndarray): + def calibrate(self, K_x: np.ndarray, y: np.ndarray): """ Method to calibrate the classifier's predicted probabilities. Parameters ---------- - x - Array containing conditioning variables for each instance. + K_x + Kernel matrix on the conditioning variables. y Boolean array marking the domain each instance belongs to (`0` for reference, `1` for test). """ clf = CalibratedClassifierCV(self.clf, method=self.cal_method, cv='prefit') - clf.fit(x, y) + clf.fit(K_x, y) self.clf = clf - def predict(self, x: np.ndarray) -> np.ndarray: + def predict(self, K_x: np.ndarray) -> np.ndarray: """ The classifier's predict method. Parameters ---------- - x - Array containing conditioning variables for each instance. + K_x + Kernel matrix on the conditioning variables. Returns ------- Propensity scores (the probability of being test instances). """ - return self.clf.predict_proba(x)[:, 1] + return self.clf.predict_proba(K_x)[:, 1] diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index 73ce558d1..82d7ac7b7 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -662,8 +662,6 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # kernel: BaseKernel = None, - # sigma: Optional[np.ndarray] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -726,7 +724,6 @@ def __init__( # Other attributes self.p_val = p_val - # self.sigma = sigma self.update_x_ref = update_x_ref self.preprocess_fn = preprocess_fn self.n = len(x_ref) diff --git a/alibi_detect/cd/context_aware.py b/alibi_detect/cd/context_aware.py index ef27cd5ef..f21b4febe 100644 --- a/alibi_detect/cd/context_aware.py +++ b/alibi_detect/cd/context_aware.py @@ -27,9 +27,7 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # x_kernel: Callable = None, x_kernel: BaseKernel = None, - # c_kernel: Callable = None, c_kernel: BaseKernel = None, n_permutations: int = 1000, prop_c_held: float = 0.25, diff --git a/alibi_detect/cd/lsdd.py b/alibi_detect/cd/lsdd.py index dec318eb3..8e7723475 100644 --- a/alibi_detect/cd/lsdd.py +++ b/alibi_detect/cd/lsdd.py @@ -22,8 +22,6 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index c1fc1ee6c..36a82026c 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -18,8 +18,6 @@ def __init__( backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - # sigma: Optional[np.ndarray] = None, - # kernel: BaseKernel = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 567a03c80..58782fdf5 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -29,7 +29,6 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: Callable = None, - # sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, batch_size_permutations: int = 1000000, diff --git a/alibi_detect/cd/mmd_online.py b/alibi_detect/cd/mmd_online.py index 90ae24c95..027c0b973 100644 --- a/alibi_detect/cd/mmd_online.py +++ b/alibi_detect/cd/mmd_online.py @@ -22,7 +22,6 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: Optional[Union[BaseKernelTorch, BaseKernelTF]] = None, - # sigma: Optional[np.ndarray] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index a5bc5bc45..4c0a14b22 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -133,9 +133,6 @@ def __init__( self.x_kernel = x_kernel self.c_kernel = c_kernel - # Initialize classifier (hardcoded for now) - self.clf = _SVCDomainClf(self.c_kernel) - def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: """ @@ -159,6 +156,9 @@ def score(self, # type: ignore[override] x_ref = torch.from_numpy(x_ref).to(self.device) # type: ignore[assignment] c_ref = torch.from_numpy(self.c_ref).to(self.device) # type: ignore[assignment] + # Initialize classifier (hardcoded for now) + self.clf = _SVCDomainClf() + # Hold out a portion of contexts for conditioning on n, n_held = len(c), int(len(c)*self.prop_c_held) inds_held = np.random.choice(n, n_held, replace=False) @@ -177,12 +177,13 @@ def score(self, # type: ignore[override] L_held = self.c_kernel(c_held, c_all) # Fit and calibrate the domain classifier - c_all_np, bools_np = c_all.cpu().numpy(), bools.cpu().numpy() - self.clf.fit(c_all_np, bools_np) - self.clf.calibrate(c_all_np, bools_np) + bools_np = bools.cpu().numpy() + K_c_all_np = self.c_kernel(c_all, c_all).cpu().numpy() + self.clf.fit(K_c_all_np, bools_np) + self.clf.calibrate(K_c_all_np, bools_np) # Obtain n_permutations conditional reassignments - prop_scores = torch.as_tensor(self.clf.predict(c_all_np)) + prop_scores = torch.as_tensor(self.clf.predict(K_c_all_np)) self.redrawn_bools = [torch.bernoulli(prop_scores) for _ in range(self.n_permutations)] iters = tqdm(self.redrawn_bools, total=self.n_permutations) if self.verbose else self.redrawn_bools diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index 4f08095ee..b0071c4ca 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -91,11 +91,12 @@ def __init__( # in the method signature, so we can't cast it to torch.Tensor unless we change the signature # to also accept torch.Tensor. We also can't redefine it's type as that would involve enabling # --allow-redefinitions in mypy settings (which we might do eventually). - self.kernel = GaussianRBF() if self.preprocess_at_init or self.preprocess_fn is None or self.x_ref_preprocessed: x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) @@ -142,6 +143,8 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and self.preprocess_at_init is False and not self.x_ref_preprocessed: self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index a581eafb6..63c5acdab 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -126,9 +126,6 @@ def __init__( self.x_kernel = x_kernel self.c_kernel = c_kernel - # Initialize classifier (hardcoded for now) - self.clf = _SVCDomainClf(self.c_kernel) - def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: """ @@ -150,6 +147,9 @@ def score(self, # type: ignore[override] """ x_ref, x = self.preprocess(x) + # Initialize classifier (hardcoded for now) + self.clf = _SVCDomainClf() + # Hold out a portion of contexts for conditioning on n, n_held = len(c), int(len(c)*self.prop_c_held) inds_held = np.random.choice(n, n_held, replace=False) @@ -167,12 +167,13 @@ def score(self, # type: ignore[override] L_held = self.c_kernel(c_held, c_all) # Fit and calibrate the domain classifier - c_all_np, bools_np = c_all.numpy(), bools.numpy() - self.clf.fit(c_all_np, bools_np) - self.clf.calibrate(c_all_np, bools_np) + bools_np = bools.numpy() + K_c_all_np = self.c_kernel(c_all, c_all).numpy() + self.clf.fit(K_c_all_np, bools_np) + self.clf.calibrate(K_c_all_np, bools_np) # Obtain n_permutations conditional reassignments - prop_scores = self.clf.predict(c_all_np) + prop_scores = self.clf.predict(K_c_all_np) self.redrawn_bools = [tfp.distributions.Bernoulli(probs=prop_scores).sample() for _ in range(self.n_permutations)] iters = tqdm(self.redrawn_bools, total=self.n_permutations) if self.verbose else self.redrawn_bools diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index 39060104d..d1ef4fb1c 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -79,11 +79,12 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - self.kernel = GaussianRBF() if self.preprocess_at_init or self.preprocess_fn is None or self.x_ref_preprocessed: x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2) @@ -127,6 +128,8 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: if self.preprocess_fn is not None and not self.preprocess_at_init and not self.x_ref_preprocessed: self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) + self.kernel = GaussianRBF() + _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) diff --git a/alibi_detect/utils/pytorch/__init__.py b/alibi_detect/utils/pytorch/__init__.py index 63ec90520..2e920eeb4 100644 --- a/alibi_detect/utils/pytorch/__init__.py +++ b/alibi_detect/utils/pytorch/__init__.py @@ -14,7 +14,7 @@ GaussianRBF, DeepKernel = import_optional( 'alibi_detect.utils.pytorch.kernels', - names=['GaussianRBF', 'DeepKernel, BaseKernel, RationalQuadratic, Periodic'] + names=['GaussianRBF', 'DeepKernel, BaseKernel, RationalQuadratic, Periodic, log_sigma_median'] ) predict_batch, predict_batch_transformer = import_optional( @@ -43,5 +43,6 @@ "get_device", "quantile", "zero_diag", + "log_sigma_median", "TorchDataset" ] diff --git a/alibi_detect/utils/pytorch/distance.py b/alibi_detect/utils/pytorch/distance.py index b5b5e85de..86b1b0aa8 100644 --- a/alibi_detect/utils/pytorch/distance.py +++ b/alibi_detect/utils/pytorch/distance.py @@ -24,8 +24,8 @@ def squared_pairwise_distance(x: torch.Tensor, y: torch.Tensor, a_min: float = 1 ------- Pairwise squared Euclidean distance [Nx, Ny]. """ - x2 = x.pow(2).sum(dim=-1, keepdim=True) - y2 = y.pow(2).sum(dim=-1, keepdim=True) + x2 = torch.square(x).sum(dim=-1, keepdim=True) + y2 = torch.square(y).sum(dim=-1, keepdim=True) dist = torch.addmm(y2.transpose(-2, -1), x, y.transpose(-2, -1), alpha=-2).add_(x2) return dist.clamp_min_(a_min) diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index b2f914d33..dbbeed628 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -57,13 +57,33 @@ def sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch. Returns ------- - The logrithm of the computed bandwidth, `log-sigma`. + The computed bandwidth, `log-sigma`. """ n = min(x.shape[0], y.shape[0]) n = n if (x[:n] == y[:n]).all() and x.shape == y.shape else 0 n_median = n + (np.prod(dist.shape) - n) // 2 - 1 sigma = (.5 * dist.flatten().sort().values[int(n_median)].unsqueeze(dim=-1)) ** .5 - return sigma.log() + return sigma + + +def log_sigma_median(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + """ + Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The logrithm of the computed bandwidth, `log-sigma`. + """ + return torch.log(sigma_median(x, y, dist)) class KernelParameter: @@ -96,7 +116,7 @@ def __init__( class BaseKernel(nn.Module): - def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + def __init__(self, active_dims: list = None) -> None: """ The base class for all kernels. @@ -104,8 +124,6 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: ---------- active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__() self.parameter_dict: dict = {} @@ -113,20 +131,18 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: self.active_dims = torch.as_tensor(active_dims) else: self.active_dims = None - self.feature_axis = feature_axis self.init_required = False @abstractmethod - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: Optional[bool] = False) -> torch.Tensor: raise NotImplementedError - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def forward(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - x, y = torch.as_tensor(x), torch.as_tensor(y) if self.active_dims is not None: - x = torch.index_select(x, self.feature_axis, self.active_dims) - y = torch.index_select(y, self.feature_axis, self.active_dims) + x = torch.index_select(x, -1, self.active_dims) + y = torch.index_select(y, -1, self.active_dims) if len(self.parameter_dict) > 0: return self.kernel_function(x, y, infer_parameter) else: @@ -134,14 +150,12 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch def __add__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] + other: Union['BaseKernel', torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) return other - elif (isinstance(other, BaseKernel) or - isinstance(other, ProductKernel) or - isinstance(other, torch.Tensor)): + elif isinstance(other, (BaseKernel, ProductKernel, torch.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) @@ -149,13 +163,13 @@ def __add__( else: raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: 'BaseKernel') -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', torch.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union['BaseKernel', torch.Tensor] + ) -> 'BaseKernel': if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other @@ -172,11 +186,11 @@ def __mul__( def __rmul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: 'BaseKernel' + ) -> 'BaseKernel': return self.__mul__(other) - def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: torch.Tensor) -> 'BaseKernel': if isinstance(other, torch.Tensor): return self.__mul__(1. / other) else: @@ -186,25 +200,25 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') -class SumKernel(torch.nn.Module): +class SumKernel(BaseKernel): def __init__(self) -> None: """ Construct a kernel by summing different kernels. """ super().__init__() - self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] + self.kernel_list: List[Union[BaseKernel, torch.Tensor]] = [] - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] for k in self.kernel_list: - if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): + if isinstance(k, (BaseKernel, SumKernel, ProductKernel)): value_list.append(k(x, y, infer_parameter)) elif isinstance(k, torch.Tensor): value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) @@ -214,7 +228,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch def __add__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + other: Union[BaseKernel, torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): for k in other.kernel_list: @@ -223,13 +237,13 @@ def __add__( self.kernel_list.append(other) return self - def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: BaseKernel) -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union[BaseKernel, torch.Tensor] + ) -> BaseKernel: if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: @@ -248,11 +262,11 @@ def __mul__( def __rmul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: BaseKernel + ) -> BaseKernel: return self.__mul__(other) - def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: torch.Tensor) -> BaseKernel: if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: @@ -262,22 +276,22 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') -class ProductKernel(torch.nn.Module): +class ProductKernel(BaseKernel): def __init__(self) -> None: """ Construct a kernel by multiplying different kernels. """ super().__init__() - self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, torch.Tensor]] = [] + self.kernel_factors: List[Union[BaseKernel, torch.Tensor]] = [] - def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], - infer_parameter: bool = False) -> torch.Tensor: + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] for k in self.kernel_factors: if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): @@ -290,7 +304,7 @@ def forward(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch def __add__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] + other: Union[BaseKernel, torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) @@ -303,14 +317,14 @@ def __add__( def __radd__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] + other: BaseKernel ) -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', torch.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union[BaseKernel, torch.Tensor] + ) -> BaseKernel: if isinstance(other, SumKernel): sum_kernel = SumKernel() for k in other.kernel_list: @@ -330,11 +344,11 @@ def __mul__( def __rmul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: BaseKernel + ) -> BaseKernel: return self.__mul__(other) - def __truediv__(self, other: torch.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: torch.Tensor) -> BaseKernel: if isinstance(other, torch.Tensor): return self.__mul__(1 / other) else: @@ -344,10 +358,10 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') class GaussianRBF(BaseKernel): @@ -356,8 +370,7 @@ def __init__( sigma: Optional[torch.Tensor] = None, init_fn_sigma: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -381,8 +394,8 @@ def __init__( feature_axis Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) - init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma + super().__init__(active_dims) + init_fn_sigma = log_sigma_median if init_fn_sigma is None else init_fn_sigma self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else None, @@ -397,11 +410,10 @@ def __init__( def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - - x, y = torch.as_tensor(x), torch.as_tensor(y) - dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) # [Nx, Ny] + n_x, n_y = x.shape[0], y.shape[0] + dist = distance.squared_pairwise_distance(x.reshape(n_x, -1), y.reshape(n_y, -1)) # [Nx, Ny] if infer_parameter or self.init_required: infer_kernel_parameter(self, x, y, dist, infer_parameter) @@ -441,10 +453,9 @@ def __init__( alpha: torch.Tensor = None, init_fn_alpha: Callable = None, sigma: torch.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -465,10 +476,8 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['alpha'] = KernelParameter( value=alpha.reshape(-1) if alpha is not None else None, init_fn=init_fn_alpha, @@ -492,10 +501,8 @@ def alpha(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - - x, y = torch.as_tensor(x), torch.as_tensor(y) dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: @@ -514,10 +521,9 @@ def __init__( tau: torch.Tensor = None, init_fn_tau: Callable = None, sigma: torch.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -528,11 +534,11 @@ def __init__( ---------- tau Period of the periodic kernel. - init_tau_fn + init_fn_tau Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. - init_sigma_fn + init_fn_sigma Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. @@ -541,7 +547,7 @@ def __init__( feature_axis Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['log-tau'] = KernelParameter( value=tau.log().reshape(-1) if tau is not None else None, init_fn=init_fn_tau, @@ -565,10 +571,9 @@ def tau(self) -> torch.Tensor: def sigma(self) -> torch.Tensor: return self.parameter_dict['log-sigma'].value.exp() - def kernel_function(self, x: Union[np.ndarray, torch.Tensor], y: Union[np.ndarray, torch.Tensor], + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: - x, y = torch.as_tensor(x), torch.as_tensor(y) - dist = torch.sqrt(distance.squared_pairwise_distance(x.flatten(1), y.flatten(1))) + dist = distance.squared_pairwise_distance(x.flatten(1), y.flatten(1)) if infer_parameter or self.init_required: infer_kernel_parameter(self, x, y, dist, infer_parameter) @@ -659,8 +664,8 @@ def _init_eps(self, eps: Union[float, str]) -> None: def kernel_function( self, - x: Union[np.ndarray, torch.Tensor], - y: Union[np.ndarray, torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, infer_parameter: Optional[bool] = False ) -> torch.Tensor: return self.comp_kernel(x, y, infer_parameter) diff --git a/alibi_detect/utils/pytorch/prediction.py b/alibi_detect/utils/pytorch/prediction.py index 05aded4aa..d8c47dbe2 100644 --- a/alibi_detect/utils/pytorch/prediction.py +++ b/alibi_detect/utils/pytorch/prediction.py @@ -35,6 +35,8 @@ def predict_batch(x: Union[list, np.ndarray, torch.Tensor], model: Union[Callabl Numpy array, torch tensor or tuples of those with model outputs. """ device = get_device(device) + if isinstance(model, nn.Module): + model = model.to(device) if isinstance(x, np.ndarray): x = torch.from_numpy(x) n = len(x) diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index a4f405b54..21129e50e 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -4,7 +4,9 @@ import torch from torch import nn from typing import Union -from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic +from alibi_detect.utils.pytorch import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic, \ + log_sigma_median +from alibi_detect.utils.pytorch.distance import squared_pairwise_distance sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -40,6 +42,54 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +def log_sigma_mean(x: torch.Tensor, y: torch.Tensor, dist: torch.Tensor) -> torch.Tensor: + sigma = (.5 * torch.mean(dist.flatten()) ** .5).unsqueeze(-1) + return torch.log(sigma) + + +kernel_ref = ['GaussianRBF', 'RationalQuadratic', 'Periodic'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +init_fn = [None, log_sigma_median, log_sigma_mean] +tests_init_fn = list(product(kernel_ref, n_features, n_instances, trainable, init_fn)) + + +@pytest.fixture +def init_fn_params(request): + return tests_init_fn[request.param] + + +@pytest.mark.parametrize('init_fn_params', list(range(len(tests_init_fn))), indirect=True) +def test_init_fn(init_fn_params): + kernel_ref, n_features, n_instances, trainable, init_fn = init_fn_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = torch.from_numpy(np.random.random(xshape)).float() + y = torch.from_numpy(np.random.random(yshape)).float() + + if kernel_ref == 'GaussianRBF': + kernel = GaussianRBF(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'RationalQuadratic': + kernel = RationalQuadratic(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'Periodic': + kernel = Periodic(trainable=trainable, init_fn_sigma=init_fn) + else: + raise NotImplementedError + if trainable: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=True) + else: + k_xy = kernel(x, y, infer_parameter=True).numpy() + k_xx = kernel(x, x, infer_parameter=True).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + if init_fn is not None: + np.testing.assert_almost_equal(kernel.sigma.numpy(), + np.exp(init_fn(x, y, squared_pairwise_distance(x, y)).numpy()), + decimal=4) + + sigma = [None, np.array([1.]), np.array([2.])] alpha = [None, np.array([1.]), np.array([2.])] n_features = [5, 10] diff --git a/alibi_detect/utils/tensorflow/__init__.py b/alibi_detect/utils/tensorflow/__init__.py index 39d6105f8..ea65e96e0 100644 --- a/alibi_detect/utils/tensorflow/__init__.py +++ b/alibi_detect/utils/tensorflow/__init__.py @@ -10,7 +10,7 @@ GaussianRBF, DeepKernel = import_optional( 'alibi_detect.utils.tensorflow.kernels', - names=['GaussianRBF', 'DeepKernel, BaseKernel, RationalQuadratic, Periodic'] + names=['GaussianRBF', 'DeepKernel, BaseKernel, RationalQuadratic, Periodic, log_sigma_median'] ) @@ -55,6 +55,7 @@ "quantile", "subset_matrix", "zero_diag", + "log_sigma_median", "mutate_categorical", "TFDataset" ] diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 47966c249..7983a4cef 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -62,7 +62,27 @@ def sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: n = n if tf.reduce_all(x[:n] == y[:n]) and x.shape == y.shape else 0 n_median = n + (tf.math.reduce_prod(dist.shape) - n) // 2 - 1 sigma = tf.expand_dims((.5 * tf.sort(tf.reshape(dist, (-1,)))[n_median]) ** .5, axis=0) - return tf.math.log(sigma) + return sigma + + +def log_sigma_median(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + """ + Bandwidth estimation using the median heuristic :cite:t:`Gretton2012`. + + Parameters + ---------- + x + Tensor of instances with dimension [Nx, features]. + y + Tensor of instances with dimension [Ny, features]. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + + Returns + ------- + The logrithm of the computed bandwidth, `log-sigma`. + """ + return tf.math.log(sigma_median(x, y, dist)) class KernelParameter: @@ -98,7 +118,7 @@ def __repr__(self) -> str: class BaseKernel(tf.keras.Model): - def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: + def __init__(self, active_dims: list = None) -> None: """ The base class for all kernels. @@ -106,13 +126,10 @@ def __init__(self, active_dims: list = None, feature_axis: int = -1) -> None: ---------- active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__() self.parameter_dict: dict = {} self.active_dims = active_dims - self.feature_axis = feature_axis self.init_required = False @abstractmethod @@ -129,14 +146,12 @@ def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf. def __add__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] + other: Union['BaseKernel', tf.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) return other - elif (isinstance(other, BaseKernel) or - isinstance(other, ProductKernel) or - isinstance(other, tf.Tensor)): + elif isinstance(other, (BaseKernel, ProductKernel, tf.Tensor)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) sum_kernel.kernel_list.append(other) @@ -144,13 +159,13 @@ def __add__( else: raise ValueError('Kernels can only added to another kernel or a constant.') - def __radd__(self, other: Union['BaseKernel', 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: 'BaseKernel') -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel', tf.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union['BaseKernel', tf.Tensor] + ) -> 'BaseKernel': if isinstance(other, ProductKernel): other.kernel_factors.append(self) return other @@ -167,8 +182,8 @@ def __mul__( def __rmul__( self, - other: Union['BaseKernel', 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: 'BaseKernel' + ) -> 'BaseKernel': return self.__mul__(other) def __truediv__(self, other: tf.Tensor) -> 'ProductKernel': @@ -181,19 +196,19 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') -class SumKernel(tf.keras.Model): +class SumKernel(BaseKernel): def __init__(self) -> None: """ Construct a kernel by summing different kernels. """ super().__init__() - self.kernel_list: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] + self.kernel_list: List[Union[BaseKernel, tf.Tensor]] = [] def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: @@ -209,7 +224,7 @@ def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], def __add__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] + other: Union[BaseKernel, tf.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): for k in other.kernel_list: @@ -218,13 +233,13 @@ def __add__( self.kernel_list.append(other) return self - def __radd__(self, other: Union[BaseKernel, 'SumKernel', 'ProductKernel']) -> 'SumKernel': + def __radd__(self, other: BaseKernel) -> 'SumKernel': return self.__add__(other) def __mul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel', tf.Tensor] - ) -> Union['SumKernel', 'ProductKernel']: + other: Union[BaseKernel, tf.Tensor] + ) -> BaseKernel: if isinstance(other, SumKernel): sum_kernel = SumKernel() for ki in self.kernel_list: @@ -243,11 +258,11 @@ def __mul__( def __rmul__( self, - other: Union[BaseKernel, 'SumKernel', 'ProductKernel'] - ) -> Union['SumKernel', 'ProductKernel']: + other: BaseKernel + ) -> BaseKernel: return self.__mul__(other) - def __truediv__(self, other: tf.Tensor) -> Union['SumKernel', 'ProductKernel']: + def __truediv__(self, other: tf.Tensor) -> BaseKernel: if isinstance(other, tf.Tensor): return self.__mul__(1 / other) else: @@ -257,10 +272,10 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') class ProductKernel(tf.keras.Model): @@ -339,10 +354,10 @@ def __rtruediv__(self, other): raise ValueError('Kernels can not be used as divisor.') def __sub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') def __rsub__(self, other): - raise ValueError('Kernels do not support substraction.') + raise ValueError('Kernels do not support subtraction.') class GaussianRBF(BaseKernel): @@ -351,8 +366,7 @@ def __init__( sigma: Optional[tf.Tensor] = None, init_fn_sigma: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -373,15 +387,13 @@ def __init__( Whether or not to track gradients w.r.t. sigma to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) - init_fn_sigma = sigma_median if init_fn_sigma is None else init_fn_sigma + super().__init__(active_dims) + init_fn_sigma = log_sigma_median if init_fn_sigma is None else init_fn_sigma self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), init_fn=init_fn_sigma, requires_grad=trainable, requires_init=True if sigma is None else False @@ -436,10 +448,9 @@ def __init__( alpha: tf.Tensor = None, init_fn_alpha: Callable = None, sigma: tf.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -460,10 +471,8 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['alpha'] = KernelParameter( value=tf.reshape( tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, @@ -473,7 +482,7 @@ def __init__( ) self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), init_fn=init_fn_sigma, requires_grad=trainable, requires_init=True if sigma is None else False @@ -509,10 +518,9 @@ def __init__( tau: tf.Tensor = None, init_fn_tau: Callable = None, sigma: tf.Tensor = None, - init_fn_sigma: Callable = sigma_median, + init_fn_sigma: Callable = log_sigma_median, trainable: bool = False, - active_dims: list = None, - feature_axis: int = -1 + active_dims: list = None ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -533,20 +541,18 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ - super().__init__(active_dims, feature_axis) + super().__init__(active_dims) self.parameter_dict['log-tau'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else None, + tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else tf.zeros(1), init_fn=init_fn_tau, requires_grad=trainable, requires_init=True if tau is None else False ) self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( - tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else None, + tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), init_fn=init_fn_sigma, requires_grad=trainable, requires_init=True if sigma is None else False diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index f73c7c302..c339112b8 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -3,7 +3,9 @@ import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input -from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic +from alibi_detect.utils.tensorflow import GaussianRBF, DeepKernel, BaseKernel, RationalQuadratic, Periodic, \ + log_sigma_median +from alibi_detect.utils.tensorflow.distance import squared_pairwise_distance sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -38,6 +40,54 @@ def test_gaussian_kernel(gaussian_kernel_params): assert (k_xx > 0.).all() and (k_xy > 0.).all() +def log_sigma_mean(x: tf.Tensor, y: tf.Tensor, dist: tf.Tensor) -> tf.Tensor: + sigma = tf.expand_dims(.5 * tf.reduce_mean(tf.reshape(dist, (-1,))) ** .5, axis=0) + return tf.math.log(sigma) + + +kernel_ref = ['GaussianRBF', 'RationalQuadratic', 'Periodic'] +n_features = [5, 10] +n_instances = [(100, 100), (100, 75)] +trainable = [True, False] +init_fn = [None, log_sigma_median, log_sigma_mean] +tests_init_fn = list(product(kernel_ref, n_features, n_instances, trainable, init_fn)) + + +@pytest.fixture +def init_fn_params(request): + return tests_init_fn[request.param] + + +@pytest.mark.parametrize('init_fn_params', list(range(len(tests_init_fn))), indirect=True) +def test_init_fn(init_fn_params): + kernel_ref, n_features, n_instances, trainable, init_fn = init_fn_params + xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) + x = tf.convert_to_tensor(np.random.random(xshape).astype('float32')) + y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) + + if kernel_ref == 'GaussianRBF': + kernel = GaussianRBF(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'RationalQuadratic': + kernel = RationalQuadratic(trainable=trainable, init_fn_sigma=init_fn) + elif kernel_ref == 'Periodic': + kernel = Periodic(trainable=trainable, init_fn_sigma=init_fn) + else: + raise NotImplementedError + if trainable: + with pytest.raises(Exception): + kernel(x, y, infer_parameter=True) + else: + k_xy = kernel(x, y, infer_parameter=True).numpy() + k_xx = kernel(x, x, infer_parameter=True).numpy() + assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) + np.testing.assert_almost_equal(k_xx.trace(), xshape[0], decimal=4) + assert (k_xx > 0.).all() and (k_xy > 0.).all() + if init_fn is not None: + np.testing.assert_almost_equal(kernel.sigma.numpy(), + np.exp(init_fn(x, y, squared_pairwise_distance(x, y)).numpy()), + decimal=4) + + sigma = [None, np.array([1.]), np.array([2.])] alpha = [None, np.array([1.]), np.array([2.])] n_features = [5, 10] From be7d9fa693de71aaafef7ed141efe25da9a14475 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Wed, 1 Feb 2023 11:49:37 +0000 Subject: [PATCH 32/37] Initial integrate with the Keops and serialisation --- alibi_detect/cd/context_aware.py | 11 +- alibi_detect/cd/keops/learned_kernel.py | 58 +-- alibi_detect/cd/keops/mmd.py | 53 +- .../keops/tests/test_learned_kernel_keops.py | 30 +- alibi_detect/cd/keops/tests/test_mmd_keops.py | 8 +- alibi_detect/cd/lsdd.py | 1 + alibi_detect/cd/lsdd_online.py | 1 + alibi_detect/cd/mmd.py | 1 + alibi_detect/cd/mmd_online.py | 1 + alibi_detect/cd/pytorch/context_aware.py | 4 +- alibi_detect/cd/pytorch/lsdd.py | 10 +- alibi_detect/cd/pytorch/lsdd_online.py | 6 +- alibi_detect/cd/pytorch/mmd.py | 24 +- alibi_detect/cd/pytorch/mmd_online.py | 8 + alibi_detect/cd/tensorflow/context_aware.py | 4 +- alibi_detect/cd/tensorflow/lsdd.py | 3 +- alibi_detect/cd/tensorflow/lsdd_online.py | 3 +- alibi_detect/cd/tensorflow/mmd.py | 23 +- alibi_detect/cd/tensorflow/mmd_online.py | 7 + alibi_detect/saving/registry.py | 8 +- alibi_detect/saving/tests/models.py | 44 +- alibi_detect/saving/tests/test_saving.py | 44 +- alibi_detect/utils/keops/__init__.py | 8 +- alibi_detect/utils/keops/kernels.py | 487 +++++++++++++++--- .../utils/keops/tests/test_kernels_keops.py | 51 +- alibi_detect/utils/pytorch/kernels.py | 46 +- .../utils/pytorch/tests/test_kernels_pt.py | 6 +- alibi_detect/utils/tensorflow/kernels.py | 20 +- .../utils/tensorflow/tests/test_kernels_tf.py | 6 +- 29 files changed, 748 insertions(+), 228 deletions(-) diff --git a/alibi_detect/cd/context_aware.py b/alibi_detect/cd/context_aware.py index f21b4febe..ff2e193c2 100644 --- a/alibi_detect/cd/context_aware.py +++ b/alibi_detect/cd/context_aware.py @@ -4,7 +4,8 @@ from alibi_detect.utils.frameworks import has_pytorch, has_tensorflow, BackendValidator, Framework from alibi_detect.utils.warnings import deprecated_alias from alibi_detect.base import DriftConfigMixin -from alibi_detect.utils.pytorch.kernels import BaseKernel +from alibi_detect.utils.pytorch.kernels import BaseKernel as BaseKernel_pt +from alibi_detect.utils.tensorflow.kernels import BaseKernel as BaseKernel_tf if has_pytorch: from alibi_detect.cd.pytorch.context_aware import ContextMMDDriftTorch @@ -27,8 +28,8 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: BaseKernel = None, - c_kernel: BaseKernel = None, + x_kernel: Union[BaseKernel_pt, BaseKernel_tf] = None, + c_kernel: Union[BaseKernel_pt, BaseKernel_tf] = None, n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -110,9 +111,9 @@ def __init__( else: from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore[no-redef] if x_kernel is None: - kwargs.update({'x_kernel': GaussianRBF}) + kwargs.update({'x_kernel': GaussianRBF()}) if c_kernel is None: - kwargs.update({'c_kernel': GaussianRBF}) + kwargs.update({'c_kernel': GaussianRBF()}) if backend == Framework.TENSORFLOW: kwargs.pop('device', None) diff --git a/alibi_detect/cd/keops/learned_kernel.py b/alibi_detect/cd/keops/learned_kernel.py index e3073713d..8a6b7d7c2 100644 --- a/alibi_detect/cd/keops/learned_kernel.py +++ b/alibi_detect/cd/keops/learned_kernel.py @@ -2,13 +2,12 @@ from functools import partial from tqdm import tqdm import numpy as np -from pykeops.torch import LazyTensor import torch import torch.nn as nn from torch.utils.data import DataLoader from typing import Callable, Dict, List, Optional, Union, Tuple from alibi_detect.cd.base import BaseLearnedKernelDrift -from alibi_detect.utils.pytorch import get_device, predict_batch +from alibi_detect.utils.pytorch import get_device from alibi_detect.utils.pytorch.data import TorchDataset from alibi_detect.utils.frameworks import Framework @@ -137,6 +136,7 @@ def __init__( self.device = get_device(device) self.original_kernel = kernel self.kernel = deepcopy(kernel) + self.kernel = self.kernel.to(self.device) # Check kernel format self.has_proj = hasattr(self.kernel, 'proj') and isinstance(self.kernel.proj, nn.Module) @@ -174,21 +174,10 @@ def __init__(self, kernel: nn.Module, var_reg: float, has_proj: bool, has_kernel def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: n = len(x) - if self.has_proj and isinstance(self.kernel.proj, nn.Module): - x_proj, y_proj = self.kernel.proj(x), self.kernel.proj(y) - else: - x_proj, y_proj = x, y - x2_proj, x_proj = LazyTensor(x_proj[None, :, :]), LazyTensor(x_proj[:, None, :]) - y2_proj, y_proj = LazyTensor(y_proj[None, :, :]), LazyTensor(y_proj[:, None, :]) - if self.has_kernel_b: - x2, x = LazyTensor(x[None, :, :]), LazyTensor(x[:, None, :]) - y2, y = LazyTensor(y[None, :, :]), LazyTensor(y[:, None, :]) - else: - x, x2, y, y2 = None, None, None, None - k_xy = self.kernel(x_proj, y2_proj, x, y2) - k_xx = self.kernel(x_proj, x2_proj, x, x2) - k_yy = self.kernel(y_proj, y2_proj, y, y2) + k_xy = self.kernel(x, y) + k_xx = self.kernel(x, x) + k_yy = self.kernel(y, y) h_mat = k_xx + k_yy - k_xy - k_xy.t() h_i = h_mat.sum(1).squeeze(-1) @@ -221,6 +210,7 @@ def score(self, x: Union[np.ndarray, list]) -> Tuple[float, float, float]: self.kernel = deepcopy(self.original_kernel) if self.retrain_from_scratch else self.kernel self.kernel = self.kernel.to(self.device) + train_args = [self.j_hat, (dl_ref_tr, dl_cur_tr), self.device] LearnedKernelDriftKeops.trainer(*train_args, **self.train_kwargs) # type: ignore @@ -263,42 +253,24 @@ def _mmd2(self, x_all: Union[list, torch.Tensor], perms: List[torch.Tensor], m: preprocess_batch_fn = self.train_kwargs['preprocess_fn'] if isinstance(preprocess_batch_fn, Callable): # type: ignore[arg-type] x_all = preprocess_batch_fn(x_all) # type: ignore[operator] - if self.has_proj: - x_all_proj = predict_batch(x_all, self.kernel.proj, device=self.device, batch_size=self.batch_size_predict, - dtype=x_all.dtype if isinstance(x_all, torch.Tensor) else torch.float32) - else: - x_all_proj = x_all - x, x2, y, y2 = None, None, None, None + x, y = None, None k_xx, k_yy, k_xy = [], [], [] for batch in range(self.n_batches): i, j = batch * self.batch_size_perms, (batch + 1) * self.batch_size_perms # Stack a batch of permuted reference and test tensors and their projections - x_proj = torch.cat([x_all_proj[perm[:m]][None, :, :] for perm in perms[i:j]], 0) - y_proj = torch.cat([x_all_proj[perm[m:]][None, :, :] for perm in perms[i:j]], 0) - if self.has_kernel_b: - x = torch.cat([x_all[perm[:m]][None, :, :] for perm in perms[i:j]], 0) - y = torch.cat([x_all[perm[m:]][None, :, :] for perm in perms[i:j]], 0) + x = torch.cat([x_all[perm[:m]][None, :, :] for perm in perms[i:j]], 0) + y = torch.cat([x_all[perm[m:]][None, :, :] for perm in perms[i:j]], 0) if batch == 0: - x_proj = torch.cat([x_all_proj[None, :m, :], x_proj], 0) - y_proj = torch.cat([x_all_proj[None, m:, :], y_proj], 0) - if self.has_kernel_b: - x = torch.cat([x_all[None, :m, :], x], 0) # type: ignore[call-overload] - y = torch.cat([x_all[None, m:, :], y], 0) # type: ignore[call-overload] - x_proj, y_proj = x_proj.to(self.device), y_proj.to(self.device) - if self.has_kernel_b: - x, y = x.to(self.device), y.to(self.device) + x = torch.cat([x_all[None, :m, :], x], 0) # type: ignore[call-overload] + y = torch.cat([x_all[None, m:, :], y], 0) # type: ignore[call-overload] + x, y = x.to(self.device), y.to(self.device) # Batch-wise kernel matrix computation over the permutations with torch.no_grad(): - x2_proj, x_proj = LazyTensor(x_proj[:, None, :, :]), LazyTensor(x_proj[:, :, None, :]) - y2_proj, y_proj = LazyTensor(y_proj[:, None, :, :]), LazyTensor(y_proj[:, :, None, :]) - if self.has_kernel_b: - x2, x = LazyTensor(x[:, None, :, :]), LazyTensor(x[:, :, None, :]) - y2, y = LazyTensor(y[:, None, :, :]), LazyTensor(y[:, :, None, :]) - k_xy.append(self.kernel(x_proj, y2_proj, x, y2).sum(1).sum(1).squeeze(-1)) - k_xx.append(self.kernel(x_proj, x2_proj, x, x2).sum(1).sum(1).squeeze(-1)) - k_yy.append(self.kernel(y_proj, y2_proj, y, y2).sum(1).sum(1).squeeze(-1)) + k_xy.append(self.kernel(x, y).sum(1).sum(1).squeeze(-1)) + k_xx.append(self.kernel(x, x).sum(1).sum(1).squeeze(-1)) + k_yy.append(self.kernel(y, y).sum(1).sum(1).squeeze(-1)) c_xx, c_yy, c_xy = 1 / (m * (m - 1)), 1 / (n * (n - 1)), 2. / (m * n) # Note that the MMD^2 estimates assume that the diagonal of the kernel matrix consists of 1's diff --git a/alibi_detect/cd/keops/mmd.py b/alibi_detect/cd/keops/mmd.py index 5b1a2fdc0..e44710e08 100644 --- a/alibi_detect/cd/keops/mmd.py +++ b/alibi_detect/cd/keops/mmd.py @@ -1,10 +1,9 @@ import logging import numpy as np -from pykeops.torch import LazyTensor import torch from typing import Callable, Dict, List, Optional, Tuple, Union from alibi_detect.cd.base import BaseMMDDrift -from alibi_detect.utils.keops.kernels import GaussianRBF +from alibi_detect.utils.keops.kernels import BaseKernel, GaussianRBF from alibi_detect.utils.pytorch import get_device from alibi_detect.utils.frameworks import Framework @@ -20,7 +19,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: Callable = GaussianRBF, + kernel: BaseKernel = GaussianRBF(), sigma: Optional[np.ndarray] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, @@ -77,7 +76,6 @@ def __init__( preprocess_at_init=preprocess_at_init, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, - sigma=sigma, configure_kernel_from_x_ref=configure_kernel_from_x_ref, n_permutations=n_permutations, input_shape=input_shape, @@ -89,23 +87,40 @@ def __init__( self.device = get_device(device) # initialize kernel - sigma = torch.from_numpy(sigma).to(self.device) if isinstance(sigma, # type: ignore[assignment] - np.ndarray) else None - self.kernel = kernel(sigma).to(self.device) if kernel == GaussianRBF else kernel + self.kernel = kernel + + if isinstance(self.kernel, GaussianRBF) & (sigma is not None): + self.kernel.parameter_dict['log-sigma'].value = torch.nn.Parameter( + torch.tensor(sigma).to(self.device).log(), + requires_grad=False) + self.kernel.parameter_dict['log-sigma'].requires_init = False + self.kernel.init_required = False + + self.kernel_parameter_specified = True + if hasattr(kernel, 'parameter_dict'): + for param in self.kernel.parameter_dict.keys(): + kernel.parameter_dict[param].value.to(self.device) + if kernel.parameter_dict[param].requires_init: + self.given_kernel_parameter = False + break + + if self.kernel_parameter_specified and self.infer_parameter: + self.infer_parameter = False + logger.warning('parameters are specified for the kernel and `configure_kernel_from_x_ref` ' + 'is set to True. Specified parameters take priority over ' + '`configure_kernel_from_x_ref` (set to False).') # set the correct MMD^2 function based on the batch size for the permutations self.batch_size = batch_size_permutations self.n_batches = 1 + (n_permutations - 1) // batch_size_permutations # infer the kernel bandwidth from the reference data - if isinstance(sigma, torch.Tensor): - self.infer_sigma = False - elif self.infer_sigma: - x = torch.from_numpy(self.x_ref).to(self.device) - _ = self.kernel(LazyTensor(x[:, None, :]), LazyTensor(x[None, :, :]), infer_sigma=self.infer_sigma) - self.infer_sigma = False + if self.infer_parameter: + x = torch.from_numpy(self.x_ref).to(self.device).reshape(1, self.x_ref.shape[0], -1) + _ = self.kernel(x, x, infer_parameter=self.infer_parameter) + self.infer_parameter = False else: - self.infer_sigma = True + self.infer_parameter = True def _mmd2(self, x_all: torch.Tensor, perms: List[torch.Tensor], m: int, n: int) \ -> Tuple[torch.Tensor, torch.Tensor]: @@ -139,12 +154,10 @@ def _mmd2(self, x_all: torch.Tensor, perms: List[torch.Tensor], m: int, n: int) x, y = x.to(self.device), y.to(self.device) # batch-wise kernel matrix computation over the permutations - k_xy.append(self.kernel( - LazyTensor(x[:, :, None, :]), LazyTensor(y[:, None, :, :]), self.infer_sigma).sum(1).sum(1).squeeze(-1)) - k_xx.append(self.kernel( - LazyTensor(x[:, :, None, :]), LazyTensor(x[:, None, :, :])).sum(1).sum(1).squeeze(-1)) - k_yy.append(self.kernel( - LazyTensor(y[:, :, None, :]), LazyTensor(y[:, None, :, :])).sum(1).sum(1).squeeze(-1)) + k_xy.append(self.kernel(x, y, infer_parameter=self.infer_parameter).sum(1).sum(1).squeeze(-1)) + k_xx.append(self.kernel(x, x, infer_parameter=self.infer_parameter).sum(1).sum(1).squeeze(-1)) + k_yy.append(self.kernel(y, y, infer_parameter=self.infer_parameter).sum(1).sum(1).squeeze(-1)) + c_xx, c_yy, c_xy = 1 / (m * (m - 1)), 1 / (n * (n - 1)), 2. / (m * n) # Note that the MMD^2 estimates assume that the diagonal of the kernel matrix consists of 1's stats = c_xx * (torch.cat(k_xx) - m) + c_yy * (torch.cat(k_yy) - n) - c_xy * torch.cat(k_xy) diff --git a/alibi_detect/cd/keops/tests/test_learned_kernel_keops.py b/alibi_detect/cd/keops/tests/test_learned_kernel_keops.py index 646027fe3..02ce9bcdc 100644 --- a/alibi_detect/cd/keops/tests/test_learned_kernel_keops.py +++ b/alibi_detect/cd/keops/tests/test_learned_kernel_keops.py @@ -9,29 +9,35 @@ from alibi_detect.utils.pytorch import mmd2_from_kernel_matrix if has_keops: from alibi_detect.cd.keops.learned_kernel import LearnedKernelDriftKeops - from alibi_detect.utils.keops import GaussianRBF - from pykeops.torch import LazyTensor + from alibi_detect.utils.keops import GaussianRBF, BaseKernel, ProjKernel n = 50 # number of instances used for the reference and test data samples in the tests if has_keops: - class MyKernel(nn.Module): + class MyKernel(BaseKernel): def __init__(self, n_features: int, proj: bool): super().__init__() sigma = .1 - self.kernel = GaussianRBF(trainable=True, sigma=torch.Tensor([sigma])) + self.kernel_a = GaussianRBF(trainable=True, sigma=torch.Tensor([sigma])) + self.log_sigma_a = self.kernel_a.parameter_dict['log-sigma'].value self.has_proj = proj if proj: self.proj = nn.Linear(n_features, 2) self.kernel_b = GaussianRBF(trainable=True, sigma=torch.Tensor([sigma])) + self.proj_kernel = ProjKernel(self.proj, self.kernel_b) + self.comp_kernel = self.proj_kernel + self.kernel_a + self.log_sigma_b = self.kernel_b.parameter_dict['log-sigma'].value + else: + self.comp_kernel = self.kernel_a - def forward(self, x_proj: LazyTensor, y_proj: LazyTensor, x: Optional[LazyTensor] = None, - y: Optional[LazyTensor] = None) -> LazyTensor: - similarity = self.kernel(x_proj, y_proj) - if self.has_proj: - similarity = similarity + self.kernel_b(x, y) - return similarity + def kernel_function( + self, + x: torch.Tensor, + y: torch.Tensor, + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: + return self.comp_kernel(x, y, infer_parameter) # test List[Any] inputs to the detector @@ -124,7 +130,7 @@ def test_lkdrift(lkdrift_params): if isinstance(preprocess_batch, Callable): x_all = preprocess_batch(x_all) - kernel = GaussianRBFTorch(sigma=cd.kernel.kernel.sigma) + kernel = GaussianRBFTorch(sigma=cd.kernel.kernel_a.sigma.cpu()) kernel_mat = kernel(x_all, x_all) mmd2_torch = mmd2_from_kernel_matrix(kernel_mat, n_test) - np.testing.assert_almost_equal(mmd2, mmd2_torch, decimal=6) + np.testing.assert_almost_equal(mmd2.cpu(), mmd2_torch.cpu(), decimal=6) diff --git a/alibi_detect/cd/keops/tests/test_mmd_keops.py b/alibi_detect/cd/keops/tests/test_mmd_keops.py index a64a78173..86ce980a0 100644 --- a/alibi_detect/cd/keops/tests/test_mmd_keops.py +++ b/alibi_detect/cd/keops/tests/test_mmd_keops.py @@ -112,9 +112,13 @@ def test_mmd(mmd_params): kernel = GaussianRBF(sigma=cd.kernel.sigma) if isinstance(preprocess_fn, Callable): x_ref, x_h1 = cd.preprocess(x_h1) - x_ref = torch.from_numpy(x_ref).float() - x_h1 = torch.from_numpy(x_h1).float() + x_ref = torch.from_numpy(x_ref).float().to(cd.kernel.sigma.device) + x_h1 = torch.from_numpy(x_h1).float().to(cd.kernel.sigma.device) x_all = torch.cat([x_ref, x_h1], 0) kernel_mat = kernel(x_all, x_all) mmd2_torch = mmd2_from_kernel_matrix(kernel_mat, x_h1.shape[0]) + if isinstance(mmd2, torch.Tensor): + mmd2 = mmd2.cpu().numpy() + if isinstance(mmd2_torch, torch.Tensor): + mmd2_torch = mmd2_torch.cpu().numpy() np.testing.assert_almost_equal(mmd2, mmd2_torch, decimal=6) diff --git a/alibi_detect/cd/lsdd.py b/alibi_detect/cd/lsdd.py index 8e7723475..1514f5435 100644 --- a/alibi_detect/cd/lsdd.py +++ b/alibi_detect/cd/lsdd.py @@ -22,6 +22,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, + sigma: Optional[Union[np.ndarray, float]] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/lsdd_online.py b/alibi_detect/cd/lsdd_online.py index 36a82026c..15c36fb0f 100644 --- a/alibi_detect/cd/lsdd_online.py +++ b/alibi_detect/cd/lsdd_online.py @@ -18,6 +18,7 @@ def __init__( backend: str = 'tensorflow', preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, + sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 58782fdf5..23f59c8fb 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -29,6 +29,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: Callable = None, + sigma: Optional[Union[np.ndarray, float]] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, batch_size_permutations: int = 1000000, diff --git a/alibi_detect/cd/mmd_online.py b/alibi_detect/cd/mmd_online.py index 027c0b973..8028e8fd3 100644 --- a/alibi_detect/cd/mmd_online.py +++ b/alibi_detect/cd/mmd_online.py @@ -22,6 +22,7 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: Optional[Union[BaseKernelTorch, BaseKernelTF]] = None, + sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index 4c0a14b22..9a067dff7 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -49,8 +49,8 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), - c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), + x_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), + c_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, diff --git a/alibi_detect/cd/pytorch/lsdd.py b/alibi_detect/cd/pytorch/lsdd.py index b0071c4ca..9692024b4 100644 --- a/alibi_detect/cd/pytorch/lsdd.py +++ b/alibi_detect/cd/pytorch/lsdd.py @@ -19,6 +19,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, + sigma: Optional[Union[np.ndarray, float]] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -95,7 +96,7 @@ def __init__( x_ref = torch.as_tensor(self.x_ref).to(self.device) # type: ignore[assignment] self._configure_normalization(x_ref) # type: ignore[arg-type] x_ref = self._normalize(x_ref) - self.kernel = GaussianRBF() + self.kernel = GaussianRBF(sigma=torch.tensor(sigma).to(self.device) if sigma is not None else None) _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) # type: ignore[arg-type] self.x_ref = x_ref.cpu().numpy() # type: ignore[union-attr] @@ -104,10 +105,13 @@ def __init__( self.H = GaussianRBF(np.sqrt(2.) * self.kernel.sigma)(self.kernel_centers, self.kernel_centers) def _configure_normalization(self, x_ref: torch.Tensor, eps: float = 1e-12): + x_ref = x_ref.to(self.device) x_ref_means = x_ref.mean(0) x_ref_stds = x_ref.std(0) - self._normalize = lambda x: (torch.as_tensor(x) - x_ref_means) / (x_ref_stds + eps) # type: ignore[assignment] - self._unnormalize = lambda x: (torch.as_tensor(x) * (x_ref_stds + eps) # type: ignore[assignment] + self._normalize = lambda x: (torch.as_tensor(x, device=self.device) # type: ignore[assignment] + - x_ref_means) / (x_ref_stds + eps) + self._unnormalize = lambda x: (torch.as_tensor(x, device=self.device) # type: ignore[assignment] + * (x_ref_stds + eps) + x_ref_means).cpu().numpy() def _configure_kernel_centers(self, x_ref: torch.Tensor): diff --git a/alibi_detect/cd/pytorch/lsdd_online.py b/alibi_detect/cd/pytorch/lsdd_online.py index 3195d15a9..c2ad0a521 100644 --- a/alibi_detect/cd/pytorch/lsdd_online.py +++ b/alibi_detect/cd/pytorch/lsdd_online.py @@ -18,6 +18,7 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, + sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -93,7 +94,7 @@ def __init__( self._configure_normalization() - self.kernel = GaussianRBF() + self.kernel = GaussianRBF(torch.tensor(sigma).to(self.device) if sigma is not None else None) if self.n_kernel_centers is None: self.n_kernel_centers = 2 * window_size @@ -107,7 +108,8 @@ def _configure_normalization(self, eps: float = 1e-12): x_ref_means = x_ref.mean(0) x_ref_stds = x_ref.std(0) self._normalize = lambda x: (x - x_ref_means) / (x_ref_stds + eps) - self._unnormalize = lambda x: (torch.as_tensor(x) * (x_ref_stds + eps) + x_ref_means).cpu().numpy() + self._unnormalize = lambda x: (torch.as_tensor(x, device=self.device) * (x_ref_stds + eps) + + x_ref_means).cpu().numpy() self.x_ref = self._normalize(x_ref).cpu().numpy() def _configure_kernel_centers(self): diff --git a/alibi_detect/cd/pytorch/mmd.py b/alibi_detect/cd/pytorch/mmd.py index ff2e394e9..8ffaa6e92 100644 --- a/alibi_detect/cd/pytorch/mmd.py +++ b/alibi_detect/cd/pytorch/mmd.py @@ -23,6 +23,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: BaseKernel = GaussianRBF(), + sigma: Optional[Union[np.ndarray, float]] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -87,8 +88,29 @@ def __init__( self.kernel = kernel + if isinstance(self.kernel, GaussianRBF) & (sigma is not None): + self.kernel.parameter_dict['log-sigma'].value = torch.nn.Parameter( + torch.tensor(sigma).to(self.device).log(), + requires_grad=False) + self.kernel.parameter_dict['log-sigma'].requires_init = False + self.kernel.init_required = False + + self.kernel_parameter_specified = True + if hasattr(kernel, 'parameter_dict'): + for param in self.kernel.parameter_dict.keys(): + kernel.parameter_dict[param].value.to(self.device) + if kernel.parameter_dict[param].requires_init: + self.kernel_parameter_specified = False + break + + if self.kernel_parameter_specified and self.infer_parameter: + self.infer_parameter = False + logger.warning('parameters are specified for the kernel and `configure_kernel_from_x_ref` ' + 'is set to True. Specified parameters take priority over ' + '`configure_kernel_from_x_ref` (set to False).') + # compute kernel matrix for the reference data - if self.infer_parameter: + if self.infer_parameter or self.kernel_parameter_specified: x = torch.from_numpy(self.x_ref).to(self.device) self.k_xx = self.kernel(x, x, infer_parameter=self.infer_parameter) self.infer_parameter = False diff --git a/alibi_detect/cd/pytorch/mmd_online.py b/alibi_detect/cd/pytorch/mmd_online.py index 9ad49e8f7..faf2dc4de 100644 --- a/alibi_detect/cd/pytorch/mmd_online.py +++ b/alibi_detect/cd/pytorch/mmd_online.py @@ -18,6 +18,7 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: BaseKernel = GaussianRBF(), + sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -82,6 +83,13 @@ def __init__( self.kernel = kernel + if isinstance(self.kernel, GaussianRBF) & (sigma is not None): + self.kernel.parameter_dict['log-sigma'].value = torch.nn.Parameter( + torch.tensor(sigma).to(self.device).log(), + requires_grad=False) + self.kernel.parameter_dict['log-sigma'].requires_init = False + self.kernel.init_required = False + # compute kernel matrix for the reference data self.x_ref = torch.from_numpy(self.x_ref).to(self.device) self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index 63c5acdab..65596891a 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -49,8 +49,8 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), - c_kernel: BaseKernel = GaussianRBF(init_fn_sigma=_sigma_median_diag), + x_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), + c_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, diff --git a/alibi_detect/cd/tensorflow/lsdd.py b/alibi_detect/cd/tensorflow/lsdd.py index d1ef4fb1c..8f31e9bbf 100644 --- a/alibi_detect/cd/tensorflow/lsdd.py +++ b/alibi_detect/cd/tensorflow/lsdd.py @@ -18,6 +18,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, + sigma: Optional[Union[np.ndarray, float]] = None, n_permutations: int = 100, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -83,7 +84,7 @@ def __init__( x_ref = tf.convert_to_tensor(self.x_ref) self._configure_normalization(x_ref) x_ref = self._normalize(x_ref) - self.kernel = GaussianRBF() + self.kernel = GaussianRBF(tf.cast(sigma) if sigma is not None else None) _ = self.kernel(x_ref, x_ref, infer_parameter=True) # infer sigma self._configure_kernel_centers(x_ref) self.x_ref = x_ref.numpy() # type: ignore[union-attr] diff --git a/alibi_detect/cd/tensorflow/lsdd_online.py b/alibi_detect/cd/tensorflow/lsdd_online.py index 63316fc57..483a0a1d9 100644 --- a/alibi_detect/cd/tensorflow/lsdd_online.py +++ b/alibi_detect/cd/tensorflow/lsdd_online.py @@ -16,6 +16,7 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, + sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, n_kernel_centers: Optional[int] = None, lambda_rd_max: float = 0.2, @@ -84,7 +85,7 @@ def __init__( self._configure_normalization() - self.kernel = GaussianRBF() + self.kernel = GaussianRBF(sigma=tf.cast(sigma) if sigma is not None else None) if self.n_kernel_centers is None: self.n_kernel_centers = 2*window_size diff --git a/alibi_detect/cd/tensorflow/mmd.py b/alibi_detect/cd/tensorflow/mmd.py index 6bc28a6a5..80eb2d997 100644 --- a/alibi_detect/cd/tensorflow/mmd.py +++ b/alibi_detect/cd/tensorflow/mmd.py @@ -22,6 +22,7 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: BaseKernel = GaussianRBF(), + sigma: Optional[Union[np.ndarray, float]] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -78,8 +79,28 @@ def __init__( self.meta.update({'backend': Framework.TENSORFLOW.value}) self.kernel = kernel + + if isinstance(self.kernel, GaussianRBF) & (sigma is not None): + self.kernel.parameter_dict['log-sigma'].value.assign(tf.cast(np.log(sigma), + tf.keras.backend.floatx())) + self.kernel.parameter_dict['log-sigma'].requires_init = False + self.kernel.init_required = False + + self.kernel_parameter_specified = True + if hasattr(kernel, 'parameter_dict'): + for param in self.kernel.parameter_dict.keys(): + if kernel.parameter_dict[param].requires_init: + self.given_kernel_parameter = False + break + + if self.kernel_parameter_specified and self.infer_parameter: + self.infer_parameter = False + logger.warning('parameters are specified for the kernel and `configure_kernel_from_x_ref` ' + 'is set to True. Specified parameters take priority over ' + '`configure_kernel_from_x_ref` (set to False).') + # compute kernel matrix for the reference data - if self.infer_parameter: + if self.infer_parameter or self.kernel_parameter_specified: self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.infer_parameter) self.infer_sigma = False else: diff --git a/alibi_detect/cd/tensorflow/mmd_online.py b/alibi_detect/cd/tensorflow/mmd_online.py index 6802bab2f..f55858d90 100644 --- a/alibi_detect/cd/tensorflow/mmd_online.py +++ b/alibi_detect/cd/tensorflow/mmd_online.py @@ -17,6 +17,7 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: BaseKernel = GaussianRBF(), + sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, verbose: bool = True, input_shape: Optional[tuple] = None, @@ -74,6 +75,12 @@ def __init__( self.kernel = kernel + if isinstance(self.kernel, GaussianRBF) & (sigma is not None): + self.kernel.parameter_dict['log-sigma'].value.assign(tf.cast(np.log(sigma), + tf.keras.backend.floatx())) + self.kernel.parameter_dict['log-sigma'].requires_init = False + self.kernel.init_required = False + # compute kernel matrix for the reference data self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) diff --git a/alibi_detect/saving/registry.py b/alibi_detect/saving/registry.py index b1ad20303..eda22f1e1 100644 --- a/alibi_detect/saving/registry.py +++ b/alibi_detect/saving/registry.py @@ -42,14 +42,16 @@ def my_function(x: np.ndarray) -> np.ndarray: preprocess_drift as preprocess_drift_tf from alibi_detect.utils.tensorflow.data import TFDataset as TFDataset_tf from alibi_detect.utils.tensorflow.kernels import \ - GaussianRBF as GaussianRBF_tf, sigma_median as sigma_median_tf + GaussianRBF as GaussianRBF_tf, sigma_median as sigma_median_tf, \ + log_sigma_median as log_sigma_median_tf from alibi_detect.cd.tensorflow.context_aware import _sigma_median_diag as _sigma_median_diag_tf if has_pytorch: from alibi_detect.cd.pytorch import \ preprocess_drift as preprocess_drift_torch from alibi_detect.utils.pytorch.kernels import \ - GaussianRBF as GaussianRBF_torch, sigma_median as sigma_median_torch + GaussianRBF as GaussianRBF_torch, sigma_median as sigma_median_torch, \ + log_sigma_median as log_sigma_median_torch from alibi_detect.cd.pytorch.context_aware import _sigma_median_diag as _sigma_median_diag_torch # Create registry @@ -59,6 +61,7 @@ def my_function(x: np.ndarray) -> np.ndarray: if has_tensorflow: registry.register('utils.tensorflow.kernels.GaussianRBF', func=GaussianRBF_tf) registry.register('utils.tensorflow.kernels.sigma_median', func=sigma_median_tf) + registry.register('utils.tensorflow.kernels.log_sigma_median', func=log_sigma_median_tf) registry.register('cd.tensorflow.context_aware._sigma_median_diag', func=_sigma_median_diag_tf) registry.register('cd.tensorflow.preprocess.preprocess_drift', func=preprocess_drift_tf) registry.register('utils.tensorflow.data.TFDataset', func=TFDataset_tf) @@ -66,5 +69,6 @@ def my_function(x: np.ndarray) -> np.ndarray: if has_pytorch: registry.register('utils.pytorch.kernels.GaussianRBF', func=GaussianRBF_torch) registry.register('utils.pytorch.kernels.sigma_median', func=sigma_median_torch) + registry.register('utils.pytorch.kernels.log_sigma_median', func=log_sigma_median_torch) registry.register('cd.pytorch.context_aware._sigma_median_diag', func=_sigma_median_diag_torch) registry.register('cd.pytorch.preprocess.preprocess_drift', func=preprocess_drift_torch) diff --git a/alibi_detect/saving/tests/models.py b/alibi_detect/saving/tests/models.py index 5a1b28c0e..405a1608f 100644 --- a/alibi_detect/saving/tests/models.py +++ b/alibi_detect/saving/tests/models.py @@ -18,8 +18,12 @@ from alibi_detect.cd.tensorflow import UAE as UAE_tf from alibi_detect.cd.tensorflow import preprocess_drift as preprocess_drift_tf from alibi_detect.utils.pytorch.kernels import GaussianRBF as GaussianRBF_pt +from alibi_detect.utils.pytorch.kernels import RationalQuadratic as RationalQuadratic_pt +from alibi_detect.utils.pytorch.kernels import Periodic as Periodic_pt from alibi_detect.utils.pytorch.kernels import DeepKernel as DeepKernel_pt from alibi_detect.utils.tensorflow.kernels import GaussianRBF as GaussianRBF_tf +from alibi_detect.utils.tensorflow.kernels import RationalQuadratic as RationalQuadratic_tf +from alibi_detect.utils.tensorflow.kernels import Periodic as Periodic_tf from alibi_detect.utils.tensorflow.kernels import DeepKernel as DeepKernel_tf from alibi_detect.models.pytorch import TransformerEmbedding as TransformerEmbedding_pt from alibi_detect.models.tensorflow import TransformerEmbedding as TransformerEmbedding_tf @@ -147,8 +151,8 @@ def deep_kernel(request, backend, encoder_model): parametrised in the test function. """ # Get DeepKernel options - kernel_a = request.param.get('kernel_a', 'rbf') - kernel_b = request.param.get('kernel_b', 'rbf') + kernel_a = request.param.get('kernel_a', {'kernel_name': 'GaussianRBF', 'kernel_config': {}}) + kernel_b = request.param.get('kernel_b', {'kernel_name': 'GaussianRBF', 'kernel_config': {}}) eps = request.param.get('eps', 'trainable') # Proj model (backend managed in encoder_model fixture) @@ -156,18 +160,46 @@ def deep_kernel(request, backend, encoder_model): # Build DeepKernel if backend == 'tensorflow': - kernel_a = GaussianRBF_tf(**kernel_a) if isinstance(kernel_a, dict) else kernel_a - kernel_b = GaussianRBF_tf(**kernel_b) if isinstance(kernel_b, dict) else kernel_b + kernel_a = initial_kernel_tf(kernel_a['kernel_name'], kernel_a['kernel_config']) + kernel_b = initial_kernel_tf(kernel_b['kernel_name'], kernel_b['kernel_config']) deep_kernel = DeepKernel_tf(proj, kernel_a=kernel_a, kernel_b=kernel_b, eps=eps) elif backend == 'pytorch': - kernel_a = GaussianRBF_pt(**kernel_a) if isinstance(kernel_a, dict) else kernel_a - kernel_b = GaussianRBF_pt(**kernel_b) if isinstance(kernel_b, dict) else kernel_b + kernel_a = initial_kernel_pt(kernel_a['kernel_name'], kernel_a['kernel_config']) + kernel_b = initial_kernel_pt(kernel_b['kernel_name'], kernel_b['kernel_config']) deep_kernel = DeepKernel_pt(proj, kernel_a=kernel_a, kernel_b=kernel_b, eps=eps) else: pytest.skip('`deep_kernel` only implemented for tensorflow and pytorch.') return deep_kernel +def initial_kernel_tf(kernel_name, kernel_config): + if 'sigma' in kernel_config: + kernel_config['sigma'] = tf.constant(kernel_config['sigma']) + if kernel_name == 'GaussianRBF': + kernel = GaussianRBF_tf(**kernel_config) + elif kernel_name == 'RationalQuadratic': + kernel = RationalQuadratic_tf(**kernel_config) + elif kernel_name == 'Periodic': + kernel = Periodic_tf(**kernel_config) + else: + pytest.skip('`initial_kernel_tf` only implemented for GaussianRBF, RationalQuadratic and Periodic.') + return kernel + + +def initial_kernel_pt(kernel_name, kernel_config): + if 'sigma' in kernel_config: + kernel_config['sigma'] = torch.tensor(kernel_config['sigma']) + if kernel_name == 'GaussianRBF': + kernel = GaussianRBF_pt(**kernel_config) + elif kernel_name == 'RationalQuadratic': + kernel = RationalQuadratic_pt(**kernel_config) + elif kernel_name == 'Periodic': + kernel = Periodic_pt(**kernel_config) + else: + pytest.skip('`initial_kernel_pt` only implemented for GaussianRBF, RationalQuadratic and Periodic.') + return kernel + + @fixture def classifier_model(backend, current_cases): """ diff --git a/alibi_detect/saving/tests/test_saving.py b/alibi_detect/saving/tests/test_saving.py index 0ffa333c8..c35c408c2 100644 --- a/alibi_detect/saving/tests/test_saving.py +++ b/alibi_detect/saving/tests/test_saving.py @@ -204,7 +204,6 @@ def test_save_mmddrift(data, kernel, preprocess_custom, backend, tmp_path, seed) """ if backend not in ('tensorflow', 'pytorch', 'keops'): pytest.skip("Detector doesn't have this backend") - # Init detector and make predictions X_ref, X_h0 = data kwargs = { @@ -228,10 +227,9 @@ def test_save_mmddrift(data, kernel, preprocess_custom, backend, tmp_path, seed) with fixed_seed(seed): cd_load = load_detector(tmp_path) preds_load = cd_load.predict(X_h0) - # assertions np.testing.assert_array_equal(preprocess_custom(X_ref), cd_load._detector.x_ref) - assert not cd_load._detector.infer_sigma + assert not cd_load._detector.infer_parameter assert cd_load._detector.n_permutations == N_PERMUTATIONS assert cd_load._detector.p_val == P_VAL assert isinstance(cd_load._detector.preprocess_fn, Callable) @@ -459,8 +457,9 @@ def test_save_spotthediff(data, classifier_model, backend, tmp_path, seed): # n @parametrize('deep_kernel', [ - {'kernel_a': 'rbf', 'eps': 0.01} # Default for kernel_a - ], indirect=True + {'kernel_a': {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': True}}, + 'eps': 0.01} + ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') def test_save_learnedkernel(data, deep_kernel, backend, tmp_path, seed): # noqa: F811 @@ -657,7 +656,10 @@ def test_save_onlinemmddrift(data, kernel, preprocess_custom, backend, tmp_path, stats_load.append(pred['data']['test_stat']) # assertions - np.testing.assert_array_equal(preprocess_custom(X_ref), cd_load._detector.x_ref) + if backend == 'pytorch': + np.testing.assert_array_equal(preprocess_custom(X_ref), cd_load._detector.x_ref.cpu().numpy()) + else: + np.testing.assert_array_equal(preprocess_custom(X_ref), cd_load._detector.x_ref) assert cd_load._detector.n_bootstraps == N_BOOTSTRAPS assert cd_load._detector.ert == ERT assert isinstance(cd_load._detector.preprocess_fn, Callable) @@ -710,7 +712,11 @@ def test_save_onlinelsdddrift(data, preprocess_custom, backend, tmp_path, seed): assert cd_load._detector.ert == ERT assert isinstance(cd_load._detector.preprocess_fn, Callable) assert cd_load._detector.preprocess_fn.func.__name__ == 'preprocess_drift' - assert cd._detector.kernel.sigma == cd_load._detector.kernel.sigma + if backend == 'pytorch': + np.testing.assert_array_almost_equal(cd._detector.kernel.sigma.cpu().numpy(), + cd_load._detector.kernel.sigma.cpu().numpy(), 5) + else: + np.testing.assert_almost_equal(cd._detector.kernel.sigma, cd_load._detector.kernel.sigma, 5) assert cd._detector.kernel.init_sigma_fn == cd_load._detector.kernel.init_sigma_fn np.testing.assert_array_equal(stats, stats_load) @@ -883,6 +889,12 @@ def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 # Call kernels X = np.random.standard_normal((10, 1)) + if backend == 'pytorch': + X = torch.from_numpy(X).float() + elif backend == 'tensorflow': + X = tf.convert_to_tensor(X) + else: + pytest.skip('Backend not supported.') kernel(X, X) kernel_loaded(X, X) @@ -893,14 +905,20 @@ def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 else: np.testing.assert_array_almost_equal(np.array(kernel_loaded.sigma), np.array(kernel.sigma), 5) assert kernel_loaded.trainable == kernel.trainable - assert kernel_loaded.init_sigma_fn == kernel.init_sigma_fn + for tmp_key in kernel.parameter_dict.keys(): + assert kernel_loaded.parameter_dict[tmp_key].init_fn == kernel.parameter_dict[tmp_key].init_fn + # assert kernel_loaded.init_sigma_fn == kernel.init_sigma_fn # `data` passed below as needed in encoder_model, which is used in deep_kernel @parametrize_with_cases("data", cases=ContinuousData.data_synthetic_nd) @parametrize('deep_kernel', [ - {'kernel_a': 'rbf', 'kernel_b': 'rbf', 'eps': 'trainable'}, # Default for kernel_a and kernel_b, trainable eps - {'kernel_a': {'trainable': True}, 'kernel_b': 'rbf', 'eps': 0.01}, # Explicit kernel_a, fixed eps + {'kernel_a': {'kernel_name': 'GaussianRBF', 'kernel_config': {}}, + 'kernel_b': {'kernel_name': 'GaussianRBF', 'kernel_config': {}}, + 'eps': 'trainable'}, # Default for kernel_a and kernel_b, trainable eps + {'kernel_a': {'kernel_name': 'GaussianRBF', 'kernel_config': {'trainable': True}}, + 'kernel_b': {'kernel_name': 'GaussianRBF', 'kernel_config': {}}, + 'eps': 0.01}, # Explicit kernel_a, fixed eps ], indirect=True ) def test_save_deepkernel(data, deep_kernel, backend, tmp_path): # noqa: F811 @@ -930,6 +948,12 @@ def test_save_deepkernel(data, deep_kernel, backend, tmp_path): # noqa: F811 kernel_loaded = resolve_config(cfg, tmp_path)['kernel'] # implicitly calls _load_kernel_config # Call kernels + if backend == 'pytorch': + X = torch.from_numpy(X).float() + elif backend == 'tensorflow': + X = tf.convert_to_tensor(X) + else: + pytest.skip('Backend not supported.') deep_kernel.kernel_a(X, X) deep_kernel.kernel_b(X, X) kernel_loaded.kernel_a(X, X) diff --git a/alibi_detect/utils/keops/__init__.py b/alibi_detect/utils/keops/__init__.py index 36dc22971..bf8490260 100644 --- a/alibi_detect/utils/keops/__init__.py +++ b/alibi_detect/utils/keops/__init__.py @@ -1,12 +1,14 @@ from alibi_detect.utils.missing_optional_dependency import import_optional -GaussianRBF, DeepKernel = import_optional( +GaussianRBF, DeepKernel, BaseKernel, ProjKernel = import_optional( 'alibi_detect.utils.keops.kernels', - names=['GaussianRBF', 'DeepKernel'] + names=['GaussianRBF', 'DeepKernel', 'BaseKernel', 'ProjKernel'] ) __all__ = [ "GaussianRBF", - "DeepKernel" + "DeepKernel", + "BaseKernel", + "ProjKernel" ] diff --git a/alibi_detect/utils/keops/kernels.py b/alibi_detect/utils/keops/kernels.py index 7da7a3ee9..500f57b63 100644 --- a/alibi_detect/utils/keops/kernels.py +++ b/alibi_detect/utils/keops/kernels.py @@ -1,7 +1,46 @@ +from abc import abstractmethod from pykeops.torch import LazyTensor +import numpy as np import torch import torch.nn as nn -from typing import Callable, Optional, Union +from typing import Callable, Optional, Union, List +from copy import deepcopy + + +def infer_kernel_parameter( + kernel: 'BaseKernel', + x: LazyTensor, + y: LazyTensor, + dist: torch.Tensor, + infer_parameter: bool = True +) -> None: + """ + Infer the kernel parameter from the data. + + Parameters + ---------- + kernel + The kernel function. + x + LazyTensor of instances with dimension [Nx, 1, features] or [batch_size, Nx, 1, features]. + The singleton dimension is necessary for broadcasting. + y + LazyTensor of instances with dimension [1, Ny, features] or [batch_size, 1, Ny, features]. + The singleton dimension is necessary for broadcasting. + dist + Tensor with dimensions [Nx, Ny], containing the pairwise distances between `x` and `y`. + infer_parameter + Whether to infer the kernel parameter. + """ + if kernel.trainable and infer_parameter: + raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") + for parameter in kernel.parameter_dict.values(): + if parameter.requires_init: + if parameter.init_fn is not None: + with torch.no_grad(): + parameter.value.data = parameter.init_fn(x, y, dist).reshape(-1) + parameter.requires_init = False + kernel.init_required = False def sigma_mean(x: LazyTensor, y: LazyTensor, dist: LazyTensor, n_min: int = 100) -> torch.Tensor: @@ -53,20 +92,296 @@ def sigma_mean(x: LazyTensor, y: LazyTensor, dist: LazyTensor, n_min: int = 100) return sigma -class GaussianRBF(nn.Module): +class KernelParameter: def __init__( self, - sigma: Optional[torch.Tensor] = None, - init_sigma_fn: Optional[Callable] = None, - trainable: bool = False + value: torch.Tensor = None, + init_fn: Optional[Callable] = None, + requires_grad: bool = False, + requires_init: bool = False + ) -> None: + """ + Parameter class for kernels. + + Parameters + ---------- + value + The pre-specified value of the parameter. + init_fn + The function used to initialize the parameter. + requires_grad + Whether the parameter requires gradient. + requires_init + Whether the parameter requires initialization. + """ + super().__init__() + self.value = nn.Parameter(value if value is not None else torch.ones(1), + requires_grad=requires_grad) + self.init_fn = init_fn + self.requires_init = requires_init + + +class BaseKernel(nn.Module): + def __init__(self, active_dims: list = None) -> None: + """ + The base class for all kernels. + + Parameters + ---------- + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + """ + super().__init__() + self.parameter_dict: dict = {} + if active_dims is not None: + self.active_dims = torch.as_tensor(active_dims) + else: + self.active_dims = None + self.init_required = False + + @abstractmethod + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: Optional[bool] = False) -> torch.Tensor: + raise NotImplementedError + + def forward(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: + if self.active_dims is not None: + x = torch.index_select(x, -1, self.active_dims) + y = torch.index_select(y, -1, self.active_dims) + if len(self.parameter_dict) > 0: + return self.kernel_function(x, y, infer_parameter) + else: + return self.kernel_function(x, y) + + def __add__( + self, + other: Union['BaseKernel', torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): + other.kernel_list.append(self) + return other + elif isinstance(other, (BaseKernel, ProductKernel, torch.Tensor)): + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + else: + raise ValueError('Kernels can only added to another kernel or a constant.') + + def __radd__(self, other: 'BaseKernel') -> 'SumKernel': + return self.__add__(other) + + def __mul__( + self, + other: Union['BaseKernel', torch.Tensor] + ) -> 'BaseKernel': + if isinstance(other, ProductKernel): + other.kernel_factors.append(self) + return other + elif isinstance(other, SumKernel): + sum_kernel = SumKernel() + for k in other.kernel_list: + sum_kernel.kernel_list.append(self * k) + return sum_kernel + else: + prod_kernel = ProductKernel() + prod_kernel.kernel_factors.append(self) + prod_kernel.kernel_factors.append(other) + return prod_kernel + + def __rmul__( + self, + other: 'BaseKernel' + ) -> 'BaseKernel': + return self.__mul__(other) + + def __truediv__(self, other: torch.Tensor) -> 'BaseKernel': + if isinstance(other, torch.Tensor): + return self.__mul__(1. / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support subtraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support subtraction.') + + +class SumKernel(BaseKernel): + def __init__(self) -> None: + """ + Construct a kernel by summing different kernels. + """ + super().__init__() + self.kernel_list: List[Union[BaseKernel, torch.Tensor]] = [] + + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: + K_sum = torch.tensor(0., device=x.device) + for k in self.kernel_list: + if isinstance(k, (BaseKernel, SumKernel, ProductKernel)): + K_sum = K_sum + k(x, y, infer_parameter) + elif isinstance(k, torch.Tensor): + K_sum = K_sum + k + else: + raise ValueError(type(k) + 'is not supported by SumKernel.') + return K_sum + + def __add__( + self, + other: Union[BaseKernel, torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): + for k in other.kernel_list: + self.kernel_list.append(k) + else: + self.kernel_list.append(other) + return self + + def __radd__(self, other: BaseKernel) -> 'SumKernel': + return self.__add__(other) + + def __mul__( + self, + other: Union[BaseKernel, torch.Tensor] + ) -> BaseKernel: + if isinstance(other, SumKernel): + sum_kernel = SumKernel() + for ki in self.kernel_list: + for kj in other.kernel_list: + sum_kernel.kernel_list.append((ki * kj)) + return sum_kernel + elif isinstance(other, ProductKernel): + return other * self + elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): + sum_kernel = SumKernel() + for ki in self.kernel_list: + sum_kernel.kernel_list.append(other * ki) + return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') + + def __rmul__( + self, + other: BaseKernel + ) -> BaseKernel: + return self.__mul__(other) + + def __truediv__(self, other: torch.Tensor) -> BaseKernel: + if isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support subtraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support subtraction.') + + +class ProductKernel(BaseKernel): + def __init__(self) -> None: + """ + Construct a kernel by multiplying different kernels. + """ + super().__init__() + self.kernel_factors: List[Union[BaseKernel, torch.Tensor]] = [] + + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> torch.Tensor: + K_prod = torch.tensor(1., device=x.device) + for k in self.kernel_factors: + if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): + K_prod = K_prod * k(x, y, infer_parameter) + elif isinstance(k, torch.Tensor): + K_prod = K_prod * k + else: + raise ValueError(type(k) + 'is not supported by ProductKernel.') + return K_prod + + def __add__( + self, + other: Union[BaseKernel, torch.Tensor] + ) -> 'SumKernel': + if isinstance(other, SumKernel): + other.kernel_list.append(self) + return other + else: + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.kernel_list.append(other) + return sum_kernel + + def __radd__( + self, + other: BaseKernel + ) -> 'SumKernel': + return self.__add__(other) + + def __mul__( + self, + other: Union[BaseKernel, torch.Tensor] + ) -> BaseKernel: + if isinstance(other, SumKernel): + sum_kernel = SumKernel() + for k in other.kernel_list: + tmp_prod_kernel = deepcopy(self) + tmp_prod_kernel.kernel_factors.append(k) + sum_kernel.kernel_list.append(tmp_prod_kernel) + return sum_kernel + elif isinstance(other, ProductKernel): + for k in other.kernel_factors: + self.kernel_factors.append(k) + return self + elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): + self.kernel_factors.append(other) + return self + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') + + def __rmul__( + self, + other: BaseKernel + ) -> BaseKernel: + return self.__mul__(other) + + def __truediv__(self, other: torch.Tensor) -> BaseKernel: + if isinstance(other, torch.Tensor): + return self.__mul__(1 / other) + else: + raise ValueError('Kernels can only be divided by a constant.') + + def __rtruediv__(self, other): + raise ValueError('Kernels can not be used as divisor.') + + def __sub__(self, other): + raise ValueError('Kernels do not support subtraction.') + + def __rsub__(self, other): + raise ValueError('Kernels do not support subtraction.') + + +class GaussianRBF(BaseKernel): + def __init__( + self, + sigma: Optional[torch.Tensor] = None, + init_sigma_fn: Optional[Callable] = None, + trainable: bool = False, + active_dims: list = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes - a batch of instances x and y and returns the kernel matrix. - x can be of shape [Nx, 1, features] or [batch_size, Nx, 1, features]. - y can be of shape [1, Ny, features] or [batch_size, 1, Ny, features]. - The returned kernel matrix can be of shape [Nx, Ny] or [batch_size, Nx, Ny]. - x, y and the returned kernel matrix are all lazy tensors. + a batch of instances x [Nx, features] and y [Ny, features] and returns the kernel + matrix [Nx, Ny]. Parameters ---------- @@ -75,38 +390,52 @@ def __init__( Can pass multiple values to eval kernel with and then average. init_sigma_fn Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. - The function's signature should match :py:func:`~alibi_detect.utils.keops.kernels.sigma_mean`, - meaning that it should take in the lazy tensors `x`, `y` and `dist` and return a tensor `sigma`. + The function's signature should match :py:func:`~alibi_detect.utils.pytorch.kernels.sigma_median`, + meaning that it should take in the tensors `x`, `y` and `dist` and return `sigma`. If `None`, it is set to + :func:`~alibi_detect.utils.pytorch.kernels.sigma_median`. trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. + active_dims + Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. + feature_axis + Axis of the feature dimension. """ - super().__init__() + super().__init__(active_dims) init_sigma_fn = sigma_mean if init_sigma_fn is None else init_sigma_fn - if sigma is None: - self.log_sigma = nn.Parameter(torch.empty(1), requires_grad=trainable) - self.init_required = True - else: - sigma = sigma.reshape(-1) # [Ns,] - self.log_sigma = nn.Parameter(sigma.log(), requires_grad=trainable) - self.init_required = False - self.init_sigma_fn = init_sigma_fn + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_sigma_fn} + self.parameter_dict['log-sigma'] = KernelParameter( + value=sigma.log().reshape(-1) if sigma is not None else None, + init_fn=init_sigma_fn, + requires_grad=trainable, + requires_init=True if sigma is None else False, + ) self.trainable = trainable + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) @property def sigma(self) -> torch.Tensor: - return self.log_sigma.exp() + return self.parameter_dict['log-sigma'].value.exp() + + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> LazyTensor: + if len(x.shape) == 3: + x = LazyTensor(x[:, :, None, :]) + elif len(x.shape) == 2: + x = LazyTensor(x[:, None, :]) + else: + raise ValueError('x should be of shape [batch_size, n_instances, features] or [batch_size, features].') - def forward(self, x: LazyTensor, y: LazyTensor, infer_sigma: bool = False) -> LazyTensor: + if len(y.shape) == 3: + y = LazyTensor(y[:, None, :, :]) + elif len(y.shape) == 2: + y = LazyTensor(y[None, :, :]) + else: + raise ValueError('y should be of shape [batch_size, n_instances, features] or [batch_size, features].') dist = ((x - y) ** 2).sum(-1) - if infer_sigma or self.init_required: - if self.trainable and infer_sigma: - raise ValueError("Gradients cannot be computed w.r.t. an inferred sigma value") - sigma = self.init_sigma_fn(x, y, dist) - with torch.no_grad(): - self.log_sigma.copy_(sigma.log().clone()) - self.init_required = False + if infer_parameter or self.init_required: + infer_kernel_parameter(self, x, y, dist, infer_parameter) gamma = 1. / (2. * self.sigma ** 2) gamma = LazyTensor(gamma[None, None, :]) if len(dist.shape) == 2 else LazyTensor(gamma[None, None, None, :]) @@ -116,45 +445,84 @@ def forward(self, x: LazyTensor, y: LazyTensor, infer_sigma: bool = False) -> La return kernel_mat -class DeepKernel(nn.Module): +class ProjKernel(BaseKernel): def __init__( self, proj: nn.Module, - kernel_a: nn.Module = GaussianRBF(trainable=True), - kernel_b: Optional[nn.Module] = GaussianRBF(trainable=True), - eps: Union[float, str] = 'trainable' + raw_kernel: BaseKernel = GaussianRBF(trainable=True), ) -> None: """ - Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). - A forward pass takes an already projected batch of instances x_proj and y_proj and optionally - (if k_b is present) a batch of instances x and y and returns the kernel matrix. - x_proj can be of shape [Nx, 1, features_proj] or [batch_size, Nx, 1, features_proj]. - y_proj can be of shape [1, Ny, features_proj] or [batch_size, 1, Ny, features_proj]. - x can be of shape [Nx, 1, features] or [batch_size, Nx, 1, features]. - y can be of shape [1, Ny, features] or [batch_size, 1, Ny, features]. - The returned kernel matrix can be of shape [Nx, Ny] or [batch_size, Nx, Ny]. - x, y and the returned kernel matrix are all lazy tensors. + A kernel that combines a raw kernel (e.g. RBF) with a projection function (e.g. deep net) as + k(x, y) = k(proj(x), proj(y)). A forward pass takes a batch of instances x [Nx, features] and + y [Ny, features] and returns the kernel matrix [Nx, Ny]. - Parameters + Parameters: ---------- proj - The projection to be applied to the inputs before applying kernel_a - kernel_a + The projection to be applied to the inputs before applying raw_kernel + raw_kernel The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. - kernel_b - The kernel to apply to the raw inputs. Defaults to a Gaussian RBF with trainable bandwidth. - Set to None in order to use only the deep component (i.e. eps=0). - eps - The proportion (in [0,1]) of weight to assign to the kernel applied to raw inputs. This can be - either specified or set to 'trainable'. Only relavent if kernel_b is not None. """ super().__init__() + self.proj = proj + self.raw_kernel = raw_kernel + self.init_required = False + + def kernel_function( + self, + x: Union[np.ndarray, torch.Tensor], + y: Union[np.ndarray, torch.Tensor], + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: + return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) + + +class DeepKernel(BaseKernel): + """ + Computes similarities as k(x,y) = (1-eps)*k_a(proj(x), proj(y)) + eps*k_b(x,y). + A forward pass takes a batch of instances x [Nx, features] and y [Ny, features] and returns + the kernel matrix [Nx, Ny]. + + Parameters + ---------- + proj + The projection to be applied to the inputs before applying kernel_a + kernel_a + The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. + kernel_b + The kernel to apply to the raw inputs. Defaults to a Gaussian RBF with trainable bandwidth. + Set to None in order to use only the deep component (i.e. eps=0). + eps + The proportion (in [0,1]) of weight to assign to the kernel applied to raw inputs. This can be + either specified or set to 'trainable'. Only relavent if kernel_b is not None. + + """ + def __init__( + self, + proj: nn.Module, + kernel_a: BaseKernel = GaussianRBF(trainable=True), + kernel_b: Optional[BaseKernel] = GaussianRBF(trainable=True), + eps: Union[float, str] = 'trainable' + ) -> None: + super().__init__() + self.proj = proj self.kernel_a = kernel_a self.kernel_b = kernel_b - self.proj = proj + + if hasattr(self.kernel_a, 'parameter_dict'): + for param in self.kernel_a.parameter_dict.keys(): + setattr(self, param, self.kernel_a.parameter_dict[param].value) + + self.proj_kernel = ProjKernel(proj=self.proj, raw_kernel=self.kernel_a) if kernel_b is not None: self._init_eps(eps) + self.comp_kernel = (1-self.logit_eps.sigmoid())*self.proj_kernel + self.logit_eps.sigmoid()*self.kernel_b + if hasattr(self.kernel_b, 'parameter_dict'): + for param in self.kernel_b.parameter_dict.keys(): + setattr(self, param, self.kernel_b.parameter_dict[param].value) + else: + self.comp_kernel = self.proj_kernel def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -170,9 +538,10 @@ def _init_eps(self, eps: Union[float, str]) -> None: def eps(self) -> torch.Tensor: return self.logit_eps.sigmoid() if self.kernel_b is not None else torch.tensor(0.) - def forward(self, x_proj: LazyTensor, y_proj: LazyTensor, x: Optional[LazyTensor] = None, - y: Optional[LazyTensor] = None) -> LazyTensor: - similarity = self.kernel_a(x_proj, y_proj) - if self.kernel_b is not None: - similarity = (1-self.eps)*similarity + self.eps*self.kernel_b(x, y) - return similarity + def kernel_function( + self, + x: torch.Tensor, + y: torch.Tensor, + infer_parameter: Optional[bool] = False + ) -> torch.Tensor: + return self.comp_kernel(x, y, infer_parameter) diff --git a/alibi_detect/utils/keops/tests/test_kernels_keops.py b/alibi_detect/utils/keops/tests/test_kernels_keops.py index b25554818..979da8c7d 100644 --- a/alibi_detect/utils/keops/tests/test_kernels_keops.py +++ b/alibi_detect/utils/keops/tests/test_kernels_keops.py @@ -6,7 +6,7 @@ import torch.nn as nn if has_keops: from pykeops.torch import LazyTensor - from alibi_detect.utils.keops import DeepKernel, GaussianRBF + from alibi_detect.utils.keops import DeepKernel, GaussianRBF, BaseKernel sigma = [None, np.array([1.]), np.array([1., 2.])] n_features = [5, 10] @@ -34,21 +34,15 @@ def test_gaussian_kernel(gaussian_kernel_params): sigma = sigma if sigma is None else torch.from_numpy(sigma).float() x = torch.from_numpy(np.random.random(xshape)).float() y = torch.from_numpy(np.random.random(yshape)).float() - if batch_size: - x_lazy, y_lazy = LazyTensor(x[:, :, None, :]), LazyTensor(y[:, None, :, :]) - x_lazy2 = LazyTensor(x[:, None, :, :]) - else: - x_lazy, y_lazy = LazyTensor(x[:, None, :]), LazyTensor(y[None, :, :]) - x_lazy2 = LazyTensor(x[None, :, :]) kernel = GaussianRBF(sigma=sigma, trainable=trainable) - infer_sigma = True if sigma is None else False - if trainable and infer_sigma: + infer_parameter = True if sigma is None else False + if trainable and infer_parameter: with pytest.raises(ValueError): - kernel(x_lazy, y_lazy, infer_sigma=infer_sigma) + kernel(x, y, infer_parameter=infer_parameter) else: - k_xy = kernel(x_lazy, y_lazy, infer_sigma=infer_sigma) - k_xx = kernel(x_lazy, x_lazy2, infer_sigma=infer_sigma) + k_xx = kernel(x, x, infer_parameter=infer_parameter) + k_xy = kernel(x, y, infer_parameter=infer_parameter) k_xy_shape = n_instances k_xx_shape = (n_instances[0], n_instances[0]) axis = 1 @@ -66,11 +60,26 @@ def test_gaussian_kernel(gaussian_kernel_params): if has_keops: - class MyKernel(nn.Module): + class MyKernel(BaseKernel): def __init__(self): super().__init__() - def forward(self, x: LazyTensor, y: LazyTensor) -> LazyTensor: + def kernel_function(self, x: torch.Tensor, y: torch.Tensor, + infer_parameter: bool = False) -> LazyTensor: + if len(x.shape) == 3: + x = LazyTensor(x[:, :, None, :]) + elif len(x.shape) == 2: + x = LazyTensor(x[:, None, :]) + else: + raise ValueError('x should be of shape [batch_size, n_instances, features] or [batch_size, features].') + + if len(y.shape) == 3: + y = LazyTensor(y[:, None, :, :]) + elif len(y.shape) == 2: + y = LazyTensor(y[None, :, :]) + else: + raise ValueError('y should be of shape [batch_size, n_instances, features] or [batch_size, features].') + return (- ((x - y) ** 2).sum(-1)).exp() @@ -104,18 +113,10 @@ def test_deep_kernel(deep_kernel_params): xshape, yshape = (n_instances[0], n_features), (n_instances[1], n_features) x = torch.as_tensor(np.random.random(xshape).astype('float32')) y = torch.as_tensor(np.random.random(yshape).astype('float32')) - x_proj, y_proj = kernel.proj(x), kernel.proj(y) - x2_proj, x_proj = LazyTensor(x_proj[None, :, :]), LazyTensor(x_proj[:, None, :]) - y2_proj, y_proj = LazyTensor(y_proj[None, :, :]), LazyTensor(y_proj[:, None, :]) - if kernel_b: - x2, x = LazyTensor(x[None, :, :]), LazyTensor(x[:, None, :]) - y2, y = LazyTensor(y[None, :, :]), LazyTensor(y[:, None, :]) - else: - x, x2, y, y2 = None, None, None, None - k_xy = kernel(x_proj, y2_proj, x, y2) - k_yx = kernel(y_proj, x2_proj, y, x2) - k_xx = kernel(x_proj, x2_proj, x, x2) + k_xy = kernel(x, y) + k_yx = kernel(y, x) + k_xx = kernel(x, x) assert k_xy.shape == n_instances and k_xx.shape == (xshape[0], xshape[0]) assert (k_xx.Kmin_argKmin(1, axis=1)[0] > 0.).all() assert (torch.abs(k_xy.sum(1).sum(1) - k_yx.t().sum(1).sum(1)) < 1e-5).all() diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index dbbeed628..a8009f6ba 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -218,10 +218,11 @@ def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] for k in self.kernel_list: + k.to(x.device) if isinstance(k, (BaseKernel, SumKernel, ProductKernel)): value_list.append(k(x, y, infer_parameter)) elif isinstance(k, torch.Tensor): - value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + value_list.append(k * torch.ones((x.shape[0], y.shape[0]), device=x.device)) else: raise ValueError(type(k) + 'is not supported by SumKernel.') return torch.sum(torch.stack(value_list), dim=0) @@ -294,10 +295,11 @@ def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] for k in self.kernel_factors: + k.to(x.device) if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) elif isinstance(k, torch.Tensor): - value_list.append(k * torch.ones((x.shape[0], y.shape[0]))) + value_list.append(k * torch.ones((x.shape[0], y.shape[0]), device=x.device)) else: raise ValueError(type(k) + 'is not supported by ProductKernel.') return torch.prod(torch.stack(value_list), dim=0) @@ -368,7 +370,7 @@ class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[torch.Tensor] = None, - init_fn_sigma: Optional[Callable] = None, + init_sigma_fn: Optional[Callable] = None, trainable: bool = False, active_dims: list = None ) -> None: @@ -395,11 +397,11 @@ def __init__( Axis of the feature dimension. """ super().__init__(active_dims) - init_fn_sigma = log_sigma_median if init_fn_sigma is None else init_fn_sigma - self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} + self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn} self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_fn_sigma, + init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False, ) @@ -417,6 +419,7 @@ def kernel_function(self, x: torch.Tensor, y: torch.Tensor, if infer_parameter or self.init_required: infer_kernel_parameter(self, x, y, dist, infer_parameter) + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) gamma = 1. / (2. * self.sigma ** 2) # [Ns,] # TODO: do matrix multiplication after all? @@ -453,7 +456,7 @@ def __init__( alpha: torch.Tensor = None, init_fn_alpha: Callable = None, sigma: torch.Tensor = None, - init_fn_sigma: Callable = log_sigma_median, + init_sigma_fn: Callable = log_sigma_median, trainable: bool = False, active_dims: list = None ) -> None: @@ -486,7 +489,7 @@ def __init__( ) self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_fn_sigma, + init_fn=init_sigma_fn, requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -521,7 +524,7 @@ def __init__( tau: torch.Tensor = None, init_fn_tau: Callable = None, sigma: torch.Tensor = None, - init_fn_sigma: Callable = log_sigma_median, + init_sigma_fn: Callable = log_sigma_median, trainable: bool = False, active_dims: list = None ) -> None: @@ -538,7 +541,7 @@ def __init__( Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. - init_fn_sigma + init_sigma_fn Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. trainable Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. @@ -556,7 +559,7 @@ def __init__( ) self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_fn_sigma, + init_fn=init_sigma_fn, requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -645,12 +648,23 @@ def __init__( ) -> None: super().__init__() self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} - proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) + self.proj = proj + self.kernel_a = kernel_a + self.kernel_b = kernel_b + + if hasattr(self.kernel_a, 'parameter_dict'): + for param in self.kernel_a.parameter_dict.keys(): + setattr(self, param, self.kernel_a.parameter_dict[param].value) + + self.proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) - self.comp_kernel = (1-self.logit_eps.sigmoid())*proj_kernel + self.logit_eps.sigmoid()*kernel_b + self.comp_kernel = (1-self.eps)*self.proj_kernel + self.eps*self.kernel_b + if hasattr(self.kernel_b, 'parameter_dict'): + for param in self.kernel_b.parameter_dict.keys(): + setattr(self, param, self.kernel_b.parameter_dict[param].value) else: - self.comp_kernel = proj_kernel + self.comp_kernel = self.proj_kernel def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -662,6 +676,10 @@ def _init_eps(self, eps: Union[float, str]) -> None: else: raise NotImplementedError("eps should be 'trainable' or a float in (0,1)") + @property + def eps(self) -> torch.Tensor: + return self.logit_eps.sigmoid() if self.kernel_b is not None else torch.tensor(0.) + def kernel_function( self, x: torch.Tensor, diff --git a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py index 21129e50e..dbf6efd11 100644 --- a/alibi_detect/utils/pytorch/tests/test_kernels_pt.py +++ b/alibi_detect/utils/pytorch/tests/test_kernels_pt.py @@ -68,11 +68,11 @@ def test_init_fn(init_fn_params): y = torch.from_numpy(np.random.random(yshape)).float() if kernel_ref == 'GaussianRBF': - kernel = GaussianRBF(trainable=trainable, init_fn_sigma=init_fn) + kernel = GaussianRBF(trainable=trainable, init_sigma_fn=init_fn) elif kernel_ref == 'RationalQuadratic': - kernel = RationalQuadratic(trainable=trainable, init_fn_sigma=init_fn) + kernel = RationalQuadratic(trainable=trainable, init_sigma_fn=init_fn) elif kernel_ref == 'Periodic': - kernel = Periodic(trainable=trainable, init_fn_sigma=init_fn) + kernel = Periodic(trainable=trainable, init_sigma_fn=init_fn) else: raise NotImplementedError if trainable: diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 7983a4cef..62d8bc2c7 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -364,7 +364,7 @@ class GaussianRBF(BaseKernel): def __init__( self, sigma: Optional[tf.Tensor] = None, - init_fn_sigma: Optional[Callable] = None, + init_sigma_fn: Optional[Callable] = None, trainable: bool = False, active_dims: list = None ) -> None: @@ -389,12 +389,12 @@ def __init__( Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. """ super().__init__(active_dims) - init_fn_sigma = log_sigma_median if init_fn_sigma is None else init_fn_sigma - self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': init_fn_sigma} + self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn} self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), - init_fn=init_fn_sigma, + init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -412,6 +412,7 @@ def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = Fa if infer_parameter or self.init_required: infer_kernel_parameter(self, x, y, dist, infer_parameter) + self.init_required = any([param.requires_init for param in self.parameter_dict.values()]) gamma = tf.constant(1. / (2. * self.sigma ** 2), dtype=x.dtype) # [Ns,] # TODO: do matrix multiplication after all? @@ -448,7 +449,7 @@ def __init__( alpha: tf.Tensor = None, init_fn_alpha: Callable = None, sigma: tf.Tensor = None, - init_fn_sigma: Callable = log_sigma_median, + init_sigma_fn: Callable = log_sigma_median, trainable: bool = False, active_dims: list = None ) -> None: @@ -483,7 +484,7 @@ def __init__( self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), - init_fn=init_fn_sigma, + init_fn=init_sigma_fn, requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -518,7 +519,7 @@ def __init__( tau: tf.Tensor = None, init_fn_tau: Callable = None, sigma: tf.Tensor = None, - init_fn_sigma: Callable = log_sigma_median, + init_sigma_fn: Callable = log_sigma_median, trainable: bool = False, active_dims: list = None ) -> None: @@ -553,7 +554,7 @@ def __init__( self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), - init_fn=init_fn_sigma, + init_fn=init_sigma_fn, requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -637,6 +638,9 @@ def __init__( eps: Union[float, str] = 'trainable' ) -> None: super().__init__() + self.proj = proj + self.kernel_a = kernel_a + self.kernel_b = kernel_b proj_kernel = ProjKernel(proj=proj, raw_kernel=kernel_a) if kernel_b is not None: self._init_eps(eps) diff --git a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py index c339112b8..80c40498a 100644 --- a/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py +++ b/alibi_detect/utils/tensorflow/tests/test_kernels_tf.py @@ -66,11 +66,11 @@ def test_init_fn(init_fn_params): y = tf.convert_to_tensor(np.random.random(yshape).astype('float32')) if kernel_ref == 'GaussianRBF': - kernel = GaussianRBF(trainable=trainable, init_fn_sigma=init_fn) + kernel = GaussianRBF(trainable=trainable, init_sigma_fn=init_fn) elif kernel_ref == 'RationalQuadratic': - kernel = RationalQuadratic(trainable=trainable, init_fn_sigma=init_fn) + kernel = RationalQuadratic(trainable=trainable, init_sigma_fn=init_fn) elif kernel_ref == 'Periodic': - kernel = Periodic(trainable=trainable, init_fn_sigma=init_fn) + kernel = Periodic(trainable=trainable, init_sigma_fn=init_fn) else: raise NotImplementedError if trainable: From 6cc1798dd035c3cd658f73406caadddc8592b179 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Fri, 24 Feb 2023 10:05:54 +0000 Subject: [PATCH 33/37] Add serialisation for all new kernel classes. --- alibi_detect/cd/base.py | 3 - alibi_detect/cd/keops/mmd.py | 22 ++- alibi_detect/cd/mmd.py | 6 +- alibi_detect/cd/mmd_online.py | 7 +- alibi_detect/cd/pytorch/context_aware.py | 9 +- alibi_detect/cd/pytorch/mmd.py | 21 ++- alibi_detect/cd/pytorch/mmd_online.py | 22 ++- alibi_detect/cd/tensorflow/context_aware.py | 9 +- alibi_detect/cd/tensorflow/mmd.py | 20 ++- alibi_detect/cd/tensorflow/mmd_online.py | 17 ++- alibi_detect/saving/registry.py | 10 +- alibi_detect/saving/schemas.py | 152 ++++++++++++++++++-- alibi_detect/saving/tests/models.py | 31 ++-- alibi_detect/saving/tests/test_saving.py | 48 +++++-- alibi_detect/saving/tests/test_validate.py | 4 +- alibi_detect/utils/pytorch/kernels.py | 123 +++++++++++----- alibi_detect/utils/tensorflow/kernels.py | 115 ++++++++++----- 17 files changed, 423 insertions(+), 196 deletions(-) diff --git a/alibi_detect/cd/base.py b/alibi_detect/cd/base.py index 82d7ac7b7..b09754312 100644 --- a/alibi_detect/cd/base.py +++ b/alibi_detect/cd/base.py @@ -535,9 +535,6 @@ def __init__( for reservoir sampling {'reservoir_sampling': n} is passed. preprocess_fn Function to preprocess the data before computing the data drift metrics. - sigma - Optionally set the Gaussian RBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. configure_kernel_from_x_ref Whether to already configure the kernel bandwidth from the reference data. n_permutations diff --git a/alibi_detect/cd/keops/mmd.py b/alibi_detect/cd/keops/mmd.py index e44710e08..3b93d50fb 100644 --- a/alibi_detect/cd/keops/mmd.py +++ b/alibi_detect/cd/keops/mmd.py @@ -19,8 +19,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: BaseKernel = GaussianRBF(), - sigma: Optional[np.ndarray] = None, + kernel: Union[BaseKernel, Callable] = GaussianRBF, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, batch_size_permutations: int = 1000000, @@ -52,9 +51,6 @@ def __init__( Function to preprocess the data before computing the data drift metrics. kernel Kernel used for the MMD computation, defaults to Gaussian RBF kernel. - sigma - Optionally set the GaussianRBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. configure_kernel_from_x_ref Whether to already configure the kernel bandwidth from the reference data. n_permutations @@ -86,15 +82,13 @@ def __init__( # set device self.device = get_device(device) - # initialize kernel - self.kernel = kernel - - if isinstance(self.kernel, GaussianRBF) & (sigma is not None): - self.kernel.parameter_dict['log-sigma'].value = torch.nn.Parameter( - torch.tensor(sigma).to(self.device).log(), - requires_grad=False) - self.kernel.parameter_dict['log-sigma'].requires_init = False - self.kernel.init_required = False + # initialise kernel + if isinstance(kernel, BaseKernel): + self.kernel = kernel + elif kernel == GaussianRBF: + self.kernel = kernel() + else: + raise ValueError("kernel must be an instance of alibi_detect.utils.keops.kernels.BaseKernel or a callable ") self.kernel_parameter_specified = True if hasattr(kernel, 'parameter_dict'): diff --git a/alibi_detect/cd/mmd.py b/alibi_detect/cd/mmd.py index 23f59c8fb..92da1f3c8 100644 --- a/alibi_detect/cd/mmd.py +++ b/alibi_detect/cd/mmd.py @@ -29,7 +29,6 @@ def __init__( update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, kernel: Callable = None, - sigma: Optional[Union[np.ndarray, float]] = None, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, batch_size_permutations: int = 1000000, @@ -63,9 +62,6 @@ def __init__( Function to preprocess the data before computing the data drift metrics. kernel Kernel used for the MMD computation, defaults to Gaussian RBF kernel. - sigma - Optionally set the GaussianRBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. configure_kernel_from_x_ref Whether to already configure the kernel bandwidth from the reference data. n_permutations @@ -114,7 +110,7 @@ def __init__( from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore else: from alibi_detect.utils.keops.kernels import GaussianRBF # type: ignore - kwargs.update({'kernel': GaussianRBF()}) + kwargs.update({'kernel': GaussianRBF}) self._detector = detector(*args, **kwargs) # type: ignore self.meta = self._detector.meta diff --git a/alibi_detect/cd/mmd_online.py b/alibi_detect/cd/mmd_online.py index 8028e8fd3..cee60e17b 100644 --- a/alibi_detect/cd/mmd_online.py +++ b/alibi_detect/cd/mmd_online.py @@ -22,7 +22,6 @@ def __init__( preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, kernel: Optional[Union[BaseKernelTorch, BaseKernelTF]] = None, - sigma: Optional[Union[np.ndarray, float]] = None, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -53,10 +52,6 @@ def __init__( data will also be preprocessed. kernel Kernel used for the MMD computation, defaults to Gaussian RBF kernel. - sigma - Optionally set the GaussianRBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. If `sigma` is not specified, the 'median - heuristic' is adopted whereby `sigma` is set as the median pairwise distance between reference samples. n_bootstraps The number of bootstrap simulations used to configure the thresholds. The larger this is the more accurately the desired ERT will be targeted. Should ideally be at least an order of magnitude @@ -93,7 +88,7 @@ def __init__( from alibi_detect.utils.tensorflow.kernels import GaussianRBF else: from alibi_detect.utils.pytorch.kernels import GaussianRBF # type: ignore - kwargs.update({'kernel': GaussianRBF()}) + kwargs.update({'kernel': GaussianRBF}) if backend == Framework.TENSORFLOW: kwargs.pop('device', None) diff --git a/alibi_detect/cd/pytorch/context_aware.py b/alibi_detect/cd/pytorch/context_aware.py index 9a067dff7..d3e2b89de 100644 --- a/alibi_detect/cd/pytorch/context_aware.py +++ b/alibi_detect/cd/pytorch/context_aware.py @@ -49,8 +49,8 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), - c_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), + x_kernel: Union[BaseKernel, Callable] = GaussianRBF, + c_kernel: Union[BaseKernel, Callable] = GaussianRBF, n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -130,8 +130,9 @@ def __init__( # set device self.device = get_device(device) - self.x_kernel = x_kernel - self.c_kernel = c_kernel + # initialize kernel + self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel + self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: diff --git a/alibi_detect/cd/pytorch/mmd.py b/alibi_detect/cd/pytorch/mmd.py index 8ffaa6e92..8df7f8c97 100644 --- a/alibi_detect/cd/pytorch/mmd.py +++ b/alibi_detect/cd/pytorch/mmd.py @@ -22,8 +22,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: BaseKernel = GaussianRBF(), - sigma: Optional[Union[np.ndarray, float]] = None, + kernel: Union[BaseKernel, Callable] = GaussianRBF, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, device: Optional[str] = None, @@ -54,9 +53,6 @@ def __init__( Function to preprocess the data before computing the data drift metrics. kernel Kernel used for the MMD computation, defaults to Gaussian RBF kernel. - sigma - Optionally set the GaussianRBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. configure_kernel_from_x_ref Whether to already configure the kernel bandwidth from the reference data. n_permutations @@ -86,14 +82,13 @@ def __init__( # set device self.device = get_device(device) - self.kernel = kernel - - if isinstance(self.kernel, GaussianRBF) & (sigma is not None): - self.kernel.parameter_dict['log-sigma'].value = torch.nn.Parameter( - torch.tensor(sigma).to(self.device).log(), - requires_grad=False) - self.kernel.parameter_dict['log-sigma'].requires_init = False - self.kernel.init_required = False + # initialise kernel + if isinstance(kernel, BaseKernel): + self.kernel = kernel + elif kernel == GaussianRBF: + self.kernel = kernel() + else: + raise ValueError("kernel must be an instance of alibi_detect.utils.pytorch.kernels.BaseKernel") self.kernel_parameter_specified = True if hasattr(kernel, 'parameter_dict'): diff --git a/alibi_detect/cd/pytorch/mmd_online.py b/alibi_detect/cd/pytorch/mmd_online.py index faf2dc4de..12d9760c5 100644 --- a/alibi_detect/cd/pytorch/mmd_online.py +++ b/alibi_detect/cd/pytorch/mmd_online.py @@ -17,8 +17,7 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - kernel: BaseKernel = GaussianRBF(), - sigma: Optional[Union[np.ndarray, float]] = None, + kernel: Union[BaseKernel, Callable] = GaussianRBF, n_bootstraps: int = 1000, device: Optional[str] = None, verbose: bool = True, @@ -47,10 +46,6 @@ def __init__( data will also be preprocessed. kernel Kernel used for the MMD computation, defaults to Gaussian RBF kernel. - sigma - Optionally set the GaussianRBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. If `sigma` is not specified, the 'median - heuristic' is adopted whereby `sigma` is set as the median pairwise distance between reference samples. n_bootstraps The number of bootstrap simulations used to configure the thresholds. The larger this is the more accurately the desired ERT will be targeted. Should ideally be at least an order of magnitude @@ -81,14 +76,13 @@ def __init__( # set device self.device = get_device(device) - self.kernel = kernel - - if isinstance(self.kernel, GaussianRBF) & (sigma is not None): - self.kernel.parameter_dict['log-sigma'].value = torch.nn.Parameter( - torch.tensor(sigma).to(self.device).log(), - requires_grad=False) - self.kernel.parameter_dict['log-sigma'].requires_init = False - self.kernel.init_required = False + # initialise kernel + if isinstance(kernel, BaseKernel): + self.kernel = kernel + elif kernel == GaussianRBF: + self.kernel = kernel() + else: + raise ValueError("kernel must be an instance of alibi_detect.utils.pytorch.kernels.BaseKernel") # compute kernel matrix for the reference data self.x_ref = torch.from_numpy(self.x_ref).to(self.device) diff --git a/alibi_detect/cd/tensorflow/context_aware.py b/alibi_detect/cd/tensorflow/context_aware.py index 65596891a..3181267bd 100644 --- a/alibi_detect/cd/tensorflow/context_aware.py +++ b/alibi_detect/cd/tensorflow/context_aware.py @@ -49,8 +49,8 @@ def __init__( preprocess_at_init: bool = True, update_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - x_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), - c_kernel: BaseKernel = GaussianRBF(init_sigma_fn=_sigma_median_diag), + x_kernel: Union[BaseKernel, Callable] = GaussianRBF, + c_kernel: Union[BaseKernel, Callable] = GaussianRBF, n_permutations: int = 1000, prop_c_held: float = 0.25, n_folds: int = 5, @@ -123,8 +123,9 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - self.x_kernel = x_kernel - self.c_kernel = c_kernel + # initialize kernel + self.x_kernel = x_kernel(init_sigma_fn=_sigma_median_diag) if x_kernel == GaussianRBF else x_kernel + self.c_kernel = c_kernel(init_sigma_fn=_sigma_median_diag) if c_kernel == GaussianRBF else c_kernel def score(self, # type: ignore[override] x: Union[np.ndarray, list], c: np.ndarray) -> Tuple[float, float, float, Tuple]: diff --git a/alibi_detect/cd/tensorflow/mmd.py b/alibi_detect/cd/tensorflow/mmd.py index 80eb2d997..d6d7aa693 100644 --- a/alibi_detect/cd/tensorflow/mmd.py +++ b/alibi_detect/cd/tensorflow/mmd.py @@ -21,8 +21,7 @@ def __init__( preprocess_at_init: bool = True, update_x_ref: Optional[Dict[str, int]] = None, preprocess_fn: Optional[Callable] = None, - kernel: BaseKernel = GaussianRBF(), - sigma: Optional[Union[np.ndarray, float]] = None, + kernel: Union[BaseKernel, Callable] = GaussianRBF, configure_kernel_from_x_ref: bool = True, n_permutations: int = 100, input_shape: Optional[tuple] = None, @@ -52,9 +51,6 @@ def __init__( Function to preprocess the data before computing the data drift metrics. kernel Kernel used for the MMD computation, defaults to Gaussian RBF kernel. - sigma - Optionally set the GaussianRBF kernel bandwidth. Can also pass multiple bandwidth values as an array. - The kernel evaluation is then averaged over those bandwidths. configure_kernel_from_x_ref Whether to already configure the kernel bandwidth from the reference data. n_permutations @@ -78,13 +74,13 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - self.kernel = kernel - - if isinstance(self.kernel, GaussianRBF) & (sigma is not None): - self.kernel.parameter_dict['log-sigma'].value.assign(tf.cast(np.log(sigma), - tf.keras.backend.floatx())) - self.kernel.parameter_dict['log-sigma'].requires_init = False - self.kernel.init_required = False + # initialise kernel + if isinstance(kernel, BaseKernel): + self.kernel = kernel + elif kernel == GaussianRBF: + self.kernel = kernel() + else: + raise ValueError("kernel must be an instance of alibi_detect.utils.tensorflow.kernels.BaseKernel") self.kernel_parameter_specified = True if hasattr(kernel, 'parameter_dict'): diff --git a/alibi_detect/cd/tensorflow/mmd_online.py b/alibi_detect/cd/tensorflow/mmd_online.py index f55858d90..5ae31c760 100644 --- a/alibi_detect/cd/tensorflow/mmd_online.py +++ b/alibi_detect/cd/tensorflow/mmd_online.py @@ -16,8 +16,7 @@ def __init__( window_size: int, preprocess_fn: Optional[Callable] = None, x_ref_preprocessed: bool = False, - kernel: BaseKernel = GaussianRBF(), - sigma: Optional[Union[np.ndarray, float]] = None, + kernel: Union[BaseKernel, Callable] = GaussianRBF, n_bootstraps: int = 1000, verbose: bool = True, input_shape: Optional[tuple] = None, @@ -73,13 +72,13 @@ def __init__( ) self.meta.update({'backend': Framework.TENSORFLOW.value}) - self.kernel = kernel - - if isinstance(self.kernel, GaussianRBF) & (sigma is not None): - self.kernel.parameter_dict['log-sigma'].value.assign(tf.cast(np.log(sigma), - tf.keras.backend.floatx())) - self.kernel.parameter_dict['log-sigma'].requires_init = False - self.kernel.init_required = False + # initialise kernel + if isinstance(kernel, BaseKernel): + self.kernel = kernel + elif kernel == GaussianRBF: + self.kernel = kernel() + else: + raise ValueError("kernel must be an instance of alibi_detect.utils.tensorflow.kernels.BaseKernel") # compute kernel matrix for the reference data self.k_xx = self.kernel(self.x_ref, self.x_ref, infer_parameter=self.kernel.init_required) diff --git a/alibi_detect/saving/registry.py b/alibi_detect/saving/registry.py index eda22f1e1..cc380e36b 100644 --- a/alibi_detect/saving/registry.py +++ b/alibi_detect/saving/registry.py @@ -43,7 +43,8 @@ def my_function(x: np.ndarray) -> np.ndarray: from alibi_detect.utils.tensorflow.data import TFDataset as TFDataset_tf from alibi_detect.utils.tensorflow.kernels import \ GaussianRBF as GaussianRBF_tf, sigma_median as sigma_median_tf, \ - log_sigma_median as log_sigma_median_tf + log_sigma_median as log_sigma_median_tf, RationalQuadratic as RationalQuadratic_tf, \ + Periodic as Periodic_tf from alibi_detect.cd.tensorflow.context_aware import _sigma_median_diag as _sigma_median_diag_tf if has_pytorch: @@ -51,7 +52,8 @@ def my_function(x: np.ndarray) -> np.ndarray: preprocess_drift as preprocess_drift_torch from alibi_detect.utils.pytorch.kernels import \ GaussianRBF as GaussianRBF_torch, sigma_median as sigma_median_torch, \ - log_sigma_median as log_sigma_median_torch + log_sigma_median as log_sigma_median_torch, RationalQuadratic as RationalQuadratic_torch, \ + Periodic as Periodic_torch from alibi_detect.cd.pytorch.context_aware import _sigma_median_diag as _sigma_median_diag_torch # Create registry @@ -60,6 +62,8 @@ def my_function(x: np.ndarray) -> np.ndarray: # Register alibi-detect classes/functions if has_tensorflow: registry.register('utils.tensorflow.kernels.GaussianRBF', func=GaussianRBF_tf) + registry.register('utils.tensorflow.kernels.RationalQuadratic', func=RationalQuadratic_tf) + registry.register('utils.tensorflow.kernels.Periodic', func=Periodic_tf) registry.register('utils.tensorflow.kernels.sigma_median', func=sigma_median_tf) registry.register('utils.tensorflow.kernels.log_sigma_median', func=log_sigma_median_tf) registry.register('cd.tensorflow.context_aware._sigma_median_diag', func=_sigma_median_diag_tf) @@ -68,6 +72,8 @@ def my_function(x: np.ndarray) -> np.ndarray: if has_pytorch: registry.register('utils.pytorch.kernels.GaussianRBF', func=GaussianRBF_torch) + registry.register('utils.pytorch.kernels.RationalQuadratic', func=RationalQuadratic_torch) + registry.register('utils.pytorch.kernels.Periodic', func=Periodic_torch) registry.register('utils.pytorch.kernels.sigma_median', func=sigma_median_torch) registry.register('utils.pytorch.kernels.log_sigma_median', func=log_sigma_median_torch) registry.register('cd.pytorch.context_aware._sigma_median_diag', func=_sigma_median_diag_torch) diff --git a/alibi_detect/saving/schemas.py b/alibi_detect/saving/schemas.py index 68a902929..af88f33fc 100644 --- a/alibi_detect/saving/schemas.py +++ b/alibi_detect/saving/schemas.py @@ -320,7 +320,7 @@ class PreprocessConfig(CustomBaseModel): """ -class KernelConfig(CustomBaseModelWithKwargs): +class RBFKernelConfig(CustomBaseModelWithKwargs): """ Unresolved schema for kernels, to be passed to a detector's `kernel` kwarg. @@ -374,6 +374,136 @@ class KernelConfig(CustomBaseModelWithKwargs): _coerce_sigma2tensor = validator('sigma', allow_reuse=True, pre=False)(coerce_2_tensor) +class RationalQuadraticKernelConfig(CustomBaseModelWithKwargs): + """ + Unresolved schema for kernels, to be passed to a detector's `kernel` kwarg. + + If `src` specifies a :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, the `sigma`, `trainable` and + `init_sigma_fn` fields are passed to it. Otherwise, all fields except `src` are passed as kwargs. + + Examples + -------- + A :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, with three different bandwidths: + + .. code-block :: toml + + [kernel] + src = "@alibi_detect.utils.tensorflow.GaussianRBF" + trainable = false + sigma = [0.1, 0.2, 0.3] + + A serialized kernel with keyword arguments passed: + + .. code-block :: toml + + [kernel] + src = "mykernel.dill" + sigma = 0.42 + custom_setting = "xyz" + """ + src: str + "A string referencing a filepath to a serialized kernel in `.dill` format, or an object registry reference." + + # Below kwargs are only passed if kernel == @GaussianRBF + flavour: Literal['tensorflow', 'pytorch'] + """ + Whether the kernel is a `tensorflow` or `pytorch` kernel. + """ + sigma: Optional[Union[float, List[float]]] = None + """ + Bandwidth used for the kernel. Needn’t be specified if being inferred or trained. Can pass multiple values to eval + kernel with and then average. + """ + alpha: Optional[Union[float, List[float]]] = None + """ + Exponent used for the kernel. Needn’t be specified if being inferred or trained. Can pass multiple values to eval + kernel with and then average. + """ + trainable: bool = False + "Whether or not to track gradients w.r.t. sigma to allow it to be trained." + + init_sigma_fn: Optional[str] = None + """ + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. The function's signature + should match :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. If `None`, it is set to + :func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. + """ + init_alpha_fn: Optional[str] = None + """ + Function used to compute the exponent `alpha`. Used when `alpha` is to be inferred. The function's signature + should match :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. Defaults to None. + """ + # Validators + _validate_flavour = validator('flavour', allow_reuse=True, pre=False)(validate_framework) + _coerce_sigma2tensor = validator('sigma', allow_reuse=True, pre=False)(coerce_2_tensor) + _coerce_alpha2tensor = validator('alpha', allow_reuse=True, pre=False)(coerce_2_tensor) + + +class PeriodicKernelConfig(CustomBaseModelWithKwargs): + """ + Unresolved schema for kernels, to be passed to a detector's `kernel` kwarg. + + If `src` specifies a :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, the `sigma`, `trainable` and + `init_sigma_fn` fields are passed to it. Otherwise, all fields except `src` are passed as kwargs. + + Examples + -------- + A :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, with three different bandwidths: + + .. code-block :: toml + + [kernel] + src = "@alibi_detect.utils.tensorflow.GaussianRBF" + trainable = false + sigma = [0.1, 0.2, 0.3] + + A serialized kernel with keyword arguments passed: + + .. code-block :: toml + + [kernel] + src = "mykernel.dill" + sigma = 0.42 + custom_setting = "xyz" + """ + src: str + "A string referencing a filepath to a serialized kernel in `.dill` format, or an object registry reference." + + # Below kwargs are only passed if kernel == @GaussianRBF + flavour: Literal['tensorflow', 'pytorch'] + """ + Whether the kernel is a `tensorflow` or `pytorch` kernel. + """ + sigma: Optional[Union[float, List[float]]] = None + """ + Bandwidth used for the kernel. Needn’t be specified if being inferred or trained. Can pass multiple values to eval + kernel with and then average. + """ + tau: Optional[Union[float, List[float]]] = None + """ + Period used for the kernel. Needn’t be specified if being inferred or trained. Can pass multiple values to eval + kernel with and then average. + """ + trainable: bool = False + "Whether or not to track gradients w.r.t. sigma to allow it to be trained." + + init_sigma_fn: Optional[str] = None + """ + Function used to compute the bandwidth `sigma`. Used when `sigma` is to be inferred. The function's signature + should match :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. If `None`, it is set to + :func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. + """ + init_tau_fn: Optional[str] = None + """ + Function used to compute the period `tau`. Used when `tau` is to be inferred. The function's signature + should match :py:func:`~alibi_detect.utils.tensorflow.kernels.sigma_median`. Defaults to None. + """ + # Validators + _validate_flavour = validator('flavour', allow_reuse=True, pre=False)(validate_framework) + _coerce_sigma2tensor = validator('sigma', allow_reuse=True, pre=False)(coerce_2_tensor) + _coerce_tau2tensor = validator('tau', allow_reuse=True, pre=False)(coerce_2_tensor) + + class DeepKernelConfig(CustomBaseModel): """ Unresolved schema for :class:`~alibi_detect.utils.tensorflow.kernels.DeepKernel`'s. @@ -406,12 +536,14 @@ class DeepKernelConfig(CustomBaseModel): The projection to be applied to the inputs before applying `kernel_a`. This should be a Tensorflow or PyTorch model, specified as an object registry reference, or a :class:`~alibi_detect.utils.schemas.ModelConfig`. """ - kernel_a: Union[str, KernelConfig] = "@utils.tensorflow.kernels.GaussianRBF" + kernel_a: Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]\ + = "@utils.tensorflow.kernels.GaussianRBF" """ The kernel to apply to the projected inputs. Defaults to a :class:`~alibi_detect.utils.tensorflow.kernels.GaussianRBF` with trainable bandwidth. """ - kernel_b: Optional[Union[str, KernelConfig]] = "@utils.tensorflow.kernels.GaussianRBF" + kernel_b: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]]\ + = "@utils.tensorflow.kernels.GaussianRBF" """ The kernel to apply to the raw inputs. Defaults to a :class:`~alibi_detect.utils.tensorflow.kernels.GaussianRBF` with trainable bandwidth. Set to `None` in order to use only the deep component (i.e. `eps=0`). @@ -677,8 +809,7 @@ class MMDDriftConfig(DriftDetectorConfig): p_val: float = .05 preprocess_at_init: bool = True update_x_ref: Optional[Dict[str, int]] = None - kernel: Optional[Union[str, KernelConfig]] = None - sigma: Optional[NDArray[np.float32]] = None + kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None configure_kernel_from_x_ref: bool = True n_permutations: int = 100 batch_size_permutations: int = 1000000 @@ -698,7 +829,6 @@ class MMDDriftConfigResolved(DriftDetectorConfigResolved): preprocess_at_init: bool = True update_x_ref: Optional[Dict[str, int]] = None kernel: Optional[Callable] = None - sigma: Optional[NDArray[np.float32]] = None configure_kernel_from_x_ref: bool = True n_permutations: int = 100 batch_size_permutations: int = 1000000 @@ -839,7 +969,7 @@ class SpotTheDiffDriftConfig(DriftDetectorConfig): verbose: int = 0 train_kwargs: Optional[dict] = None dataset: Optional[str] = None - kernel: Optional[Union[str, KernelConfig]] = None + kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None n_diffs: int = 1 initial_diffs: Optional[str] = None l1_reg: float = 0.01 @@ -959,8 +1089,8 @@ class ContextMMDDriftConfig(DriftDetectorConfig): c_ref: str preprocess_at_init: bool = True update_ref: Optional[Dict[str, int]] = None - x_kernel: Optional[Union[str, KernelConfig]] = None - c_kernel: Optional[Union[str, KernelConfig]] = None + x_kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None + c_kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None n_permutations: int = 100 prop_c_held: float = 0.25 n_folds: int = 5 @@ -1004,8 +1134,7 @@ class MMDDriftOnlineConfig(DriftDetectorConfig): backend: Literal['tensorflow', 'pytorch'] = 'tensorflow' ert: float window_size: int - kernel: Optional[Union[str, KernelConfig]] = None - sigma: Optional[np.ndarray] = None + kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None n_bootstraps: int = 1000 device: Optional[Literal['cpu', 'cuda']] = None verbose: bool = True @@ -1024,7 +1153,6 @@ class MMDDriftOnlineConfigResolved(DriftDetectorConfigResolved): ert: float window_size: int kernel: Optional[Callable] = None - sigma: Optional[np.ndarray] = None n_bootstraps: int = 1000 device: Optional[Literal['cpu', 'cuda']] = None verbose: bool = True diff --git a/alibi_detect/saving/tests/models.py b/alibi_detect/saving/tests/models.py index 405a1608f..07c81390f 100644 --- a/alibi_detect/saving/tests/models.py +++ b/alibi_detect/saving/tests/models.py @@ -104,21 +104,18 @@ def preprocess_custom(encoder_model): @fixture def kernel(request, backend): """ - Gaussian RBF kernel for given backend. Settings are parametrised in the test function. + Kernel for given backend. Settings are parametrised in the test function. """ kernel = request.param if isinstance(kernel, dict): # dict of kwargs - kernel_cfg = kernel.copy() - sigma = kernel_cfg.pop('sigma', None) + kernel_meta_cfg = kernel.copy() + kernel_name = kernel_meta_cfg['kernel_name'] + kernel_cfg = kernel_meta_cfg['kernel_config'] if backend == 'tensorflow': - if sigma is not None and not isinstance(sigma, tf.Tensor): - sigma = tf.convert_to_tensor(sigma) - kernel = GaussianRBF_tf(sigma=sigma, **kernel_cfg) + kernel = initial_kernel_tf(kernel_name, kernel_cfg) elif backend == 'pytorch': - if sigma is not None and not isinstance(sigma, torch.Tensor): - sigma = torch.tensor(sigma) - kernel = GaussianRBF_pt(sigma=sigma, **kernel_cfg) + kernel = initial_kernel_pt(kernel_name, kernel_cfg) else: pytest.skip('`kernel` only implemented for tensorflow and pytorch.') return kernel @@ -173,8 +170,12 @@ def deep_kernel(request, backend, encoder_model): def initial_kernel_tf(kernel_name, kernel_config): - if 'sigma' in kernel_config: - kernel_config['sigma'] = tf.constant(kernel_config['sigma']) + if ('sigma' in kernel_config) and (kernel_config['sigma'] is not None): + kernel_config['sigma'] = tf.convert_to_tensor(np.array(kernel_config['sigma'])) + if ('alpha' in kernel_config) and (kernel_config['alpha'] is not None): + kernel_config['alpha'] = tf.convert_to_tensor(np.array(kernel_config['alpha'])) + if ('tau' in kernel_config) and (kernel_config['tau'] is not None): + kernel_config['tau'] = tf.convert_to_tensor(np.array(kernel_config['tau'])) if kernel_name == 'GaussianRBF': kernel = GaussianRBF_tf(**kernel_config) elif kernel_name == 'RationalQuadratic': @@ -187,8 +188,12 @@ def initial_kernel_tf(kernel_name, kernel_config): def initial_kernel_pt(kernel_name, kernel_config): - if 'sigma' in kernel_config: - kernel_config['sigma'] = torch.tensor(kernel_config['sigma']) + if ('sigma' in kernel_config) and (kernel_config['sigma'] is not None): + kernel_config['sigma'] = torch.tensor(np.array(kernel_config['sigma'])) + if ('alpha' in kernel_config) and (kernel_config['alpha'] is not None): + kernel_config['alpha'] = torch.tensor(np.array(kernel_config['alpha'])) + if ('tau' in kernel_config) and (kernel_config['tau'] is not None): + kernel_config['tau'] = torch.tensor(np.array(kernel_config['tau'])) if kernel_name == 'GaussianRBF': kernel = GaussianRBF_pt(**kernel_config) elif kernel_name == 'RationalQuadratic': diff --git a/alibi_detect/saving/tests/test_saving.py b/alibi_detect/saving/tests/test_saving.py index c35c408c2..320912b14 100644 --- a/alibi_detect/saving/tests/test_saving.py +++ b/alibi_detect/saving/tests/test_saving.py @@ -42,7 +42,8 @@ from alibi_detect.saving.saving import _serialize_object from alibi_detect.saving.saving import (_path2str, _int2str_keys, _save_kernel_config, _save_model_config, _save_preprocess_config) -from alibi_detect.saving.schemas import DeepKernelConfig, KernelConfig, ModelConfig, PreprocessConfig +from alibi_detect.saving.schemas import DeepKernelConfig, ModelConfig, PreprocessConfig, RBFKernelConfig,\ + RationalQuadraticKernelConfig, PeriodicKernelConfig from alibi_detect.utils.pytorch.kernels import DeepKernel as DeepKernel_pt from alibi_detect.utils.tensorflow.kernels import DeepKernel as DeepKernel_tf @@ -192,7 +193,9 @@ def test_save_cvmdrift(data, preprocess_custom, tmp_path): @parametrize('kernel', [ None, # Use default kernel - {'sigma': 0.5, 'trainable': False}, # pass kernel as object + {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': False}}, # pass kernel as object + {'kernel_name': 'RationalQuadratic', 'kernel_config': {'sigma': 0.5, 'alpha': 4.0, 'trainable': False}}, + {'kernel_name': 'Periodic', 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False}}, ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -213,8 +216,7 @@ def test_save_mmddrift(data, kernel, preprocess_custom, backend, tmp_path, seed) 'n_permutations': N_PERMUTATIONS, 'preprocess_at_init': True, 'kernel': kernel, - 'configure_kernel_from_x_ref': False, - 'sigma': np.array([0.5]) + 'configure_kernel_from_x_ref': False } if backend == 'pytorch': kwargs['device'] = 'cuda' if torch.cuda.is_available() else 'cpu' @@ -501,7 +503,11 @@ def test_save_learnedkernel(data, deep_kernel, backend, tmp_path, seed): # noqa @parametrize('kernel', [ None, # Default kernel - {'sigma': 0.5, 'trainable': False}, # pass kernels as GaussianRBF objects, with default sigma_median fn + {'kernel_name': 'GaussianRBF', + 'kernel_config': {'sigma': 0.5, 'trainable': False}}, + # pass kernels as GaussianRBF objects, with default sigma_median fn + {'kernel_name': 'RationalQuadratic', 'kernel_config': {'sigma': 0.5, 'alpha': 4.0, 'trainable': False}}, + {'kernel_name': 'Periodic', 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False}}, ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -614,7 +620,9 @@ def test_save_regressoruncertaintydrift(data, regressor, backend, tmp_path, seed @parametrize('kernel', [ None, # Use default kernel - {'sigma': 0.5, 'trainable': False}, # pass kernel as object + {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': False}}, # pass kernel as object + {'kernel_name': 'RationalQuadratic', 'kernel_config': {'sigma': 0.5, 'alpha': 4.0, 'trainable': False}}, + {'kernel_name': 'Periodic', 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False}}, ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -858,9 +866,22 @@ def test_version_warning(data, tmp_path): @parametrize('kernel', [ - {'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, - {'sigma': [0.5, 0.8], 'trainable': False, 'init_sigma_fn': None}, - {'sigma': None, 'trainable': True, 'init_sigma_fn': None}, + {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_name': 'GaussianRBF', + 'kernel_config': {'sigma': [0.5, 0.8], 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': None, 'trainable': True, 'init_sigma_fn': None}}, + {'kernel_name': 'RationalQuadratic', + 'kernel_config': {'sigma': 0.5, 'alpha': 3.0, 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_name': 'RationalQuadratic', + 'kernel_config': {'sigma': [0.5, 0.8], 'alpha': [2.0, 3.0], 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_name': 'RationalQuadratic', + 'kernel_config': {'sigma': None, 'alpha': None, 'trainable': True, 'init_sigma_fn': None}}, + {'kernel_name': 'Periodic', + 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_name': 'Periodic', + 'kernel_config': {'sigma': [0.5, 0.8], 'tau': [2.0, 3.0], 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_name': 'Periodic', + 'kernel_config': {'sigma': None, 'tau': None, 'trainable': True, 'init_sigma_fn': None}}, ], indirect=True ) def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 @@ -873,9 +894,15 @@ def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 filepath = tmp_path filename = Path('mykernel') cfg_kernel = _save_kernel_config(kernel, filepath, filename) - cfg_kernel = KernelConfig(**cfg_kernel).dict() # Pass through validator to test, and coerce sigma to Tensor if kernel.__class__.__name__ == 'GaussianRBF': assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.GaussianRBF' + cfg_kernel = RBFKernelConfig(**cfg_kernel).dict() # Pass through validator to test, and coerce sigma to Tensor + elif kernel.__class__.__name__ == 'RationalQuadratic': + assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.RationalQuadratic' + cfg_kernel = RationalQuadraticKernelConfig(**cfg_kernel).dict() # Pass through validator to test + elif kernel.__class__.__name__ == 'Periodic': + assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.Periodic' + cfg_kernel = PeriodicKernelConfig(**cfg_kernel).dict() # Pass through validator to test else: assert Path(cfg_kernel['src']).suffix == '.dill' assert cfg_kernel['trainable'] == kernel.trainable @@ -907,7 +934,6 @@ def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 assert kernel_loaded.trainable == kernel.trainable for tmp_key in kernel.parameter_dict.keys(): assert kernel_loaded.parameter_dict[tmp_key].init_fn == kernel.parameter_dict[tmp_key].init_fn - # assert kernel_loaded.init_sigma_fn == kernel.init_sigma_fn # `data` passed below as needed in encoder_model, which is used in deep_kernel diff --git a/alibi_detect/saving/tests/test_validate.py b/alibi_detect/saving/tests/test_validate.py index b9a777209..08df9cc04 100644 --- a/alibi_detect/saving/tests/test_validate.py +++ b/alibi_detect/saving/tests/test_validate.py @@ -3,7 +3,7 @@ from pydantic import ValidationError from alibi_detect.saving import validate_config -from alibi_detect.saving.schemas import KernelConfig +from alibi_detect.saving.schemas import RBFKernelConfig from alibi_detect.saving.saving import X_REF_FILENAME from alibi_detect.version import __version__ from copy import deepcopy @@ -105,7 +105,7 @@ def test_validate_kernel_and_coerce_2_tensor(flavour, sigma): } # Pass through validation and check results - kernel_cfg_val = KernelConfig(**kernel_cfg).dict() + kernel_cfg_val = RBFKernelConfig(**kernel_cfg).dict() assert kernel_cfg_val['src'] == kernel_cfg['src'] assert kernel_cfg_val['flavour'] == flavour if sigma is None: diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index a8009f6ba..ff992d4ab 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -205,6 +205,25 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = torch.tensor(np.array(config['sigma'])) + if 'alpha' in config and config['alpha'] is not None: + config['alpha'] = torch.tensor(np.array(config['alpha'])) + if 'tau' in config and config['tau'] is not None: + config['tau'] = torch.tensor(np.array(config['tau'])) + return cls(**config) + class SumKernel(BaseKernel): def __init__(self) -> None: @@ -372,7 +391,7 @@ def __init__( sigma: Optional[torch.Tensor] = None, init_sigma_fn: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None + active_dims: Optional[list] = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -398,9 +417,10 @@ def __init__( """ super().__init__(active_dims) self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn - self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn} + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn, + 'active_dims': active_dims} self.parameter_dict['log-sigma'] = KernelParameter( - value=sigma.log().reshape(-1) if sigma is not None else None, + value=sigma.log().reshape(-1) if sigma is not None else torch.zeros(1), init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False, @@ -428,7 +448,7 @@ def kernel_function(self, x: torch.Tensor, y: torch.Tensor, def get_config(self) -> dict: """ - Returns a serializable config dict (excluding the input_sigma_fn, which is serialized in alibi_detect.saving). + Returns a serializable config dict (excluding the infer_sigma_fn, which is serialized in alibi_detect.saving). """ cfg = self.config.copy() if isinstance(cfg['sigma'], torch.Tensor): @@ -436,29 +456,16 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.PYTORCH.value}) return cfg - @classmethod - def from_config(cls, config): - """ - Instantiates a kernel from a config dictionary. - - Parameters - ---------- - config - A kernel config dictionary. - """ - config.pop('flavour') - return cls(**config) - class RationalQuadratic(BaseKernel): def __init__( self, - alpha: torch.Tensor = None, - init_fn_alpha: Callable = None, - sigma: torch.Tensor = None, - init_sigma_fn: Callable = log_sigma_median, + alpha: Optional[torch.Tensor] = None, + init_alpha_fn: Optional[Callable] = None, + sigma: Optional[torch.Tensor] = None, + init_sigma_fn: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None + active_dims: Optional[list] = None ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -481,15 +488,22 @@ def __init__( Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. """ super().__init__(active_dims) - self.parameter_dict['alpha'] = KernelParameter( - value=alpha.reshape(-1) if alpha is not None else None, - init_fn=init_fn_alpha, + if alpha is not None and sigma is not None: + if alpha.shape != sigma.shape: + raise ValueError('alpha and sigma must have the same shape.') + self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn + self.init_alpha_fn = init_alpha_fn + self.config = {'alpha': alpha, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, + 'init_alpha_fn': self.init_alpha_fn, 'init_sigma_fn': self.init_sigma_fn} + self.parameter_dict['log-alpha'] = KernelParameter( + value=alpha.log().reshape(-1) if alpha is not None else torch.zeros(1), + init_fn=self.init_alpha_fn, # type: ignore requires_grad=trainable, requires_init=True if alpha is None else False ) self.parameter_dict['log-sigma'] = KernelParameter( - value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_sigma_fn, + value=sigma.log().reshape(-1) if sigma is not None else torch.zeros(1), + init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -498,7 +512,7 @@ def __init__( @property def alpha(self) -> torch.Tensor: - return self.parameter_dict['alpha'].value + return self.parameter_dict['log-alpha'].value.exp() @property def sigma(self) -> torch.Tensor: @@ -517,16 +531,29 @@ def kernel_function(self, x: torch.Tensor, y: torch.Tensor, return kernel_mat.mean(dim=0) + def get_config(self) -> dict: + """ + Returns a serializable config dict (excluding the infer_sigma_fn and infer_alpha_fn, + which is serialized in alibi_detect.saving). + """ + cfg = self.config.copy() + if isinstance(cfg['sigma'], torch.Tensor): + cfg['sigma'] = cfg['sigma'].detach().cpu().numpy().tolist() + if isinstance(cfg['alpha'], torch.Tensor): + cfg['alpha'] = cfg['alpha'].detach().cpu().numpy().tolist() + cfg.update({'flavour': Framework.PYTORCH.value}) + return cfg + class Periodic(BaseKernel): def __init__( self, - tau: torch.Tensor = None, - init_fn_tau: Callable = None, - sigma: torch.Tensor = None, - init_sigma_fn: Callable = log_sigma_median, + tau: Optional[torch.Tensor] = None, + init_tau_fn: Optional[Callable] = None, + sigma: Optional[torch.Tensor] = None, + init_sigma_fn: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None + active_dims: Optional[list] = None ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -537,7 +564,7 @@ def __init__( ---------- tau Period of the periodic kernel. - init_fn_tau + init_tau_fn Function used to compute the period `tau`. Used when `tau` is to be inferred. sigma Bandwidth used for the kernel. @@ -551,15 +578,22 @@ def __init__( Axis of the feature dimension. """ super().__init__(active_dims) + if tau is not None and sigma is not None: + if tau.shape != sigma.shape: + raise ValueError('tau and sigma must have the same shape.') + self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn + self.init_tau_fn = init_tau_fn + self.config = {'tau': tau, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, + 'init_tau_fn': self.init_tau_fn, 'init_sigma_fn': self.init_sigma_fn} self.parameter_dict['log-tau'] = KernelParameter( - value=tau.log().reshape(-1) if tau is not None else None, - init_fn=init_fn_tau, + value=tau.log().reshape(-1) if tau is not None else torch.zeros(1), + init_fn=self.init_tau_fn, # type: ignore requires_grad=trainable, requires_init=True if tau is None else False ) self.parameter_dict['log-sigma'] = KernelParameter( - value=sigma.log().reshape(-1) if sigma is not None else None, - init_fn=init_sigma_fn, + value=sigma.log().reshape(-1) if sigma is not None else torch.zeros(1), + init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -586,6 +620,19 @@ def kernel_function(self, x: torch.Tensor, y: torch.Tensor, for i in range(len(self.sigma))], dim=0) return kernel_mat.mean(dim=0) + def get_config(self) -> dict: + """ + Returns a serializable config dict (excluding the infer_sigma_fn and infer_tau_fn, + which is serialized in alibi_detect.saving). + """ + cfg = self.config.copy() + if isinstance(cfg['sigma'], torch.Tensor): + cfg['sigma'] = cfg['sigma'].detach().cpu().numpy().tolist() + if isinstance(cfg['tau'], torch.Tensor): + cfg['tau'] = cfg['tau'].detach().cpu().numpy().tolist() + cfg.update({'flavour': Framework.PYTORCH.value}) + return cfg + class ProjKernel(BaseKernel): def __init__( diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 62d8bc2c7..c0424d3fb 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -201,6 +201,25 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = tf.convert_to_tensor(np.array(config['sigma'])) + if 'alpha' in config and config['alpha'] is not None: + config['alpha'] = tf.convert_to_tensor(np.array(config['alpha'])) + if 'tau' in config and config['tau'] is not None: + config['tau'] = tf.convert_to_tensor(np.array(config['tau'])) + return cls(**config) + class SumKernel(BaseKernel): def __init__(self) -> None: @@ -366,7 +385,7 @@ def __init__( sigma: Optional[tf.Tensor] = None, init_sigma_fn: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None + active_dims: Optional[list] = None ) -> None: """ Gaussian RBF kernel: k(x,y) = exp(-(1/(2*sigma^2)||x-y||^2). A forward pass takes @@ -390,7 +409,8 @@ def __init__( """ super().__init__(active_dims) self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn - self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn} + self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn, + 'active_dims': active_dims} self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), @@ -421,7 +441,7 @@ def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = Fa def get_config(self) -> dict: """ - Returns a serializable config dict (excluding the input_sigma_fn, which is serialized in alibi_detect.saving). + Returns a serializable config dict (excluding the infer_sigma_fn, which is serialized in alibi_detect.saving). """ cfg = self.config.copy() if isinstance(cfg['sigma'], tf.Tensor): @@ -429,29 +449,16 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.TENSORFLOW.value}) return cfg - @classmethod - def from_config(cls, config): - """ - Instantiates a kernel from a config dictionary. - - Parameters - ---------- - config - A kernel config dictionary. - """ - config.pop('flavour') - return cls(**config) - class RationalQuadratic(BaseKernel): def __init__( self, - alpha: tf.Tensor = None, - init_fn_alpha: Callable = None, - sigma: tf.Tensor = None, - init_sigma_fn: Callable = log_sigma_median, + alpha: Optional[tf.Tensor] = None, + init_alpha_fn: Optional[Callable] = None, + sigma: Optional[tf.Tensor] = None, + init_sigma_fn: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None + active_dims: Optional[list] = None ) -> None: """ Rational Quadratic kernel: k(x,y) = (1 + ||x-y||^2 / (2*sigma^2))^(-alpha). @@ -474,17 +481,24 @@ def __init__( Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. """ super().__init__(active_dims) - self.parameter_dict['alpha'] = KernelParameter( - value=tf.reshape( - tf.cast(alpha, tf.keras.backend.floatx()), -1) if alpha is not None else None, - init_fn=init_fn_alpha, + if alpha is not None and sigma is not None: + if alpha.shape != sigma.shape: + raise ValueError('alpha and sigma must have the same shape.') + self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn + self.init_alpha_fn = init_alpha_fn + self.config = {'alpha': alpha, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, + 'init_sigma_fn': self.init_sigma_fn, 'init_alpha_fn': self.init_alpha_fn} + self.parameter_dict['log-alpha'] = KernelParameter( + value=tf.reshape(tf.math.log( + tf.cast(alpha, tf.keras.backend.floatx())), -1) if alpha is not None else tf.zeros(1), + init_fn=self.init_alpha_fn, # type: ignore requires_grad=trainable, requires_init=True if alpha is None else False ) self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), - init_fn=init_sigma_fn, + init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -497,7 +511,7 @@ def sigma(self) -> tf.Tensor: @property def alpha(self) -> tf.Tensor: - return self.parameter_dict['alpha'].value + return tf.math.exp(self.parameter_dict['log-alpha'].value) def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) @@ -512,16 +526,29 @@ def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = Fa ** (-self.alpha[i]) for i in range(len(self.sigma))], axis=0) return tf.reduce_mean(kernel_mat, axis=0) + def get_config(self) -> dict: + """ + Returns a serializable config dict (excluding the infer_sigma_fn and infer_alpha_fn, + which is serialized in alibi_detect.saving). + """ + cfg = self.config.copy() + if isinstance(cfg['sigma'], tf.Tensor): + cfg['sigma'] = cfg['sigma'].numpy().tolist() + if isinstance(cfg['alpha'], tf.Tensor): + cfg['alpha'] = cfg['alpha'].numpy().tolist() + cfg.update({'flavour': Framework.TENSORFLOW.value}) + return cfg + class Periodic(BaseKernel): def __init__( self, - tau: tf.Tensor = None, - init_fn_tau: Callable = None, - sigma: tf.Tensor = None, - init_sigma_fn: Callable = log_sigma_median, + tau: Optional[tf.Tensor] = None, + init_tau_fn: Optional[Callable] = None, + sigma: Optional[tf.Tensor] = None, + init_sigma_fn: Optional[Callable] = None, trainable: bool = False, - active_dims: list = None + active_dims: Optional[list] = None ) -> None: """ Periodic kernel: k(x,y) = exp(-2 * sin(pi * |x - y| / tau)^2 / (sigma^2)). @@ -544,17 +571,24 @@ def __init__( Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. """ super().__init__(active_dims) + if tau is not None and sigma is not None: + if tau.shape != sigma.shape: + raise ValueError('tau and sigma must have the same shape.') + self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn + self.init_tau_fn = init_tau_fn + self.config = {'tau': tau, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, + 'init_tau_fn': self.init_tau_fn, 'init_sigma_fn': self.init_sigma_fn} self.parameter_dict['log-tau'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else tf.zeros(1), - init_fn=init_fn_tau, + init_fn=self.init_tau_fn, # type: ignore requires_grad=trainable, requires_init=True if tau is None else False ) self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), - init_fn=init_sigma_fn, + init_fn=self.init_sigma_fn, # type: ignore requires_grad=trainable, requires_init=True if sigma is None else False ) @@ -582,6 +616,19 @@ def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = Fa for i in range(len(self.sigma))], axis=0) return tf.reduce_mean(kernel_mat, axis=0) + def get_config(self) -> dict: + """ + Returns a serializable config dict (excluding the infer_sigma_fn and infer_tau_fn, + which is serialized in alibi_detect.saving). + """ + cfg = self.config.copy() + if isinstance(cfg['sigma'], tf.Tensor): + cfg['sigma'] = cfg['sigma'].numpy().tolist() + if isinstance(cfg['tau'], tf.Tensor): + cfg['tau'] = cfg['tau'].numpy().tolist() + cfg.update({'flavour': Framework.TENSORFLOW.value}) + return cfg + class ProjKernel(BaseKernel): def __init__( From 1e381f40fe8739683c1d7765c6874cd66f9eeb74 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 20 Mar 2023 07:20:00 +0000 Subject: [PATCH 34/37] Add support for serialisation of composite kernels. --- alibi_detect/saving/loading.py | 49 ++++ alibi_detect/saving/registry.py | 8 +- alibi_detect/saving/saving.py | 30 ++- alibi_detect/saving/schemas.py | 18 ++ alibi_detect/saving/tests/models.py | 82 ++++-- alibi_detect/saving/tests/test_saving.py | 150 ++++++++--- alibi_detect/saving/tests/test_validate.py | 3 +- alibi_detect/utils/pytorch/kernels.py | 284 ++++++++++++++++++--- alibi_detect/utils/tensorflow/kernels.py | 284 ++++++++++++++++++--- 9 files changed, 771 insertions(+), 137 deletions(-) diff --git a/alibi_detect/saving/loading.py b/alibi_detect/saving/loading.py index 977da1ac3..7a714cb4c 100644 --- a/alibi_detect/saving/loading.py +++ b/alibi_detect/saving/loading.py @@ -466,6 +466,16 @@ def resolve_config(cfg: dict, config_dir: Optional[Path]) -> dict: if config_dir is not None: _prepend_cfg_filepaths(cfg, config_dir) + # get additional fields to resolve for composite kernels + if 'kernel' in cfg: + if isinstance(cfg['kernel'], dict): + if (cfg['kernel']['kernel_type'] == 'Sum') or (cfg['kernel']['kernel_type'] == 'Product'): + composite_fields = _get_composite_kernel_fields(cfg['kernel']) + for field in composite_fields: + field.insert(0, 'kernel') + loc = FIELDS_TO_RESOLVE.index(['kernel']) + FIELDS_TO_RESOLVE[loc:loc] = composite_fields + # Resolve filepaths (load files) and resolve function/object registries for key in FIELDS_TO_RESOLVE: logger.info('Resolving config field: {}.'.format(key)) @@ -519,6 +529,45 @@ def resolve_config(cfg: dict, config_dir: Optional[Path]) -> dict: return cfg +def _get_composite_kernel_fields(cfg: dict) -> list: + """ + Get additional fields to resolve for composite kernels. + + Parameters + ---------- + cfg + The config dict. + + Returns + ------- + The additional fields to resolve. + """ + fields = [] + if 'kernel_type' in cfg: + if (cfg['kernel_type'] == 'Sum') or (cfg['kernel_type'] == 'Product'): + kernel_number = len(cfg) - 3 + for i in range(kernel_number): + if isinstance(cfg['comp_{}'.format(i)], dict): + if 'kernel_type' in cfg['comp_{}'.format(i)]: + if (cfg['comp_{}'.format(i)]['kernel_type'] == 'Sum') or \ + (cfg['comp_{}'.format(i)]['kernel_type'] == 'Product'): + fields.extend(_get_composite_kernel_fields(cfg['comp_{}'.format(i)])) + elif cfg['comp_{}'.format(i)]['kernel_type'] == 'GaussianRBF': + fields.append(['comp_{}'.format(i), 'src']) + fields.append(['comp_{}'.format(i), 'init_sigma_fn']) + elif cfg['comp_{}'.format(i)]['kernel_type'] == 'RationalQuadratic': + fields.append(['comp_{}'.format(i), 'src']) + fields.append(['comp_{}'.format(i), 'init_sigma_fn']) + fields.append(['comp_{}'.format(i), 'init_alpha_fn']) + elif cfg['comp_{}'.format(i)]['kernel_type'] == 'Period': + fields.append(['comp_{}'.format(i), 'src']) + fields.append(['comp_{}'.format(i), 'init_sigma_fn']) + fields.append(['comp_{}'.format(i), 'init_tau_fn']) + else: + raise ValueError('Unknown kernel type: {}'.format(cfg['comp_{}'.format(i)]['kernel_type'])) + return fields + + def _replace(cfg: dict, orig: Optional[str], new: Optional[str]) -> dict: """ Recursively traverse a nested dictionary and replace values. diff --git a/alibi_detect/saving/registry.py b/alibi_detect/saving/registry.py index cc380e36b..41a4a5621 100644 --- a/alibi_detect/saving/registry.py +++ b/alibi_detect/saving/registry.py @@ -44,7 +44,7 @@ def my_function(x: np.ndarray) -> np.ndarray: from alibi_detect.utils.tensorflow.kernels import \ GaussianRBF as GaussianRBF_tf, sigma_median as sigma_median_tf, \ log_sigma_median as log_sigma_median_tf, RationalQuadratic as RationalQuadratic_tf, \ - Periodic as Periodic_tf + Periodic as Periodic_tf, SumKernel as SumKernel_tf, ProductKernel as ProductKernel_tf from alibi_detect.cd.tensorflow.context_aware import _sigma_median_diag as _sigma_median_diag_tf if has_pytorch: @@ -53,7 +53,7 @@ def my_function(x: np.ndarray) -> np.ndarray: from alibi_detect.utils.pytorch.kernels import \ GaussianRBF as GaussianRBF_torch, sigma_median as sigma_median_torch, \ log_sigma_median as log_sigma_median_torch, RationalQuadratic as RationalQuadratic_torch, \ - Periodic as Periodic_torch + Periodic as Periodic_torch, SumKernel as SumKernel_torch, ProductKernel as ProductKernel_torch from alibi_detect.cd.pytorch.context_aware import _sigma_median_diag as _sigma_median_diag_torch # Create registry @@ -64,6 +64,8 @@ def my_function(x: np.ndarray) -> np.ndarray: registry.register('utils.tensorflow.kernels.GaussianRBF', func=GaussianRBF_tf) registry.register('utils.tensorflow.kernels.RationalQuadratic', func=RationalQuadratic_tf) registry.register('utils.tensorflow.kernels.Periodic', func=Periodic_tf) + registry.register('utils.tensorflow.kernels.SumKernel', func=SumKernel_tf) + registry.register('utils.tensorflow.kernels.ProductKernel', func=ProductKernel_tf) registry.register('utils.tensorflow.kernels.sigma_median', func=sigma_median_tf) registry.register('utils.tensorflow.kernels.log_sigma_median', func=log_sigma_median_tf) registry.register('cd.tensorflow.context_aware._sigma_median_diag', func=_sigma_median_diag_tf) @@ -74,6 +76,8 @@ def my_function(x: np.ndarray) -> np.ndarray: registry.register('utils.pytorch.kernels.GaussianRBF', func=GaussianRBF_torch) registry.register('utils.pytorch.kernels.RationalQuadratic', func=RationalQuadratic_torch) registry.register('utils.pytorch.kernels.Periodic', func=Periodic_torch) + registry.register('utils.pytorch.kernels.SumKernel', func=SumKernel_torch) + registry.register('utils.pytorch.kernels.ProductKernel', func=ProductKernel_torch) registry.register('utils.pytorch.kernels.sigma_median', func=sigma_median_torch) registry.register('utils.pytorch.kernels.log_sigma_median', func=log_sigma_median_torch) registry.register('cd.pytorch.context_aware._sigma_median_diag', func=_sigma_median_diag_torch) diff --git a/alibi_detect/saving/saving.py b/alibi_detect/saving/saving.py index 9648e404f..59653568a 100644 --- a/alibi_detect/saving/saving.py +++ b/alibi_detect/saving/saving.py @@ -503,6 +503,22 @@ def _save_kernel_config(kernel: Callable, if not isinstance(kernel_b, str) and kernel_b is not None: cfg_kernel['kernel_b'] = _save_kernel_config(cfg_kernel['kernel_b'], base_path, Path('kernel_b')) + # if a composite kernel + elif hasattr(kernel, 'kernel_list'): + kernel_class = kernel.__class__ + + if hasattr(kernel, 'get_config'): + cfg_kernel = kernel.get_config() # type: ignore[attr-defined] + else: + raise AttributeError("The detector's `kernel` must have a .get_config() method for it to be saved.") + + for i, k in enumerate(kernel.kernel_list): + if hasattr(k, 'get_config'): + cfg_kernel['comp_' + str(i)] = _save_kernel_config(k, base_path, + Path(local_path, 'kernel_{}'.format(i))) + cfg_kernel = dict(sorted(cfg_kernel.items())) + cfg_kernel['src'], _ = _serialize_object(kernel_class, base_path, local_path.joinpath('kernel')) + # If any other kernel, serialize the class to disk and get config else: if isinstance(kernel, type): # if still a class @@ -512,8 +528,18 @@ def _save_kernel_config(kernel: Callable, kernel_class = kernel.__class__ if hasattr(kernel, 'get_config'): cfg_kernel = kernel.get_config() # type: ignore[attr-defined] - cfg_kernel['init_sigma_fn'], _ = _serialize_object(cfg_kernel['init_sigma_fn'], base_path, - local_path.joinpath('init_sigma_fn')) + if 'init_sigma_fn' in cfg_kernel: + if cfg_kernel['init_sigma_fn'] is not None: + cfg_kernel['init_sigma_fn'], _ = _serialize_object(cfg_kernel['init_sigma_fn'], base_path, + local_path.joinpath('init_sigma_fn')) + if 'init_alpha_fn' in cfg_kernel: + if cfg_kernel['init_alpha_fn'] is not None: + cfg_kernel['init_alpha_fn'], _ = _serialize_object(cfg_kernel['init_alpha_fn'], base_path, + local_path.joinpath('init_alpha_fn')) + if 'init_tau_fn' in cfg_kernel: + if cfg_kernel['init_tau_fn'] is not None: + cfg_kernel['init_tau_fn'], _ = _serialize_object(cfg_kernel['init_tau_fn'], base_path, + local_path.joinpath('init_tau_fn')) else: raise AttributeError("The detector's `kernel` must have a .get_config() method for it to be saved.") # Serialize the kernel class diff --git a/alibi_detect/saving/schemas.py b/alibi_detect/saving/schemas.py index af88f33fc..e42873c26 100644 --- a/alibi_detect/saving/schemas.py +++ b/alibi_detect/saving/schemas.py @@ -350,6 +350,8 @@ class RBFKernelConfig(CustomBaseModelWithKwargs): src: str "A string referencing a filepath to a serialized kernel in `.dill` format, or an object registry reference." + kernel_type: Literal['GaussianRBF'] + # Below kwargs are only passed if kernel == @GaussianRBF flavour: Literal['tensorflow', 'pytorch'] """ @@ -404,6 +406,8 @@ class RationalQuadraticKernelConfig(CustomBaseModelWithKwargs): src: str "A string referencing a filepath to a serialized kernel in `.dill` format, or an object registry reference." + kernel_type: Literal['RationalQuadratic'] + # Below kwargs are only passed if kernel == @GaussianRBF flavour: Literal['tensorflow', 'pytorch'] """ @@ -469,6 +473,8 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): src: str "A string referencing a filepath to a serialized kernel in `.dill` format, or an object registry reference." + kernel_type: Literal['Periodic'] + # Below kwargs are only passed if kernel == @GaussianRBF flavour: Literal['tensorflow', 'pytorch'] """ @@ -504,6 +510,14 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): _coerce_tau2tensor = validator('tau', allow_reuse=True, pre=False)(coerce_2_tensor) +class CompositeKernelConfig(CustomBaseModelWithKwargs): + src: str + + kernel_type: Literal['Sum', 'Product'] + + flavour: Literal['tensorflow', 'pytorch'] + + class DeepKernelConfig(CustomBaseModel): """ Unresolved schema for :class:`~alibi_detect.utils.tensorflow.kernels.DeepKernel`'s. @@ -531,6 +545,10 @@ class DeepKernelConfig(CustomBaseModel): [kernel.proj] src = "model/" """ + kernel_type: Literal['Deep'] + + flavour: Literal['tensorflow', 'pytorch'] + proj: Union[str, ModelConfig] """ The projection to be applied to the inputs before applying `kernel_a`. This should be a Tensorflow or PyTorch diff --git a/alibi_detect/saving/tests/models.py b/alibi_detect/saving/tests/models.py index 07c81390f..33afbf9e5 100644 --- a/alibi_detect/saving/tests/models.py +++ b/alibi_detect/saving/tests/models.py @@ -21,10 +21,14 @@ from alibi_detect.utils.pytorch.kernels import RationalQuadratic as RationalQuadratic_pt from alibi_detect.utils.pytorch.kernels import Periodic as Periodic_pt from alibi_detect.utils.pytorch.kernels import DeepKernel as DeepKernel_pt +from alibi_detect.utils.pytorch.kernels import SumKernel as SumKernel_pt +from alibi_detect.utils.pytorch.kernels import ProductKernel as ProductKernel_pt from alibi_detect.utils.tensorflow.kernels import GaussianRBF as GaussianRBF_tf from alibi_detect.utils.tensorflow.kernels import RationalQuadratic as RationalQuadratic_tf from alibi_detect.utils.tensorflow.kernels import Periodic as Periodic_tf from alibi_detect.utils.tensorflow.kernels import DeepKernel as DeepKernel_tf +from alibi_detect.utils.tensorflow.kernels import SumKernel as SumKernel_tf +from alibi_detect.utils.tensorflow.kernels import ProductKernel as ProductKernel_tf from alibi_detect.models.pytorch import TransformerEmbedding as TransformerEmbedding_pt from alibi_detect.models.tensorflow import TransformerEmbedding as TransformerEmbedding_tf from alibi_detect.cd.pytorch import HiddenOutput as HiddenOutput_pt @@ -107,15 +111,11 @@ def kernel(request, backend): Kernel for given backend. Settings are parametrised in the test function. """ kernel = request.param - if isinstance(kernel, dict): # dict of kwargs - kernel_meta_cfg = kernel.copy() - kernel_name = kernel_meta_cfg['kernel_name'] - kernel_cfg = kernel_meta_cfg['kernel_config'] if backend == 'tensorflow': - kernel = initial_kernel_tf(kernel_name, kernel_cfg) + kernel = initial_kernel_tf(kernel) elif backend == 'pytorch': - kernel = initial_kernel_pt(kernel_name, kernel_cfg) + kernel = initial_kernel_pt(kernel) else: pytest.skip('`kernel` only implemented for tensorflow and pytorch.') return kernel @@ -148,8 +148,8 @@ def deep_kernel(request, backend, encoder_model): parametrised in the test function. """ # Get DeepKernel options - kernel_a = request.param.get('kernel_a', {'kernel_name': 'GaussianRBF', 'kernel_config': {}}) - kernel_b = request.param.get('kernel_b', {'kernel_name': 'GaussianRBF', 'kernel_config': {}}) + kernel_a = request.param.get('kernel_a', {'kernel_type': 'GaussianRBF'}) + kernel_b = request.param.get('kernel_b', {'kernel_type': 'GaussianRBF'}) eps = request.param.get('eps', 'trainable') # Proj model (backend managed in encoder_model fixture) @@ -157,49 +157,91 @@ def deep_kernel(request, backend, encoder_model): # Build DeepKernel if backend == 'tensorflow': - kernel_a = initial_kernel_tf(kernel_a['kernel_name'], kernel_a['kernel_config']) - kernel_b = initial_kernel_tf(kernel_b['kernel_name'], kernel_b['kernel_config']) + kernel_a = initial_kernel_tf(kernel_a) + kernel_b = initial_kernel_tf(kernel_b) deep_kernel = DeepKernel_tf(proj, kernel_a=kernel_a, kernel_b=kernel_b, eps=eps) elif backend == 'pytorch': - kernel_a = initial_kernel_pt(kernel_a['kernel_name'], kernel_a['kernel_config']) - kernel_b = initial_kernel_pt(kernel_b['kernel_name'], kernel_b['kernel_config']) + kernel_a = initial_kernel_pt(kernel_a) + kernel_b = initial_kernel_pt(kernel_b) deep_kernel = DeepKernel_pt(proj, kernel_a=kernel_a, kernel_b=kernel_b, eps=eps) else: pytest.skip('`deep_kernel` only implemented for tensorflow and pytorch.') return deep_kernel -def initial_kernel_tf(kernel_name, kernel_config): +def initial_kernel_tf(kernel_config): + kernel_config = kernel_config.copy() + if 'kernel_type' in kernel_config: + kernel_name = kernel_config.pop('kernel_type') if ('sigma' in kernel_config) and (kernel_config['sigma'] is not None): - kernel_config['sigma'] = tf.convert_to_tensor(np.array(kernel_config['sigma'])) + kernel_config['sigma'] = tf.convert_to_tensor(np.array(kernel_config['sigma']), dtype=tf.float32) if ('alpha' in kernel_config) and (kernel_config['alpha'] is not None): - kernel_config['alpha'] = tf.convert_to_tensor(np.array(kernel_config['alpha'])) + kernel_config['alpha'] = tf.convert_to_tensor(np.array(kernel_config['alpha']), dtype=tf.float32) if ('tau' in kernel_config) and (kernel_config['tau'] is not None): - kernel_config['tau'] = tf.convert_to_tensor(np.array(kernel_config['tau'])) + kernel_config['tau'] = tf.convert_to_tensor(np.array(kernel_config['tau']), dtype=tf.float32) if kernel_name == 'GaussianRBF': kernel = GaussianRBF_tf(**kernel_config) elif kernel_name == 'RationalQuadratic': kernel = RationalQuadratic_tf(**kernel_config) elif kernel_name == 'Periodic': kernel = Periodic_tf(**kernel_config) + elif kernel_name == 'Sum': + kernel_list = [] + for k_config in kernel_config.values(): + if isinstance(k_config, dict): + kernel_list.append(initial_kernel_tf(k_config)) + elif isinstance(k_config, float): + kernel_list.append(tf.cast(k_config, dtype=tf.float32)) + final_config = {'kernel_list': kernel_list} + kernel = SumKernel_tf(**final_config) + elif kernel_name == 'Product': + kernel_list = [] + for k_config in kernel_config.values(): + if isinstance(k_config, dict): + kernel_list.append(initial_kernel_tf(k_config)) + elif isinstance(k_config, float): + kernel_list.append(tf.cast(k_config, dtype=tf.float32)) + final_config = {'kernel_list': kernel_list} + kernel = ProductKernel_tf(**final_config) else: pytest.skip('`initial_kernel_tf` only implemented for GaussianRBF, RationalQuadratic and Periodic.') return kernel -def initial_kernel_pt(kernel_name, kernel_config): +def initial_kernel_pt(kernel_config): + kernel_config = kernel_config.copy() + if 'kernel_type' in kernel_config: + kernel_name = kernel_config.pop('kernel_type') if ('sigma' in kernel_config) and (kernel_config['sigma'] is not None): - kernel_config['sigma'] = torch.tensor(np.array(kernel_config['sigma'])) + kernel_config['sigma'] = torch.tensor(np.array(kernel_config['sigma']), dtype=torch.float32) if ('alpha' in kernel_config) and (kernel_config['alpha'] is not None): - kernel_config['alpha'] = torch.tensor(np.array(kernel_config['alpha'])) + kernel_config['alpha'] = torch.tensor(np.array(kernel_config['alpha']), dtype=torch.float32) if ('tau' in kernel_config) and (kernel_config['tau'] is not None): - kernel_config['tau'] = torch.tensor(np.array(kernel_config['tau'])) + kernel_config['tau'] = torch.tensor(np.array(kernel_config['tau']), dtype=torch.float32) if kernel_name == 'GaussianRBF': kernel = GaussianRBF_pt(**kernel_config) elif kernel_name == 'RationalQuadratic': kernel = RationalQuadratic_pt(**kernel_config) elif kernel_name == 'Periodic': kernel = Periodic_pt(**kernel_config) + elif kernel_name == 'Sum': + kernel_list = [] + for k_config in kernel_config.values(): + if isinstance(k_config, dict): + kernel_list.append(initial_kernel_pt(k_config)) + elif isinstance(k_config, float): + kernel_list.append(torch.tensor(k_config, dtype=torch.float32)) + final_config = {'kernel_list': kernel_list} + kernel = SumKernel_pt(**final_config) + elif kernel_name == 'Product': + kernel_list = [] + for k_config in kernel_config.values(): + if isinstance(k_config, dict): + kernel_list.append(initial_kernel_pt(k_config)) + elif isinstance(k_config, float): + kernel_list.append(torch.tensor(k_config, dtype=torch.float32)) + final_config = {'kernel_list': kernel_list} + kernel = ProductKernel_pt(**final_config) else: pytest.skip('`initial_kernel_pt` only implemented for GaussianRBF, RationalQuadratic and Periodic.') return kernel diff --git a/alibi_detect/saving/tests/test_saving.py b/alibi_detect/saving/tests/test_saving.py index 320912b14..316314641 100644 --- a/alibi_detect/saving/tests/test_saving.py +++ b/alibi_detect/saving/tests/test_saving.py @@ -43,7 +43,7 @@ from alibi_detect.saving.saving import (_path2str, _int2str_keys, _save_kernel_config, _save_model_config, _save_preprocess_config) from alibi_detect.saving.schemas import DeepKernelConfig, ModelConfig, PreprocessConfig, RBFKernelConfig,\ - RationalQuadraticKernelConfig, PeriodicKernelConfig + RationalQuadraticKernelConfig, PeriodicKernelConfig, CompositeKernelConfig from alibi_detect.utils.pytorch.kernels import DeepKernel as DeepKernel_pt from alibi_detect.utils.tensorflow.kernels import DeepKernel as DeepKernel_tf @@ -193,9 +193,9 @@ def test_save_cvmdrift(data, preprocess_custom, tmp_path): @parametrize('kernel', [ None, # Use default kernel - {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': False}}, # pass kernel as object - {'kernel_name': 'RationalQuadratic', 'kernel_config': {'sigma': 0.5, 'alpha': 4.0, 'trainable': False}}, - {'kernel_name': 'Periodic', 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False}}, + {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False}, # pass kernel as object + {'kernel_type': 'RationalQuadratic', 'sigma': 0.5, 'alpha': 4.0, 'trainable': False}, + {'kernel_type': 'Periodic', 'sigma': 0.5, 'tau': 2.0, 'trainable': False}, ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -459,7 +459,7 @@ def test_save_spotthediff(data, classifier_model, backend, tmp_path, seed): # n @parametrize('deep_kernel', [ - {'kernel_a': {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': True}}, + {'kernel_a': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': True}, 'eps': 0.01} ], indirect=True ) @@ -503,11 +503,10 @@ def test_save_learnedkernel(data, deep_kernel, backend, tmp_path, seed): # noqa @parametrize('kernel', [ None, # Default kernel - {'kernel_name': 'GaussianRBF', - 'kernel_config': {'sigma': 0.5, 'trainable': False}}, + {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False}, # pass kernels as GaussianRBF objects, with default sigma_median fn - {'kernel_name': 'RationalQuadratic', 'kernel_config': {'sigma': 0.5, 'alpha': 4.0, 'trainable': False}}, - {'kernel_name': 'Periodic', 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False}}, + {'kernel_type': 'RationalQuadratic', 'sigma': 0.5, 'alpha': 4.0, 'trainable': False}, + {'kernel_type': 'Periodic', 'sigma': 0.5, 'tau': 2.0, 'trainable': False}, ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -620,9 +619,9 @@ def test_save_regressoruncertaintydrift(data, regressor, backend, tmp_path, seed @parametrize('kernel', [ None, # Use default kernel - {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': False}}, # pass kernel as object - {'kernel_name': 'RationalQuadratic', 'kernel_config': {'sigma': 0.5, 'alpha': 4.0, 'trainable': False}}, - {'kernel_name': 'Periodic', 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False}}, + {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False}, # pass kernel as object + {'kernel_type': 'RationalQuadratic', 'sigma': 0.5, 'alpha': 4.0, 'trainable': False}, + {'kernel_type': 'Periodic', 'sigma': 0.5, 'tau': 2.0, 'trainable': False}, ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -866,22 +865,16 @@ def test_version_warning(data, tmp_path): @parametrize('kernel', [ - {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}}, - {'kernel_name': 'GaussianRBF', - 'kernel_config': {'sigma': [0.5, 0.8], 'trainable': False, 'init_sigma_fn': None}}, - {'kernel_name': 'GaussianRBF', 'kernel_config': {'sigma': None, 'trainable': True, 'init_sigma_fn': None}}, - {'kernel_name': 'RationalQuadratic', - 'kernel_config': {'sigma': 0.5, 'alpha': 3.0, 'trainable': False, 'init_sigma_fn': None}}, - {'kernel_name': 'RationalQuadratic', - 'kernel_config': {'sigma': [0.5, 0.8], 'alpha': [2.0, 3.0], 'trainable': False, 'init_sigma_fn': None}}, - {'kernel_name': 'RationalQuadratic', - 'kernel_config': {'sigma': None, 'alpha': None, 'trainable': True, 'init_sigma_fn': None}}, - {'kernel_name': 'Periodic', - 'kernel_config': {'sigma': 0.5, 'tau': 2.0, 'trainable': False, 'init_sigma_fn': None}}, - {'kernel_name': 'Periodic', - 'kernel_config': {'sigma': [0.5, 0.8], 'tau': [2.0, 3.0], 'trainable': False, 'init_sigma_fn': None}}, - {'kernel_name': 'Periodic', - 'kernel_config': {'sigma': None, 'tau': None, 'trainable': True, 'init_sigma_fn': None}}, + {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, + {'kernel_type': 'GaussianRBF', 'sigma': [0.5, 0.8], 'trainable': False, 'init_sigma_fn': None}, + {'kernel_type': 'GaussianRBF', 'sigma': None, 'trainable': True, 'init_sigma_fn': None}, + {'kernel_type': 'RationalQuadratic', 'sigma': 0.5, 'alpha': 3.0, 'trainable': False, 'init_sigma_fn': None}, + {'kernel_type': 'RationalQuadratic', 'sigma': [0.5, 0.8], 'alpha': [2.0, 3.0], 'trainable': False, + 'init_sigma_fn': None}, + {'kernel_type': 'RationalQuadratic', 'sigma': None, 'alpha': None, 'trainable': True, 'init_sigma_fn': None}, + {'kernel_type': 'Periodic', 'sigma': 0.5, 'tau': 2.0, 'trainable': False, 'init_sigma_fn': None}, + {'kernel_type': 'Periodic', 'sigma': [0.5, 0.8], 'tau': [2.0, 3.0], 'trainable': False, 'init_sigma_fn': None}, + {'kernel_type': 'Periodic', 'sigma': None, 'tau': None, 'trainable': True, 'init_sigma_fn': None}, ], indirect=True ) def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 @@ -936,14 +929,107 @@ def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 assert kernel_loaded.parameter_dict[tmp_key].init_fn == kernel.parameter_dict[tmp_key].init_fn +@parametrize('kernel', [ + {'kernel_type': 'Sum', + 'comp_1': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, + 'comp_2': {'kernel_type': 'GaussianRBF', 'sigma': 1.0, 'trainable': False, 'init_sigma_fn': None}, + 'comp_3': 0.5}, + {'kernel_type': 'Product', + 'comp_1': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, + 'comp_2': {'kernel_type': 'GaussianRBF', 'sigma': 1.0, 'trainable': False, 'init_sigma_fn': None}}, + ], indirect=True +) +def test_save_composite_kernel(kernel, backend, tmp_path): # noqa: F811 + """ + Unit test for _save/_load_kernel_config, when kernel is a GaussianRBF kernel. + + Kernels are saved and then loaded, with assertions to check equivalence. + """ + # Save kernel to config + filepath = tmp_path + filename = Path('mykernel') + cfg_kernel = _save_kernel_config(kernel, filepath, filename) + if kernel.__class__.__name__ == 'SumKernel': + assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.SumKernel' + cfg_kernel = validate_composite_kernel_config(cfg_kernel) # Pass through validator to test + elif kernel.__class__.__name__ == 'ProductKernel': + assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.ProductKernel' + cfg_kernel = validate_composite_kernel_config(cfg_kernel) # Pass through validator to test + else: + assert Path(cfg_kernel['src']).suffix == '.dill' + + # Resolve and load config (_load_kernel_config is called within resolve_config) + cfg = {'kernel': cfg_kernel, 'backend': backend} + _prepend_cfg_filepaths(cfg, tmp_path) + kernel_loaded = resolve_config(cfg, tmp_path)['kernel'] + + # Call kernels + X = np.random.standard_normal((10, 1)) + if backend == 'pytorch': + X = torch.from_numpy(X).float() + elif backend == 'tensorflow': + X = tf.convert_to_tensor(X) + else: + pytest.skip('Backend not supported.') + K_0 = kernel(X, X) + K_1 = kernel_loaded(X, X) + + # Final checks + assert type(kernel_loaded) == type(kernel) + if backend == 'pytorch': + K_0 = K_0.detach().numpy().ravel() + K_1 = K_1.detach().numpy().ravel() + np.testing.assert_array_almost_equal(K_0, K_1, 5) + elif backend == 'tensorflow': + K_0 = K_0.numpy().ravel() + K_1 = K_1.numpy().ravel() + np.testing.assert_array_almost_equal(K_0, K_1, 5) + else: + raise NotImplementedError('Backend not supported.') + for i in range(len(kernel.kernel_list)): + if hasattr(kernel.kernel_list[i], 'sigma'): + if backend == 'pytorch': + np.testing.assert_array_almost_equal(kernel_loaded.kernel_list[i].sigma.detach().numpy(), + kernel.kernel_list[i].sigma.detach().numpy(), 5) + else: + np.testing.assert_array_almost_equal(np.array(kernel_loaded.kernel_list[i].sigma), + np.array(kernel.kernel_list[i].sigma), 5) + assert kernel_loaded.kernel_list[i].trainable == kernel.kernel_list[i].trainable + for tmp_key in kernel.kernel_list[i].parameter_dict.keys(): + assert kernel_loaded.kernel_list[i].parameter_dict[tmp_key].init_fn == \ + kernel.kernel_list[i].parameter_dict[tmp_key].init_fn + + +def validate_composite_kernel_config(cfg_kernel): + cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() + comp_number = len(cfg_kernel) - 3 + for i in range(comp_number): + if isinstance(cfg_kernel['comp_' + str(i)], dict): + if 'kernel_type' in cfg_kernel['comp_' + str(i)]: + if cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Sum': + cfg_kernel['comp_' + str(i)] = validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Product': + cfg_kernel['comp_' + str(i)] = validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'GaussianRBF': + cfg_kernel['comp_' + str(i)] = RBFKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'RationalQuadratic': + cfg_kernel['comp_' + str(i)] = RationalQuadraticKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Periodic': + cfg_kernel['comp_' + str(i)] = PeriodicKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() + else: + raise ValueError('Kernel type not supported.') + cfg_kernel = dict(sorted(cfg_kernel.items())) # Sort dict to ensure order is consistent + return cfg_kernel + + # `data` passed below as needed in encoder_model, which is used in deep_kernel @parametrize_with_cases("data", cases=ContinuousData.data_synthetic_nd) @parametrize('deep_kernel', [ - {'kernel_a': {'kernel_name': 'GaussianRBF', 'kernel_config': {}}, - 'kernel_b': {'kernel_name': 'GaussianRBF', 'kernel_config': {}}, + {'kernel_a': {'kernel_type': 'GaussianRBF'}, + 'kernel_b': {'kernel_type': 'GaussianRBF'}, 'eps': 'trainable'}, # Default for kernel_a and kernel_b, trainable eps - {'kernel_a': {'kernel_name': 'GaussianRBF', 'kernel_config': {'trainable': True}}, - 'kernel_b': {'kernel_name': 'GaussianRBF', 'kernel_config': {}}, + {'kernel_a': {'kernel_type': 'GaussianRBF', 'trainable': True}, + 'kernel_b': {'kernel_type': 'GaussianRBF'}, 'eps': 0.01}, # Explicit kernel_a, fixed eps ], indirect=True ) diff --git a/alibi_detect/saving/tests/test_validate.py b/alibi_detect/saving/tests/test_validate.py index 08df9cc04..05680b5d3 100644 --- a/alibi_detect/saving/tests/test_validate.py +++ b/alibi_detect/saving/tests/test_validate.py @@ -101,7 +101,8 @@ def test_validate_kernel_and_coerce_2_tensor(flavour, sigma): kernel_cfg = { 'src': f'@utils.{flavour}.kernels.GaussianRBF', 'flavour': flavour, - 'sigma': sigma + 'sigma': sigma, + 'kernel_type': 'GaussianRBF' } # Pass through validation and check results diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index ff992d4ab..2acd3df25 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -127,6 +127,7 @@ def __init__(self, active_dims: list = None) -> None: """ super().__init__() self.parameter_dict: dict = {} + self.config: dict = {} if active_dims is not None: self.active_dims = torch.as_tensor(active_dims) else: @@ -153,12 +154,23 @@ def __add__( other: Union['BaseKernel', torch.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): + kernel_count = len(other.kernel_list) other.kernel_list.append(self) + other.config['comp_' + str(kernel_count)] = self.config # type: ignore return other - elif isinstance(other, (BaseKernel, ProductKernel, torch.Tensor)): + elif isinstance(other, (BaseKernel, ProductKernel)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.config # type: ignore + return sum_kernel + elif isinstance(other, torch.Tensor): + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config # type: ignore + sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.detach().cpu().numpy() # type: ignore return sum_kernel else: raise ValueError('Kernels can only added to another kernel or a constant.') @@ -171,18 +183,33 @@ def __mul__( other: Union['BaseKernel', torch.Tensor] ) -> 'BaseKernel': if isinstance(other, ProductKernel): - other.kernel_factors.append(self) + other.kernel_list.append(self) + other.config['comp_' + str(len(other.kernel_list))] = self.config # type: ignore return other elif isinstance(other, SumKernel): sum_kernel = SumKernel() + kernel_count = 0 for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) + sum_kernel.config['comp_' + str(kernel_count)] = self.config # type: ignore + kernel_count += 1 return sum_kernel - else: + elif isinstance(other, BaseKernel): + prod_kernel = ProductKernel() + prod_kernel.kernel_list.append(self) + prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.kernel_list.append(other) + prod_kernel.config['comp_1'] = other.config # type: ignore + return prod_kernel + elif isinstance(other, torch.Tensor): prod_kernel = ProductKernel() - prod_kernel.kernel_factors.append(self) - prod_kernel.kernel_factors.append(other) + prod_kernel.kernel_list.append(self) + prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.kernel_list.append(other) + prod_kernel.config['comp_1'] = other.detach().cpu().numpy() # type: ignore return prod_kernel + else: + raise ValueError('Kernels can only be multiplied by another kernel or a constant.') def __rmul__( self, @@ -205,33 +232,28 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') - @classmethod - def from_config(cls, config): - """ - Instantiates a kernel from a config dictionary. - - Parameters - ---------- - config - A kernel config dictionary. - """ - config.pop('flavour') - if 'sigma' in config and config['sigma'] is not None: - config['sigma'] = torch.tensor(np.array(config['sigma'])) - if 'alpha' in config and config['alpha'] is not None: - config['alpha'] = torch.tensor(np.array(config['alpha'])) - if 'tau' in config and config['tau'] is not None: - config['tau'] = torch.tensor(np.array(config['tau'])) - return cls(**config) + def get_config(self) -> dict: + return self.config.copy() class SumKernel(BaseKernel): - def __init__(self) -> None: + def __init__(self, + kernel_list: Optional[List[Union[BaseKernel, torch.Tensor]]] = None) -> None: """ Construct a kernel by summing different kernels. """ super().__init__() - self.kernel_list: List[Union[BaseKernel, torch.Tensor]] = [] + self.kernel_list = [] + self.config: dict = {'kernel_type': 'Sum'} + if kernel_list is not None: + self.kernel_list = kernel_list + for i in range(len(self.kernel_list)): + if isinstance(self.kernel_list[i], BaseKernel): + self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + elif isinstance(self.kernel_list[i], torch.Tensor): + self.config['comp_' + str(i)] = self.kernel_list[i].detach().cpu().numpy() # type: ignore + else: + raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by SumKernel.') def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: @@ -250,11 +272,23 @@ def __add__( self, other: Union[BaseKernel, torch.Tensor] ) -> 'SumKernel': + kernel_count = len(self.kernel_list) if isinstance(other, SumKernel): for k in other.kernel_list: self.kernel_list.append(k) - else: + if isinstance(k, BaseKernel): + self.config['comp_' + str(kernel_count)] = k.config + elif isinstance(k, torch.Tensor): + self.config['comp_' + str(kernel_count)] = k.detach().cpu().numpy() + kernel_count += 1 + elif isinstance(other, BaseKernel): + self.kernel_list.append(other) + self.config['comp_' + str(kernel_count)] = other.config + elif isinstance(other, torch.Tensor): self.kernel_list.append(other) + self.config['comp_' + str(kernel_count)] = other.detach().cpu().numpy() + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') return self def __radd__(self, other: BaseKernel) -> 'SumKernel': @@ -269,6 +303,8 @@ def __mul__( for ki in self.kernel_list: for kj in other.kernel_list: sum_kernel.kernel_list.append((ki * kj)) + sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): return other * self @@ -276,6 +312,8 @@ def __mul__( sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) + sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel else: raise ValueError(type(other) + 'is not supported by SumKernel.') @@ -301,19 +339,50 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') + def get_config(self) -> dict: + cfg = self.config.copy() + cfg.update({'flavour': Framework.PYTORCH.value}) + return cfg + + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + config = fill_composite_config(config) + return cls(**config) + class ProductKernel(BaseKernel): - def __init__(self) -> None: + def __init__(self, + kernel_list: Optional[List[Union[BaseKernel, torch.Tensor]]] = None) -> None: """ Construct a kernel by multiplying different kernels. """ super().__init__() - self.kernel_factors: List[Union[BaseKernel, torch.Tensor]] = [] + self.kernel_list = [] + self.config: dict = {'kernel_type': 'Product'} + if kernel_list is not None: + self.kernel_list = kernel_list + for i in range(len(self.kernel_list)): + if isinstance(self.kernel_list[i], BaseKernel): + self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + elif isinstance(self.kernel_list[i], torch.Tensor): + self.config['comp_' + str(i)] = self.kernel_list[i].detach().cpu().numpy() # type: ignore + else: + raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by ProductKernel.') def kernel_function(self, x: torch.Tensor, y: torch.Tensor, infer_parameter: bool = False) -> torch.Tensor: value_list: List[torch.Tensor] = [] - for k in self.kernel_factors: + for k in self.kernel_list: k.to(x.device) if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) @@ -329,12 +398,24 @@ def __add__( ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) + other.config['comp_' + str(len(other.kernel_list))] = self.config return other - else: + elif isinstance(other, ProductKernel) or isinstance(other, BaseKernel): + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config + sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.config + return sum_kernel + elif isinstance(other, torch.Tensor): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.detach().cpu().numpy() return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') def __radd__( self, @@ -350,15 +431,23 @@ def __mul__( sum_kernel = SumKernel() for k in other.kernel_list: tmp_prod_kernel = deepcopy(self) - tmp_prod_kernel.kernel_factors.append(k) + tmp_prod_kernel.kernel_list.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) + sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list))] = \ + sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): - for k in other.kernel_factors: - self.kernel_factors.append(k) + for k in other.kernel_list: + self.kernel_list.append(k) + self.config['comp_' + str(len(self.kernel_list))] = k.config # type: ignore return self - elif isinstance(other, BaseKernel) or isinstance(other, torch.Tensor): - self.kernel_factors.append(other) + elif isinstance(other, BaseKernel): + self.kernel_list.append(other) + self.config['comp_' + str(len(self.kernel_list))] = other.config # type: ignore + return self + elif isinstance(other, torch.Tensor): + self.kernel_list.append(other) + self.config['comp_' + str(len(self.kernel_list))] = other.detach().cpu().numpy() # type: ignore return self else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -384,6 +473,26 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') + def get_config(self) -> dict: + cfg = self.config.copy() + cfg.update({'flavour': Framework.PYTORCH.value}) + return cfg + + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + config = fill_composite_config(config) + return cls(**config) + class GaussianRBF(BaseKernel): def __init__( @@ -418,7 +527,7 @@ def __init__( super().__init__(active_dims) self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn, - 'active_dims': active_dims} + 'active_dims': active_dims, 'kernel_type': 'GaussianRBF'} self.parameter_dict['log-sigma'] = KernelParameter( value=sigma.log().reshape(-1) if sigma is not None else torch.zeros(1), init_fn=self.init_sigma_fn, # type: ignore @@ -456,6 +565,22 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.PYTORCH.value}) return cfg + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = torch.tensor(np.array(config['sigma'])) + return cls(**config) + class RationalQuadratic(BaseKernel): def __init__( @@ -494,7 +619,8 @@ def __init__( self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn self.init_alpha_fn = init_alpha_fn self.config = {'alpha': alpha, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, - 'init_alpha_fn': self.init_alpha_fn, 'init_sigma_fn': self.init_sigma_fn} + 'init_alpha_fn': self.init_alpha_fn, 'init_sigma_fn': self.init_sigma_fn, + 'kernel_type': 'RationalQuadratic'} self.parameter_dict['log-alpha'] = KernelParameter( value=alpha.log().reshape(-1) if alpha is not None else torch.zeros(1), init_fn=self.init_alpha_fn, # type: ignore @@ -544,6 +670,24 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.PYTORCH.value}) return cfg + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = torch.tensor(np.array(config['sigma'])) + if 'alpha' in config and config['alpha'] is not None: + config['alpha'] = torch.tensor(np.array(config['alpha'])) + return cls(**config) + class Periodic(BaseKernel): def __init__( @@ -584,7 +728,8 @@ def __init__( self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn self.init_tau_fn = init_tau_fn self.config = {'tau': tau, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, - 'init_tau_fn': self.init_tau_fn, 'init_sigma_fn': self.init_sigma_fn} + 'init_tau_fn': self.init_tau_fn, 'init_sigma_fn': self.init_sigma_fn, + 'kernel_type': 'Periodic'} self.parameter_dict['log-tau'] = KernelParameter( value=tau.log().reshape(-1) if tau is not None else torch.zeros(1), init_fn=self.init_tau_fn, # type: ignore @@ -633,6 +778,24 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.PYTORCH.value}) return cfg + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = torch.tensor(np.array(config['sigma'])) + if 'tau' in config and config['tau'] is not None: + config['tau'] = torch.tensor(np.array(config['tau'])) + return cls(**config) + class ProjKernel(BaseKernel): def __init__( @@ -653,6 +816,7 @@ def __init__( The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. """ super().__init__() + self.config = {'proj': proj, 'raw_kernel': raw_kernel, 'kernel_type': 'Proj'} self.proj = proj self.raw_kernel = raw_kernel self.init_required = False @@ -665,6 +829,17 @@ def kernel_function( ) -> torch.Tensor: return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) + def get_config(self) -> dict: + cfg = self.config.copy() + cfg.update({'flavour': Framework.PYTORCH.value}) + return cfg + + @classmethod + def from_config(cls, config): + config.pop('flavour') + config.pop('kernel_type') + return cls(**config) + class DeepKernel(BaseKernel): """ @@ -694,7 +869,7 @@ def __init__( eps: Union[float, str] = 'trainable' ) -> None: super().__init__() - self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} + self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps, 'kernel_type': 'Deep'} self.proj = proj self.kernel_a = kernel_a self.kernel_b = kernel_b @@ -736,8 +911,37 @@ def kernel_function( return self.comp_kernel(x, y, infer_parameter) def get_config(self) -> dict: - return self.config.copy() + cfg = self.config.copy() + cfg.update({'flavour': Framework.PYTORCH.value}) + return cfg @classmethod def from_config(cls, config): + config.pop('kernel_type') + config.pop('flavour') return cls(**config) + + +def fill_composite_config(config: dict) -> dict: + final_config: dict = {'kernel_list': []} + for k_config in config.values(): + if isinstance(k_config, dict): + k_config.pop('src') + if k_config['kernel_type'] == 'Sum': + final_config['kernel_list'].append(SumKernel.from_config(k_config)) + elif k_config['kernel_type'] == 'Product': + final_config['kernel_list'].append(ProductKernel.from_config(k_config)) + elif k_config['kernel_type'] == 'GaussianRBF': + final_config['kernel_list'].append(GaussianRBF.from_config(k_config)) + elif k_config['kernel_type'] == 'Periodic': + final_config['kernel_list'].append(Periodic.from_config(k_config)) + elif k_config['kernel_type'] == 'RationalQuadratic': + final_config['kernel_list'].append(RationalQuadratic.from_config(k_config)) + else: + raise ValueError('Unknown kernel type.') + elif isinstance(k_config, np.ndarray) or isinstance(k_config, float) or \ + isinstance(k_config, np.float32) or isinstance(k_config, np.float64): + final_config['kernel_list'].append(torch.tensor(np.array(k_config))) + else: + raise ValueError('Unknown kernel type.') + return final_config diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index c0424d3fb..40a655156 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -129,6 +129,7 @@ def __init__(self, active_dims: list = None) -> None: """ super().__init__() self.parameter_dict: dict = {} + self.config: dict = {} self.active_dims = active_dims self.init_required = False @@ -149,12 +150,23 @@ def __add__( other: Union['BaseKernel', tf.Tensor] ) -> 'SumKernel': if isinstance(other, SumKernel): + kernel_count = len(other.kernel_list) other.kernel_list.append(self) + other.config['comp_' + str(kernel_count)] = self.config # type: ignore return other - elif isinstance(other, (BaseKernel, ProductKernel, tf.Tensor)): + elif isinstance(other, (BaseKernel, ProductKernel)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.config # type: ignore + return sum_kernel + elif isinstance(other, tf.Tensor): + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config # type: ignore + sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.numpy() # type: ignore return sum_kernel else: raise ValueError('Kernels can only added to another kernel or a constant.') @@ -167,18 +179,33 @@ def __mul__( other: Union['BaseKernel', tf.Tensor] ) -> 'BaseKernel': if isinstance(other, ProductKernel): - other.kernel_factors.append(self) + other.kernel_list.append(self) + other.config['comp_' + str(len(other.kernel_list))] = self.config # type: ignore return other elif isinstance(other, SumKernel): sum_kernel = SumKernel() + kernel_count = 0 for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) + sum_kernel.config['comp_' + str(kernel_count)] = self.config # type: ignore + kernel_count += 1 return sum_kernel - else: + elif isinstance(other, BaseKernel): + prod_kernel = ProductKernel() + prod_kernel.kernel_list.append(self) + prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.kernel_list.append(other) + prod_kernel.config['comp_1'] = other.config # type: ignore + return prod_kernel + elif isinstance(other, tf.Tensor): prod_kernel = ProductKernel() - prod_kernel.kernel_factors.append(self) - prod_kernel.kernel_factors.append(other) + prod_kernel.kernel_list.append(self) + prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.kernel_list.append(other) + prod_kernel.config['comp_1'] = other.numpy() # type: ignore return prod_kernel + else: + raise ValueError('Kernels can only be multiplied by another kernel or a constant.') def __rmul__( self, @@ -201,33 +228,28 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') - @classmethod - def from_config(cls, config): - """ - Instantiates a kernel from a config dictionary. - - Parameters - ---------- - config - A kernel config dictionary. - """ - config.pop('flavour') - if 'sigma' in config and config['sigma'] is not None: - config['sigma'] = tf.convert_to_tensor(np.array(config['sigma'])) - if 'alpha' in config and config['alpha'] is not None: - config['alpha'] = tf.convert_to_tensor(np.array(config['alpha'])) - if 'tau' in config and config['tau'] is not None: - config['tau'] = tf.convert_to_tensor(np.array(config['tau'])) - return cls(**config) + def get_config(self) -> dict: + return self.config.copy() class SumKernel(BaseKernel): - def __init__(self) -> None: + def __init__(self, + kernel_list: Optional[List[Union[BaseKernel, tf.Tensor]]] = None) -> None: """ Construct a kernel by summing different kernels. """ super().__init__() - self.kernel_list: List[Union[BaseKernel, tf.Tensor]] = [] + self.kernel_list = [] + self.config: dict = {'kernel_type': 'Sum'} + if kernel_list is not None: + self.kernel_list = kernel_list + for i in range(len(self.kernel_list)): + if isinstance(self.kernel_list[i], BaseKernel): + self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + elif isinstance(self.kernel_list[i], tf.Tensor): + self.config['comp_' + str(i)] = self.kernel_list[i].numpy() # type: ignore + else: + raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by SumKernel.') def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: @@ -245,11 +267,23 @@ def __add__( self, other: Union[BaseKernel, tf.Tensor] ) -> 'SumKernel': + kernel_count = len(self.kernel_list) if isinstance(other, SumKernel): for k in other.kernel_list: self.kernel_list.append(k) - else: + if isinstance(k, BaseKernel): + self.config['comp_' + str(kernel_count)] = k.config + elif isinstance(k, tf.Tensor): + self.config['comp_' + str(kernel_count)] = k.numpy() + kernel_count += 1 + elif isinstance(other, BaseKernel): + self.kernel_list.append(other) + self.config['comp_' + str(kernel_count)] = other.config + elif isinstance(other, tf.Tensor): self.kernel_list.append(other) + self.config['comp_' + str(kernel_count)] = other.numpy() + else: + raise ValueError(type(other) + 'is not supported by SumKernel.') return self def __radd__(self, other: BaseKernel) -> 'SumKernel': @@ -264,6 +298,8 @@ def __mul__( for ki in self.kernel_list: for kj in other.kernel_list: sum_kernel.kernel_list.append((ki * kj)) + sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): return other * self @@ -271,6 +307,8 @@ def __mul__( sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) + sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel else: raise ValueError(type(other) + 'is not supported by SumKernel.') @@ -296,19 +334,50 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') + def get_config(self) -> dict: + cfg = self.config.copy() + cfg.update({'flavour': Framework.TENSORFLOW.value}) + return cfg + + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + config = fill_composite_config(config) + return cls(**config) + class ProductKernel(tf.keras.Model): - def __init__(self) -> None: + def __init__(self, + kernel_list: Optional[List[Union[BaseKernel, tf.Tensor]]] = None) -> None: """ Construct a kernel by multiplying different kernels. """ super().__init__() - self.kernel_factors: List[Union[BaseKernel, SumKernel, ProductKernel, tf.Tensor]] = [] + self.kernel_list = [] + self.config: dict = {'kernel_type': 'Product'} + if kernel_list is not None: + self.kernel_list = kernel_list + for i in range(len(self.kernel_list)): + if isinstance(self.kernel_list[i], BaseKernel): + self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + elif isinstance(self.kernel_list[i], tf.Tensor): + self.config['comp_' + str(i)] = self.kernel_list[i].cpu().numpy() # type: ignore + else: + raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by ProductKernel.') def call(self, x: Union[np.ndarray, tf.Tensor], y: Union[np.ndarray, tf.Tensor], infer_parameter: bool = False) -> tf.Tensor: value_list: List[tf.Tensor] = [] - for k in self.kernel_factors: + for k in self.kernel_list: if isinstance(k, BaseKernel) or isinstance(k, SumKernel) or isinstance(k, ProductKernel): value_list.append(k(x, y, infer_parameter)) elif isinstance(k, tf.Tensor): @@ -323,12 +392,24 @@ def __add__( ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) + other.config['comp_' + str(len(other.kernel_list))] = self.config return other - else: + elif isinstance(other, ProductKernel) or isinstance(other, BaseKernel): + sum_kernel = SumKernel() + sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config + sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.config + return sum_kernel + elif isinstance(other, tf.Tensor): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) + sum_kernel.config['comp_0'] = self.config sum_kernel.kernel_list.append(other) + sum_kernel.config['comp_1'] = other.numpy() return sum_kernel + else: + raise ValueError(type(other) + 'is not supported by ProductKernel.') def __radd__( self, @@ -344,15 +425,23 @@ def __mul__( sum_kernel = SumKernel() for k in other.kernel_list: tmp_prod_kernel = deepcopy(self) - tmp_prod_kernel.kernel_factors.append(k) + tmp_prod_kernel.kernel_list.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) + sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list))] = \ + sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): - for k in other.kernel_factors: - self.kernel_factors.append(k) + for k in other.kernel_list: + self.kernel_list.append(k) + self.config['comp_' + str(len(self.kernel_list))] = k.config # type: ignore return self - elif isinstance(other, BaseKernel) or isinstance(other, tf.Tensor): - self.kernel_factors.append(other) + elif isinstance(other, BaseKernel): + self.kernel_list.append(other) + self.config['comp_' + str(len(self.kernel_list))] = other.config # type: ignore + return self + elif isinstance(other, tf.Tensor): + self.kernel_list.append(other) + self.config['comp_' + str(len(self.kernel_list))] = other.numpy() # type: ignore return self else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -378,6 +467,26 @@ def __sub__(self, other): def __rsub__(self, other): raise ValueError('Kernels do not support subtraction.') + def get_config(self) -> dict: + cfg = self.config.copy() + cfg.update({'flavour': Framework.TENSORFLOW.value}) + return cfg + + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + config = fill_composite_config(config) + return cls(**config) + class GaussianRBF(BaseKernel): def __init__( @@ -410,7 +519,7 @@ def __init__( super().__init__(active_dims) self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn self.config = {'sigma': sigma, 'trainable': trainable, 'init_sigma_fn': self.init_sigma_fn, - 'active_dims': active_dims} + 'active_dims': active_dims, 'kernel_type': 'GaussianRBF'} self.parameter_dict['log-sigma'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(sigma, tf.keras.backend.floatx())), -1) if sigma is not None else tf.zeros(1), @@ -449,6 +558,22 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.TENSORFLOW.value}) return cfg + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = tf.convert_to_tensor(np.array(config['sigma'])) + return cls(**config) + class RationalQuadratic(BaseKernel): def __init__( @@ -487,7 +612,8 @@ def __init__( self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn self.init_alpha_fn = init_alpha_fn self.config = {'alpha': alpha, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, - 'init_sigma_fn': self.init_sigma_fn, 'init_alpha_fn': self.init_alpha_fn} + 'init_sigma_fn': self.init_sigma_fn, 'init_alpha_fn': self.init_alpha_fn, + 'kernel_type': 'RationalQuadratic'} self.parameter_dict['log-alpha'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(alpha, tf.keras.backend.floatx())), -1) if alpha is not None else tf.zeros(1), @@ -539,6 +665,24 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.TENSORFLOW.value}) return cfg + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = tf.convert_to_tensor(np.array(config['sigma'])) + if 'alpha' in config and config['alpha'] is not None: + config['alpha'] = tf.convert_to_tensor(np.array(config['alpha'])) + return cls(**config) + class Periodic(BaseKernel): def __init__( @@ -577,7 +721,8 @@ def __init__( self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn self.init_tau_fn = init_tau_fn self.config = {'tau': tau, 'sigma': sigma, 'trainable': trainable, 'active_dims': active_dims, - 'init_tau_fn': self.init_tau_fn, 'init_sigma_fn': self.init_sigma_fn} + 'init_tau_fn': self.init_tau_fn, 'init_sigma_fn': self.init_sigma_fn, + 'kernel_type': 'Periodic'} self.parameter_dict['log-tau'] = KernelParameter( value=tf.reshape(tf.math.log( tf.cast(tau, tf.keras.backend.floatx())), -1) if tau is not None else tf.zeros(1), @@ -629,6 +774,24 @@ def get_config(self) -> dict: cfg.update({'flavour': Framework.TENSORFLOW.value}) return cfg + @classmethod + def from_config(cls, config): + """ + Instantiates a kernel from a config dictionary. + + Parameters + ---------- + config + A kernel config dictionary. + """ + config.pop('flavour') + config.pop('kernel_type') + if 'sigma' in config and config['sigma'] is not None: + config['sigma'] = tf.convert_to_tensor(np.array(config['sigma'])) + if 'tau' in config and config['tau'] is not None: + config['tau'] = tf.convert_to_tensor(np.array(config['tau'])) + return cls(**config) + class ProjKernel(BaseKernel): def __init__( @@ -649,6 +812,7 @@ def __init__( The kernel to apply to the projected inputs. Defaults to a Gaussian RBF with trainable bandwidth. """ super().__init__() + self.config = {'proj': proj, 'raw_kernel': raw_kernel, 'kernel_type': 'Proj'} self.proj = proj self.raw_kernel = raw_kernel self.init_required = False @@ -656,6 +820,17 @@ def __init__( def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: return self.raw_kernel(self.proj(x), self.proj(y), infer_parameter) + def get_config(self) -> dict: + cfg = self.config.copy() + cfg.update({'flavour': Framework.TENSORFLOW.value}) + return cfg + + @classmethod + def from_config(cls, config): + config.pop('flavour') + config.pop('kernel_type') + return cls(**config) + class DeepKernel(BaseKernel): """ @@ -694,7 +869,7 @@ def __init__( self.comp_kernel = (1-tf.sigmoid(self.logit_eps))*proj_kernel + tf.sigmoid(self.logit_eps)*kernel_b else: self.comp_kernel = proj_kernel - self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps} + self.config = {'proj': proj, 'kernel_a': kernel_a, 'kernel_b': kernel_b, 'eps': eps, 'kernel_type': 'Deep'} def _init_eps(self, eps: Union[float, str]) -> None: if isinstance(eps, float): @@ -715,8 +890,37 @@ def kernel_function(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = Fa return self.comp_kernel(x, y, infer_parameter) def get_config(self) -> dict: - return self.config.copy() + cfg = self.config.copy() + cfg.update({'flavour': Framework.TENSORFLOW.value}) + return cfg @classmethod def from_config(cls, config): + config.pop('kernel_type') + config.pop('flavour') return cls(**config) + + +def fill_composite_config(config: dict) -> dict: + final_config: dict = {'kernel_list': []} + for k_config in config.values(): + if isinstance(k_config, dict): + k_config.pop('src') + if k_config['kernel_type'] == 'Sum': + final_config['kernel_list'].append(SumKernel.from_config(k_config)) + elif k_config['kernel_type'] == 'Product': + final_config['kernel_list'].append(ProductKernel.from_config(k_config)) + elif k_config['kernel_type'] == 'GaussianRBF': + final_config['kernel_list'].append(GaussianRBF.from_config(k_config)) + elif k_config['kernel_type'] == 'Periodic': + final_config['kernel_list'].append(Periodic.from_config(k_config)) + elif k_config['kernel_type'] == 'RationalQuadratic': + final_config['kernel_list'].append(RationalQuadratic.from_config(k_config)) + else: + raise ValueError('Unknown kernel type.') + elif isinstance(k_config, np.ndarray) or isinstance(k_config, float) or \ + isinstance(k_config, np.float32) or isinstance(k_config, np.float64): + final_config['kernel_list'].append(tf.cast(np.array(k_config), tf.keras.backend.floatx())) + else: + raise ValueError('Unknown component type.') + return final_config From b14db5a328da09830f327d21d6f1747be21b0492 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 20 Mar 2023 09:53:03 +0000 Subject: [PATCH 35/37] Move composite kernel validation functions to loading module. Fixes for nested composite kernels. --- alibi_detect/saving/loading.py | 47 ++++++++++++++++++++++- alibi_detect/saving/schemas.py | 26 +++++++++---- alibi_detect/saving/tests/test_saving.py | 48 ++++++++++-------------- alibi_detect/utils/pytorch/kernels.py | 20 +++++----- 4 files changed, 94 insertions(+), 47 deletions(-) diff --git a/alibi_detect/saving/loading.py b/alibi_detect/saving/loading.py index 7a714cb4c..c3bfc91ac 100644 --- a/alibi_detect/saving/loading.py +++ b/alibi_detect/saving/loading.py @@ -19,7 +19,8 @@ from alibi_detect.saving.validate import validate_config from alibi_detect.base import Detector, ConfigurableDetector from alibi_detect.utils.frameworks import has_tensorflow, has_pytorch, Framework -from alibi_detect.saving.schemas import supported_models_tf, supported_models_torch +from alibi_detect.saving.schemas import supported_models_tf, supported_models_torch, \ + RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig, CompositeKernelConfig from alibi_detect.utils.missing_optional_dependency import import_optional get_device = import_optional('alibi_detect.utils.pytorch.misc', names=['get_device']) @@ -130,6 +131,13 @@ def _load_detector_config(filepath: Union[str, os.PathLike]) -> ConfigurableDete # Resolve and validate config cfg = validate_config(cfg) + + # Validate unresolved composite kernels + if 'kernel' in cfg: + if isinstance(cfg['kernel'], dict): + if cfg['kernel']['kernel_type'] == 'Sum' or cfg['kernel']['kernel_type'] == 'Product': + cfg['kernel'] = _validate_composite_kernel_config(cfg['kernel']) + logger.info('Validated unresolved config.') cfg = resolve_config(cfg, config_dir=config_dir) cfg = validate_config(cfg, resolved=True) @@ -369,6 +377,8 @@ def _get_nested_value(dic: dict, keys: list) -> Any: dic = dic[key] except (TypeError, KeyError): return None + except IndexError: + return None # only for scalar in composite kernels as it doesn't have any keys return dic @@ -529,6 +539,41 @@ def resolve_config(cfg: dict, config_dir: Optional[Path]) -> dict: return cfg +def _validate_composite_kernel_config(cfg_kernel): + """ + Validate composite kernel config. + + Parameters + ---------- + cfg_kernel + Composite kernel config. + + Returns + ------- + cfg_kernel + Validated composite kernel config. + """ + cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() + comp_number = len(cfg_kernel) - 3 + for i in range(comp_number): + if isinstance(cfg_kernel['comp_' + str(i)], dict): + if 'kernel_type' in cfg_kernel['comp_' + str(i)]: + if cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Sum': + cfg_kernel['comp_' + str(i)] = _validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Product': + cfg_kernel['comp_' + str(i)] = _validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'GaussianRBF': + cfg_kernel['comp_' + str(i)] = RBFKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'RationalQuadratic': + cfg_kernel['comp_' + str(i)] = RationalQuadraticKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() + elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Periodic': + cfg_kernel['comp_' + str(i)] = PeriodicKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() + else: + raise ValueError('Kernel type not supported.') + cfg_kernel = dict(sorted(cfg_kernel.items())) # Sort dict to ensure order is consistent + return cfg_kernel + + def _get_composite_kernel_fields(cfg: dict) -> list: """ Get additional fields to resolve for composite kernels. diff --git a/alibi_detect/saving/schemas.py b/alibi_detect/saving/schemas.py index e42873c26..8813ab35b 100644 --- a/alibi_detect/saving/schemas.py +++ b/alibi_detect/saving/schemas.py @@ -511,6 +511,11 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): class CompositeKernelConfig(CustomBaseModelWithKwargs): + """ + Unresolved schema for composite kernels, to be passed to a detector's `kernel` kwarg. + HEre only the src, kernel_type and flavour fields are checked. The kernels within kernel list will be + checked sperately. + """ src: str kernel_type: Literal['Sum', 'Product'] @@ -554,14 +559,14 @@ class DeepKernelConfig(CustomBaseModel): The projection to be applied to the inputs before applying `kernel_a`. This should be a Tensorflow or PyTorch model, specified as an object registry reference, or a :class:`~alibi_detect.utils.schemas.ModelConfig`. """ - kernel_a: Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]\ + kernel_a: Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig, CompositeKernelConfig]\ = "@utils.tensorflow.kernels.GaussianRBF" """ The kernel to apply to the projected inputs. Defaults to a :class:`~alibi_detect.utils.tensorflow.kernels.GaussianRBF` with trainable bandwidth. """ - kernel_b: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]]\ - = "@utils.tensorflow.kernels.GaussianRBF" + kernel_b: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig, + CompositeKernelConfig]] = "@utils.tensorflow.kernels.GaussianRBF" """ The kernel to apply to the raw inputs. Defaults to a :class:`~alibi_detect.utils.tensorflow.kernels.GaussianRBF` with trainable bandwidth. Set to `None` in order to use only the deep component (i.e. `eps=0`). @@ -827,7 +832,8 @@ class MMDDriftConfig(DriftDetectorConfig): p_val: float = .05 preprocess_at_init: bool = True update_x_ref: Optional[Dict[str, int]] = None - kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None + kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, + PeriodicKernelConfig, CompositeKernelConfig]] = None configure_kernel_from_x_ref: bool = True n_permutations: int = 100 batch_size_permutations: int = 1000000 @@ -987,7 +993,8 @@ class SpotTheDiffDriftConfig(DriftDetectorConfig): verbose: int = 0 train_kwargs: Optional[dict] = None dataset: Optional[str] = None - kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None + kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, + PeriodicKernelConfig, CompositeKernelConfig]] = None n_diffs: int = 1 initial_diffs: Optional[str] = None l1_reg: float = 0.01 @@ -1107,8 +1114,10 @@ class ContextMMDDriftConfig(DriftDetectorConfig): c_ref: str preprocess_at_init: bool = True update_ref: Optional[Dict[str, int]] = None - x_kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None - c_kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None + x_kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, + PeriodicKernelConfig, CompositeKernelConfig]] = None + c_kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, + PeriodicKernelConfig, CompositeKernelConfig]] = None n_permutations: int = 100 prop_c_held: float = 0.25 n_folds: int = 5 @@ -1152,7 +1161,8 @@ class MMDDriftOnlineConfig(DriftDetectorConfig): backend: Literal['tensorflow', 'pytorch'] = 'tensorflow' ert: float window_size: int - kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig]] = None + kernel: Optional[Union[str, RBFKernelConfig, RationalQuadraticKernelConfig, + PeriodicKernelConfig, CompositeKernelConfig]] = None n_bootstraps: int = 1000 device: Optional[Literal['cpu', 'cuda']] = None verbose: bool = True diff --git a/alibi_detect/saving/tests/test_saving.py b/alibi_detect/saving/tests/test_saving.py index 316314641..d792b13cd 100644 --- a/alibi_detect/saving/tests/test_saving.py +++ b/alibi_detect/saving/tests/test_saving.py @@ -38,12 +38,13 @@ from alibi_detect.saving import (load_detector, read_config, registry, resolve_config, save_detector, write_config) from alibi_detect.saving.loading import (_get_nested_value, _replace, - _set_dtypes, _set_nested_value, _prepend_cfg_filepaths) + _set_dtypes, _set_nested_value, _prepend_cfg_filepaths, + _validate_composite_kernel_config) from alibi_detect.saving.saving import _serialize_object from alibi_detect.saving.saving import (_path2str, _int2str_keys, _save_kernel_config, _save_model_config, _save_preprocess_config) from alibi_detect.saving.schemas import DeepKernelConfig, ModelConfig, PreprocessConfig, RBFKernelConfig,\ - RationalQuadraticKernelConfig, PeriodicKernelConfig, CompositeKernelConfig + RationalQuadraticKernelConfig, PeriodicKernelConfig from alibi_detect.utils.pytorch.kernels import DeepKernel as DeepKernel_pt from alibi_detect.utils.tensorflow.kernels import DeepKernel as DeepKernel_tf @@ -196,6 +197,10 @@ def test_save_cvmdrift(data, preprocess_custom, tmp_path): {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False}, # pass kernel as object {'kernel_type': 'RationalQuadratic', 'sigma': 0.5, 'alpha': 4.0, 'trainable': False}, {'kernel_type': 'Periodic', 'sigma': 0.5, 'tau': 2.0, 'trainable': False}, + {'kernel_type': 'Sum', + 'comp_1': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, + 'comp_2': {'kernel_type': 'GaussianRBF', 'sigma': 1.0, 'trainable': False, 'init_sigma_fn': None}, + 'comp_3': 0.5} ], indirect=True ) @parametrize_with_cases("data", cases=ContinuousData, prefix='data_') @@ -236,8 +241,9 @@ def test_save_mmddrift(data, kernel, preprocess_custom, backend, tmp_path, seed) assert cd_load._detector.p_val == P_VAL assert isinstance(cd_load._detector.preprocess_fn, Callable) assert cd_load._detector.preprocess_fn.func.__name__ == 'preprocess_drift' - assert cd._detector.kernel.sigma == cd_load._detector.kernel.sigma - assert cd._detector.kernel.init_sigma_fn == cd_load._detector.kernel.init_sigma_fn + if hasattr(cd._detector.kernel, 'sigma'): + assert cd._detector.kernel.sigma == cd_load._detector.kernel.sigma + assert cd._detector.kernel.init_sigma_fn == cd_load._detector.kernel.init_sigma_fn assert preds['data']['p_val'] == preds_load['data']['p_val'] @@ -933,10 +939,16 @@ def test_save_kernel(kernel, backend, tmp_path): # noqa: F811 {'kernel_type': 'Sum', 'comp_1': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, 'comp_2': {'kernel_type': 'GaussianRBF', 'sigma': 1.0, 'trainable': False, 'init_sigma_fn': None}, - 'comp_3': 0.5}, + 'comp_3': 0.01}, {'kernel_type': 'Product', 'comp_1': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, 'comp_2': {'kernel_type': 'GaussianRBF', 'sigma': 1.0, 'trainable': False, 'init_sigma_fn': None}}, + {'kernel_type': 'Product', + 'comp_1': 0.5, + 'comp_2': {'kernel_type': 'Sum', + 'comp_1': {'kernel_type': 'GaussianRBF', 'sigma': 0.5, 'trainable': False, 'init_sigma_fn': None}, + 'comp_2': {'kernel_type': 'GaussianRBF', 'sigma': 1.0, 'trainable': False, 'init_sigma_fn': None}, + 'comp_3': 0.5}}, ], indirect=True ) def test_save_composite_kernel(kernel, backend, tmp_path): # noqa: F811 @@ -951,10 +963,10 @@ def test_save_composite_kernel(kernel, backend, tmp_path): # noqa: F811 cfg_kernel = _save_kernel_config(kernel, filepath, filename) if kernel.__class__.__name__ == 'SumKernel': assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.SumKernel' - cfg_kernel = validate_composite_kernel_config(cfg_kernel) # Pass through validator to test + cfg_kernel = _validate_composite_kernel_config(cfg_kernel) # Pass through validator to test elif kernel.__class__.__name__ == 'ProductKernel': assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.ProductKernel' - cfg_kernel = validate_composite_kernel_config(cfg_kernel) # Pass through validator to test + cfg_kernel = _validate_composite_kernel_config(cfg_kernel) # Pass through validator to test else: assert Path(cfg_kernel['src']).suffix == '.dill' @@ -1000,28 +1012,6 @@ def test_save_composite_kernel(kernel, backend, tmp_path): # noqa: F811 kernel.kernel_list[i].parameter_dict[tmp_key].init_fn -def validate_composite_kernel_config(cfg_kernel): - cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() - comp_number = len(cfg_kernel) - 3 - for i in range(comp_number): - if isinstance(cfg_kernel['comp_' + str(i)], dict): - if 'kernel_type' in cfg_kernel['comp_' + str(i)]: - if cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Sum': - cfg_kernel['comp_' + str(i)] = validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Product': - cfg_kernel['comp_' + str(i)] = validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'GaussianRBF': - cfg_kernel['comp_' + str(i)] = RBFKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'RationalQuadratic': - cfg_kernel['comp_' + str(i)] = RationalQuadraticKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Periodic': - cfg_kernel['comp_' + str(i)] = PeriodicKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() - else: - raise ValueError('Kernel type not supported.') - cfg_kernel = dict(sorted(cfg_kernel.items())) # Sort dict to ensure order is consistent - return cfg_kernel - - # `data` passed below as needed in encoder_model, which is used in deep_kernel @parametrize_with_cases("data", cases=ContinuousData.data_synthetic_nd) @parametrize('deep_kernel', [ diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 2acd3df25..4df36c700 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -170,7 +170,7 @@ def __add__( sum_kernel.kernel_list.append(self) sum_kernel.config['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.detach().cpu().numpy() # type: ignore + sum_kernel.config['comp_1'] = other.detach().cpu().item() # type: ignore return sum_kernel else: raise ValueError('Kernels can only added to another kernel or a constant.') @@ -206,7 +206,7 @@ def __mul__( prod_kernel.kernel_list.append(self) prod_kernel.config['comp_0'] = self.config # type: ignore prod_kernel.kernel_list.append(other) - prod_kernel.config['comp_1'] = other.detach().cpu().numpy() # type: ignore + prod_kernel.config['comp_1'] = other.detach().cpu().item() # type: ignore return prod_kernel else: raise ValueError('Kernels can only be multiplied by another kernel or a constant.') @@ -251,7 +251,8 @@ def __init__(self, if isinstance(self.kernel_list[i], BaseKernel): self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore elif isinstance(self.kernel_list[i], torch.Tensor): - self.config['comp_' + str(i)] = self.kernel_list[i].detach().cpu().numpy() # type: ignore + self.config['comp_' + str(i)] = \ + self.kernel_list[i].detach().cpu().item() # type: ignore else: raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by SumKernel.') @@ -279,14 +280,14 @@ def __add__( if isinstance(k, BaseKernel): self.config['comp_' + str(kernel_count)] = k.config elif isinstance(k, torch.Tensor): - self.config['comp_' + str(kernel_count)] = k.detach().cpu().numpy() + self.config['comp_' + str(kernel_count)] = k.detach().cpu().item() kernel_count += 1 elif isinstance(other, BaseKernel): self.kernel_list.append(other) self.config['comp_' + str(kernel_count)] = other.config elif isinstance(other, torch.Tensor): self.kernel_list.append(other) - self.config['comp_' + str(kernel_count)] = other.detach().cpu().numpy() + self.config['comp_' + str(kernel_count)] = other.detach().cpu().item() else: raise ValueError(type(other) + 'is not supported by SumKernel.') return self @@ -375,7 +376,8 @@ def __init__(self, if isinstance(self.kernel_list[i], BaseKernel): self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore elif isinstance(self.kernel_list[i], torch.Tensor): - self.config['comp_' + str(i)] = self.kernel_list[i].detach().cpu().numpy() # type: ignore + self.config['comp_' + str(i)] = \ + self.kernel_list[i].detach().cpu().item() # type: ignore else: raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by ProductKernel.') @@ -412,7 +414,7 @@ def __add__( sum_kernel.kernel_list.append(self) sum_kernel.config['comp_0'] = self.config sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.detach().cpu().numpy() + sum_kernel.config['comp_1'] = other.detach().cpu().item() return sum_kernel else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -447,7 +449,7 @@ def __mul__( return self elif isinstance(other, torch.Tensor): self.kernel_list.append(other) - self.config['comp_' + str(len(self.kernel_list))] = other.detach().cpu().numpy() # type: ignore + self.config['comp_' + str(len(self.kernel_list))] = other.detach().cpu().item() # type: ignore return self else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -943,5 +945,5 @@ def fill_composite_config(config: dict) -> dict: isinstance(k_config, np.float32) or isinstance(k_config, np.float64): final_config['kernel_list'].append(torch.tensor(np.array(k_config))) else: - raise ValueError('Unknown kernel type.') + raise ValueError('Unknown component type.') return final_config From b24655ef5442ed541bdbd183c2a289993473326e Mon Sep 17 00:00:00 2001 From: Hao Song Date: Wed, 22 Mar 2023 15:20:08 +0000 Subject: [PATCH 36/37] (1) add 'kernel_list' key in config dict for better management. (2) move validation function into schema to allow full pedantic check. (3) make temp copies of FIELDS_TO_RESOLVE for composite kernel. --- alibi_detect/saving/loading.py | 100 +++++++++-------------- alibi_detect/saving/saving.py | 6 +- alibi_detect/saving/schemas.py | 76 +++++++++++++++-- alibi_detect/saving/tests/test_saving.py | 11 +-- alibi_detect/saving/validate.py | 43 +++++++++- alibi_detect/utils/pytorch/kernels.py | 67 +++++++-------- alibi_detect/utils/tensorflow/kernels.py | 66 +++++++-------- 7 files changed, 225 insertions(+), 144 deletions(-) diff --git a/alibi_detect/saving/loading.py b/alibi_detect/saving/loading.py index c3bfc91ac..b1febdcb5 100644 --- a/alibi_detect/saving/loading.py +++ b/alibi_detect/saving/loading.py @@ -19,8 +19,7 @@ from alibi_detect.saving.validate import validate_config from alibi_detect.base import Detector, ConfigurableDetector from alibi_detect.utils.frameworks import has_tensorflow, has_pytorch, Framework -from alibi_detect.saving.schemas import supported_models_tf, supported_models_torch, \ - RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig, CompositeKernelConfig +from alibi_detect.saving.schemas import supported_models_tf, supported_models_torch from alibi_detect.utils.missing_optional_dependency import import_optional get_device = import_optional('alibi_detect.utils.pytorch.misc', names=['get_device']) @@ -132,12 +131,6 @@ def _load_detector_config(filepath: Union[str, os.PathLike]) -> ConfigurableDete # Resolve and validate config cfg = validate_config(cfg) - # Validate unresolved composite kernels - if 'kernel' in cfg: - if isinstance(cfg['kernel'], dict): - if cfg['kernel']['kernel_type'] == 'Sum' or cfg['kernel']['kernel_type'] == 'Product': - cfg['kernel'] = _validate_composite_kernel_config(cfg['kernel']) - logger.info('Validated unresolved config.') cfg = resolve_config(cfg, config_dir=config_dir) cfg = validate_config(cfg, resolved=True) @@ -476,18 +469,11 @@ def resolve_config(cfg: dict, config_dir: Optional[Path]) -> dict: if config_dir is not None: _prepend_cfg_filepaths(cfg, config_dir) - # get additional fields to resolve for composite kernels - if 'kernel' in cfg: - if isinstance(cfg['kernel'], dict): - if (cfg['kernel']['kernel_type'] == 'Sum') or (cfg['kernel']['kernel_type'] == 'Product'): - composite_fields = _get_composite_kernel_fields(cfg['kernel']) - for field in composite_fields: - field.insert(0, 'kernel') - loc = FIELDS_TO_RESOLVE.index(['kernel']) - FIELDS_TO_RESOLVE[loc:loc] = composite_fields + # get additional fields to resolve for composite kernels TODO make a private function for this part, get temp fields + FIELDS_TO_RESOLVE_TEMP = _add_composite_fields(cfg) # Resolve filepaths (load files) and resolve function/object registries - for key in FIELDS_TO_RESOLVE: + for key in FIELDS_TO_RESOLVE_TEMP: logger.info('Resolving config field: {}.'.format(key)) src = _get_nested_value(cfg, key) obj = None @@ -539,39 +525,31 @@ def resolve_config(cfg: dict, config_dir: Optional[Path]) -> dict: return cfg -def _validate_composite_kernel_config(cfg_kernel): +def _add_composite_fields(cfg): """ - Validate composite kernel config. + Check if the cfg contains a composite kernel and add the fields to resolve. Parameters ---------- - cfg_kernel - Composite kernel config. + cfg + Config dict. Returns ------- - cfg_kernel - Validated composite kernel config. - """ - cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() - comp_number = len(cfg_kernel) - 3 - for i in range(comp_number): - if isinstance(cfg_kernel['comp_' + str(i)], dict): - if 'kernel_type' in cfg_kernel['comp_' + str(i)]: - if cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Sum': - cfg_kernel['comp_' + str(i)] = _validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Product': - cfg_kernel['comp_' + str(i)] = _validate_composite_kernel_config(cfg_kernel['comp_' + str(i)]) - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'GaussianRBF': - cfg_kernel['comp_' + str(i)] = RBFKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'RationalQuadratic': - cfg_kernel['comp_' + str(i)] = RationalQuadraticKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() - elif cfg_kernel['comp_' + str(i)]['kernel_type'] == 'Periodic': - cfg_kernel['comp_' + str(i)] = PeriodicKernelConfig(**cfg_kernel['comp_' + str(i)]).dict() - else: - raise ValueError('Kernel type not supported.') - cfg_kernel = dict(sorted(cfg_kernel.items())) # Sort dict to ensure order is consistent - return cfg_kernel + FIELDS_TO_RESOLVE_TEMP + List of fields to resolve. + """ + FIELDS_TO_RESOLVE_TEMP = FIELDS_TO_RESOLVE.copy() + if 'kernel' in cfg: + if isinstance(cfg['kernel'], dict): + if (cfg['kernel']['kernel_type'] == 'Sum') or (cfg['kernel']['kernel_type'] == 'Product'): + FIELDS_TO_RESOLVE_TEMP = FIELDS_TO_RESOLVE.copy() + composite_fields = _get_composite_kernel_fields(cfg['kernel']) + for field in composite_fields: + field.insert(0, 'kernel') + loc = FIELDS_TO_RESOLVE_TEMP.index(['kernel']) + FIELDS_TO_RESOLVE_TEMP[loc:loc] = composite_fields + return FIELDS_TO_RESOLVE_TEMP def _get_composite_kernel_fields(cfg: dict) -> list: @@ -590,24 +568,24 @@ def _get_composite_kernel_fields(cfg: dict) -> list: fields = [] if 'kernel_type' in cfg: if (cfg['kernel_type'] == 'Sum') or (cfg['kernel_type'] == 'Product'): - kernel_number = len(cfg) - 3 + kernel_number = len(cfg['kernel_list']) for i in range(kernel_number): - if isinstance(cfg['comp_{}'.format(i)], dict): - if 'kernel_type' in cfg['comp_{}'.format(i)]: - if (cfg['comp_{}'.format(i)]['kernel_type'] == 'Sum') or \ - (cfg['comp_{}'.format(i)]['kernel_type'] == 'Product'): - fields.extend(_get_composite_kernel_fields(cfg['comp_{}'.format(i)])) - elif cfg['comp_{}'.format(i)]['kernel_type'] == 'GaussianRBF': - fields.append(['comp_{}'.format(i), 'src']) - fields.append(['comp_{}'.format(i), 'init_sigma_fn']) - elif cfg['comp_{}'.format(i)]['kernel_type'] == 'RationalQuadratic': - fields.append(['comp_{}'.format(i), 'src']) - fields.append(['comp_{}'.format(i), 'init_sigma_fn']) - fields.append(['comp_{}'.format(i), 'init_alpha_fn']) - elif cfg['comp_{}'.format(i)]['kernel_type'] == 'Period': - fields.append(['comp_{}'.format(i), 'src']) - fields.append(['comp_{}'.format(i), 'init_sigma_fn']) - fields.append(['comp_{}'.format(i), 'init_tau_fn']) + if isinstance(cfg['kernel_list']['comp_{}'.format(i)], dict): + if 'kernel_type' in cfg['kernel_list']['comp_{}'.format(i)]: + if (cfg['kernel_list']['comp_{}'.format(i)]['kernel_type'] == 'Sum') or \ + (cfg['kernel_list']['comp_{}'.format(i)]['kernel_type'] == 'Product'): + fields.extend(_get_composite_kernel_fields(cfg['kernel_list']['comp_{}'.format(i)])) + elif cfg['kernel_list']['comp_{}'.format(i)]['kernel_type'] == 'GaussianRBF': + fields.append(['kernel_list', 'comp_{}'.format(i), 'src']) + fields.append(['kernel_list', 'comp_{}'.format(i), 'init_sigma_fn']) + elif cfg['kernel_list']['comp_{}'.format(i)]['kernel_type'] == 'RationalQuadratic': + fields.append(['kernel_list', 'comp_{}'.format(i), 'src']) + fields.append(['kernel_list', 'comp_{}'.format(i), 'init_sigma_fn']) + fields.append(['kernel_list', 'comp_{}'.format(i), 'init_alpha_fn']) + elif cfg['kernel_list']['comp_{}'.format(i)]['kernel_type'] == 'Period': + fields.append(['kernel_list', 'comp_{}'.format(i), 'src']) + fields.append(['kernel_list', 'comp_{}'.format(i), 'init_sigma_fn']) + fields.append(['kernel_list', 'comp_{}'.format(i), 'init_tau_fn']) else: raise ValueError('Unknown kernel type: {}'.format(cfg['comp_{}'.format(i)]['kernel_type'])) return fields diff --git a/alibi_detect/saving/saving.py b/alibi_detect/saving/saving.py index 59653568a..3e8588207 100644 --- a/alibi_detect/saving/saving.py +++ b/alibi_detect/saving/saving.py @@ -514,9 +514,9 @@ def _save_kernel_config(kernel: Callable, for i, k in enumerate(kernel.kernel_list): if hasattr(k, 'get_config'): - cfg_kernel['comp_' + str(i)] = _save_kernel_config(k, base_path, - Path(local_path, 'kernel_{}'.format(i))) - cfg_kernel = dict(sorted(cfg_kernel.items())) + cfg_kernel['kernel_list']['comp_' + str(i)] =\ + _save_kernel_config(k, base_path, Path(local_path, 'kernel_{}'.format(i))) + cfg_kernel['kernel_list'] = dict(sorted(cfg_kernel['kernel_list'].items())) cfg_kernel['src'], _ = _serialize_object(kernel_class, base_path, local_path.joinpath('kernel')) # If any other kernel, serialize the class to disk and get config diff --git a/alibi_detect/saving/schemas.py b/alibi_detect/saving/schemas.py index 8813ab35b..4ba773084 100644 --- a/alibi_detect/saving/schemas.py +++ b/alibi_detect/saving/schemas.py @@ -51,6 +51,44 @@ def validate_model(cls, model: Any, values: dict) -> Any: raise TypeError('The model is not recognised as a supported type.') +def validate_composite_kernel_config(cfg_kernel_list: Dict[str, Any]) -> Dict[str, Any]: + """ + Validate composite kernel config. + + Parameters + ---------- + cfg_kernel + Composite kernel config. + + Returns + ------- + cfg_kernel + Validated composite kernel config. + """ + # cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() + comp_number = len(cfg_kernel_list) + for i in range(comp_number): + if isinstance(cfg_kernel_list['comp_' + str(i)], dict): + if 'kernel_type' in cfg_kernel_list['comp_' + str(i)]: + if (cfg_kernel_list['comp_' + str(i)]['kernel_type'] == 'Sum') or\ + (cfg_kernel_list['comp_' + str(i)]['kernel_type'] == 'Product'): + cfg_kernel_list['comp_' + str(i)] =\ + CompositeKernelConfig(**cfg_kernel_list['comp_' + str(i)]).dict() + elif cfg_kernel_list['comp_' + str(i)]['kernel_type'] == 'GaussianRBF': + cfg_kernel_list['comp_' + str(i)] =\ + RBFKernelConfig(**cfg_kernel_list['comp_' + str(i)]).dict() + elif cfg_kernel_list['comp_' + str(i)]['kernel_type'] == 'RationalQuadratic': + cfg_kernel_list['comp_' + str(i)] =\ + RationalQuadraticKernelConfig(**cfg_kernel_list['comp_' + str(i)]).dict() + elif cfg_kernel_list['comp_' + str(i)]['kernel_type'] == 'Periodic': + cfg_kernel_list['comp_' + str(i)] =\ + PeriodicKernelConfig(**cfg_kernel_list['comp_' + str(i)]).dict() + else: + raise ValueError('Kernel type not supported.') + cfg_kernel_list = dict(sorted(cfg_kernel_list.items())) # Sort dict to ensure order is consistent + return cfg_kernel_list + + class SupportedOptimizer: """ Pydantic custom type to check the optimizer is one of the supported types (conditional on what optional deps @@ -380,12 +418,13 @@ class RationalQuadraticKernelConfig(CustomBaseModelWithKwargs): """ Unresolved schema for kernels, to be passed to a detector's `kernel` kwarg. - If `src` specifies a :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, the `sigma`, `trainable` and - `init_sigma_fn` fields are passed to it. Otherwise, all fields except `src` are passed as kwargs. + If `src` specifies a :class:`~alibi_detect.utils.tensorflow.RationalQuadratic` kernel, the `sigma`, `alpha`, + 'trainable' and `init_sigma_fn`, 'init_alpha_fn' fields are passed to it. Otherwise, all fields except `src` + are passed as kwargs. Examples -------- - A :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, with three different bandwidths: + A :class:`~alibi_detect.utils.tensorflow.RationalQuadratic` kernel, with three different bandwidths and alphas: .. code-block :: toml @@ -393,6 +432,7 @@ class RationalQuadraticKernelConfig(CustomBaseModelWithKwargs): src = "@alibi_detect.utils.tensorflow.GaussianRBF" trainable = false sigma = [0.1, 0.2, 0.3] + alpha = [1.0, 2.0, 3.0] A serialized kernel with keyword arguments passed: @@ -401,6 +441,7 @@ class RationalQuadraticKernelConfig(CustomBaseModelWithKwargs): [kernel] src = "mykernel.dill" sigma = 0.42 + alpha = 2.0 custom_setting = "xyz" """ src: str @@ -447,8 +488,8 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): """ Unresolved schema for kernels, to be passed to a detector's `kernel` kwarg. - If `src` specifies a :class:`~alibi_detect.utils.tensorflow.GaussianRBF` kernel, the `sigma`, `trainable` and - `init_sigma_fn` fields are passed to it. Otherwise, all fields except `src` are passed as kwargs. + If `src` specifies a :class:`~alibi_detect.utils.tensorflow.PeriodicKernel` kernel, the `sigma`, 'tau', `trainable` + and `init_sigma_fn`, 'init_tau_fn' fields are passed to it. Otherwise, all fields except `src` are passed as kwargs. Examples -------- @@ -457,9 +498,10 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): .. code-block :: toml [kernel] - src = "@alibi_detect.utils.tensorflow.GaussianRBF" + src = "@alibi_detect.utils.tensorflow.PeriodicKernel" trainable = false sigma = [0.1, 0.2, 0.3] + tau = [1.0, 2.0, 3.0] A serialized kernel with keyword arguments passed: @@ -468,6 +510,7 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): [kernel] src = "mykernel.dill" sigma = 0.42 + tau = 1.0 custom_setting = "xyz" """ src: str @@ -513,8 +556,20 @@ class PeriodicKernelConfig(CustomBaseModelWithKwargs): class CompositeKernelConfig(CustomBaseModelWithKwargs): """ Unresolved schema for composite kernels, to be passed to a detector's `kernel` kwarg. - HEre only the src, kernel_type and flavour fields are checked. The kernels within kernel list will be - checked sperately. + + Examples + -------- + A :class:`~alibi_detect.utils.tensorflow.SumKernel` obtained by adding two + :class:`~alibi_detect.utils.tensorflow.GaussianRBF` instances: + + .. code-block :: toml + + [kernel] + src = "@alibi_detect.utils.tensorflow.SumKernel" + kernel_list = [ + RBFKernelConfig(src="@alibi_detect.utils.tensorflow.GaussianRBF", trainable=false, sigma=0.1), + RBFKernelConfig(src="@alibi_detect.utils.tensorflow.GaussianRBF", trainable=false, sigma=0.2) + ] """ src: str @@ -522,6 +577,11 @@ class CompositeKernelConfig(CustomBaseModelWithKwargs): flavour: Literal['tensorflow', 'pytorch'] + kernel_list: Dict + + _validate_composite_kernel =\ + validator('kernel_list', allow_reuse=True, pre=False)(validate_composite_kernel_config) + class DeepKernelConfig(CustomBaseModel): """ diff --git a/alibi_detect/saving/tests/test_saving.py b/alibi_detect/saving/tests/test_saving.py index d792b13cd..90e305870 100644 --- a/alibi_detect/saving/tests/test_saving.py +++ b/alibi_detect/saving/tests/test_saving.py @@ -38,13 +38,12 @@ from alibi_detect.saving import (load_detector, read_config, registry, resolve_config, save_detector, write_config) from alibi_detect.saving.loading import (_get_nested_value, _replace, - _set_dtypes, _set_nested_value, _prepend_cfg_filepaths, - _validate_composite_kernel_config) + _set_dtypes, _set_nested_value, _prepend_cfg_filepaths) from alibi_detect.saving.saving import _serialize_object from alibi_detect.saving.saving import (_path2str, _int2str_keys, _save_kernel_config, _save_model_config, _save_preprocess_config) from alibi_detect.saving.schemas import DeepKernelConfig, ModelConfig, PreprocessConfig, RBFKernelConfig,\ - RationalQuadraticKernelConfig, PeriodicKernelConfig + RationalQuadraticKernelConfig, PeriodicKernelConfig, CompositeKernelConfig from alibi_detect.utils.pytorch.kernels import DeepKernel as DeepKernel_pt from alibi_detect.utils.tensorflow.kernels import DeepKernel as DeepKernel_tf @@ -963,10 +962,12 @@ def test_save_composite_kernel(kernel, backend, tmp_path): # noqa: F811 cfg_kernel = _save_kernel_config(kernel, filepath, filename) if kernel.__class__.__name__ == 'SumKernel': assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.SumKernel' - cfg_kernel = _validate_composite_kernel_config(cfg_kernel) # Pass through validator to test + cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() # Pass through validator to test + # cfg_kernel = _validate_composite_kernel_config(cfg_kernel) # Pass through validator to test elif kernel.__class__.__name__ == 'ProductKernel': assert cfg_kernel['src'] == '@utils.' + backend + '.kernels.ProductKernel' - cfg_kernel = _validate_composite_kernel_config(cfg_kernel) # Pass through validator to test + cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() # Pass through validator to test + # cfg_kernel = _validate_composite_kernel_config(cfg_kernel) # Pass through validator to test else: assert Path(cfg_kernel['src']).suffix == '.dill' diff --git a/alibi_detect/saving/validate.py b/alibi_detect/saving/validate.py index 672ee7431..bf9907526 100644 --- a/alibi_detect/saving/validate.py +++ b/alibi_detect/saving/validate.py @@ -1,7 +1,8 @@ import warnings from alibi_detect.saving.schemas import ( # type: ignore[attr-defined] - DETECTOR_CONFIGS, DETECTOR_CONFIGS_RESOLVED) + DETECTOR_CONFIGS, DETECTOR_CONFIGS_RESOLVED, + RBFKernelConfig, RationalQuadraticKernelConfig, PeriodicKernelConfig) from alibi_detect.version import __version__ @@ -54,3 +55,43 @@ def validate_config(cfg: dict, resolved: bool = False) -> dict: cfg['meta'].update({'version_warning': True}) return cfg + + +def validate_composite_kernel_config(cfg_kernel): + """ + Validate composite kernel config. + + Parameters + ---------- + cfg_kernel + Composite kernel config. + + Returns + ------- + cfg_kernel + Validated composite kernel config. + """ + # cfg_kernel = CompositeKernelConfig(**cfg_kernel).dict() + comp_number = len(cfg_kernel['kernel_list']) + for i in range(comp_number): + if isinstance(cfg_kernel['kernel_list']['comp_' + str(i)], dict): + if 'kernel_type' in cfg_kernel['kernel_list']['comp_' + str(i)]: + if cfg_kernel['kernel_list']['comp_' + str(i)]['kernel_type'] == 'Sum': + cfg_kernel['kernel_list']['comp_' + str(i)] =\ + validate_composite_kernel_config(cfg_kernel['kernel_list']['comp_' + str(i)]) + elif cfg_kernel['kernel_list']['comp_' + str(i)]['kernel_type'] == 'Product': + cfg_kernel['kernel_list']['comp_' + str(i)] =\ + validate_composite_kernel_config(cfg_kernel['kernel_list']['comp_' + str(i)]) + elif cfg_kernel['kernel_list']['comp_' + str(i)]['kernel_type'] == 'GaussianRBF': + cfg_kernel['kernel_list']['comp_' + str(i)] =\ + RBFKernelConfig(**cfg_kernel['kernel_list']['comp_' + str(i)]).dict() + elif cfg_kernel['kernel_list']['comp_' + str(i)]['kernel_type'] == 'RationalQuadratic': + cfg_kernel['kernel_list']['comp_' + str(i)] =\ + RationalQuadraticKernelConfig(**cfg_kernel['kernel_list']['comp_' + str(i)]).dict() + elif cfg_kernel['kernel_list']['comp_' + str(i)]['kernel_type'] == 'Periodic': + cfg_kernel['kernel_list']['comp_' + str(i)] =\ + PeriodicKernelConfig(**cfg_kernel['kernel_list']['comp_' + str(i)]).dict() + else: + raise ValueError('Kernel type not supported.') + cfg_kernel = dict(sorted(cfg_kernel.items())) # Sort dict to ensure order is consistent + return cfg_kernel diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index 4df36c700..add09ef46 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -156,21 +156,21 @@ def __add__( if isinstance(other, SumKernel): kernel_count = len(other.kernel_list) other.kernel_list.append(self) - other.config['comp_' + str(kernel_count)] = self.config # type: ignore + other.config['kernel_list']['comp_' + str(kernel_count)] = self.config # type: ignore return other elif isinstance(other, (BaseKernel, ProductKernel)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config # type: ignore + sum_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.config # type: ignore + sum_kernel.config['kernel_list']['comp_1'] = other.config # type: ignore return sum_kernel elif isinstance(other, torch.Tensor): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config # type: ignore + sum_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.detach().cpu().item() # type: ignore + sum_kernel.config['kernel_list']['comp_1'] = other.detach().cpu().item() # type: ignore return sum_kernel else: raise ValueError('Kernels can only added to another kernel or a constant.') @@ -184,29 +184,29 @@ def __mul__( ) -> 'BaseKernel': if isinstance(other, ProductKernel): other.kernel_list.append(self) - other.config['comp_' + str(len(other.kernel_list))] = self.config # type: ignore + other.config['kernel_list']['comp_' + str(len(other.kernel_list))] = self.config # type: ignore return other elif isinstance(other, SumKernel): sum_kernel = SumKernel() kernel_count = 0 for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) - sum_kernel.config['comp_' + str(kernel_count)] = self.config # type: ignore + sum_kernel.config['kernel_list']['comp_' + str(kernel_count)] = self.config # type: ignore kernel_count += 1 return sum_kernel elif isinstance(other, BaseKernel): prod_kernel = ProductKernel() prod_kernel.kernel_list.append(self) - prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore prod_kernel.kernel_list.append(other) - prod_kernel.config['comp_1'] = other.config # type: ignore + prod_kernel.config['kernel_list']['comp_1'] = other.config # type: ignore return prod_kernel elif isinstance(other, torch.Tensor): prod_kernel = ProductKernel() prod_kernel.kernel_list.append(self) - prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore prod_kernel.kernel_list.append(other) - prod_kernel.config['comp_1'] = other.detach().cpu().item() # type: ignore + prod_kernel.config['kernel_list']['comp_1'] = other.detach().cpu().item() # type: ignore return prod_kernel else: raise ValueError('Kernels can only be multiplied by another kernel or a constant.') @@ -244,14 +244,14 @@ def __init__(self, """ super().__init__() self.kernel_list = [] - self.config: dict = {'kernel_type': 'Sum'} + self.config: dict = {'kernel_type': 'Sum', 'kernel_list': {}} if kernel_list is not None: self.kernel_list = kernel_list for i in range(len(self.kernel_list)): if isinstance(self.kernel_list[i], BaseKernel): - self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + self.config['kernel_list']['comp_' + str(i)] = self.kernel_list[i].config # type: ignore elif isinstance(self.kernel_list[i], torch.Tensor): - self.config['comp_' + str(i)] = \ + self.config['kernel_list']['comp_' + str(i)] = \ self.kernel_list[i].detach().cpu().item() # type: ignore else: raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by SumKernel.') @@ -278,16 +278,16 @@ def __add__( for k in other.kernel_list: self.kernel_list.append(k) if isinstance(k, BaseKernel): - self.config['comp_' + str(kernel_count)] = k.config + self.config['kernel_list']['comp_' + str(kernel_count)] = k.config elif isinstance(k, torch.Tensor): - self.config['comp_' + str(kernel_count)] = k.detach().cpu().item() + self.config['kernel_list']['comp_' + str(kernel_count)] = k.detach().cpu().item() kernel_count += 1 elif isinstance(other, BaseKernel): self.kernel_list.append(other) - self.config['comp_' + str(kernel_count)] = other.config + self.config['kernel_list']['comp_' + str(kernel_count)] = other.config elif isinstance(other, torch.Tensor): self.kernel_list.append(other) - self.config['comp_' + str(kernel_count)] = other.detach().cpu().item() + self.config['kernel_list']['comp_' + str(kernel_count)] = other.detach().cpu().item() else: raise ValueError(type(other) + 'is not supported by SumKernel.') return self @@ -304,7 +304,7 @@ def __mul__( for ki in self.kernel_list: for kj in other.kernel_list: sum_kernel.kernel_list.append((ki * kj)) - sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.config['kernel_list']['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): @@ -313,7 +313,7 @@ def __mul__( sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) - sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.config['kernel_list']['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel else: @@ -369,14 +369,14 @@ def __init__(self, """ super().__init__() self.kernel_list = [] - self.config: dict = {'kernel_type': 'Product'} + self.config: dict = {'kernel_type': 'Product', 'kernel_list': {}} if kernel_list is not None: self.kernel_list = kernel_list for i in range(len(self.kernel_list)): if isinstance(self.kernel_list[i], BaseKernel): - self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + self.config['kernel_list']['comp_' + str(i)] = self.kernel_list[i].config # type: ignore elif isinstance(self.kernel_list[i], torch.Tensor): - self.config['comp_' + str(i)] = \ + self.config['kernel_list']['comp_' + str(i)] = \ self.kernel_list[i].detach().cpu().item() # type: ignore else: raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by ProductKernel.') @@ -400,21 +400,21 @@ def __add__( ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) - other.config['comp_' + str(len(other.kernel_list))] = self.config + other.config['kernel_list']['comp_' + str(len(other.kernel_list))] = self.config return other elif isinstance(other, ProductKernel) or isinstance(other, BaseKernel): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config + sum_kernel.config['kernel_list']['comp_0'] = self.config sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.config + sum_kernel.config['kernel_list']['comp_1'] = other.config return sum_kernel elif isinstance(other, torch.Tensor): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config + sum_kernel.config['kernel_list']['comp_0'] = self.config sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.detach().cpu().item() + sum_kernel.config['kernel_list']['comp_1'] = other.detach().cpu().item() return sum_kernel else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -435,21 +435,22 @@ def __mul__( tmp_prod_kernel = deepcopy(self) tmp_prod_kernel.kernel_list.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) - sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list))] = \ + sum_kernel.config['kernel_list']['comp_' + str(len(sum_kernel.kernel_list))] = \ sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): for k in other.kernel_list: self.kernel_list.append(k) - self.config['comp_' + str(len(self.kernel_list))] = k.config # type: ignore + self.config['kernel_list']['comp_' + str(len(self.kernel_list))] = k.config # type: ignore return self elif isinstance(other, BaseKernel): self.kernel_list.append(other) - self.config['comp_' + str(len(self.kernel_list))] = other.config # type: ignore + self.config['kernel_list']['comp_' + str(len(self.kernel_list))] = other.config # type: ignore return self elif isinstance(other, torch.Tensor): self.kernel_list.append(other) - self.config['comp_' + str(len(self.kernel_list))] = other.detach().cpu().item() # type: ignore + self.config['kernel_list']['comp_' + str(len(self.kernel_list))] =\ + other.detach().cpu().item() # type: ignore return self else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -926,7 +927,7 @@ def from_config(cls, config): def fill_composite_config(config: dict) -> dict: final_config: dict = {'kernel_list': []} - for k_config in config.values(): + for k_config in config['kernel_list'].values(): if isinstance(k_config, dict): k_config.pop('src') if k_config['kernel_type'] == 'Sum': diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index 40a655156..e1b26a016 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -152,21 +152,21 @@ def __add__( if isinstance(other, SumKernel): kernel_count = len(other.kernel_list) other.kernel_list.append(self) - other.config['comp_' + str(kernel_count)] = self.config # type: ignore + other.config['kernel_list']['comp_' + str(kernel_count)] = self.config # type: ignore return other elif isinstance(other, (BaseKernel, ProductKernel)): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config # type: ignore + sum_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.config # type: ignore + sum_kernel.config['kernel_list']['comp_1'] = other.config # type: ignore return sum_kernel elif isinstance(other, tf.Tensor): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config # type: ignore + sum_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.numpy() # type: ignore + sum_kernel.config['kernel_list']['comp_1'] = other.numpy() # type: ignore return sum_kernel else: raise ValueError('Kernels can only added to another kernel or a constant.') @@ -180,29 +180,29 @@ def __mul__( ) -> 'BaseKernel': if isinstance(other, ProductKernel): other.kernel_list.append(self) - other.config['comp_' + str(len(other.kernel_list))] = self.config # type: ignore + other.config['kernel_list']['comp_' + str(len(other.kernel_list))] = self.config # type: ignore return other elif isinstance(other, SumKernel): sum_kernel = SumKernel() kernel_count = 0 for k in other.kernel_list: sum_kernel.kernel_list.append(self * k) - sum_kernel.config['comp_' + str(kernel_count)] = self.config # type: ignore + sum_kernel.config['kernel_list']['comp_' + str(kernel_count)] = self.config # type: ignore kernel_count += 1 return sum_kernel elif isinstance(other, BaseKernel): prod_kernel = ProductKernel() prod_kernel.kernel_list.append(self) - prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore prod_kernel.kernel_list.append(other) - prod_kernel.config['comp_1'] = other.config # type: ignore + prod_kernel.config['kernel_list']['comp_1'] = other.config # type: ignore return prod_kernel elif isinstance(other, tf.Tensor): prod_kernel = ProductKernel() prod_kernel.kernel_list.append(self) - prod_kernel.config['comp_0'] = self.config # type: ignore + prod_kernel.config['kernel_list']['comp_0'] = self.config # type: ignore prod_kernel.kernel_list.append(other) - prod_kernel.config['comp_1'] = other.numpy() # type: ignore + prod_kernel.config['kernel_list']['comp_1'] = other.numpy() # type: ignore return prod_kernel else: raise ValueError('Kernels can only be multiplied by another kernel or a constant.') @@ -240,14 +240,14 @@ def __init__(self, """ super().__init__() self.kernel_list = [] - self.config: dict = {'kernel_type': 'Sum'} + self.config: dict = {'kernel_type': 'Sum', 'kernel_list': {}} if kernel_list is not None: self.kernel_list = kernel_list for i in range(len(self.kernel_list)): if isinstance(self.kernel_list[i], BaseKernel): - self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + self.config['kernel_list']['comp_' + str(i)] = self.kernel_list[i].config # type: ignore elif isinstance(self.kernel_list[i], tf.Tensor): - self.config['comp_' + str(i)] = self.kernel_list[i].numpy() # type: ignore + self.config['kernel_list']['comp_' + str(i)] = self.kernel_list[i].numpy() # type: ignore else: raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by SumKernel.') @@ -272,16 +272,16 @@ def __add__( for k in other.kernel_list: self.kernel_list.append(k) if isinstance(k, BaseKernel): - self.config['comp_' + str(kernel_count)] = k.config + self.config['kernel_list']['comp_' + str(kernel_count)] = k.config elif isinstance(k, tf.Tensor): - self.config['comp_' + str(kernel_count)] = k.numpy() + self.config['kernel_list']['comp_' + str(kernel_count)] = k.numpy() kernel_count += 1 elif isinstance(other, BaseKernel): self.kernel_list.append(other) - self.config['comp_' + str(kernel_count)] = other.config + self.config['kernel_list']['comp_' + str(kernel_count)] = other.config elif isinstance(other, tf.Tensor): self.kernel_list.append(other) - self.config['comp_' + str(kernel_count)] = other.numpy() + self.config['kernel_list']['comp_' + str(kernel_count)] = other.numpy() else: raise ValueError(type(other) + 'is not supported by SumKernel.') return self @@ -298,7 +298,7 @@ def __mul__( for ki in self.kernel_list: for kj in other.kernel_list: sum_kernel.kernel_list.append((ki * kj)) - sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.config['kernel_list']['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): @@ -307,7 +307,7 @@ def __mul__( sum_kernel = SumKernel() for ki in self.kernel_list: sum_kernel.kernel_list.append(other * ki) - sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ + sum_kernel.config['kernel_list']['comp_' + str(len(sum_kernel.kernel_list) - 1)] = \ sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel else: @@ -363,14 +363,14 @@ def __init__(self, """ super().__init__() self.kernel_list = [] - self.config: dict = {'kernel_type': 'Product'} + self.config: dict = {'kernel_type': 'Product', 'kernel_list': {}} if kernel_list is not None: self.kernel_list = kernel_list for i in range(len(self.kernel_list)): if isinstance(self.kernel_list[i], BaseKernel): - self.config['comp_' + str(i)] = self.kernel_list[i].config # type: ignore + self.config['kernel_list']['comp_' + str(i)] = self.kernel_list[i].config # type: ignore elif isinstance(self.kernel_list[i], tf.Tensor): - self.config['comp_' + str(i)] = self.kernel_list[i].cpu().numpy() # type: ignore + self.config['kernel_list']['comp_' + str(i)] = self.kernel_list[i].cpu().numpy() # type: ignore else: raise ValueError(str(type(self.kernel_list[i])) + 'is not supported by ProductKernel.') @@ -392,21 +392,21 @@ def __add__( ) -> 'SumKernel': if isinstance(other, SumKernel): other.kernel_list.append(self) - other.config['comp_' + str(len(other.kernel_list))] = self.config + other.config['kernel_list']['comp_' + str(len(other.kernel_list))] = self.config return other elif isinstance(other, ProductKernel) or isinstance(other, BaseKernel): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config + sum_kernel.config['kernel_list']['comp_0'] = self.config sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.config + sum_kernel.config['kernel_list']['comp_1'] = other.config return sum_kernel elif isinstance(other, tf.Tensor): sum_kernel = SumKernel() sum_kernel.kernel_list.append(self) - sum_kernel.config['comp_0'] = self.config + sum_kernel.config['kernel_list']['comp_0'] = self.config sum_kernel.kernel_list.append(other) - sum_kernel.config['comp_1'] = other.numpy() + sum_kernel.config['kernel_list']['comp_1'] = other.numpy() return sum_kernel else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -427,21 +427,21 @@ def __mul__( tmp_prod_kernel = deepcopy(self) tmp_prod_kernel.kernel_list.append(k) sum_kernel.kernel_list.append(tmp_prod_kernel) - sum_kernel.config['comp_' + str(len(sum_kernel.kernel_list))] = \ + sum_kernel.config['kernel_list']['comp_' + str(len(sum_kernel.kernel_list))] = \ sum_kernel.kernel_list[-1].config # type: ignore return sum_kernel elif isinstance(other, ProductKernel): for k in other.kernel_list: self.kernel_list.append(k) - self.config['comp_' + str(len(self.kernel_list))] = k.config # type: ignore + self.config['kernel_list']['comp_' + str(len(self.kernel_list))] = k.config # type: ignore return self elif isinstance(other, BaseKernel): self.kernel_list.append(other) - self.config['comp_' + str(len(self.kernel_list))] = other.config # type: ignore + self.config['kernel_list']['comp_' + str(len(self.kernel_list))] = other.config # type: ignore return self elif isinstance(other, tf.Tensor): self.kernel_list.append(other) - self.config['comp_' + str(len(self.kernel_list))] = other.numpy() # type: ignore + self.config['kernel_list']['comp_' + str(len(self.kernel_list))] = other.numpy() # type: ignore return self else: raise ValueError(type(other) + 'is not supported by ProductKernel.') @@ -903,7 +903,7 @@ def from_config(cls, config): def fill_composite_config(config: dict) -> dict: final_config: dict = {'kernel_list': []} - for k_config in config.values(): + for k_config in config['kernel_list'].values(): if isinstance(k_config, dict): k_config.pop('src') if k_config['kernel_type'] == 'Sum': From fb922a2670bfbc6a9834ef1de7782db695202ae4 Mon Sep 17 00:00:00 2001 From: Hao Song Date: Mon, 3 Apr 2023 06:27:56 -0700 Subject: [PATCH 37/37] Fix dimension selection for TF. --- alibi_detect/utils/keops/kernels.py | 2 -- alibi_detect/utils/pytorch/kernels.py | 4 ---- alibi_detect/utils/tensorflow/kernels.py | 4 ++-- 3 files changed, 2 insertions(+), 8 deletions(-) diff --git a/alibi_detect/utils/keops/kernels.py b/alibi_detect/utils/keops/kernels.py index 500f57b63..cecba108b 100644 --- a/alibi_detect/utils/keops/kernels.py +++ b/alibi_detect/utils/keops/kernels.py @@ -397,8 +397,6 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__(active_dims) init_sigma_fn = sigma_mean if init_sigma_fn is None else init_sigma_fn diff --git a/alibi_detect/utils/pytorch/kernels.py b/alibi_detect/utils/pytorch/kernels.py index add09ef46..f8c58006c 100644 --- a/alibi_detect/utils/pytorch/kernels.py +++ b/alibi_detect/utils/pytorch/kernels.py @@ -524,8 +524,6 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__(active_dims) self.init_sigma_fn = log_sigma_median if init_sigma_fn is None else init_sigma_fn @@ -721,8 +719,6 @@ def __init__( Whether or not to track gradients w.r.t. `sigma` to allow it to be trained. active_dims Indices of the dimensions of the feature to be used for the kernel. If None, all dimensions are used. - feature_axis - Axis of the feature dimension. """ super().__init__(active_dims) if tau is not None and sigma is not None: diff --git a/alibi_detect/utils/tensorflow/kernels.py b/alibi_detect/utils/tensorflow/kernels.py index e1b26a016..6ecb6ce8d 100644 --- a/alibi_detect/utils/tensorflow/kernels.py +++ b/alibi_detect/utils/tensorflow/kernels.py @@ -141,8 +141,8 @@ def kernel_function(self, x: tf.Tensor, y: tf.Tensor, def call(self, x: tf.Tensor, y: tf.Tensor, infer_parameter: bool = False) -> tf.Tensor: y = tf.cast(y, x.dtype) if self.active_dims is not None: - x = tf.gather(x, self.active_dims, axis=self.feature_axis) - y = tf.gather(y, self.active_dims, axis=self.feature_axis) + x = tf.gather(x, self.active_dims, axis=-1) + y = tf.gather(y, self.active_dims, axis=-1) return self.kernel_function(x, y, infer_parameter) def __add__(