Table of Contents
Shortcuts

# Source code for torch.distributions.studentT

    import math

    import torch
    from torch import inf, nan
    from torch.distributions import Chi2, constraints
    from torch.distributions.distribution import Distribution
    from torch.distributions.utils import _standard_normal, broadcast_all

    __all__ = ["StudentT"]

    class StudentT(Distribution):
        r"""
        Creates a Student's t-distribution parameterized by degree of
        freedom :attr:`df`, mean :attr:`loc` and scale :attr:`scale`.

        Example::

            >>> # xdoctest: +IGNORE_WANT("non-deterinistic")
            >>> m = StudentT(torch.tensor([2.0]))
            >>> m.sample()  # Student's t-distributed with degrees of freedom=2
            tensor([ 0.1046])

        Args:
            df (float or Tensor): degrees of freedom
            loc (float or Tensor): mean of the distribution
            scale (float or Tensor): scale of the distribution
        """
        arg_constraints = {
            "df": constraints.positive,
            "loc": constraints.real,
            "scale": constraints.positive,
        }
        support = constraints.real
        has_rsample = True

        @property
        def mean(self):
            m = self.loc.clone(memory_format=torch.contiguous_format)
            m[self.df <= 1] = nan
            return m

        @property
        def mode(self):
            return self.loc

        @property
        def variance(self):
            m = self.df.clone(memory_format=torch.contiguous_format)
            m[self.df > 2] = (
                self.scale[self.df > 2].pow(2)
                * self.df[self.df > 2]
                / (self.df[self.df > 2] - 2)
            )
            m[(self.df <= 2) & (self.df > 1)] = inf
            m[self.df <= 1] = nan
            return m

        def __init__(self, df, loc=0.0, scale=1.0, validate_args=None):
            self.df, self.loc, self.scale = broadcast_all(df, loc, scale)
            self._chi2 = Chi2(self.df)
            batch_shape = self.df.size()
            super().__init__(batch_shape, validate_args=validate_args)

        def expand(self, batch_shape, _instance=None):
            new = self._get_checked_instance(StudentT, _instance)
            batch_shape = torch.Size(batch_shape)
            new.df = self.df.expand(batch_shape)
            new.loc = self.loc.expand(batch_shape)
            new.scale = self.scale.expand(batch_shape)
            new._chi2 = self._chi2.expand(batch_shape)
            super(StudentT, new).__init__(batch_shape, validate_args=False)
            new._validate_args = self._validate_args
            return new

        def rsample(self, sample_shape=torch.Size()):
            # NOTE: This does not agree with scipy implementation as much as other distributions.
            # (see https://github.com/fritzo/notebooks/blob/master/debug-student-t.ipynb). Using DoubleTensor
            # parameters seems to help.

            #   X ~ Normal(0, 1)
            #   Z ~ Chi2(df)
            #   Y = X / sqrt(Z / df) ~ StudentT(df)
            shape = self._extended_shape(sample_shape)
            X = _standard_normal(shape, dtype=self.df.dtype, device=self.df.device)
            Z = self._chi2.rsample(sample_shape)
            Y = X * torch.rsqrt(Z / self.df)
            return self.loc + self.scale * Y

        def log_prob(self, value):
            if self._validate_args:
                self._validate_sample(value)
            y = (value - self.loc) / self.scale
            Z = (
                self.scale.log()
                + 0.5 * self.df.log()
                + 0.5 * math.log(math.pi)
                + torch.lgamma(0.5 * self.df)
                - torch.lgamma(0.5 * (self.df + 1.0))
            )
            return -0.5 * (self.df + 1.0) * torch.log1p(y**2.0 / self.df) - Z

        def entropy(self):
            lbeta = (
                torch.lgamma(0.5 * self.df)
                + math.lgamma(0.5)
                - torch.lgamma(0.5 * (self.df + 1))
            )
            return (
                self.scale.log()
                + 0.5
                * (self.df + 1)
                * (torch.digamma(0.5 * (self.df + 1)) - torch.digamma(0.5 * self.df))
                + 0.5 * self.df.log()
                + lbeta
            )

## Docs

Access comprehensive developer documentation for PyTorch

View Docs

## Tutorials

Get in-depth tutorials for beginners and advanced developers

View Tutorials

## Resources

Find development resources and get your questions answered

View Resources

To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: Cookies Policy.