def partialset(t, order=1, mask=None, bounds=None): """ Given a tensor, compute another one that contains all partial derivatives of certain order(s) and according to some optional mask. :Examples: >>> t = tn.rand([10, 10, 10]) # A 3D tensor >>> x, y, z = tn.symbols(3) >>> partialset(t, 1, x) # x >>> partialset(t, 2, x) # xx, xy, xz >>> partialset(t, 2, tn.only(y | z)) # yy, yz, zz :param t: a :class:`Tensor` :param order: an int or list of ints. Default is 1 :param mask: an optional mask to select only a subset of partials :param bounds: a list of pairs [lower bound, upper bound] specifying parameter ranges (used to compute derivative steps). If None (default), all steps will be 1 :return: a :class:`Tensor` """ if bounds is None: bounds = [[0, sh - 1] for sh in t.shape] if not hasattr(order, '__len__'): order = [order] max_order = max(order) def diff(core, n): if core.dim() == 3: pad = torch.zeros(core.shape[0], 1, core.shape[2]) else: pad = torch.zeros(1, core.shape[1]) if core.shape[1] == 1: return pad step = (bounds[n][1] - bounds[n][0]) / (core.shape[-2] - 1) return torch.cat(((core[..., 1:, :] - core[..., :-1, :]) / step, pad), dim=-2) cores = [] idxs = [] for n in range(t.dim()): if t.Us[n] is None: stack = [t.cores[n]] else: stack = [torch.einsum('ijk,aj->iak', (t.cores[n], t.Us[n]))] idx = torch.zeros([t.shape[n]]) for o in range(1, max_order + 1): stack.append(diff(stack[-1], n)) idx = torch.cat((idx, torch.ones(stack[-1].shape[-2]) * o)) if o == max_order: break cores.append(torch.cat(stack, dim=-2)) idxs.append(idx) d = tn.Tensor(cores, idxs=idxs) wm = tn.automata.weight_mask(t.dim(), order, nsymbols=max_order + 1) if mask is not None: wm = tn.mask(wm, mask) result = tn.mask(d, wm) result.idxs = idxs return result
def truncate_anova(t, mask, keepdim=False, marginals=None): """ Given a tensor and a mask, return the function that results after deleting all ANOVA terms that do not satisfy the mask. :Example: >>> t = ... # an ND tensor >>> x = tn.symbols(t.dim())[0] >>> t2 = tn.truncate_anova(t, mask=tn.only(x), keepdim=False) # This tensor will depend on one variable only :param t: :param mask: :param keepdim: if True, all dummy dimensions will be preserved, otherwise they will disappear. Default is False :param marginals: see :func:`anova_decomposition()` :return: a :class:`Tensor` """ t = tn.undo_anova_decomposition(tn.mask(tn.anova_decomposition(t, marginals=marginals), mask=mask)) if not keepdim: N = t.dim() affecting = torch.sum(torch.tensor(tn.accepted_inputs(mask).double()), dim=0) slices = [0 for n in range(N)] for i in np.where(affecting)[0]: slices[int(i)] = slice(None) t = t[slices] return t
def mean_dimension(t, mask=None, marginals=None): """ Computes the mean dimension of a given tensor with given marginal distributions. This quantity measures how well the represented function can be expressed as a sum of low-parametric functions. For example, mean dimension 1 (the lowest possible value) means that it is a purely additive function: :math:`f(x_1, ..., x_N) = f_1(x_1) + ... + f_N(x_N)`. Assumption: the input variables :math:`x_n` are independently distributed. References: - R. E. Caflisch, W. J. Morokoff, and A. B. Owen: `"Valuation of Mortgage Backed Securities Using Brownian Bridges to Reduce Effective Dimension" (1997) <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.36.3160>`_ - R. Ballester-Ripoll, E. G. Paredes, and R. Pajarola: `"Tensor Algorithms for Advanced Sensitivity Metrics" (2017) <https://epubs.siam.org/doi/10.1137/17M1160252>`_ :param t: an N-dimensional :class:`Tensor` :param marginals: a list of N vectors (will be normalized if not summing to 1). If None (default), uniform distributions are assumed for all variables :return: a scalar >= 1 """ if mask is None: return tn.sobol(t, tn.weight(t.dim()), marginals=marginals) else: return tn.sobol( t, tn.mask(tn.weight(t.dim()), mask), marginals=marginals) / tn.sobol(t, mask, marginals=marginals)
def only(t): """ Forces all irrelevant symbols to be zero. :Example: >>> x, y = tn.symbols(2) >>> tn.sum(x) # Result: 2 (x = True, y = False, and x = True, y = True) >>> tn.sum(tn.only(x)) # Result: 1 (x = True, y = False) :param: a :math:`2^N` :class:`Tensor` :return: a masked :class:`Tensor` """ return tn.mask(t, absence(t.dim(), irrelevant_symbols(t)))
def sobol(t, mask, marginals=None, normalize=True): """ Compute Sobol indices (as given by a certain mask) for a tensor and independently distributed input variables. Reference: R. Ballester-Ripoll, E. G. Paredes, and R. Pajarola: `"Sobol Tensor Trains for Global Sensitivity Analysis" (2017) <https://www.sciencedirect.com/science/article/pii/S0951832018303132?dgcid=rss_sd_all>`_ :param t: an N-dimensional :class:`Tensor` :param mask: an N-dimensional mask :param marginals: a list of N vectors (will be normalized if not summing to 1). If None (default), uniform distributions are assumed for all variables :param normalize: whether to normalize indices by the total variance of the model (True by default) :return: a scalar >= 0 """ if marginals is None: marginals = [None] * t.dim() a = tn.anova_decomposition(t, marginals) a -= tn.Tensor([ torch.cat((torch.ones(1, 1, 1), torch.zeros(1, sh - 1, 1)), dim=1) for sh in a.shape ]) * a[(0, ) * t.dim()] # Set empty tuple to 0 am = a.clone() for n in range(t.dim()): if marginals[n] is None: m = torch.ones([t.shape[n]]) else: m = marginals[n] m /= torch.sum(m) # Make sure each marginal sums to 1 if am.Us[n] is None: if am.cores[n].dim() == 3: am.cores[n][:, 1:, :] *= m[None, :, None] else: am.cores[n][1:, :] *= m[:, None] else: am.Us[n][1:, :] *= m[:, None] am_masked = tn.mask(am, mask) if am_masked.cores[-1].shape[-1] > 1: am_masked.cores.append( torch.eye(am_masked.cores[-1].shape[-1])[:, :, None]) am_masked.Us.append(None) if normalize: return tn.dot(a, am_masked) / tn.dot(a, am) else: return tn.dot(a, am_masked)
def dimension_distribution(t, mask=None, order=None, marginals=None): """ Computes the dimension distribution of an ND tensor. :param t: ND input :class:`Tensor` :param mask: an optional mask :class:`Tensor` to restrict to :param order: int, compute only this many order contributions. By default, all N are returned :param marginals: PMFs for input variables. By default, uniform distributions :return: a PyTorch vector containing N elements """ if order is None: order = t.dim() if mask is None: return tn.sobol(t, tn.weight_one_hot(t.dim(), order+1), marginals=marginals).torch()[1:] else: mask2 = tn.mask(tn.weight_one_hot(t.dim(), order+1), mask) return tn.sobol(t, mask2, marginals=marginals).torch()[1:] / tn.sobol(t, mask, marginals=marginals)