tensor

startorch.tensor ¶

Contain tensor generators.

startorch.tensor.Abs ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the absolute value of a tensor.

This tensor generator is equivalent to: output = abs(tensor)

Example usage:

>>> from startorch.tensor import Abs, RandNormal
>>> generator = Abs(RandNormal())
>>> generator
AbsTensorGenerator(
  (tensor): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AbsTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the absolute value of a tensor.

This tensor generator is equivalent to: output = abs(tensor)

Example usage:

>>> from startorch.tensor import Abs, RandNormal
>>> generator = Abs(RandNormal())
>>> generator
AbsTensorGenerator(
  (tensor): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Acosh ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the inverse hyperbolic cosine (arccosh) of each value.

Example usage:

>>> from startorch.tensor import Acosh, RandUniform
>>> generator = Acosh(RandUniform(low=1.0, high=5.0))
>>> generator
AcoshTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=5.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AcoshTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the inverse hyperbolic cosine (arccosh) of each value.

Example usage:

>>> from startorch.tensor import Acosh, RandUniform
>>> generator = Acosh(RandUniform(low=1.0, high=5.0))
>>> generator
AcoshTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=5.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Add ¶

Bases: BaseTensorGenerator

Implement a tensor generator that adds several tensor.

This tensor generator is equivalent to: output = tensor_1 + tensor_2 + ... + tensor_n

Parameters:

Name	Type	Description	Default
`generators`	`Sequence[BaseTensorGenerator \| dict]`	The tensor generators.	required

Raises:

Type	Description
`ValueError`	if no sequence generator is provided.

Example usage:

>>> from startorch.tensor import Add, RandNormal, RandUniform
>>> generator = Add([RandUniform(), RandNormal()])
>>> generator
AddTensorGenerator(
  (0): RandUniformTensorGenerator(low=0.0, high=1.0)
  (1): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AddScalar ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that adds a scalar value to a generated batch of tensors.

This tensor generator is equivalent to: output = tensor + scalar

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`value`	`float`	The scalar value to add.	required

Example usage:

>>> from startorch.tensor import AddScalar, RandUniform
>>> generator = AddScalar(RandUniform(), 10.0)
>>> generator
AddScalarTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
  (value): 10.0
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AddScalarTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that adds a scalar value to a generated batch of tensors.

This tensor generator is equivalent to: output = tensor + scalar

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`value`	`float`	The scalar value to add.	required

Example usage:

>>> from startorch.tensor import AddScalar, RandUniform
>>> generator = AddScalar(RandUniform(), 10.0)
>>> generator
AddScalarTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
  (value): 10.0
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AddTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that adds several tensor.

This tensor generator is equivalent to: output = tensor_1 + tensor_2 + ... + tensor_n

Parameters:

Name	Type	Description	Default
`generators`	`Sequence[BaseTensorGenerator \| dict]`	The tensor generators.	required

Raises:

Type	Description
`ValueError`	if no sequence generator is provided.

Example usage:

>>> from startorch.tensor import Add, RandNormal, RandUniform
>>> generator = Add([RandUniform(), RandNormal()])
>>> generator
AddTensorGenerator(
  (0): RandUniformTensorGenerator(low=0.0, high=1.0)
  (1): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Asinh ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the inverse hyperbolic sine (arcsinh) of each value.

Example usage:

>>> from startorch.tensor import Asinh, RandUniform
>>> generator = Asinh(RandUniform(low=0.0, high=1000.0))
>>> generator
AsinhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1000.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AsinhTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the inverse hyperbolic sine (arcsinh) of each value.

Example usage:

>>> from startorch.tensor import Asinh, RandUniform
>>> generator = Asinh(RandUniform(low=0.0, high=1000.0))
>>> generator
AsinhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1000.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AsinhUniform ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate tensors by sampling values from an asinh-uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (inclusive).	required
`high`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandUniform, AsinhUniform
>>> generator = AsinhUniform(
...     low=RandUniform(low=-1000, high=-100), high=RandUniform(low=100, high=1000)
... )
>>> generator
AsinhUniformTensorGenerator(
  (low): RandUniformTensorGenerator(low=-1000.0, high=-100.0)
  (high): RandUniformTensorGenerator(low=100.0, high=1000.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AsinhUniformTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate tensors by sampling values from an asinh-uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (inclusive).	required
`high`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandUniform, AsinhUniform
>>> generator = AsinhUniform(
...     low=RandUniform(low=-1000, high=-100), high=RandUniform(low=100, high=1000)
... )
>>> generator
AsinhUniformTensorGenerator(
  (low): RandUniformTensorGenerator(low=-1000.0, high=-100.0)
  (high): RandUniformTensorGenerator(low=100.0, high=1000.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Atanh ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the inverse hyperbolic tangent (arctanh) of each value.

Example usage:

>>> from startorch.tensor import Atanh, RandUniform
>>> generator = Atanh(RandUniform(low=-0.5, high=0.5))
>>> generator
AtanhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=-0.5, high=0.5)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.AtanhTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the inverse hyperbolic tangent (arctanh) of each value.

Example usage:

>>> from startorch.tensor import Atanh, RandUniform
>>> generator = Atanh(RandUniform(low=-0.5, high=0.5))
>>> generator
AtanhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=-0.5, high=0.5)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.BaseTensorGenerator ¶

Bases: ABC

Define the base class to generate tensor.

A child class has to implement the generate method.

Example usage:

>>> import torch
>>> from startorch.tensor import RandUniform
>>> generator = RandUniform()
>>> generator
RandUniformTensorGenerator(low=0.0, high=1.0)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.BaseTensorGenerator.generate `abstractmethod` ¶

generate(
    size: tuple[int, ...], rng: Generator | None = None
) -> Tensor

Generate a tensor.

Parameters:

Name	Type	Description	Default
`size`	`tuple[int, ...]`	The size of the tensor to generate.	required
`rng`	`Generator \| None`	An optional random number generator.	`None`

Returns:

Type	Description
`Tensor`	The generated tensor with the specified size.

Example usage:

>>> import torch
>>> from startorch.tensor import RandUniform
>>> generator = RandUniform()
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.BaseWrapperTensorGenerator ¶

Bases: BaseTensorGenerator

Define a base class to easily wrap a tensor generator into another tensor generator.

Note

It is possible to wrap a tensor generator into another tensor generator without using this base class. This class makes it more convenient and reduce duplicate code.

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required

startorch.tensor.Cauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the location.	required
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required

Example usage:

>>> from startorch.tensor import Cauchy, RandUniform
>>> generator = Cauchy(
...     loc=RandUniform(low=-1.0, high=1.0), scale=RandUniform(low=1.0, high=2.0)
... )
>>> generator
CauchyTensorGenerator(
  (loc): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.CauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the location.	required
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required

Example usage:

>>> from startorch.tensor import Cauchy, RandUniform
>>> generator = Cauchy(
...     loc=RandUniform(low=-1.0, high=1.0), scale=RandUniform(low=1.0, high=2.0)
... )
>>> generator
CauchyTensorGenerator(
  (loc): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Clamp ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator to generate tensors where the values are clamped.

Note: min_value and max_value cannot be both None.

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`min_value`	`float \| None`	The lower bound. If `min_value` is `None`, there is no lower bound.	required
`max_value`	`float \| None`	The upper bound. If `max_value` is `None`, there is no upper bound.	required

Raises:

Type	Description
`ValueError`	if both `min` and `max` are `None`

Example usage:

>>> from startorch.tensor import Clamp, RandUniform
>>> generator = Clamp(RandUniform(low=1.0, high=50.0), min_value=2.0, max_value=10.0)
>>> generator
ClampTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=50.0)
  (min_value): 2.0
  (max_value): 10.0
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.ClampTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator to generate tensors where the values are clamped.

Note: min_value and max_value cannot be both None.

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`min_value`	`float \| None`	The lower bound. If `min_value` is `None`, there is no lower bound.	required
`max_value`	`float \| None`	The upper bound. If `max_value` is `None`, there is no upper bound.	required

Raises:

Type	Description
`ValueError`	if both `min` and `max` are `None`

Example usage:

>>> from startorch.tensor import Clamp, RandUniform
>>> generator = Clamp(RandUniform(low=1.0, high=50.0), min_value=2.0, max_value=10.0)
>>> generator
ClampTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=50.0)
  (min_value): 2.0
  (max_value): 10.0
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Cosh ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the hyperbolic cosine (cosh) of each value.

Example usage:

>>> from startorch.tensor import Cosh, RandUniform
>>> generator = Cosh(RandUniform())
>>> generator
CoshTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.CoshTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the hyperbolic cosine (cosh) of each value.

Example usage:

>>> from startorch.tensor import Cosh, RandUniform
>>> generator = Cosh(RandUniform())
>>> generator
CoshTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Div ¶

Bases: BaseTensorGenerator

Implement a tensor generator that divides one tensor by another one.

This tensor generator is equivalent to

output = dividend / divisor (a.k.a. true division)
output = dividend // divisor (a.k.a. floor division)

Parameters:

Name	Type	Description	Default
`dividend`	`BaseTensorGenerator \| dict`	The dividend tensor generator or its configuration.	required
`divisor`	`BaseTensorGenerator \| dict`	The divisor tensor generator or its configuration.	required
`rounding_mode`	`str \| None`	The type of rounding applied to the result. - `None`: true division. - `"trunc"`: rounds the results of the division towards zero. - `"floor"`: floor division.	`None`

Example usage:

>>> from startorch.tensor import Div, RandUniform
>>> generator = Div(RandUniform(), RandUniform(low=1.0, high=10.0))
>>> generator
DivTensorGenerator(
  (dividend): RandUniformTensorGenerator(low=0.0, high=1.0)
  (divisor): RandUniformTensorGenerator(low=1.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.DivTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that divides one tensor by another one.

This tensor generator is equivalent to

output = dividend / divisor (a.k.a. true division)
output = dividend // divisor (a.k.a. floor division)

Parameters:

Name	Type	Description	Default
`dividend`	`BaseTensorGenerator \| dict`	The dividend tensor generator or its configuration.	required
`divisor`	`BaseTensorGenerator \| dict`	The divisor tensor generator or its configuration.	required
`rounding_mode`	`str \| None`	The type of rounding applied to the result. - `None`: true division. - `"trunc"`: rounds the results of the division towards zero. - `"floor"`: floor division.	`None`

Example usage:

>>> from startorch.tensor import Div, RandUniform
>>> generator = Div(RandUniform(), RandUniform(low=1.0, high=10.0))
>>> generator
DivTensorGenerator(
  (dividend): RandUniformTensorGenerator(low=0.0, high=1.0)
  (divisor): RandUniformTensorGenerator(low=1.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Exp ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the exponential of a tensor.

This tensor generator is equivalent to: output = exp(tensor)

Example usage:

>>> from startorch.tensor import Exp, RandUniform
>>> generator = Exp(RandUniform(low=1.0, high=5.0))
>>> generator
ExpTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=5.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.ExpTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the exponential of a tensor.

This tensor generator is equivalent to: output = exp(tensor)

Example usage:

>>> from startorch.tensor import Exp, RandUniform
>>> generator = Exp(RandUniform(low=1.0, high=5.0))
>>> generator
ExpTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=5.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Exponential ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors by sampling values from an Exponential distribution.

The rates of the Exponential distribution are generated by the rate generator. The rate generator should return the rate for each value in the sequence.

Parameters:

Name	Type	Description	Default
`rate`	`BaseTensorGenerator \| dict`	The rate generator or its configuration. The rate generator should return valid rate values.	required

Example usage:

>>> from startorch.tensor import Exponential, RandUniform
>>> generator = Exponential(rate=RandUniform(low=1.0, high=100.0))
>>> generator
ExponentialTensorGenerator(
  (rate): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.ExponentialTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors by sampling values from an Exponential distribution.

The rates of the Exponential distribution are generated by the rate generator. The rate generator should return the rate for each value in the sequence.

Parameters:

Name	Type	Description	Default
`rate`	`BaseTensorGenerator \| dict`	The rate generator or its configuration. The rate generator should return valid rate values.	required

Example usage:

>>> from startorch.tensor import Exponential, RandUniform
>>> generator = Exponential(rate=RandUniform(low=1.0, high=100.0))
>>> generator
ExponentialTensorGenerator(
  (rate): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Float ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that converts tensor values to float.

Example usage:

>>> from startorch.tensor import Float, RandInt
>>> generator = Float(RandInt(low=0, high=10))
>>> generator
FloatTensorGenerator(
  (tensor): RandIntTensorGenerator(low=0, high=10)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.FloatTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that converts tensor values to float.

Example usage:

>>> from startorch.tensor import Float, RandInt
>>> generator = Float(RandInt(low=0, high=10))
>>> generator
FloatTensorGenerator(
  (tensor): RandIntTensorGenerator(low=0, high=10)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Fmod ¶

Bases: BaseTensorGenerator

Implement a tensor generator that computes the element-wise remainder of division.

This tensor generator is equivalent to: output = dividend % divisor

Parameters:

Name	Type	Description	Default
`dividend`	`BaseTensorGenerator \| dict`	The tensor generator (or its configuration) that generates the dividend values.	required
`divisor`	`BaseTensorGenerator \| dict \| float`	The divisor.	required

Example usage:

>>> from startorch.tensor import Fmod, RandUniform
>>> generator = Fmod(dividend=RandUniform(low=-100, high=100), divisor=10.0)
>>> generator
FmodTensorGenerator(
  (dividend): RandUniformTensorGenerator(low=-100.0, high=100.0)
  (divisor): 10.0
)
>>> generator.generate((2, 6))
tensor([[...]])
>>> generator = Fmod(
...     dividend=RandUniform(low=-100, high=100), divisor=RandUniform(low=1, high=10)
... )
>>> generator
FmodTensorGenerator(
  (dividend): RandUniformTensorGenerator(low=-100.0, high=100.0)
  (divisor): RandUniformTensorGenerator(low=1.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.FmodTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that computes the element-wise remainder of division.

This tensor generator is equivalent to: output = dividend % divisor

Parameters:

Name	Type	Description	Default
`dividend`	`BaseTensorGenerator \| dict`	The tensor generator (or its configuration) that generates the dividend values.	required
`divisor`	`BaseTensorGenerator \| dict \| float`	The divisor.	required

Example usage:

>>> from startorch.tensor import Fmod, RandUniform
>>> generator = Fmod(dividend=RandUniform(low=-100, high=100), divisor=10.0)
>>> generator
FmodTensorGenerator(
  (dividend): RandUniformTensorGenerator(low=-100.0, high=100.0)
  (divisor): 10.0
)
>>> generator.generate((2, 6))
tensor([[...]])
>>> generator = Fmod(
...     dividend=RandUniform(low=-100, high=100), divisor=RandUniform(low=1, high=10)
... )
>>> generator
FmodTensorGenerator(
  (dividend): RandUniformTensorGenerator(low=-100.0, high=100.0)
  (divisor): RandUniformTensorGenerator(low=1.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Full ¶

Bases: BaseTensorGenerator

Implement a tensor generator that fills the tensor with a given value.

Parameters:

Name	Type	Description	Default
`value`	`bool \| float`	The fill value.	required
`dtype`	`dtype \| None`	The target dtype. `None` means the data type is infered from the value type.	`None`

Example usage:

>>> from startorch.tensor import Full
>>> generator = Full(value=42)
>>> generator
FullTensorGenerator(value=42, dtype=None)
>>> generator.generate((2, 6))
tensor([[42, 42, 42, 42, 42, 42],
        [42, 42, 42, 42, 42, 42]])

startorch.tensor.FullTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that fills the tensor with a given value.

Parameters:

Name	Type	Description	Default
`value`	`bool \| float`	The fill value.	required
`dtype`	`dtype \| None`	The target dtype. `None` means the data type is infered from the value type.	`None`

Example usage:

>>> from startorch.tensor import Full
>>> generator = Full(value=42)
>>> generator
FullTensorGenerator(value=42, dtype=None)
>>> generator.generate((2, 6))
tensor([[42, 42, 42, 42, 42, 42],
        [42, 42, 42, 42, 42, 42]])

startorch.tensor.HalfCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required

Example usage:

>>> from startorch.tensor import HalfCauchy, RandUniform
>>> generator = HalfCauchy(scale=RandUniform(low=1.0, high=2.0))
>>> generator
HalfCauchyTensorGenerator(
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.HalfCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required

Example usage:

>>> from startorch.tensor import HalfCauchy, RandUniform
>>> generator = HalfCauchy(scale=RandUniform(low=1.0, high=2.0))
>>> generator
HalfCauchyTensorGenerator(
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.HalfNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation.	required

Example usage:

>>> from startorch.tensor import HalfNormal, RandUniform
>>> generator = HalfNormal(std=RandUniform(low=1.0, high=2.0))
>>> generator
HalfNormalTensorGenerator(
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.HalfNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation.	required

Example usage:

>>> from startorch.tensor import HalfNormal, RandUniform
>>> generator = HalfNormal(std=RandUniform(low=1.0, high=2.0))
>>> generator
HalfNormalTensorGenerator(
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.Log ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the logarithm of a tensor.

This tensor generator is equivalent to: output = log(tensor)

Example usage:

>>> from startorch.tensor import Log, RandUniform
>>> generator = Log(RandUniform(low=1.0, high=100.0))
>>> generator
LogTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.LogNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the mean of the underlying Normal distribution.	required
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation of the underlying Normal distribution.	required

Example usage:

>>> from startorch.tensor import LogNormal, RandUniform
>>> generator = LogNormal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
LogNormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.LogNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the mean of the underlying Normal distribution.	required
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation of the underlying Normal distribution.	required

Example usage:

>>> from startorch.tensor import LogNormal, RandUniform
>>> generator = LogNormal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
LogNormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.LogTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the logarithm of a tensor.

This tensor generator is equivalent to: output = log(tensor)

Example usage:

>>> from startorch.tensor import Log, RandUniform
>>> generator = Log(RandUniform(low=1.0, high=100.0))
>>> generator
LogTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.LogUniform ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate tensors by sampling values from a log-uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (inclusive).	required
`high`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandUniform, LogUniform
>>> generator = LogUniform(
...     low=RandUniform(low=0.1, high=1.0), high=RandUniform(low=100, high=1000)
... )
>>> generator
LogUniformTensorGenerator(
  (low): RandUniformTensorGenerator(low=0.1, high=1.0)
  (high): RandUniformTensorGenerator(low=100.0, high=1000.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.LogUniformTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate tensors by sampling values from a log-uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (inclusive).	required
`high`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandUniform, LogUniform
>>> generator = LogUniform(
...     low=RandUniform(low=0.1, high=1.0), high=RandUniform(low=100, high=1000)
... )
>>> generator
LogUniformTensorGenerator(
  (low): RandUniformTensorGenerator(low=0.1, high=1.0)
  (high): RandUniformTensorGenerator(low=100.0, high=1000.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Long ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that converts a tensor values to long.

Example usage:

>>> from startorch.tensor import Long, RandUniform
>>> generator = Long(RandUniform(low=0, high=10))
>>> generator
LongTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.LongTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that converts a tensor values to long.

Example usage:

>>> from startorch.tensor import Long, RandUniform
>>> generator = Long(RandUniform(low=0, high=10))
>>> generator
LongTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Mul ¶

Bases: BaseTensorGenerator

Implement a tensor generator that multiplies multiple tensors.

This tensor generator is equivalent to: output = tensor_1 * tensor_2 * ... * tensor_n

Parameters:

Name	Type	Description	Default
`generators`	`Sequence[BaseTensorGenerator \| dict]`	The tensor generators.	required

Raises:

Type	Description
`ValueError`	if no sequence generator is provided.

Example usage:

>>> import torch
>>> from startorch.tensor import Mul, RandUniform, RandNormal
>>> generator = Mul([RandUniform(), RandNormal()])
>>> generator
MulTensorGenerator(
  (0): RandUniformTensorGenerator(low=0.0, high=1.0)
  (1): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.MulScalar ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that multiplies a scalar value to a generated batch of tensors.

This tensor generator is equivalent to: output = tensor * scalar

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`value`	`float`	The scalar value to multiply.	required

Example usage:

>>> import torch
>>> from startorch.tensor import MulScalar, RandUniform, RandNormal
>>> generator = MulScalar(RandUniform(), 42)
>>> generator
MulScalarTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.MulScalarTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that multiplies a scalar value to a generated batch of tensors.

This tensor generator is equivalent to: output = tensor * scalar

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`value`	`float`	The scalar value to multiply.	required

Example usage:

>>> import torch
>>> from startorch.tensor import MulScalar, RandUniform, RandNormal
>>> generator = MulScalar(RandUniform(), 42)
>>> generator
MulScalarTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.MulTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that multiplies multiple tensors.

This tensor generator is equivalent to: output = tensor_1 * tensor_2 * ... * tensor_n

Parameters:

Name	Type	Description	Default
`generators`	`Sequence[BaseTensorGenerator \| dict]`	The tensor generators.	required

Raises:

Type	Description
`ValueError`	if no sequence generator is provided.

Example usage:

>>> import torch
>>> from startorch.tensor import Mul, RandUniform, RandNormal
>>> generator = Mul([RandUniform(), RandNormal()])
>>> generator
MulTensorGenerator(
  (0): RandUniformTensorGenerator(low=0.0, high=1.0)
  (1): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Multinomial ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors of categorical variables where each value is sampled from a multinomial distribution.

Parameters:

Name	Type	Description	Default
`weights`	`Tensor \| Sequence[float]`	The vector of weights associated at each category. It must be a float tensor of shape `(num_categories,)`. The weights have to be positive but do not need to sum to 1.	required

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial(torch.ones(10))
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.Multinomial.create_exp_weights `classmethod` ¶

create_exp_weights(
    num_categories: int, scale: float = 0.1
) -> MultinomialTensorGenerator

Instantiate the weights with an exponential pattern.

The weight of the i-th category (w_i) is generated with the rule: w_i = exp(-scale * i)

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required
`scale`	`float`	The scale parameter that controls the exponential function.	`0.1`

Returns:

Type	Description
`MultinomialTensorGenerator`	A tensor generator where the weights of the multinomial distribution follow an exponential pattern.

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial.create_exp_weights(10)
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.Multinomial.create_linear_weights `classmethod` ¶

create_linear_weights(
    num_categories: int,
) -> MultinomialTensorGenerator

Instantiate the weights with a linear pattern.

The weight of the i-th category (w_i) is generated with the rule: w_i = num_categories - i

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required

Returns:

Type	Description
`MultinomialTensorGenerator`	A tensor generator where the weights of the multinomial distribution follow a linear pattern.

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial.create_linear_weights(10)
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.Multinomial.create_uniform_weights `classmethod` ¶

create_uniform_weights(
    num_categories: int,
) -> MultinomialTensorGenerator

Instantiate the weights with a uniform pattern.

All the categories have the same probability. The weight of the i-th category (w_i) is generated with the rule: w_i = 1

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required

Returns:

Type	Description
`MultinomialTensorGenerator`	A tensor generator where the weights of the multinomial distribution follow a uniform pattern.

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial.create_uniform_weights(10)
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.MultinomialChoice ¶

Bases: BaseTensorGenerator

Implement a tensor generator that select a tensor generator at each batch.

This tensor generator is used to generate tensors with different generation processes. The user can specify a list of tensor generators with an associated weight. The weight is used to sample the tensor generator with a multinomial distribution. Higher weight means that the tensor generator has a higher probability to be selected at each batch. Each dictionary in the generators input should have the following items:

- a key ``'generator'`` which indicates the tensor generator
    or its configuration.
- an optional key ``'weight'`` with a float value which
    indicates the weight of the tensor generator.
    If this key is absent, the weight is set to ``1.0``.

Parameters:

Name	Type	Description	Default
`generators`	`Sequence[dict[str, BaseTensorGenerator \| dict]]`	The tensor generators and their weights. See above to learn about the expected format.	required

Example usage:

>>> from startorch.tensor import MultinomialChoice, RandUniform, RandNormal
>>> generator = MultinomialChoice(
...     (
...         {"weight": 2.0, "generator": RandUniform()},
...         {"weight": 1.0, "generator": RandNormal()},
...     )
... )
>>> generator
MultinomialChoiceTensorGenerator(
  (0) [weight=2.0] RandUniformTensorGenerator(low=0.0, high=1.0)
  (1) [weight=1.0] RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.MultinomialChoiceTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that select a tensor generator at each batch.

This tensor generator is used to generate tensors with different generation processes. The user can specify a list of tensor generators with an associated weight. The weight is used to sample the tensor generator with a multinomial distribution. Higher weight means that the tensor generator has a higher probability to be selected at each batch. Each dictionary in the generators input should have the following items:

- a key ``'generator'`` which indicates the tensor generator
    or its configuration.
- an optional key ``'weight'`` with a float value which
    indicates the weight of the tensor generator.
    If this key is absent, the weight is set to ``1.0``.

Parameters:

Name	Type	Description	Default
`generators`	`Sequence[dict[str, BaseTensorGenerator \| dict]]`	The tensor generators and their weights. See above to learn about the expected format.	required

Example usage:

>>> from startorch.tensor import MultinomialChoice, RandUniform, RandNormal
>>> generator = MultinomialChoice(
...     (
...         {"weight": 2.0, "generator": RandUniform()},
...         {"weight": 1.0, "generator": RandNormal()},
...     )
... )
>>> generator
MultinomialChoiceTensorGenerator(
  (0) [weight=2.0] RandUniformTensorGenerator(low=0.0, high=1.0)
  (1) [weight=1.0] RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.MultinomialTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors of categorical variables where each value is sampled from a multinomial distribution.

Parameters:

Name	Type	Description	Default
`weights`	`Tensor \| Sequence[float]`	The vector of weights associated at each category. It must be a float tensor of shape `(num_categories,)`. The weights have to be positive but do not need to sum to 1.	required

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial(torch.ones(10))
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.MultinomialTensorGenerator.create_exp_weights `classmethod` ¶

create_exp_weights(
    num_categories: int, scale: float = 0.1
) -> MultinomialTensorGenerator

Instantiate the weights with an exponential pattern.

The weight of the i-th category (w_i) is generated with the rule: w_i = exp(-scale * i)

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required
`scale`	`float`	The scale parameter that controls the exponential function.	`0.1`

Returns:

Type	Description
`MultinomialTensorGenerator`	A tensor generator where the weights of the multinomial distribution follow an exponential pattern.

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial.create_exp_weights(10)
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.MultinomialTensorGenerator.create_linear_weights `classmethod` ¶

create_linear_weights(
    num_categories: int,
) -> MultinomialTensorGenerator

Instantiate the weights with a linear pattern.

The weight of the i-th category (w_i) is generated with the rule: w_i = num_categories - i

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required

Returns:

Type	Description
`MultinomialTensorGenerator`	A tensor generator where the weights of the multinomial distribution follow a linear pattern.

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial.create_linear_weights(10)
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.MultinomialTensorGenerator.create_uniform_weights `classmethod` ¶

create_uniform_weights(
    num_categories: int,
) -> MultinomialTensorGenerator

Instantiate the weights with a uniform pattern.

All the categories have the same probability. The weight of the i-th category (w_i) is generated with the rule: w_i = 1

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required

Returns:

Type	Description
`MultinomialTensorGenerator`	A tensor generator where the weights of the multinomial distribution follow a uniform pattern.

Example usage:

>>> import torch
>>> from startorch.tensor import Multinomial
>>> generator = Multinomial.create_uniform_weights(10)
>>> generator
MultinomialTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.Neg ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the negation of a generated tensor.

This tensor generator is equivalent to: output = -tensor

Example usage:

>>> import torch
>>> from startorch.tensor import Neg, RandNormal
>>> generator = Neg(RandNormal())
>>> generator
NegTensorGenerator(
  (tensor): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.NegTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the negation of a generated tensor.

This tensor generator is equivalent to: output = -tensor

Example usage:

>>> import torch
>>> from startorch.tensor import Neg, RandNormal
>>> generator = Neg(RandNormal())
>>> generator
NegTensorGenerator(
  (tensor): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Normal ¶

Bases: BaseTensorGenerator

Implement a class to generate sequence by sampling values from a Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the mean.	required
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation.	required

Example usage:

>>> from startorch.tensor import Normal, RandUniform
>>> generator = Normal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
NormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.NormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate sequence by sampling values from a Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the mean.	required
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation.	required

Example usage:

>>> from startorch.tensor import Normal, RandUniform
>>> generator = Normal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
NormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Poisson ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors by sampling values from a Poisson distribution.

The rates of the Poisson distribution are generated by the rate generator. The rate generator should return the rate for each value in the tensor. The rate values should be greater than 0.

Parameters:

Name	Type	Description	Default
`rate`	`BaseTensorGenerator \| dict`	The rate generator or its configuration. The rate generator should return valid rate values.	required

Example usage:

>>> from startorch.tensor import RandUniform, Poisson
>>> generator = Poisson(rate=RandUniform(low=1.0, high=2.0))
>>> generator
PoissonTensorGenerator(
  (rate): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.PoissonTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors by sampling values from a Poisson distribution.

The rates of the Poisson distribution are generated by the rate generator. The rate generator should return the rate for each value in the tensor. The rate values should be greater than 0.

Parameters:

Name	Type	Description	Default
`rate`	`BaseTensorGenerator \| dict`	The rate generator or its configuration. The rate generator should return valid rate values.	required

Example usage:

>>> from startorch.tensor import RandUniform, Poisson
>>> generator = Poisson(rate=RandUniform(low=1.0, high=2.0))
>>> generator
PoissonTensorGenerator(
  (rate): RandUniformTensorGenerator(low=1.0, high=2.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandAsinhUniform ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling values from an asinh- uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`float`	The minimum value (inclusive).	required
`high`	`float`	The maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandAsinhUniform
>>> generator = RandAsinhUniform(low=-1000, high=1000)
>>> generator
RandAsinhUniformTensorGenerator(low=-1000.0, high=1000.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandAsinhUniformTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling values from an asinh- uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`float`	The minimum value (inclusive).	required
`high`	`float`	The maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandAsinhUniform
>>> generator = RandAsinhUniform(low=-1000, high=1000)
>>> generator
RandAsinhUniformTensorGenerator(low=-1000.0, high=1000.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`float`	The location/median of the Cauchy distribution.	`0.0`
`scale`	`float`	The scale of the distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `scale` is not a positive number.

Example usage:

>>> from startorch.tensor import RandCauchy
>>> generator = RandCauchy(loc=0.0, scale=1.0)
>>> generator
RandCauchyTensorGenerator(loc=0.0, scale=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`float`	The location/median of the Cauchy distribution.	`0.0`
`scale`	`float`	The scale of the distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `scale` is not a positive number.

Example usage:

>>> from startorch.tensor import RandCauchy
>>> generator = RandCauchy(loc=0.0, scale=1.0)
>>> generator
RandCauchyTensorGenerator(loc=0.0, scale=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandExponential ¶

Bases: BaseTensorGenerator

Implement a class to generate sequences by sampling values from an Exponential distribution.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Exponential distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `rate` is not a positive number.

Example usage:

>>> from startorch.tensor import RandExponential
>>> generator = RandExponential(rate=1.0)
>>> generator
RandExponentialTensorGenerator(rate=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandExponentialTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate sequences by sampling values from an Exponential distribution.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Exponential distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `rate` is not a positive number.

Example usage:

>>> from startorch.tensor import RandExponential
>>> generator = RandExponential(rate=1.0)
>>> generator
RandExponentialTensorGenerator(rate=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandHalfCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`float`	The scale of the distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `scale` is not a positive number.

Example usage:

>>> from startorch.tensor import RandHalfCauchy
>>> generator = RandHalfCauchy(scale=1.0)
>>> generator
RandHalfCauchyTensorGenerator(scale=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandHalfCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`float`	The scale of the distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `scale` is not a positive number.

Example usage:

>>> from startorch.tensor import RandHalfCauchy
>>> generator = RandHalfCauchy(scale=1.0)
>>> generator
RandHalfCauchyTensorGenerator(scale=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandHalfNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`float`	The std of the distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.

Example usage:

>>> from startorch.tensor import RandHalfNormal
>>> generator = RandHalfNormal(std=1.0)
>>> generator
RandHalfNormalTensorGenerator(std=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandHalfNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`float`	The std of the distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.

Example usage:

>>> from startorch.tensor import RandHalfNormal
>>> generator = RandHalfNormal(std=1.0)
>>> generator
RandHalfNormalTensorGenerator(std=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandInt ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling integer values from a uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`int`	The minimum value (inclusive).	required
`high`	`int`	The maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandInt
>>> generator = RandInt(low=0, high=10)
>>> generator
RandIntTensorGenerator(low=0, high=10)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandIntTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling integer values from a uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`int`	The minimum value (inclusive).	required
`high`	`int`	The maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandInt
>>> generator = RandInt(low=0, high=10)
>>> generator
RandIntTensorGenerator(low=0, high=10)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandLogNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the underlying Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the underlying Normal distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.

Example usage:

>>> from startorch.tensor import RandLogNormal
>>> generator = RandLogNormal(mean=0.0, std=1.0)
>>> generator
RandLogNormalTensorGenerator(mean=0.0, std=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandLogNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the underlying Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the underlying Normal distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.

Example usage:

>>> from startorch.tensor import RandLogNormal
>>> generator = RandLogNormal(mean=0.0, std=1.0)
>>> generator
RandLogNormalTensorGenerator(mean=0.0, std=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandLogUniform ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate tensors by sampling values from a log-uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`float`	The minimum value (inclusive).	required
`high`	`float`	The maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandLogUniform
>>> generator = RandLogUniform(low=0.1, high=100.0)
>>> generator
RandLogUniformTensorGenerator(low=0.1, high=100.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandLogUniformTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate tensors by sampling values from a log-uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`float`	The minimum value (inclusive).	required
`high`	`float`	The maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandLogUniform
>>> generator = RandLogUniform(low=0.1, high=100.0)
>>> generator
RandLogUniformTensorGenerator(low=0.1, high=100.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandNormal ¶

Bases: BaseTensorGenerator

Implement a sequence generator to generate cyclic sequences by sampling values from a Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the Normal distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `std` is not a postive number.

Example usage:

>>> from startorch.tensor import RandNormal
>>> generator = RandNormal(mean=0.0, std=1.0)
>>> generator
RandNormalTensorGenerator(mean=0.0, std=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a sequence generator to generate cyclic sequences by sampling values from a Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the Normal distribution.	`1.0`

Raises:

Type	Description
`ValueError`	if `std` is not a postive number.

Example usage:

>>> from startorch.tensor import RandNormal
>>> generator = RandNormal(mean=0.0, std=1.0)
>>> generator
RandNormalTensorGenerator(mean=0.0, std=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandPoisson ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors by sampling values from a Poisson distribution.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Poisson distribution. This value has to be greater than 0.	`1.0`

Raises:

Type	Description
`ValueError`	if `rate` is not a positive number.

Example usage:

>>> from startorch.tensor import RandPoisson
>>> generator = RandPoisson(rate=1.0)
>>> generator
RandPoissonTensorGenerator(rate=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandPoissonTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors by sampling values from a Poisson distribution.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Poisson distribution. This value has to be greater than 0.	`1.0`

Raises:

Type	Description
`ValueError`	if `rate` is not a positive number.

Example usage:

>>> from startorch.tensor import RandPoisson
>>> generator = RandPoisson(rate=1.0)
>>> generator
RandPoissonTensorGenerator(rate=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`float`	The location/median of the Cauchy distribution.	`0.0`
`scale`	`float`	The scale of the distribution.	`1.0`
`min_value`	`float`	The minimum value (included).	`-2.0`
`max_value`	`float`	The maximum value (excluded).	`2.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.
`ValueError`	if `max_value` is lower than `min_value`.

Example usage:

>>> from startorch.tensor import RandTruncCauchy
>>> generator = RandTruncCauchy(loc=0.0, scale=1.0, min_value=-1.0, max_value=1.0)
>>> generator
RandTruncCauchyTensorGenerator(loc=0.0, scale=1.0, min_value=-1.0, max_value=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`float`	The location/median of the Cauchy distribution.	`0.0`
`scale`	`float`	The scale of the distribution.	`1.0`
`min_value`	`float`	The minimum value (included).	`-2.0`
`max_value`	`float`	The maximum value (excluded).	`2.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.
`ValueError`	if `max_value` is lower than `min_value`.

Example usage:

>>> from startorch.tensor import RandTruncCauchy
>>> generator = RandTruncCauchy(loc=0.0, scale=1.0, min_value=-1.0, max_value=1.0)
>>> generator
RandTruncCauchyTensorGenerator(loc=0.0, scale=1.0, min_value=-1.0, max_value=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncExponential ¶

Bases: BaseTensorGenerator

Implement a class to generate sequences by sampling values from a truncated Exponential distribution.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Exponential distribution.	`1.0`
`max_value`	`float`	The maximum value.	`5.0`

Raises:

Type	Description
`ValueError`	if `rate` is not a positive number.
`ValueError`	if `max_value` is not a positive number.

Example usage:

>>> from startorch.tensor import RandTruncExponential
>>> generator = RandTruncExponential(rate=1.0, max_value=3.0)
>>> generator
RandTruncExponentialTensorGenerator(rate=1.0, max_value=3.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncExponentialTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate sequences by sampling values from a truncated Exponential distribution.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Exponential distribution.	`1.0`
`max_value`	`float`	The maximum value.	`5.0`

Raises:

Type	Description
`ValueError`	if `rate` is not a positive number.
`ValueError`	if `max_value` is not a positive number.

Example usage:

>>> from startorch.tensor import RandTruncExponential
>>> generator = RandTruncExponential(rate=1.0, max_value=3.0)
>>> generator
RandTruncExponentialTensorGenerator(rate=1.0, max_value=3.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncHalfCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`float`	The scale of the distribution.	`1.0`
`max_value`	`float`	The maximum value.	`4.0`

Raises:

Type	Description
`ValueError`	if `scale` is not a positive number.
`ValueError`	if `max_value` is not a positive number.

Example usage:

>>> from startorch.tensor import RandTruncHalfCauchy
>>> generator = RandTruncHalfCauchy(scale=1.0, max_value=5.0)
>>> generator
RandTruncHalfCauchyTensorGenerator(scale=1.0, max_value=5.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncHalfCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`float`	The scale of the distribution.	`1.0`
`max_value`	`float`	The maximum value.	`4.0`

Raises:

Type	Description
`ValueError`	if `scale` is not a positive number.
`ValueError`	if `max_value` is not a positive number.

Example usage:

>>> from startorch.tensor import RandTruncHalfCauchy
>>> generator = RandTruncHalfCauchy(scale=1.0, max_value=5.0)
>>> generator
RandTruncHalfCauchyTensorGenerator(scale=1.0, max_value=5.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncHalfNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`float`	The std of the distribution.	`1.0`
`max_value`	`float`	The maximum value.	`3.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.
`ValueError`	if `max_value` is not a positive number.

Example usage:

>>> from startorch.tensor import RandTruncHalfNormal
>>> generator = RandTruncHalfNormal(std=1.0, max_value=1.0)
>>> generator
RandTruncHalfNormalTensorGenerator(std=1.0, max_value=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandTruncHalfNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`float`	The std of the distribution.	`1.0`
`max_value`	`float`	The maximum value.	`3.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.
`ValueError`	if `max_value` is not a positive number.

Example usage:

>>> from startorch.tensor import RandTruncHalfNormal
>>> generator = RandTruncHalfNormal(std=1.0, max_value=1.0)
>>> generator
RandTruncHalfNormalTensorGenerator(std=1.0, max_value=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandTruncLogNormal ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate cyclic tensors by sampling values from a truncated log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the log-Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the log-Normal distribution.	`1.0`
`min_value`	`float`	The minimum value.	`0.0`
`max_value`	`float`	The maximum value.	`5.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.
`ValueError`	if `max_value` is lower than `min_value`.

Example usage:

>>> from startorch.tensor import RandTruncLogNormal
>>> generator = RandTruncLogNormal(mean=0.0, std=1.0, min_value=0.0, max_value=1.0)
>>> generator
RandTruncLogNormalTensorGenerator(mean=0.0, std=1.0, min_value=0.0, max_value=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandTruncLogNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator to generate cyclic tensors by sampling values from a truncated log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the log-Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the log-Normal distribution.	`1.0`
`min_value`	`float`	The minimum value.	`0.0`
`max_value`	`float`	The maximum value.	`5.0`

Raises:

Type	Description
`ValueError`	if `std` is not a positive number.
`ValueError`	if `max_value` is lower than `min_value`.

Example usage:

>>> from startorch.tensor import RandTruncLogNormal
>>> generator = RandTruncLogNormal(mean=0.0, std=1.0, min_value=0.0, max_value=1.0)
>>> generator
RandTruncLogNormalTensorGenerator(mean=0.0, std=1.0, min_value=0.0, max_value=1.0)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.RandTruncNormal ¶

Bases: BaseTensorGenerator

Implement a sequence generator to generate cyclic sequences by sampling values from a truncated Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the Normal distribution.	`1.0`
`min_value`	`float`	The minimum value.	`-3.0`
`max_value`	`float`	The maximum value.	`3.0`

Raises:

Type	Description
`ValueError`	if `std` is not a postive number.
`ValueError`	if `max_value` is lower than `min_value`.

Example usage:

>>> from startorch.tensor import RandTruncNormal
>>> generator = RandTruncNormal(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0)
>>> generator
RandTruncNormalTensorGenerator(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandTruncNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a sequence generator to generate cyclic sequences by sampling values from a truncated Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`float`	The mean of the Normal distribution.	`0.0`
`std`	`float`	The standard deviation of the Normal distribution.	`1.0`
`min_value`	`float`	The minimum value.	`-3.0`
`max_value`	`float`	The maximum value.	`3.0`

Raises:

Type	Description
`ValueError`	if `std` is not a postive number.
`ValueError`	if `max_value` is lower than `min_value`.

Example usage:

>>> from startorch.tensor import RandTruncNormal
>>> generator = RandTruncNormal(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0)
>>> generator
RandTruncNormalTensorGenerator(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandUniform ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling values from a uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`float`	The minimum value (inclusive).	`0.0`
`high`	`float`	The maximum value (exclusive).	`1.0`

Example usage:

>>> from startorch.tensor import RandUniform
>>> generator = RandUniform(low=0, high=10)
>>> generator
RandUniformTensorGenerator(low=0.0, high=10.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.RandUniformTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling values from a uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`float`	The minimum value (inclusive).	`0.0`
`high`	`float`	The maximum value (exclusive).	`1.0`

Example usage:

>>> from startorch.tensor import RandUniform
>>> generator = RandUniform(low=0, high=10)
>>> generator
RandUniformTensorGenerator(low=0.0, high=10.0)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Sinh ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the hyperbolic sine (sinh) of each value.

Example usage:

>>> from startorch.tensor import RandUniform, Sinh
>>> generator = Sinh(RandUniform(low=0.0, high=1.0))
>>> generator
SinhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.SinhTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the hyperbolic sine (sinh) of each value.

Example usage:

>>> from startorch.tensor import RandUniform, Sinh
>>> generator = Sinh(RandUniform(low=0.0, high=1.0))
>>> generator
SinhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Sqrt ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the squared root of a tensor.

This tensor generator is equivalent to: output = sqrt(tensor)

Example usage:

>>> from startorch.tensor import RandUniform, Sqrt
>>> generator = Sqrt(RandUniform(low=1.0, high=100.0))
>>> generator
SqrtTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.SqrtTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the squared root of a tensor.

This tensor generator is equivalent to: output = sqrt(tensor)

Example usage:

>>> from startorch.tensor import RandUniform, Sqrt
>>> generator = Sqrt(RandUniform(low=1.0, high=100.0))
>>> generator
SqrtTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Sub ¶

Bases: BaseTensorGenerator

Implement a tensor generator that subtracts two tensors.

This tensor generator is equivalent to: output = tensor_1 - tensor_2

Parameters:

Name	Type	Description	Default
`tensor1`	`BaseTensorGenerator \| dict`	The first tensor generator or its configuration.	required
`tensor2`	`BaseTensorGenerator \| dict`	The second tensor generator or its configuration.	required

Example usage:

>>> from startorch.tensor import RandNormal, RandUniform, Sub
>>> generator = Sub(RandUniform(), RandNormal())
>>> generator
SubTensorGenerator(
  (tensor1): RandUniformTensorGenerator(low=0.0, high=1.0)
  (tensor2): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.SubTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator that subtracts two tensors.

This tensor generator is equivalent to: output = tensor_1 - tensor_2

Parameters:

Name	Type	Description	Default
`tensor1`	`BaseTensorGenerator \| dict`	The first tensor generator or its configuration.	required
`tensor2`	`BaseTensorGenerator \| dict`	The second tensor generator or its configuration.	required

Example usage:

>>> from startorch.tensor import RandNormal, RandUniform, Sub
>>> generator = Sub(RandUniform(), RandNormal())
>>> generator
SubTensorGenerator(
  (tensor1): RandUniformTensorGenerator(low=0.0, high=1.0)
  (tensor2): RandNormalTensorGenerator(mean=0.0, std=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Tanh ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the hyperbolic tangent (tanh) of each value.

Example usage:

>>> from startorch.tensor import RandUniform, Tanh
>>> generator = Tanh(RandUniform(low=0.0, high=1.0))
>>> generator
TanhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TanhTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that computes the hyperbolic tangent (tanh) of each value.

Example usage:

>>> from startorch.tensor import RandUniform, Tanh
>>> generator = Tanh(RandUniform(low=0.0, high=1.0))
>>> generator
TanhTensorGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TransformTensorGenerator ¶

Bases: BaseWrapperTensorGenerator

Implement a tensor generator that generates a tensor and then transform it.

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	The tensor generator or its configuration.	required
`transformer`	`BaseTensorTransformer \| dict`	The tensor transformer or its configuration.	required

Example usage:

>>> from startorch.tensor import TransformTensorGenerator, Full
>>> from startorch.tensor.transformer import Abs
>>> generator = TransformTensorGenerator(generator=Full(-1), transformer=Abs())
>>> generator
TransformTensorGenerator(
  (generator): FullTensorGenerator(value=-1, dtype=None)
  (transformer): AbsTensorTransformer()
)
>>> generator.generate(size=(2, 6))
tensor([[1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1]])

startorch.tensor.TruncCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the location.	required
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required
`min_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (included).	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncCauchy
>>> generator = TruncCauchy(
...     loc=RandUniform(low=-1.0, high=1.0),
...     scale=RandUniform(low=1.0, high=2.0),
...     min_value=RandUniform(low=-10.0, high=-5.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncCauchyTensorGenerator(
  (loc): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
  (min_value): RandUniformTensorGenerator(low=-10.0, high=-5.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a Cauchy distribution.

Parameters:

Name	Type	Description	Default
`loc`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the location.	required
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required
`min_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (included).	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncCauchy
>>> generator = TruncCauchy(
...     loc=RandUniform(low=-1.0, high=1.0),
...     scale=RandUniform(low=1.0, high=2.0),
...     min_value=RandUniform(low=-10.0, high=-5.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncCauchyTensorGenerator(
  (loc): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
  (min_value): RandUniformTensorGenerator(low=-10.0, high=-5.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncExponential ¶

Bases: BaseTensorGenerator

Implement a class to generate sequence by sampling values from an Exponential distribution.

Parameters:

Name	Type	Description	Default
`rate`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the rate.	required
`max_value`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncExponential
>>> generator = TruncExponential(
...     rate=RandUniform(low=1.0, high=10.0),
...     max_value=RandUniform(low=1.0, high=100.0),
... )
>>> generator
TruncExponentialTensorGenerator(
  (rate): RandUniformTensorGenerator(low=1.0, high=10.0)
  (max_value): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncExponentialTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate sequence by sampling values from an Exponential distribution.

Parameters:

Name	Type	Description	Default
`rate`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the rate.	required
`max_value`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncExponential
>>> generator = TruncExponential(
...     rate=RandUniform(low=1.0, high=10.0),
...     max_value=RandUniform(low=1.0, high=100.0),
... )
>>> generator
TruncExponentialTensorGenerator(
  (rate): RandUniformTensorGenerator(low=1.0, high=10.0)
  (max_value): RandUniformTensorGenerator(low=1.0, high=100.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncHalfCauchy ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncHalfCauchy
>>> generator = TruncHalfCauchy(
...     scale=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfCauchyTensorGenerator(
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncHalfCauchyTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Cauchy distribution.

Parameters:

Name	Type	Description	Default
`scale`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the scale.	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncHalfCauchy
>>> generator = TruncHalfCauchy(
...     scale=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfCauchyTensorGenerator(
  (scale): RandUniformTensorGenerator(low=1.0, high=2.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncHalfNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the std.	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncHalfNormal
>>> generator = TruncHalfNormal(
...     std=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfNormalTensorGenerator(
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.TruncHalfNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a half-Normal distribution.

Parameters:

Name	Type	Description	Default
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the std.	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncHalfNormal
>>> generator = TruncHalfNormal(
...     std=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfNormalTensorGenerator(
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.TruncLogNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the mean of the underlying Normal distribution.	required
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation of the underlying Normal distribution.	required
`min_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (included).	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncLogNormal
>>> generator = TruncLogNormal(
...     mean=RandUniform(low=-1.0, high=1.0),
...     std=RandUniform(low=1.0, high=2.0),
...     min_value=RandUniform(low=0.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncLogNormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
  (min_value): RandUniformTensorGenerator(low=0.0, high=2.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.TruncLogNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensor by sampling values from a truncated log-Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the mean of the underlying Normal distribution.	required
`std`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the standard deviation of the underlying Normal distribution.	required
`min_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (included).	required
`max_value`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncLogNormal
>>> generator = TruncLogNormal(
...     mean=RandUniform(low=-1.0, high=1.0),
...     std=RandUniform(low=1.0, high=2.0),
...     min_value=RandUniform(low=0.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncLogNormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
  (min_value): RandUniformTensorGenerator(low=0.0, high=2.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate(size=(2, 6))
tensor([[...]])

startorch.tensor.TruncNormal ¶

Bases: BaseTensorGenerator

Implement a class to generate sequence by sampling values from a truncated Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the mean.	required
`std`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the standard deviation.	required
`min_value`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the minimum value (included).	required
`max_value`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncNormal
>>> generator = TruncNormal(
...     mean=RandUniform(low=-1.0, high=1.0),
...     std=RandUniform(low=1.0, high=2.0),
...     min_value=RandUniform(low=-10.0, high=-5.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncNormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
  (min_value): RandUniformTensorGenerator(low=-10.0, high=-5.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.TruncNormalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate sequence by sampling values from a truncated Normal distribution.

Parameters:

Name	Type	Description	Default
`mean`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the mean.	required
`std`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the standard deviation.	required
`min_value`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the minimum value (included).	required
`max_value`	`BaseTensorGenerator \| dict`	A sequence generator (or its configuration) to generate the maximum value (excluded).	required

Example usage:

>>> from startorch.tensor import RandUniform, TruncNormal
>>> generator = TruncNormal(
...     mean=RandUniform(low=-1.0, high=1.0),
...     std=RandUniform(low=1.0, high=2.0),
...     min_value=RandUniform(low=-10.0, high=-5.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncNormalTensorGenerator(
  (mean): RandUniformTensorGenerator(low=-1.0, high=1.0)
  (std): RandUniformTensorGenerator(low=1.0, high=2.0)
  (min_value): RandUniformTensorGenerator(low=-10.0, high=-5.0)
  (max_value): RandUniformTensorGenerator(low=5.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.Uniform ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling values from a uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (inclusive).	required
`high`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandUniform, Uniform
>>> generator = UniformTensorGenerator(
...     low=RandUniform(low=0, high=2), high=RandUniform(low=8, high=10)
... )
>>> generator
UniformTensorGenerator(
  (low): RandUniformTensorGenerator(low=0.0, high=2.0)
  (high): RandUniformTensorGenerator(low=8.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.UniformCategorical ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors of uniformly distributed categorical variables.

All the categories have the same probability.

Note: it is a more efficient implementation of Multinomial.generate_uniform_weights.

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required

Raises:

Type	Description
`ValueError`	if `num_categories` is negative.

Example usage:

>>> import torch
>>> from startorch.tensor import UniformCategorical
>>> generator = UniformCategorical(10)
>>> generator
UniformCategoricalTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.UniformCategoricalTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a class to generate tensors of uniformly distributed categorical variables.

All the categories have the same probability.

Note: it is a more efficient implementation of Multinomial.generate_uniform_weights.

Parameters:

Name	Type	Description	Default
`num_categories`	`int`	The number of categories.	required

Raises:

Type	Description
`ValueError`	if `num_categories` is negative.

Example usage:

>>> import torch
>>> from startorch.tensor import UniformCategorical
>>> generator = UniformCategorical(10)
>>> generator
UniformCategoricalTensorGenerator(num_categories=10)
>>> generator.generate(size=(4, 12))
tensor([[...]])

startorch.tensor.UniformTensorGenerator ¶

Bases: BaseTensorGenerator

Implement a tensor generator by sampling values from a uniform distribution.

Parameters:

Name	Type	Description	Default
`low`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the minimum value (inclusive).	required
`high`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) to generate the maximum value (exclusive).	required

Example usage:

>>> from startorch.tensor import RandUniform, Uniform
>>> generator = UniformTensorGenerator(
...     low=RandUniform(low=0, high=2), high=RandUniform(low=8, high=10)
... )
>>> generator
UniformTensorGenerator(
  (low): RandUniformTensorGenerator(low=0.0, high=2.0)
  (high): RandUniformTensorGenerator(low=8.0, high=10.0)
)
>>> generator.generate((2, 6))
tensor([[...]])

startorch.tensor.is_tensor_generator_config ¶

is_tensor_generator_config(config: dict) -> bool

Indicate if the input configuration is a configuration for a BaseTensorGenerator.

This function only checks if the value of the key _target_ is valid. It does not check the other values. If _target_ indicates a function, the returned type hint is used to check the class.

Parameters:

Name	Type	Description	Default
`config`	`dict`	The configuration to check.	required

Returns:

Type	Description
`bool`	`True` if the input configuration is a configuration for a `BaseTensorGenerator` object.

Example usage:

>>> from startorch.tensor import is_tensor_generator_config
>>> is_tensor_generator_config({"_target_": "startorch.tensor.RandUniform"})
True

startorch.tensor.setup_tensor_generator ¶

setup_tensor_generator(
    generator: BaseTensorGenerator | dict,
) -> BaseTensorGenerator

Set up a tensor generator.

The tensor generator is instantiated from its configuration by using the BaseTensorGenerator factory function.

Parameters:

Name	Type	Description	Default
`generator`	`BaseTensorGenerator \| dict`	A tensor generator or its configuration.	required

Returns:

Type	Description
`BaseTensorGenerator`	A tensor generator.

Example usage:

>>> from startorch.tensor import setup_tensor_generator
>>> setup_tensor_generator({"_target_": "startorch.tensor.RandUniform"})
RandUniformTensorGenerator(low=0.0, high=1.0)

tensor

startorch.tensor ¶

startorch.tensor.Abs ¶

startorch.tensor.AbsTensorGenerator ¶

startorch.tensor.Acosh ¶

startorch.tensor.AcoshTensorGenerator ¶

startorch.tensor.Add ¶

startorch.tensor.AddScalar ¶

startorch.tensor.AddScalarTensorGenerator ¶

startorch.tensor.AddTensorGenerator ¶

startorch.tensor.Asinh ¶

startorch.tensor.AsinhTensorGenerator ¶

startorch.tensor.AsinhUniform ¶

startorch.tensor.AsinhUniformTensorGenerator ¶

startorch.tensor.Atanh ¶

startorch.tensor.AtanhTensorGenerator ¶

startorch.tensor.BaseTensorGenerator ¶

startorch.tensor.BaseTensorGenerator.generate abstractmethod ¶

startorch.tensor.BaseWrapperTensorGenerator ¶

startorch.tensor.Cauchy ¶

startorch.tensor.CauchyTensorGenerator ¶

startorch.tensor.Clamp ¶

startorch.tensor.ClampTensorGenerator ¶

startorch.tensor.Cosh ¶

startorch.tensor.CoshTensorGenerator ¶

startorch.tensor.Div ¶

startorch.tensor.DivTensorGenerator ¶

startorch.tensor.Exp ¶

startorch.tensor.ExpTensorGenerator ¶

startorch.tensor.Exponential ¶

startorch.tensor.ExponentialTensorGenerator ¶

startorch.tensor.Float ¶

startorch.tensor.FloatTensorGenerator ¶

startorch.tensor.Fmod ¶

startorch.tensor.FmodTensorGenerator ¶

startorch.tensor.Full ¶

startorch.tensor.FullTensorGenerator ¶

startorch.tensor.HalfCauchy ¶

startorch.tensor.HalfCauchyTensorGenerator ¶

startorch.tensor.HalfNormal ¶

startorch.tensor.HalfNormalTensorGenerator ¶

startorch.tensor.Log ¶

startorch.tensor.LogNormal ¶

startorch.tensor.LogNormalTensorGenerator ¶

startorch.tensor.LogTensorGenerator ¶

startorch.tensor.LogUniform ¶

startorch.tensor.LogUniformTensorGenerator ¶

startorch.tensor.Long ¶

startorch.tensor.LongTensorGenerator ¶

startorch.tensor.Mul ¶

startorch.tensor.MulScalar ¶

startorch.tensor.MulScalarTensorGenerator ¶

startorch.tensor.MulTensorGenerator ¶

startorch.tensor.Multinomial ¶

startorch.tensor.Multinomial.create_exp_weights classmethod ¶

startorch.tensor.Multinomial.create_linear_weights classmethod ¶

startorch.tensor.Multinomial.create_uniform_weights classmethod ¶

startorch.tensor.MultinomialChoice ¶

startorch.tensor.MultinomialChoiceTensorGenerator ¶

startorch.tensor.MultinomialTensorGenerator ¶

startorch.tensor.MultinomialTensorGenerator.create_exp_weights classmethod ¶

startorch.tensor.MultinomialTensorGenerator.create_linear_weights classmethod ¶

startorch.tensor.MultinomialTensorGenerator.create_uniform_weights classmethod ¶

startorch.tensor.Neg ¶

startorch.tensor.NegTensorGenerator ¶

startorch.tensor.Normal ¶

startorch.tensor.NormalTensorGenerator ¶

startorch.tensor.Poisson ¶

startorch.tensor.PoissonTensorGenerator ¶

startorch.tensor.RandAsinhUniform ¶

startorch.tensor.RandAsinhUniformTensorGenerator ¶

startorch.tensor.RandCauchy ¶

startorch.tensor.RandCauchyTensorGenerator ¶

startorch.tensor.RandExponential ¶

startorch.tensor.RandExponentialTensorGenerator ¶

startorch.tensor.RandHalfCauchy ¶

startorch.tensor.RandHalfCauchyTensorGenerator ¶

startorch.tensor.RandHalfNormal ¶

startorch.tensor.RandHalfNormalTensorGenerator ¶

startorch.tensor.RandInt ¶

startorch.tensor.BaseTensorGenerator.generate `abstractmethod` ¶

startorch.tensor.Multinomial.create_exp_weights `classmethod` ¶

startorch.tensor.Multinomial.create_linear_weights `classmethod` ¶

startorch.tensor.Multinomial.create_uniform_weights `classmethod` ¶

startorch.tensor.MultinomialTensorGenerator.create_exp_weights `classmethod` ¶

startorch.tensor.MultinomialTensorGenerator.create_linear_weights `classmethod` ¶

startorch.tensor.MultinomialTensorGenerator.create_uniform_weights `classmethod` ¶