pytorch_backend

class pyhf.tensor.pytorch_backend.pytorch_backend(**kwargs)

Bases: object

PyTorch backend for pyhf

Attributes

default_do_grad

dtypemap

name

precision

Methods

__init__(**kwargs)

Initialize self. See help(type(self)) for accurate signature.

abs(tensor)

astensor(tensor_in, dtype='float')

Convert to a PyTorch Tensor.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> tensor = pyhf.tensorlib.astensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
>>> tensor
tensor([[1., 2., 3.],
        [4., 5., 6.]])
>>> type(tensor)
<class 'torch.Tensor'>

Parameters

tensor_in (Number or Tensor) – Tensor object

Returns

A multi-dimensional matrix containing elements of a single data type.

Return type

torch.Tensor

boolean_mask(tensor, mask)

clip(tensor_in, min_value, max_value)

Clips (limits) the tensor values to be within a specified min and max.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> a = pyhf.tensorlib.astensor([-2, -1, 0, 1, 2])
>>> pyhf.tensorlib.clip(a, -1, 1)
tensor([-1., -1.,  0.,  1.,  1.])

Parameters

• tensor_in (tensor) – The input tensor object

• min_value (scalar or tensor or None) – The minimum value to be cliped to

• max_value (scalar or tensor or None) – The maximum value to be cliped to

Returns

A clipped tensor

Return type

PyTorch tensor

concatenate(sequence, axis=0)

Join a sequence of arrays along an existing axis.

Parameters

• sequence – sequence of tensors

• axis – dimension along which to concatenate

Returns

the concatenated tensor

Return type

output

conditional(predicate, true_callable, false_callable)

Runs a callable conditional on the boolean value of the evaulation of a predicate

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> tensorlib = pyhf.tensorlib
>>> a = tensorlib.astensor([4])
>>> b = tensorlib.astensor([5])
>>> tensorlib.conditional((a < b)[0], lambda: a + b, lambda: a - b)
tensor([9.])

Parameters

• predicate (scalar) – The logical condition that determines which callable to evaluate

• true_callable (callable) – The callable that is evaluated when the predicate evalutes to true

• false_callable (callable) – The callable that is evaluated when the predicate evalutes to false

Returns

The output of the callable that was evaluated

Return type

PyTorch Tensor

divide(tensor_in_1, tensor_in_2)

einsum(subscripts, *operands)

This function provides a way of computing multilinear expressions (i.e. sums of products) using the Einstein summation convention.

Parameters

• subscripts – str, specifies the subscripts for summation

• operands – list of array_like, these are the tensors for the operation

Returns

the calculation based on the Einstein summation convention

Return type

tensor

exp(tensor_in)

gather(tensor, indices)

isfinite(tensor)

log(tensor_in)

normal(x, mu, sigma)

The probability density function of the Normal distribution evaluated at x given parameters of mean of mu and standard deviation of sigma.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> pyhf.tensorlib.normal(0.5, 0., 1.)
tensor(0.3521)
>>> values = pyhf.tensorlib.astensor([0.5, 2.0])
>>> means = pyhf.tensorlib.astensor([0., 2.3])
>>> sigmas = pyhf.tensorlib.astensor([1., 0.8])
>>> pyhf.tensorlib.normal(values, means, sigmas)
tensor([0.3521, 0.4648])

Parameters

• x (tensor or float) – The value at which to evaluate the Normal distribution p.d.f.

• mu (tensor or float) – The mean of the Normal distribution

• sigma (tensor or float) – The standard deviation of the Normal distribution

Returns

Value of Normal(x|mu, sigma)

Return type

PyTorch FloatTensor

normal_cdf(x, mu=0.0, sigma=1.0)

The cumulative distribution function for the Normal distribution

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> pyhf.tensorlib.normal_cdf(0.8)
tensor(0.7881)
>>> values = pyhf.tensorlib.astensor([0.8, 2.0])
>>> pyhf.tensorlib.normal_cdf(values)
tensor([0.7881, 0.9772])

