From 9f894e6d9351e3fdccd55db90c76758969f8e5bb Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 00:18:18 +0300 Subject: [PATCH 01/20] add timesfm model --- README.md | 3 +- docs/source/api_reference/models.rst | 3 +- docs/source/installation.rst | 3 +- etna/libs/timesfm/__init__.py | 155 +++ etna/libs/timesfm/patched_decoder.py | 948 ++++++++++++++++++ etna/libs/timesfm/timesfm.py | 325 ++++++ etna/libs/timesfm/timesfm_base.py | 806 +++++++++++++++ etna/libs/timesfm/xreg_lib.py | 635 ++++++++++++ etna/models/nn/__init__.py | 3 + etna/models/nn/timesfm.py | 274 +++++ etna/settings.py | 21 + examples/202-NN_examples.ipynb | 190 +++- poetry.lock | 137 ++- pyproject.toml | 11 +- .../test_inference/test_forecast.py | 55 +- .../test_inference/test_predict.py | 10 + tests/test_models/test_nn/test_timesfm.py | 145 +++ 17 files changed, 3702 insertions(+), 22 deletions(-) create mode 100644 etna/libs/timesfm/__init__.py create mode 100644 etna/libs/timesfm/patched_decoder.py create mode 100644 etna/libs/timesfm/timesfm.py create mode 100644 etna/libs/timesfm/timesfm_base.py create mode 100644 etna/libs/timesfm/xreg_lib.py create mode 100644 etna/models/nn/timesfm.py create mode 100644 tests/test_models/test_nn/test_timesfm.py 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..f707879fe --- /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): + 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): + 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) # TODO weights_only=True + 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..400cc6bfe --- /dev/null +++ b/etna/libs/timesfm/timesfm_base.py @@ -0,0 +1,806 @@ +""" + 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) + +"""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 + +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: str): + """Returns the frequency map for the given frequency string.""" + 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[str] = None + huggingface_repo_id: Optional[str] = None + type: Any = None + step: Optional[int] = None + local_dir: Optional[str] = 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: + print("Processing dataframe with single process.") + 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: + print("Processing dataframe with multiple processes.") + 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: + print("Finished preprocessing dataframe.") + freq_inps = [freq_map(freq)] * len(new_inputs) + _, full_forecast = self.forecast(new_inputs, + freq=freq_inps, + window_size=window_size) + if verbose: + print("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..1cbb39781 --- /dev/null +++ b/etna/libs/timesfm/xreg_lib.py @@ -0,0 +1,635 @@ +""" + 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) + +"""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 + +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] + + # Categorical features. Encode one by one. + one_hot_encoder = preprocessing.OneHotEncoder( + drop=one_hot_encoder_drop, + sparse_output=False, + handle_unknown="ignore", + ) + 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. + # Ocassionally it helps with the speed and the accuracy if we force single + # thread execution on cpu for accelerator machines: + # 1. Avoid moving data to accelarator 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/timesfm.py b/etna/models/nn/timesfm.py new file mode 100644 index 000000000..c687d371d --- /dev/null +++ b/etna/models/nn/timesfm.py @@ -0,0 +1,274 @@ +import os +import warnings +from pathlib import Path +from typing import Dict +from typing import List +from urllib import request + +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 + +_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``. + + Official implementation: https://github.com/google-research/timesfm + + Warning + ------- + This model doesn't support forecasting on misaligned data with `freq=None`. + + 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: str = "cpu", + batch_size: int = 128, + 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", "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. + 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.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 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. + NotImplementedError: + if data with None frequency is used. + """ + if ts.freq is None: + raise NotImplementedError("Data with None frequency isn't currently implemented!") + + 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.") + available_context_size = min(max_context_size, self.context_size) + + self.tfm._set_horizon(prediction_size) + + target = ts.df.loc[ts.index[:-prediction_size], pd.IndexSlice[:, "target"]] + target = target.iloc[-available_context_size:] + df = TSDataset.to_flatten(target).dropna() + df = df.rename(columns={"segment": "unique_id", "timestamp": "ds"}) + + predictions = self.tfm.forecast_on_df(df, freq=ts.freq, value_name="target") + + end_idx = len(ts.index) + future_ts = ts.tsdataset_idx_slice(start_idx=end_idx - prediction_size, end_idx=end_idx) + 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..d8ad46123 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,12 +44,12 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install \"etna[torch,chronos]\" -q" + "!pip install \"etna[torch,chronos,timesfm]\" -q" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "0eb5e69e", "metadata": { "tags": [] @@ -62,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "a1a1a571", "metadata": { "pycharm": { @@ -95,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "7851ddcc", "metadata": { "tags": [] @@ -128,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "bfe220cb", "metadata": { "tags": [] @@ -204,7 +205,7 @@ "4 2019-01-05 segment_a 279" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -224,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "c1f7de68", "metadata": { "tags": [] @@ -326,7 +327,7 @@ "2019-01-05 279 137 104 384" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -369,7 +370,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "f3ae2de0", "metadata": { "tags": [] @@ -381,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "af6a6035", "metadata": { "tags": [] @@ -444,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "fbb2c279-f505-4f1b-b0e3-5e94369f9673", "metadata": { "tags": [] @@ -5035,6 +5036,169 @@ "score = metrics_chronos_bolt[\"SMAPE\"].mean()\n", "print(f\"Average SMAPE for Chronos Bolt small with long context: {score:.3f}\")" ] + }, + { + "cell_type": "markdown", + "id": "708ecd8f", + "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": 10, + "id": "95832e68", + "metadata": {}, + "outputs": [], + "source": [ + "from etna.models.nn import TimesFMModel" + ] + }, + { + "cell_type": "markdown", + "id": "4130cab8", + "metadata": {}, + "source": [ + "Now only one model is available." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "24a4a369", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['google/timesfm-1.0-200m-pytorch']" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "TimesFMModel.list_models()" + ] + }, + { + "cell_type": "markdown", + "id": "2173dc9f", + "metadata": {}, + "source": [ + "Be careful. `encoder_length` needs to be a multiplier of 32." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0473e740", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cbe5ceeb717c4b25a6261ac67bb69a4f", + "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..7c9120114 100644 --- a/tests/test_models/test_inference/test_forecast.py +++ b/tests/test_models/test_inference/test_forecast.py @@ -46,6 +46,7 @@ from etna.models.nn import RNNModel from etna.models.nn import TFTModel from etna.models.nn import TFTNativeModel +from etna.models.nn import TimesFMModel from etna.models.nn.deepstate import CompositeSSM from etna.models.nn.deepstate import WeeklySeasonalitySSM from etna.transforms import LagTransform @@ -245,6 +246,17 @@ 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", + [ + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), + ], + ) + 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 +414,18 @@ 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", + [ + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), + ], + ) + 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 +516,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_forecast_in_sample_suffix_no_target(self, model, transforms, dataset_name, request): @@ -617,6 +641,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_forecast_in_sample_suffix(self, model, transforms, dataset_name, request): @@ -792,6 +817,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_forecast_out_sample_datetime_timestamp(self, model, transforms, dataset_name, request): @@ -891,6 +917,18 @@ 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", + [ + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), + ], + ) + 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 +1085,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_forecast_out_sample_prefix(self, model, transforms, dataset_name, request): @@ -1255,6 +1294,17 @@ 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", + [ + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), + ], + ) + def test_forecast_out_sample_suffix_failed_timesfm(self, model, transforms, dataset_name, request): + 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 +1445,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_forecast_mixed_in_out_sample(self, model, transforms, dataset_name, request): @@ -1557,6 +1608,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_forecast_subset_segments(self, model, transforms, dataset_name, request): @@ -1734,6 +1786,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) 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..601703b36 100644 --- a/tests/test_models/test_inference/test_predict.py +++ b/tests/test_models/test_inference/test_predict.py @@ -44,6 +44,7 @@ from etna.models.nn import RNNModel from etna.models.nn import TFTModel from etna.models.nn import TFTNativeModel +from etna.models.nn import TimesFMModel from etna.models.nn.deepstate import CompositeSSM from etna.models.nn.deepstate import WeeklySeasonalitySSM from etna.transforms import LagTransform @@ -195,6 +196,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_in_sample_full_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -326,6 +328,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_in_sample_suffix_datetime_timestamp_failed_not_implemented_predict( @@ -472,6 +475,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_in_sample_suffix_int_timestamp_failed_not_implemented_predict( @@ -614,6 +618,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_out_sample_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -773,6 +778,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_out_sample_prefix_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -946,6 +952,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_out_sample_suffix_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -1124,6 +1131,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_mixed_in_out_sample_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -1290,6 +1298,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) def test_predict_subset_segments_failed_not_implemented_predict(self, model, transforms, dataset_name, request): @@ -1421,6 +1430,7 @@ 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"), + (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "example_tsds"), ], ) 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..cfbb88b87 --- /dev/null +++ b/tests/test_models/test_nn/test_timesfm.py @@ -0,0 +1,145 @@ +import os +from pathlib import Path + +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 + + +@pytest.fixture +def ts_increasing_integers(): + 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)) + ts = TSDataset(df, freq="D") + return ts + + +@pytest.fixture +def expected_ts_increasing_integers(): + df = generate_ar_df(start_time="2001-03-06", periods=1, n_segments=2) + df["target"] = [128.0] + [228.0] + ts = TSDataset(df, freq="D") + return ts + + +@pytest.mark.smoke +def test_chronos_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_chronos_custom_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_chronos_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) + + +@pytest.mark.smoke +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]) +def test_forecast(ts_increasing_integers, expected_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) + forecast = pipeline.forecast() + assert_frame_equal(forecast.df, expected_ts_increasing_integers.df, atol=2) + + +@pytest.mark.smoke +def test_forecast_failed_int_timestamps(example_tsds_int_timestamp): + model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") + pipeline = Pipeline(model=model, horizon=1) + pipeline.fit(example_tsds_int_timestamp) + with pytest.raises(NotImplementedError, match="Data with None frequency isn't currently implemented!"): + _ = pipeline.forecast() + + +@pytest.mark.smoke +@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 From 2d7d02cc52cd193c53d994138f35f3fd8f7e729f Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 12:56:58 +0300 Subject: [PATCH 02/20] add exogenous features --- etna/libs/timesfm/timesfm_base.py | 24 +-- etna/libs/timesfm/xreg_lib.py | 12 +- etna/models/nn/timesfm.py | 101 ++++++++++--- examples/202-NN_examples.ipynb | 169 ++++++++++++++++------ tests/test_models/test_nn/test_timesfm.py | 60 +++++++- 5 files changed, 284 insertions(+), 82 deletions(-) diff --git a/etna/libs/timesfm/timesfm_base.py b/etna/libs/timesfm/timesfm_base.py index 400cc6bfe..ade80e6c3 100644 --- a/etna/libs/timesfm/timesfm_base.py +++ b/etna/libs/timesfm/timesfm_base.py @@ -165,6 +165,9 @@ # 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.""" @@ -172,8 +175,8 @@ import dataclasses import logging import multiprocessing -from typing import Any, Literal, Sequence, Optional, Tuple, List, Dict - +from typing import Any, Literal, Sequence, Optional, Tuple, List, Dict, Union +from pathlib import Path import numpy as np import pandas as pd @@ -202,8 +205,11 @@ def moving_average(arr, window_size): return [smoothed_arr, arr - smoothed_arr] -def freq_map(freq: str): +def freq_map(freq: Optional[str]): """Returns the frequency map for the given frequency string.""" + if freq is None: + 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")): @@ -284,11 +290,11 @@ class TimesFmCheckpoint: """ version: str = "jax" - path: Optional[str] = None + path: Optional[Union[str, Path]] = None huggingface_repo_id: Optional[str] = None type: Any = None step: Optional[int] = None - local_dir: Optional[str] = None + local_dir: Optional[Union[str, Path]] = None class TimesFmBase: @@ -758,7 +764,7 @@ def forecast_on_df( uids = [] if num_jobs == 1: if verbose: - print("Processing dataframe with single process.") + logging.info("Processing dataframe with single process.") for key, group in df_sorted.groupby("unique_id"): inp, uid = process_group( key, @@ -772,7 +778,7 @@ def forecast_on_df( if num_jobs == -1: num_jobs = multiprocessing.cpu_count() if verbose: - print("Processing dataframe with multiple processes.") + logging.info("Processing dataframe with multiple processes.") with multiprocessing.Pool(processes=num_jobs) as pool: results = pool.starmap( process_group, @@ -781,13 +787,13 @@ def forecast_on_df( ) new_inputs, uids = zip(*results) if verbose: - print("Finished preprocessing dataframe.") + logging.info("Finished preprocessing dataframe.") freq_inps = [freq_map(freq)] * len(new_inputs) _, full_forecast = self.forecast(new_inputs, freq=freq_inps, window_size=window_size) if verbose: - print("Finished forecasting.") + logging.info("Finished forecasting.") fcst_df = make_future_dataframe( uids=uids, last_times=df_sorted.groupby("unique_id")["ds"].tail(1), diff --git a/etna/libs/timesfm/xreg_lib.py b/etna/libs/timesfm/xreg_lib.py index 1cbb39781..ba7ab69ce 100644 --- a/etna/libs/timesfm/xreg_lib.py +++ b/etna/libs/timesfm/xreg_lib.py @@ -165,7 +165,7 @@ # 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 @@ -176,6 +176,7 @@ import jax.numpy as jnp import numpy as np from sklearn import preprocessing +from sklearn import __version__ as sklearn_version Category = Union[int, str] @@ -496,11 +497,18 @@ def create_covariate_matrix( 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, - sparse_output=False, handle_unknown="ignore", + **encoder_params ) for name in sorted(self.train_dynamic_categorical_covariates.keys()): ohe_train = _unnest( diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index c687d371d..abf018ca1 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -3,8 +3,11 @@ 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 @@ -16,6 +19,7 @@ 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" @@ -32,6 +36,8 @@ class TimesFMModel(NonPredictionIntervalContextRequiredAbstractModel): ------- This model doesn't support forecasting on misaligned data with `freq=None`. + Use :py:class:`~etna.transforms.TimeSeriesImputerTransform` to fill NaNs for stable behaviour. + Note ---- This model requires ``timesfm`` extension to be installed. @@ -42,8 +48,12 @@ def __init__( self, path_or_url: str, encoder_length: int = 512, - device: str = "cpu", + 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, ): """ @@ -62,11 +72,19 @@ def __init__( - 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", "gpu". + 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. """ @@ -74,6 +92,10 @@ def __init__( 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() @@ -189,11 +211,8 @@ def forecast( ValueError: if dataset doesn't have any context timestamps. NotImplementedError: - if data with None frequency is used. + if forecasting is done without exogenous features and dataset has None frequency. """ - if ts.freq is None: - raise NotImplementedError("Data with None frequency isn't currently implemented!") - if return_components: raise NotImplementedError("This mode isn't currently implemented!") @@ -203,25 +222,71 @@ 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) self.tfm._set_horizon(prediction_size) - target = ts.df.loc[ts.index[:-prediction_size], pd.IndexSlice[:, "target"]] - target = target.iloc[-available_context_size:] - df = TSDataset.to_flatten(target).dropna() - df = df.rename(columns={"segment": "unique_id", "timestamp": "ds"}) + end_idx = len(ts.index) - predictions = self.tfm.forecast_on_df(df, freq=ts.freq, value_name="target") + static_reals_dict = ( + {column: ts.df.loc[ts.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: ts.df.loc[ts.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: ts.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: ts.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 + ) - end_idx = len(ts.index) future_ts = ts.tsdataset_idx_slice(start_idx=end_idx - prediction_size, end_idx=end_idx) - 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 + if static_reals_dict or static_categoricals_dict or time_varying_reals_dict or time_varying_categoricals_dict: + target = ts.df.loc[:, pd.IndexSlice[:, "target"]].dropna().values.swapaxes(1, 0).tolist() + + 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( + "Data with None frequency isn't currently implemented for forecasting without exogenous features." + ) + + target = ts.to_pandas(flatten=True, features=["target"]).dropna() + 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 diff --git a/examples/202-NN_examples.ipynb b/examples/202-NN_examples.ipynb index d8ad46123..bdedfdc57 100644 --- a/examples/202-NN_examples.ipynb +++ b/examples/202-NN_examples.ipynb @@ -5039,7 +5039,7 @@ }, { "cell_type": "markdown", - "id": "708ecd8f", + "id": "3d1c5cdc", "metadata": {}, "source": [ "### 3.13 TimesFm Model \n", @@ -5049,8 +5049,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "95832e68", + "execution_count": 9, + "id": "b1cddb5d", "metadata": {}, "outputs": [], "source": [ @@ -5059,7 +5059,7 @@ }, { "cell_type": "markdown", - "id": "4130cab8", + "id": "62e2a14a", "metadata": {}, "source": [ "Now only one model is available." @@ -5067,8 +5067,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "24a4a369", + "execution_count": 10, + "id": "c9728978", "metadata": {}, "outputs": [ { @@ -5077,7 +5077,7 @@ "['google/timesfm-1.0-200m-pytorch']" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -5088,7 +5088,7 @@ }, { "cell_type": "markdown", - "id": "2173dc9f", + "id": "2cff6154", "metadata": {}, "source": [ "Be careful. `encoder_length` needs to be a multiplier of 32." @@ -5096,14 +5096,14 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "0473e740", + "execution_count": 11, + "id": "4482e56d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cbe5ceeb717c4b25a6261ac67bb69a4f", + "model_id": "f01e125a40134bd680b31057fb7fa78e", "version_major": 2, "version_minor": 0 }, @@ -5120,47 +5120,105 @@ "text": [ "[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.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 2 out of 2 | elapsed: 0.4s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s 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.5s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s 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.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.0s finished\n" ] - }, + } + ], + "source": [ + "set_seed()\n", + "\n", + "model_timesfm = TimesFMModel(path_or_url=\"google/timesfm-1.0-200m-pytorch\", encoder_length=32)\n", + "\n", + "pipeline_timesfm = Pipeline(model=model_timesfm, horizon=HORIZON, transforms=[])\n", + "\n", + "metrics_timesfm, forecast_timesfm, fold_info_timesfm = pipeline_timesfm.backtest(\n", + " ts, metrics=metrics, n_folds=3, n_jobs=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "04f62aad", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Processing dataframe with single process.\n", - "Finished preprocessing dataframe.\n", - "Finished forecasting.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.2s remaining: 0.0s\n" + "Average SMAPE for TimesFM: 5.249\n" ] - }, + } + ], + "source": [ + "score = metrics_timesfm[\"SMAPE\"].mean()\n", + "print(f\"Average SMAPE for TimesFM: {score:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "149a91eb", + "metadata": {}, + "outputs": [], + "source": [ + "plot_backtest(forecast_timesfm, ts, history_len=20)" + ] + }, + { + "cell_type": "markdown", + "id": "bb035a81", + "metadata": {}, + "source": [ + "Model can work with exogenous features." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c0588f39", + "metadata": {}, + "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing dataframe with single process.\n", - "Finished preprocessing dataframe.\n", - "Finished forecasting.\n", - "Processing dataframe with single process.\n", - "Finished preprocessing dataframe.\n", - "Finished forecasting.\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "20fed636fead4ca6b8f533edcde1a686", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 3 files: 0%| | 0/3 [00:00 Date: Tue, 24 Dec 2024 13:13:59 +0300 Subject: [PATCH 03/20] chronos minor fix --- etna/models/nn/chronos/base.py | 5 +- examples/202-NN_examples.ipynb | 243 +++++++++++++++++++++------------ 2 files changed, 159 insertions(+), 89 deletions(-) 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/examples/202-NN_examples.ipynb b/examples/202-NN_examples.ipynb index bdedfdc57..1a03ef37e 100644 --- a/examples/202-NN_examples.ipynb +++ b/examples/202-NN_examples.ipynb @@ -37,6 +37,16 @@ " * [TimesFM Model](#section_3_13)" ] }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dfdc181e", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -49,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "0eb5e69e", "metadata": { "tags": [] @@ -63,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "a1a1a571", "metadata": { "pycharm": { @@ -96,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "7851ddcc", "metadata": { "tags": [] @@ -129,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "bfe220cb", "metadata": { "tags": [] @@ -205,7 +215,7 @@ "4 2019-01-05 segment_a 279" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -225,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "c1f7de68", "metadata": { "tags": [] @@ -327,7 +337,7 @@ "2019-01-05 279 137 104 384" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -370,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "f3ae2de0", "metadata": { "tags": [] @@ -382,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "af6a6035", "metadata": { "tags": [] @@ -445,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "fbb2c279-f505-4f1b-b0e3-5e94369f9673", "metadata": { "tags": [] @@ -4651,6 +4661,64 @@ "Chronos is pretrained model for zero-shot forecasting." ] }, + { + "cell_type": "code", + "execution_count": 80, + "id": "13f5f221", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "17d7b955", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "1c214441", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "085b45de", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "934b244c", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a247b7ef", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 84, @@ -4718,15 +4786,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.2s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.2s 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" ] } ], @@ -4816,15 +4884,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" ] } ], @@ -4878,20 +4946,20 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.3s 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.1s 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: 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.2s 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" ] } ], @@ -4989,20 +5057,20 @@ "output_type": "stream", "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 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)]: 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.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" ] } ], @@ -5039,7 +5107,7 @@ }, { "cell_type": "markdown", - "id": "3d1c5cdc", + "id": "83d6d047", "metadata": {}, "source": [ "### 3.13 TimesFm Model \n", @@ -5049,8 +5117,8 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "b1cddb5d", + "execution_count": 98, + "id": "eee62c5e", "metadata": {}, "outputs": [], "source": [ @@ -5059,7 +5127,7 @@ }, { "cell_type": "markdown", - "id": "62e2a14a", + "id": "999d5479", "metadata": {}, "source": [ "Now only one model is available." @@ -5067,8 +5135,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "c9728978", + "execution_count": 99, + "id": "d19f4212", "metadata": {}, "outputs": [ { @@ -5077,7 +5145,7 @@ "['google/timesfm-1.0-200m-pytorch']" ] }, - "execution_count": 10, + "execution_count": 99, "metadata": {}, "output_type": "execute_result" } @@ -5088,7 +5156,7 @@ }, { "cell_type": "markdown", - "id": "2cff6154", + "id": "ae998579", "metadata": {}, "source": [ "Be careful. `encoder_length` needs to be a multiplier of 32." @@ -5096,14 +5164,14 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "4482e56d", + "execution_count": 100, + "id": "8697927d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f01e125a40134bd680b31057fb7fa78e", + "model_id": "20c4816d7a1f43fd86b152a6257ea4cf", "version_major": 2, "version_minor": 0 }, @@ -5120,14 +5188,14 @@ "text": [ "[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.4s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s finished\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.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.2s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.5s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.7s finished\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", @@ -5150,8 +5218,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "04f62aad", + "execution_count": 101, + "id": "83422d02", "metadata": {}, "outputs": [ { @@ -5169,17 +5237,28 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "149a91eb", + "execution_count": 102, + "id": "391044d7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_backtest(forecast_timesfm, ts, history_len=20)" ] }, { "cell_type": "markdown", - "id": "bb035a81", + "id": "334b9a6b", "metadata": {}, "source": [ "Model can work with exogenous features." @@ -5187,14 +5266,14 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "c0588f39", + "execution_count": 103, + "id": "de5f4d5d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "20fed636fead4ca6b8f533edcde1a686", + "model_id": "eb26373760e0483abd16481719195154", "version_major": 2, "version_minor": 0 }, @@ -5212,13 +5291,13 @@ "[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.2s 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)]: 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.3s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 0.5s remaining: 0.0s\n", "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.6s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.9s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.9s finished\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.8s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.8s 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", @@ -5233,14 +5312,14 @@ "transforms = [\n", " SegmentEncoderTransform(),\n", " LagTransform(in_column=\"target\", lags=[HORIZON], out_column=\"lag\"),\n", - " DateFlagsTransform(day_number_in_week=True, day_number_in_month=False, is_weekend=False, out_column=\"flag\"),\n", + " DateFlagsTransform(day_number_in_week=True, day_number_in_month=False, is_weekend=False, out_column=\"dateflag\"),\n", "]\n", "model_timesfm = TimesFMModel(\n", " path_or_url=\"google/timesfm-1.0-200m-pytorch\",\n", " encoder_length=32,\n", " static_categoricals=[\"segment_code\"],\n", " time_varying_reals=[f\"lag_{HORIZON}\"],\n", - " time_varying_categoricals=[\"flag_day_number_in_week\"],\n", + " time_varying_categoricals=[\"dateflag_day_number_in_week\"],\n", ")\n", "\n", "pipeline_timesfm = Pipeline(model=model_timesfm, horizon=HORIZON, transforms=transforms)\n", @@ -5252,15 +5331,15 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "4467a8c0", + "execution_count": 104, + "id": "daeddd44", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Average SMAPE for TimesFM: 6.784\n" + "Average SMAPE for TimesFM with exogenous features: 6.784\n" ] } ], @@ -5268,14 +5347,6 @@ "score = metrics_timesfm[\"SMAPE\"].mean()\n", "print(f\"Average SMAPE for TimesFM with exogenous features: {score:.3f}\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6d6a8774", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From c609ab7b038e13826c5954f4ca9187a52c3abff4 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 13:19:40 +0300 Subject: [PATCH 04/20] update changelog --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b7d0a3b9a..0d28abf23 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)) From 2faa926ed4c5faa7d7c5e781d8ee5bba869abdca Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 13:25:50 +0300 Subject: [PATCH 05/20] minor docstring fix --- etna/models/nn/timesfm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index abf018ca1..0f6bdf396 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -34,7 +34,7 @@ class TimesFMModel(NonPredictionIntervalContextRequiredAbstractModel): Warning ------- - This model doesn't support forecasting on misaligned data with `freq=None`. + This model doesn't support forecasting on misaligned data with `freq=None` without exogenous features. Use :py:class:`~etna.transforms.TimeSeriesImputerTransform` to fill NaNs for stable behaviour. From 5d537b0cb85382b3f68ebde6b86411bf781c5af1 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 13:34:01 +0300 Subject: [PATCH 06/20] lints --- etna/libs/timesfm/xreg_lib.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/etna/libs/timesfm/xreg_lib.py b/etna/libs/timesfm/xreg_lib.py index ba7ab69ce..4521009bf 100644 --- a/etna/libs/timesfm/xreg_lib.py +++ b/etna/libs/timesfm/xreg_lib.py @@ -605,9 +605,9 @@ def fit( # 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. - # Ocassionally it helps with the speed and the accuracy if we force single + # 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 accelarator memory. + # 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) From c9726f711b113941149fe35de6bdc9be1468f58d Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 13:38:45 +0300 Subject: [PATCH 07/20] minor notebook fix --- examples/202-NN_examples.ipynb | 90 +++++----------------------------- 1 file changed, 11 insertions(+), 79 deletions(-) diff --git a/examples/202-NN_examples.ipynb b/examples/202-NN_examples.ipynb index 1a03ef37e..7af8f9d14 100644 --- a/examples/202-NN_examples.ipynb +++ b/examples/202-NN_examples.ipynb @@ -37,16 +37,6 @@ " * [TimesFM Model](#section_3_13)" ] }, - { - "cell_type": "code", - "execution_count": 1, - "id": "dfdc181e", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -4661,64 +4651,6 @@ "Chronos is pretrained model for zero-shot forecasting." ] }, - { - "cell_type": "code", - "execution_count": 80, - "id": "13f5f221", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "17d7b955", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "1c214441", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "085b45de", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "934b244c", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a247b7ef", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 84, @@ -5107,7 +5039,7 @@ }, { "cell_type": "markdown", - "id": "83d6d047", + "id": "e39ebb25", "metadata": {}, "source": [ "### 3.13 TimesFm Model \n", @@ -5118,7 +5050,7 @@ { "cell_type": "code", "execution_count": 98, - "id": "eee62c5e", + "id": "f7cae59a", "metadata": {}, "outputs": [], "source": [ @@ -5127,7 +5059,7 @@ }, { "cell_type": "markdown", - "id": "999d5479", + "id": "2e999f64", "metadata": {}, "source": [ "Now only one model is available." @@ -5136,7 +5068,7 @@ { "cell_type": "code", "execution_count": 99, - "id": "d19f4212", + "id": "a268ee77", "metadata": {}, "outputs": [ { @@ -5156,7 +5088,7 @@ }, { "cell_type": "markdown", - "id": "ae998579", + "id": "e57e1f23", "metadata": {}, "source": [ "Be careful. `encoder_length` needs to be a multiplier of 32." @@ -5165,7 +5097,7 @@ { "cell_type": "code", "execution_count": 100, - "id": "8697927d", + "id": "cdc514fa", "metadata": {}, "outputs": [ { @@ -5219,7 +5151,7 @@ { "cell_type": "code", "execution_count": 101, - "id": "83422d02", + "id": "625ef289", "metadata": {}, "outputs": [ { @@ -5238,7 +5170,7 @@ { "cell_type": "code", "execution_count": 102, - "id": "391044d7", + "id": "32f13834", "metadata": {}, "outputs": [ { @@ -5258,7 +5190,7 @@ }, { "cell_type": "markdown", - "id": "334b9a6b", + "id": "095326bd", "metadata": {}, "source": [ "Model can work with exogenous features." @@ -5267,7 +5199,7 @@ { "cell_type": "code", "execution_count": 103, - "id": "de5f4d5d", + "id": "10dede77", "metadata": {}, "outputs": [ { @@ -5332,7 +5264,7 @@ { "cell_type": "code", "execution_count": 104, - "id": "daeddd44", + "id": "379309bd", "metadata": {}, "outputs": [ { From 20eac8aa83e2523276efaf5d45932ffb45eb6643 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 17:34:39 +0300 Subject: [PATCH 08/20] minor fix --- etna/libs/timesfm/timesfm.py | 6 +++--- etna/libs/timesfm/timesfm_base.py | 8 ++++---- etna/models/nn/timesfm.py | 2 +- tests/test_models/test_nn/test_timesfm.py | 6 +++--- 4 files changed, 11 insertions(+), 11 deletions(-) diff --git a/etna/libs/timesfm/timesfm.py b/etna/libs/timesfm/timesfm.py index f707879fe..d46782e3c 100644 --- a/etna/libs/timesfm/timesfm.py +++ b/etna/libs/timesfm/timesfm.py @@ -206,7 +206,7 @@ def __post_init__(self): torch.cuda.is_available() and self.backend == "gpu") else "cpu") self._median_index = -1 - def _set_horizon(self, horizon): + def _set_horizon(self, horizon): # changed: added to change horizon after initialization self.horizon_len = horizon def load_from_checkpoint( @@ -216,10 +216,10 @@ def load_from_checkpoint( """Loads a checkpoint and compiles the decoder.""" checkpoint_path = checkpoint.path repo_id = checkpoint.huggingface_repo_id - if not os.path.exists(checkpoint_path): + 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) # TODO weights_only=True + 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}") diff --git a/etna/libs/timesfm/timesfm_base.py b/etna/libs/timesfm/timesfm_base.py index ade80e6c3..14755cbb3 100644 --- a/etna/libs/timesfm/timesfm_base.py +++ b/etna/libs/timesfm/timesfm_base.py @@ -207,7 +207,7 @@ def moving_average(arr, window_size): def freq_map(freq: Optional[str]): """Returns the frequency map for the given frequency string.""" - if freq is None: + 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) @@ -764,7 +764,7 @@ def forecast_on_df( uids = [] if num_jobs == 1: if verbose: - logging.info("Processing dataframe with single process.") + logging.info("Processing dataframe with single process.") # changed: replace print for key, group in df_sorted.groupby("unique_id"): inp, uid = process_group( key, @@ -778,7 +778,7 @@ def forecast_on_df( if num_jobs == -1: num_jobs = multiprocessing.cpu_count() if verbose: - logging.info("Processing dataframe with multiple processes.") + logging.info("Processing dataframe with multiple processes.") # changed: replace print with multiprocessing.Pool(processes=num_jobs) as pool: results = pool.starmap( process_group, @@ -787,7 +787,7 @@ def forecast_on_df( ) new_inputs, uids = zip(*results) if verbose: - logging.info("Finished preprocessing dataframe.") + 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, diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index 0f6bdf396..8a3bcc155 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -274,7 +274,7 @@ def forecast( else: if ts.freq is None: raise NotImplementedError( - "Data with None frequency isn't currently implemented for forecasting without exogenous features." + "Forecasting misaligned data with freq=None without exogenous features isn't currently implemented." ) target = ts.to_pandas(flatten=True, features=["target"]).dropna() diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 4a91630c0..739d51afc 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -33,7 +33,7 @@ def expected_ts_increasing_integers(): @pytest.mark.smoke -def test_chronos_url(tmp_path): +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) @@ -41,7 +41,7 @@ def test_chronos_url(tmp_path): @pytest.mark.smoke -def test_chronos_custom_cache_dir(tmp_path): +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) @@ -55,7 +55,7 @@ def test_context_size(): @pytest.mark.smoke -def test_chronos_get_model(example_tsds): +def test_get_model(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") assert isinstance(model.get_model(), TimesFmTorch) From 2b89f55bed543e2635a1521020de9b9c040dd437 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Tue, 24 Dec 2024 17:45:42 +0300 Subject: [PATCH 09/20] minor fix tests --- tests/test_models/test_nn/test_timesfm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 739d51afc..4131f5d73 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -118,7 +118,7 @@ def test_forecast_only_target_failed_int_timestamps(example_tsds_int_timestamp): pipeline.fit(example_tsds_int_timestamp) with pytest.raises( NotImplementedError, - match="Data with None frequency isn't currently implemented for forecasting without exogenous features.", + match="Forecasting misaligned data with freq=None without exogenous features isn't currently implemented.", ): _ = pipeline.forecast() From 10d60b4fb807ce93b0e0639a271cf2e4d18ff40d Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Wed, 25 Dec 2024 09:59:05 +0300 Subject: [PATCH 10/20] fix notebook, tests --- examples/202-NN_examples.ipynb | 164 +++++++++++++----- .../test_inference/test_forecast.py | 1 + tests/test_models/test_nn/test_timesfm.py | 2 - 3 files changed, 117 insertions(+), 50 deletions(-) diff --git a/examples/202-NN_examples.ipynb b/examples/202-NN_examples.ipynb index 7af8f9d14..71d116237 100644 --- a/examples/202-NN_examples.ipynb +++ b/examples/202-NN_examples.ipynb @@ -37,6 +37,16 @@ " * [TimesFM Model](#section_3_13)" ] }, + { + "cell_type": "code", + "execution_count": 1, + "id": "05682333", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -4651,6 +4661,64 @@ "Chronos is pretrained model for zero-shot forecasting." ] }, + { + "cell_type": "code", + "execution_count": 80, + "id": "d37a75b8", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "17322770", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "3b147434", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "7e37a4b5", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "e596bf7e", + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1be903d8", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 84, @@ -4720,8 +4788,8 @@ "[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.2s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.2s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.2s finished\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", @@ -4761,27 +4829,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", @@ -4792,7 +4839,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 88, "id": "cfff335c", "metadata": {}, "outputs": [], @@ -4802,7 +4849,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 89, "id": "5b07ab78", "metadata": {}, "outputs": [ @@ -4842,7 +4889,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 90, "id": "cd7238b2", "metadata": {}, "outputs": [ @@ -4869,7 +4916,7 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 91, "id": "bc2fde04", "metadata": {}, "outputs": [ @@ -4878,13 +4925,13 @@ "output_type": "stream", "text": [ "[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.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)]: Done 1 out of 1 | elapsed: 0.3s 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)]: Using backend SequentialBackend with 1 concurrent workers.\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.2s 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", @@ -4909,7 +4956,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 92, "id": "7b5d7d58", "metadata": {}, "outputs": [ @@ -4926,6 +4973,27 @@ "print(f\"Average SMAPE for Chronos small with long context: {score:.3f}\")" ] }, + { + "cell_type": "code", + "execution_count": 93, + "id": "1666d622", + "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,10 +5057,10 @@ "output_type": "stream", "text": [ "[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.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)]: 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.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.1s remaining: 0.0s\n", @@ -5039,7 +5107,7 @@ }, { "cell_type": "markdown", - "id": "e39ebb25", + "id": "2337e9ce", "metadata": {}, "source": [ "### 3.13 TimesFm Model \n", @@ -5050,7 +5118,7 @@ { "cell_type": "code", "execution_count": 98, - "id": "f7cae59a", + "id": "dfea3ca5", "metadata": {}, "outputs": [], "source": [ @@ -5059,7 +5127,7 @@ }, { "cell_type": "markdown", - "id": "2e999f64", + "id": "5a30860f", "metadata": {}, "source": [ "Now only one model is available." @@ -5068,7 +5136,7 @@ { "cell_type": "code", "execution_count": 99, - "id": "a268ee77", + "id": "876014e9", "metadata": {}, "outputs": [ { @@ -5088,7 +5156,7 @@ }, { "cell_type": "markdown", - "id": "e57e1f23", + "id": "85dc8d64", "metadata": {}, "source": [ "Be careful. `encoder_length` needs to be a multiplier of 32." @@ -5097,7 +5165,7 @@ { "cell_type": "code", "execution_count": 100, - "id": "cdc514fa", + "id": "4cea77dd", "metadata": {}, "outputs": [ { @@ -5151,7 +5219,7 @@ { "cell_type": "code", "execution_count": 101, - "id": "625ef289", + "id": "92fd49c4", "metadata": {}, "outputs": [ { @@ -5170,7 +5238,7 @@ { "cell_type": "code", "execution_count": 102, - "id": "32f13834", + "id": "ba48b07d", "metadata": {}, "outputs": [ { @@ -5190,7 +5258,7 @@ }, { "cell_type": "markdown", - "id": "095326bd", + "id": "6a6d6cd7", "metadata": {}, "source": [ "Model can work with exogenous features." @@ -5199,7 +5267,7 @@ { "cell_type": "code", "execution_count": 103, - "id": "10dede77", + "id": "c92e1d41", "metadata": {}, "outputs": [ { @@ -5264,7 +5332,7 @@ { "cell_type": "code", "execution_count": 104, - "id": "379309bd", + "id": "1a98104a", "metadata": {}, "outputs": [ { diff --git a/tests/test_models/test_inference/test_forecast.py b/tests/test_models/test_inference/test_forecast.py index 7c9120114..573ea4ce7 100644 --- a/tests/test_models/test_inference/test_forecast.py +++ b/tests/test_models/test_inference/test_forecast.py @@ -1301,6 +1301,7 @@ def test_forecast_out_sample_suffix_failed_chronos(self, model, transforms, data ], ) 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) diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 4131f5d73..af5608dbc 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -73,7 +73,6 @@ def test_predict(example_tsds): model.predict(ts=example_tsds, prediction_size=1) -@pytest.mark.smoke 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) @@ -142,7 +141,6 @@ def test_forecast_exog_int_timestamps(example_tsds_int_timestamp): _ = pipeline.forecast() -@pytest.mark.smoke @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) From e99e6872adceb82e11e2f30c133743142f4c2cbd Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Thu, 26 Dec 2024 14:19:13 +0300 Subject: [PATCH 11/20] raise exception when NaNs are in features --- etna/models/nn/timesfm.py | 95 ++++++++++------- examples/202-NN_examples.ipynb | 118 +++++----------------- tests/test_models/test_nn/test_timesfm.py | 74 ++++++++++++-- 3 files changed, 149 insertions(+), 138 deletions(-) diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index 8a3bcc155..a869ec491 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -30,14 +30,12 @@ class TimesFMModel(NonPredictionIntervalContextRequiredAbstractModel): This model is only for zero-shot forecasting: it doesn't support training on data during ``fit``. - Official implementation: https://github.com/google-research/timesfm - - Warning - ------- This model doesn't support forecasting on misaligned data with `freq=None` without exogenous features. Use :py:class:`~etna.transforms.TimeSeriesImputerTransform` to fill NaNs for stable behaviour. + Official implementation: https://github.com/google-research/timesfm + Note ---- This model requires ``timesfm`` extension to be installed. @@ -181,6 +179,14 @@ def predict( """ raise NotImplementedError("Method predict isn't currently implemented!") + def _get_exog_features(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, @@ -210,6 +216,8 @@ def forecast( 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. """ @@ -227,40 +235,55 @@ def forecast( end_idx = len(ts.index) - static_reals_dict = ( - {column: ts.df.loc[ts.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: ts.df.loc[ts.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: ts.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: ts.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 - ) + all_exog = self._get_exog_features() + df_slice = ts.df.loc[:, pd.IndexSlice[:, all_exog + ["target"]]] + first_valid_index = df_slice.isna().any(axis=1).idxmin() + + target_df = df_slice.loc[first_valid_index : ts.index[-prediction_size - 1], pd.IndexSlice[:, "target"]] + if target_df.isna().any().any(): + raise ValueError("There are NaNs in the middle or end of the time series.") future_ts = ts.tsdataset_idx_slice(start_idx=end_idx - prediction_size, end_idx=end_idx) - if static_reals_dict or static_categoricals_dict or time_varying_reals_dict or time_varying_categoricals_dict: - target = ts.df.loc[:, pd.IndexSlice[:, "target"]].dropna().values.swapaxes(1, 0).tolist() + 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]] + if exog_df.isna().any().any(): + raise ValueError("There are NaNs in the middle or end of the exogenous features.") + + 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, @@ -277,7 +300,7 @@ def forecast( "Forecasting misaligned data with freq=None without exogenous features isn't currently implemented." ) - target = ts.to_pandas(flatten=True, features=["target"]).dropna() + 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") diff --git a/examples/202-NN_examples.ipynb b/examples/202-NN_examples.ipynb index 71d116237..d6a53d551 100644 --- a/examples/202-NN_examples.ipynb +++ b/examples/202-NN_examples.ipynb @@ -37,16 +37,6 @@ " * [TimesFM Model](#section_3_13)" ] }, - { - "cell_type": "code", - "execution_count": 1, - "id": "05682333", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -4661,64 +4651,6 @@ "Chronos is pretrained model for zero-shot forecasting." ] }, - { - "cell_type": "code", - "execution_count": 80, - "id": "d37a75b8", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "17322770", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "3b147434", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "7e37a4b5", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "e596bf7e", - "metadata": {}, - "outputs": [], - "source": [ - "a = 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1be903d8", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 84, @@ -4976,7 +4908,7 @@ { "cell_type": "code", "execution_count": 93, - "id": "1666d622", + "id": "041c767b", "metadata": {}, "outputs": [ { @@ -5107,7 +5039,7 @@ }, { "cell_type": "markdown", - "id": "2337e9ce", + "id": "d438f154", "metadata": {}, "source": [ "### 3.13 TimesFm Model \n", @@ -5118,7 +5050,7 @@ { "cell_type": "code", "execution_count": 98, - "id": "dfea3ca5", + "id": "d2d30ce1", "metadata": {}, "outputs": [], "source": [ @@ -5127,7 +5059,7 @@ }, { "cell_type": "markdown", - "id": "5a30860f", + "id": "7978edc4", "metadata": {}, "source": [ "Now only one model is available." @@ -5136,7 +5068,7 @@ { "cell_type": "code", "execution_count": 99, - "id": "876014e9", + "id": "215231c6", "metadata": {}, "outputs": [ { @@ -5156,7 +5088,7 @@ }, { "cell_type": "markdown", - "id": "85dc8d64", + "id": "32806e28", "metadata": {}, "source": [ "Be careful. `encoder_length` needs to be a multiplier of 32." @@ -5165,13 +5097,13 @@ { "cell_type": "code", "execution_count": 100, - "id": "4cea77dd", + "id": "cf12e1ca", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "20c4816d7a1f43fd86b152a6257ea4cf", + "model_id": "31c00b3df9ce47b9bf5a43dfdb29b79d", "version_major": 2, "version_minor": 0 }, @@ -5188,15 +5120,15 @@ "text": [ "[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.2s 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.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.4s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.7s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 1.0s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 1.0s 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.0s remaining: 0.0s\n", @@ -5219,7 +5151,7 @@ { "cell_type": "code", "execution_count": 101, - "id": "92fd49c4", + "id": "8bf266f6", "metadata": {}, "outputs": [ { @@ -5238,7 +5170,7 @@ { "cell_type": "code", "execution_count": 102, - "id": "ba48b07d", + "id": "9ac4f029", "metadata": {}, "outputs": [ { @@ -5258,7 +5190,7 @@ }, { "cell_type": "markdown", - "id": "6a6d6cd7", + "id": "6baa3066", "metadata": {}, "source": [ "Model can work with exogenous features." @@ -5267,13 +5199,13 @@ { "cell_type": "code", "execution_count": 103, - "id": "c92e1d41", + "id": "fcc1d4c4", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eb26373760e0483abd16481719195154", + "model_id": "915baa91dd90481b93504302699e6d67", "version_major": 2, "version_minor": 0 }, @@ -5291,13 +5223,13 @@ "[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.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)]: 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.5s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 2 out of 2 | elapsed: 0.6s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.8s remaining: 0.0s\n", - "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 0.8s finished\n", + "[Parallel(n_jobs=1)]: Done 1 out of 1 | elapsed: 1.0s 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.5s remaining: 0.0s\n", + "[Parallel(n_jobs=1)]: Done 3 out of 3 | elapsed: 1.5s 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", @@ -5332,7 +5264,7 @@ { "cell_type": "code", "execution_count": 104, - "id": "1a98104a", + "id": "a38f407f", "metadata": {}, "outputs": [ { diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index af5608dbc..27f0629ef 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -1,6 +1,7 @@ import os from pathlib import Path +import numpy as np import pandas as pd import pytest from pandas.testing import assert_frame_equal @@ -15,11 +16,32 @@ from etna.transforms import SegmentEncoderTransform -@pytest.fixture -def ts_increasing_integers(): +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 + + +@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 @@ -82,34 +104,68 @@ def test_forecast_warns_big_context_size(ts_increasing_integers): @pytest.mark.parametrize("encoder_length", [32, 64, 128]) -def test_forecast(ts_increasing_integers, expected_ts_increasing_integers, encoder_length): +@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_increasing_integers) + pipeline.fit(ts) forecast = pipeline.forecast() assert_frame_equal(forecast.df, expected_ts_increasing_integers.df, atol=1) -def test_forecast_exogenous_features(ts_increasing_integers, expected_ts_increasing_integers): +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="There are NaNs in the middle or end of the time series."): + _ = 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], out_column="lag"), + 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=32, + encoder_length=encoder_length, static_categoricals=["segment_code"], - time_varying_reals=[f"lag_{horizon}"], + 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_increasing_integers) + 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 end of the time series."): + _ = 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) From 85fbe3c5b70c149dbe6aa3ebfd90231766debe16 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Thu, 26 Dec 2024 16:05:48 +0300 Subject: [PATCH 12/20] minor fixes --- etna/models/nn/timesfm.py | 30 +++++++++++---- tests/test_models/test_nn/test_timesfm.py | 47 ++++++++++++++++++++++- 2 files changed, 67 insertions(+), 10 deletions(-) diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index a869ec491..0fc504360 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -1,4 +1,5 @@ import os +import reprlib import warnings from pathlib import Path from typing import Dict @@ -32,7 +33,8 @@ class TimesFMModel(NonPredictionIntervalContextRequiredAbstractModel): This model doesn't support forecasting on misaligned data with `freq=None` without exogenous features. - Use :py:class:`~etna.transforms.TimeSeriesImputerTransform` to fill NaNs for stable behaviour. + This model doesn't support NaN in the middle or at the end of time series. + Use :py:class:`~etna.transforms.TimeSeriesImputerTransform` to fill them. Official implementation: https://github.com/google-research/timesfm @@ -179,7 +181,7 @@ def predict( """ raise NotImplementedError("Method predict isn't currently implemented!") - def _get_exog_features(self) -> List[str]: + def _exog_сolumns(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 @@ -235,13 +237,20 @@ def forecast( end_idx = len(ts.index) - all_exog = self._get_exog_features() + all_exog = self._exog_сolumns() df_slice = ts.df.loc[:, pd.IndexSlice[:, all_exog + ["target"]]] - first_valid_index = df_slice.isna().any(axis=1).idxmin() + 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"]] - if target_df.isna().any().any(): - raise ValueError("There are NaNs in the middle or end of the time series.") + + 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).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) @@ -249,8 +258,13 @@ def forecast( target = target_df.values.swapaxes(1, 0).tolist() exog_df = df_slice.loc[first_valid_index:, pd.IndexSlice[:, all_exog]] - if exog_df.isna().any().any(): - raise ValueError("There are NaNs in the middle or end of the exogenous features.") + + 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).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 = ( { diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 27f0629ef..3778c432b 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -23,6 +23,13 @@ def generate_increasing_df(): 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() @@ -54,6 +61,24 @@ def expected_ts_increasing_integers(): 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" @@ -118,7 +143,7 @@ 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="There are NaNs in the middle or end of the time series."): + with pytest.raises(ValueError, match=r"There are NaNs in the middle or at the end of target. Segments with NaNs:"): _ = pipeline.forecast() @@ -162,7 +187,25 @@ def test_forecast_exog_features_failed_nan_middle_target(ts_nan_middle): ) 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 end of the time series."): + 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() From 36c3f2b5f43fd2e7d4125064b9bd274ef65b226c Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Thu, 26 Dec 2024 19:16:20 +0300 Subject: [PATCH 13/20] fix --- etna/models/nn/timesfm.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index 0fc504360..160e1f6c7 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -33,7 +33,7 @@ class TimesFMModel(NonPredictionIntervalContextRequiredAbstractModel): 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 time series. + 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 @@ -181,7 +181,7 @@ def predict( """ raise NotImplementedError("Method predict isn't currently implemented!") - def _exog_сolumns(self) -> List[str]: + 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 @@ -247,7 +247,7 @@ def forecast( 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).tolist() + 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)}." ) @@ -261,7 +261,7 @@ def forecast( 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).tolist() + 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)}." ) From 67fb748860132728f969430fcddc18a1d52b72db Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Thu, 26 Dec 2024 19:19:22 +0300 Subject: [PATCH 14/20] fix --- etna/models/nn/timesfm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/etna/models/nn/timesfm.py b/etna/models/nn/timesfm.py index 160e1f6c7..793665269 100644 --- a/etna/models/nn/timesfm.py +++ b/etna/models/nn/timesfm.py @@ -237,7 +237,7 @@ def forecast( end_idx = len(ts.index) - all_exog = self._exog_сolumns() + 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() From 397086fee82f985498aa247454129de1408f55aa Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Fri, 27 Dec 2024 11:05:38 +0300 Subject: [PATCH 15/20] skip timesfm tests in inference tests --- .../test_inference/test_forecast.py | 77 ++++++++++++++++--- .../test_inference/test_predict.py | 63 ++++++++++++--- 2 files changed, 120 insertions(+), 20 deletions(-) diff --git a/tests/test_models/test_inference/test_forecast.py b/tests/test_models/test_inference/test_forecast.py index 573ea4ce7..eb3a25ea9 100644 --- a/tests/test_models/test_inference/test_forecast.py +++ b/tests/test_models/test_inference/test_forecast.py @@ -249,7 +249,12 @@ def test_forecast_in_sample_full_no_target_failed_chronos(self, model, transform @pytest.mark.parametrize( "model, transforms, dataset_name", [ - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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_full_no_target_failed_timesfm(self, model, transforms, dataset_name, request): @@ -422,7 +427,12 @@ def test_forecast_in_sample_full_failed_chronos(self, model, transforms, dataset @pytest.mark.parametrize( "model, transforms, dataset_name", [ - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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_full_failed_timesfm(self, model, transforms, dataset_name, request): @@ -516,7 +526,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -641,7 +656,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -817,7 +837,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -920,7 +945,12 @@ def test_forecast_out_sample_int_timestamp(self, model, transforms, dataset_name @pytest.mark.parametrize( "model, transforms, dataset_name", [ - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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_int_timestamp_failed_timesfm(self, model, transforms, dataset_name, request): @@ -1085,7 +1115,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -1297,7 +1332,12 @@ def test_forecast_out_sample_suffix_failed_chronos(self, model, transforms, data @pytest.mark.parametrize( "model, transforms, dataset_name", [ - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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_suffix_failed_timesfm(self, model, transforms, dataset_name, request): @@ -1446,7 +1486,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -1609,7 +1654,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -1787,7 +1837,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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 601703b36..a6ef08bd8 100644 --- a/tests/test_models/test_inference/test_predict.py +++ b/tests/test_models/test_inference/test_predict.py @@ -196,7 +196,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -328,7 +333,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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( @@ -475,7 +485,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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( @@ -618,7 +633,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -778,7 +798,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -952,7 +977,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -1131,7 +1161,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -1298,7 +1333,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): @@ -1430,7 +1470,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"), - (TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32), [], "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): From 409ac14d38fb91af15ce8eaca877e8b136225fc9 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Fri, 27 Dec 2024 12:58:54 +0300 Subject: [PATCH 16/20] skip test for timesfm --- tests/test_models/test_nn/test_timesfm.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 3778c432b..da032ea86 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -79,6 +79,7 @@ def ts_exog_all_nan(): return ts +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_url(tmp_path): model_name = "timesfm-1.0-200m-pytorch.ckpt" @@ -87,6 +88,7 @@ def test_url(tmp_path): assert os.path.exists(tmp_path / model_name) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_cache_dir(tmp_path): path_or_url = "google/timesfm-1.0-200m-pytorch" @@ -95,24 +97,28 @@ def test_cache_dir(tmp_path): assert os.path.exists(tmp_path / f"models--google--{model_name}") +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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.skip(reason="Model causes OOM in GitHub Actions.") @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.skip(reason="Model causes OOM in GitHub Actions.") @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.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_predict(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") @@ -120,6 +126,7 @@ def test_predict(example_tsds): model.predict(ts=example_tsds, prediction_size=1) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") 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) @@ -139,6 +146,7 @@ def test_forecast(ts, expected_ts_increasing_integers, encoder_length, request): assert_frame_equal(forecast.df, expected_ts_increasing_integers.df, atol=1) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") 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) @@ -171,6 +179,7 @@ def test_forecast_exogenous_features(ts, expected_ts_increasing_integers, encode assert_frame_equal(forecast.df.loc[:, pd.IndexSlice[:, "target"]], expected_ts_increasing_integers.df, atol=1) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") def test_forecast_exog_features_failed_nan_middle_target(ts_nan_middle): horizon = 2 transforms = [ @@ -191,6 +200,7 @@ def test_forecast_exog_features_failed_nan_middle_target(ts_nan_middle): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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) @@ -209,6 +219,7 @@ def test_forecast_exog_features_failed_exog_nan(ts, request): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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) @@ -221,6 +232,7 @@ def test_forecast_only_target_failed_int_timestamps(example_tsds_int_timestamp): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_forecast_exog_int_timestamps(example_tsds_int_timestamp): horizon = 2 @@ -240,6 +252,7 @@ def test_forecast_exog_int_timestamps(example_tsds_int_timestamp): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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) @@ -249,6 +262,7 @@ def test_forecast_wrong_context_len(ts_increasing_integers, encoder_length): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_forecast_without_fit(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32) @@ -256,6 +270,7 @@ def test_forecast_without_fit(example_tsds): _ = pipeline.forecast(example_tsds) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_forecast_fails_components(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") @@ -264,11 +279,13 @@ def test_forecast_fails_components(example_tsds): pipeline.forecast(ts=example_tsds, return_components=True) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_list_models(): assert TimesFMModel.list_models() == ["google/timesfm-1.0-200m-pytorch"] +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_save_load(tmp_path, ts_increasing_integers): path = Path(tmp_path) / "tmp.zip" @@ -282,6 +299,7 @@ def test_save_load(tmp_path, ts_increasing_integers): assert isinstance(loaded_model, TimesFMModel) +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_params_to_tune(): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") From 0d27c55f36d6b92719662d2fa3e0427337be6c5a Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Fri, 27 Dec 2024 13:49:29 +0300 Subject: [PATCH 17/20] skip last 2 tests --- tests/test_models/test_nn/test_timesfm.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index da032ea86..491846946 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -135,6 +135,7 @@ def test_forecast_warns_big_context_size(ts_increasing_integers): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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): @@ -155,6 +156,7 @@ def test_forecast_failed_nan_middle_target(ts_nan_middle): _ = pipeline.forecast() +@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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): From bdd0ec61e60f76b9285da7789d5672095a1d476a Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Fri, 27 Dec 2024 16:24:36 +0300 Subject: [PATCH 18/20] comment inference timesfm tests --- .../test_inference/test_forecast.py | 133 +++++++++--------- .../test_inference/test_predict.py | 109 +++++++------- 2 files changed, 120 insertions(+), 122 deletions(-) diff --git a/tests/test_models/test_inference/test_forecast.py b/tests/test_models/test_inference/test_forecast.py index eb3a25ea9..7b7557c9b 100644 --- a/tests/test_models/test_inference/test_forecast.py +++ b/tests/test_models/test_inference/test_forecast.py @@ -46,7 +46,6 @@ from etna.models.nn import RNNModel from etna.models.nn import TFTModel from etna.models.nn import TFTNativeModel -from etna.models.nn import TimesFMModel from etna.models.nn.deepstate import CompositeSSM from etna.models.nn.deepstate import WeeklySeasonalitySSM from etna.transforms import LagTransform @@ -249,12 +248,12 @@ def test_forecast_in_sample_full_no_target_failed_chronos(self, model, transform @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."), - ), + # 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): @@ -427,12 +426,12 @@ def test_forecast_in_sample_full_failed_chronos(self, model, transforms, dataset @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."), - ), + # 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): @@ -526,12 +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."), - ), + # 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): @@ -656,12 +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."), - ), + # 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): @@ -837,12 +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."), - ), + # 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): @@ -945,12 +944,12 @@ def test_forecast_out_sample_int_timestamp(self, model, transforms, dataset_name @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."), - ), + # 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): @@ -1115,12 +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."), - ), + # 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): @@ -1332,12 +1331,12 @@ def test_forecast_out_sample_suffix_failed_chronos(self, model, transforms, data @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."), - ), + # 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): @@ -1486,12 +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."), - ), + # 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): @@ -1654,12 +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."), - ), + # 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): @@ -1837,12 +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."), - ), + # 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 a6ef08bd8..2c8d433dc 100644 --- a/tests/test_models/test_inference/test_predict.py +++ b/tests/test_models/test_inference/test_predict.py @@ -44,7 +44,6 @@ from etna.models.nn import RNNModel from etna.models.nn import TFTModel from etna.models.nn import TFTNativeModel -from etna.models.nn import TimesFMModel from etna.models.nn.deepstate import CompositeSSM from etna.models.nn.deepstate import WeeklySeasonalitySSM from etna.transforms import LagTransform @@ -196,12 +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."), - ), + # 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): @@ -333,12 +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."), - ), + # 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( @@ -485,12 +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."), - ), + # 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( @@ -633,12 +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."), - ), + # 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): @@ -798,12 +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."), - ), + # 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): @@ -977,12 +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."), - ), + # 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): @@ -1161,12 +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."), - ), + # 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): @@ -1333,12 +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."), - ), + # 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): @@ -1470,12 +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."), - ), + # 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): From c911b2f23a1a59247e578f592cf3a5346062ffaa Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Fri, 27 Dec 2024 17:08:34 +0300 Subject: [PATCH 19/20] unlock one test --- tests/test_models/test_nn/test_timesfm.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 491846946..4c17fd71f 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -79,7 +79,6 @@ def ts_exog_all_nan(): return ts -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_url(tmp_path): model_name = "timesfm-1.0-200m-pytorch.ckpt" From 2b3e3fc9a1a0f44cb82478398d5191e2853aeec0 Mon Sep 17 00:00:00 2001 From: Egor Baturin Date: Fri, 27 Dec 2024 17:53:19 +0300 Subject: [PATCH 20/20] unlock all tests --- tests/test_models/test_nn/test_timesfm.py | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/tests/test_models/test_nn/test_timesfm.py b/tests/test_models/test_nn/test_timesfm.py index 4c17fd71f..3778c432b 100644 --- a/tests/test_models/test_nn/test_timesfm.py +++ b/tests/test_models/test_nn/test_timesfm.py @@ -87,7 +87,6 @@ def test_url(tmp_path): assert os.path.exists(tmp_path / model_name) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_cache_dir(tmp_path): path_or_url = "google/timesfm-1.0-200m-pytorch" @@ -96,28 +95,24 @@ def test_cache_dir(tmp_path): assert os.path.exists(tmp_path / f"models--google--{model_name}") -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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.skip(reason="Model causes OOM in GitHub Actions.") @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.skip(reason="Model causes OOM in GitHub Actions.") @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.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_predict(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") @@ -125,7 +120,6 @@ def test_predict(example_tsds): model.predict(ts=example_tsds, prediction_size=1) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") 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) @@ -134,7 +128,6 @@ def test_forecast_warns_big_context_size(ts_increasing_integers): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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): @@ -146,7 +139,6 @@ def test_forecast(ts, expected_ts_increasing_integers, encoder_length, request): assert_frame_equal(forecast.df, expected_ts_increasing_integers.df, atol=1) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") 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) @@ -155,7 +147,6 @@ def test_forecast_failed_nan_middle_target(ts_nan_middle): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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): @@ -180,7 +171,6 @@ def test_forecast_exogenous_features(ts, expected_ts_increasing_integers, encode assert_frame_equal(forecast.df.loc[:, pd.IndexSlice[:, "target"]], expected_ts_increasing_integers.df, atol=1) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") def test_forecast_exog_features_failed_nan_middle_target(ts_nan_middle): horizon = 2 transforms = [ @@ -201,7 +191,6 @@ def test_forecast_exog_features_failed_nan_middle_target(ts_nan_middle): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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) @@ -220,7 +209,6 @@ def test_forecast_exog_features_failed_exog_nan(ts, request): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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) @@ -233,7 +221,6 @@ def test_forecast_only_target_failed_int_timestamps(example_tsds_int_timestamp): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_forecast_exog_int_timestamps(example_tsds_int_timestamp): horizon = 2 @@ -253,7 +240,6 @@ def test_forecast_exog_int_timestamps(example_tsds_int_timestamp): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @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) @@ -263,7 +249,6 @@ def test_forecast_wrong_context_len(ts_increasing_integers, encoder_length): _ = pipeline.forecast() -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_forecast_without_fit(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch", encoder_length=32) @@ -271,7 +256,6 @@ def test_forecast_without_fit(example_tsds): _ = pipeline.forecast(example_tsds) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_forecast_fails_components(example_tsds): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch") @@ -280,13 +264,11 @@ def test_forecast_fails_components(example_tsds): pipeline.forecast(ts=example_tsds, return_components=True) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_list_models(): assert TimesFMModel.list_models() == ["google/timesfm-1.0-200m-pytorch"] -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_save_load(tmp_path, ts_increasing_integers): path = Path(tmp_path) / "tmp.zip" @@ -300,7 +282,6 @@ def test_save_load(tmp_path, ts_increasing_integers): assert isinstance(loaded_model, TimesFMModel) -@pytest.mark.skip(reason="Model causes OOM in GitHub Actions.") @pytest.mark.smoke def test_params_to_tune(): model = TimesFMModel(path_or_url="google/timesfm-1.0-200m-pytorch")