timesead.utils.torch_utils
==========================

.. py:module:: timesead.utils.torch_utils


Attributes
----------

.. autoapisummary::

   timesead.utils.torch_utils.activations


Classes
-------

.. autoapisummary::

   timesead.utils.torch_utils.ConstantLR


Functions
---------

.. autoapisummary::

   timesead.utils.torch_utils.run_deterministic
   timesead.utils.torch_utils.run_fast
   timesead.utils.torch_utils.clear_gpu_memory
   timesead.utils.torch_utils.set_threads
   timesead.utils.torch_utils.collate_fn_variable_length_ts
   timesead.utils.torch_utils.unpack_sequence
   timesead.utils.torch_utils.generate_random_sequences_like
   timesead.utils.torch_utils.generate_random_sequences
   timesead.utils.torch_utils.dataset_to_numpy_array
   timesead.utils.torch_utils.sequences_to_dataframe
   timesead.utils.torch_utils.list2tensor
   timesead.utils.torch_utils.tensor2scalar
   timesead.utils.torch_utils.batched_dot
   timesead.utils.torch_utils.get_device
   timesead.utils.torch_utils.nested_list2tensor
   timesead.utils.torch_utils.exponential_moving_avg_
   timesead.utils.torch_utils.unsqueeze_like
   timesead.utils.torch_utils.transform_tensor
   timesead.utils.torch_utils.log1mexp


Module Contents
---------------

.. py:data:: activations

.. py:function:: run_deterministic() -> None

.. py:function:: run_fast() -> None

.. py:function:: clear_gpu_memory() -> None

.. py:function:: set_threads(n: Optional[int] = None) -> None

.. py:function:: collate_fn_variable_length_ts(tensors: List[Tuple[torch.Tensor, torch.Tensor]]) -> Tuple[torch.nn.utils.rnn.PackedSequence, torch.nn.utils.rnn.PackedSequence]

.. py:function:: unpack_sequence(packed_sequence: torch.nn.utils.rnn.PackedSequence) -> List[torch.Tensor]

.. py:function:: generate_random_sequences_like(sequences: Union[torch.Tensor, torch.nn.utils.rnn.PackedSequence]) -> Union[torch.Tensor, torch.nn.utils.rnn.PackedSequence]

.. py:function:: generate_random_sequences(shape: Union[List[Tuple[int, int]], Tuple[int, int]], n: int = 1) -> Union[torch.Tensor, torch.nn.utils.rnn.PackedSequence]

.. py:function:: dataset_to_numpy_array(dataset: Union[torch.utils.data.Dataset, torch.utils.data.DataLoader], n: int = -1) -> List[numpy.array]

   Accumulates elements from a torch dataset into a numpy array.

   :param dataset: Dataset.
   :type dataset: torch.utils.data.dataset.Dataset or torch.utils.data.DataLoader
   :param n: Maximum number of samples collected from the dataset.
   :type n: int
   :return: Dataset as a list of numpy arrays.
   :rtype: list(numpy.array)


.. py:function:: sequences_to_dataframe(sequences: Union[torch.Tensor, torch.nn.utils.rnn.PackedSequence]) -> List[pandas.DataFrame]

.. py:function:: list2tensor(input: Union[List[torch.Tensor], torch.Tensor]) -> torch.Tensor

.. py:function:: tensor2scalar(tensor: torch.Tensor) -> Union[torch.Tensor, float, int]

.. py:function:: batched_dot(vec1: torch.Tensor, vec2: torch.Tensor) -> torch.Tensor

   Computes a batched dot product.

   :param vec1: Tensor of shape (\*, D).
   :param vec2: Tensor of shape (\*, D). The batch shapes of both inputs must be broadcastable.
   :return: Tensor of shape (\*)


.. py:function:: get_device(module: torch.nn.Module) -> torch.device

.. py:function:: nested_list2tensor(inputs: List) -> torch.Tensor

.. py:function:: exponential_moving_avg_(series: torch.Tensor, alpha: float, avg_num: float = 0, avg_denom: float = 0)

   Computes the online adjusted exp weighted average of the errors.
   See https://pandas.pydata.org/docs/user_guide/window.html#window-exponentially-weighted.
   This modifies the given TS tensor in-place.


.. py:function:: unsqueeze_like(to_squeeze: torch.Tensor, like: torch.Tensor, keep_dims: Optional[List] = None) -> torch.Tensor

.. py:function:: transform_tensor(tensor: Union[Tuple[torch.Tensor], torch.Tensor], current_shape: str, target_shape: str) -> Union[Tuple[torch.Tensor], torch.Tensor]

.. py:function:: log1mexp(x: torch.Tensor) -> torch.Tensor

   Numerically accurate evaluation of log(1 - exp(x)) for x < 0.
   See [Maechler2012accurate]_ for details.

   .. [Maechler2012accurate] Maechler, Martin (2012). Accurately Computing log(1-exp(-\|a\|)). Assessed from the Rmpfr package.


.. py:class:: ConstantLR(optimizer: torch.optim.Optimizer)

   Bases: :py:obj:`torch.optim.lr_scheduler.StepLR`


   Decays the learning rate of each parameter group by gamma every step_size epochs.

   Notice that such decay can happen simultaneously with other changes to the learning rate
   from outside this scheduler. When last_epoch=-1, sets initial lr as lr.

   :param optimizer: Wrapped optimizer.
   :type optimizer: Optimizer
   :param step_size: Period of learning rate decay.
   :type step_size: int
   :param gamma: Multiplicative factor of learning rate decay.
                 Default: 0.1.
   :type gamma: float
   :param last_epoch: The index of last epoch. Default: -1.
   :type last_epoch: int

   .. rubric:: Example

   >>> # xdoctest: +SKIP
   >>> # Assuming optimizer uses lr = 0.05 for all groups
   >>> # lr = 0.05     if epoch < 30
   >>> # lr = 0.005    if 30 <= epoch < 60
   >>> # lr = 0.0005   if 60 <= epoch < 90
   >>> # ...
   >>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
   >>> for epoch in range(100):
   >>>     train(...)
   >>>     validate(...)
   >>>     scheduler.step()