diff --git a/CHANGELOG.md b/CHANGELOG.md index 729813490..53a902d45 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,8 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Add `ChronosModel` ([#511](https://github.com/etna-team/etna/pull/511)) - Add `ChronosBoltModel` ([#511](https://github.com/etna-team/etna/pull/511)) - Add usage example of `ChronosModel` and `ChronosBoltModel` in `202-NN_examples` notebook ([#511](https://github.com/etna-team/etna/pull/511)) -- -- +- Add `TimesFMModel` ([#544](https://github.com/etna-team/etna/pull/544)) +- Add usage example of `TimesFMModel` in `202-NN_examples` notebook ([#544](https://github.com/etna-team/etna/pull/544)) - - - Add `MissingCounter` metric ([#520](https://github.com/etna-team/etna/pull/520)) diff --git a/README.md b/README.md index baae3b461..64016e1ad 100644 --- a/README.md +++ b/README.md @@ -149,7 +149,8 @@ Available user extensions are the following: * `auto`: adds AutoML functionality, * `statsforecast`: adds models from [statsforecast](https://nixtla.github.io/statsforecast/), * `classiciation`: adds time series classification functionality, -* `chronos`: adds Chronos-like pretrained models. +* `chronos`: adds Chronos-like pretrained models, +* `timesfm`: adds TimesFM pretrained models. Install extension: ```bash diff --git a/docs/source/api_reference/models.rst b/docs/source/api_reference/models.rst index daea65539..ef06daee4 100644 --- a/docs/source/api_reference/models.rst +++ b/docs/source/api_reference/models.rst @@ -122,4 +122,5 @@ Pretrained neural network models: :template: class.rst nn.ChronosModel - nn.ChronosBoltModel \ No newline at end of file + nn.ChronosBoltModel + nn.TimesFMModel \ No newline at end of file diff --git a/docs/source/installation.rst b/docs/source/installation.rst index 86cd18123..90ac3d214 100644 --- a/docs/source/installation.rst +++ b/docs/source/installation.rst @@ -24,7 +24,8 @@ Available user extensions are the following: - ``auto``: adds AutoML functionality, - ``statsforecast``: adds models from `statsforecast `_, - ``classiciation``: adds time series classification functionality, -- ``chronos``: adds Chronos-like pretrained models. +- ``chronos``: adds Chronos-like pretrained models, +- ``timesfm``: adds TimesFM pretrained models. Install extension: diff --git a/etna/libs/timesfm/__init__.py b/etna/libs/timesfm/__init__.py new file mode 100644 index 000000000..2346aa8a2 --- /dev/null +++ b/etna/libs/timesfm/__init__.py @@ -0,0 +1,155 @@ +""" + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + 1. Definitions. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. +""" + + +from etna.libs.timesfm.timesfm import TimesFmTorch +from etna.libs.timesfm.timesfm_base import TimesFmHparams, TimesFmCheckpoint diff --git a/etna/libs/timesfm/patched_decoder.py b/etna/libs/timesfm/patched_decoder.py new file mode 100644 index 000000000..53cd5c6c1 --- /dev/null +++ b/etna/libs/timesfm/patched_decoder.py @@ -0,0 +1,948 @@ +""" + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + 1. Definitions. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. +""" + +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Note: Copied from timesfm repository (https://github.com/google-research/timesfm/blob/154248137ccce29b01f4c3a765e85c3d9e4d92ba/src/timesfm/patched_decoder.py) + +"""Pytorch version of patched decoder.""" + +import dataclasses +import math +from typing import List, Tuple, Optional +import torch +from torch import nn +import torch.nn.functional as F + + +def _create_quantiles() -> List[float]: + return [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] + + +@dataclasses.dataclass +class TimesFMConfig: + """Config for initializing timesfm patched_decoder class.""" + + # The number of blocks in the model. + num_layers: int = 20 + # The number of attention heads used in the attention layers of the model. + num_heads: int = 16 + # The number of key-value heads for implementing attention. + num_kv_heads: int = 16 + # The hidden size of the model. + hidden_size: int = 1280 + # The dimension of the MLP representations. + intermediate_size: int = 1280 + # The number of head dimensions. + head_dim: int = 80 + # The epsilon used by the rms normalization layers. + rms_norm_eps: float = 1e-6 + # Patch length + patch_len: int = 32 + # Horizon length + horizon_len: int = 128 + # quantiles + quantiles: List[float] = dataclasses.field(default_factory=_create_quantiles) + # Padding value + pad_val: float = 1123581321.0 + # Tolerance + tolerance: float = 1e-6 + # The dtype of the weights. + dtype: str = "bfloat32" + # use positional embedding + use_positional_embedding: bool = True + + +def _masked_mean_std( + inputs: torch.Tensor, + padding: torch.Tensor +) -> Tuple[torch.Tensor, torch.Tensor]: + """Calculates mean and standard deviation of `inputs` across axis 1. + + It excludes values where `padding` is 1. + + Args: + inputs: A PyTorch tensor of shape [b, n, p]. + padding: A PyTorch tensor of shape [b, n, p] with values 0 or 1. + + Returns: + A tuple containing the mean and standard deviation. + We return the statistics of the first patch with more than three non-padded + values. + """ + # Selecting the first patch with more than 3 unpadded values. + pad_sum = torch.sum(1 - padding, dim=2) + + def _get_patch_index(arr: torch.Tensor): + indices = torch.argmax((arr >= 3).to(torch.int32), dim=1) + row_sum = (arr >= 3).to(torch.int32).sum(dim=1) + return torch.where(row_sum == 0, arr.shape[1] - 1, indices) + + patch_indices = _get_patch_index(pad_sum) + bidxs = torch.arange(inputs.shape[0]) + + arr = inputs[bidxs, patch_indices, :] + pad = padding[bidxs, patch_indices, :] + + # Create a mask where padding is 0 + mask = 1 - pad + + # Calculate the number of valid elements + num_valid_elements = torch.sum(mask, dim=1) + num_valid_elements = torch.where( + num_valid_elements == 0, + torch.tensor(1, + dtype=num_valid_elements.dtype, + device=num_valid_elements.device), + num_valid_elements, + ) + + # Calculate the masked sum and squared sum + masked_sum = torch.sum(arr * mask, dim=1) + masked_squared_sum = torch.sum((arr * mask)**2, dim=1) + + # Calculate the masked mean and standard deviation + masked_mean = masked_sum / num_valid_elements + masked_var = masked_squared_sum / num_valid_elements - masked_mean**2 + masked_var = torch.where( + masked_var < 0.0, + torch.tensor(0.0, dtype=masked_var.dtype, device=masked_var.device), + masked_var, + ) + masked_std = torch.sqrt(masked_var) + + return masked_mean, masked_std + + +def _shift_padded_seq(mask: torch.Tensor, seq: torch.Tensor) -> torch.Tensor: + """Shifts rows of seq based on the first 0 in each row of the mask. + + Args: + mask: mask tensor of shape [B, N] + seq: seq tensor of shape [B, N, P] + + Returns: + Returns the shifted sequence. + """ + batch_size, num_seq, feature_dim = seq.shape + + new_mask: torch.BoolTensor = mask == 0 + + # Use argmax to find the first True value in each row + indices = new_mask.to(torch.int32).argmax(dim=1) + + # Handle rows with all zeros + indices[~new_mask.any(dim=1)] = -1 + + # Create index ranges for each sequence in the batch + idx_range = (torch.arange(num_seq).to( + seq.device).unsqueeze(0).unsqueeze(-1).expand(batch_size, -1, + feature_dim)) + + # Calculate shifted indices for each element in each sequence + shifted_idx = (idx_range - indices[:, None, None]) % num_seq + + # Gather values from seq using shifted indices + shifted_seq = seq.gather(1, shifted_idx) + + return shifted_seq + + +def get_large_negative_number(dtype: torch.dtype) -> torch.Tensor: + """Returns a large negative value for the given dtype.""" + if dtype.is_floating_point: + dtype_max = torch.finfo(dtype).max + else: + dtype_max = torch.iinfo(dtype).max + return torch.tensor(-0.7 * dtype_max, dtype=dtype) + + +def apply_mask_to_logits(logits: torch.Tensor, mask: torch.Tensor) -> torch.Tensor: + """Applies a floating-point mask to a set of logits. + + Args: + logits: A torch.Tensor of logit values. + mask: A torch.Tensor (float32) of mask values with the encoding described + in the function documentation. + + Returns: + Masked logits. + """ + + min_value = get_large_negative_number(logits.dtype) + + return torch.where((mask >= min_value * 0.5), logits, min_value) + + +def convert_paddings_to_mask(paddings: torch.Tensor, dtype: torch.dtype = torch.float32) -> torch.Tensor: + """Converts binary paddings to a logit mask ready to add to attention matrix. + + Args: + paddings: binary torch.Tensor of shape [B, T], with 1 denoting padding + token. + dtype: data type of the input. + + Returns: + A torch.Tensor of shape [B, 1, 1, T] ready to add to attention logits. + """ + attention_mask = paddings.detach().clone() + attention_mask = attention_mask[:, None, None, :] # Equivalent to jnp.newaxis + attention_mask *= get_large_negative_number(dtype) + return attention_mask + + +def causal_mask(input_t: torch.Tensor) -> torch.Tensor: + """Computes and returns causal mask. + + Args: + input_t: A torch.Tensor of shape [B, T, D]. + + Returns: + An attention_mask torch.Tensor of shape [1, 1, T, T]. Attention mask has + already been converted to large negative values. + """ + assert input_t.dtype.is_floating_point, input_t.dtype + large_negative_number = get_large_negative_number(input_t.dtype) + t = input_t.shape[1] + col_idx = torch.arange(t).unsqueeze(0).repeat(t, 1) + row_idx = torch.arange(t).unsqueeze(1).repeat(1, t) + mask = (row_idx < col_idx).to(input_t.dtype) * large_negative_number + return mask.unsqueeze(0).unsqueeze(0).to(input_t.device) # Equivalent to jnp.newaxis + + +def merge_masks(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + """Merges 2 masks. + + logscale mask is expected but 0/1 mask is also fine. + + Args: + a: torch.Tensor of shape [1|B, 1, 1|T, S]. + b: torch.Tensor of shape [1|B, 1, 1|T, S]. + + Returns: + torch.Tensor of shape [1|B, 1, 1|T, S]. + """ + + def expand_t(key_mask): + query_mask = key_mask.transpose(-1, -2) # Equivalent of jnp.transpose + return torch.minimum(query_mask, key_mask) + + if a.shape[2] != b.shape[2]: + if a.shape[2] == 1: + a = expand_t(a) + else: + assert b.shape[2] == 1 + b = expand_t(b) + + assert a.shape[1:] == b.shape[1:], f"a.shape={a.shape}, b.shape={b.shape}." + return torch.minimum(a, b) # Element-wise minimum, similar to jnp.minimum + + +class ResidualBlock(nn.Module): + """TimesFM residual block.""" + + def __init__( + self, + input_dims, + hidden_dims, + output_dims, + ): + super(ResidualBlock, self).__init__() + self.input_dims = input_dims + self.hidden_dims = hidden_dims + self.output_dims = output_dims + + # Hidden Layer + self.hidden_layer = nn.Sequential( + nn.Linear(input_dims, hidden_dims), + nn.SiLU(), + ) + + # Output Layer + self.output_layer = nn.Linear(hidden_dims, output_dims) + # Residual Layer + self.residual_layer = nn.Linear(input_dims, output_dims) + + def forward(self, x): + hidden = self.hidden_layer(x) + output = self.output_layer(hidden) + residual = self.residual_layer(x) + return output + residual + + +class RMSNorm(torch.nn.Module): + """Pax rms norm in pytorch.""" + + def __init__( + self, + dim: int, + eps: float = 1e-6, + add_unit_offset: bool = False, + ): + super().__init__() + self.eps = eps + self.add_unit_offset = add_unit_offset + self.weight = nn.Parameter(torch.zeros(dim)) + + def _norm(self, x): + return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) + + def forward(self, x): + output = self._norm(x.float()) + if self.add_unit_offset: + output = output * (1 + self.weight.float()) + else: + output = output * self.weight.float() + return output.type_as(x) + + +class TransformerMLP(nn.Module): + """Pax transformer MLP in pytorch.""" + + def __init__( + self, + hidden_size: int, + intermediate_size: int, + ): + super().__init__() + self.gate_proj = nn.Linear(hidden_size, intermediate_size) + self.down_proj = nn.Linear(intermediate_size, hidden_size) + self.layer_norm = nn.LayerNorm(normalized_shape=hidden_size, eps=1e-6) + + def forward(self, x, paddings=None): + gate_inp = self.layer_norm(x) + gate = self.gate_proj(gate_inp) + gate = F.relu(gate) + outputs = self.down_proj(gate) + if paddings is not None: + outputs = outputs * (1.0 - paddings[:, :, None]) + return outputs + x + + +class TimesFMAttention(nn.Module): + """Implements the attention used in TimesFM.""" + + def __init__( + self, + hidden_size: int, + num_heads: int, + num_kv_heads: int, + head_dim: int, + ): + super().__init__() + + self.num_heads = num_heads + self.num_kv_heads = num_kv_heads + + assert self.num_heads % self.num_kv_heads == 0 + self.num_queries_per_kv = self.num_heads // self.num_kv_heads + + self.hidden_size = hidden_size + self.head_dim = head_dim + + self.q_size = self.num_heads * self.head_dim + self.kv_size = self.num_kv_heads * self.head_dim + self.scaling = nn.Parameter( + torch.empty((self.head_dim,), dtype=torch.float32),) + + self.qkv_proj = nn.Linear( + self.hidden_size, + (self.num_heads + 2 * self.num_kv_heads) * self.head_dim, + ) + self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size) + + def _per_dim_scaling(self, query: torch.Tensor) -> torch.Tensor: + # [batch_size, n_local_heads, input_len, head_dim] + r_softplus_0 = 1.442695041 + softplus_func = torch.nn.Softplus() + scale = r_softplus_0 / math.sqrt(self.head_dim) + scale = scale * softplus_func(self.scaling) + return query * scale[None, None, None, :] + + def forward( + self, + hidden_states: torch.Tensor, + mask: torch.Tensor, + kv_write_indices: Optional[torch.Tensor] = None, + kv_cache: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + ) -> torch.Tensor: + hidden_states_shape = hidden_states.shape + assert len(hidden_states_shape) == 3 + + batch_size, input_len, _ = hidden_states_shape + + qkv = self.qkv_proj(hidden_states) + xq, xk, xv = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1) + + xq = xq.view(batch_size, -1, self.num_heads, self.head_dim) + xk = xk.view(batch_size, -1, self.num_kv_heads, self.head_dim) + xv = xv.view(batch_size, -1, self.num_kv_heads, self.head_dim) + xq = self._per_dim_scaling(xq) + + # Write new kv cache. + # [batch_size, input_len, n_local_kv_heads, head_dim] + if kv_cache is not None and kv_write_indices is not None: + k_cache, v_cache = kv_cache + k_cache.index_copy_(1, kv_write_indices, xk) + v_cache.index_copy_(1, kv_write_indices, xv) + + key = k_cache + value = v_cache + else: + key = xk + value = xv + if self.num_kv_heads != self.num_heads: + # [batch_size, max_seq_len, n_local_heads, head_dim] + key = torch.repeat_interleave(key, self.num_queries_per_kv, dim=2) + value = torch.repeat_interleave(value, self.num_queries_per_kv, dim=2) + + # [batch_size, n_local_heads, input_len, head_dim] + q = xq.transpose(1, 2) + # [batch_size, n_local_heads, max_seq_len, head_dim] + k = key.transpose(1, 2) + v = value.transpose(1, 2) + + # [batch_size, n_local_heads, input_len, max_seq_len] + scores = torch.matmul(q, k.transpose(2, 3)) + scores = scores + mask + scores = F.softmax(scores.float(), dim=-1).type_as(q) + + # [batch_size, n_local_heads, input_len, head_dim] + output = torch.matmul(scores, v) + # return scores, output.transpose(1, 2).contiguous() + + # [batch_size, input_len, hidden_dim] + output = output.transpose(1, 2).contiguous().view(batch_size, input_len, -1) + output = self.o_proj(output) + return scores, output + + +class TimesFMDecoderLayer(nn.Module): + """Transformer layer.""" + + def __init__( + self, + hidden_size: int, + intermediate_size: int, + num_heads: int, + num_kv_heads: int, + head_dim: int, + rms_norm_eps: float = 1e-6, + ): + super().__init__() + self.self_attn = TimesFMAttention( + hidden_size=hidden_size, + num_heads=num_heads, + num_kv_heads=num_kv_heads, + head_dim=head_dim, + ) + self.mlp = TransformerMLP( + hidden_size=hidden_size, + intermediate_size=intermediate_size, + ) + self.input_layernorm = RMSNorm(hidden_size, eps=rms_norm_eps) + + def forward( + self, + hidden_states: torch.Tensor, + mask: torch.Tensor, + paddings: torch.Tensor, + kv_write_indices: Optional[torch.Tensor] = None, + kv_cache: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + ) -> torch.Tensor: + # Self Attention + residual = hidden_states + hidden_states = self.input_layernorm(hidden_states) + scores, hidden_states = self.self_attn( + hidden_states=hidden_states, + mask=mask, + kv_write_indices=kv_write_indices, + kv_cache=kv_cache, + ) + hidden_states = residual + hidden_states + + # MLP + hidden_states = self.mlp(hidden_states, paddings=paddings) + + return scores, hidden_states + + +class StackedDecoder(nn.Module): + """Stacked transformer layer.""" + + def __init__( + self, + hidden_size: int, + intermediate_size: int, + num_heads: int, + num_kv_heads: int, + head_dim: int, + num_layers: int, + rms_norm_eps: float = 1e-6, + ): + super().__init__() + + self.layers = nn.ModuleList() + for _ in range(num_layers): + self.layers.append( + TimesFMDecoderLayer( + hidden_size=hidden_size, + intermediate_size=intermediate_size, + num_heads=num_heads, + num_kv_heads=num_kv_heads, + head_dim=head_dim, + rms_norm_eps=rms_norm_eps, + )) + + def forward( + self, + hidden_states: torch.Tensor, + paddings: torch.Tensor, + kv_write_indices: Optional[torch.Tensor] = None, + kv_caches: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] = None, + ) -> torch.Tensor: + padding_mask = convert_paddings_to_mask(paddings, hidden_states.dtype) + atten_mask = causal_mask(hidden_states) + mask = merge_masks(padding_mask, atten_mask) + for i in range(len(self.layers)): + layer = self.layers[i] + kv_cache = kv_caches[i] if kv_caches is not None else None + _, hidden_states = layer( + hidden_states=hidden_states, + mask=mask, + paddings=paddings, + kv_write_indices=kv_write_indices, + kv_cache=kv_cache, + ) + return hidden_states + + +class PositionalEmbedding(torch.nn.Module): + """Generates position embedding for a given 1-d sequence. + + Attributes: + min_timescale: Start of the geometric index. Determines the periodicity of + the added signal. + max_timescale: End of the geometric index. Determines the frequency of the + added signal. + embedding_dims: Dimension of the embedding to be generated. + """ + + def __init__( + self, + embedding_dims: int, + min_timescale: int = 1, + max_timescale: int = 10_000, + ) -> None: + super().__init__() + self.min_timescale = min_timescale + self.max_timescale = max_timescale + self.embedding_dims = embedding_dims + + def forward(self, seq_length=None, position=None): + """Generates a Tensor of sinusoids with different frequencies. + + Args: + seq_length: an optional Python int defining the output sequence length. + if the `position` argument is specified. + position: [B, seq_length], optional position for each token in the + sequence, only required when the sequence is packed. + + Returns: + [B, seqlen, D] if `position` is specified, else [1, seqlen, D] + """ + if position is None: + assert seq_length is not None + # [1, seqlen] + position = torch.arange(seq_length, dtype=torch.float32).unsqueeze(0) + else: + assert position.ndim == 2, position.shape + + num_timescales = self.embedding_dims // 2 + log_timescale_increment = math.log( + float(self.max_timescale) / float(self.min_timescale)) / max( + num_timescales - 1, 1) + inv_timescales = self.min_timescale * torch.exp( + torch.arange(num_timescales, dtype=torch.float32) * + -log_timescale_increment) + scaled_time = position.unsqueeze(2) * inv_timescales.unsqueeze(0).unsqueeze( + 0) + signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], dim=2) + # Padding to ensure correct embedding dimension + signal = F.pad(signal, (0, 0, 0, self.embedding_dims % 2)) + return signal + + +class PatchedTimeSeriesDecoder(nn.Module): + """Patched time-series decoder.""" + + def __init__(self, config: TimesFMConfig): + super().__init__() + self.config = config + self.input_ff_layer = ResidualBlock( + input_dims=2 * config.patch_len, + output_dims=config.hidden_size, + hidden_dims=config.intermediate_size, + ) + self.freq_emb = nn.Embedding(num_embeddings=3, + embedding_dim=config.hidden_size) + self.horizon_ff_layer = ResidualBlock( + input_dims=config.hidden_size, + output_dims=config.horizon_len * (1 + len(config.quantiles)), + hidden_dims=config.intermediate_size, + ) + self.stacked_transformer = StackedDecoder( + hidden_size=self.config.hidden_size, + intermediate_size=self.config.intermediate_size, + num_heads=self.config.num_heads, + num_kv_heads=self.config.num_kv_heads, + head_dim=self.config.head_dim, + num_layers=self.config.num_layers, + rms_norm_eps=self.config.rms_norm_eps, + ) + if self.config.use_positional_embedding: + self.position_emb = PositionalEmbedding(self.config.hidden_size) + + def _forward_transform( + self, inputs: torch.Tensor, patched_pads: torch.Tensor + ) -> Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + """Input is of shape [B, N, P].""" + mu, sigma = _masked_mean_std(inputs, patched_pads) + sigma = torch.where( + sigma < self.config.tolerance, + torch.tensor(1.0, dtype=sigma.dtype, device=sigma.device), + sigma, + ) + + # Normalize each patch + outputs = (inputs - mu[:, None, None]) / sigma[:, None, None] + outputs = torch.where( + torch.abs(inputs - self.config.pad_val) < self.config.tolerance, + torch.tensor(self.config.pad_val, + dtype=outputs.dtype, + device=outputs.device), + outputs, + ) + return outputs, (mu, sigma) + + def _reverse_transform(self, outputs: torch.Tensor, stats: Tuple[torch.Tensor, torch.Tensor]) -> torch.Tensor: + """Output is of shape [B, N, P, Q].""" + mu, sigma = stats + return outputs * sigma[:, None, None, None] + mu[:, None, None, None] + + def _preprocess_input( + self, + input_ts: torch.Tensor, + input_padding: torch.Tensor, + ) -> Tuple[ + torch.Tensor, + torch.Tensor, + Optional[Tuple[torch.Tensor, torch.Tensor]], + torch.Tensor, + ]: + """Preprocess input for stacked transformer.""" + + # Reshape into patches (using view for efficiency) + bsize = input_ts.shape[0] + patched_inputs = input_ts.view(bsize, -1, self.config.patch_len) + patched_pads = input_padding.view(bsize, -1, self.config.patch_len) + + patched_inputs = torch.where( + torch.abs(patched_pads - 1.0) < self.config.tolerance, + torch.tensor(0.0, + dtype=patched_inputs.dtype, + device=patched_inputs.device), + patched_inputs, + ) + patched_pads = torch.where( + torch.abs(patched_inputs - self.config.pad_val) < self.config.tolerance, + torch.tensor(1.0, dtype=patched_pads.dtype, device=patched_pads.device), + patched_pads, + ) + patched_inputs, stats = self._forward_transform(patched_inputs, + patched_pads) + + # B x N x D + patched_inputs = patched_inputs * (1.0 - patched_pads) + concat_inputs = torch.cat([patched_inputs, patched_pads], dim=-1) + model_input = self.input_ff_layer(concat_inputs) + + # A patch should not be padded even if there is at least one zero. + patched_padding = torch.min(patched_pads, + dim=-1)[0] # Get the values from the min result + if self.config.use_positional_embedding: + pos_emb = self.position_emb(model_input.shape[1]).to(model_input.device) + pos_emb = torch.concat([pos_emb] * model_input.shape[0], dim=0) + pos_emb = _shift_padded_seq(patched_padding, pos_emb) + model_input += pos_emb + + return model_input, patched_padding, stats, patched_inputs + + def _postprocess_output( + self, + model_output: torch.Tensor, + num_outputs: int, + stats: Tuple[torch.Tensor, torch.Tensor], + ) -> torch.Tensor: + """Postprocess output of stacked transformer.""" + + # B x N x (H.Q) + output_ts = self.horizon_ff_layer(model_output) + + # Reshape using view + b, n, _ = output_ts.shape + output_ts = output_ts.view(b, n, self.config.horizon_len, num_outputs) + + return self._reverse_transform(output_ts, stats) + + def forward( + self, + input_ts: torch.Tensor, + input_padding: torch.LongTensor, + freq: torch.Tensor, + ) -> torch.Tensor: + num_outputs = len(self.config.quantiles) + 1 + model_input, patched_padding, stats, _ = self._preprocess_input( + input_ts=input_ts, + input_padding=input_padding, + ) + f_emb = self.freq_emb(freq) # B x 1 x D + model_input += f_emb + model_output = self.stacked_transformer(model_input, patched_padding) + + output_ts = self._postprocess_output(model_output, num_outputs, stats) + return output_ts + + def decode( + self, + input_ts: torch.Tensor, + paddings: torch.Tensor, + freq: torch.LongTensor, + horizon_len: int, + output_patch_len: Optional[int] = None, + max_len: int = 512, + return_forecast_on_context: bool = False, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """Auto-regressive decoding without caching. + + Args: + input_ts: input time-series and paddings. Time-series shape B x C. + paddings: padding shape B x (C + H) where H is the prediction length. + freq: frequency shape B x 1 + horizon_len: prediction length. + output_patch_len: output length to be fetched from one step of + auto-regressive decoding. + max_len: maximum training context length. + return_forecast_on_context: whether to return the model forecast on the + context except the first input patch. + + Returns: + Tuple of two forecasting results: + - Point (mean) output predictions as a tensor with shape B x H'. + - Full predictions (mean and quantiles) as a tensor with shape + B x H' x (1 + # quantiles). + In particular, if return_forecast_on_context is True, H' is H plus + the forecastable context length, i.e. context_len - (first) patch_len. + """ + final_out = input_ts + context_len = final_out.shape[1] + full_outputs = [] + if paddings.shape[1] != final_out.shape[1] + horizon_len: + raise ValueError( + "Length of paddings must match length of input + horizon_len:" + f" {paddings.shape[1]} != {final_out.shape[1]} + {horizon_len}") + if output_patch_len is None: + output_patch_len = self.config.horizon_len + num_decode_patches = (horizon_len + output_patch_len - 1) // output_patch_len + for step_index in range(num_decode_patches): + current_padding = paddings[:, 0:final_out.shape[1]] + input_ts = final_out[:, -max_len:] + input_padding = current_padding[:, -max_len:] + fprop_outputs = self(input_ts, input_padding, freq) + if return_forecast_on_context and step_index == 0: + # For the first decodings step, collect the model forecast on the + # context except the unavailable first input batch forecast. + new_full_ts = fprop_outputs[:, :-1, :self.config.patch_len, :] + new_full_ts = fprop_outputs.view(new_full_ts.size(0), -1, + new_full_ts.size(3)) + + full_outputs.append(new_full_ts) + + # (full batch, last patch, output_patch_len, index of mean forecast = 0) + new_ts = fprop_outputs[:, -1, :output_patch_len, 0] + new_full_ts = fprop_outputs[:, -1, :output_patch_len, :] + # (full batch, last patch, output_patch_len, all output indices) + full_outputs.append(new_full_ts) + final_out = torch.concat([final_out, new_ts], dim=-1) # TODO torch.concatenate(axis) => torch.concat(dim) + + if return_forecast_on_context: + # `full_outputs` indexing starts at after the first input patch. + full_outputs = torch.concat( # TODO torch.concatenate(axis) => torch.concat(dim) + full_outputs, + dim=1)[:, :(context_len - self.config.patch_len + horizon_len), :] + else: + # `full_outputs` indexing starts at the forecast horizon. + full_outputs = torch.concat(full_outputs, dim=1)[:, 0:horizon_len, :] # TODO torch.concatenate(axis) => torch.concat(dim) + + return full_outputs[:, :, 0], full_outputs diff --git a/etna/libs/timesfm/timesfm.py b/etna/libs/timesfm/timesfm.py new file mode 100644 index 000000000..d46782e3c --- /dev/null +++ b/etna/libs/timesfm/timesfm.py @@ -0,0 +1,325 @@ +""" + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + 1. Definitions. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. +""" + +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Note: Copied from timesfm repository (https://github.com/google-research/timesfm/blob/154248137ccce29b01f4c3a765e85c3d9e4d92ba/src/timesfm/timesfm_torch.py) +# Add method to change horizon after initialization. +# Minor logic change of loading model. + +"""TimesFM pytorch forecast API for inference.""" + +import logging +from os import path +from typing import Any, Sequence, Optional, Tuple +import os +import numpy as np +import torch +from huggingface_hub import snapshot_download +from etna.libs.timesfm import timesfm_base + +from etna.libs.timesfm import patched_decoder as ppd + +_TOL = 1e-6 + + +class TimesFmTorch(timesfm_base.TimesFmBase): + """TimesFM forecast API for inference.""" + + def __post_init__(self): + self._model_config = ppd.TimesFMConfig( + num_layers=self.num_layers, + num_heads=self.num_heads, + hidden_size=self.model_dims, + intermediate_size=self.model_dims, + patch_len=self.input_patch_len, + horizon_len=self.output_patch_len, + head_dim=self.model_dims // self.num_heads, + quantiles=self.quantiles, + use_positional_embedding=self.use_pos_emb, + ) + self._model = None + self.num_cores = 1 + self.global_batch_size = self.per_core_batch_size + self._device = torch.device("cuda:0" if ( + torch.cuda.is_available() and self.backend == "gpu") else "cpu") + self._median_index = -1 + + def _set_horizon(self, horizon): # changed: added to change horizon after initialization + self.horizon_len = horizon + + def load_from_checkpoint( + self, + checkpoint: timesfm_base.TimesFmCheckpoint, + ) -> None: + """Loads a checkpoint and compiles the decoder.""" + checkpoint_path = checkpoint.path + repo_id = checkpoint.huggingface_repo_id + if not os.path.exists(checkpoint_path): # changed: make loading similar to chronos + checkpoint_path = path.join(snapshot_download(checkpoint_path, cache_dir=checkpoint.local_dir), "torch_model.ckpt") + self._model = ppd.PatchedTimeSeriesDecoder(self._model_config) + loaded_checkpoint = torch.load(checkpoint_path) # changed: remove weights_only=True due to attribute absence in low torch versions + logging.info("Loading checkpoint from %s", checkpoint_path) + self._model.load_state_dict(loaded_checkpoint) + logging.info("Sending checkpoint to device %s", f"{self._device}") + self._model.to(self._device) + self._model.eval() + # TODO: add compilation. + + def _forecast( + self, + inputs: Sequence[Any], + freq: Optional[Sequence[int]] = None, + window_size: Optional[int] = None, + forecast_context_len: Optional[int] = None, + return_forecast_on_context: bool = False, + ) -> Tuple[np.ndarray, np.ndarray]: + """Forecasts on a list of time series. + + Args: + inputs: list of time series forecast contexts. Each context time series + should be in a format convertible to JTensor by `jnp.array`. + freq: frequency of each context time series. 0 for high frequency + (default), 1 for medium, and 2 for low. Notice this is different from + the `freq` required by `forecast_on_df`. + window_size: window size of trend + residual decomposition. If None then + we do not do decomposition. + forecast_context_len: optional max context length. + return_forecast_on_context: True to return the forecast on the context + when available, i.e. after the first input patch. + + Returns: + A tuple for JTensors: + - the mean forecast of size (# inputs, # forecast horizon), + - the full forecast (mean + quantiles) of size + (# inputs, # forecast horizon, 1 + # quantiles). + + Raises: + ValueError: If the checkpoint is not properly loaded. + """ + if not self._model: + raise ValueError( + "Checkpoint not loaded. Call `load_from_checkpoint` before" + " `forecast`.") + if forecast_context_len is None: + fcontext_len = self.context_len + else: + fcontext_len = forecast_context_len + inputs = [np.array(ts)[-fcontext_len:] for ts in inputs] + + if window_size is not None: + new_inputs = [] + for ts in inputs: + new_inputs.extend(timesfm_base.moving_average(ts, window_size)) + inputs = new_inputs + + if freq is None: + logging.info("No frequency provided via `freq`. Default to high (0).") + freq = [0] * len(inputs) + + input_ts, input_padding, inp_freq, pmap_pad = self._preprocess(inputs, freq) + with torch.no_grad(): + mean_outputs = [] + full_outputs = [] + assert input_ts.shape[0] % self.global_batch_size == 0 + for i in range(input_ts.shape[0] // self.global_batch_size): + input_ts_in = torch.from_numpy( + np.array(input_ts[i * self.global_batch_size:(i + 1) * + self.global_batch_size], + dtype=np.float32)).to(self._device) + input_padding_in = torch.from_numpy( + np.array(input_padding[i * self.global_batch_size:(i + 1) * + self.global_batch_size], + dtype=np.float32)).to(self._device) + inp_freq_in = torch.from_numpy( + np.array(inp_freq[ + i * self.global_batch_size:(i + 1) * self.global_batch_size, + :, + ], + dtype=np.int32)).long().to(self._device) + mean_output, full_output = self._model.decode( + input_ts=input_ts_in, + paddings=input_padding_in, + freq=inp_freq_in, + horizon_len=self.horizon_len, + return_forecast_on_context=return_forecast_on_context, + ) + mean_output = mean_output.detach().cpu().numpy() + full_output = full_output.detach().cpu().numpy() + mean_output = np.array(mean_output) + full_output = np.array(full_output) + mean_outputs.append(mean_output) + full_outputs.append(full_output) + + mean_outputs = np.concatenate(mean_outputs, axis=0) + full_outputs = np.concatenate(full_outputs, axis=0) + + if pmap_pad > 0: + mean_outputs = mean_outputs[:-pmap_pad, ...] + full_outputs = full_outputs[:-pmap_pad, ...] + + if window_size is not None: + mean_outputs = mean_outputs[0::2, ...] + mean_outputs[1::2, ...] + full_outputs = full_outputs[0::2, ...] + full_outputs[1::2, ...] + return mean_outputs, full_outputs \ No newline at end of file diff --git a/etna/libs/timesfm/timesfm_base.py b/etna/libs/timesfm/timesfm_base.py new file mode 100644 index 000000000..14755cbb3 --- /dev/null +++ b/etna/libs/timesfm/timesfm_base.py @@ -0,0 +1,812 @@ +""" + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + 1. Definitions. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. +""" + +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Note: Copied from timesfm repository (https://github.com/google-research/timesfm/blob/154248137ccce29b01f4c3a765e85c3d9e4d92ba/src/timesfm/timesfm_base.py) +# replace print with logging + +import warnings + +"""Base class for TimesFM inference. This will be common to PAX and Pytorch.""" + +import collections +import dataclasses +import logging +import multiprocessing +from typing import Any, Literal, Sequence, Optional, Tuple, List, Dict, Union +from pathlib import Path +import numpy as np +import pandas as pd + +from utilsforecast.processing import make_future_dataframe + +from etna.libs.timesfm import xreg_lib + +Category = xreg_lib.Category +XRegMode = xreg_lib.XRegMode + +_TOL = 1e-6 +DEFAULT_QUANTILES = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9) + + +def process_group(key, group, value_name, forecast_context_len): + group = group.tail(forecast_context_len) + return np.array(group[value_name], dtype=np.float32), key + + +def moving_average(arr, window_size): + """Calculates the moving average using NumPy's convolution function.""" + # Pad with zeros to handle initial window positions + arr_padded = np.pad(arr, (window_size - 1, 0), "constant") + smoothed_arr = (np.convolve(arr_padded, np.ones(window_size), "valid") / + window_size) + return [smoothed_arr, arr - smoothed_arr] + + +def freq_map(freq: Optional[str]): + """Returns the frequency map for the given frequency string.""" + if freq is None: # changed: added this case to handle int timestamps during forecasting with exogenous features + warnings.warn("Frequency is None. Mapping it to 0, that can be not optimal. Better to set it to known frequency") + return 0 + freq = str.upper(freq) + if (freq.endswith("H") or freq.endswith("T") or freq.endswith("MIN") or + freq.endswith("D") or freq.endswith("B") or freq.endswith("U")): + return 0 + elif freq.endswith(("W", "M", "MS")): + return 1 + elif freq.endswith("Y") or freq.endswith("Q"): + return 2 + else: + raise ValueError(f"Invalid frequency: {freq}") + + +# Per time series normalization: forward. +def _normalize(batch): + stats = [ + (np.mean(x), np.where((w := np.std(x)) > _TOL, w, 1.0)) for x in batch + ] + new_batch = [(x - stat[0]) / stat[1] for x, stat in zip(batch, stats)] + return new_batch, stats + + +# Per time series normalization: inverse. +def _renormalize(batch, stats): + return [x * stat[1] + stat[0] for x, stat in zip(batch, stats)] + + +@dataclasses.dataclass() +class TimesFmHparams: + """Hparams used to initialize a TimesFM model for inference. + + These are the sufficient subset of hparams to configure TimesFM inference + agnostic to the checkpoint version, and are not necessarily the same as the + hparams used to train the checkpoint. + + Attributes: + context_len: Largest context length the model allows for each decode call. + This technically can be any large, but practically should set to the + context length the checkpoint was trained with. + horizon_len: Forecast horizon. + input_patch_len: Input patch len. + output_patch_len: Output patch len. How many timepoints is taken from a + single step of autoregressive decoding. Can be set as the training horizon + of the checkpoint. + num_layers: Number of transformer layers in the model. + model_dims: Model dimension. + per_core_batch_size: Batch size on each core for data parallelism. + backend: One of "cpu", "gpu" or "tpu". + quantiles: Which quantiles are output by the model. + """ + + context_len: int = 512 + horizon_len: int = 128 + input_patch_len: int = 32 + output_patch_len: int = 128 + num_layers: int = 20 + num_heads: int = 16 + model_dims: int = 1280 + per_core_batch_size: int = 32 + backend: Literal["cpu", "gpu", "tpu"] = "cpu" + quantiles: Optional[Sequence[float]] = DEFAULT_QUANTILES + use_positional_embedding: bool = True + # Hparams beyond the model. + point_forecast_mode: Literal["mean", "median"] = "median" + + +@dataclasses.dataclass() +class TimesFmCheckpoint: + """Checkpoint used to initialize a TimesFM model for inference. + + Attributes: + version: Version of the checkpoint, e.g. "jax", "torch", "tensorflow", etc. + The factory will create the corresponding TimesFm inference class based on + this version. + path: Path to the checkpoint. + type: If provided, type of the checkpoint used by the specific checkpoint + loader per version. + step: If provided, step of the checkpoint. + """ + + version: str = "jax" + path: Optional[Union[str, Path]] = None + huggingface_repo_id: Optional[str] = None + type: Any = None + step: Optional[int] = None + local_dir: Optional[Union[str, Path]] = None + + +class TimesFmBase: + """Base TimesFM forecast API for inference. + + This class is the scaffolding for calling TimesFM forecast. To properly use: + 1. Create an instance with the correct hyperparameters of a TimesFM model. + 2. Call `load_from_checkpoint` to load a compatible checkpoint. + 3. Call `forecast` for inference. + """ + + def _logging(self, s): + print(s) + + def __post_init__(self) -> None: + """Additional initialization for subclasses before checkpoint loading.""" + pass + + def __init__(self, hparams: TimesFmHparams, + checkpoint: TimesFmCheckpoint) -> None: + """Initializes the TimesFM forecast API. + + Args: + hparams: Hyperparameters of the model. + checkpoint: Checkpoint to load. Notice `checkpoint.version` will decide + which TimesFM version to use. + """ + self.hparams = hparams + + # Expand hparams for conciseness within the model code. + self.context_len = hparams.context_len + self.horizon_len = hparams.horizon_len + self.input_patch_len = hparams.input_patch_len + self.output_patch_len = hparams.output_patch_len + self.num_layers = hparams.num_layers + self.model_dims = hparams.model_dims + self.backend = hparams.backend + self.quantiles = hparams.quantiles + self.num_heads = hparams.num_heads + self.use_pos_emb = hparams.use_positional_embedding + + # Rewrite these values in __post_init__ for SPMD. + self.num_cores = 1 + self.per_core_batch_size = hparams.per_core_batch_size + self.global_batch_size = hparams.per_core_batch_size + + self._horizon_start = self.context_len - self.input_patch_len + self.__post_init__() + self.load_from_checkpoint(checkpoint) + + def load_from_checkpoint(self, checkpoint: TimesFmCheckpoint) -> None: + """Loads a checkpoint and compiles the decoder.""" + raise NotImplementedError("`load_from_checkpoint` is not implemented.") + + def _preprocess( + self, inputs: Sequence[np.ndarray], + freq: Sequence[int]) -> Tuple[np.ndarray, np.ndarray, np.ndarray, int]: + """Formats and pads raw inputs to feed into the model. + + This function both pads each time series to match the context length, and + pads the inputs to meet the SPMD shape requirement. + + Args: + inputs: A list of 1d JTensors. Each JTensor is the context time series of + a single forecast task. + freq: list of frequencies + + Returns: + A tuple of: + - the padded input time series to meet the model required context. + - the padding indicator. + - the frequency of each input time series. + - the number of padded examples for SPMD so that each core has the same + number (a multiple of `batch_size`) of examples. + """ + + input_ts, input_padding, inp_freq = [], [], [] + + pmap_pad = ((len(inputs) - 1) // self.global_batch_size + + 1) * self.global_batch_size - len(inputs) + + for i, ts in enumerate(inputs): + input_len = ts.shape[0] + padding = np.zeros(shape=(input_len + self.horizon_len,), dtype=float) + if input_len < self.context_len: + num_front_pad = self.context_len - input_len + ts = np.concatenate([np.zeros(shape=(num_front_pad,), dtype=float), ts], + axis=0) + padding = np.concatenate( + [np.ones(shape=(num_front_pad,), dtype=float), padding], axis=0) + elif input_len > self.context_len: + ts = ts[-self.context_len:] + padding = padding[-(self.context_len + self.horizon_len):] + + input_ts.append(ts) + input_padding.append(padding) + inp_freq.append(freq[i]) + + # Padding the remainder batch. + for _ in range(pmap_pad): + input_ts.append(input_ts[-1]) + input_padding.append(input_padding[-1]) + inp_freq.append(inp_freq[-1]) + + return ( + np.stack(input_ts, axis=0), + np.stack(input_padding, axis=0), + np.array(inp_freq).astype(np.int32).reshape(-1, 1), + pmap_pad, + ) + + def _forecast( + self, + inputs: Sequence[Any], + freq: Optional[Sequence[int]] = None, + window_size: Optional[int] = None, + forecast_context_len: Optional[int] = None, + return_forecast_on_context: bool = False, + ) -> Tuple[np.ndarray, np.ndarray]: + """Forecasts on a list of time series. + + Args: + inputs: list of time series forecast contexts. Each context time series + should be in a format convertible to JTensor by `jnp.array`. + freq: frequency of each context time series. 0 for high frequency + (default), 1 for medium, and 2 for low. Notice this is different from + the `freq` required by `forecast_on_df`. + window_size: window size of trend + residual decomposition. If None then + we do not do decomposition. + forecast_context_len: optional max context length. + return_forecast_on_context: True to return the forecast on the context + when available, i.e. after the first input patch. + + Returns: + A tuple for np.array: + - the mean forecast of size (# inputs, # forecast horizon), + - the full forecast (mean + quantiles) of size + (# inputs, # forecast horizon, 1 + # quantiles). + + Raises: + ValueError: If the checkpoint is not properly loaded. + """ + raise NotImplementedError("`_forecast` is not implemented.") + + def forecast( + self, + inputs: Sequence[Any], + freq: Optional[Sequence[int]] = None, + window_size: Optional[int] = None, + forecast_context_len: Optional[int] = None, + return_forecast_on_context: bool = False, + normalize: bool = False, + ) -> Tuple[np.ndarray, np.ndarray]: + """Forecasts on a list of time series. + + Args: + inputs: list of time series forecast contexts. Each context time series + should be in a format convertible to JTensor by `jnp.array`. + freq: frequency of each context time series. 0 for high frequency + (default), 1 for medium, and 2 for low. Notice this is different from + the `freq` required by `forecast_on_df`. + window_size: window size of trend + residual decomposition. If None then + we do not do decomposition. + forecast_context_len: optional max context length. + return_forecast_on_context: True to return the forecast on the context + when available, i.e. after the first input patch. + normalize: If True, then we normalize the inputs before forecasting and + the outputs are then renormalized to the original scale. + + Returns: + A tuple for np.array: + - the mean forecast of size (# inputs, # forecast horizon), + - the full forecast (mean + quantiles) of size + (# inputs, # forecast horizon, 1 + # quantiles). + + Raises: + ValueError: If the checkpoint is not properly loaded. + """ + stats = None + if normalize: + inputs, stats = _normalize(inputs) + mean_forecast, quantile_forecast = self._forecast( + inputs, + freq, + window_size, + forecast_context_len, + return_forecast_on_context, + ) + if stats is not None: + stats = np.array(stats) + mu = stats[:, 0] + sigma = stats[:, 1] + mean_forecast = mean_forecast * sigma[:, None] + mu[:, None] + quantile_forecast = (quantile_forecast * sigma[:, None, None] + + mu[:, None, None]) + if self.hparams.point_forecast_mode == "mean": + return mean_forecast, quantile_forecast + elif self.hparams.point_forecast_mode == "median": + if self._median_index == -1: + for i, quantile in enumerate(self.quantiles): + if quantile == 0.5: + self._median_index = i + break + if self._median_index == -1: + raise ValueError("Median (0.5) is not found in the model quantiles:" + f" {self.quantiles}. Please check the hparams.") + return ( + quantile_forecast[:, :, 1 + self._median_index], + quantile_forecast, + ) + else: + raise ValueError( + "Unsupported point forecast mode:" + f" {self.hparams.point_forecast_mode}. Use 'mean' or 'median'.") + + def forecast_with_covariates( + self, + inputs: List[Sequence[float]], + dynamic_numerical_covariates: Optional[Dict[str, Sequence[Sequence[float]]]] = None, + dynamic_categorical_covariates: Optional[Dict[str, Sequence[Sequence[Category]]]] = None, + static_numerical_covariates: Optional[Dict[str, Sequence[float]]] = None, + static_categorical_covariates: Optional[Dict[str, Sequence[Category]]]= None, + freq: Optional[Sequence[int]] = None, + window_size: Optional[int] = None, + forecast_context_len: Optional[int]= None, + xreg_mode: XRegMode = "xreg + timesfm", + normalize_xreg_target_per_input: bool = True, + ridge: float = 0.0, + max_rows_per_col: int = 0, + force_on_cpu: bool = False, + ): + """Forecasts on a list of time series with covariates. + + To optimize inference speed, avoid string valued categorical covariates. + + Args: + inputs: A list of time series forecast contexts. Each context time series + should be in a format convertible to JTensor by `jnp.array`. + dynamic_numerical_covariates: A dict of dynamic numerical covariates. + dynamic_categorical_covariates: A dict of dynamic categorical covariates. + static_numerical_covariates: A dict of static numerical covariates. + static_categorical_covariates: A dict of static categorical covariates. + freq: frequency of each context time series. 0 for high frequency + (default), 1 for medium, and 2 for low. Notice this is different from + the `freq` required by `forecast_on_df`. + window_size: window size of trend + residual decomposition. If None then + we do not do decomposition. + forecast_context_len: optional max context length. + xreg_mode: one of "xreg + timesfm" or "timesfm + xreg". "xreg + timesfm" + fits a model on the residuals of the TimesFM forecast. "timesfm + xreg" + fits a model on the targets then forecasts on the residuals via TimesFM. + normalize_xreg_target_per_input: whether to normalize the xreg target per + input in the given batch. + ridge: ridge penalty for the linear model. + max_rows_per_col: max number of rows per column for the linear model. + force_on_cpu: whether to force running on cpu for the linear model. + + Returns: + A tuple of two lists. The first is the outputs of the model. The second is + the outputs of the xreg. + """ + + # Verify and bookkeep covariates. + if not (dynamic_numerical_covariates or dynamic_categorical_covariates or + static_numerical_covariates or static_categorical_covariates): + raise ValueError( + "At least one of dynamic_numerical_covariates," + " dynamic_categorical_covariates, static_numerical_covariates," + " static_categorical_covariates must be set.") + + # Track the lengths of (1) each input, (2) the part that can be used in the + # linear model, and (3) the horizon. + input_lens, train_lens, test_lens = [], [], [] + + for i, input_ts in enumerate(inputs): + input_len = len(input_ts) + input_lens.append(input_len) + + if xreg_mode == "timesfm + xreg": + # For fitting residuals, no TimesFM forecast on the first patch. + train_lens.append(max(0, input_len - self.input_patch_len)) + elif xreg_mode == "xreg + timesfm": + train_lens.append(input_len) + else: + raise ValueError(f"Unsupported mode: {xreg_mode}") + + if dynamic_numerical_covariates: + test_lens.append( + len(list(dynamic_numerical_covariates.values())[0][i]) - input_len) + elif dynamic_categorical_covariates: + test_lens.append( + len(list(dynamic_categorical_covariates.values())[0][i]) - + input_len) + else: + test_lens.append(self.horizon_len) + + if test_lens[-1] > self.horizon_len: + raise ValueError( + "Forecast requested longer horizon than the model definition " + f"supports: {test_lens[-1]} vs {self.horizon_len}.") + + # Prepare the covariates into train and test. + train_dynamic_numerical_covariates = collections.defaultdict(list) + test_dynamic_numerical_covariates = collections.defaultdict(list) + train_dynamic_categorical_covariates = collections.defaultdict(list) + test_dynamic_categorical_covariates = collections.defaultdict(list) + for covariates, train_covariates, test_covariates in ( + ( + dynamic_numerical_covariates, + train_dynamic_numerical_covariates, + test_dynamic_numerical_covariates, + ), + ( + dynamic_categorical_covariates, + train_dynamic_categorical_covariates, + test_dynamic_categorical_covariates, + ), + ): + if not covariates: + continue + for covariate_name, covariate_values in covariates.items(): + for input_len, train_len, covariate_value in zip( + input_lens, train_lens, covariate_values): + train_covariates[covariate_name].append( + covariate_value[(input_len - train_len):input_len]) + test_covariates[covariate_name].append(covariate_value[input_len:]) + + # Fit models. + if xreg_mode == "timesfm + xreg": + # Forecast via TimesFM then fit a model on the residuals. + mean_outputs, _ = self.forecast( + inputs, + freq, + window_size, + forecast_context_len, + return_forecast_on_context=True, + ) + targets = [ + (np.array(input_ts)[-train_len:] - + mean_output[(self._horizon_start - train_len):self._horizon_start]) + for input_ts, mean_output, train_len in zip(inputs, mean_outputs, + train_lens) + ] + per_instance_stats = None + if normalize_xreg_target_per_input: + targets, per_instance_stats = _normalize(targets) + xregs = xreg_lib.BatchedInContextXRegLinear( + targets=targets, + train_lens=train_lens, + test_lens=test_lens, + train_dynamic_numerical_covariates=train_dynamic_numerical_covariates, + test_dynamic_numerical_covariates=test_dynamic_numerical_covariates, + train_dynamic_categorical_covariates= + train_dynamic_categorical_covariates, + test_dynamic_categorical_covariates= + test_dynamic_categorical_covariates, + static_numerical_covariates=static_numerical_covariates, + static_categorical_covariates=static_categorical_covariates, + ).fit( + ridge=ridge, + one_hot_encoder_drop=None if ridge > 0 else "first", + max_rows_per_col=max_rows_per_col, + force_on_cpu=force_on_cpu, + debug_info=False, + assert_covariates=True, + assert_covariate_shapes=True, + ) + if normalize_xreg_target_per_input: + xregs = _renormalize(xregs, per_instance_stats) + outputs = [ + (mean_output[self._horizon_start:(self._horizon_start + test_len)] + + xreg) + for mean_output, test_len, xreg in zip(mean_outputs, test_lens, xregs) + ] + + else: + # Fit a model on the targets then forecast on the residuals via TimesFM. + targets = [ + np.array(input_ts)[-train_len:] + for input_ts, train_len in zip(inputs, train_lens) + ] + per_instance_stats = None + if normalize_xreg_target_per_input: + targets, per_instance_stats = _normalize(targets) + xregs, xregs_on_context, _, _, _ = xreg_lib.BatchedInContextXRegLinear( + targets=targets, + train_lens=train_lens, + test_lens=test_lens, + train_dynamic_numerical_covariates=train_dynamic_numerical_covariates, + test_dynamic_numerical_covariates=test_dynamic_numerical_covariates, + train_dynamic_categorical_covariates= + train_dynamic_categorical_covariates, + test_dynamic_categorical_covariates= + test_dynamic_categorical_covariates, + static_numerical_covariates=static_numerical_covariates, + static_categorical_covariates=static_categorical_covariates, + ).fit( + ridge=ridge, + one_hot_encoder_drop=None if ridge > 0 else "first", + max_rows_per_col=max_rows_per_col, + force_on_cpu=force_on_cpu, + debug_info=True, + assert_covariates=True, + assert_covariate_shapes=True, + ) + mean_outputs, _ = self.forecast( + [ + target - xreg_on_context + for target, xreg_on_context in zip(targets, xregs_on_context) + ], + freq, + window_size, + forecast_context_len, + return_forecast_on_context=True, + ) + outputs = [ + (mean_output[self._horizon_start:(self._horizon_start + test_len)] + + xreg) + for mean_output, test_len, xreg in zip(mean_outputs, test_lens, xregs) + ] + if normalize_xreg_target_per_input: + outputs = _renormalize(outputs, per_instance_stats) + + return outputs, xregs + + def forecast_on_df( + self, + inputs: pd.DataFrame, + freq: str, + forecast_context_len: int = 0, + value_name: str = "values", + model_name: str = "timesfm", + window_size: Optional[int] = None, + num_jobs: int = 1, + verbose: bool = True, + ) -> pd.DataFrame: + """Forecasts on a list of time series. + + Args: + inputs: A pd.DataFrame of all time series. The dataframe should have a + `unique_id` column for identifying the time series, a `ds` column for + timestamps and a value column for the time series values. + freq: string valued `freq` of data. Notice this is different from the + `freq` required by `forecast`. See `freq_map` for allowed values. + forecast_context_len: If provided none zero, we take the last + `forecast_context_len` time-points from each series as the forecast + context instead of the `context_len` set by the model. + value_name: The name of the value column. + model_name: name of the model to be written into future df. + window_size: window size of trend + residual decomposition. If None then + we do not do decomposition. + num_jobs: number of parallel processes to use for dataframe processing. + verbose: output model states in terminal. + + Returns: + Future forecasts dataframe. + """ + if not ("unique_id" in inputs.columns and "ds" in inputs.columns and + value_name in inputs.columns): + raise ValueError( + f"DataFrame must have unique_id, ds and {value_name} columns.") + if not forecast_context_len: + forecast_context_len = self.context_len + logging.info("Preprocessing dataframe.") + df_sorted = inputs.sort_values(by=["unique_id", "ds"]) + new_inputs = [] + uids = [] + if num_jobs == 1: + if verbose: + logging.info("Processing dataframe with single process.") # changed: replace print + for key, group in df_sorted.groupby("unique_id"): + inp, uid = process_group( + key, + group, + value_name, + forecast_context_len, + ) + new_inputs.append(inp) + uids.append(uid) + else: + if num_jobs == -1: + num_jobs = multiprocessing.cpu_count() + if verbose: + logging.info("Processing dataframe with multiple processes.") # changed: replace print + with multiprocessing.Pool(processes=num_jobs) as pool: + results = pool.starmap( + process_group, + [(key, group, value_name, forecast_context_len) + for key, group in df_sorted.groupby("unique_id")], + ) + new_inputs, uids = zip(*results) + if verbose: + logging.info("Finished preprocessing dataframe.") # changed: replace print + freq_inps = [freq_map(freq)] * len(new_inputs) + _, full_forecast = self.forecast(new_inputs, + freq=freq_inps, + window_size=window_size) + if verbose: + logging.info("Finished forecasting.") + fcst_df = make_future_dataframe( + uids=uids, + last_times=df_sorted.groupby("unique_id")["ds"].tail(1), + h=self.horizon_len, + freq=freq, + ) + fcst_df[model_name] = full_forecast[:, 0:self.horizon_len, 0].reshape(-1, 1) + + for i, q in enumerate(self.quantiles): + q_col = f"{model_name}-q-{q}" + fcst_df[q_col] = full_forecast[:, 0:self.horizon_len, + 1 + i].reshape(-1, 1) + if q == 0.5: + fcst_df[model_name] = fcst_df[q_col] + logging.info("Finished creating output dataframe.") + return fcst_df \ No newline at end of file diff --git a/etna/libs/timesfm/xreg_lib.py b/etna/libs/timesfm/xreg_lib.py new file mode 100644 index 000000000..4521009bf --- /dev/null +++ b/etna/libs/timesfm/xreg_lib.py @@ -0,0 +1,643 @@ +""" + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + 1. Definitions. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. +""" + +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Note: Copied from timesfm repository (https://github.com/google-research/timesfm/blob/154248137ccce29b01f4c3a765e85c3d9e4d92ba/src/timesfm/xreg_lib.py) +# add check of sklearn version for OHE +"""Helper functions for in-context covariates and regression.""" + +import itertools +import math +from typing import Any, Iterable, Literal, Mapping, Sequence, Union, Optional, Tuple, List + +import jax +import jax.numpy as jnp +import numpy as np +from sklearn import preprocessing +from sklearn import __version__ as sklearn_version + +Category = Union[int, str] + +_TOL = 1e-6 +XRegMode = Literal["timesfm + xreg", "xreg + timesfm"] + + +def _unnest(nested: Sequence[Sequence[Any]]) -> np.ndarray: + return np.array(list(itertools.chain.from_iterable(nested))) + + +def _repeat(elements: Iterable[Any], counts: Iterable[int]) -> np.ndarray: + return np.array( + list( + itertools.chain.from_iterable(map(itertools.repeat, elements, + counts)))) + + +def _to_padded_jax_array(x: np.ndarray) -> jax.Array: + if x.ndim == 1: + (i,) = x.shape + di = 2**math.ceil(math.log2(i)) - i + return jnp.pad(x, ((0, di),), mode="constant", constant_values=0.0) + elif x.ndim == 2: + i, j = x.shape + di = 2**math.ceil(math.log2(i)) - i + dj = 2**math.ceil(math.log2(j)) - j + return jnp.pad(x, ((0, di), (0, dj)), mode="constant", constant_values=0.0) + else: + raise ValueError(f"Unsupported array shape: {x.shape}") + + +class BatchedInContextXRegBase: + """Helper class for in-context regression covariate formatting. + + Attributes: + targets: List of targets (responses) of the in-context regression. + train_lens: List of lengths of each target vector from the context. + test_lens: List of lengths of each forecast horizon. + train_dynamic_numerical_covariates: Dict of covariate names mapping to the + dynamic numerical covariates of each forecast task on the context. Their + lengths should match the corresponding lengths in `train_lens`. + train_dynamic_categorical_covariates: Dict of covariate names mapping to the + dynamic categorical covariates of each forecast task on the context. Their + lengths should match the corresponding lengths in `train_lens`. + test_dynamic_numerical_covariates: Dict of covariate names mapping to the + dynamic numerical covariates of each forecast task on the horizon. Their + lengths should match the corresponding lengths in `test_lens`. + test_dynamic_categorical_covariates: Dict of covariate names mapping to the + dynamic categorical covariates of each forecast task on the horizon. Their + lengths should match the corresponding lengths in `test_lens`. + static_numerical_covariates: Dict of covariate names mapping to the static + numerical covariates of each forecast task. + static_categorical_covariates: Dict of covariate names mapping to the static + categorical covariates of each forecast task. + """ + + def __init__( + self, + targets: Sequence[Sequence[float]], + train_lens: Sequence[int], + test_lens: Sequence[int], + train_dynamic_numerical_covariates: Optional[Mapping[str, Sequence[Sequence[float]]]] = None, + train_dynamic_categorical_covariates: Optional[Mapping[str, Sequence[Sequence[Category]]]] = None, + test_dynamic_numerical_covariates: Optional[Mapping[str, Sequence[Sequence[float]]]] = None, + test_dynamic_categorical_covariates: Optional[Mapping[str, Sequence[Sequence[Category]]]] = None, + static_numerical_covariates: Optional[Mapping[str, Sequence[float]]] = None, + static_categorical_covariates: Optional[Mapping[str, Sequence[Category]]] = None, + ) -> None: + """Initializes with the exogenous covariate inputs. + + Here we use model fitting language to refer to the context as 'train' and + the horizon as 'test'. We assume batched inputs. To properly format the + request: + + - `train_lens` represents the contexts in the batch. Targets and all train + dynamic covariates should have the same lengths as the corresponding + elements + in `train_lens`. Notice each `train_len` can be different from the exact + length of the corresponding context depending on how much of the context is + used for fitting the in-context model. + - `test_lens` represents the horizon lengths in the batch. All tesdt + dynamic + covariates should have the same lengths as the corresponding elements in + `test_lens`. + - Static covariates should be one for each input. + - For train and test dynamic covariates, they should have the same + covariate + names. + + Pass an empty dict {} for a covariate type if it is not present. + + Example: + Here is a set of valid inputs whose schema can be used for reference. + ``` + targets = [ + [0.0, 0.1, 0.2], + [0.0, 0.1, 0.2, 0.3], + ] # Two inputs in this batch. + train_lens = [3, 4] + test_lens = [2, 5] # Forecast horizons 2 and 5 respectively. + train_dynamic_numerical_covariates = { + "cov_1_dn": [[0.0, 0.5, 1.0], [0.0, 0.5, 1.0, 1.5]], + "cov_2_dn": [[0.0, 1.5, 1.0], [0.0, 1.5, 1.0, 2.5]], + } # Each train dynamic covariate has 3 and 4 elements respectively. + test_dynamic_numerical_covariates = { + "cov_1_dn": [[0.1, 0.6], [0.1, 0.6, 1.1, 1.6, 2.4]], + "cov_2_dn": [[0.1, 1.1], [0.1, 1.6, 1.1, 2.6, 10.0]], + } # Each test dynamic covariate has 2 and 5 elements respectively. + train_dynamic_categorical_covariates = { + "cov_1_dc": [[0, 1, 0], [0, 1, 2, 3]], + "cov_2_dc": [["good", "bad", "good"], ["good", "good", "bad", + "bad"]], + } + test_dynamic_categorical_covariates = { + "cov_1_dc": [[1, 0], [1, 0, 2, 3, 1]], + "cov_2_dc": [["bad", "good"], ["bad", "bad", "bad", "bad", "bad"]], + } + static_numerical_covariates = { + "cov_1_sn": [0.0, 3.0], + "cov_2_sn": [2.0, 1.0], + "cov_3_sn": [1.0, 2.0], + } # Each static covariate has 1 element for each input. + static_categorical_covariates = { + "cov_1_sc": ["apple", "orange"], + "cov_2_sc": [2, 3], + } + ``` + + Args: + targets: List of targets (responses) of the in-context regression. + train_lens: List of lengths of each target vector from the context. + test_lens: List of lengths of each forecast horizon. + train_dynamic_numerical_covariates: Dict of covariate names mapping to the + dynamic numerical covariates of each forecast task on the context. Their + lengths should match the corresponding lengths in `train_lens`. + train_dynamic_categorical_covariates: Dict of covariate names mapping to + the dynamic categorical covariates of each forecast task on the context. + Their lengths should match the corresponding lengths in `train_lens`. + test_dynamic_numerical_covariates: Dict of covariate names mapping to the + dynamic numerical covariates of each forecast task on the horizon. Their + lengths should match the corresponding lengths in `test_lens`. + test_dynamic_categorical_covariates: Dict of covariate names mapping to + the dynamic categorical covariates of each forecast task on the horizon. + Their lengths should match the corresponding lengths in `test_lens`. + static_numerical_covariates: Dict of covariate names mapping to the static + numerical covariates of each forecast task. + static_categorical_covariates: Dict of covariate names mapping to the + static categorical covariates of each forecast task. + """ + self.targets = targets + self.train_lens = train_lens + self.test_lens = test_lens + self.train_dynamic_numerical_covariates = ( + train_dynamic_numerical_covariates or {}) + self.train_dynamic_categorical_covariates = ( + train_dynamic_categorical_covariates or {}) + self.test_dynamic_numerical_covariates = (test_dynamic_numerical_covariates + or {}) + self.test_dynamic_categorical_covariates = ( + test_dynamic_categorical_covariates or {}) + self.static_numerical_covariates = static_numerical_covariates or {} + self.static_categorical_covariates = static_categorical_covariates or {} + + def _assert_covariates(self, assert_covariate_shapes: bool = False) -> None: + """Verifies the validity of the covariate inputs.""" + + # Check presence. + if (self.train_dynamic_numerical_covariates and + not self.test_dynamic_numerical_covariates) or ( + not self.train_dynamic_numerical_covariates and + self.test_dynamic_numerical_covariates): + raise ValueError( + "train_dynamic_numerical_covariates and" + " test_dynamic_numerical_covariates must be both present or both" + " absent.") + + if (self.train_dynamic_categorical_covariates and + not self.test_dynamic_categorical_covariates) or ( + not self.train_dynamic_categorical_covariates and + self.test_dynamic_categorical_covariates): + raise ValueError( + "train_dynamic_categorical_covariates and" + " test_dynamic_categorical_covariates must be both present or both" + " absent.") + + # Check keys. + for dict_a, dict_b, dict_a_name, dict_b_name in ( + ( + self.train_dynamic_numerical_covariates, + self.test_dynamic_numerical_covariates, + "train_dynamic_numerical_covariates", + "test_dynamic_numerical_covariates", + ), + ( + self.train_dynamic_categorical_covariates, + self.test_dynamic_categorical_covariates, + "train_dynamic_categorical_covariates", + "test_dynamic_categorical_covariates", + ), + ): + if w := set(dict_a.keys()) - set(dict_b.keys()): + raise ValueError( + f"{dict_a_name} has keys not present in {dict_b_name}: {w}") + if w := set(dict_b.keys()) - set(dict_a.keys()): + raise ValueError( + f"{dict_b_name} has keys not present in {dict_a_name}: {w}") + + # Check shapes. + if assert_covariate_shapes: + if len(self.targets) != len(self.train_lens): + raise ValueError( + "targets and train_lens must have the same number of elements.") + + if len(self.train_lens) != len(self.test_lens): + raise ValueError( + "train_lens and test_lens must have the same number of elements.") + + for i, (target, train_len) in enumerate(zip(self.targets, + self.train_lens)): + if len(target) != train_len: + raise ValueError( + f"targets[{i}] has length {len(target)} != expected {train_len}.") + + for key, values in self.static_numerical_covariates.items(): + if len(values) != len(self.train_lens): + raise ValueError( + f"static_numerical_covariates has key {key} with number of" + f" examples {len(values)} != expected {len(self.train_lens)}.") + + for key, values in self.static_categorical_covariates.items(): + if len(values) != len(self.train_lens): + raise ValueError( + f"static_categorical_covariates has key {key} with number of" + f" examples {len(values)} != expected {len(self.train_lens)}.") + + for lens, dict_cov, dict_cov_name in ( + ( + self.train_lens, + self.train_dynamic_numerical_covariates, + "train_dynamic_numerical_covariates", + ), + ( + self.train_lens, + self.train_dynamic_categorical_covariates, + "train_dynamic_categorical_covariates", + ), + ( + self.test_lens, + self.test_dynamic_numerical_covariates, + "test_dynamic_numerical_covariates", + ), + ( + self.test_lens, + self.test_dynamic_categorical_covariates, + "test_dynamic_categorical_covariates", + ), + ): + for key, cov_values in dict_cov.items(): + if len(cov_values) != len(lens): + raise ValueError( + f"{dict_cov_name} has key {key} with number of examples" + f" {len(cov_values)} != expected {len(lens)}.") + for i, cov_value in enumerate(cov_values): + if len(cov_value) != lens[i]: + raise ValueError( + f"{dict_cov_name} has key {key} with its {i}-th example" + f" length {len(cov_value)} != expected {lens[i]}.") + + def create_covariate_matrix( + self, + one_hot_encoder_drop: Optional[str]= "first", + use_intercept: bool = True, + assert_covariates: bool = False, + assert_covariate_shapes: bool = False, + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """Creates target vector and covariate matrices for in context regression. + + Here we use model fitting language to refer to the context as 'train' and + the horizon as 'test'. + + Args: + one_hot_encoder_drop: Which drop strategy to use for the one hot encoder. + use_intercept: Whether to prepare an intercept (all 1) column in the + matrices. + assert_covariates: Whether to assert the validity of the covariate inputs. + assert_covariate_shapes: Whether to assert the shapes of the covariate + inputs when `assert_covariates` is True. + + Returns: + A tuple of the target vector, the covariate matrix for the context, and + the covariate matrix for the horizon. + """ + if assert_covariates: + self._assert_covariates(assert_covariate_shapes) + + x_train, x_test = [], [] + + # Numerical features. + for name in sorted(self.train_dynamic_numerical_covariates): + x_train.append( + _unnest(self.train_dynamic_numerical_covariates[name])[:, np.newaxis]) + x_test.append( + _unnest(self.test_dynamic_numerical_covariates[name])[:, np.newaxis]) + + for covs in self.static_numerical_covariates.values(): + x_train.append(_repeat(covs, self.train_lens)[:, np.newaxis]) + x_test.append(_repeat(covs, self.test_lens)[:, np.newaxis]) + + if x_train: + x_train = np.concatenate(x_train, axis=1) + x_test = np.concatenate(x_test, axis=1) + + # Normalize for robustness. + x_mean = np.mean(x_train, axis=0, keepdims=True) + x_std = np.where((w := np.std(x_train, axis=0, keepdims=True)) > _TOL, w, + 1.0) + x_train = [(x_train - x_mean) / x_std] + x_test = [(x_test - x_mean) / x_std] + + sklearn_version_tuple = tuple(map(int, sklearn_version.split("."))) + encoder_params = {} + if sklearn_version_tuple < (1, 2): + encoder_params["sparse"] = False + else: + encoder_params["sparse_output"] = False + + # Categorical features. Encode one by one. + one_hot_encoder = preprocessing.OneHotEncoder( + drop=one_hot_encoder_drop, + handle_unknown="ignore", + **encoder_params + ) + for name in sorted(self.train_dynamic_categorical_covariates.keys()): + ohe_train = _unnest( + self.train_dynamic_categorical_covariates[name])[:, np.newaxis] + ohe_test = _unnest( + self.test_dynamic_categorical_covariates[name])[:, np.newaxis] + x_train.append(np.array(one_hot_encoder.fit_transform(ohe_train))) + x_test.append(np.array(one_hot_encoder.transform(ohe_test))) + + for covs in self.static_categorical_covariates.values(): + ohe = one_hot_encoder.fit_transform(np.array(covs)[:, np.newaxis]) + x_train.append(_repeat(ohe, self.train_lens)) + x_test.append(_repeat(ohe, self.test_lens)) + + x_train = np.concatenate(x_train, axis=1) + x_test = np.concatenate(x_test, axis=1) + + if use_intercept: + x_train = np.pad(x_train, ((0, 0), (1, 0)), constant_values=1.0) + x_test = np.pad(x_test, ((0, 0), (1, 0)), constant_values=1.0) + + return _unnest(self.targets), x_train, x_test + + def fit(self) -> Any: + raise NotImplementedError("Fit is not implemented.") + + +class BatchedInContextXRegLinear(BatchedInContextXRegBase): + """Linear in-context regression model.""" + + def fit( + self, + ridge: float = 0.0, + one_hot_encoder_drop: Optional[str] = "first", + use_intercept: bool = True, + force_on_cpu: bool = False, + max_rows_per_col: int = 0, + max_rows_per_col_sample_seed: int = 42, + debug_info: bool = False, + assert_covariates: bool = False, + assert_covariate_shapes: bool = False, + ) -> Union[List[np.ndarray], Tuple[List[np.ndarray], List[np.ndarray], jax.Array, jax.Array, jax.Array]]: + """Fits a linear model for in-context regression. + + Args: + ridge: A non-negative value for specifying the ridge regression penalty. + If 0 is provided, fallback to ordinary least squares. Note this penalty + is added to the normalized covariate matrix. + one_hot_encoder_drop: Which drop strategy to use for the one hot encoder. + use_intercept: Whether to prepare an intercept (all 1) column in the + matrices. + force_on_cpu: Whether to force execution on cpu for accelerator machines. + max_rows_per_col: How many rows to subsample per column. 0 for no + subsampling. This is for speeding up model fitting. + max_rows_per_col_sample_seed: The seed for the subsampling if needed by + `max_rows_per_col`. + debug_info: Whether to return debug info. + assert_covariates: Whether to assert the validity of the covariate inputs. + assert_covariate_shapes: Whether to assert the shapes of the covariate + inputs when `assert_covariates` is True. + + Returns: + If `debug_info` is False: + The linear fits on the horizon. + If `debug_info` is True: + A tuple of: + - the linear fits on the horizon, + - the linear fits on the context, + - the flattened target vector, + - the covariate matrix for the context, and + - the covariate matrix for the horizon. + """ + flat_targets, x_train_raw, x_test = self.create_covariate_matrix( + one_hot_encoder_drop=one_hot_encoder_drop, + use_intercept=use_intercept, + assert_covariates=assert_covariates, + assert_covariate_shapes=assert_covariate_shapes, + ) + + x_train = x_train_raw.copy() + if max_rows_per_col: + nrows, ncols = x_train.shape + if nrows > (w := ncols * max_rows_per_col): + subsample = jax.random.choice( + jax.random.PRNGKey(max_rows_per_col_sample_seed), + nrows, + (w,), + replace=False, + ) + x_train = x_train[subsample] + flat_targets = flat_targets[subsample] + + device = jax.devices("cpu")[0] if force_on_cpu else None + # Runs jitted version of the solvers which are quicker at the cost of + # running jitting during the first time calling. Re-jitting happens whenever + # new (padded) shapes are encountered. + # Occasionally it helps with the speed and the accuracy if we force single + # thread execution on cpu for accelerator machines: + # 1. Avoid moving data to accelerator memory. + # 2. Avoid precision loss if any. + with jax.default_device(device): + x_train_raw = _to_padded_jax_array(x_train_raw) + x_train = _to_padded_jax_array(x_train) + flat_targets = _to_padded_jax_array(flat_targets) + x_test = _to_padded_jax_array(x_test) + beta_hat = (jnp.linalg.pinv( + x_train.T @ x_train + ridge * jnp.eye(x_train.shape[1]), + hermitian=True, + ) @ x_train.T @ flat_targets) + y_hat = x_test @ beta_hat + y_hat_context = x_train_raw @ beta_hat if debug_info else None + + outputs = [] + outputs_context = [] + + # Reconstruct the ragged 2-dim batched forecasts from flattened linear fits. + train_index, test_index = 0, 0 + for train_index_delta, test_index_delta in zip(self.train_lens, + self.test_lens): + outputs.append(np.array(y_hat[test_index:(test_index + + test_index_delta)])) + if debug_info: + outputs_context.append( + np.array(y_hat_context[train_index:(train_index + + train_index_delta)])) + train_index += train_index_delta + test_index += test_index_delta + + if debug_info: + return outputs, outputs_context, flat_targets, x_train, x_test + else: + return outputs \ No newline at end of file diff --git a/etna/models/nn/__init__.py b/etna/models/nn/__init__.py index b972e2aab..4512ac420 100644 --- a/etna/models/nn/__init__.py +++ b/etna/models/nn/__init__.py @@ -16,3 +16,6 @@ if SETTINGS.chronos_required: from etna.models.nn.chronos import ChronosBoltModel from etna.models.nn.chronos import ChronosModel + +if SETTINGS.timesfm_required: + from etna.models.nn.timesfm import TimesFMModel diff --git a/etna/models/nn/chronos/base.py b/etna/models/nn/chronos/base.py index a20514a1a..7505b150c 100644 --- a/etna/models/nn/chronos/base.py +++ b/etna/models/nn/chronos/base.py @@ -202,10 +202,9 @@ def _forecast( if max_context_size < self.context_size: warnings.warn("Actual length of a dataset is less that context size. All history will be used as context.") - available_context_size = min(max_context_size, self.context_size) - target = ts.df.loc[:, pd.IndexSlice[:, "target"]] - context = torch.tensor(target.values.T[:, :available_context_size]) + target = ts.df.loc[:, pd.IndexSlice[:, "target"]].dropna() + context = torch.tensor(target.values.T) if prediction_interval: quantiles_forecast, target_forecast = self.pipeline.predict_quantiles( diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py new file mode 100644 index 000000000..793665269 --- /dev/null +++ b/etna/models/nn/timesfm.py @@ -0,0 +1,376 @@ +import os +import reprlib +import warnings +from pathlib import Path +from typing import Dict +from typing import List +from typing import Literal +from typing import Optional +from urllib import request + +import numpy as np +import pandas as pd + +from etna import SETTINGS +from etna.datasets import TSDataset +from etna.distributions import BaseDistribution +from etna.models.base import NonPredictionIntervalContextRequiredAbstractModel + +if SETTINGS.timesfm_required: + from etna.libs.timesfm import TimesFmCheckpoint + from etna.libs.timesfm import TimesFmHparams + from etna.libs.timesfm import TimesFmTorch + from etna.libs.timesfm.timesfm_base import freq_map + +_DOWNLOAD_PATH = Path.home() / ".etna" / "timesfm" + + +class TimesFMModel(NonPredictionIntervalContextRequiredAbstractModel): + """ + Class for pretrained timesfm models. + + This model is only for zero-shot forecasting: it doesn't support training on data during ``fit``. + + This model doesn't support forecasting on misaligned data with `freq=None` without exogenous features. + + This model doesn't support NaN in the middle or at the end of target and exogenous features. + Use :py:class:`~etna.transforms.TimeSeriesImputerTransform` to fill them. + + Official implementation: https://github.com/google-research/timesfm + + Note + ---- + This model requires ``timesfm`` extension to be installed. + Read more about this at :ref:`installation page `. + """ + + def __init__( + self, + path_or_url: str, + encoder_length: int = 512, + device: Literal["cpu", "gpu"] = "cpu", + batch_size: int = 128, + static_reals: Optional[List[str]] = None, + static_categoricals: Optional[List[str]] = None, + time_varying_reals: Optional[List[str]] = None, + time_varying_categoricals: Optional[List[str]] = None, + cache_dir: Path = _DOWNLOAD_PATH, + ): + """ + Init TimesFM model. + + Parameters + ---------- + path_or_url: + Path to the model. It can be huggingface repository, local path or external url. + + - If huggingface repository, the available models are: + + - 'google/timesfm-1.0-200m-pytorch'. + During the first initialization model is downloaded from huggingface and saved to local ``cache_dir``. + All following initializations model will be loaded from ``cache_dir``. + - If local path, it should be a file with model weights, that can be loaded by :py:func:`torch.load`. + - If external url, it must be a file with model weights, that can be loaded by :py:func:`torch.load`. Model will be downloaded to ``cache_dir``. + device: + Device type. Can be "cpu" or "gpu". + encoder_length: + Number of last timestamps to use as a context. It needs to be a multiplier of 32. + batch_size: + Batch size. It can be useful when inference is done on gpu. + static_reals: + Continuous features that have one unique feature value for the whole series. The first value in the series will be used for each feature. + static_categoricals: + Categorical features that have one unique feature value for the whole series. The first value in the series will be used for each feature. + time_varying_reals: + Time varying continuous features known for future. + time_varying_categoricals: + Time varying categorical features known for future. + cache_dir: + Local path to save model from huggingface during first model initialization. All following class initializations appropriate model version will be downloaded from this path. + """ + self.path_or_url = path_or_url + self.encoder_length = encoder_length + self.device = device + self.batch_size = batch_size + self.static_reals = static_reals + self.static_categoricals = static_categoricals + self.time_varying_reals = time_varying_reals + self.time_varying_categoricals = time_varying_categoricals + self.cache_dir = cache_dir + + self._set_pipeline() + + def _set_pipeline(self): + """Set ``tfm`` attribute.""" + if self._is_url(): + full_model_path = self._download_model_from_url() + self.tfm = TimesFmTorch( + hparams=TimesFmHparams( + context_len=self.encoder_length, per_core_batch_size=self.batch_size, backend=self.device + ), + checkpoint=TimesFmCheckpoint(path=full_model_path), + ) + else: + self.tfm = TimesFmTorch( + hparams=TimesFmHparams( + context_len=self.encoder_length, per_core_batch_size=self.batch_size, backend=self.device + ), + checkpoint=TimesFmCheckpoint(path=self.path_or_url, local_dir=self.cache_dir), + ) + + def _is_url(self): + """Check whether ``path_or_url`` is url.""" + return self.path_or_url.startswith("https://") or self.path_or_url.startswith("http://") + + def _download_model_from_url(self) -> str: + """Download model from url to local cache_dir.""" + model_file = self.path_or_url.split("/")[-1] + full_model_path = f"{self.cache_dir}/{model_file}" + if not os.path.exists(full_model_path): + request.urlretrieve(url=self.path_or_url, filename=full_model_path) + return full_model_path + + @property + def context_size(self) -> int: + """Context size for model.""" + return self.encoder_length + + def get_model(self) -> TimesFmTorch: + """Get model.""" + return self.tfm + + def fit(self, ts: TSDataset): + """Fit model. + + For this model, fit does nothing. + + Parameters + ---------- + ts: + Dataset with features. + + Returns + ------- + : + Model after fit + """ + return self + + def predict( + self, + ts: TSDataset, + prediction_size: int, + return_components: bool = False, + ) -> TSDataset: + """Make predictions using true values as autoregression context (teacher forcing). + + Parameters + ---------- + ts: + Dataset with features. + prediction_size: + Number of last timestamps to leave after making prediction. + Previous timestamps will be used as a context. + return_components: + If True additionally returns forecast components. + + Returns + ------- + : + Dataset with predictions. + """ + raise NotImplementedError("Method predict isn't currently implemented!") + + def _exog_columns(self) -> List[str]: + static_reals = [] if self.static_reals is None else self.static_reals + static_categoricals = [] if self.static_categoricals is None else self.static_categoricals + time_varying_reals = [] if self.time_varying_reals is None else self.time_varying_reals + time_varying_categoricals = [] if self.time_varying_categoricals is None else self.time_varying_categoricals + + return static_reals + static_categoricals + time_varying_reals + time_varying_categoricals + + def forecast( + self, + ts: TSDataset, + prediction_size: int, + return_components: bool = False, + ) -> TSDataset: + """Make autoregressive forecasts. + + Parameters + ---------- + ts: + Dataset with features. + prediction_size: + Number of last timestamps to leave after making prediction. + Previous timestamps will be used as a context. + return_components: + If True additionally returns forecast components. + + Returns + ------- + : + Dataset with predictions. + + Raises + ------ + NotImplementedError: + if return_components mode is used. + ValueError: + if dataset doesn't have any context timestamps. + ValueError: + if there are NaNs in the middle or end of the time series. + NotImplementedError: + if forecasting is done without exogenous features and dataset has None frequency. + """ + if return_components: + raise NotImplementedError("This mode isn't currently implemented!") + + max_context_size = len(ts.index) - prediction_size + if max_context_size <= 0: + raise ValueError("Dataset doesn't have any context timestamps.") + + if max_context_size < self.context_size: + warnings.warn("Actual length of a dataset is less that context size. All history will be used as context.") + + self.tfm._set_horizon(prediction_size) + + end_idx = len(ts.index) + + all_exog = self._exog_columns() + df_slice = ts.df.loc[:, pd.IndexSlice[:, all_exog + ["target"]]] + first_valid_index = ( + df_slice.isna().any(axis=1).idxmin() + ) # If all timestamps contains NaNs, idxmin() returns the first timestamp + + target_df = df_slice.loc[first_valid_index : ts.index[-prediction_size - 1], pd.IndexSlice[:, "target"]] + + nan_segment_mask = target_df.isna().any() + if nan_segment_mask.any(): + nan_segments = nan_segment_mask.loc[:, nan_segment_mask].index.get_level_values(0).unique().tolist() + raise ValueError( + f"There are NaNs in the middle or at the end of target. Segments with NaNs: {reprlib.repr(nan_segments)}." + ) + + future_ts = ts.tsdataset_idx_slice(start_idx=end_idx - prediction_size, end_idx=end_idx) + + if len(all_exog) > 0: + target = target_df.values.swapaxes(1, 0).tolist() + + exog_df = df_slice.loc[first_valid_index:, pd.IndexSlice[:, all_exog]] + + nan_segment_mask = exog_df.isna().any() + if nan_segment_mask.any(): + nan_segments = nan_segment_mask.loc[:, nan_segment_mask].index.get_level_values(0).unique().tolist() + raise ValueError( + f"There are NaNs in the middle or at the end of exogenous features. Segments with NaNs: {reprlib.repr(nan_segments)}." + ) + + static_reals_dict = ( + { + column: exog_df.loc[exog_df.index[0], pd.IndexSlice[:, column]].values.tolist() + for column in self.static_reals + } + if self.static_reals is not None + else None + ) + static_categoricals_dict = ( + { + column: exog_df.loc[exog_df.index[0], pd.IndexSlice[:, column]].values.tolist() + for column in self.static_categoricals + } + if self.static_categoricals is not None + else None + ) + time_varying_reals_dict = ( + { + column: exog_df.loc[:, pd.IndexSlice[:, column]].values.swapaxes(1, 0).tolist() + for column in self.time_varying_reals + } + if self.time_varying_reals is not None + else None + ) + time_varying_categoricals_dict = ( + { + column: exog_df.loc[:, pd.IndexSlice[:, column]].values.swapaxes(1, 0).tolist() + for column in self.time_varying_categoricals + } + if self.time_varying_categoricals is not None + else None + ) + + complex_forecast, _ = self.tfm.forecast_with_covariates( + inputs=target, + dynamic_numerical_covariates=time_varying_reals_dict, + dynamic_categorical_covariates=time_varying_categoricals_dict, + static_numerical_covariates=static_reals_dict, + static_categorical_covariates=static_categoricals_dict, + freq=[freq_map(ts.freq)] * len(ts.segments), + ) + future_ts.df.loc[:, pd.IndexSlice[:, "target"]] = np.vstack(complex_forecast).swapaxes(1, 0) + else: + if ts.freq is None: + raise NotImplementedError( + "Forecasting misaligned data with freq=None without exogenous features isn't currently implemented." + ) + + target = TSDataset.to_flatten(df=target_df) + target = target.rename(columns={"segment": "unique_id", "timestamp": "ds"}) + + predictions = self.tfm.forecast_on_df(target, freq=ts.freq, value_name="target") + + predictions = predictions.rename(columns={"unique_id": "segment", "ds": "timestamp", "timesfm": "target"}) + predictions = TSDataset.to_dataset(predictions) + future_ts.df.loc[:, pd.IndexSlice[:, "target"]] = predictions.loc[ + :, pd.IndexSlice[:, "target"] + ].values # .values is needed to cast predictions type of initial target type in ts + return future_ts + + @staticmethod + def list_models() -> List[str]: + """ + Return a list of available pretrained timesfm models. + + Returns + ------- + : + List of available pretrained chronos models. + """ + return ["google/timesfm-1.0-200m-pytorch"] + + def save(self, path: Path): + """Save the model. This method doesn't save model's weights. + + During ``load`` weights are loaded from the path where they were saved during ``init`` + + Parameters + ---------- + path: + Path to save object to. + """ + self._save(path=path, skip_attributes=["tfm"]) + + @classmethod + def load(cls, path: Path): + """Load the model. + + Parameters + ---------- + path: + Path to load object from. + """ + obj: TimesFMModel = super().load(path=path) + obj._set_pipeline() + return obj + + def params_to_tune(self) -> Dict[str, BaseDistribution]: + """Get default grid for tuning hyperparameters. + + This grid is empty. + + Returns + ------- + : + Grid to tune. + """ + return {} diff --git a/etna/settings.py b/etna/settings.py index 987525548..afbcc5d8a 100644 --- a/etna/settings.py +++ b/etna/settings.py @@ -52,6 +52,21 @@ def _is_chronos_available(): return False +def _is_timesfm_available(): + true_case = ( + _module_available("torch") + & _module_available("jax") + & _module_available("jaxlib") + & _module_available("huggingface_hub") + & _module_available("utilsforecast") + ) + if true_case: + return True + else: + warnings.warn("etna[timesfm] is not available, to install it, run `pip install etna[timesfm]`") + return False + + def _is_wandb_available(): if _module_available("wandb"): return True @@ -112,6 +127,7 @@ def __init__( # noqa: D107 self, torch_required: Optional[bool] = None, chronos_required: Optional[bool] = None, + timesfm_required: Optional[bool] = None, prophet_required: Optional[bool] = None, wandb_required: Optional[bool] = None, classification_required: Optional[bool] = None, @@ -131,6 +147,11 @@ def __init__( # noqa: D107 _is_chronos_available, "etna[chronos] is not available, to install it, run `pip install etna[chronos]`.", ) + self.timesfm_required: bool = _get_optional_value( + timesfm_required, + _is_timesfm_available, + "etna[timesfm] is not available, to install it, run `pip install etna[timesfm]`.", + ) self.wandb_required: bool = _get_optional_value( wandb_required, _is_wandb_available, "wandb is not available, to install it, " "run `pip install wandb`." ) diff --git a/examples/202-NN_examples.ipynb b/examples/202-NN_examples.ipynb index 29bdeee07..d6a53d551 100644 --- a/examples/202-NN_examples.ipynb +++ b/examples/202-NN_examples.ipynb @@ -33,7 +33,8 @@ " * [N-BEATS Model](#section_3_9)\n", " * [PatchTS Model](#section_3_10)\n", " * [Chronos Model](#section_3_11)\n", - " * [Chronos Bolt Model](#section_3_12)" + " * [Chronos Bolt Model](#section_3_12)\n", + " * [TimesFM Model](#section_3_13)" ] }, { @@ -43,7 +44,7 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install \"etna[torch,chronos]\" -q" + "!pip install \"etna[torch,chronos,timesfm]\" -q" ] }, { @@ -4717,15 +4718,15 @@ "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.2s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.3s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.5s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.5s finished\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.1s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.2s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.3s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.3s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.0s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.0s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s finished\n" ] } ], @@ -4760,27 +4761,6 @@ "print(f\"Average SMAPE for Chronos tiny: {score:.3f}\")" ] }, - { - "cell_type": "code", - "execution_count": 88, - "id": "8334cd6a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_backtest(forecast_chronos, ts, history_len=20)" - ] - }, { "cell_type": "markdown", "id": "e78ef2ad", @@ -4791,7 +4771,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 88, "id": "cfff335c", "metadata": {}, "outputs": [], @@ -4801,7 +4781,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 89, "id": "5b07ab78", "metadata": {}, "outputs": [ @@ -4815,15 +4795,15 @@ "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.7s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 1.5s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 2.2s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 2.2s finished\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.2s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.4s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.6s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.6s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.0s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.0s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s finished\n" ] } ], @@ -4841,7 +4821,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 90, "id": "cd7238b2", "metadata": {}, "outputs": [ @@ -4868,7 +4848,7 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 91, "id": "bc2fde04", "metadata": {}, "outputs": [ @@ -4882,15 +4862,15 @@ "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.4s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.4s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 3.7s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 7.5s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 11.4s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 11.4s finished\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.6s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 1.3s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 1.9s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 1.9s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.0s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.0s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s finished\n" ] } ], @@ -4908,7 +4888,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 92, "id": "7b5d7d58", "metadata": {}, "outputs": [ @@ -4925,6 +4905,27 @@ "print(f\"Average SMAPE for Chronos small with long context: {score:.3f}\")" ] }, + { + "cell_type": "code", + "execution_count": 93, + "id": "041c767b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_backtest(forecast_chronos, ts, history_len=20)" + ] + }, { "cell_type": "markdown", "id": "6bbea6f5", @@ -4989,19 +4990,19 @@ "text": [ "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.2s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.2s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.3s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.3s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.3s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.1s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.3s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.4s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.4s finished\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.1s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.0s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.0s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s finished\n" ] } ], @@ -5035,6 +5036,249 @@ "score = metrics_chronos_bolt[\"SMAPE\"].mean()\n", "print(f\"Average SMAPE for Chronos Bolt small with long context: {score:.3f}\")" ] + }, + { + "cell_type": "markdown", + "id": "d438f154", + "metadata": {}, + "source": [ + "### 3.13 TimesFm Model \n", + "\n", + "`TimesFMModel` is one more pretrained model for zero-shot forecasting. It has similar interface to `ChronosBoltModel` and `ChronosModel`." + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "d2d30ce1", + "metadata": {}, + "outputs": [], + "source": [ + "from etna.models.nn import TimesFMModel" + ] + }, + { + "cell_type": "markdown", + "id": "7978edc4", + "metadata": {}, + "source": [ + "Now only one model is available." + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "215231c6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['google/timesfm-1.0-200m-pytorch']" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "TimesFMModel.list_models()" + ] + }, + { + "cell_type": "markdown", + "id": "32806e28", + "metadata": {}, + "source": [ + "Be careful. `encoder_length` needs to be a multiplier of 32." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "cf12e1ca", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "31c00b3df9ce47b9bf5a43dfdb29b79d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 3 files: 0%| | 0/3 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_backtest(forecast_timesfm, ts, history_len=20)" + ] + }, + { + "cell_type": "markdown", + "id": "6baa3066", + "metadata": {}, + "source": [ + "Model can work with exogenous features." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "fcc1d4c4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "915baa91dd90481b93504302699e6d67", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 3 files: 0%| | 0/3 [00:00=0.5.2)", "pipreqs", "requirementslib" plugins = ["setuptools"] requirements-deprecated-finder = ["pip-api", "pipreqs"] +[[package]] +name = "jax" +version = "0.4.13" +description = "Differentiate, compile, and transform Numpy code." +optional = true +python-versions = ">=3.8" +files = [ + {file = "jax-0.4.13.tar.gz", hash = "sha256:03bfe6749dfe647f16f15f6616638adae6c4a7ca7167c75c21961ecfd3a3baaa"}, +] + +[package.dependencies] +importlib_metadata = {version = ">=4.6", markers = "python_version < \"3.10\""} +ml_dtypes = ">=0.1.0" +numpy = ">=1.21" +opt_einsum = "*" +scipy = ">=1.7" + +[package.extras] +australis = ["protobuf (>=3.13,<4)"] +ci = ["jaxlib (==0.4.12)"] +cpu = ["jaxlib (==0.4.13)"] +cuda = ["jaxlib (==0.4.13+cuda11.cudnn86)"] +cuda11-cudnn86 = ["jaxlib (==0.4.13+cuda11.cudnn86)"] +cuda11-local = ["jaxlib (==0.4.13+cuda11.cudnn86)"] +cuda11-pip = ["jaxlib (==0.4.13+cuda11.cudnn86)", "nvidia-cublas-cu11 (>=11.11)", "nvidia-cuda-cupti-cu11 (>=11.8)", "nvidia-cuda-nvcc-cu11 (>=11.8)", "nvidia-cuda-runtime-cu11 (>=11.8)", "nvidia-cudnn-cu11 (>=8.8)", "nvidia-cufft-cu11 (>=10.9)", "nvidia-cusolver-cu11 (>=11.4)", "nvidia-cusparse-cu11 (>=11.7)"] +cuda12-local = ["jaxlib (==0.4.13+cuda12.cudnn89)"] +cuda12-pip = ["jaxlib (==0.4.13+cuda12.cudnn89)", "nvidia-cublas-cu12", "nvidia-cuda-cupti-cu12", "nvidia-cuda-nvcc-cu12", "nvidia-cuda-runtime-cu12", "nvidia-cudnn-cu12 (>=8.9)", "nvidia-cufft-cu12", "nvidia-cusolver-cu12", "nvidia-cusparse-cu12"] +minimum-jaxlib = ["jaxlib (==0.4.11)"] +tpu = ["jaxlib (==0.4.13)", "libtpu-nightly (==0.1.dev20230622)"] + +[[package]] +name = "jaxlib" +version = "0.4.13" +description = "XLA library for JAX" +optional = true +python-versions = ">=3.8" +files = [ + {file = "jaxlib-0.4.13-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:532ebc4fb11386282ad63b83941d4557f4038c1144acf026f1f8565f64c7e9c0"}, + {file = "jaxlib-0.4.13-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a259bb35429bfbd3b76e43019dfc8f7d6ea94bb217400b78f7d0824ce07a58ac"}, + {file = "jaxlib-0.4.13-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:ea1bc9811ef7d73a15e3213115e88fe7f5d14b59d95027bea9fccc98e5a14af8"}, + {file = "jaxlib-0.4.13-cp310-cp310-win_amd64.whl", hash = "sha256:fde66a93e9be89d99e5792f677ed8e319667d6b2396865b1c52c1312844c47f9"}, + {file = "jaxlib-0.4.13-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:49690fcdd26560515fd15399fc3a44777e0bfc5db5c48fe76ff7bc7228e8b2fb"}, + {file = "jaxlib-0.4.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f4e9e34e5d8a6556f62fead14aee0b1614c2c6296f0078d8e6139d6aff109649"}, + {file = "jaxlib-0.4.13-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:8000c0d15c107328e8f7b7b3ac91dd822f5c287a80231882b620503ed141fa89"}, + {file = "jaxlib-0.4.13-cp311-cp311-win_amd64.whl", hash = "sha256:19ae4c316b17a49342432c69f7f89f190b975333f3f9e9e175f686a651bc7347"}, + {file = "jaxlib-0.4.13-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:522635d5e159401a386c79f1236c218c1f68fbb4ca6648115c3ad3c2c3f518ab"}, + {file = "jaxlib-0.4.13-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:411334d903df07dc1ace8d52fc53c17f6bc1d55aff7f6e0e5cf61ec149f758a0"}, + {file = "jaxlib-0.4.13-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:839173b2e9593f5e9a6d3c42852cd15070fe80a939246efbb5cf40eec815de89"}, + {file = "jaxlib-0.4.13-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:c230ef85712e608d0f048869766a5a63afeb2e72309943db0df9f959ab17307f"}, + {file = "jaxlib-0.4.13-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d19c05c15f962e098d49b45e2758aacf19330d192ec5395f9ef136f62db90edc"}, + {file = "jaxlib-0.4.13-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:b5c0a9737efd95fe18fd7715ce30dfce476546705ea8934aad6731777a9631a5"}, + {file = "jaxlib-0.4.13-cp39-cp39-win_amd64.whl", hash = "sha256:bebb4cf001f180dc431f9604daf930c2d9cc778e4dda26f401ac939b7bac912e"}, +] + +[package.dependencies] +ml-dtypes = ">=0.1.0" +numpy = ">=1.21" +scipy = ">=1.7" + +[package.extras] +cuda11-pip = ["nvidia-cublas-cu11 (>=11.11)", "nvidia-cuda-cupti-cu11 (>=11.8)", "nvidia-cuda-nvcc-cu11 (>=11.8)", "nvidia-cuda-runtime-cu11 (>=11.8)", "nvidia-cudnn-cu11 (>=8.8)", "nvidia-cufft-cu11 (>=10.9)", "nvidia-cusolver-cu11 (>=11.4)", "nvidia-cusparse-cu11 (>=11.7)"] +cuda12-pip = ["nvidia-cublas-cu12", "nvidia-cuda-cupti-cu12", "nvidia-cuda-nvcc-cu12", "nvidia-cuda-runtime-cu12", "nvidia-cudnn-cu12 (>=8.9)", "nvidia-cufft-cu12", "nvidia-cusolver-cu12", "nvidia-cusparse-cu12"] + [[package]] name = "jedi" version = "0.18.2" @@ -2673,6 +2736,41 @@ files = [ {file = "mistune-2.0.5.tar.gz", hash = "sha256:0246113cb2492db875c6be56974a7c893333bf26cd92891c85f63151cee09d34"}, ] +[[package]] +name = "ml-dtypes" +version = "0.2.0" +description = "" +optional = true +python-versions = ">=3.7" +files = [ + {file = "ml_dtypes-0.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:df6a76e1c8adf484feb138ed323f9f40a7b6c21788f120f7c78bec20ac37ee81"}, + {file = "ml_dtypes-0.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc29a0524ef5e23a7fbb8d881bdecabeb3fc1d19d9db61785d077a86cb94fab2"}, + {file = "ml_dtypes-0.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f08c391c2794f2aad358e6f4c70785a9a7b1df980ef4c232b3ccd4f6fe39f719"}, + {file = "ml_dtypes-0.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:75015818a7fccf99a5e8ed18720cb430f3e71a8838388840f4cdf225c036c983"}, + {file = "ml_dtypes-0.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e70047ec2c83eaee01afdfdabee2c5b0c133804d90d0f7db4dd903360fcc537c"}, + {file = "ml_dtypes-0.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36d28b8861a8931695e5a31176cad5ae85f6504906650dea5598fbec06c94606"}, + {file = "ml_dtypes-0.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e85ba8e24cf48d456e564688e981cf379d4c8e644db0a2f719b78de281bac2ca"}, + {file = "ml_dtypes-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:832a019a1b6db5c4422032ca9940a990fa104eee420f643713241b3a518977fa"}, + {file = "ml_dtypes-0.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:8faaf0897942c8253dd126662776ba45f0a5861968cf0f06d6d465f8a7bc298a"}, + {file = "ml_dtypes-0.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35b984cddbe8173b545a0e3334fe56ea1a5c3eb67c507f60d0cfde1d3fa8f8c2"}, + {file = "ml_dtypes-0.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:022d5a4ee6be14569c2a9d1549e16f1ec87ca949681d0dca59995445d5fcdd5b"}, + {file = "ml_dtypes-0.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:50845af3e9a601810751b55091dee6c2562403fa1cb4e0123675cf3a4fc2c17a"}, + {file = "ml_dtypes-0.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f00c71c8c63e03aff313bc6a7aeaac9a4f1483a921a6ffefa6d4404efd1af3d0"}, + {file = "ml_dtypes-0.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:80d304c836d73f10605c58ccf7789c171cc229bfb678748adfb7cea2510dfd0e"}, + {file = "ml_dtypes-0.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32107e7fa9f62db9a5281de923861325211dfff87bd23faefb27b303314635ab"}, + {file = "ml_dtypes-0.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:1749b60348da71fd3c2ab303fdbc1965958dc50775ead41f5669c932a341cafd"}, + {file = "ml_dtypes-0.2.0.tar.gz", hash = "sha256:6488eb642acaaf08d8020f6de0a38acee7ac324c1e6e92ee0c0fea42422cb797"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.21.2", markers = "python_version > \"3.9\""}, + {version = ">1.20", markers = "python_version <= \"3.9\""}, +] + +[package.extras] +dev = ["absl-py", "pyink", "pylint (>=2.6.0)", "pytest", "pytest-xdist"] + [[package]] name = "msgpack" version = "1.0.5" @@ -3215,6 +3313,17 @@ files = [ antlr4-python3-runtime = "==4.9.*" PyYAML = ">=5.1.0" +[[package]] +name = "opt-einsum" +version = "3.4.0" +description = "Path optimization of einsum functions." +optional = true +python-versions = ">=3.8" +files = [ + {file = "opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd"}, + {file = "opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac"}, +] + [[package]] name = "optuna" version = "2.10.1" @@ -6031,6 +6140,27 @@ brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)", "brotlipy (>=0.6.0)"] secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"] socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] +[[package]] +name = "utilsforecast" +version = "0.2.10" +description = "Forecasting utilities" +optional = true +python-versions = ">=3.8" +files = [ + {file = "utilsforecast-0.2.10-py3-none-any.whl", hash = "sha256:ee7860f18a6df5dd695b51e603f3866a00dd0da0eb6c12d07f052e54390cf1a7"}, + {file = "utilsforecast-0.2.10.tar.gz", hash = "sha256:6058ca1a00b7e9dc02346a071a8e3f4dabe2a01f6f6b5a563c6c849754a86d3e"}, +] + +[package.dependencies] +numpy = "*" +packaging = "*" +pandas = ">=1.1.1" + +[package.extras] +dev = ["black", "datasetsforecast (==0.0.8)", "nbdev (<2.3.26)", "numba (>=0.58.0)", "pandas[plot]", "plotly", "plotly-resampler", "polars[numpy]", "pyarrow", "scipy"] +plotting = ["pandas[plot]", "plotly", "plotly-resampler"] +polars = ["polars[numpy]"] + [[package]] name = "wandb" version = "0.12.21" @@ -6348,8 +6478,8 @@ docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker testing = ["big-O", "flake8 (<5)", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] [extras] -all = ["accelerate", "einops", "huggingface-hub", "optuna", "prophet", "pytorch-forecasting", "pytorch-lightning", "pyts", "sqlalchemy", "statsforecast", "torch", "transformers", "tsfresh", "wandb"] -all-dev = ["GitPython", "Sphinx", "accelerate", "black", "click", "click", "codespell", "einops", "flake8", "flake8-bugbear", "flake8-comprehensions", "flake8-docstrings", "huggingface-hub", "ipywidgets", "isort", "jupyter", "mypy", "myst-parser", "nbconvert", "nbqa", "nbsphinx", "optuna", "pep8-naming", "prophet", "pydata-sphinx-theme", "pytest", "pytest-cov", "pytest-shard", "pytorch-forecasting", "pytorch-lightning", "pyts", "semver", "semver", "sphinx-design", "sphinx-mathjax-offline", "sqlalchemy", "statsforecast", "torch", "transformers", "tsfresh", "types-PyYAML", "types-setuptools", "wandb"] +all = ["accelerate", "einops", "huggingface-hub", "jax", "jaxlib", "optuna", "prophet", "pytorch-forecasting", "pytorch-lightning", "pyts", "sqlalchemy", "statsforecast", "torch", "transformers", "tsfresh", "utilsforecast", "wandb"] +all-dev = ["GitPython", "Sphinx", "accelerate", "black", "click", "click", "codespell", "einops", "flake8", "flake8-bugbear", "flake8-comprehensions", "flake8-docstrings", "huggingface-hub", "ipywidgets", "isort", "jax", "jaxlib", "jupyter", "mypy", "myst-parser", "nbconvert", "nbqa", "nbsphinx", "optuna", "pep8-naming", "prophet", "pydata-sphinx-theme", "pytest", "pytest-cov", "pytest-shard", "pytorch-forecasting", "pytorch-lightning", "pyts", "semver", "semver", "sphinx-design", "sphinx-mathjax-offline", "sqlalchemy", "statsforecast", "torch", "transformers", "tsfresh", "types-PyYAML", "types-setuptools", "utilsforecast", "wandb"] auto = ["optuna", "sqlalchemy"] chronos = ["accelerate", "huggingface-hub", "torch", "transformers"] classification = ["pyts", "tsfresh"] @@ -6360,10 +6490,11 @@ release = ["click", "semver"] statsforecast = ["statsforecast"] style = ["black", "codespell", "flake8", "flake8-bugbear", "flake8-comprehensions", "flake8-docstrings", "isort", "mypy", "nbqa", "pep8-naming", "types-PyYAML", "types-setuptools"] tests = ["pytest", "pytest-cov", "pytest-shard"] +timesfm = ["huggingface-hub", "jax", "jaxlib", "torch", "utilsforecast"] torch = ["einops", "pytorch-forecasting", "pytorch-lightning", "torch"] wandb = ["wandb"] [metadata] lock-version = "2.0" python-versions = ">=3.8.0, <3.11.0" -content-hash = "e77d4814a86e46ab4009fd8d0ba2900a3099263a8aad209befbdd764447e4691" +content-hash = "560122b4e3d4cbbe17fa501f1eb961c3a9605cf52a40b1f9df7129d3ab58f5cf" diff --git a/pyproject.toml b/pyproject.toml index c00f004ac..2e4cd2239 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -89,6 +89,10 @@ transformers = {version = "<5", optional = true} accelerate = {version = "<1", optional = true} huggingface-hub = {version = ">=0.21,<0.23", optional = true} +jax = {version = "<1", optional = true} +jaxlib = {version = "<1", optional = true} +utilsforecast = {version = ">=0.1.10,<1", optional = true} + sphinx-mathjax-offline = {version = "^0.0.2", optional = true} nbsphinx = {version = "^0.9.0", optional = true} Sphinx = {version = "^6.2", optional = true} @@ -132,6 +136,7 @@ auto = ["optuna", "sqlalchemy"] classification = ["pyts", "tsfresh"] statsforecast = ["statsforecast"] chronos = ["torch", "transformers", "accelerate", "huggingface-hub"] +timesfm = ["torch", "jax", "jaxlib", "huggingface-hub", "utilsforecast"] # dev deps release = ["click", "semver"] @@ -147,7 +152,8 @@ all = [ "optuna", "sqlalchemy", "pyts", "tsfresh", "statsforecast", - "transformers", "accelerate", "huggingface-hub" + "transformers", "accelerate", "huggingface-hub", + "jax", "jaxlib", "utilsforecast" ] all-dev = [ @@ -163,7 +169,8 @@ all-dev = [ "jupyter", "nbconvert", "ipywidgets", "pyts", "tsfresh", "statsforecast", - "transformers", "accelerate", "huggingface-hub" + "transformers", "accelerate", "huggingface-hub", + "jax", "jaxlib", "utilsforecast" ] [tool.poetry.scripts] diff --git a/tests/test_models/test_inference/test_forecast.py b/tests/test_models/test_inference/test_forecast.py index bc3b9da02..7b7557c9b 100644 --- a/tests/test_models/test_inference/test_forecast.py +++ b/tests/test_models/test_inference/test_forecast.py @@ -245,6 +245,22 @@ def test_forecast_in_sample_full_no_target_failed_chronos(self, model, transform with pytest.raises(ValueError, match="Dataset doesn't have any context timestamps."): self._test_forecast_in_sample_full_no_target(ts, model, transforms) + @pytest.mark.parametrize( + "model, transforms, dataset_name", + [ + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), + ], + ) + def test_forecast_in_sample_full_no_target_failed_timesfm(self, model, transforms, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(ValueError, match="Dataset doesn't have any context timestamps."): + self._test_forecast_in_sample_full_no_target(ts, model, transforms) + class TestForecastInSampleFull: """Test forecast on full train dataset. @@ -402,7 +418,23 @@ def test_forecast_in_sample_full_not_implemented(self, model, transforms, datase (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), ], ) - def test_forecast_in_sample_full_no_target_failed_chronos(self, model, transforms, dataset_name, request): + def test_forecast_in_sample_full_failed_chronos(self, model, transforms, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(ValueError, match="Dataset doesn't have any context timestamps."): + _test_prediction_in_sample_full(ts, model, transforms, method_name="forecast") + + @pytest.mark.parametrize( + "model, transforms, dataset_name", + [ + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), + ], + ) + def test_forecast_in_sample_full_failed_timesfm(self, model, transforms, dataset_name, request): ts = request.getfixturevalue(dataset_name) with pytest.raises(ValueError, match="Dataset doesn't have any context timestamps."): _test_prediction_in_sample_full(ts, model, transforms, method_name="forecast") @@ -493,6 +525,12 @@ def _test_forecast_in_sample_suffix_no_target(ts, model, transforms, num_skip_po (NBeatsGenericModel(input_size=7, output_size=50, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_in_sample_suffix_no_target(self, model, transforms, dataset_name, request): @@ -617,6 +655,12 @@ class TestForecastInSampleSuffix: (NBeatsGenericModel(input_size=7, output_size=50, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_in_sample_suffix(self, model, transforms, dataset_name, request): @@ -792,6 +836,12 @@ def _test_forecast_out_sample(ts, model, transforms, prediction_size=5): (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_out_sample_datetime_timestamp(self, model, transforms, dataset_name, request): @@ -891,6 +941,23 @@ def test_forecast_out_sample_int_timestamp(self, model, transforms, dataset_name ts_int_timestamp = convert_ts_to_int_timestamp(ts, shift=10) self._test_forecast_out_sample(ts_int_timestamp, model, transforms) + @pytest.mark.parametrize( + "model, transforms, dataset_name", + [ + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), + ], + ) + def test_forecast_out_sample_int_timestamp_failed_timesfm(self, model, transforms, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + ts_int_timestamp = convert_ts_to_int_timestamp(ts, shift=10) + with pytest.raises(NotImplementedError, match="Data with None frequency isn't currently implemented!"): + self._test_forecast_out_sample(ts_int_timestamp, model, transforms) + @pytest.mark.parametrize( "model, transforms, dataset_name", [ @@ -1047,6 +1114,12 @@ def _test_forecast_out_sample_prefix(ts, model, transforms, full_prediction_size (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_out_sample_prefix(self, model, transforms, dataset_name, request): @@ -1255,6 +1328,23 @@ def test_forecast_out_sample_suffix_failed_chronos(self, model, transforms, data with pytest.raises(AssertionError): self._test_forecast_out_sample_suffix(ts, model, transforms) + @pytest.mark.parametrize( + "model, transforms, dataset_name", + [ + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), + ], + ) + def test_forecast_out_sample_suffix_failed_timesfm(self, model, transforms, dataset_name, request): + """This test is expected to fail due to patch strategy in TimesFM""" + ts = request.getfixturevalue(dataset_name) + with pytest.raises(AssertionError): + self._test_forecast_out_sample_suffix(ts, model, transforms) + @to_be_fixed( raises=NotImplementedError, match="This model can't make forecast on out-of-sample data that goes after training data with a gap", @@ -1395,6 +1485,12 @@ def _test_forecast_mixed_in_out_sample(ts, model, transforms, num_skip_points=50 (NBeatsGenericModel(input_size=7, output_size=55, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_mixed_in_out_sample(self, model, transforms, dataset_name, request): @@ -1557,6 +1653,12 @@ def _test_forecast_subset_segments(self, ts, model, transforms, segments, predic ), (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_subset_segments(self, model, transforms, dataset_name, request): @@ -1734,6 +1836,12 @@ def _test_forecast_new_segments(self, ts, model, transforms, train_segments, pre (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_forecast_new_segments(self, model, transforms, dataset_name, request): diff --git a/tests/test_models/test_inference/test_predict.py b/tests/test_models/test_inference/test_predict.py index f53019df5..2c8d433dc 100644 --- a/tests/test_models/test_inference/test_predict.py +++ b/tests/test_models/test_inference/test_predict.py @@ -195,6 +195,12 @@ def test_predict_in_sample_full_failed_not_enough_context(self, model, transform (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_in_sample_full_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -326,6 +332,12 @@ def test_predict_in_sample_suffix_datetime_timestamp(self, model, transforms, da (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_in_sample_suffix_datetime_timestamp_failed_not_implemented_predict( @@ -472,6 +484,12 @@ def test_predict_in_sample_suffix_int_timestamp_failed(self, model, transforms, (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_in_sample_suffix_int_timestamp_failed_not_implemented_predict( @@ -614,6 +632,12 @@ def test_predict_out_sample(self, model, transforms, dataset_name, request): (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_out_sample_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -773,6 +797,12 @@ def test_predict_out_sample_prefix(self, model, transforms, dataset_name, reques (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_out_sample_prefix_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -946,6 +976,12 @@ def test_predict_out_sample_suffix(self, model, transforms, dataset_name, reques (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_out_sample_suffix_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -1124,6 +1160,12 @@ def test_predict_mixed_in_out_sample(self, model, transforms, dataset_name, requ (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_mixed_in_out_sample_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -1290,6 +1332,12 @@ def test_predict_subset_segments(self, model, transforms, dataset_name, request) (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_subset_segments_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -1421,6 +1469,12 @@ def test_predict_new_segments(self, model, transforms, dataset_name, request): (NBeatsGenericModel(input_size=7, output_size=7, trainer_params=dict(max_epochs=1)), [], "example_tsds"), (ChronosModel(path_or_url="amazon/chronos-t5-tiny", encoder_length=7), [], "example_tsds"), (ChronosBoltModel(path_or_url="amazon/chronos-bolt-tiny", encoder_length=7), [], "example_tsds"), + # pytest.param( + # TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), + # [], + # "example_tsds", + # marks=pytest.mark.skip(reason="Model causes OOM in GitHub Actions."), + # ), ], ) def test_predict_new_segments_failed_not_implemented_predict(self, model, transforms, dataset_name, request): diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py new file mode 100644 index 000000000..3778c432b --- /dev/null +++ b/tests/test_models/test_nn/test_timesfm.py @@ -0,0 +1,288 @@ +import os +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest +from pandas.testing import assert_frame_equal + +from etna.datasets import TSDataset +from etna.datasets import generate_ar_df +from etna.libs.timesfm import TimesFmTorch +from etna.models.nn import TimesFMModel +from etna.pipeline import Pipeline +from etna.transforms import DateFlagsTransform +from etna.transforms import LagTransform +from etna.transforms import SegmentEncoderTransform + + +def generate_increasing_df(): + n = 128 + df = generate_ar_df(start_time="2001-01-01", periods=n, n_segments=2) + df["target"] = list(range(n)) + list(range(100, 100 + n)) + return df + + +def generate_exog(): + n = 128 + df_exog = generate_ar_df(start_time="2001-01-01", periods=n + 2, n_segments=2) + df_exog.rename(columns={"target": "exog"}, inplace=True) + return df_exog + + +@pytest.fixture +def ts_increasing_integers(): + df = generate_increasing_df() + ts = TSDataset(df, freq="D") + return ts + + +@pytest.fixture +def ts_nan_start(): + df = generate_increasing_df() + df.loc[0, "target"] = np.NaN + ts = TSDataset(df, freq="D") + return ts + + +@pytest.fixture +def ts_nan_middle(): + df = generate_increasing_df() + df.loc[120, "target"] = np.NaN + ts = TSDataset(df, freq="D") + return ts + + +@pytest.fixture +def expected_ts_increasing_integers(): + df = generate_ar_df(start_time="2001-05-09", periods=2, n_segments=2) + df["target"] = [128.0, 129.0] + [228.0, 229.0] + ts = TSDataset(df, freq="D") + return ts + + +@pytest.fixture +def ts_exog_middle_nan(): + df = generate_increasing_df() + df_exog = generate_exog() + df_exog.loc[120, "exog"] = np.NaN + ts = TSDataset(df, df_exog=df_exog, freq="D", known_future="all") + return ts + + +@pytest.fixture +def ts_exog_all_nan(): + df = generate_increasing_df() + df_exog = generate_exog() + df_exog["exog"] = np.NaN + ts = TSDataset(df, df_exog=df_exog, freq="D", known_future="all") + return ts + + +@pytest.mark.smoke +def test_url(tmp_path): + model_name = "timesfm-1.0-200m-pytorch.ckpt" + url = f"http://etna-github-prod.cdn-tinkoff.ru/timesfm/{model_name}" + _ = TimesFMModel(path_or_url=url, cache_dir=tmp_path) + assert os.path.exists(tmp_path / model_name) + + +@pytest.mark.smoke +def test_cache_dir(tmp_path): + path_or_url = "google/timesfm-1.0-200m-pytorch" + model_name = path_or_url.split("/")[-1] + _ = TimesFMModel(path_or_url=path_or_url, cache_dir=tmp_path) + assert os.path.exists(tmp_path / f"models--google--{model_name}") + + +@pytest.mark.smoke +def test_context_size(): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=10) + assert model.context_size == 10 + + +@pytest.mark.smoke +def test_get_model(example_tsds): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") + assert isinstance(model.get_model(), TimesFmTorch) + + +@pytest.mark.smoke +def test_fit(example_tsds): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") + model.fit(example_tsds) + + +@pytest.mark.smoke +def test_predict(example_tsds): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") + with pytest.raises(NotImplementedError, match="Method predict isn't currently implemented!"): + model.predict(ts=example_tsds, prediction_size=1) + + +def test_forecast_warns_big_context_size(ts_increasing_integers): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=512) + pipeline = Pipeline(model=model, horizon=1) + pipeline.fit(ts_increasing_integers) + with pytest.warns(UserWarning, match="Actual length of a dataset is less that context size."): + _ = pipeline.forecast() + + +@pytest.mark.parametrize("encoder_length", [32, 64, 128]) +@pytest.mark.parametrize("ts", ["ts_increasing_integers", "ts_nan_start"]) +def test_forecast(ts, expected_ts_increasing_integers, encoder_length, request): + ts = request.getfixturevalue(ts) + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=encoder_length) + pipeline = Pipeline(model=model, horizon=2) + pipeline.fit(ts) + forecast = pipeline.forecast() + assert_frame_equal(forecast.df, expected_ts_increasing_integers.df, atol=1) + + +def test_forecast_failed_nan_middle_target(ts_nan_middle): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=128) + pipeline = Pipeline(model=model, horizon=2) + pipeline.fit(ts_nan_middle) + with pytest.raises(ValueError, match=r"There are NaNs in the middle or at the end of target. Segments with NaNs:"): + _ = pipeline.forecast() + + +@pytest.mark.parametrize("encoder_length", [32, 64, 128]) +@pytest.mark.parametrize("ts", ["ts_increasing_integers", "ts_nan_start"]) +def test_forecast_exogenous_features(ts, expected_ts_increasing_integers, encoder_length, request): + ts = request.getfixturevalue(ts) + + horizon = 2 + transforms = [ + SegmentEncoderTransform(), + LagTransform(in_column="target", lags=[horizon, horizon + 1], out_column="lag"), + DateFlagsTransform(day_number_in_week=True, day_number_in_month=False, is_weekend=False, out_column="flag"), + ] + model = TimesFMModel( + path_or_url="google/timesfm-1.0-200m-pytorch", + encoder_length=encoder_length, + static_categoricals=["segment_code"], + time_varying_reals=[f"lag_{horizon}", f"lag_{horizon+1}"], + time_varying_categoricals=["flag_day_number_in_week"], + ) + pipeline = Pipeline(model=model, transforms=transforms, horizon=horizon) + pipeline.fit(ts) + forecast = pipeline.forecast() + assert_frame_equal(forecast.df.loc[:, pd.IndexSlice[:, "target"]], expected_ts_increasing_integers.df, atol=1) + + +def test_forecast_exog_features_failed_nan_middle_target(ts_nan_middle): + horizon = 2 + transforms = [ + SegmentEncoderTransform(), + LagTransform(in_column="target", lags=[horizon, horizon + 1], out_column="lag"), + DateFlagsTransform(day_number_in_week=True, day_number_in_month=False, is_weekend=False, out_column="flag"), + ] + model = TimesFMModel( + path_or_url="google/timesfm-1.0-200m-pytorch", + encoder_length=128, + static_categoricals=["segment_code"], + time_varying_reals=[f"lag_{horizon}", f"lag_{horizon+1}"], + time_varying_categoricals=["flag_day_number_in_week"], + ) + pipeline = Pipeline(model=model, transforms=transforms, horizon=horizon) + pipeline.fit(ts_nan_middle) + with pytest.raises(ValueError, match="There are NaNs in the middle or at the end of target. Segments with NaNs:"): + _ = pipeline.forecast() + + +@pytest.mark.parametrize("ts", ["ts_exog_middle_nan", "ts_exog_all_nan"]) +def test_forecast_exog_features_failed_exog_nan(ts, request): + ts = request.getfixturevalue(ts) + + horizon = 2 + model = TimesFMModel( + path_or_url="google/timesfm-1.0-200m-pytorch", + encoder_length=128, + time_varying_reals=["exog"], + ) + pipeline = Pipeline(model=model, transforms=[], horizon=horizon) + pipeline.fit(ts) + with pytest.raises( + ValueError, match="There are NaNs in the middle or at the end of exogenous features. Segments with NaNs:" + ): + _ = pipeline.forecast() + + +@pytest.mark.smoke +def test_forecast_only_target_failed_int_timestamps(example_tsds_int_timestamp): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32) + pipeline = Pipeline(model=model, horizon=1) + pipeline.fit(example_tsds_int_timestamp) + with pytest.raises( + NotImplementedError, + match="Forecasting misaligned data with freq=None without exogenous features isn't currently implemented.", + ): + _ = pipeline.forecast() + + +@pytest.mark.smoke +def test_forecast_exog_int_timestamps(example_tsds_int_timestamp): + horizon = 2 + transforms = [SegmentEncoderTransform(), LagTransform(in_column="target", lags=[horizon], out_column="lag")] + model = TimesFMModel( + path_or_url="google/timesfm-1.0-200m-pytorch", + encoder_length=32, + static_categoricals=["segment_code"], + time_varying_reals=[f"lag_{horizon}"], + ) + pipeline = Pipeline(model=model, transforms=transforms, horizon=horizon) + pipeline.fit(example_tsds_int_timestamp) + with pytest.warns( + UserWarning, + match="Frequency is None. Mapping it to 0, that can be not optimal. Better to set it to known frequency", + ): + _ = pipeline.forecast() + + +@pytest.mark.parametrize("encoder_length", [16, 33]) +def test_forecast_wrong_context_len(ts_increasing_integers, encoder_length): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=encoder_length) + pipeline = Pipeline(model=model, horizon=1) + pipeline.fit(ts_increasing_integers) + with pytest.raises(RuntimeError, match=r"shape .+ is invalid for input of size \d+"): + _ = pipeline.forecast() + + +@pytest.mark.smoke +def test_forecast_without_fit(example_tsds): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32) + pipeline = Pipeline(model=model, horizon=1) + _ = pipeline.forecast(example_tsds) + + +@pytest.mark.smoke +def test_forecast_fails_components(example_tsds): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") + pipeline = Pipeline(model=model, horizon=1) + with pytest.raises(NotImplementedError, match="This mode isn't currently implemented!"): + pipeline.forecast(ts=example_tsds, return_components=True) + + +@pytest.mark.smoke +def test_list_models(): + assert TimesFMModel.list_models() == ["google/timesfm-1.0-200m-pytorch"] + + +@pytest.mark.smoke +def test_save_load(tmp_path, ts_increasing_integers): + path = Path(tmp_path) / "tmp.zip" + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32) + model.save(path) + loaded_model = TimesFMModel.load(path) + + pipeline = Pipeline(model=loaded_model, horizon=1) + pipeline.fit(ts_increasing_integers) + _ = pipeline.forecast() + assert isinstance(loaded_model, TimesFMModel) + + +@pytest.mark.smoke +def test_params_to_tune(): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") + assert len(model.params_to_tune()) == 0