Parameters

• x (tensor or float) – The observed value of the random variable to evaluate the CDF for

• mu (tensor or float) – The mean of the Normal distribution

• sigma (tensor or float) – The standard deviation of the Normal distribution

Returns

The CDF

Return type

PyTorch FloatTensor

normal_dist(mu, sigma)

The Normal distribution with mean mu and standard deviation sigma.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> means = pyhf.tensorlib.astensor([5, 8])
>>> stds = pyhf.tensorlib.astensor([1, 0.5])
>>> values = pyhf.tensorlib.astensor([4, 9])
>>> normals = pyhf.tensorlib.normal_dist(means, stds)
>>> normals.log_prob(values)
tensor([-1.4189, -2.2258])

Parameters

• mu (tensor or float) – The mean of the Normal distribution

• sigma (tensor or float) – The standard deviation of the Normal distribution

Returns

The Normal distribution class

Return type

PyTorch Normal distribution

normal_logpdf(x, mu, sigma)

ones(shape)

outer(tensor_in_1, tensor_in_2)

poisson(n, lam)

The continous approximation, using \(n! = \Gamma\left(n+1\right)\), to the probability mass function of the Poisson distribution evaluated at n given the parameter lam.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> pyhf.tensorlib.poisson(5., 6.)
tensor(0.1606)
>>> values = pyhf.tensorlib.astensor([5., 9.])
>>> rates = pyhf.tensorlib.astensor([6., 8.])
>>> pyhf.tensorlib.poisson(values, rates)
tensor([0.1606, 0.1241])

Parameters

• n (tensor or float) – The value at which to evaluate the approximation to the Poisson distribution p.m.f. (the observed number of events)

• lam (tensor or float) – The mean of the Poisson distribution p.m.f. (the expected number of events)

Returns

Value of the continous approximation to Poisson(n|lam)

Return type

PyTorch FloatTensor

poisson_dist(rate)

The Poisson distribution with rate parameter rate.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> rates = pyhf.tensorlib.astensor([5, 8])
>>> values = pyhf.tensorlib.astensor([4, 9])
>>> poissons = pyhf.tensorlib.poisson_dist(rates)
>>> poissons.log_prob(values)
tensor([-1.7403, -2.0869])

Parameters

rate (tensor or float) – The mean of the Poisson distribution (the expected number of events)

Returns

The Poisson distribution class

Return type

PyTorch Poisson distribution

poisson_logpdf(n, lam)

power(tensor_in_1, tensor_in_2)

product(tensor_in, axis=None)

reshape(tensor, newshape)

shape(tensor)

simple_broadcast(*args)

Broadcast a sequence of 1 dimensional arrays.

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> pyhf.tensorlib.simple_broadcast(
...   pyhf.tensorlib.astensor([1]),
...   pyhf.tensorlib.astensor([2, 3, 4]),
...   pyhf.tensorlib.astensor([5, 6, 7]))
[tensor([1., 1., 1.]), tensor([2., 3., 4.]), tensor([5., 6., 7.])]

Parameters

args (Array of Tensors) – Sequence of arrays

Returns

The sequence broadcast together.

Return type

list of Tensors

sqrt(tensor_in)

stack(sequence, axis=0)

sum(tensor_in, axis=None)

tile(tensor_in, repeats)

Repeat tensor data along a specific dimension

Example

>>> import pyhf
>>> pyhf.set_backend("pytorch")
>>> a = pyhf.tensorlib.astensor([[1.0], [2.0]])
>>> pyhf.tensorlib.tile(a, (1, 2))
tensor([[1., 1.],
        [2., 2.]])

Parameters

• tensor_in (Tensor) – The tensor to be repeated

• repeats (Tensor) – The tuple of multipliers for each dimension

Returns

The tensor with repeated axes

Return type

PyTorch tensor

tolist(tensor_in)

where(mask, tensor_in_1, tensor_in_2)

zeros(shape)