sequence

startorch.sequence ¶

Contain sequence generators.

startorch.sequence.Abs ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the absolute value of a generated sequence.

Example usage:

>>> import torch
>>> from startorch.sequence import Abs, RandNormal
>>> generator = Abs(RandNormal())
>>> generator
AbsSequenceGenerator(
  (sequence): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AbsSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the absolute value of a generated sequence.

Example usage:

>>> import torch
>>> from startorch.sequence import Abs, RandNormal
>>> generator = Abs(RandNormal())
>>> generator
AbsSequenceGenerator(
  (sequence): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Acosh ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Acosh, RandUniform
>>> generator = Acosh(RandUniform())
>>> generator
AcoshSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AcoshSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Acosh, RandUniform
>>> generator = Acosh(RandUniform())
>>> generator
AcoshSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Add ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that adds multiple sequences.

sequence = sequence_1 + sequence_2 + ... + sequence_n

Parameters:

Name	Type	Description	Default
`sequences`	`Sequence[BaseSequenceGenerator \| dict]`	The sequence generators or their configuration.	required

Raises:

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

Example usage:

>>> import torch
>>> from startorch.sequence import Add, RandUniform, RandNormal
>>> generator = Add([RandUniform(), RandNormal()])
>>> generator
AddSequenceGenerator(
  (0): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (1): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AddScalar ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that adds a scalar value to a generated batch of sequences.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import AddScalar, RandUniform, RandNormal
>>> generator = AddScalar(RandUniform(), 42.0)
>>> generator
AddScalarSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (value): 42.0
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AddScalarSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that adds a scalar value to a generated batch of sequences.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import AddScalar, RandUniform, RandNormal
>>> generator = AddScalar(RandUniform(), 42.0)
>>> generator
AddScalarSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (value): 42.0
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AddSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that adds multiple sequences.

sequence = sequence_1 + sequence_2 + ... + sequence_n

Parameters:

Name	Type	Description	Default
`sequences`	`Sequence[BaseSequenceGenerator \| dict]`	The sequence generators or their configuration.	required

Raises:

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

Example usage:

>>> import torch
>>> from startorch.sequence import Add, RandUniform, RandNormal
>>> generator = Add([RandUniform(), RandNormal()])
>>> generator
AddSequenceGenerator(
  (0): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (1): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Arange ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence of consecutive integer values between 0 and seq_len-1.

Parameters:

Name	Type	Description	Default
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Example usage:

>>> from startorch.sequence import Arange
>>> generator = Arange(feature_size=())
>>> generator
ArangeSequenceGenerator(feature_size=())
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[0, 1, 2, 3, 4, 5],
        [0, 1, 2, 3, 4, 5]])

startorch.sequence.ArangeSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence of consecutive integer values between 0 and seq_len-1.

Parameters:

Name	Type	Description	Default
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Example usage:

>>> from startorch.sequence import Arange
>>> generator = Arange(feature_size=())
>>> generator
ArangeSequenceGenerator(feature_size=())
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[0, 1, 2, 3, 4, 5],
        [0, 1, 2, 3, 4, 5]])

startorch.sequence.Asinh ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Asinh, RandUniform
>>> generator = Asinh(RandUniform())
>>> generator
AsinhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AsinhSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Asinh, RandUniform
>>> generator = Asinh(RandUniform())
>>> generator
AsinhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AsinhUniform ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences by sampling values from an asinh-uniform distribution.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import AsinhUniform, RandUniform
>>> generator = AsinhUniform(low=RandUniform(-1.0, 0.0), high=RandUniform(0.0, 1.0))
>>> generator
AsinhUniformSequenceGenerator(
  (low): RandUniformSequenceGenerator(low=-1.0, high=0.0, feature_size=(1,))
  (high): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AsinhUniformSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences by sampling values from an asinh-uniform distribution.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import AsinhUniform, RandUniform
>>> generator = AsinhUniform(low=RandUniform(-1.0, 0.0), high=RandUniform(0.0, 1.0))
>>> generator
AsinhUniformSequenceGenerator(
  (low): RandUniformSequenceGenerator(low=-1.0, high=0.0, feature_size=(1,))
  (high): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Atanh ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Atanh, RandUniform
>>> generator = Atanh(RandUniform())
>>> generator
AtanhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AtanhSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Atanh, RandUniform
>>> generator = Atanh(RandUniform())
>>> generator
AtanhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AutoRegressive ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence by sampling values from an autoregressive process.

Parameters:

Name	Type	Description	Default
`value`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) used to generate the initial sequence values. These values are used to start the AR.	required
`coefficient`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) used to generate the coefficients.	required
`noise`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) used to generate the noise values.	required
`order`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) used to generate the order of the AR.	required
`max_abs_value`	`float`	The maximum absolute value. This argument ensures the values stay in the range `[-max_abs_value, max_abs_value]`.	required
`warmup`	`int`	The number of cycles used to initiate the AR. The initial value sampled do not follow an AR, so using warmup allows to initialize the AR so each value follows an AR.	`10`

Raises:

Type	Description
`ValueError`	if `max_abs_value` is not a positive number.
`ValueError`	if `warmup` is not a positive number.

Example usage:

>>> import torch
>>> from startorch.sequence import AutoRegressive, RandUniform, RandNormal, Full
>>> from startorch.tensor import RandInt
>>> generator = AutoRegressive(
...     value=RandNormal(),
...     coefficient=RandUniform(low=-1.0, high=1.0),
...     noise=Full(0.0),
...     order=RandInt(low=1, high=6),
...     max_abs_value=100.0,
... )
>>> generator
AutoRegressiveSequenceGenerator(
  (value): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (coefficient): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (noise): FullSequenceGenerator(value=0.0, feature_size=(1,))
  (order): RandIntTensorGenerator(low=1, high=6)
  (max_abs_value): 100.0
  (warmup): 10
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.AutoRegressiveSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence by sampling values from an autoregressive process.

Parameters:

Name	Type	Description	Default
`value`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) used to generate the initial sequence values. These values are used to start the AR.	required
`coefficient`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) used to generate the coefficients.	required
`noise`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) used to generate the noise values.	required
`order`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration) used to generate the order of the AR.	required
`max_abs_value`	`float`	The maximum absolute value. This argument ensures the values stay in the range `[-max_abs_value, max_abs_value]`.	required
`warmup`	`int`	The number of cycles used to initiate the AR. The initial value sampled do not follow an AR, so using warmup allows to initialize the AR so each value follows an AR.	`10`

Raises:

Type	Description
`ValueError`	if `max_abs_value` is not a positive number.
`ValueError`	if `warmup` is not a positive number.

Example usage:

>>> import torch
>>> from startorch.sequence import AutoRegressive, RandUniform, RandNormal, Full
>>> from startorch.tensor import RandInt
>>> generator = AutoRegressive(
...     value=RandNormal(),
...     coefficient=RandUniform(low=-1.0, high=1.0),
...     noise=Full(0.0),
...     order=RandInt(low=1, high=6),
...     max_abs_value=100.0,
... )
>>> generator
AutoRegressiveSequenceGenerator(
  (value): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (coefficient): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (noise): FullSequenceGenerator(value=0.0, feature_size=(1,))
  (order): RandIntTensorGenerator(low=1, high=6)
  (max_abs_value): 100.0
  (warmup): 10
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.BaseSequenceGenerator ¶

Bases: ABC

Define the base class to generate sequences.

A child class has to implement the generate method.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform
>>> generator = RandUniform()
>>> generator
RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.BaseSequenceGenerator.generate `abstractmethod` ¶

generate(
    seq_len: int,
    batch_size: int = 1,
    rng: Generator | None = None,
) -> Tensor

Generate a batch of sequences.

All the sequences in the batch must have the same length.

Parameters:

Name	Type	Description	Default
`seq_len`	`int`	The sequence length.	required
`batch_size`	`int`	The batch size.	`1`
`rng`	`Generator \| None`	An optional random number generator.	`None`

Returns:

Type	Description
`Tensor`	A batch of sequences. The data in the batch are represented as a `torch.Tensor` of shape `(batch_size, sequence_length, )` where `` means any number of dimensions.

Example usage:

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

startorch.sequence.BaseWrapperSequenceGenerator ¶

Bases: BaseSequenceGenerator

Define a base class to easily wrap a sequence generator.

Note

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

Parameters:

Name	Type	Description	Default
`generator`	`BaseSequenceGenerator \| dict`	The sequence generator or its configuration.	required

startorch.sequence.Cat2 ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that concatenate two sequences along the sequence dimension.

ouput = [sequence1, sequence2]

Parameters:

Name	Type	Description	Default
`generator1`	`BaseSequenceGenerator \| dict`	The first sequence generator or its configuration.	required
`generator2`	`BaseSequenceGenerator \| dict`	The second sequence generator or its configuration.	required
`changepoint`	`BaseTensorGenerator \| dict`	The change point generator or its configuration.	required

Example usage:

>>> import torch
>>> from startorch.sequence import Cat2, RandUniform, RandNormal
>>> from startorch.tensor import RandInt
>>> generator = Cat2(
...     generator1=RandUniform(), generator2=RandNormal(), changepoint=RandInt(0, 12)
... )
>>> generator
Cat2SequenceGenerator(
  (generator1): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (generator2): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (changepoint): RandIntTensorGenerator(low=0, high=12)
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Cat2SequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that concatenate two sequences along the sequence dimension.

ouput = [sequence1, sequence2]

Parameters:

Name	Type	Description	Default
`generator1`	`BaseSequenceGenerator \| dict`	The first sequence generator or its configuration.	required
`generator2`	`BaseSequenceGenerator \| dict`	The second sequence generator or its configuration.	required
`changepoint`	`BaseTensorGenerator \| dict`	The change point generator or its configuration.	required

Example usage:

>>> import torch
>>> from startorch.sequence import Cat2, RandUniform, RandNormal
>>> from startorch.tensor import RandInt
>>> generator = Cat2(
...     generator1=RandUniform(), generator2=RandNormal(), changepoint=RandInt(0, 12)
... )
>>> generator
Cat2SequenceGenerator(
  (generator1): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (generator2): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (changepoint): RandIntTensorGenerator(low=0, high=12)
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Cauchy ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import Cauchy, RandUniform
>>> generator = Cauchy(
...     loc=RandUniform(low=-1.0, high=1.0),
...     scale=RandUniform(low=1.0, high=2.0),
... )
>>> generator
CauchySequenceGenerator(
  (loc): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.CauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import Cauchy, RandUniform
>>> generator = Cauchy(
...     loc=RandUniform(low=-1.0, high=1.0),
...     scale=RandUniform(low=1.0, high=2.0),
... )
>>> generator
CauchySequenceGenerator(
  (loc): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Clamp ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator to generate a batch of sequences where the values are clamped.

Note: min_value and max_value cannot be both None.

Parameters:

Name	Type	Description	Default
`generator`	`BaseSequenceGenerator \| dict`	The sequence generator or its configuration.	required
`min`	`float \| None`	The lower bound. If `min_value` is `None`, there is no lower bound.	required
`max`	`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:

>>> import torch
>>> from startorch.sequence import Clamp, RandNormal
>>> generator = Clamp(RandNormal(), -1.0, 1.0)
>>> generator
ClampSequenceGenerator(
  (sequence): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (min): -1.0
  (max): 1.0
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.ClampSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator to generate a batch of sequences where the values are clamped.

Note: min_value and max_value cannot be both None.

Parameters:

Name	Type	Description	Default
`generator`	`BaseSequenceGenerator \| dict`	The sequence generator or its configuration.	required
`min`	`float \| None`	The lower bound. If `min_value` is `None`, there is no lower bound.	required
`max`	`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:

>>> import torch
>>> from startorch.sequence import Clamp, RandNormal
>>> generator = Clamp(RandNormal(), -1.0, 1.0)
>>> generator
ClampSequenceGenerator(
  (sequence): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (min): -1.0
  (max): 1.0
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Constant ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator to generate a batch of sequences with constant values where the values for each sequence are sampled from another sequence generator.

Example usage:

>>> from startorch.sequence import Constant, RandUniform
>>> generator = Constant(RandUniform())
>>> generator
ConstantSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.ConstantSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator to generate a batch of sequences with constant values where the values for each sequence are sampled from another sequence generator.

Example usage:

>>> from startorch.sequence import Constant, RandUniform
>>> generator = Constant(RandUniform())
>>> generator
ConstantSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Cosh ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Cosh, RandUniform
>>> generator = Cosh(RandUniform())
>>> generator
CoshSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.CoshSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Cosh, RandUniform
>>> generator = Cosh(RandUniform())
>>> generator
CoshSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Cumsum ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the cumulative sum of a generated sequence.

Example usage:

>>> import torch
>>> from startorch.sequence import Cumsum, RandUniform
>>> generator = Cumsum(RandUniform())
>>> generator
CumsumSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.CumsumSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the cumulative sum of a generated sequence.

Example usage:

>>> import torch
>>> from startorch.sequence import Cumsum, RandUniform
>>> generator = Cumsum(RandUniform())
>>> generator
CumsumSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Div ¶

Bases: BaseSequenceGenerator

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

sequence = dividend / divisor (a.k.a. true division)

Parameters:

Name	Type	Description	Default
`dividend`	`BaseSequenceGenerator \| dict`	The dividend sequence generator or its configuration.	required
`divisor`	`BaseSequenceGenerator \| dict`	The divisor sequence 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:

>>> import torch
>>> from startorch.sequence import Div, RandUniform, RandNormal
>>> generator = Div(RandNormal(), RandUniform(1.0, 10.0))
>>> generator
DivSequenceGenerator(
  (dividend): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (divisor): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
  (rounding_mode): None
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.DivSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

sequence = dividend / divisor (a.k.a. true division)

Parameters:

Name	Type	Description	Default
`dividend`	`BaseSequenceGenerator \| dict`	The dividend sequence generator or its configuration.	required
`divisor`	`BaseSequenceGenerator \| dict`	The divisor sequence 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:

>>> import torch
>>> from startorch.sequence import Div, RandUniform, RandNormal
>>> generator = Div(RandNormal(), RandUniform(1.0, 10.0))
>>> generator
DivSequenceGenerator(
  (dividend): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
  (divisor): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
  (rounding_mode): None
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Exp ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the exponential of a batch of sequences.

Example usage:

>>> import torch
>>> from startorch.sequence import Exp, RandUniform, RandNormal
>>> generator = Exp(RandUniform())
>>> generator
ExpSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.ExpSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the exponential of a batch of sequences.

Example usage:

>>> import torch
>>> from startorch.sequence import Exp, RandUniform, RandNormal
>>> generator = Exp(RandUniform())
>>> generator
ExpSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Exponential ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`	`BaseSequenceGenerator \| dict`	The rate generator or its configuration. The rate generator should return valid rate values.	required

Example usage:

>>> from startorch.sequence import Exponential, RandUniform
>>> generator = Exponential(rate=RandUniform(low=1.0, high=10.0))
>>> generator
ExponentialSequenceGenerator(
  (rate): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Exponential.create_fixed_rate `classmethod` ¶

create_fixed_rate(
    rate: float = 1.0,
    feature_size: tuple[int, ...] | list[int] | int = 1,
) -> ExponentialSequenceGenerator

Implement a sequence generator where the values are sampled from an Exponential distribution with a fixed rate.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Exponential distribution.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Returns:

Type	Description
`ExponentialSequenceGenerator`	A sequence generator where the rates of the Exponential distribution are a fixed given value.

Example usage:

>>> from startorch.sequence import Exponential, RandUniform
>>> generator = Exponential.create_fixed_rate(rate=1.0)
>>> generator
ExponentialSequenceGenerator(
  (rate): FullSequenceGenerator(value=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Exponential.create_uniform_rate `classmethod` ¶

create_uniform_rate(
    min_rate: float = 0.01,
    max_rate: float = 1.0,
    feature_size: tuple[int, ...] | list[int] | int = 1,
) -> ExponentialSequenceGenerator

Implement a sequence generator where the rates of the Exponential distribution are sampled from a uniform distribution.

One rate is sampled per sequence.

Parameters:

Name	Type	Description	Default
`min_rate`	`float`	The minimum rate value.	`0.01`
`max_rate`	`float`	The maximum rate value.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Returns:

Type	Description
`ExponentialSequenceGenerator`	A sequence generator where the rates for each sequence are sampled from a uniform distribution.

Example usage:

>>> from startorch.sequence import Exponential, RandUniform
>>> generator = Exponential.create_uniform_rate(min_rate=0.1, max_rate=1.0)
>>> generator
ExponentialSequenceGenerator(
  (rate): ConstantSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=0.1, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.ExponentialSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`	`BaseSequenceGenerator \| dict`	The rate generator or its configuration. The rate generator should return valid rate values.	required

Example usage:

>>> from startorch.sequence import Exponential, RandUniform
>>> generator = Exponential(rate=RandUniform(low=1.0, high=10.0))
>>> generator
ExponentialSequenceGenerator(
  (rate): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.ExponentialSequenceGenerator.create_fixed_rate `classmethod` ¶

create_fixed_rate(
    rate: float = 1.0,
    feature_size: tuple[int, ...] | list[int] | int = 1,
) -> ExponentialSequenceGenerator

Implement a sequence generator where the values are sampled from an Exponential distribution with a fixed rate.

Parameters:

Name	Type	Description	Default
`rate`	`float`	The rate of the Exponential distribution.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Returns:

Type	Description
`ExponentialSequenceGenerator`	A sequence generator where the rates of the Exponential distribution are a fixed given value.

Example usage:

>>> from startorch.sequence import Exponential, RandUniform
>>> generator = Exponential.create_fixed_rate(rate=1.0)
>>> generator
ExponentialSequenceGenerator(
  (rate): FullSequenceGenerator(value=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.ExponentialSequenceGenerator.create_uniform_rate `classmethod` ¶

create_uniform_rate(
    min_rate: float = 0.01,
    max_rate: float = 1.0,
    feature_size: tuple[int, ...] | list[int] | int = 1,
) -> ExponentialSequenceGenerator

Implement a sequence generator where the rates of the Exponential distribution are sampled from a uniform distribution.

One rate is sampled per sequence.

Parameters:

Name	Type	Description	Default
`min_rate`	`float`	The minimum rate value.	`0.01`
`max_rate`	`float`	The maximum rate value.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Returns:

Type	Description
`ExponentialSequenceGenerator`	A sequence generator where the rates for each sequence are sampled from a uniform distribution.

Example usage:

>>> from startorch.sequence import Exponential, RandUniform
>>> generator = Exponential.create_uniform_rate(min_rate=0.1, max_rate=1.0)
>>> generator
ExponentialSequenceGenerator(
  (rate): ConstantSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=0.1, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Float ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that converts a batch of sequences to float type.

Example usage:

>>> from startorch.sequence import Float, RandInt
>>> generator = Float(RandInt(low=0, high=10))
>>> generator
FloatSequenceGenerator(
  (sequence): RandIntSequenceGenerator(low=0, high=10, feature_size=())
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.FloatSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that converts a batch of sequences to float type.

Example usage:

>>> from startorch.sequence import Float, RandInt
>>> generator = Float(RandInt(low=0, high=10))
>>> generator
FloatSequenceGenerator(
  (sequence): RandIntSequenceGenerator(low=0, high=10, feature_size=())
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Fmod ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import Fmod, RandUniform
>>> generator = Fmod(dividend=RandUniform(low=-100, high=100), divisor=10.0)
>>> generator
FmodSequenceGenerator(
  (dividend): RandUniformSequenceGenerator(low=-100.0, high=100.0, feature_size=(1,))
  (divisor): 10.0
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])
>>> generator = Fmod(
...     dividend=RandUniform(low=-100, high=100), divisor=RandUniform(low=1, high=10)
... )
>>> generator
FmodSequenceGenerator(
  (dividend): RandUniformSequenceGenerator(low=-100.0, high=100.0, feature_size=(1,))
  (divisor): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.FmodSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import Fmod, RandUniform
>>> generator = Fmod(dividend=RandUniform(low=-100, high=100), divisor=10.0)
>>> generator
FmodSequenceGenerator(
  (dividend): RandUniformSequenceGenerator(low=-100.0, high=100.0, feature_size=(1,))
  (divisor): 10.0
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])
>>> generator = Fmod(
...     dividend=RandUniform(low=-100, high=100), divisor=RandUniform(low=1, high=10)
... )
>>> generator
FmodSequenceGenerator(
  (dividend): RandUniformSequenceGenerator(low=-100.0, high=100.0, feature_size=(1,))
  (divisor): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Full ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences filled with a given value.

This sequence generator is fully deterministic and the random seed has no effect.

Parameters:

Name	Type	Description	Default
`value`	`float`	The value.	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Example usage:

>>> from startorch.sequence import Full
>>> generator = Full(42.0)
>>> generator
FullSequenceGenerator(value=42.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[[42.],
         [42.],
         [42.],
         [42.],
         [42.],
         [42.]],
        [[42.],
         [42.],
         [42.],
         [42.],
         [42.],
         [42.]]])
>>> generator = Full(42, feature_size=())
>>> generator
FullSequenceGenerator(value=42, feature_size=())
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[42, 42, 42, 42, 42, 42],
        [42, 42, 42, 42, 42, 42]])

startorch.sequence.FullSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences filled with a given value.

This sequence generator is fully deterministic and the random seed has no effect.

Parameters:

Name	Type	Description	Default
`value`	`float`	The value.	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Example usage:

>>> from startorch.sequence import Full
>>> generator = Full(42.0)
>>> generator
FullSequenceGenerator(value=42.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[[42.],
         [42.],
         [42.],
         [42.],
         [42.],
         [42.]],
        [[42.],
         [42.],
         [42.],
         [42.],
         [42.],
         [42.]]])
>>> generator = Full(42, feature_size=())
>>> generator
FullSequenceGenerator(value=42, feature_size=())
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[42, 42, 42, 42, 42, 42],
        [42, 42, 42, 42, 42, 42]])

startorch.sequence.HalfCauchy ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import HalfCauchy, RandUniform
>>> generator = HalfCauchy(scale=RandUniform(low=1.0, high=2.0))
>>> generator
HalfCauchySequenceGenerator(
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.HalfCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import HalfCauchy, RandUniform
>>> generator = HalfCauchy(scale=RandUniform(low=1.0, high=2.0))
>>> generator
HalfCauchySequenceGenerator(
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.HalfNormal ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import HalfNormal, RandUniform
>>> generator = HalfNormal(std=RandUniform(low=1.0, high=2.0))
>>> generator
HalfNormalSequenceGenerator(
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.HalfNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import HalfNormal, RandUniform
>>> generator = HalfNormal(std=RandUniform(low=1.0, high=2.0))
>>> generator
HalfNormalSequenceGenerator(
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Linear ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence by sampling values with a linear pattern.

The sequences are generated by using the following formula:

output = slope * value + intercept

Parameters:

Name	Type	Description	Default
`value`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the sequence values. The linear transformation is applied on these values.	required
`slope`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the slope values.	required
`intercept`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the intercept values.	required

Example usage:

>>> from startorch.sequence import Linear, RandUniform
>>> generator = Linear(
...     value=RandUniform(low=-1.0, high=1.0),
...     slope=RandUniform(low=1.0, high=2.0),
...     intercept=RandUniform(low=-10.0, high=-5.0),
... )
>>> generator
LinearSequenceGenerator(
  (value): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (slope): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (intercept): RandUniformSequenceGenerator(low=-10.0, high=-5.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.LinearSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence by sampling values with a linear pattern.

The sequences are generated by using the following formula:

output = slope * value + intercept

Parameters:

Name	Type	Description	Default
`value`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the sequence values. The linear transformation is applied on these values.	required
`slope`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the slope values.	required
`intercept`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the intercept values.	required

Example usage:

>>> from startorch.sequence import Linear, RandUniform
>>> generator = Linear(
...     value=RandUniform(low=-1.0, high=1.0),
...     slope=RandUniform(low=1.0, high=2.0),
...     intercept=RandUniform(low=-10.0, high=-5.0),
... )
>>> generator
LinearSequenceGenerator(
  (value): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (slope): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (intercept): RandUniformSequenceGenerator(low=-10.0, high=-5.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Log ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the logarithm of a batch of sequences.

Example usage:

>>> import torch
>>> from startorch.sequence import Log, RandUniform, RandNormal
>>> generator = Log(RandUniform(1.0, 10.0))
>>> generator
LogSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.LogNormal ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import LogNormal, RandUniform
>>> generator = LogNormal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
LogNormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.LogNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import LogNormal, RandUniform
>>> generator = LogNormal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
LogNormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.LogSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the logarithm of a batch of sequences.

Example usage:

>>> import torch
>>> from startorch.sequence import Log, RandUniform, RandNormal
>>> generator = Log(RandUniform(1.0, 10.0))
>>> generator
LogSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.LogUniform ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences by sampling values from a log-uniform distribution.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import LogUniform, RandUniform
>>> generator = LogUniform(low=RandUniform(0.0, 1.0), high=RandUniform(5.0, 10.0))
>>> generator
LogUniformSequenceGenerator(
  (low): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (high): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.LogUniformSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences by sampling values from a log-uniform distribution.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import LogUniform, RandUniform
>>> generator = LogUniform(low=RandUniform(0.0, 1.0), high=RandUniform(5.0, 10.0))
>>> generator
LogUniformSequenceGenerator(
  (low): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (high): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Long ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that converts a batch of sequences to long type.

Example usage:

>>> from startorch.sequence import Long, RandUniform
>>> generator = Long(RandUniform(low=0, high=10))
>>> generator
LongSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.LongSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that converts a batch of sequences to long type.

Example usage:

>>> from startorch.sequence import Long, RandUniform
>>> generator = Long(RandUniform(low=0, high=10))
>>> generator
LongSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.MarkovChain ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate a batch of sequences where the data are generated by using a Markov chain/process.

Parameters:

Name	Type	Description	Default
`transition`	`Tensor`	The transition matrix of the Markov chain.	required
`init`	`Tensor \| None`	The initial probabilities. If `None`, the initial values are sampled with a uniform probability.	`None`

Example usage:

>>> import torch
>>> from startorch.sequence import MarkovChain
>>> generator = MarkovChain(transition=torch.rand(5, 5))
>>> generator
MarkovChainSequenceGenerator(transition=(5, 5), init=None)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.MarkovChain.create_from_generators `classmethod` ¶

create_from_generators(
    n: int,
    transition: BaseTransitionGenerator | dict,
    init: BaseTensorGenerator | dict | None = None,
    rng: Generator | None = None,
) -> MarkovChainSequenceGenerator

Create the Markov chain sequence generator where the transition matrix and initial probabilities are generated from generators.

Parameters:

Name	Type	Description	Default
`n`	`int`	The number of states in the Markov chain i.e. the size of the transition matrix.	required
`transition`	`BaseTransitionGenerator \| dict`	The transition matrix generator or its configuration.	required
`init`	`BaseTensorGenerator \| dict \| None`	The initial probabilities generator or its configuration.	`None`
`rng`	`Generator \| None`	An optional random number generator.	`None`

Returns:

Type	Description
`MarkovChainSequenceGenerator`	The instantiated Markov chain sequence generator.

Example usage:

>>> import torch
>>> from startorch.sequence import MarkovChain
>>> generator = MarkovChain.create_from_generators(
...     n=6,
...     transition={'_target_': 'startorch.transition.Diagonal'},
...     init={'_target_': 'startorch.tensor.RandUniform'},
... )
>>> generator
MarkovChainSequenceGenerator(transition=(6, 6), init=(6,))

startorch.sequence.MarkovChainSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate a batch of sequences where the data are generated by using a Markov chain/process.

Parameters:

Name	Type	Description	Default
`transition`	`Tensor`	The transition matrix of the Markov chain.	required
`init`	`Tensor \| None`	The initial probabilities. If `None`, the initial values are sampled with a uniform probability.	`None`

Example usage:

>>> import torch
>>> from startorch.sequence import MarkovChain
>>> generator = MarkovChain(transition=torch.rand(5, 5))
>>> generator
MarkovChainSequenceGenerator(transition=(5, 5), init=None)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.MarkovChainSequenceGenerator.create_from_generators `classmethod` ¶

create_from_generators(
    n: int,
    transition: BaseTransitionGenerator | dict,
    init: BaseTensorGenerator | dict | None = None,
    rng: Generator | None = None,
) -> MarkovChainSequenceGenerator

Create the Markov chain sequence generator where the transition matrix and initial probabilities are generated from generators.

Parameters:

Name	Type	Description	Default
`n`	`int`	The number of states in the Markov chain i.e. the size of the transition matrix.	required
`transition`	`BaseTransitionGenerator \| dict`	The transition matrix generator or its configuration.	required
`init`	`BaseTensorGenerator \| dict \| None`	The initial probabilities generator or its configuration.	`None`
`rng`	`Generator \| None`	An optional random number generator.	`None`

Returns:

Type	Description
`MarkovChainSequenceGenerator`	The instantiated Markov chain sequence generator.

Example usage:

>>> import torch
>>> from startorch.sequence import MarkovChain
>>> generator = MarkovChain.create_from_generators(
...     n=6,
...     transition={'_target_': 'startorch.transition.Diagonal'},
...     init={'_target_': 'startorch.tensor.RandUniform'},
... )
>>> generator
MarkovChainSequenceGenerator(transition=(6, 6), init=(6,))

startorch.sequence.Mul ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that multiplies multiple sequences.

sequence = sequence_1 * sequence_2 * ... * sequence_n

Parameters:

Name	Type	Description	Default
`sequences`	`Sequence[BaseSequenceGenerator \| dict]`	The sequence generators.	required

Raises:

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

Example usage:

>>> import torch
>>> from startorch.sequence import Mul, RandUniform, RandNormal
>>> generator = Mul([RandUniform(), RandNormal()])
>>> generator
MulSequenceGenerator(
  (0): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (1): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.MulScalar ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that multiplies a scalar value to a generated batch of sequences.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import MulScalar, RandUniform, RandNormal
>>> generator = MulScalar(RandUniform(), 2.0)
>>> generator
MulScalarSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (value): 2.0
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.MulScalarSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that multiplies a scalar value to a generated batch of sequences.

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import MulScalar, RandUniform, RandNormal
>>> generator = MulScalar(RandUniform(), 2.0)
>>> generator
MulScalarSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (value): 2.0
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.MulSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that multiplies multiple sequences.

sequence = sequence_1 * sequence_2 * ... * sequence_n

Parameters:

Name	Type	Description	Default
`sequences`	`Sequence[BaseSequenceGenerator \| dict]`	The sequence generators.	required

Raises:

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

Example usage:

>>> import torch
>>> from startorch.sequence import Mul, RandUniform, RandNormal
>>> generator = Mul([RandUniform(), RandNormal()])
>>> generator
MulSequenceGenerator(
  (0): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (1): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Multinomial ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequences 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. The weights have to be positive but do not need to sum to 1. The input is expected to be a `torch.Tensor` of shape `(num_categories,)` and type float.	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Example usage:

>>> import torch
>>> from startorch.sequence import Multinomial
>>> generator = Multinomial(weights=torch.ones(5))
>>> generator
MultinomialSequenceGenerator(num_categories=5, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Multinomial.create_exp_weights `classmethod` ¶

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

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
`MultinomialSequenceGenerator`	A sequence generator where the weights of the multinomial distribution follow an exponential pattern.

startorch.sequence.Multinomial.create_linear_weights `classmethod` ¶

create_linear_weights(
    num_categories: int,
) -> MultinomialSequenceGenerator

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
`MultinomialSequenceGenerator`	A sequence generator where the weights of the multinomial distribution follow a linear pattern.

startorch.sequence.Multinomial.create_uniform_weights `classmethod` ¶

create_uniform_weights(
    num_categories: int,
) -> MultinomialSequenceGenerator

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
`MultinomialSequenceGenerator`	A sequence generator where the weights of the multinomial distribution follow a uniform pattern.

startorch.sequence.MultinomialChoice ¶

Bases: BaseSequenceGenerator

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

This sequence generator is used to generate sequences with different generation processes. The user can specify a list of sequence generators with an associated weight. The weight is used to sample the sequence generator with a multinomial distribution. Higher weight means that the sequence 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 sequence generator
    or its configuration.
- an optional key ``'weight'`` with a float value which
    indicates the weight of the sequence generator.
    If this key is absent, the weight is set to ``1.0``.

Parameters:

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

Example usage:

>>> from startorch.sequence import MultinomialChoice, RandUniform, RandNormal
>>> generator = MultinomialChoice(
...     (
...         {"weight": 2.0, "generator": RandUniform()},
...         {"weight": 1.0, "generator": RandNormal()},
...     )
... )
>>> generator.generate(seq_len=10, batch_size=2)
tensor([[...]])

startorch.sequence.MultinomialChoiceSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

This sequence generator is used to generate sequences with different generation processes. The user can specify a list of sequence generators with an associated weight. The weight is used to sample the sequence generator with a multinomial distribution. Higher weight means that the sequence 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 sequence generator
    or its configuration.
- an optional key ``'weight'`` with a float value which
    indicates the weight of the sequence generator.
    If this key is absent, the weight is set to ``1.0``.

Parameters:

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

Example usage:

>>> from startorch.sequence import MultinomialChoice, RandUniform, RandNormal
>>> generator = MultinomialChoice(
...     (
...         {"weight": 2.0, "generator": RandUniform()},
...         {"weight": 1.0, "generator": RandNormal()},
...     )
... )
>>> generator.generate(seq_len=10, batch_size=2)
tensor([[...]])

startorch.sequence.MultinomialSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequences 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. The weights have to be positive but do not need to sum to 1. The input is expected to be a `torch.Tensor` of shape `(num_categories,)` and type float.	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Example usage:

>>> import torch
>>> from startorch.sequence import Multinomial
>>> generator = Multinomial(weights=torch.ones(5))
>>> generator
MultinomialSequenceGenerator(num_categories=5, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.MultinomialSequenceGenerator.create_exp_weights `classmethod` ¶

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

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
`MultinomialSequenceGenerator`	A sequence generator where the weights of the multinomial distribution follow an exponential pattern.

startorch.sequence.MultinomialSequenceGenerator.create_linear_weights `classmethod` ¶

create_linear_weights(
    num_categories: int,
) -> MultinomialSequenceGenerator

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
`MultinomialSequenceGenerator`	A sequence generator where the weights of the multinomial distribution follow a linear pattern.

startorch.sequence.MultinomialSequenceGenerator.create_uniform_weights `classmethod` ¶

create_uniform_weights(
    num_categories: int,
) -> MultinomialSequenceGenerator

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
`MultinomialSequenceGenerator`	A sequence generator where the weights of the multinomial distribution follow a uniform pattern.

startorch.sequence.Neg ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Neg, RandUniform, RandNormal
>>> generator = Neg(RandUniform())
>>> generator
NegSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.NegSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Neg, RandUniform, RandNormal
>>> generator = Neg(RandUniform())
>>> generator
NegSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Normal ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import Normal, RandUniform
>>> generator = Normal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
NormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.NormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import Normal, RandUniform
>>> generator = Normal(
...     mean=RandUniform(low=-1.0, high=1.0), std=RandUniform(low=1.0, high=2.0)
... )
>>> generator
NormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Periodic ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate periodic sequence from a regular sequence generator.

Parameters:

Name	Type	Description	Default
`sequence`	`BaseSequenceGenerator \| BasePeriodicSequenceGenerator \| dict`	A sequence generator or its configuration that is used to generate the periodic pattern.	required
`period`	`BaseTensorGenerator \| dict`	The period length sampler or its configuration. This sampler is used to sample the period length at each batch.	required

Example usage:

>>> from startorch.sequence import Periodic, RandUniform
>>> from startorch.tensor import RandInt
>>> generator = Periodic(sequence=RandUniform(), period=RandInt(2, 5))
>>> generator
PeriodicSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (period): RandIntTensorGenerator(low=2, high=5)
)
>>> generator.generate(seq_len=10, batch_size=2)
tensor([[...]])

startorch.sequence.PeriodicSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate periodic sequence from a regular sequence generator.

Parameters:

Name	Type	Description	Default
`sequence`	`BaseSequenceGenerator \| BasePeriodicSequenceGenerator \| dict`	A sequence generator or its configuration that is used to generate the periodic pattern.	required
`period`	`BaseTensorGenerator \| dict`	The period length sampler or its configuration. This sampler is used to sample the period length at each batch.	required

Example usage:

>>> from startorch.sequence import Periodic, RandUniform
>>> from startorch.tensor import RandInt
>>> generator = Periodic(sequence=RandUniform(), period=RandInt(2, 5))
>>> generator
PeriodicSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (period): RandIntTensorGenerator(low=2, high=5)
)
>>> generator.generate(seq_len=10, batch_size=2)
tensor([[...]])

startorch.sequence.Poisson ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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 sequence. The rate values should be greater than 0.

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, Poisson
>>> generator = Poisson(rate=RandUniform(low=1.0, high=2.0))
>>> generator
PoissonSequenceGenerator(
  (rate): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Poisson.generate_uniform_rate `classmethod` ¶

generate_uniform_rate(
    min_rate: float = 0.01,
    max_rate: float = 1.0,
    feature_size: tuple[int, ...] | list[int] | int = 1,
) -> PoissonSequenceGenerator

Implement a sequence generator where the rates of the Poisson distribution are sampled from a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_rate`	`float`	The minimum rate value.	`0.01`
`max_rate`	`float`	The maximum rate value.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Returns:

Type	Description
`PoissonSequenceGenerator`	A sequence generator where the rates of the Poisson distribution are sampled from a uniform distribution (`UniformConstantSequenceGenerator`).

startorch.sequence.PoissonSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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 sequence. The rate values should be greater than 0.

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, Poisson
>>> generator = Poisson(rate=RandUniform(low=1.0, high=2.0))
>>> generator
PoissonSequenceGenerator(
  (rate): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.PoissonSequenceGenerator.generate_uniform_rate `classmethod` ¶

generate_uniform_rate(
    min_rate: float = 0.01,
    max_rate: float = 1.0,
    feature_size: tuple[int, ...] | list[int] | int = 1,
) -> PoissonSequenceGenerator

Implement a sequence generator where the rates of the Poisson distribution are sampled from a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_rate`	`float`	The minimum rate value.	`0.01`
`max_rate`	`float`	The maximum rate value.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Returns:

Type	Description
`PoissonSequenceGenerator`	A sequence generator where the rates of the Poisson distribution are sampled from a uniform distribution (`UniformConstantSequenceGenerator`).

startorch.sequence.RandAsinhUniform ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences 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
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandAsinhUniform
>>> generator = RandAsinhUniform(low=1.0, high=10.0)
>>> generator
RandAsinhUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandAsinhUniformSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences 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
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandAsinhUniform
>>> generator = RandAsinhUniform(low=1.0, high=10.0)
>>> generator
RandAsinhUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandCauchy ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandCauchy
>>> generator = RandCauchy(loc=0.0, scale=1.0)
>>> generator
RandCauchySequenceGenerator(loc=0.0, scale=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandCauchy
>>> generator = RandCauchy(loc=0.0, scale=1.0)
>>> generator
RandCauchySequenceGenerator(loc=0.0, scale=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandExponential ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandExponential
>>> generator = RandExponential(rate=1.0)
>>> generator
RandExponentialSequenceGenerator(rate=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandExponentialSequenceGenerator ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandExponential
>>> generator = RandExponential(rate=1.0)
>>> generator
RandExponentialSequenceGenerator(rate=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandHalfCauchy ¶

Bases: BaseSequenceGenerator

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

Parameters:

Name	Type	Description	Default
`scale`	`float`	The scale of the distribution.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandHalfCauchy
>>> generator = RandHalfCauchy(scale=1.0)
>>> generator
RandHalfCauchySequenceGenerator(scale=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandHalfCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

Name	Type	Description	Default
`scale`	`float`	The scale of the distribution.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandHalfCauchy
>>> generator = RandHalfCauchy(scale=1.0)
>>> generator
RandHalfCauchySequenceGenerator(scale=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandHalfNormal ¶

Bases: BaseSequenceGenerator

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

Parameters:

Name	Type	Description	Default
`std`	`float`	The std of the distribution.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandHalfNormal
>>> generator = RandHalfNormal(std=1.0)
>>> generator
RandHalfNormalSequenceGenerator(std=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandHalfNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

Name	Type	Description	Default
`std`	`float`	The std of the distribution.	`1.0`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandHalfNormal
>>> generator = RandHalfNormal(std=1.0)
>>> generator
RandHalfNormalSequenceGenerator(std=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandInt ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequences of uniformly distributed integers.

Parameters:

Name	Type	Description	Default
`low`	`int`	The minimum value (included).	required
`high`	`int`	The maximum value (excluded).	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`()`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandInt
>>> generator = RandInt(0, 100)
>>> generator
RandIntSequenceGenerator(low=0, high=100, feature_size=())
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandIntSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequences of uniformly distributed integers.

Parameters:

Name	Type	Description	Default
`low`	`int`	The minimum value (included).	required
`high`	`int`	The maximum value (excluded).	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`()`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandInt
>>> generator = RandInt(0, 100)
>>> generator
RandIntSequenceGenerator(low=0, high=100, feature_size=())
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandLogNormal ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandLogNormal
>>> generator = RandLogNormal(mean=0.0, std=1.0)
>>> generator
RandLogNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandLogNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandLogNormal
>>> generator = RandLogNormal(mean=0.0, std=1.0)
>>> generator
RandLogNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandLogUniform ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences 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
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandLogUniform
>>> generator = RandLogUniform(low=1.0, high=10.0)
>>> generator
RandLogUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandLogUniformSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences 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
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandLogUniform
>>> generator = RandLogUniform(low=1.0, high=10.0)
>>> generator
RandLogUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandNormal ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandNormal
>>> generator = RandNormal(mean=0.0, std=1.0)
>>> generator
RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandNormal
>>> generator = RandNormal(mean=0.0, std=1.0)
>>> generator
RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandPoisson ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandPoisson
>>> generator = RandPoisson(rate=1.0)
>>> generator
RandPoissonSequenceGenerator(rate=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandPoissonSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandPoisson
>>> generator = RandPoisson(rate=1.0)
>>> generator
RandPoissonSequenceGenerator(rate=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncCauchy ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncCauchy
>>> generator = RandTruncCauchy(loc=0.0, scale=1.0, min_value=-5.0, max_value=5.0)
>>> generator
RandTruncCauchySequenceGenerator(loc=0.0, scale=1.0, min_value=-5.0, max_value=5.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncCauchy
>>> generator = RandTruncCauchy(loc=0.0, scale=1.0, min_value=-5.0, max_value=5.0)
>>> generator
RandTruncCauchySequenceGenerator(loc=0.0, scale=1.0, min_value=-5.0, max_value=5.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncExponential ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncExponential
>>> generator = RandTruncExponential(rate=1.0, max_value=3.0)
>>> generator
RandTruncExponentialSequenceGenerator(rate=1.0, max_value=3.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncExponentialSequenceGenerator ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncExponential
>>> generator = RandTruncExponential(rate=1.0, max_value=3.0)
>>> generator
RandTruncExponentialSequenceGenerator(rate=1.0, max_value=3.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncHalfCauchy ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncHalfCauchy
>>> generator = RandTruncHalfCauchy(scale=1.0, max_value=5.0)
>>> generator
RandTruncHalfCauchySequenceGenerator(scale=1.0, max_value=5.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncHalfCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncHalfCauchy
>>> generator = RandTruncHalfCauchy(scale=1.0, max_value=5.0)
>>> generator
RandTruncHalfCauchySequenceGenerator(scale=1.0, max_value=5.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncHalfNormal ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncHalfNormal
>>> generator = RandTruncHalfNormal(std=1.0, max_value=1.0)
>>> generator
RandTruncHalfNormalSequenceGenerator(std=1.0, max_value=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncHalfNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncHalfNormal
>>> generator = RandTruncHalfNormal(std=1.0, max_value=1.0)
>>> generator
RandTruncHalfNormalSequenceGenerator(std=1.0, max_value=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncLogNormal ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate cyclic sequences 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncLogNormal
>>> generator = RandTruncLogNormal(mean=0.0, std=1.0, min_value=0.0, max_value=1.0)
>>> generator
RandTruncLogNormalSequenceGenerator(mean=0.0, std=1.0, min_value=0.0, max_value=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncLogNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate cyclic sequences 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncLogNormal
>>> generator = RandTruncLogNormal(mean=0.0, std=1.0, min_value=0.0, max_value=1.0)
>>> generator
RandTruncLogNormalSequenceGenerator(mean=0.0, std=1.0, min_value=0.0, max_value=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncNormal ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncNormal
>>> generator = RandTruncNormal(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0)
>>> generator
RandTruncNormalSequenceGenerator(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandTruncNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

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

Example usage:

>>> from startorch.sequence import RandTruncNormal
>>> generator = RandTruncNormal(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0)
>>> generator
RandTruncNormalSequenceGenerator(mean=0.0, std=1.0, min_value=-1.0, max_value=1.0, feature_size=(1,))
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandUniform ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform
>>> generator = RandUniform()
>>> generator
RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandUniformSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences 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`
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`1`

Raises:

Type	Description
`ValueError`	if `high` is lower than `low`.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform
>>> generator = RandUniform()
>>> generator
RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.RandWienerProcess ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences where the values are generated by a Wiener process.

Useful link: https://en.wikipedia.org/wiki/Wiener_process

Parameters:

Name	Type	Description	Default
`step_size`	`float`	The time step size.	`1.0`

Raises:

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

Example usage:

>>> from startorch.sequence import RandWienerProcess
>>> generator = RandWienerProcess()
>>> generator
RandWienerProcessSequenceGenerator(step_size=1.0)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.RandWienerProcessSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences where the values are generated by a Wiener process.

Useful link: https://en.wikipedia.org/wiki/Wiener_process

Parameters:

Name	Type	Description	Default
`step_size`	`float`	The time step size.	`1.0`

Raises:

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

Example usage:

>>> from startorch.sequence import RandWienerProcess
>>> generator = RandWienerProcess()
>>> generator
RandWienerProcessSequenceGenerator(step_size=1.0)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.SineWave ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence by sampling values with a sine wave pattern.

The sequences are generated by using the following formula:

output = amplitude * sin(2 * pi * frequency * value + phase)

Parameters:

Name	Type	Description	Default
`value`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the sequence values.	required
`frequency`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the frequency values.	required
`phase`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the phase values.	required
`amplitude`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the amplitude values.	required

Example usage:

>>> import torch
>>> from startorch.sequence import Arange, SineWave, RandUniform, Constant, RandLogUniform
>>> generator = SineWave(
...     value=Arange(),
...     frequency=Constant(RandLogUniform(low=0.01, high=0.1)),
...     phase=Constant(RandUniform(low=-1.0, high=1.0)),
...     amplitude=Constant(RandLogUniform(low=0.1, high=1.0)),
... )
>>> generator
SineWaveSequenceGenerator(
  (value): ArangeSequenceGenerator(feature_size=(1,))
  (frequency): ConstantSequenceGenerator(
      (sequence): RandLogUniformSequenceGenerator(low=0.01, high=0.1, feature_size=(1,))
    )
  (phase): ConstantSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
    )
  (amplitude): ConstantSequenceGenerator(
      (sequence): RandLogUniformSequenceGenerator(low=0.1, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.SineWaveSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequence by sampling values with a sine wave pattern.

The sequences are generated by using the following formula:

output = amplitude * sin(2 * pi * frequency * value + phase)

Parameters:

Name	Type	Description	Default
`value`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the sequence values.	required
`frequency`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the frequency values.	required
`phase`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the phase values.	required
`amplitude`	`BaseSequenceGenerator \| dict`	A sequence generator (or its configuration) to generate the amplitude values.	required

Example usage:

>>> import torch
>>> from startorch.sequence import Arange, SineWave, RandUniform, Constant, RandLogUniform
>>> generator = SineWave(
...     value=Arange(),
...     frequency=Constant(RandLogUniform(low=0.01, high=0.1)),
...     phase=Constant(RandUniform(low=-1.0, high=1.0)),
...     amplitude=Constant(RandLogUniform(low=0.1, high=1.0)),
... )
>>> generator
SineWaveSequenceGenerator(
  (value): ArangeSequenceGenerator(feature_size=(1,))
  (frequency): ConstantSequenceGenerator(
      (sequence): RandLogUniformSequenceGenerator(low=0.01, high=0.1, feature_size=(1,))
    )
  (phase): ConstantSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
    )
  (amplitude): ConstantSequenceGenerator(
      (sequence): RandLogUniformSequenceGenerator(low=0.1, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Sinh ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Sinh, RandUniform
>>> generator = Sinh(RandUniform())
>>> generator
SinhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.SinhSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Sinh, RandUniform
>>> generator = Sinh(RandUniform())
>>> generator
SinhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Sort ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that sorts a generated sequence.

Parameters:

Name	Type	Description	Default
`generator`	`BaseSequenceGenerator \| dict`	The sequence generator or its configuration.	required
`descending`	`bool`	Control the sorting order. If `True`, the elements are sorted in descending order by value.	`False`

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Sort
>>> generator = Sort(RandUniform())
>>> generator
SortSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.SortSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that sorts a generated sequence.

Parameters:

Name	Type	Description	Default
`generator`	`BaseSequenceGenerator \| dict`	The sequence generator or its configuration.	required
`descending`	`bool`	Control the sorting order. If `True`, the elements are sorted in descending order by value.	`False`

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Sort
>>> generator = Sort(RandUniform())
>>> generator
SortSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Sqrt ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the squared root of a batch of sequences.

Example usage:

>>> import torch
>>> from startorch.sequence import Sqrt, RandUniform, RandNormal
>>> generator = Sqrt(RandUniform(1.0, 4.0))
>>> generator
SqrtSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=1.0, high=4.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.SqrtSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that computes the squared root of a batch of sequences.

Example usage:

>>> import torch
>>> from startorch.sequence import Sqrt, RandUniform, RandNormal
>>> generator = Sqrt(RandUniform(1.0, 4.0))
>>> generator
SqrtSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=1.0, high=4.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Sub ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that subtracts sequences.

sequence = sequence_1 - sequence_2

Parameters:

Name	Type	Description	Default
`sequence1`	`BaseSequenceGenerator \| dict`	The first sequence generator or its configuration.	required
`sequence2`	`BaseSequenceGenerator \| dict`	The second sequence generator or its configuration.	required

Example usage:

>>> import torch
>>> from startorch.sequence import Sub, RandUniform, RandNormal
>>> generator = Sub(RandUniform(), RandNormal())
>>> generator
SubSequenceGenerator(
  (sequence1): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (sequence2): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.SubSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator that subtracts sequences.

sequence = sequence_1 - sequence_2

Parameters:

Name	Type	Description	Default
`sequence1`	`BaseSequenceGenerator \| dict`	The first sequence generator or its configuration.	required
`sequence2`	`BaseSequenceGenerator \| dict`	The second sequence generator or its configuration.	required

Example usage:

>>> import torch
>>> from startorch.sequence import Sub, RandUniform, RandNormal
>>> generator = Sub(RandUniform(), RandNormal())
>>> generator
SubSequenceGenerator(
  (sequence1): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
  (sequence2): RandNormalSequenceGenerator(mean=0.0, std=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Tanh ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Tanh, RandUniform
>>> generator = Tanh(RandUniform())
>>> generator
TanhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TanhSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

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

Example usage:

>>> import torch
>>> from startorch.sequence import Tanh, RandUniform
>>> generator = Tanh(RandUniform())
>>> generator
TanhSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TensorSequence ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences from a tensor generator.

Parameters:

Name	Type	Description	Default
`tensor`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration).	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`()`

Example usage:

>>> import torch
>>> from startorch.sequence import TensorSequence
>>> from startorch.tensor import RandUniform
>>> generator = TensorSequence(RandUniform())
>>> generator
TensorSequenceGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
  (feature_size): ()
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TensorSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to generate sequences from a tensor generator.

Parameters:

Name	Type	Description	Default
`tensor`	`BaseTensorGenerator \| dict`	A tensor generator (or its configuration).	required
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`()`

Example usage:

>>> import torch
>>> from startorch.sequence import TensorSequence
>>> from startorch.tensor import RandUniform
>>> generator = TensorSequence(RandUniform())
>>> generator
TensorSequenceGenerator(
  (tensor): RandUniformTensorGenerator(low=0.0, high=1.0)
  (feature_size): ()
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator to generate time sequences.

The time is represented as a float value. The unit depends on the context. If the unit is the second:

1.2 -> 00:00:01.200
61.2 -> 00:01:01.200
3661.2 -> 01:01:01.200

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time(RandUniform())
>>> generator
TimeSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_exponential_constant_time_diff `classmethod` ¶

create_exponential_constant_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps is constant and is sampled from an exponential distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps is constant and is sampled from an exponential distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_exponential_constant_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ConstantSequenceGenerator(
          (sequence): ExponentialSequenceGenerator(
              (rate): ConstantSequenceGenerator(
                  (sequence): RandUniformSequenceGenerator(low=1.0, high=1.0, feature_size=(1,))
                )
            )
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_exponential_time_diff `classmethod` ¶

create_exponential_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps follows an exponential distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps follows an exponential distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_exponential_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ExponentialSequenceGenerator(
          (rate): ConstantSequenceGenerator(
              (sequence): RandUniformSequenceGenerator(low=1.0, high=1.0, feature_size=(1,))
            )
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_poisson_constant_time_diff `classmethod` ¶

create_poisson_constant_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps is constant and is sampled from a Poisson distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps is constant and is sampled from a Poisson distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_poisson_constant_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ConstantSequenceGenerator(
          (sequence): RandPoissonSequenceGenerator(rate=1.0, feature_size=(1,))
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_poisson_time_diff `classmethod` ¶

create_poisson_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps follows a Poisson distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps follows a Poisson distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_poisson_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): RandPoissonSequenceGenerator(rate=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_uniform_constant_time_diff `classmethod` ¶

create_uniform_constant_time_diff(
    min_time_diff: float = 0.0, max_time_diff: float = 1.0
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps is constant and is sampled from a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_time_diff`	`float`	The minimum time difference between two consecutive steps.	`0.0`
`max_time_diff`	`float`	The maximum time difference between two consecutive steps.	`1.0`

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps is constant and is sampled from a uniform distribution.

Raises:

Type	Description
`ValueError`	if `min_time_diff` is lower than 0.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_uniform_constant_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ConstantSequenceGenerator(
          (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_uniform_time `classmethod` ¶

create_uniform_time(
    min_time: float = 0.0, max_time: float = 1.0
) -> TimeSequenceGenerator

Create a time sequence generator where the time is sampled from a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_time`	`float`	The minimum time.	`0.0`
`max_time`	`float`	The maximum time.	`1.0`

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time is sampled from a uniform distribution.

Raises:

Type	Description
`ValueError`	if `min_time` is lower than 0.

Example usage:

```pycon

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_uniform_time()
>>> generator
TimeSequenceGenerator(
  (sequence): SortSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.Time.create_uniform_time_diff `classmethod` ¶

create_uniform_time_diff(
    min_time_diff: float = 0.0, max_time_diff: float = 1.0
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps follows a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_time_diff`	`float`	The minimum time difference between two consecutive steps.	`0.0`
`max_time_diff`	`float`	The maximum time difference between two consecutive steps.	`1.0`

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps follows a uniform distribution.

Raises:

Type	Description
`ValueError`	if `min_time_diff` is lower than 0.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_uniform_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator to generate time sequences.

The time is represented as a float value. The unit depends on the context. If the unit is the second:

1.2 -> 00:00:01.200
61.2 -> 00:01:01.200
3661.2 -> 01:01:01.200

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time(RandUniform())
>>> generator
TimeSequenceGenerator(
  (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_exponential_constant_time_diff `classmethod` ¶

create_exponential_constant_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps is constant and is sampled from an exponential distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps is constant and is sampled from an exponential distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_exponential_constant_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ConstantSequenceGenerator(
          (sequence): ExponentialSequenceGenerator(
              (rate): ConstantSequenceGenerator(
                  (sequence): RandUniformSequenceGenerator(low=1.0, high=1.0, feature_size=(1,))
                )
            )
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_exponential_time_diff `classmethod` ¶

create_exponential_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps follows an exponential distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps follows an exponential distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_exponential_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ExponentialSequenceGenerator(
          (rate): ConstantSequenceGenerator(
              (sequence): RandUniformSequenceGenerator(low=1.0, high=1.0, feature_size=(1,))
            )
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_poisson_constant_time_diff `classmethod` ¶

create_poisson_constant_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps is constant and is sampled from a Poisson distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps is constant and is sampled from a Poisson distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_poisson_constant_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ConstantSequenceGenerator(
          (sequence): RandPoissonSequenceGenerator(rate=1.0, feature_size=(1,))
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_poisson_time_diff `classmethod` ¶

create_poisson_time_diff(
    rate: float = 1.0,
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps follows a Poisson distribution.

Parameters:

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

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps follows a Poisson distribution.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_poisson_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): RandPoissonSequenceGenerator(rate=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_uniform_constant_time_diff `classmethod` ¶

create_uniform_constant_time_diff(
    min_time_diff: float = 0.0, max_time_diff: float = 1.0
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps is constant and is sampled from a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_time_diff`	`float`	The minimum time difference between two consecutive steps.	`0.0`
`max_time_diff`	`float`	The maximum time difference between two consecutive steps.	`1.0`

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps is constant and is sampled from a uniform distribution.

Raises:

Type	Description
`ValueError`	if `min_time_diff` is lower than 0.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_uniform_constant_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): ConstantSequenceGenerator(
          (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
        )
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_uniform_time `classmethod` ¶

create_uniform_time(
    min_time: float = 0.0, max_time: float = 1.0
) -> TimeSequenceGenerator

Create a time sequence generator where the time is sampled from a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_time`	`float`	The minimum time.	`0.0`
`max_time`	`float`	The maximum time.	`1.0`

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time is sampled from a uniform distribution.

Raises:

Type	Description
`ValueError`	if `min_time` is lower than 0.

Example usage:

```pycon

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_uniform_time()
>>> generator
TimeSequenceGenerator(
  (sequence): SortSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TimeSequenceGenerator.create_uniform_time_diff `classmethod` ¶

create_uniform_time_diff(
    min_time_diff: float = 0.0, max_time_diff: float = 1.0
) -> TimeSequenceGenerator

Create a time sequence generator where the time difference between two consecutive steps follows a uniform distribution.

Parameters:

Name	Type	Description	Default
`min_time_diff`	`float`	The minimum time difference between two consecutive steps.	`0.0`
`max_time_diff`	`float`	The maximum time difference between two consecutive steps.	`1.0`

Returns:

Type	Description
`TimeSequenceGenerator`	A time sequence generator where the time difference between two consecutive steps follows a uniform distribution.

Raises:

Type	Description
`ValueError`	if `min_time_diff` is lower than 0.

Example usage:

>>> import torch
>>> from startorch.sequence import RandUniform, Time
>>> generator = Time.create_uniform_time_diff()
>>> generator
TimeSequenceGenerator(
  (sequence): CumsumSequenceGenerator(
      (sequence): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
    )
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.TransformSequenceGenerator ¶

Bases: BaseWrapperSequenceGenerator

Implement a sequence generator that generates a batch of sequences and then transform it.

Parameters:

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

Example usage:

>>> from startorch.sequence import TransformSequenceGenerator, Full
>>> from startorch.tensor.transformer import Abs
>>> generator = TransformSequenceGenerator(
...     generator=Full(value=-1, feature_size=()), transformer=Abs()
... )
>>> generator
TransformSequenceGenerator(
  (generator): FullSequenceGenerator(value=-1, feature_size=())
  (transformer): AbsTensorTransformer()
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1]])

startorch.sequence.TruncCauchy ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence 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
TruncCauchySequenceGenerator(
  (loc): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (min_value): RandUniformSequenceGenerator(low=-10.0, high=-5.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence 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
TruncCauchySequenceGenerator(
  (loc): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (min_value): RandUniformSequenceGenerator(low=-10.0, high=-5.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncExponential ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, TruncExponential
>>> generator = TruncExponential(
...     rate=RandUniform(low=1.0, high=10.0),
...     max_value=RandUniform(low=1.0, high=100.0),
... )
>>> generator
TruncExponentialSequenceGenerator(
  (rate): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=1.0, high=100.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncExponentialSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, TruncExponential
>>> generator = TruncExponential(
...     rate=RandUniform(low=1.0, high=10.0),
...     max_value=RandUniform(low=1.0, high=100.0),
... )
>>> generator
TruncExponentialSequenceGenerator(
  (rate): RandUniformSequenceGenerator(low=1.0, high=10.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=1.0, high=100.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncHalfCauchy ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, TruncHalfCauchy
>>> generator = TruncHalfCauchy(
...     scale=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfCauchySequenceGenerator(
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncHalfCauchySequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, TruncHalfCauchy
>>> generator = TruncHalfCauchy(
...     scale=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfCauchySequenceGenerator(
  (scale): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncHalfNormal ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, TruncHalfNormal
>>> generator = TruncHalfNormal(
...     std=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfNormalSequenceGenerator(
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncHalfNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence import RandUniform, TruncHalfNormal
>>> generator = TruncHalfNormal(
...     std=RandUniform(low=1.0, high=2.0),
...     max_value=RandUniform(low=5.0, high=10.0),
... )
>>> generator
TruncHalfNormalSequenceGenerator(
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncLogNormal ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence 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
TruncLogNormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (min_value): RandUniformSequenceGenerator(low=0.0, high=2.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncLogNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence 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
TruncLogNormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (min_value): RandUniformSequenceGenerator(low=0.0, high=2.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncNormal ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence 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
TruncNormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (min_value): RandUniformSequenceGenerator(low=-10.0, high=-5.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.TruncNormalSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> from startorch.sequence 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
TruncNormalSequenceGenerator(
  (mean): RandUniformSequenceGenerator(low=-1.0, high=1.0, feature_size=(1,))
  (std): RandUniformSequenceGenerator(low=1.0, high=2.0, feature_size=(1,))
  (min_value): RandUniformSequenceGenerator(low=-10.0, high=-5.0, feature_size=(1,))
  (max_value): RandUniformSequenceGenerator(low=5.0, high=10.0, feature_size=(1,))
)
>>> generator.generate(seq_len=6, batch_size=2)
tensor([[...]])

startorch.sequence.Uniform ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import Uniform, RandUniform
>>> generator = Uniform(low=RandUniform(-1.0, 0.0), high=RandUniform(0.0, 1.0))
>>> generator
UniformSequenceGenerator(
  (low): RandUniformSequenceGenerator(low=-1.0, high=0.0, feature_size=(1,))
  (high): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.UniformCategorical ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequences 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
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`()`

Raises:

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

Example usage:

>>> import torch
>>> from startorch.sequence import UniformCategorical
>>> generator = UniformCategorical(10)
>>> generator
UniformCategoricalSequenceGenerator(num_categories=10, feature_size=())
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.UniformCategoricalSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a class to generate sequences 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
`feature_size`	`tuple[int, ...] \| list[int] \| int`	The feature size.	`()`

Raises:

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

Example usage:

>>> import torch
>>> from startorch.sequence import UniformCategorical
>>> generator = UniformCategorical(10)
>>> generator
UniformCategoricalSequenceGenerator(num_categories=10, feature_size=())
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.UniformSequenceGenerator ¶

Bases: BaseSequenceGenerator

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

Parameters:

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

Example usage:

>>> import torch
>>> from startorch.sequence import Uniform, RandUniform
>>> generator = Uniform(low=RandUniform(-1.0, 0.0), high=RandUniform(0.0, 1.0))
>>> generator
UniformSequenceGenerator(
  (low): RandUniformSequenceGenerator(low=-1.0, high=0.0, feature_size=(1,))
  (high): RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))
)
>>> generator.generate(seq_len=12, batch_size=4)
tensor([[...]])

startorch.sequence.VanillaSequenceGenerator ¶

Bases: BaseSequenceGenerator

Implement a sequence generator to "generate" the input data.

Parameters:

Name	Type	Description	Default
`data`	`Tensor`	The sequence data to generate.	required

Sequence usage:

>>> import torch
>>> from startorch.sequence import VanillaSequenceGenerator
>>> generator = VanillaSequenceGenerator(data=torch.arange(40).view(4, 10))
>>> generator
VanillaSequenceGenerator(batch_size=4, seq_len=10)
>>> generator.generate(batch_size=3, seq_len=6)
tensor([[ 0,  1,  2,  3,  4,  5],
        [10, 11, 12, 13, 14, 15],
        [20, 21, 22, 23, 24, 25]])

startorch.sequence.is_sequence_generator_config ¶

is_sequence_generator_config(config: dict) -> bool

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

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 `BaseSequenceGenerator` object.

Example usage:

>>> from startorch.sequence import is_sequence_generator_config
>>> is_sequence_generator_config({"_target_": "startorch.sequence.RandUniform"})
True

startorch.sequence.setup_sequence_generator ¶

setup_sequence_generator(
    generator: BaseSequenceGenerator | dict,
) -> BaseSequenceGenerator

Set up a sequence generator.

The sequence generator is instantiated from its configuration by using the BaseSequenceGenerator factory function.

Parameters:

Name	Type	Description	Default
`generator`	`BaseSequenceGenerator \| dict`	A sequence generator or its configuration.	required

Returns:

Type	Description
`BaseSequenceGenerator`	A sequence generator.

Example usage:

>>> from startorch.sequence import setup_sequence_generator
>>> setup_sequence_generator({"_target_": "startorch.sequence.RandUniform"})
RandUniformSequenceGenerator(low=0.0, high=1.0, feature_size=(1,))

sequence

startorch.sequence ¶

startorch.sequence.Abs ¶

startorch.sequence.AbsSequenceGenerator ¶

startorch.sequence.Acosh ¶

startorch.sequence.AcoshSequenceGenerator ¶

startorch.sequence.Add ¶

startorch.sequence.AddScalar ¶

startorch.sequence.AddScalarSequenceGenerator ¶

startorch.sequence.AddSequenceGenerator ¶

startorch.sequence.Arange ¶

startorch.sequence.ArangeSequenceGenerator ¶

startorch.sequence.Asinh ¶

startorch.sequence.AsinhSequenceGenerator ¶

startorch.sequence.AsinhUniform ¶

startorch.sequence.AsinhUniformSequenceGenerator ¶

startorch.sequence.Atanh ¶

startorch.sequence.AtanhSequenceGenerator ¶

startorch.sequence.AutoRegressive ¶

startorch.sequence.AutoRegressiveSequenceGenerator ¶

startorch.sequence.BaseSequenceGenerator ¶

startorch.sequence.BaseSequenceGenerator.generate abstractmethod ¶

startorch.sequence.BaseWrapperSequenceGenerator ¶

startorch.sequence.Cat2 ¶

startorch.sequence.Cat2SequenceGenerator ¶

startorch.sequence.Cauchy ¶

startorch.sequence.CauchySequenceGenerator ¶

startorch.sequence.Clamp ¶

startorch.sequence.ClampSequenceGenerator ¶

startorch.sequence.Constant ¶

startorch.sequence.ConstantSequenceGenerator ¶

startorch.sequence.Cosh ¶

startorch.sequence.CoshSequenceGenerator ¶

startorch.sequence.Cumsum ¶

startorch.sequence.CumsumSequenceGenerator ¶

startorch.sequence.Div ¶

startorch.sequence.DivSequenceGenerator ¶

startorch.sequence.Exp ¶

startorch.sequence.ExpSequenceGenerator ¶

startorch.sequence.Exponential ¶

startorch.sequence.Exponential.create_fixed_rate classmethod ¶

startorch.sequence.Exponential.create_uniform_rate classmethod ¶

startorch.sequence.ExponentialSequenceGenerator ¶

startorch.sequence.ExponentialSequenceGenerator.create_fixed_rate classmethod ¶

startorch.sequence.ExponentialSequenceGenerator.create_uniform_rate classmethod ¶

startorch.sequence.Float ¶

startorch.sequence.FloatSequenceGenerator ¶

startorch.sequence.Fmod ¶

startorch.sequence.FmodSequenceGenerator ¶

startorch.sequence.Full ¶

startorch.sequence.FullSequenceGenerator ¶

startorch.sequence.HalfCauchy ¶

startorch.sequence.HalfCauchySequenceGenerator ¶

startorch.sequence.HalfNormal ¶

startorch.sequence.HalfNormalSequenceGenerator ¶

startorch.sequence.Linear ¶

startorch.sequence.LinearSequenceGenerator ¶

startorch.sequence.Log ¶

startorch.sequence.LogNormal ¶

startorch.sequence.LogNormalSequenceGenerator ¶

startorch.sequence.LogSequenceGenerator ¶

startorch.sequence.LogUniform ¶

startorch.sequence.LogUniformSequenceGenerator ¶

startorch.sequence.Long ¶

startorch.sequence.LongSequenceGenerator ¶

startorch.sequence.MarkovChain ¶

startorch.sequence.MarkovChain.create_from_generators classmethod ¶

startorch.sequence.MarkovChainSequenceGenerator ¶

startorch.sequence.MarkovChainSequenceGenerator.create_from_generators classmethod ¶

startorch.sequence.Mul ¶

startorch.sequence.MulScalar ¶

startorch.sequence.MulScalarSequenceGenerator ¶

startorch.sequence.MulSequenceGenerator ¶

startorch.sequence.Multinomial ¶

startorch.sequence.Multinomial.create_exp_weights classmethod ¶

startorch.sequence.Multinomial.create_linear_weights classmethod ¶

startorch.sequence.Multinomial.create_uniform_weights classmethod ¶

startorch.sequence.MultinomialChoice ¶

startorch.sequence.MultinomialChoiceSequenceGenerator ¶

startorch.sequence.MultinomialSequenceGenerator ¶

startorch.sequence.BaseSequenceGenerator.generate `abstractmethod` ¶

startorch.sequence.Exponential.create_fixed_rate `classmethod` ¶

startorch.sequence.Exponential.create_uniform_rate `classmethod` ¶

startorch.sequence.ExponentialSequenceGenerator.create_fixed_rate `classmethod` ¶

startorch.sequence.ExponentialSequenceGenerator.create_uniform_rate `classmethod` ¶

startorch.sequence.MarkovChain.create_from_generators `classmethod` ¶

startorch.sequence.MarkovChainSequenceGenerator.create_from_generators `classmethod` ¶

startorch.sequence.Multinomial.create_exp_weights `classmethod` ¶

startorch.sequence.Multinomial.create_linear_weights `classmethod` ¶

startorch.sequence.Multinomial.create_uniform_weights `classmethod` ¶

startorch.sequence.MultinomialSequenceGenerator.create_exp_weights `classmethod` ¶

startorch.sequence.MultinomialSequenceGenerator.create_linear_weights `classmethod` ¶

startorch.sequence.MultinomialSequenceGenerator.create_uniform_weights `classmethod` ¶

startorch.sequence.Poisson.generate_uniform_rate `classmethod` ¶

startorch.sequence.PoissonSequenceGenerator.generate_uniform_rate `classmethod` ¶

startorch.sequence.Time.create_exponential_constant_time_diff `classmethod` ¶

startorch.sequence.Time.create_exponential_time_diff `classmethod` ¶

startorch.sequence.Time.create_poisson_constant_time_diff `classmethod` ¶

startorch.sequence.Time.create_poisson_time_diff `classmethod` ¶

startorch.sequence.Time.create_uniform_constant_time_diff `classmethod` ¶

startorch.sequence.Time.create_uniform_time `classmethod` ¶