Upload 4 files

synbench/copula.py

@@ -0,0 +1,686 @@
+import random
+import math
+
+import numpy as np
+import torch
+from torch.distributions import Normal, Beta, Exponential, StudentT
+from scipy.stats import beta as scipy_beta
+
+
+
+# ───────────────────────── helper: icdf() calculation on torch ──────────────────────────
+def _neg_log1p(u):
+    """
+    Compute -log(1 - u) in a numerically stable way for u close to 0.
+
+    Args:
+        u: Tensor with values in [0, 1).
+
+    Returns:
+        Tensor of -log(1 - u), clamped to be non-negative.
+    """
+    return (-torch.log1p(-u)).clamp_min(0.0)
+
+
+def exp_icdf(u, rate):
+    """
+    Inverse CDF (quantile function) of the Exponential distribution.
+
+    Args:
+        u    : Tensor of shape (...,) with values in (0, 1).
+        rate : Scale parameter λ > 0, broadcastable with u.
+
+    Returns:
+        Tensor of the same shape as u containing the quantiles.
+    """
+    return _neg_log1p(u) / rate
+
+
+def beta_icdf(p, a, b, n_grid: int = 1000):
+    """
+    Approximate inverse CDF (quantile function) of the Beta distribution via
+    numerical CDF inversion on a uniform grid followed by linear interpolation.
+
+    Args:
+        p      : Tensor of probabilities in (0, 1), shape (N,) or (N, D).
+        a      : Alpha (concentration1) parameter(s), broadcastable to (1, D).
+        b      : Beta  (concentration0) parameter(s), broadcastable to (1, D).
+        n_grid : Number of grid points used to approximate the CDF (default 1000).
+
+    Returns:
+        Tensor of quantiles with shape (N, D), clamped to [0, 1].
+    """
+    p = torch.as_tensor(p, dtype=torch.float32)
+    a = torch.as_tensor(a, dtype=torch.float32)
+    b = torch.as_tensor(b, dtype=torch.float32)
+    if a.size() == torch.Size([]):
+      a = a.expand(1)
+    if b.size() == torch.Size([]):
+      b = b.expand(1)
+    x = torch.linspace(0.0, 1.0, n_grid + 1, dtype=torch.float32, device=p.device)
+    mid = (x[:-1] + x[1:]) / 2.0
+    mid = mid.view(-1, 1)  # shape [n_grid, 1]
+    dx = 1.0 / n_grid
+
+    log_norm = torch.lgamma(a) + torch.lgamma(b) - torch.lgamma(a + b)
+    pdf_mid = torch.exp((a - 1) * torch.log(mid) +
+                        (b - 1) * torch.log1p(-mid) -
+                        log_norm)  # [n_grid, D]
+    cdf = torch.cumsum(pdf_mid, dim=0) * dx  # [n_grid, D]
+    cdf = torch.cat([torch.zeros(1, cdf.shape[1], device=p.device), cdf], dim=0)  # [n_grid+1, D]
+    # Expand p to match shape [N, D]
+    if p.ndim == 1:
+        p = p.unsqueeze(1)
+    if a.ndim == 1:
+        a = a.unsqueeze(0)
+        b = b.unsqueeze(0)
+    if p.shape[1] != a.shape[1]:
+        p = p.expand(-1, a.shape[1])
+    # Searchsorted per-dimension
+    N, D = p.shape
+    idx = torch.empty((N, D), dtype=torch.long, device=p.device)
+    for d in range(D):
+        idx[:, d] = torch.searchsorted(cdf[:, d], p[:, d], right=False).clamp(1, n_grid)
+    # Gather x and y for interpolation
+    x0 = x[idx - 1]
+    x1 = x[idx]
+    y0 = torch.empty_like(p)
+    y1 = torch.empty_like(p)
+    for d in range(D):
+        y0[:, d] = cdf[idx[:, d] - 1, d]
+        y1[:, d] = cdf[idx[:, d], d]
+
+    t = (p - y0) / (y1 - y0 + 1e-12)
+    return torch.clamp(x0 + t * (x1 - x0), 0., 1.)
+
+
+def student_t_icdf(u, df):
+    """
+    Approximate inverse CDF (quantile function) of the Student-t distribution.
+
+    Uses the relationship between the Student-t and Beta distributions:
+    p-value of |t| under t(df) equals the regularised incomplete beta function
+    evaluated at df/(df + t^2).
+
+    Args:
+        u  : Tensor of probabilities in (0, 1).
+        df : Degrees-of-freedom parameter, broadcastable with u.
+
+    Returns:
+        Tensor of quantiles with the same shape as u.
+    """
+    u = torch.as_tensor(u, dtype=torch.float32)
+    df = torch.as_tensor(df, dtype=torch.float32)
+
+    p = 2.0 * torch.minimum(u, 1 - u)
+    p = p.to(df.device)
+    x = beta_icdf(p, 0.5 * df, torch.tensor(0.5,device = p.device))
+    t = torch.sqrt(df * (1.0 / x - 1.0))
+    return torch.where(u > 0.5, t, -t)
+
+
+def normal_cdf(x):
+    """
+    CDF of the standard normal distribution evaluated element-wise.
+
+    Args:
+        x: Tensor of real-valued inputs.
+
+    Returns:
+        Tensor of probabilities in (0, 1) with the same shape as x.
+    """
+    return 0.5*(1+torch.special.erf(x/math.sqrt(2)))
+
+
+def normal_ppf(u):
+    """
+    Percent-point function (inverse CDF) of the standard normal distribution.
+
+    Args:
+        u: Tensor of probabilities in (0, 1).
+
+    Returns:
+        Tensor of quantiles with the same shape as u.
+    """
+    return Normal(0,1).icdf(u)
+
+
+# ─────────────── low-level helpers ───────────────
+def rand_corr_batch(batch, d, identity=False, device='cuda'):
+    """
+    Generate a batch of random (or identity) correlation matrices.
+
+    A valid positive-definite correlation matrix is produced by forming
+    A @ A^T and normalising so that every diagonal entry equals 1.
+
+    Args:
+        batch    : Number of correlation matrices to generate.
+        d        : Dimension of each matrix.
+        identity : If True, return identity matrices instead of random ones.
+        device   : Torch device string (default 'cuda').
+
+    Returns:
+        Tensor of shape (B, d, d) containing correlation matrices on the
+        specified device with dtype torch.float32.
+    """
+    if identity:
+        eye = torch.eye(d, device=device, dtype=torch.float32)
+        return eye.expand(batch, -1, -1).clone()
+
+    A   = torch.rand(batch, d, d, device=device, dtype=torch.float32)
+    psd = A @ A.transpose(-1, -2)
+    diag= torch.diagonal(psd, dim1=-2, dim2=-1)
+    norm= torch.sqrt(torch.clamp(diag, 1e-12))
+    C   = psd / (norm.unsqueeze(-1)*norm.unsqueeze(-2))
+    C.diagonal(dim1=-2, dim2=-1).fill_(1.)
+    C += torch.eye(d, device=device, dtype=torch.float32).unsqueeze(0)*1e-6
+    return C
+
+
+def mvn_sample(chol, device):
+    """
+    Draw one sample per batch from a zero-mean multivariate normal distribution
+    parameterised by its Cholesky factor.
+
+    Args:
+        chol   : Lower-triangular Cholesky factor of shape (B, d, d) or (d, d).
+                 A 2-D input is broadcast to batch size 1.
+        device : Torch device on which to allocate the standard normal noise.
+
+    Returns:
+        Tensor of shape (B, d) containing the multivariate normal samples.
+    """
+    # chol: (B,d,d) or (d,d)
+    if chol.dim() == 2: chol = chol.unsqueeze(0)
+    B,d = chol.shape[:2]
+    z   = torch.randn(B, d, 1, device=device, dtype=torch.float32)
+    return (chol @ z).squeeze(-1)           # (B,d)
+
+
+# ─────────────── mixture helpers ───────────────
+class GaussianMix:
+    """
+    A univariate Gaussian mixture model that supports CDF and quantile queries.
+
+    Components are specified as (weight, mean, std) tuples; weights are
+    automatically normalised to sum to 1.
+    """
+
+    def __init__(self, comps, device='cpu'):
+        """
+        Initialise the Gaussian mixture.
+
+        Args:
+            comps  : Iterable of (weight, mean, std) tuples defining each component.
+            device : Torch device on which to store parameter tensors (default 'cpu').
+        """
+        w, mu, sigma = zip(*comps)
+        self.device = device
+        self.w = torch.tensor(w, device=device, dtype=torch.float32)
+        self.mu = torch.tensor(mu, device=device, dtype=torch.float32)
+        self.sigma = torch.tensor(sigma, device=device, dtype=torch.float32)
+        self.w /= self.w.sum()
+
+    def cdf(self, x):
+        """
+        Evaluate the mixture CDF at x.
+
+        Args:
+            x: Scalar or tensor of query points.
+
+        Returns:
+            Tensor of CDF values in [0, 1] with the same shape as x.
+        """
+        x = torch.as_tensor(x, dtype=torch.float32, device=self.device)
+        z = (x.unsqueeze(-1) - self.mu) / (self.sigma * math.sqrt(2))
+        return (self.w * (0.5 * (1 + torch.erf(z)))).sum(-1)
+
+    def ppf_bounds(self):
+        """
+        Return conservative lower and upper bounds for the support of the mixture.
+
+        Returns:
+            Tuple (lo, hi) of floats representing the ±5-sigma range across all
+            mixture components.
+        """
+        lo = (self.mu - 5 * self.sigma).min().item()
+        hi = (self.mu + 5 * self.sigma).max().item()
+        return lo, hi
+
+    def ppf(self, u, tol=1e-5, max_iter=100):
+        """
+        Quantile function of the mixture via bisection search.
+
+        Args:
+            u        : Tensor of probabilities in (0, 1), shape (...).
+            tol      : Convergence tolerance on the bracket width (default 1e-5).
+            max_iter : Maximum number of bisection iterations (default 100).
+
+        Returns:
+            Tensor of quantiles with the same shape as u.
+        """
+        u = torch.as_tensor(u, device=self.device, dtype=torch.float32)
+        low, high = self.ppf_bounds()
+        low = torch.full_like(u, low)
+        high = torch.full_like(u, high)
+
+        for _ in range(max_iter):
+            mid = 0.5 * (low + high)
+            cdf_mid = self.cdf(mid)
+            low = torch.where(cdf_mid < u, mid, low)
+            high = torch.where(cdf_mid >= u, mid, high)
+            if torch.max(high - low) < tol:
+                break
+        return 0.5 * (low + high)
+
+
+class BetaMix:
+    """
+    A univariate Beta mixture model with per-component location-scale transforms.
+
+    Each component is specified as (weight, alpha, beta, loc, scale) so that the
+    effective random variable is  loc + scale * Beta(alpha, beta).
+    """
+
+    def __init__(self, comps, device='cuda'):
+        """
+        Initialise the Beta mixture.
+
+        Args:
+            comps  : Iterable of (weight, alpha, beta, loc, scale) tuples.
+            device : Torch device on which to store parameter tensors (default 'cuda').
+        """
+        self.comps = comps
+        self.w = torch.tensor([c[0] for c in comps], device=device, dtype=torch.float32)
+        self.a = torch.tensor([c[1] for c in comps], device=device, dtype=torch.float32)
+        self.b = torch.tensor([c[2] for c in comps], device=device, dtype=torch.float32)
+        self.loc = torch.tensor([c[3] for c in comps], device=device, dtype=torch.float32)
+        self.sc = torch.tensor([c[4] for c in comps], device=device, dtype=torch.float32)
+        self.w /= self.w.sum()
+        self.device = device
+
+    def cdf(self, x: torch.Tensor):
+        """
+        Evaluate the mixture CDF at x using SciPy's Beta CDF (CPU fallback).
+
+        Args:
+            x: Tensor of query points.
+
+        Returns:
+            Tensor of CDF values in [0, 1] with the same shape as x,
+            returned on the device specified at construction time.
+        """
+        # Fallback to CPU-based computation
+        x_cpu = x.detach().cpu().numpy()
+        cdf_vals = np.zeros_like(x_cpu)
+        for w, a, b, loc, scale in zip(self.w, self.a, self.b, self.loc, self.sc):
+            dist = scipy_beta(a=a.item(), b=b.item(), loc=loc.item(), scale=scale.item())
+            cdf_vals += w.item() * dist.cdf(x_cpu)
+        return torch.tensor(cdf_vals, device=self.device, dtype=torch.float32)
+
+    def ppf_bounds(self):
+        """
+        Return conservative lower and upper bounds for the support of the mixture.
+
+        Returns:
+            Tuple (lo, hi) of floats corresponding to the minimum loc and the
+            maximum loc + scale across all components.
+        """
+        lo = (self.loc).min().item()
+        hi = (self.loc + self.sc).max().item()
+        return lo, hi
+
+# ─────────────── marginal catalogue ───────────────
+def rand_def(device='cuda', PPF_GRID=1_000):
+    """
+    Randomly sample a marginal distribution specification.
+
+    Picks uniformly from: Normal, Beta, Exponential, StudentT, Gaussian mixture,
+    and Beta mixture.  For parametric torch distributions the spec contains the
+    distribution object directly; for mixture models an interpolation grid is
+    precomputed and stored instead.
+
+    Args:
+        device   : Torch device on which to allocate tensors (default 'cuda').
+        PPF_GRID : Number of grid points for the quantile interpolation table
+                   used by mixture distributions (default 1000).
+
+    Returns:
+        dict with key 'kind':
+          - 'torch'  → also has key 'dist' (a torch.distributions instance).
+          - 'interp' → also has keys 'u', 'x', 'lo', 'hi' for grid interpolation.
+    """
+
+    cat = random.choice(["normal","beta","beta_mix","expo","gauss_mix","beta_mix","student"])
+    if cat=="normal":
+        return dict(kind="torch", dist=Normal(torch.tensor(random.uniform(-1,1)),
+                                              torch.tensor(random.uniform(1.5,2))))
+    if cat=="beta":
+        return dict(kind="torch", dist=Beta(torch.tensor(random.uniform(1,5)),
+                                            torch.tensor(random.uniform(1,5))))
+    if cat=="expo":
+        return dict(kind="torch", dist=Exponential(torch.tensor(random.uniform(1,2))))
+    if cat=="student":
+        return dict(kind="torch", dist=StudentT(torch.tensor(random.randint(3,10))))
+    if cat=="gauss_mix":
+        comps = [(random.uniform(0.3,0.7),
+                  random.uniform(-3,3),
+                  random.uniform(0.5,1.5)) for _ in range(random.randint(1,3))]
+        mix   = GaussianMix(comps)
+    else:
+        comps = [(random.uniform(0.3,0.7),
+                  random.uniform(1,5),
+                  random.uniform(1,5),
+                  -5.0, 10.0) for _ in range(random.randint(1,3))]
+        mix   = BetaMix(comps,device=device)
+    # build interpolation grids
+    u_grid = torch.linspace(0.001,0.999,PPF_GRID, device=device, dtype=torch.float32)
+    lo,hi  = mix.ppf_bounds()
+    x_grid = torch.linspace(lo,hi,PPF_GRID, device=device, dtype=torch.float32)
+    #cdf_vals = mix.cdf(x_grid)
+    return dict(kind="interp", u=u_grid, x=x_grid, lo=lo, hi=hi)
+
+
+class CopulaGenerator:
+    """
+    Generates labelled anomaly-detection datasets via a Gaussian copula.
+
+    The joint distribution is built by:
+      1. Sampling from a multivariate normal with a random correlation structure.
+      2. Mapping each marginal through its CDF to obtain uniform scores.
+      3. Applying per-dimension quantile functions drawn from ``rand_def`` to
+         produce the final heterogeneous features.
+
+    Inliers follow the base copula; outliers are injected by either perturbing
+    the uniform scores toward the tails or by replacing a random sub-block of the
+    Cholesky factor with an independent structure.
+    """
+
+    def __init__(self, num_dims, device="cuda", ppf_grid=2_000):
+        """
+        Initialise the copula generator.
+
+        Args:
+            num_dims : Number of feature dimensions (d).
+            device   : Torch device (default 'cuda').
+            ppf_grid : Grid resolution for quantile interpolation tables
+                       used by mixture marginals (default 2000).
+        """
+        self.num_dims = num_dims
+        self.device = device
+        self.dtype = torch.float32
+        self.ppf_grid = ppf_grid
+        self.chol_base = torch.linalg.cholesky(
+            rand_corr_batch(1, num_dims, device=device)[0]
+        )
+        self.specs = [rand_def(device=device, PPF_GRID=ppf_grid) for _ in range(num_dims)]
+
+
+    def sample_inliers(self, num_inliers):
+        """
+        Sample inlier observations from the base copula.
+
+        Draws from the zero-mean multivariate normal defined by the stored
+        Cholesky factor.  The raw Gaussian samples are returned without
+        marginal transformation so that ``_transform`` can be applied later.
+
+        Args:
+            num_inliers : Number of inlier samples to generate.
+
+        Returns:
+            Tensor of shape (num_inliers, num_dims) containing the raw
+            Gaussian-copula samples.
+        """
+        z = torch.randn(num_inliers, self.num_dims, device=self.device, dtype=self.dtype)
+        samples = (z @ self.chol_base.T)
+        return samples
+
+    def sample_outliers(self,
+                        num_outliers,
+                        method="probabilistic",
+                        strength=0.2):
+        """
+        Generate outlier observations in Gaussian-copula space.
+
+        Two injection strategies are supported:
+
+        ``'probabilistic'``
+            Samples from the base copula, converts to uniform marginals, then
+            forces a random subset of dimensions toward 0 or 1 to create
+            extreme-value anomalies.
+
+        ``'dependence'``
+            Replaces a contiguous block of the Cholesky factor with a randomly
+            rotated version, breaking the local correlation structure.
+
+        Args:
+            num_outliers : Number of outlier samples to generate.
+            method       : Injection strategy – ``'probabilistic'`` or
+                           ``'dependence'`` (default ``'probabilistic'``).
+            strength     : Controls how extreme the perturbation is.  For
+                           ``'probabilistic'`` this is the tail-fraction pushed;
+                           for ``'dependence'`` it is the mixing weight of
+                           the random sub-block (default 0.2).
+
+        Returns:
+            Tensor of shape (num_outliers, num_dims) in Gaussian-copula space
+            (before marginal transformation).
+
+        Raises:
+            ValueError: If ``method`` is not one of the supported strategies.
+        """
+        if method == "probabilistic":
+            # 1. Sample from base MVN
+            z = torch.randn(num_outliers, self.num_dims, device=self.device, dtype=self.dtype)
+            samples = (z @ self.chol_base.T)
+
+            # 2. Transform to uniform
+            U = normal_cdf(samples)
+            min_k = max(1, math.ceil(0.02 * self.num_dims))
+            max_k = max(min_k, math.floor(0.2 * self.num_dims))
+
+            # Ensure min_k < max_k + 1 to avoid invalid range
+            if min_k >= max_k + 1:
+                max_k = min_k # fallback: both min_k and max_k equal, will result in k_row = min_k
+
+            k_row = torch.randint(min_k, max_k + 1, (num_outliers,), device=self.device)
+            #k_row = torch.randint(5, 6, (num_outliers,), device=self.device) 
+            perm = torch.rand(num_outliers, self.num_dims, device=self.device).argsort(dim=1)
+            sel_mask = torch.arange(self.num_dims, device=self.device).expand(num_outliers, -1) < k_row.unsqueeze(1)
+            mask = torch.zeros_like(U, dtype=torch.bool).scatter(1, perm, sel_mask)
+
+            push0 = torch.rand_like(U) < 0.5
+            z_mask, o_mask = mask & push0, mask & ~push0
+            noise = torch.empty_like(U)
+            noise[z_mask] = strength * torch.rand(z_mask.sum(), device=self.device) * 0.5
+            noise[o_mask] = 1.0 - strength * torch.rand(o_mask.sum(), device=self.device) * 0.5
+            U[mask] = noise[mask]
+
+            samples = Normal(0, 1).icdf(U)
+            return samples
+
+        elif method == "dependence":
+            d, device = self.num_dims, self.device
+            base_L    = self.chol_base                       
+            # 1) Random block lengths k  and start indices i0  –– now 1 … d inclusive 
+            lowerbound = int(1+ d//3)
+            upperbound = min(int(1+ 2 * d//3),d+1)
+            if lowerbound == upperbound:
+              upperbound += 1
+            k      = torch.randint(lowerbound, upperbound, (num_outliers,), device=device)     # (B,) #int(1+ d//2)
+            k_max  = int(k.max())
+
+            # Vectorised start positions: i0[b] ∈ {0 … d-k[b]}
+            # torch.randint can’t take a per-element “high”, so we synthesise i0 using rand():
+            max_start = d - k                          # (B,)
+            i0 = (torch.rand(num_outliers, device=device) * (max_start + 1)
+                ).floor().long()                      # (B,)
+
+            i1 = i0 + k                                # (B,)  exclusive end index
+            L_rand_full = torch.linalg.cholesky(
+                rand_corr_batch(num_outliers, k_max, identity=True, device=device)          # (B,k_max,k_max)
+            )
+            rows  = torch.arange(k_max, device=device).view(1, k_max, 1)     # (1,k_max,1)
+            cols  = torch.arange(k_max, device=device).view(1, 1, k_max)     # (1,1,k_max)
+            keep  = (rows < k.view(-1, 1, 1)) & (cols < k.view(-1, 1, 1))    # (B,k_max,k_max)
+
+            L_rand_pad = torch.zeros(num_outliers, d, d, device=device)      # (B,d,d)
+            L_rand_pad[:, :k_max, :k_max][keep] = L_rand_full[keep]
+            L_mix = base_L.expand(num_outliers, -1, -1).clone()
+
+            row = torch.arange(d, device=device).view(1, d)        # (1,d)
+            mask_rows = (row >= i0.view(-1, 1)) & (row < i1.view(-1, 1))  # (B,d)
+            col = torch.arange(d, device=device).view(1, 1, d)     # (1,1,d)
+            mask = mask_rows.unsqueeze(-1) & (col < row.unsqueeze(-1) + 1)
+
+            L_mix = torch.where(mask,
+                                (1- strength) * L_mix + strength *L_rand_pad,
+                                L_mix)
+            L_mix.diagonal(dim1=-2, dim2=-1).clamp_(min=1e-6)
+            return mvn_sample(L_mix, device=device)  
+        else:
+            raise ValueError(f"Unsupported outlier injection method: {method}")
+
+    def _transform(self, samples):
+        """
+        Map Gaussian-copula samples to the target marginal distributions.
+
+        Converts each column of ``samples`` through the standard-normal CDF to
+        obtain uniform scores, then applies the per-dimension quantile function
+        stored in ``self.specs``.
+
+        Distribution-specific dispatch:
+          - ``Normal``, ``Beta``, ``Exponential``, ``StudentT`` → vectorised GPU
+            operations (batched across all columns of the same type).
+          - Mixture (``kind='interp'``) → fast linear interpolation on the
+            precomputed PPF grid.
+
+        Args:
+            samples : Tensor of shape (N, D) in Gaussian-copula space.
+
+        Returns:
+            Tensor of shape (N, D) with each column drawn from its target
+            marginal distribution.
+        """
+        U = normal_cdf(samples)
+        eps = 1e-6
+        U = torch.clamp(U, eps, 1-eps) #make sure U does not approch infty
+        N, D = U.shape
+        X = torch.empty_like(U)
+        # Group columns by distribution type
+        interp_cols, normal_cols, beta_cols, exp_cols, student_cols = [], [], [], [], []
+        for d, spec in enumerate(self.specs):
+            if spec["kind"] == "interp":
+                interp_cols.append(d)
+            elif spec["kind"] == "torch":
+                dist = spec["dist"]
+                if isinstance(dist, Normal):
+                    normal_cols.append(d)
+                elif isinstance(dist, Beta):
+                    beta_cols.append(d)
+                elif isinstance(dist, Exponential):
+                    exp_cols.append(d)
+                elif isinstance(dist, StudentT):
+                    student_cols.append(d)
+        # ---------- Interp mixture sampling ----------
+        for d in interp_cols:
+            u = U[:, d]
+            spec = self.specs[d]
+            grid_min = spec["u"][0]
+            grid_max = spec["u"][-1]
+            n_bins = len(spec["u"]) - 1
+            bin_width = (grid_max - grid_min) / n_bins
+            # Clamp u to grid range
+            u_clamped = torch.clamp(u, grid_min, grid_max - 1e-6)
+            # Fast approximate bin index (assumes linear CDF grid)
+            idx = ((u_clamped - grid_min) / bin_width).long().clamp(0, n_bins - 1)
+            idx = torch.clamp(idx, 1, len(spec["u"]) - 1)
+            u_lo, u_hi = spec["u"][idx - 1], spec["u"][idx]
+            x_lo, x_hi = spec["x"][idx - 1], spec["x"][idx]
+            X[:, d] = x_lo + (u - u_lo) * (x_hi - x_lo) / (u_hi - u_lo)
+        # ---------- Normal ----------
+        if normal_cols:
+            loc = torch.tensor([self.specs[d]["dist"].loc for d in normal_cols],
+                            device=self.device).view(1, -1)
+            scale = torch.tensor([self.specs[d]["dist"].scale for d in normal_cols],
+                                device=self.device).view(1, -1)
+            dist = Normal(loc, scale)
+            X[:, normal_cols] = dist.icdf(U[:, normal_cols])
+        # ---------- Beta ----------
+        if beta_cols:
+            a = torch.tensor([self.specs[d]["dist"].concentration1 for d in beta_cols],
+                            device=self.device).view(1, -1)
+            b = torch.tensor([self.specs[d]["dist"].concentration0 for d in beta_cols],
+                            device=self.device).view(1, -1)
+            X[:, beta_cols] = beta_icdf(U[:, beta_cols], a, b)
+        # ---------- Exponential ----------
+        if exp_cols:
+            rate = torch.tensor([self.specs[d]["dist"].rate for d in exp_cols],
+                                device=self.device).view(1, -1)
+            X[:, exp_cols] = exp_icdf(U[:, exp_cols], rate)
+        # ---------- StudentT ----------
+        if student_cols:
+            df = torch.tensor([self.specs[d]["dist"].df for d in student_cols],
+                            device=self.device).view(1, -1)
+            X[:, student_cols] = student_t_icdf(U[:, student_cols], df)
+        return X
+
+
+
+    @torch.no_grad()
+    def draw_batched_data(self,
+                          num_inliers,
+                          num_local_anomalies):
+        """
+        Generate a labelled dataset of inliers and outliers.
+
+        Randomly selects an outlier-injection method and strength, draws both
+        populations, concatenates them, applies the marginal transformation, and
+        then splits the result back into inlier and outlier tensors.
+
+        Args:
+            num_inliers        : Number of normal (inlier) observations.
+            num_local_anomalies: Number of anomalous (outlier) observations.
+
+        Returns:
+            Tuple ``(X_inliers, X_outliers)`` where each element is a Tensor of
+            shape (n, num_dims) already transformed to the target marginals.
+        """
+        METHOD = random.choice(['dependence']) #["disturb_covariance"])#,"probabilistic"])  # or add "probabilistic"
+        STRENGTH = random.uniform(0.2,0.4) if METHOD == 'probabilistic' else random.uniform(0.97,0.99)
+        inliers = self.sample_inliers(num_inliers)
+
+        outliers =  self.sample_outliers(num_local_anomalies, method=METHOD, strength=STRENGTH)
+        combined = torch.cat([inliers, outliers], dim=0)
+
+        X_combined = self._transform(combined)
+        X_inliers = X_combined[:num_inliers]
+        X_outliers = X_combined[num_inliers:]
+
+        return X_inliers, X_outliers
+
+
+def make_Copula(device,
+                max_feature_dim=100,
+                min_feature_dim=2,
+                dim=None):
+    """
+    Convenience factory for ``CopulaGenerator`` with a randomised feature dimension.
+
+    Args:
+        device          : Torch device string (e.g. ``'cuda'``, ``'cpu'``).
+        max_feature_dim : Upper bound (exclusive) for the random feature count
+                          when ``dim`` is not provided (default 100).
+        min_feature_dim : Lower bound (inclusive) for the random feature count
+                          when ``dim`` is not provided (default 2).
+        dim             : If given, use this exact feature dimension instead of
+                          sampling randomly.
+
+    Returns:
+        A freshly initialised ``CopulaGenerator`` instance.
+    """
+    if dim is not None:
+        num_features = dim
+    else:
+        num_features = np.random.randint(min_feature_dim, max_feature_dim)
+    return CopulaGenerator(num_dims=num_features, device=device)

synbench/generator.py

@@ -0,0 +1,148 @@
+from copula import CopulaGenerator
+from gmm import make_NdMclusterGMM
+from scm import make_structuralSCM
+
+import math
+import os
+import random
+
+import numpy as np
+import torch
+from sklearn.metrics import roc_auc_score
+from sklearn.neighbors import LocalOutlierFactor
+from tqdm import tqdm
+
+#========== Helper functions =========================#
+def set_seed(seed: int = 0):
+     # Python built-in RNG
+    random.seed(seed)
+    # NumPy RNG
+    np.random.seed(seed)
+    # PyTorch CPU RNG
+    torch.manual_seed(seed)
+    # PyTorch CUDA RNG (all GPUs)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    
+def evaluate_with_lof(X, y, num_outliers):
+    contamination = num_outliers / len(y)
+    lof = LocalOutlierFactor(n_neighbors=20, contamination=contamination)
+    _ = lof.fit_predict(X)
+    scores = -lof.negative_outlier_factor_
+    return roc_auc_score(y, scores)
+
+
+def run_generation(
+    model_builder,
+    save_path_builder,
+    accept_auc,
+    base_seed,
+    dimension_range,
+    samples_per_dim_range=32,
+    device='cuda:0',
+):
+    for j, dimension in tqdm(enumerate(dimension_range)):
+        count = 0
+        i = 0
+        begin_idx = j * samples_per_dim_range
+
+        while count < samples_per_dim_range:
+            set_seed(base_seed + i)
+            dim = np.random.randint(low=dimension[0], high=dimension[1])
+
+            num_inliers = np.random.randint(1_000, 5_000)
+            outliers_ratio = np.random.uniform(0.05, 0.15)
+            num_outliers = int(outliers_ratio * num_inliers)
+
+            model = model_builder(dim=dim, device=device)
+            X_in, X_out = model.draw_batched_data(num_inliers, num_outliers)
+
+            X = torch.cat([X_in, X_out]).cpu().numpy()
+            y = np.concatenate([np.zeros(num_inliers), np.ones(num_outliers)])
+
+            auc = evaluate_with_lof(X, y, num_outliers)
+            if accept_auc(auc):
+                saved = begin_idx + count
+                output_path = save_path_builder(saved)
+                os.makedirs(os.path.dirname(output_path), exist_ok=True)
+                np.savez(output_path, X=X, y=y)
+                count += 1
+            i += 1
+
+        print(
+            f"For dimension [{dimension[0]}, {dimension[1]}), accepted ratio:",
+            (count / i),
+        )
+
+
+def build_gmm_model(dim, device):
+    num_cluster = np.random.randint(low=2, high=6)
+    max_mean = np.random.randint(low=2, high=6)
+    max_var = np.random.randint(low=2, high=6)
+    return make_NdMclusterGMM(
+        dim=dim,
+        num_cluster=num_cluster,
+        weights=torch.tensor([1 / num_cluster] * num_cluster, device=device),
+        max_mean=max_mean,
+        max_var=max_var,
+        inflate_full=False,
+        sub_dims=None,
+        percentile=0.9,
+        delta=0.05,
+        device=device,
+    )
+
+
+def build_copula_model(dim, device):
+    return CopulaGenerator(num_dims=dim, device=device)
+
+
+def build_scm_model(dim, device):
+    max_num_layer = 5
+    min_num_layer = max(int(np.sqrt(dim)) - 3, 2)
+    min_hidden_size = max(int(math.floor(dim / min_num_layer)) + 2, 2)
+    max_hidden_size = min(min_hidden_size + 7, 40)
+    return make_structuralSCM(
+        max_feature_dim=dim,
+        min_num_layer=min_num_layer,
+        max_num_layer=max_num_layer,
+        min_hidden_size=min_hidden_size,
+        max_hidden_size=max_hidden_size,
+        alpha=1.5,
+        beta=4.0,
+        device=device,
+    )
+
+
+if __name__ == '__main__':
+    dimension_range = [(2, 21), (21, 41), (41, 61), (61, 81), (81, 101)]
+
+    print('generate GMM based')
+    run_generation(
+        model_builder=build_gmm_model,
+        save_path_builder=lambda saved: f"gaussian/gaussian_{saved}.npz",
+        accept_auc=lambda auc: auc < 0.95,
+        base_seed=52324,
+        dimension_range=dimension_range,
+    )
+
+    print('generate copula based')
+    run_generation(
+        model_builder=build_copula_model,
+        save_path_builder=lambda saved: f"copula_disturb/copuladisturb_{saved}.npz",
+        accept_auc=lambda auc: 0.5 < auc < 0.95,
+        base_seed=52324,
+        dimension_range=dimension_range,
+    )
+
+    print('generate scm based')
+    run_generation(
+        model_builder=build_scm_model,
+        save_path_builder=lambda saved: f"scm_contextual/scmcontextual_{saved}.npz",
+        accept_auc=lambda auc: 0.5 < auc < 0.95,
+        base_seed=52324,
+        dimension_range=dimension_range,
+    )

synbench/gmm.py

@@ -0,0 +1,421 @@
+import numpy as np
+import torch
+from torch.distributions.multivariate_normal import MultivariateNormal
+from scipy.stats import chi2
+import time
+
+
+class GaussianMixtureModel:
+    def __init__(self, 
+                 means: torch.Tensor, 
+                 covariances: torch.Tensor, 
+                 weights: torch.Tensor,
+                 percentile=0.80, 
+                 delta=0.05, 
+                 inflate_scale=5.0, 
+                 inflate_full=False,
+                 sub_dims=None, 
+                 device='cpu'):
+        """
+        Initialize a Gaussian Mixture Model and a corresponding inflated GMM.
+
+        The normal GMM is used to draw inlier samples. The inflated GMM is
+        created by enlarging the covariance values on a selected subset of
+        dimensions, which makes it easier to sample local anomalies.
+
+        Args:
+            means: Tensor of shape ``(num_cluster, d)`` containing one mean
+                vector per Gaussian component.
+            covariances: Tensor of shape ``(num_cluster, d, d)`` containing one
+                covariance matrix per Gaussian component.
+            weights: Tensor of shape ``(num_cluster,)`` containing mixture
+                probabilities. These are used by ``torch.multinomial`` when
+                choosing which component to sample from.
+            percentile: Base chi-square percentile used to define inlier and
+                anomaly thresholds in the selected subspace.
+            delta: Margin around ``percentile``. Inliers are below
+                ``percentile - delta``; local anomalies are above
+                ``percentile + delta``.
+            inflate_scale: Multiplicative factor applied to selected covariance
+                entries when constructing the inflated GMM.
+            inflate_full: If True, inflate all dimensions. If False, randomly
+                choose a non-empty subset of dimensions to inflate.
+            sub_dims: Optional user-provided dimensions to inflate and use for
+                Mahalanobis-distance filtering.
+            device: Device on which tensors are stored.
+        """
+        self.device = device
+        self.means = means
+        self.covariances = covariances
+        self.weights = weights
+
+        self.num_cluster = len(means)
+        d = self.means[0].shape[0]
+        self.d = d
+        n = d if inflate_full else np.random.randint(1, d + 1)  # Generate random integer between 1 and d, inclusive
+        if inflate_full and sub_dims is not None:
+            print('we are inflating all the dimensions, however, sub_dims is provided')
+            raise Exception
+        self.sub_dims = torch.sort(torch.randperm(d)[:n]).values.to(self.device) if sub_dims is None else sub_dims.to(
+            self.device)
+
+        self.threshold_plus_delta = chi2.ppf(percentile + delta, df=len(self.sub_dims))
+        self.threshold_minus_delta = chi2.ppf(percentile - delta, df=len(self.sub_dims))
+
+        self.inflated_covariances = []
+        self.inv_sub_covariances = []
+
+        for cov in self.covariances:
+            cov_copy = cov.clone()
+            sub_cov = cov_copy[self.sub_dims, :][:, self.sub_dims]  # the sub_cov defines a new (smaller) Gaussian
+            # n x n ---> sub_dims x n ---> sub_dims x sub_dims
+            self.inv_sub_covariances.append(torch.linalg.inv(sub_cov))
+            cov_copy[self.sub_dims[:, None], self.sub_dims] *= inflate_scale
+            self.inflated_covariances.append(cov_copy)
+
+        self.inflated_covariances = torch.stack(self.inflated_covariances)
+        self.inv_sub_covariances = torch.stack(self.inv_sub_covariances)
+
+        self.GMM4sample = [MultivariateNormal(self.means[cluster_id], self.covariances[cluster_id])
+                           for cluster_id in range(len(self.weights))]
+
+        self.GMM4inf = [MultivariateNormal(self.means[cluster_id], self.inflated_covariances[cluster_id])
+                        for cluster_id in range(len(self.weights))]
+
+
+    def draw_samples(self, num_samples):
+        """
+        Draws samples from the d-dimensional Gaussian Mixture Model.
+        Args:
+            num_samples (int): Number of samples to draw.
+        Returns:
+        torch.Tensor: samples drawn from the GMM.
+        """
+        samples = torch.zeros(num_samples, self.d, device=self.device)
+        component_choices = torch.multinomial(self.weights, num_samples, replacement=True)
+        for cluster_id in range(self.num_cluster):
+            mask = (component_choices == cluster_id)
+            num_cluster_samples = mask.sum().item()
+            if num_cluster_samples > 0:
+                sample = self.GMM4sample[cluster_id].sample((num_cluster_samples,))
+                samples[mask] = sample
+        return samples
+
+
+    def draw_inflated_samples(self, num_samples):
+        """
+        Draws samples from the d-dimensional inflated Gaussian Mixture Model.
+        Args:
+            num_samples (int): Number of samples to draw.
+        Returns:
+        torch.Tensor: samples drawn from the inflated GMM.
+        """
+        samples = torch.zeros(num_samples, self.d, device=self.device)
+        component_choices = torch.multinomial(self.weights, num_samples, replacement=True)
+
+        for cluster_id in range(self.num_cluster):
+            mask = (component_choices == cluster_id)
+            num_cluster_samples = mask.sum().item()
+            if num_cluster_samples > 0:
+                sample = self.GMM4inf[cluster_id].sample((num_cluster_samples,))  # .type_as(self.weights)
+                samples[mask] = sample
+        return samples
+
+
+    def mahalanobis_distance(self, sample, mean, inv_covariance):
+        """
+        Computes the Mahalanobis distance of a sample from a given mean and inverse covariance matrix.
+        Args:
+            sample (torch.Tensor): Sample point. (d, )
+            mean (torch.Tensor): Mean vector.  (d, )
+            inv_covariance (torch.Tensor): Inverse covariance matrix.  (sub-dims, )
+        Returns:
+        float: Mahalanobis distance of the sample from the mean.
+        """
+        delta = sample[self.sub_dims] - mean[self.sub_dims]
+        return torch.sqrt((delta @ inv_covariance @ delta).sum())
+
+
+    def batched_squared_mahalanobis_distance(self, X, mean, inv_cov):
+        # Select only the dimensions used for local anomaly detection,
+        # then subtract the corresponding mean values.
+        # X[:, self.sub_dims]: shape (num_samples, num_selected_dims)
+        # mean[self.sub_dims]: shape (num_selected_dims,)
+        delta = X[:, self.sub_dims] - mean[self.sub_dims]
+
+        # Compute squared Mahalanobis distance for each sample:
+        # distance_i = delta_i^T @ inv_cov @ delta_i
+        # delta @ inv_cov @ delta.T gives a matrix of pairwise quadratic forms
+        # between all samples. The diagonal contains each sample's own
+        # squared Mahalanobis distance.
+        return torch.diag(delta @ inv_cov @ delta.T)
+
+
+    def draw_inliers(self, num_samples):
+        """
+        Draw inlier samples from the original GMM using rejection sampling.
+        A sample is accepted as an inlier if its minimum squared Mahalanobis
+        distance to any Gaussian component, computed only on self.sub_dims,
+        is below self.threshold_minus_delta.
+        Args:
+            num_samples: Number of inlier samples to return.
+        Returns:
+            Tensor of shape (num_samples, self.d) containing accepted inlier samples.
+        """
+
+        # Draw more candidates than needed, because some samples will be rejected.
+        # Use at least 1000 candidates per loop to avoid very small inefficient batches.
+        batch_size = max(num_samples * 2, 1000)
+        samples = []
+        total_samples_needed = num_samples
+        while total_samples_needed > 0:
+            raw_samples = self.draw_samples(batch_size)
+            batch_distances = self.get_squared_batched_dist(raw_samples)
+            min_squared_distances = torch.min(batch_distances, dim=1).values
+            inliner_mask = min_squared_distances < self.threshold_minus_delta
+            selected_samples = raw_samples[inliner_mask]
+            num_selected = selected_samples.shape[0]
+            if num_selected > 0:
+                if num_selected >= total_samples_needed:
+                    samples.append(selected_samples[:total_samples_needed])
+                    total_samples_needed = 0
+                else:
+                    samples.append(selected_samples)
+                    total_samples_needed -= num_selected
+        samples = torch.cat(samples)
+        return samples
+
+
+    def draw_local_anomalies(self, num_samples):
+        """
+        Draw local anomaly samples from the inflated GMM using rejection sampling.
+
+        A sample is accepted as a local anomaly if its minimum squared Mahalanobis
+        distance to any original Gaussian component, computed only on self.sub_dims,
+        is above self.threshold_plus_delta.
+
+        Args:
+            num_samples: Number of local anomaly samples to return.
+
+        Returns:
+            Tensor of shape (num_samples, self.d) containing accepted local anomaly samples.
+        """
+        batch_size = max(num_samples * 2, 1000)
+        samples = []
+        total_samples_needed = num_samples
+        while total_samples_needed > 0:
+            raw_samples = self.draw_inflated_samples(batch_size)
+            batch_distances = self.get_squared_batched_dist(raw_samples)
+            min_squared_distances = torch.min(batch_distances, dim=1).values
+            anomaly_mask = min_squared_distances > self.threshold_plus_delta
+            selected_samples = raw_samples[anomaly_mask]
+            num_selected = selected_samples.shape[0]
+            if num_selected > 0:
+                if num_selected >= total_samples_needed:
+                    samples.append(selected_samples[:total_samples_needed])
+                    total_samples_needed = 0
+                else:
+                    samples.append(selected_samples)
+                    total_samples_needed -= num_selected
+        samples = torch.cat(samples)
+        return samples
+
+
+    def assert_inliers(self, samples):
+        """
+        Verify that all given samples satisfy the inlier criterion.
+        A sample is considered an inlier if its minimum squared Mahalanobis
+        distance to any Gaussian component, computed on self.sub_dims, is below
+        self.threshold_minus_delta.
+        Args:
+            samples: Tensor of shape (num_samples, self.d) containing samples
+                to check.
+        Raises:
+            AssertionError: If any sample does not satisfy the inlier condition.
+        """
+        for sample in samples:
+            distances = [self.mahalanobis_distance(sample, mean, inv_cov) for mean, inv_cov in
+                         zip(self.means, self.inv_sub_covariances)]
+            assert min(distances) ** 2 < self.threshold_minus_delta
+
+
+    def assert_local_anomalies(self, samples):
+        """
+        Verify that all given samples satisfy the local anomaly criterion.
+        A sample is considered a local anomaly if its minimum squared Mahalanobis
+        distance to any Gaussian component, computed on self.sub_dims, is above
+        self.threshold_plus_delta.
+        Args:
+            samples: Tensor of shape (num_samples, self.d) containing samples
+                to check.
+        Raises:
+            AssertionError: If any sample does not satisfy the local anomaly condition.
+        """
+        for sample in samples:
+            distances = [self.mahalanobis_distance(sample, mean, inv_cov) for mean, inv_cov in
+                         zip(self.means, self.inv_sub_covariances)]
+            assert min(distances) ** 2 > self.threshold_plus_delta
+
+
+    def get_squared_batched_dist(self, raw_samples):
+        """
+        Compute squared Mahalanobis distances from samples to all GMM components.
+        For each sample, this computes its squared Mahalanobis distance to each
+        Gaussian component using only self.sub_dims.
+        Args:
+            raw_samples: Tensor of shape (num_samples, self.d) containing samples
+                to evaluate.
+        Returns:
+            Tensor of shape (num_samples, num_cluster), where entry (i, j) is the
+            squared Mahalanobis distance from sample i to component j.
+        """
+        batch_dist = []
+        for mean, inv_cov in zip(self.means, self.inv_sub_covariances):
+            distances = self.batched_squared_mahalanobis_distance(X=raw_samples, mean=mean, inv_cov=inv_cov)
+            batch_dist.append(distances)
+        return torch.stack(batch_dist, dim=1)  # (#samples, num_cluster)
+
+
+    def draw_batched_data(self, num_inliers, num_local_anomalies):
+        """
+        Draw a batch containing both inliers and local anomalies.
+
+        This method first oversamples candidate inliers from the original GMM and
+        candidate anomalies from the inflated GMM. It then filters them using
+        Mahalanobis-distance thresholds. If not enough valid samples are found,
+        it calls draw_inliers or draw_local_anomalies to fill the missing amount.
+
+        Args:
+            num_inliers: Number of accepted inlier samples to return.
+            num_local_anomalies: Number of accepted local anomaly samples to return.
+
+        Returns:
+            A tuple:
+                inliers: Tensor of shape (num_inliers, self.d)
+                local_anomalies: Tensor of shape (num_local_anomalies, self.d)
+        """
+        raw_inliers = self.draw_samples(num_samples=int(num_inliers * 2))
+        raw_local_anomalies = self.draw_inflated_samples(num_samples=int(num_local_anomalies * 2))
+
+        inliers_squared_dist = self.get_squared_batched_dist(raw_samples=raw_inliers)
+        local_anomalies_squared_dist = self.get_squared_batched_dist(raw_samples=raw_local_anomalies)
+
+        min_inliers_squared_dist = torch.min(inliers_squared_dist, dim=1).values
+        min_local_anomalies_squared_dist = torch.min(local_anomalies_squared_dist, dim=1).values
+
+        inliers_mask = min_inliers_squared_dist < self.threshold_minus_delta  # (#raw-inliers, )
+        local_anomalies_mask = min_local_anomalies_squared_dist > self.threshold_plus_delta  # (#raw-la, )
+
+        inliers = raw_inliers[inliers_mask][:num_inliers]
+        local_anomalies = raw_local_anomalies[local_anomalies_mask][:num_local_anomalies]
+
+        def add_extra(existing_samples, target_num_samples, draw_func):
+            if existing_samples.shape[0] < target_num_samples:
+                extra_samples = draw_func(num_samples=target_num_samples - existing_samples.shape[0])
+                existing_samples = torch.concat([existing_samples, extra_samples], dim=0)
+            return existing_samples
+
+        inliers = add_extra(existing_samples=inliers, target_num_samples=num_inliers, draw_func=self.draw_inliers)
+        local_anomalies = add_extra(existing_samples=local_anomalies, target_num_samples=num_local_anomalies,
+                                    draw_func=self.draw_local_anomalies)
+        return inliers, local_anomalies
+
+
+
+def make_NdMclusterGMM(dim: int, num_cluster: int, weights: torch.Tensor, max_mean: int, max_var: int,
+                       inflate_full: bool, device, sub_dims=None, percentile=0.80, delta=0.05):
+    # Generate means between -max_mean and max_mean
+    means = torch.rand(num_cluster, dim, device=device) * \
+            torch.randint(low=-max_mean, high=max_mean+1, size=(num_cluster, dim, ), device=device)
+
+    # Generate diagonal covariance matrices with positive entries between 1 and max_var
+    diag_values = torch.rand(num_cluster, dim, device=device) * \
+                  torch.randint(low=1, high=max_var+1, size=(num_cluster, dim, ), device=device)
+    diag_values[diag_values == 0] = max_var / 2
+
+    # Create batch of diagonal covariance matrices
+    covariances = torch.diag_embed(diag_values)  # Shape: (num_cluster, dim, dim)
+
+    N_d_M_cluster_gaussian = GaussianMixtureModel(
+        means=means,
+        covariances=covariances,
+        weights=weights,
+        inflate_full=inflate_full,
+        sub_dims=sub_dims,
+        percentile=percentile,
+        delta=delta,
+        device=device
+    )
+    return N_d_M_cluster_gaussian
+
+
+#================= Helper functions ===================#
+def generate_constrained_eigenvals(d):
+    # Generate uniformly distributed values in the range (-0.8, -0.2)
+    low_range = np.random.uniform(-1.0, -0.1, size=d)
+
+    # Generate uniformly distributed values in the range (0.2, 0.8)
+    high_range = np.random.uniform(0.1, 1.0, size=d)
+
+    # Randomly choose between the two ranges for each element
+    choice = np.random.choice([0, 1], size=d)
+    vector = np.where(choice == 0, low_range, high_range)
+
+    return vector
+
+
+def generate_full_rank_matrix(dim, device, scale=1):
+    # Generate a random orthogonal matrix using QR decomposition
+    A = np.random.rand(dim, dim)
+    Q, _ = np.linalg.qr(A)
+
+    eigenvals = generate_constrained_eigenvals(d=dim)
+    eigenvals = np.diag(eigenvals)
+
+    full_rank_matrix = Q @ eigenvals @ Q.T
+    assert np.linalg.matrix_rank(full_rank_matrix) == dim
+    if device is None:  # source is numpy
+        return full_rank_matrix
+    else:
+        return torch.from_numpy(full_rank_matrix).to(dtype=torch.float, device=device)
+
+
+def generate_linear_transform(dim, device, A_scale=1, b_scale=1):
+    A = generate_full_rank_matrix(dim=dim, device=device, scale=A_scale)
+    b = np.random.rand(dim) * np.random.randint(low=-b_scale, high=b_scale + 1, size=dim)  # [low, high)
+
+    if device is not None:  # source is torch, transfer from numpy to torch
+        b = torch.from_numpy(b).to(dtype=torch.float, device=device)
+    return A, b
+
+
+def transform_means(means, sub_dims, A, b):
+    trans = []
+    for mean in means:
+        new_mean = mean.clone()
+        new_mean[sub_dims] = A @ new_mean[sub_dims] + b
+        trans.append(new_mean)
+    return torch.stack(trans)
+
+
+def transform_covs(covs, sub_dims, A):
+    trans = []
+    for cov in covs:
+        new_cov = cov.clone()
+        new_cov[sub_dims[:, None], sub_dims] = A @ new_cov[sub_dims[:, None], sub_dims] @ A.T
+        trans.append(new_cov)
+    return torch.stack(trans)
+
+
+def transform_samples(samples, sub_dims, A, b, is_source_numpy=False):
+    if is_source_numpy:
+        new_samples = samples.copy()
+    else:
+        new_samples = samples.clone()
+
+    if sub_dims is None:
+        new_samples = new_samples @ A.T + b
+    else:
+        new_samples[:, sub_dims] = new_samples[:, sub_dims] @ A.T + b
+
+    return new_samples

synbench/scm.py

@@ -0,0 +1,702 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import time
+import math
+import random
+
+def lognormal_discrete(mu,
+                       sigma,
+                       minval: int,
+                       maxval: int):
+    """
+    Sample an integer from a log-normal distribution, clamped to [minval, maxval].
+
+    Args:
+        mu     : Mean of the underlying normal distribution.
+        sigma  : Standard deviation of the underlying normal distribution.
+        minval : Minimum integer value (inclusive).
+        maxval : Maximum integer value (inclusive).
+
+    Returns:
+        int: A rounded, clipped sample from the log-normal distribution.
+    """
+    val = int(np.round(np.random.lognormal(mu, sigma)))
+    return int(np.clip(val, minval, maxval))
+
+
+def sample_layers_and_nodes(min_num_layer =2,
+                            max_num_layer =5,
+                            min_hidden_size = 3,
+                            max_hidden_size = 8):
+    """
+    Randomly sample the number of hidden layers and the hidden-layer width.
+
+    Uses log-normal priors so moderate values are more likely than extremes.
+
+    Args:
+        min_num_layer   : Minimum number of hidden layers (default 2).
+        max_num_layer   : Maximum number of hidden layers (default 5).
+        min_hidden_size : Minimum number of nodes per hidden layer (default 3).
+        max_hidden_size : Maximum number of nodes per hidden layer (default 8).
+
+    Returns:
+        Tuple (l, h) where l is the number of layers and h is the hidden size.
+    """
+    l = lognormal_discrete(mu=0.7, sigma=0.4, minval=min_num_layer, maxval=max_num_layer)  # num layers
+    h = lognormal_discrete(mu=1.2, sigma=0.5, minval=min_hidden_size, maxval=max_hidden_size)  # hidden size
+    return l, h
+
+@torch.no_grad()
+def sample_noise_distribution(device='cpu'):
+    """
+    Create a random log-normal noise sampler with randomised parameters.
+
+    The log-normal parameters are drawn uniformly:
+      - mu    ~ Uniform(-0.5, 0.5)
+      - sigma ~ Uniform(0.05, 0.5)
+
+    The returned callable samples n independent log-normal values and exposes
+    its ``mu`` and ``sigma`` attributes for later inspection.
+
+    Args:
+        device : Torch device on which to allocate noise tensors (default 'cpu').
+
+    Returns:
+        Callable noise_func(n) -> Tensor of shape (n,) drawn from
+        LogNormal(mu, sigma).  The function has attributes ``mu`` and ``sigma``.
+    """
+    mu = (torch.rand(1, device=device) - 0.5).item()
+    sigma = (torch.rand(1, device=device) * (0.5 - 0.05) + 0.05).item()
+    def noise_func(n):
+        return torch.exp(mu + sigma * torch.randn(n, device=device))
+    noise_func.mu = mu
+    noise_func.sigma = sigma
+    return noise_func
+
+@torch.no_grad()
+def sample_activation(device='cpu'):
+    """
+    Uniformly sample one activation function from a fixed catalogue.
+
+    The catalogue contains: tanh, leaky ReLU (slope 0.01), ELU, and identity.
+
+    Args:
+        device : Torch device (unused at runtime but kept for API consistency).
+
+    Returns:
+        Tuple (name: str, fn: Callable) where fn maps a Tensor to a Tensor.
+    """
+    activations = [
+        ("tanh", torch.tanh),
+        ("leaky_relu", lambda x: torch.where(x > 0, x, 0.01 * x)),
+        ("elu", lambda x: torch.where(x > 0, x, torch.exp(x) - 1)),
+        ("identity", lambda x: x),
+    ]
+    idx = torch.randint(0, len(activations), (1,), device=device).item()
+    return activations[idx]
+
+
+@torch.no_grad()
+def random_noise_scales_per_sample(num_samples, layer_sizes, high_noise=5.0, high_noise_prob=0.2, device='cpu'):
+    """
+    Generate random noise scales for each sample and node, for each layer.
+    Returns: List of tensors, each shape (num_samples, layer_size)
+    """
+    noise_scales = [
+        torch.where(
+            torch.rand(num_samples, n, device=device) < high_noise_prob,
+            torch.full((num_samples, n), high_noise, device=device),
+            torch.ones(num_samples, n, device=device)
+        )
+        for n in layer_sizes
+    ]
+    return noise_scales
+
+
+@torch.no_grad()
+def create_weight_mask(
+    num_samples, layers, chosen_nodes, perturb_prob=0.5, device='cpu'
+):
+    """
+    Vectorized version: No per-sample loop.
+    For each sample and layer, ensures that at least one parent of a chosen node is perturbed.
+    """
+    masks = []
+    node_layer_size = layers[0].weight.shape[0]  # assumes all layers same size
+
+    for l, layer in enumerate(layers):
+        weight = layer.weight  # (out_features, in_features)
+        perturbable = (torch.abs(weight) > 0.5)  # (out, in)
+        mask = torch.ones(num_samples, *weight.shape, device=device)
+
+        perturb_mask = (torch.rand(num_samples, *weight.shape, device=device) < perturb_prob) & perturbable.unsqueeze(0)
+        flip_mask = torch.rand(num_samples, *weight.shape, device=device) < 0.5
+
+        mask[perturb_mask & flip_mask] = -1.0
+        mask[perturb_mask & (~flip_mask)] = 0.0
+
+        # Find chosen nodes for this layer (global to local index)
+        chosen_nodes_this_layer = [idx for idx in chosen_nodes if (idx // node_layer_size) == l]
+        if len(chosen_nodes_this_layer) == 0:
+            masks.append(mask)
+            continue
+
+        for cidx in chosen_nodes_this_layer:
+            node_idx = cidx % node_layer_size  # local node index for this layer
+
+            # For all samples: find if any parent is perturbed (and perturbable) for this node
+            perturbed = ((mask[:, node_idx, :] != 1.0) & perturbable[node_idx, :])  # (num_samples, in_features)
+            any_perturbed = perturbed.any(dim=1)  # (num_samples,)
+
+            need_perturb = (~any_perturbed)  # (num_samples,)
+            num_to_fix = need_perturb.sum().item()
+            if num_to_fix == 0:
+                continue
+
+            # For those samples, pick a random eligible parent and force a perturbation
+            eligible_parents = perturbable[node_idx, :].nonzero(as_tuple=True)[0]
+            if len(eligible_parents) == 0:
+                continue
+
+            # Pick a random parent for each sample needing fix
+            rand_idx = torch.randint(0, len(eligible_parents), (num_to_fix,), device=device)
+            parent_idx = eligible_parents[rand_idx]  # (num_to_fix,)
+            sample_idx = need_perturb.nonzero(as_tuple=True)[0]  # (num_to_fix,)
+
+            # Randomly decide flip or zero
+            random_flip = (torch.rand(num_to_fix, device=device) < 0.5)
+            mask[sample_idx, node_idx, parent_idx] = torch.where(random_flip, -1.0, 0.0)
+
+        masks.append(mask)
+    return masks
+
+
+
+class MaskedLinear(nn.Linear):
+    """
+    A linear layer whose effective weight matrix is element-wise multiplied by
+    a binary (or real-valued) mask, enabling sparse / structured connectivity.
+
+    Weights are initialised from N(0, 1).  The mask is a non-gradient parameter
+    that can be set randomly via ``set_random_mask`` or overridden per-sample
+    during the forward pass.
+    """
+
+    def __init__(self, in_features, out_features, min_abs=0.35, device='cpu'):
+        """
+        Initialise MaskedLinear with N(0, 1) weights and an all-ones mask.
+
+        Args:
+            in_features  : Size of each input sample.
+            out_features : Size of each output sample.
+            min_abs      : Unused minimum absolute weight threshold (reserved).
+            device       : Torch device for weight initialisation (default 'cpu').
+        """
+        super().__init__(in_features, out_features, False)
+        # Sample weights from N(0, 1)
+        with torch.no_grad():
+            w = torch.normal(mean=0., std=1., size=self.weight.shape, device=device)
+            # abs_w = torch.clamp(torch.abs(w), min=torch.tensor(min_abs,device=device))
+            # w_clipped = torch.sign(w) * abs_w
+            self.weight.copy_(w) #_clipped)
+        self.mask = nn.Parameter(torch.ones_like(self.weight), requires_grad=False)
+
+
+    def set_random_mask(self, keep_prob=0.7):
+        """
+        Randomly zero out a fraction of mask entries (Bernoulli dropout-style).
+
+        Args:
+            keep_prob : Probability of keeping each connection (default 0.7).
+                        Each mask entry is set to 1.0 with this probability and
+                        0.0 otherwise.
+        """
+        with torch.no_grad():
+            self.mask[:] = (torch.rand_like(self.mask) < keep_prob).float()
+
+    def forward(self, input, weight_mask=None):
+        """
+        Compute the masked linear transformation.
+
+        When ``weight_mask`` is None the layer behaves like a standard linear
+        layer with weights replaced by ``self.weight * self.mask``.
+        When ``weight_mask`` is provided (shape ``(batch, out, in)``), each
+        sample in the batch gets its own additional per-element weight scaling,
+        enabling sample-specific structural perturbations.
+
+        Args:
+            input       : Tensor of shape (batch, in_features).
+            weight_mask : Optional tensor of shape (batch, out_features, in_features)
+                          applied on top of the stored mask.  ``None`` means no
+                          per-sample mask is used.
+
+        Returns:
+            Tensor of shape (batch, out_features).
+        """
+        # input: (batch, in_features)
+        # self.weight: (out_features, in_features)
+        # weight_mask: (batch, out_features, in_features) or None
+        masked_weight = self.weight * self.mask
+        if weight_mask is None:
+            return nn.functional.linear(input, masked_weight, None)
+        # Use per-sample masked weights (batched matmul)
+        # weight_mask shape: (batch, out_features, in_features)
+        # input shape: (batch, in_features)
+        # Expand masked_weight for batch: (1, out_features, in_features)
+        batch = input.size(0)
+        masked_weight = masked_weight.unsqueeze(0)  # (1, out_features, in_features)
+        # Broadcast for batch
+        weight = masked_weight.expand(batch, -1, -1) * weight_mask  # (batch, out_features, in_features)
+        # Batched matmul: input (batch, in_features) × weight.transpose(-2, -1) (batch, in_features, out_features)
+        # Result: (batch, out_features)
+        out = torch.bmm(input.unsqueeze(1), weight.transpose(1,2)).squeeze(1)
+        return out
+
+
+
+
+class SCM_MLP(nn.Module):
+    """
+    A multi-layer perceptron used as the functional core of a Structural
+    Causal Model (SCM).
+
+    Each layer is a ``MaskedLinear`` unit followed by additive log-normal
+    noise and a randomly chosen activation function.  The forward pass
+    returns the concatenated hidden activations from all layers, providing a
+    rich feature space from which the SCM can select its observable nodes.
+    """
+
+    def __init__(self, hidden_dim, num_layers, activations, device='cuda'):
+        """
+        Initialise the SCM-MLP.
+
+        Args:
+            hidden_dim  : Width of every hidden layer (all layers share the same size).
+            num_layers  : Number of hidden layers.
+            activations : List of callables of length ``num_layers``, one activation
+                          function per layer.
+            device      : Torch device (default 'cuda').
+        """
+        super().__init__()
+        self.layers = nn.ModuleList()
+        for _ in range(num_layers):
+            self.layers.append(MaskedLinear(hidden_dim, hidden_dim,device=device))
+        assert len(activations) == len(self.layers)
+        self.activations = activations
+        
+        # Per-node noise distributions for each layer and neuron
+        self.noise_funcs = [
+            [sample_noise_distribution(device) for _ in range(hidden_dim)]  # per node
+            for _ in range(num_layers)
+        ]
+
+
+    def set_masks(self, keep_prob=0.7):
+        """
+        Apply random binary masks to all layers simultaneously.
+
+        Args:
+            keep_prob : Probability of retaining each weight connection
+                        (default 0.7).  Passed through to
+                        ``MaskedLinear.set_random_mask``.
+        """
+        for layer in self.layers:
+            layer.set_random_mask(keep_prob)
+            
+            
+    def forward(self, 
+                x):
+        """
+        Standard forward pass: apply each masked layer, add per-node log-normal
+        noise, apply the activation, and collect hidden activations.
+
+        Args:
+            x : Input tensor of shape (batch, hidden_dim).
+
+        Returns:
+            Tensor of shape (batch, hidden_dim * num_layers) formed by
+            concatenating the post-activation outputs of all layers.
+        """
+        activations = []
+        out = x
+        batch_size = x.shape[0]
+        for idx, layer in enumerate(self.layers):
+            out = layer(out)
+            # Generate per-node noise for the whole batch
+            noises = torch.stack([
+                self.noise_funcs[idx][j](batch_size)  # shape (batch,)
+                for j in range(out.shape[1])
+            ], dim=1)  # shape (batch, nodes)
+            out = out + noises
+            out = self.activations[idx](out)
+            activations.append(out)
+        return torch.cat(activations, dim=1)
+
+
+    def forward_with_weight_masks(self,
+                                x,
+                                noise_std=0.1, 
+                                weight_masks=None):
+        """
+        Forward pass with optional per-sample weight masks.
+
+        Applies a distinct weight mask to each sample in the batch, enabling
+        sample-specific structural perturbations used when generating structural
+        outliers.
+
+        Args:
+            x            : Input tensor of shape (batch, in_features).
+            noise_std    : Unused noise standard deviation (reserved for future use).
+            weight_masks : List of tensors, one per layer, each of shape
+                           (batch, out_features, in_features), or ``None`` for
+                           no per-sample masking.
+
+        Returns:
+            Tensor of shape (batch, hidden_dim * num_layers) formed by
+            concatenating the post-activation outputs of all layers.
+        """
+        activations = []
+        out = x
+        batch_size = x.shape[0]
+        for idx, layer in enumerate(self.layers):
+            mask = weight_masks[idx] if weight_masks is not None else None
+            out = layer(out, weight_mask=mask) if mask is not None else layer(out)
+            # Generate per-node noise for the whole batch
+            noises = torch.stack([
+                self.noise_funcs[idx][j](batch_size)  # shape (batch,)
+                for j in range(out.shape[1])
+            ], dim=1)  # shape (batch, nodes)
+            out = out + noises
+            out = self.activations[idx](out)
+            activations.append(out)
+        return torch.cat(activations, dim=1)
+        
+    
+    
+    def forward_with_noise_scales(self,
+                                x,
+                                noise_scales=None,
+                                return_noises=False):
+        """
+        Forward pass with optional per-sample, per-node noise scaling.
+
+        Used during probabilistic outlier generation to amplify the log-normal
+        noise on selected nodes, pushing their activations to extreme values.
+
+        Args:
+            x            : Input tensor of shape (batch, hidden_dim).
+            noise_scales : List of tensors, one per layer, each of shape
+                           (batch, layer_size) containing multiplicative noise
+                           scale factors.  ``None`` defaults to all-ones (no scaling).
+            return_noises: If ``True``, also return the raw noise tensors and the
+                           applied scale tensors (useful for filtering valid outliers).
+
+        Returns:
+            If ``return_noises`` is ``False``:
+                Tensor of shape (batch, hidden_dim * num_layers).
+            If ``return_noises`` is ``True``:
+                Tuple (activations, all_noises, all_scales) where ``all_noises``
+                and ``all_scales`` are lists of per-layer tensors.
+        """
+        activations = []
+        out = x
+        batch_size = x.shape[0]
+        all_noises = []
+        all_scales = []
+        for idx, layer in enumerate(self.layers):
+            out = layer(out)
+            noises = torch.stack([
+                self.noise_funcs[idx][j](batch_size)
+                for j in range(out.shape[1])
+            ], dim=1)  # (batch, nodes)
+            scales = noise_scales[idx] if noise_scales is not None else torch.ones_like(noises)
+            noises = noises * scales
+            out = out + noises
+            out = self.activations[idx](out)
+            activations.append(out)
+            if return_noises:
+                all_noises.append(noises)
+                all_scales.append(scales)
+        if return_noises:
+            return torch.cat(activations, dim=1), all_noises, all_scales
+        else:
+            return torch.cat(activations, dim=1)
+
+    
+class StructuralCausalModel:
+    """
+    A randomly instantiated Structural Causal Model (SCM) for generating
+    synthetic anomaly-detection datasets.
+
+    An MLP with masked layers and per-node log-normal noise serves as the
+    causal mechanism.  A random subset of the hidden nodes is exposed as the
+    observable feature vector.  Inliers are sampled directly from the model;
+    outliers are produced either by amplifying noise (``'prob'``) or by
+    perturbing the causal weights (``'structural'``).
+    """
+
+    def __init__(self,
+                 num_features: int = 3,
+                 min_num_layer: int = 3,
+                 max_num_layer: int = 5,
+                 min_hidden_size: int = 8,
+                 max_hidden_size: int = 8,
+                 device='cpu',
+                 outlier_type='structural',
+                 drop_weight_prob: float = 0.7,
+                 ):
+        """
+        Initialise the SCM by sampling a random MLP architecture.
+
+        The architecture is resampled until the total number of hidden nodes
+        (layers × width) is at least ``num_features``.  A random subset of
+        those nodes is then selected as the observable features.
+
+        Args:
+            num_features    : Number of observable output dimensions.
+            min_num_layer   : Minimum number of MLP hidden layers.
+            max_num_layer   : Maximum number of MLP hidden layers.
+            min_hidden_size : Minimum width of each hidden layer.
+            max_hidden_size : Maximum width of each hidden layer.
+            device          : Torch device (default 'cpu').
+            outlier_type    : Outlier strategy – ``'measurement'`` for noise-amplification
+                              outliers, ``'structural'`` for weight-perturbation
+                              outliers (default ``'structural'``).
+            drop_weight_prob: Probability of retaining each MLP weight connection
+                              (default 0.7).
+        """
+        self.device = device
+        self.l, self.h = sample_layers_and_nodes(min_num_layer,max_num_layer,min_hidden_size, max_hidden_size)
+        while self.l * self.h < num_features:
+            self.l, self.h = sample_layers_and_nodes(min_num_layer,max_num_layer,min_hidden_size, max_hidden_size)
+        self.activations = [sample_activation(device)[1] for _ in range(self.l)]
+        self.mlp = SCM_MLP(self.h, self.l, activations=self.activations, device=device)
+        self.mlp = self.mlp.to(device) 
+        self.mlp.set_masks(keep_prob=drop_weight_prob) 
+        self.num_features = num_features
+        self.chosen_nodes = np.random.choice(self.l * self.h, self.num_features, replace=False)
+        self.outlier_type = outlier_type
+
+    @torch.no_grad()
+    def sample_inliers(self, num_samples):
+        """
+        Sample inlier observations from the SCM.
+
+        Feeds a constant all-ones input through the MLP (noise is injected
+        inside the MLP), then returns the values at the pre-selected
+        observable nodes.
+
+        Args:
+            num_samples : Number of inlier observations to generate.
+
+        Returns:
+            Tensor of shape (num_samples, num_features).
+        """
+        # Constant input; randomness comes from per-node noise inside the MLP
+        x = torch.ones((num_samples, self.h), device=self.device)
+        acts = self.mlp(x)  # shape: (num_samples, total_nodes)
+        # Return only the selected nodes for each sample
+        return acts[:, self.chosen_nodes]
+
+    @torch.no_grad()
+    def sample_measurement_outliers(self, 
+                            num_samples, 
+                            high_noise=5.0, 
+                            high_noise_prob=0.2, 
+                            batch_factor=2):
+        """
+        Sample measurement outliers by amplifying per-node noise.
+
+        A random fraction of nodes receives a noise scale of ``high_noise``
+        instead of 1.0.  Samples where the amplified noise values actually
+        deviate significantly from the base distribution mean are kept;
+        the rest are rejected and new candidates are drawn (rejection sampling).
+
+        Args:
+            num_samples     : Number of valid outlier samples to collect.
+            high_noise      : Noise scale applied to the selected anomalous nodes
+                              (default 5.0).
+            high_noise_prob : Probability that any given node receives the high
+                              noise scale (default 0.2).
+            batch_factor    : Over-sampling factor to reduce rejection overhead
+                              (default 2).
+
+        Returns:
+            Tensor of shape (num_samples, num_features).
+        """
+        collected = []
+        while len(collected) < num_samples:
+            batch_size = max(int((num_samples - len(collected)) * batch_factor), 10000)
+            x = torch.ones((batch_size, self.h), device=self.device)
+            layer_sizes = [layer.out_features for layer in self.mlp.layers]
+            noise_scales = random_noise_scales_per_sample(
+                batch_size, layer_sizes, 
+                high_noise=high_noise, 
+                high_noise_prob=high_noise_prob, 
+                device=self.device
+            )
+            activations, all_noises, all_noise_scales = self.mlp.forward_with_noise_scales(
+                x, noise_scales=noise_scales, return_noises=True
+            )
+            batch_mask = torch.ones(batch_size, dtype=torch.bool, device=x.device)
+            for idx, (noises, scales) in enumerate(zip(all_noises, all_noise_scales)):
+                high_noise_mask = (scales == high_noise)
+                if high_noise_mask.any():
+                    # For each node in this layer, get its mean and std
+                    means = torch.tensor(
+                        [float(getattr(self.mlp.noise_funcs[idx][j], 'mu', 0.0)) for j in range(noises.shape[1])],
+                        device=x.device
+                    )
+                    stds = torch.tensor(
+                        [float(getattr(self.mlp.noise_funcs[idx][j], 'sigma', 1.0)) for j in range(noises.shape[1])],
+                        device=x.device
+                    )
+                    thresholds = means +  stds  # shape: (nodes,)
+                    # Broadcast to batch shape
+                    thresholds = thresholds.unsqueeze(0).expand_as(noises)
+                    means = means.unsqueeze(0).expand_as(noises)
+                    # Check (for high noise) if |noise - mean| >= threshold
+                    valid = ((noises - means).abs() >= thresholds) | (~high_noise_mask)
+                    valid = valid.all(dim=1)
+                    batch_mask &= valid
+            valid_idx = batch_mask.nonzero(as_tuple=True)[0]
+            if len(valid_idx) > 0:
+                acts_valid = activations[valid_idx][:, self.chosen_nodes]
+                collected.append(acts_valid)
+            total = sum(x.shape[0] for x in collected)
+            if total >= num_samples:
+                collected = torch.cat(collected)[:num_samples]
+                break
+        return collected
+
+    
+    
+    @torch.no_grad()
+    def sample_structural_outliers(self, num_samples, perturb_prob=0.2):
+        """
+        Sample structural outliers by perturbing MLP weight connections.
+
+        For each sample, a random subset of the causal weights feeding into the
+        observable nodes is flipped or zeroed, producing activations that are
+        statistically unusual in the context of the inlier distribution.
+
+        Args:
+            num_samples  : Number of structural outlier observations to generate.
+            perturb_prob : Probability of perturbing each eligible weight
+                           connection (default 0.2).
+
+        Returns:
+            Tensor of shape (num_samples, num_features).
+        """
+        x = torch.ones((num_samples, self.h), device=self.device)
+        weight_masks = create_weight_mask(
+            num_samples, self.mlp.layers, chosen_nodes = self.chosen_nodes, perturb_prob=perturb_prob, device=self.device
+        )
+        #print('draw weights', time.time()-start)
+        acts = self.mlp.forward_with_weight_masks(x, weight_masks=weight_masks)
+        return acts[:, self.chosen_nodes]
+
+
+    @torch.no_grad()
+    def draw_batched_data(self, 
+                          num_inliers, 
+                          num_local_anomalies):
+        """
+        Generate a labelled dataset of inliers and outliers.
+
+        Delegates to ``sample_inliers`` and either ``sample_measurement_outliers`` or
+        ``sample_structural_outliers`` depending on ``self.outlier_type``.
+
+        Args:
+            num_inliers        : Number of normal observations.
+            num_local_anomalies: Number of anomalous observations.
+
+        Returns:
+            Tuple ``(raw_inliers, raw_local_anomalies)`` where each element is a
+            Tensor of shape (n, num_features).
+        """
+        raw_inliers = self.sample_inliers(num_inliers)
+        if self.outlier_type == 'measurement':
+            raw_local_anomalies = self.sample_measurement_outliers(num_samples=num_local_anomalies)
+        elif self.outlier_type == 'structural':
+            raw_local_anomalies = self.sample_structural_outliers(num_samples=num_local_anomalies)
+        return raw_inliers, raw_local_anomalies
+    
+    
+    
+def make_measurementSCM(max_feature_dim: int,
+                 min_num_layer: int,
+                 max_num_layer: int,
+                 min_hidden_size: int,
+                 max_hidden_size: int,
+                 alpha: float,
+                 beta: float,
+                 device):
+    """
+    Factory function for a measurement-outlier SCM.
+
+    Constructs a ``StructuralCausalModel`` configured to generate outliers via
+    noise amplification (``outlier_type='measurement'``) with a fixed weight-keep
+    probability of 0.6.
+
+    Args:
+        max_feature_dim : Number of observable feature dimensions.
+        min_num_layer   : Minimum number of MLP hidden layers.
+        max_num_layer   : Maximum number of MLP hidden layers.
+        min_hidden_size : Minimum hidden-layer width.
+        max_hidden_size : Maximum hidden-layer width.
+        alpha           : Unused (reserved for future parameterisation).
+        beta            : Unused (reserved for future parameterisation).
+        device          : Torch device string.
+
+    Returns:
+        A freshly initialised ``StructuralCausalModel`` instance.
+    """
+    return StructuralCausalModel(num_features = max_feature_dim,
+                                 min_num_layer=min_num_layer,
+                                 max_num_layer = max_num_layer,
+                                 min_hidden_size = min_hidden_size,
+                                 max_hidden_size = max_hidden_size,
+                                 device = device,
+                                 outlier_type = 'measurement',
+                                 drop_weight_prob = 0.6)
+
+
+def make_structuralSCM(max_feature_dim: int,
+                 min_num_layer: int,
+                 max_num_layer: int,
+                 min_hidden_size: int,
+                 max_hidden_size: int,
+                 alpha: float,
+                 beta: float,
+                 device):
+    """
+    Factory function for a structural-outlier SCM.
+
+    Constructs a ``StructuralCausalModel`` configured to generate outliers via
+    causal weight perturbation (``outlier_type='structural'``) with a fixed
+    weight-keep probability of 0.6.
+
+    Args:
+        max_feature_dim : Number of observable feature dimensions.
+        min_num_layer   : Minimum number of MLP hidden layers.
+        max_num_layer   : Maximum number of MLP hidden layers.
+        min_hidden_size : Minimum hidden-layer width.
+        max_hidden_size : Maximum hidden-layer width.
+        alpha           : Unused (reserved for future parameterisation).
+        beta            : Unused (reserved for future parameterisation).
+        device          : Torch device string.
+
+    Returns:
+        A freshly initialised ``StructuralCausalModel`` instance.
+    """
+    return StructuralCausalModel(num_features = max_feature_dim,
+                                 min_num_layer=min_num_layer,
+                                 max_num_layer = max_num_layer,
+                                 min_hidden_size = min_hidden_size,
+                                 max_hidden_size = max_hidden_size,
+                                 device = device,
+                                 outlier_type = 'structural',
+                                 drop_weight_prob = 0.6)
+