From 50db0ca6c9f8419de9195622b5c6a8c256f8a2d9 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Sat, 16 Nov 2024 09:54:06 -0800 Subject: [PATCH 001/140] [cye/evo2-llm-dev] Private internal development branch for Evo2 in BioNeMo. --- 3rdparty/Megatron-LM | 2 +- 3rdparty/NeMo | 2 +- sub-packages/bionemo-evo2/LICENSE | 202 ++++++++++++++++++ sub-packages/bionemo-evo2/README.md | 1 + sub-packages/bionemo-evo2/VERSION | 1 + sub-packages/bionemo-evo2/pyproject.toml | 35 +++ .../bionemo-evo2/src/bionemo/evo2/README.md | 1 + sub-packages/bionemo-evo2/tests/README.md | 1 + 8 files changed, 243 insertions(+), 2 deletions(-) create mode 100644 sub-packages/bionemo-evo2/LICENSE create mode 100644 sub-packages/bionemo-evo2/README.md create mode 100644 sub-packages/bionemo-evo2/VERSION create mode 100644 sub-packages/bionemo-evo2/pyproject.toml create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/README.md create mode 100644 sub-packages/bionemo-evo2/tests/README.md diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index aded519cfb..2348b70f8c 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit aded519cfb1de2abf96f36ca059f992294b7876f +Subproject commit 2348b70f8c727a33f1d4f1acc87877fec64473bd diff --git a/3rdparty/NeMo b/3rdparty/NeMo index e2b0f0ead1..edba56aa90 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit e2b0f0ead13be29476c047dfb49ad49f85a849bb +Subproject commit edba56aa90ecafdd997e76b8a1c0984bfa111c5a diff --git a/sub-packages/bionemo-evo2/LICENSE b/sub-packages/bionemo-evo2/LICENSE new file mode 100644 index 0000000000..d645695673 --- /dev/null +++ b/sub-packages/bionemo-evo2/LICENSE @@ -0,0 +1,202 @@ + + 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. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md new file mode 100644 index 0000000000..f032c8c889 --- /dev/null +++ b/sub-packages/bionemo-evo2/README.md @@ -0,0 +1 @@ +Library containing data preprocessing, training, and inference tooling for Evo2. \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/VERSION b/sub-packages/bionemo-evo2/VERSION new file mode 100644 index 0000000000..cd5ac039d6 --- /dev/null +++ b/sub-packages/bionemo-evo2/VERSION @@ -0,0 +1 @@ +2.0 diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml new file mode 100644 index 0000000000..0b75bd0ce6 --- /dev/null +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -0,0 +1,35 @@ +[build-system] +requires = ["setuptools>=64", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "bionemo-evo2" +readme = "README.md" +description = "Library containing data preprocessing, training, and inference tooling for Evo2." +authors = [{ name = "BioNeMo Team", email = "bionemofeedback@nvidia.com" }] +requires-python = ">=3.10" +license = { file = "LICENSE" } +dynamic = ["version"] +dependencies = [] + +[project.scripts] +bionemo-evo2-train = "" +bionemo-evo2-recipe = "" +infer_evo2 = "" +train_evo2 = "" + +# Make sure that the tokenizer files are included along with the python files during installation. +[tool.setuptools.package-data] +"bionemo.evo2" = [] + +[tool.setuptools.packages.find] +where = ["src"] +include = ["bionemo.*"] +namespaces = true +exclude = ["test*."] + +[tool.setuptools.dynamic] +version = { file = "VERSION" } + +[tool.uv] +cache-keys = [{ git = true }] \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md new file mode 100644 index 0000000000..81b4e9b765 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md @@ -0,0 +1 @@ +Source code for BioNeMo Evo2. \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/tests/README.md b/sub-packages/bionemo-evo2/tests/README.md new file mode 100644 index 0000000000..5be056289a --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/README.md @@ -0,0 +1 @@ +Tests for BioNeMo Evo2. \ No newline at end of file From 737f16cd10a67797cb19e09ca3876686cf3a7f5a Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Wed, 4 Dec 2024 10:07:10 -0800 Subject: [PATCH 002/140] [cye/evo2-llm-dev] Add rough draft of data preprocessing for Evo2. --- 3rdparty/Megatron-LM | 2 +- 3rdparty/NeMo | 2 +- sub-packages/bionemo-evo2/pyproject.toml | 10 +- .../bionemo-evo2/src/bionemo/evo2/__init__.py | 14 + .../src/bionemo/evo2/data/__init__.py | 14 + .../src/bionemo/evo2/data/config.py | 71 ++++ .../src/bionemo/evo2/data/dataset.py | 93 +++++ .../src/bionemo/evo2/data/preprocess.py | 319 ++++++++++++++++++ .../bionemo/evo2/data/resources/__init__.py | 14 + .../evo2/data/resources/phyla_kingdom_map.py | 71 ++++ .../src/bionemo/evo2/data/tokenizer.py | 76 +++++ .../src/bionemo/evo2/run/__init__.py | 14 + .../src/bionemo/evo2/run/infer.py | 77 +++++ .../src/bionemo/evo2/run/train.py | 187 ++++++++++ .../src/bionemo/evo2/utils/torch2nemo.py | 289 ++++++++++++++++ .../tests/config/test_preproc_config.yaml | 38 +++ 16 files changed, 1284 insertions(+), 7 deletions(-) create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py create mode 100644 sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index 2348b70f8c..cbb9c5a431 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit 2348b70f8c727a33f1d4f1acc87877fec64473bd +Subproject commit cbb9c5a4312d537b48cf93844bf54ee94060b3bc diff --git a/3rdparty/NeMo b/3rdparty/NeMo index edba56aa90..093578467e 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit edba56aa90ecafdd997e76b8a1c0984bfa111c5a +Subproject commit 093578467e3cee73e7e27edb2d926940515cb78d diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index 0b75bd0ce6..bb8270e32b 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -12,11 +12,11 @@ license = { file = "LICENSE" } dynamic = ["version"] dependencies = [] -[project.scripts] -bionemo-evo2-train = "" -bionemo-evo2-recipe = "" -infer_evo2 = "" -train_evo2 = "" +# [project.scripts] +# bionemo-evo2-train = "" +# bionemo-evo2-recipe = "" +# infer_evo2 = "" +# train_evo2 = "" # Make sure that the tokenizer files are included along with the python files during installation. [tool.setuptools.package-data] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py new file mode 100644 index 0000000000..172dc0ad0f --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py @@ -0,0 +1,71 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path +from typing import Literal + +from pydantic import BaseModel + + +class Evo2PreprocessingConfig(BaseModel): + """Class specifying the configuration schema for Evo2 data preprocessing.""" + + # Paths + datapaths: list[Path] = [] + output_dir: None | Path = None + output_prefix: None | str = None + # Datasplit + train_split: float = 0.7 + valid_split: float = 0.2 + test_split: float = 0.1 + # Evo Taxonomy + taxonomy_path: None | Path = None + # Raw Preprocessing Transforms + gzip_data: bool = False + embed_reverse_complement: bool = False + random_reverse_complement: bool = False + subsequence_length: None | int = None + include_sequence_id: bool = False + transcribe: None | Literal["transcribe", "back_transcribe"] = None + force_uppercase: bool = False + # Tokenizer + tokenizer_type: Literal[ + "Byte-Level", + "HuggingFace", + "SentencePiece", + "Regex", + "Megatron", + "Tiktoken", + ] = "Byte-Level" + vocab_file: None | Path = None + vocab_size: None | int = 512 + merges_file: None | Path = None + # Either a named pretrained tokenizer model, or a path to a SentencePiece tokenizer. + pretrained_tokenizer_model: None | str = None + special_tokens: None | dict[str, str] = {} + fast_hf_tokenizer: bool = False + append_eod: bool = False + enforce_sample_length: None | int = None + ftfy: bool = False + indexed_dataset_dtype: str = "uint8" + # Compute + workers: int = 1 + preproc_concurrency: int = 10000 + # Filters + drop_empty_sequences: bool = False + nnn_filter: bool = False + # RNG + seed: None | int = None diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py new file mode 100644 index 0000000000..57b0b4f50c --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py @@ -0,0 +1,93 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import ClassVar, Dict, Optional + +import torch +from megatron.core.datasets.gpt_dataset import GPTDataset + + +class Evo2Dataset(GPTDataset): + """Dataset for training Evo2.""" + + CONTROL_TAGS: ClassVar[list[int]] = [64, 35] # '@' tag for splice splits/windows, '#' for contig splits + TAG_BOUNDS = 124 # start and end delim: '|' + TAG_CHARS: ClassVar[set[int]] = {95, 59, 32} # chars only found in control tags: _, ;, space + DEFAULT_EOD = 0 + + def __getitem__(self, idx: Optional[int]) -> Dict[str, torch.Tensor]: + """Get data at the specified index.""" + databatch: dict = super().__getitem__(idx) + labels = databatch.get("labels", None) + loss_mask = databatch.get("loss_mask", None) + if labels is None or loss_mask is None: + # No next-token labels or loss to mask. + return databatch + + # Mask special label tags in loss. + control_mask = torch.isin(labels, torch.tensor(self.CONTROL_TAGS, device=labels.device)) + loss_mask[control_mask] = 0 + phylotag_mask = Evo2Dataset.mask_phylogenetic_tags( + labels, + self.TAG_BOUNDS, + self.TAG_CHARS, + self.config.tokenizer.eod if self.config.tokenizer is not None else self.DEFAULT_EOD, + ) + databatch["loss_mask"] = loss_mask * phylotag_mask + + return databatch + + @staticmethod + def mask_phylogenetic_tags(tokenized_sequence, terminal_tag_char, other_tag_chars, eod_token_id): + """Optimized version to create a phylonetic tag mask for batched tokenized sequences with correct handling of partial tags. + + Args: + tokenized_sequence (torch.Tensor): A batched tensor of shape (batch_size, seq_length). If (seq_length,) is detected, it will be converted into a (1, seq_length) tensor. + terminal_tag_char (int): The token ID representing the start and end of a phylogenetic tag ('|'). + other_tag_chars (set of int): A set of token IDs that are uniquely part of the tag ('_', ';', etc.). + eod_token_id (int): The token ID representing the end-of-document (EOD). + + Returns: + mask_vector (torch.Tensor): A batched mask of the same shape as tokenized_sequence where 1 represents non-tag tokens and 0 represents tokens within the masked region. + """ + device = tokenized_sequence.device + if len(tokenized_sequence.shape) == 1: + tokenized_sequence = tokenized_sequence.unsqueeze(dim=0) + batch_size, seq_len = tokenized_sequence.shape + mask_vector = torch.ones_like(tokenized_sequence, dtype=torch.int, device=device) + + # To address when unbalanced tags are present + terms = torch.tensor([0, seq_len - 1], device=device) + other_tags = torch.tensor(list(other_tag_chars), device=device) + for batch_idx in range(batch_size): + tag_term_locs = torch.where(tokenized_sequence[batch_idx] == terminal_tag_char)[0] + tag_end_locs = torch.where(tokenized_sequence[batch_idx] == eod_token_id)[0] + + merged_tags = torch.cat((terms, tag_term_locs, tag_end_locs)).sort()[0] + merged_tags = merged_tags.unique() + + start = 0 # First and last locations are always added + for end in merged_tags[1:]: + if torch.isin(tokenized_sequence[batch_idx][start:end], other_tags).sum() > 0: + # end token is not part of the tag + if eod_token_id == tokenized_sequence[batch_idx][end]: + end = end - 1 + if eod_token_id == tokenized_sequence[batch_idx][start]: + start = start + 1 + + mask_vector[batch_idx][start : (end + 1)] = 0 + start = end + return mask_vector diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py new file mode 100644 index 0000000000..2f38f4c78c --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -0,0 +1,319 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +"""Module containing data preprocessing and splitting functions for Evo2 in BioNeMo. + +It can also be utilized as a script to dump pre-processed data to JSON. + +TODO(@cye): Add commentary and config interface. +""" + +import argparse +import gzip +import multiprocessing as mp +import random +from contextlib import contextmanager +from pathlib import Path +from threading import Semaphore + +import numpy as np +import pandas as pd +import torch +import yaml +from Bio import Seq, SeqIO +from megatron.core.datasets.indexed_dataset import IndexedDatasetBuilder +from nemo.utils import logging + +from bionemo.evo2.data.config import Evo2PreprocessingConfig +from bionemo.evo2.data.resources.phyla_kingdom_map import PHYLA_TO_KINGDOM +from bionemo.evo2.data.tokenizer import Evo2Tokenizer + + +@contextmanager +def preprocessing_context_manager(seed: int | None = None): + """Context manager for Evo2 preprocessing RNG.""" + # Track current state. + current_state = random.getstate() + try: + # Set random seed. + random.seed(seed) + yield seed + finally: + # Restore random state. + random.setstate(current_state) + + +class Evo2Preprocessor: + """Data preprocessing class for Evo2.""" + + VBAR = "|" + PROMPT_SPACER_LENGTH = 131_072 + + def __init__(self, params: Evo2PreprocessingConfig | None = None): + """Initialize Evo2Preprocessor.""" + self.params: Evo2PreprocessingConfig = params if params is not None else Evo2PreprocessingConfig() + self.tokenizer: Evo2Tokenizer = Evo2Tokenizer(self.params) + self.id_to_taxonomy: dict | None = ( + self._load_evo_taxonomy(self.params.taxonomy_path) if self.params.taxonomy_path is not None else None + ) + + @staticmethod + def _subsequence_generator(sequence: Seq.Seq, subsequence_length: int | None = None, offset: int | None = None): + subsequence_length = subsequence_length if isinstance(subsequence_length, int) else len(sequence) + step_size = offset if isinstance(offset, int) else subsequence_length + for i in range(0, len(sequence), step_size): + yield sequence[i : i + subsequence_length] + + @staticmethod + def _random_reverse_complement(seq: Seq.Seq, prob: float = 0.5): + if random.random() < prob: + return seq.reverse_complement() + else: + return seq + + @staticmethod + def _reverse_complement_expansion(seq: Seq.Seq): + return [seq, seq.reverse_complement()] + + @staticmethod + def _get_evo_seq_id(filename: str): + try: + return ".".join(filename.split("/")[-1].split(".")[:-1]) + except Exception: + return None + + @staticmethod + def _get_evo_phyla_from_lineage_string(lineage_str: str): + try: + return lineage_str.split(";")[1].split("_")[-1] + except Exception: + return None + + @staticmethod + def _load_evo_taxonomy(fname): + df = pd.read_csv(fname, sep="\t") + id_to_taxonomy = {} + for _, row in df.iterrows(): + lineage_string = ( + f'd__{row["kingdom"]};' + f'p__{row["phylum"]};' + f'c__{row["class"]};' + f'o__{row["order"]};' + f'f__{row["family"]};' + f'g__{row["genus"]};' + f's__{row["species"]}' + ) + id_to_taxonomy[row["genome_id"]] = lineage_string + return id_to_taxonomy + + @staticmethod + def _yield_sequences_from_files(fnames: list, semaphore: Semaphore, gzip_data: bool = False): + """Iterator over sequences within multiple input documents. Arguments for multiprocessing tasks. + + Utilized to limit the amount of sequences streamed into memory. + TODO(@cye): Just do the fasta parsing ourselves if there's no weird formats. + """ + + def yielder(fname, semaphore): + # Open file. + with gzip.open(fname, "rt") if gzip_data else open(fname, "r") as f: + for record in SeqIO.parse(f, "fasta"): + semaphore.acquire() + # Yield filename and record within fasta. + yield str(fname), record + + for fname in fnames: + semaphore.acquire() + yield from yielder(fname, semaphore) + + def configure(self, params: Evo2PreprocessingConfig | None = None): + """Configure a new Evo2PreprocessingConfig for Evo2Preprocessor.""" + self.params = params if params is not None else Evo2PreprocessingConfig() + self.id_to_taxonomy = ( + self._load_evo_taxonomy(self.params.taxonomy_path) if self.params.taxonomy_path is not None else None + ) + + def preprocess_data(self, filepath: str, record) -> list[dict]: + """Preprocess Evo2 fasta datapaths.""" + # Retrieve EVO taxonomy metadata if id_to_taxonomy is provided. + lineage_string = ( + self.id_to_taxonomy.get(self._get_evo_seq_id(str(filepath)), None) + if isinstance(self.id_to_taxonomy, dict) + else None + ) + phyla = self._get_evo_phyla_from_lineage_string(lineage_string) if lineage_string is not None else None + kingdom = PHYLA_TO_KINGDOM.get(phyla, None) if phyla is not None else None + if isinstance(self.id_to_taxonomy, dict) and (lineage_string is None or kingdom is None): + logging.info(f"No taxonomy lineage metadata detected for {filepath}. Skipping datafile...") + return [] + + # Preprocess data. + preproc_data = [] + with preprocessing_context_manager( + self.params.seed + hash(filepath) if self.params.seed is not None else None + ): + seq = record.seq + # Randomly reverse complement the sequence. + seq = self._random_reverse_complement(seq, prob=0.5) if self.params.random_reverse_complement else seq + seqs_to_parse = self._reverse_complement_expansion(seq) if self.params.embed_reverse_complement else [seq] + for seq in seqs_to_parse: + if self.params.force_uppercase: + seq = seq.upper() + if self.params.transcribe == "transcribe": + seq = seq.transcribe() + elif self.params.transcribe == "back_transcribe": + seq = seq.back_transcribe() + if self.params.drop_empty_sequences and len(seq) == 0: + continue + if self.params.nnn_filter and "NNN" in seq.upper(): + continue + taxonomy_token = ( + self.VBAR + lineage_string.upper() + self.VBAR if isinstance(lineage_string, str) else None + ) + target_length = ( + # Full sequence length minus bandwidth for the special Taxonomy token. + self.PROMPT_SPACER_LENGTH - len(taxonomy_token) + if isinstance(taxonomy_token, str) + # Chunk into subsequences. If None, then default to sequence length. + else self.params.subsequence_length + ) + for i, subseq in enumerate(self._subsequence_generator(seq, target_length, target_length)): + preproc_data_record = { + "text": taxonomy_token + str(subseq) if taxonomy_token is not None else str(subseq), + } + if self.params.include_sequence_id: + preproc_data_record["id"] = f"{record.id}_{i}" + # Tokenize the sequence. + preproc_data_record["tokens"] = self.tokenizer.tokenize( + preproc_data_record["text"], + use_ftfy=self.params.ftfy, + enforce_sample_length=self.params.enforce_sample_length, + append_eod=self.params.append_eod, + drop_empty_sequences=self.params.drop_empty_sequences, + ) + preproc_data.append(preproc_data_record) + return preproc_data + + def preprocess_data_task(self, file_record): + """Wrapper function to unpack args for preprocess_data.""" + return self.preprocess_data(*file_record) + + def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): + """Main function to preprocess data for Evo2.""" + # Configure preprocessor. + self.configure(preproc_config) + + # Instantiate multiprocessing pool. + semaphore = Semaphore(preproc_config.preproc_concurrency + preproc_config.workers) + if preproc_config.workers > 1: + pool = mp.Pool(preproc_config.workers) + # Ordered imap for downstream seeded splitting. + preproc_tasks = pool.imap( + evo2_preprocessor.preprocess_data_task, + Evo2Preprocessor._yield_sequences_from_files( + preproc_config.datapaths, semaphore, preproc_config.gzip_data + ), + chunksize=25, + ) + else: + preproc_tasks = ( + evo2_preprocessor.preprocess_data_task(x) + for x in Evo2Preprocessor._yield_sequences_from_files( + preproc_config.datapaths, semaphore, preproc_config.gzip_data + ) + ) + + # Preprocess data and split results into train, test, and split. + with preprocessing_context_manager(preproc_config.seed if preproc_config.seed is not None else None): + for result in preproc_tasks: + # Release semaphore for the task associated with the result. + semaphore.release() + # Randomly assign all sequences from this document to train, val, or test. + roll = random.random() + split = "train" + if roll > evo2_preproc_config.train_split: + if roll < 1 - evo2_preproc_config.test_split: + split = "val" + else: + split = "test" + for sequence in result: + sequence["split"] = split + yield sequence + + def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): + """Offline data preprocessing script for Evo2.""" + # Process output directory. + output_dir = preproc_config.output_dir + if output_dir is None: + output_dir = Path.cwd() + # Build train, validation, and test datasplits. + BIN = ".bin" + TRAIN_SUFFIX = "_train" + VAL_SUFFIX = "_val" + TEST_SUFFIX = "_test" + config_prefix = "{}_{}".format( + preproc_config.output_prefix, preproc_config.tokenizer_type.lower().replace(" ", "") + ) + train_bin_path = Path(output_dir) / (config_prefix + TRAIN_SUFFIX + BIN) + val_bin_path = Path(output_dir) / (config_prefix + VAL_SUFFIX + BIN) + test_bin_path = Path(output_dir) / (config_prefix + TEST_SUFFIX + BIN) + dataset_dtype = getattr(np, preproc_config.indexed_dataset_dtype) + train_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(train_bin_path), dtype=dataset_dtype) + val_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(val_bin_path), dtype=dataset_dtype) + test_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(test_bin_path), dtype=dataset_dtype) + + # Preprocess data and split results into train, validation, or test. + for sequence in self.preprocess_generator(preproc_config): + if sequence["split"] == "train": + train_builder.add_item(torch.Tensor(sequence["tokens"])) + elif sequence["split"] == "val": + val_builder.add_item(torch.Tensor(sequence["tokens"])) + elif sequence["split"] == "test": + test_builder.add_item(torch.Tensor(sequence["tokens"])) + train_builder.end_document() + val_builder.end_document() + test_builder.end_document() + + # Write preprocessed index sdata to disk. + IDX = ".idx" + train_idx_path = Path(output_dir) / (config_prefix + TRAIN_SUFFIX + IDX) + val_idx_path = Path(output_dir) / (config_prefix + VAL_SUFFIX + IDX) + test_idx_path = Path(output_dir) / (config_prefix + TEST_SUFFIX + IDX) + train_builder.finalize(idx_path=str(train_idx_path)) + val_builder.finalize(idx_path=str(val_idx_path)) + test_builder.finalize(idx_path=str(test_idx_path)) + + +def parse_args(): + """Parse arguments for Evo2 preprocessing.""" + parser = argparse.ArgumentParser(description="Preprocess datapaths for Evo2.") + parser.add_argument("-c", "--config", type=str, required=True, help="Path to Evo2 data preprocessing config JSON.") + return parser.parse_args() + + +if __name__ == "__main__": + # Parse arguments. + args = parse_args() + # Read config YAML. + with open(args.config, "r") as yaml_fs: + evo2_preproc_config_batch = yaml.safe_load(yaml_fs) + # Instantiate Evo2Preprocessor. + evo2_preprocessor = Evo2Preprocessor() + for config in evo2_preproc_config_batch: + # Convert into Evo2PreprocessingConfig. + evo2_preproc_config = Evo2PreprocessingConfig(**config) + # Preprocess data specified in config. + evo2_preprocessor.preprocess_offline(evo2_preproc_config) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py new file mode 100644 index 0000000000..3839a9c236 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py @@ -0,0 +1,71 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +PHYLA_TO_KINGDOM = { + "Acanthocephala": "animalia", + "Annelida": "animalia", + "Apicomplexa": "protista", + "Arthropoda": "animalia", + "Ascomycota": "fungi", + "Bacillariophyta": "chromista", + "Basidiomycota": "fungi", + "Blastocladiomycota": "fungi", + "Brachiopoda": "animalia", + "Bryozoa": "animalia", + "Cercozoa": "protista", + "Chlorophyta": "plantae", + "Chordata": "animalia", + "Chytridiomycota": "fungi", + "Ciliophora": "protista", + "Cnidaria": "animalia", + "Cryptomycota": "fungi", + "Ctenophora": "animalia", + "Dicyemida": "animalia", + "Discosea": "protista", + "Echinodermata": "animalia", + "Endomyxa": "protista", + "Euglenozoa": "protista", + "Evosea": "protista", + "Foraminifera": "protista", + "Fornicata": "protista", + "Haptophyta": "protista", + "Hemichordata": "animalia", + "Heterolobosea": "protista", + "Microsporidia": "fungi", + "Mollusca": "animalia", + "Mucoromycota": "fungi", + "Nematoda": "animalia", + "Nematomorpha": "animalia", + "Nemertea": "animalia", + "Onychophora": "animalia", + "Oomycota": "chromista", + "Orthonectida": "animalia", + "Parabasalia": "protista", + "Perkinsozoa": "protista", + "Phoronida": "animalia", + "Placozoa": "animalia", + "Platyhelminthes": "animalia", + "Porifera": "animalia", + "Preaxostyla": "protista", + "Priapulida": "animalia", + "Rhodophyta": "plantae", + "Rotifera": "animalia", + "Sanchytriomycota": "fungi", + "Streptophyta": "plantae", + "Tardigrada": "animalia", + "Xenacoelomorpha": "animalia", + "Zoopagomycota": "fungi", +} diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py new file mode 100644 index 0000000000..6c4e2afa47 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py @@ -0,0 +1,76 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import ftfy +from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec +from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer + +from bionemo.evo2.data.config import Evo2PreprocessingConfig + + +class Evo2Tokenizer: + """Tokenizer for Evo2.""" + + def __init__(self, params: Evo2PreprocessingConfig | None = None): + """Initialize the Evo2Tokenizer.""" + # Pass all NeMo2/Megatron-compliant parameters associated with config.Evo2PreprocessingConfig. + self.params: Evo2PreprocessingConfig = params if params is not None else Evo2PreprocessingConfig() + self.tokenizer: TokenizerSpec = get_nmt_tokenizer( + library=self.params.tokenizer_type.lower(), + vocab_file=str(self.params.vocab_file) if self.params.vocab_file is not None else None, + merges_file=str(self.params.merges_file) if self.params.merges_file is not None else None, + model_name=self.params.pretrained_tokenizer_model, + tokenizer_model=self.params.pretrained_tokenizer_model, + special_tokens=self.params.special_tokens, + use_fast=self.params.fast_hf_tokenizer, + ) + + def tokenize( + self, + text: str | list[str], + use_ftfy: bool = False, + enforce_sample_length: None | int = None, + append_eod: bool = False, + drop_empty_sequences: bool = False, + ): + """Tokenize the input text data for Evo2.""" + if isinstance(text, str): + text = [text] + # Tokenize a document or batch of strings. + doc_ids = [] + for l, t in enumerate(text): + if use_ftfy: + t = ftfy.fix_text(t) + # Tokenize the string. + text_ids: list = self.tokenizer.text_to_ids(t) + if drop_empty_sequences and len(text_ids) == 0: + continue + # Append EOD token if appropriate. + eod_length = int(append_eod and l == len(text) - 1) + token_length = len(text_ids) + eod_length + text_ids += [self.tokenizer.eod] * eod_length + if enforce_sample_length is not None: + # Pad shorter sequences and except excessive sequences. + if token_length > enforce_sample_length: + raise ValueError( + "Detected input text with a length greater than the maximum " + f"possible sample length of {enforce_sample_length}.)" + ) + else: + text_ids += [self.tokenizer.pad] * (enforce_sample_length - token_length) + # Append to document. + doc_ids.append(text_ids) + return doc_ids diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py new file mode 100644 index 0000000000..ce0d5d5d6c --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -0,0 +1,77 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import argparse + +from megatron.core.inference.common_inference_params import CommonInferenceParams +from nemo.collections.llm.inference import generate, setup_model_and_tokenizer + + +def parse_args(): + """Parse arguments for Evo2 inference.""" + ap = argparse.ArgumentParser() + + # generation args: + default_prompt = ( + "|d__Bacteria;" + + "p__Pseudomonadota;" + + "c__Gammaproteobacteria;" + + "o__Enterobacterales;" + + "f__Enterobacteriaceae;" + + "g__Escherichia;" + + "s__Escherichia|" + ) + ap.add_argument("--prompt", type=str, default=default_prompt, help="Prompt for generation") + ap.add_argument( + "--ckpt-dir", type=str, required=True, help="Path to checkpoint directory containing pre-trained Hyena model." + ) + ap.add_argument("--temperature", type=float, default=1.0, help="Temperature during sampling") + ap.add_argument("--top-k", type=int, default=4, help="Top K during sampling") + ap.add_argument("--top-p", type=float, default=1.0, help="Top P during sampling") + ap.add_argument("--cached-generation", type=bool, default=True, help="Use KV caching during generation") + ap.add_argument("--max-new-tokens", type=int, default=1024, help="Max new tokens during sampling") + ap.add_argument("--repetition-penalty", type=float, default=1.0, help="Repetition penalty during sampling") + ap.add_argument("--penalty-alpha", type=float, default=0.0, help="Penalty alpha during sampling") + # output args: + ap.add_argument("--sequence-fasta", type=str, default="sequence.fasta", help="Sequence fasta file") + ap.add_argument("--proteins-fasta", type=str, default="proteins.fasta", help="Proteins fasta file") + ap.add_argument("--structure-pdb", type=str, default="structure.pdb", help="Structure PDB file") + # misc args: + ap.add_argument("--devices", type=str, default="cuda:0", help="Device for generation") + ap.add_argument("--seed", type=int, default=12345, help="Random seed") + + return ap.parse_args() + + +def main(): + """Inference workflow for Evo2.""" + # Parse args. + args = parse_args() + + # Load and wrap model for inferencing. + model, tokenizer = setup_model_and_tokenizer(args.ckpt_dir) + + # Generate. + infer_params = CommonInferenceParams( + args.temperature, args.top_k, args.top_p, return_log_probs=False, num_tokens_to_generate=args.max_new_tokens + ) + # transformers generate method has more options than NeMo/Megatron. + results = generate(model, tokenizer, args.prompt, random_seed=args.seed, inference_params=infer_params) + print(results) + + +if __name__ == "__main__": + main() diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py new file mode 100644 index 0000000000..ccf23502f9 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -0,0 +1,187 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import argparse + +import torch +from megatron.core.optimizer import OptimizerConfig +from nemo import lightning as nl +from nemo.collections import llm +from nemo.collections.llm.gpt.data import PreTrainingDataModule +from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer +from nemo.lightning import NeMoLogger +from nemo.lightning.pytorch.callbacks import ModelCheckpoint +from nemo.lightning.pytorch.optim import CosineAnnealingScheduler +from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule +from pytorch_lightning.loggers import WandbLogger + + +def parse_args(): + """Parse arguments for Evo2 model training.""" + parser = argparse.ArgumentParser(description="Train a Hyena model using NeMo 2.0") + parser.add_argument("--num-nodes", type=int, default=1, help="Number of nodes to use for training, defaults to 1") + parser.add_argument("--devices", type=int, help="Number of devices to use for training") + parser.add_argument("--seq-length", type=int, default=8192, help="Training sequence length") + parser.add_argument("--data-path", type=str, help="Data path") + parser.add_argument("--tensor-parallel-size", type=int, default=1, help="Tensor Parallel Size") + parser.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Pipeline Parallel Size") + parser.add_argument("--context-parallel-size", type=int, default=1, help="Context Parallel Size") + parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallel") + parser.add_argument("--micro-batch-size", type=int, default=1, help="Pipeline Parallel Size") + parser.add_argument("--global-batch-size", type=int, default=8, help="Pipeline Parallel Size") + parser.add_argument("--max-steps", type=int, help="Number of steps to train for") + parser.add_argument("--val-check-interval", type=int, help="Number of steps between val check") + parser.add_argument( + "--model-size", + type=str, + default="7b", + help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b)", + ) + parser.add_argument("--experiment-dir", type=str, default=None, help="directory to write results to") + parser.add_argument("--ckpt-dir", type=str, default=None, help="directory to write checkpoints to") + parser.add_argument("--tokenizer-path", type=str, default=None, help="Path to tokenizer model") + + return parser.parse_args() + + +def main(): + """Main function to run Evo2 training.""" + args = parse_args() + + tokenizer = get_nmt_tokenizer( + "byte-level", + ) + + data = PreTrainingDataModule( + paths=args.data_path, + seq_length=args.seq_length, + micro_batch_size=args.micro_batch_size, + global_batch_size=args.global_batch_size, + seed=1234, + num_workers=2, + tokenizer=tokenizer, + ) + + if args.model_size == "7b": + hyena_config = llm.Hyena7bConfig() + elif args.model_size == "40b": + hyena_config = llm.Hyena40bConfig() + elif args.model_size == "test": + hyena_config = llm.HyenaTestConfig() + else: + raise ValueError(f"Invalid model size: {args.model_size}") + + hyena_config.seq_length = args.seq_length + model = llm.GPTModel(hyena_config, tokenizer=data.tokenizer) + + checkpoint_callback = ModelCheckpoint( + every_n_train_steps=args.val_check_interval, + dirpath=args.experiment_dir, + save_top_k=5, + save_optim_on_train_end=True, + ) + + loggers = [] + wandb_logger = WandbLogger( + name=( + f"hyena-size-{args.model_size}-TP{args.tensor_parallel_size}-" + f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" + f"-GBS{args.global_batch_size}-MBS{args.micro_batch_size}" + ), + project="hyena_ux_test", + save_dir=args.experiment_dir, + ) + # wandb_logger = TensorBoardLogger( + # save_dir='dummy', ## NOTE: this gets overwritten by default + # ) + loggers.append(wandb_logger) + + nemo_logger = NeMoLogger(log_dir=args.experiment_dir, wandb=wandb_logger) + + trainer = nl.Trainer( + devices=args.devices, + num_nodes=args.num_nodes, + max_steps=args.max_steps, + accelerator="gpu", + strategy=nl.MegatronStrategy( + tensor_model_parallel_size=args.tensor_parallel_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + context_parallel_size=args.context_parallel_size, + pipeline_dtype=torch.bfloat16, + sequence_parallel=args.sequence_parallel, + ckpt_load_optimizer=True, + ckpt_save_optimizer=True, + ckpt_async_save=False, + save_ckpt_format="zarr", + ), + logger=loggers, + callbacks=[checkpoint_callback], + log_every_n_steps=1, + limit_val_batches=10, + num_sanity_val_steps=0, + plugins=nl.MegatronMixedPrecision( + precision="bf16-mixed", + params_dtype=torch.bfloat16, + ), + val_check_interval=args.val_check_interval, + ) + + # Logger setup + nemo_logger.setup( + trainer, + resume_if_exists=True, + ) + + # Auto resume setup + + resume = nl.AutoResume( + resume_if_exists=True, + resume_ignore_no_checkpoint=True, + resume_past_end=True, + resume_from_directory=args.ckpt_dir, + # restore_config=( + # RestoreConfig( + # path=args.ckpt_dir, + # load_model_state = True, + # load_optim_state = True, + # ) if args.ckpt_dir else None + # ), + ) + resume.setup(trainer, model) + + # Optimizer and scheduler setup + opt_config = OptimizerConfig( + optimizer="adam", + lr=0.0003, + adam_beta1=0.9, + adam_beta2=0.95, + use_distributed_optimizer=True, + bf16=True, + ) + sched = CosineAnnealingScheduler( + max_steps=trainer.max_steps, + warmup_steps=2500, + min_lr=0.00003, + ) + + opt = MegatronOptimizerModule(opt_config, sched) + opt.connect(model) + + # Start training + trainer.fit(model, data) + + +if __name__ == "__main__": + main() diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py new file mode 100644 index 0000000000..2e573f66ee --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py @@ -0,0 +1,289 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import argparse +from dataclasses import dataclass + +import torch +from nemo.collections.llm.gpt.model.hyena import HyenaConfig, PyTorchHyenaImporter + + +""" +python torch2nemo.py --model-ckpt pretrained_model/global_step199400 --output-nemo-ckpt nemo_pretrained_model/evo2_nemo_pretrained.nemo +""" + + +@dataclass +class Hyena40bPretrainedConfig(HyenaConfig): + """Fixes SDHSDH instead of SHDSDH in the original 40b, probably a typo there?""" + + hybrid_override_pattern: str = "SDH*SDHSDH*SDHSDH*SDHSDH*SDHSDH*SDH*SDHSDH*SDHSDH*" + num_layers: int = 50 + seq_length: int = 8192 + hidden_size: int = 8192 + num_groups_hyena: int = 8192 + num_groups_hyena_medium: int = 512 + num_groups_hyena_short: int = 512 + make_vocab_size_divisible_by: int = 8 + tokenizer_library: str = "byte-level" + mapping_type: str = "base" + ffn_hidden_size: int = 21888 + gated_linear_unit: bool = True + num_attention_heads: int = 64 + use_cpu_initialization: bool = False + hidden_dropout: float = 0.0 + attention_dropout: float = 0.0 + params_dtype: torch.dtype = torch.bfloat16 + normalization: str = "RMSNorm" + add_qkv_bias: bool = False + add_bias_linear: bool = False + layernorm_epsilon: float = 1e-6 + # fp8: str = 'hybrid' + # fp8_amax_history_len: int = 16 + # fp8_amax_compute_algo: str = "max" + recompute_granularity: str = "full" + recompute_method: str = "uniform" + recompute_num_layers: int = 2 + hyena_init_method: str = "small_init" + hyena_output_layer_init_method: str = "wang_init" + hyena_filter_no_wd: bool = True + + +def parse_args(): + """Parse args.""" + parser = argparse.ArgumentParser(description="PyTorch to NeMo converter") + parser.add_argument("--model-ckpt", type=str, required=True, help="Path to the PyTorch model checkpoint.") + parser.add_argument("--output-nemo-ckpt", type=str, required=True, help="Path to the NeMo model checkpoint.") + return parser.parse_args() + + +if __name__ == "__main__": + # print(torch.load("pretrained_model/global_step199400/mp_rank_00_model_states.pt").keys()) + args = parse_args() + pretrained_config: HyenaConfig = Hyena40bPretrainedConfig() + importer = PyTorchHyenaImporter(args.model_ckpt, model_config=pretrained_config) + importer.apply(args.output_nemo_ckpt) + + +""" +{ + # Logging + 'use_wandb': true, + "print_mem_alloc_stats": false, + "log_memory_stats": true, + "log_memory_alloc_counts": false, + # MP / PP config + 'pipe_parallel_size': 0, + 'model_parallel_size': 2, + 'sequence_parallel': true, + + # Zero config + # Leaf Modules + # Modules to mark as leaf modules, only for Zero-stage 3 + # Must be list of strings that can be be used as such getattr(module, leaf_module) + # where module is one of savanna.model.block or savanna.model.operators.hyena.hyena. + + # This controls the granularity of zero-3 parameter partitioning. I.e., if ParallelSequenceMixer is + # set as a leaf module, then the entire ParallelSequenceMixer will be gathered / partitioned as a single unit. + # ParallelSequenceMixer is the equivalent of an AttentionBlock: input projections, self attention, and output projections. + # ParallelBlockPipe is the equivalent of a TransformerBlock: AttentionBlock + FFN + # backbone modules: ParallelBlockPipe + # block modules: 'ParallelSequenceMixer', 'ParallelGLU', 'ParallelLinear', 'FlexLinear', 'ParallelMLP', + # hyena_modules: 'ParallelCausalDepthwiseConv1d', 'ParallelComplexModalFilter', 'ParallelHyenaOperator', 'ParallelImplicitFreeformFilter', 'ParallelShortHyenaOperator', + #NOTE: If a module is specified as a leaf module, all its nested modules will be + 'zero_use_leaf_modules': false, + 'zero_leaf_modules': ["ParallelSequenceMixer", "ParallelGLU"], + + 'zero_use_mics': false, + 'zero_optimization': + { + 'stage': 3, + 'prefetch_bucket_size': 500000000, + 'max_live_parameters': 1000000000, + 'allgather_partitions': True, + 'allgather_bucket_size': 500000000, + 'overlap_comm': True, + 'reduce_scatter': True, + 'reduce_bucket_size': 500000000, + 'contiguous_gradients': True, + 'cpu_offload': false, + 'param_persistence_threshold': 0, + # "mics_shard_size": 8, + # "mics_hierarchical_params_gather": false, + }, + + # Batch sizing + 'train_micro_batch_size_per_gpu': 8, + 'gradient_accumulation_steps': 1, + + # Activation checkpointing + 'checkpoint-activations': true, + 'checkpoint-num-layers': 1, + + # Training + 'train-iters': 40, + 'lr-decay-iters': 40, + + 'make_vocab_size_divisible_by': 8, + 'num_layers': 50, + 'hidden_size': 8192, + 'num_attention_heads': 64, + 'num_groups_hyena': 8192, + 'num_groups_hyena_medium': 512, + 'num_groups_hyena_short': 512, + 'num_groups_hyena_mlp': 512, + 'operator-config': + [ + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['hyena_short_conv'], 1], + [['hyena_medium_conv'], 1], + [['hyena'], 1], + [['flash_v2'], 1], + ], + + # These kernels will be also autotuned and activated + 'use_cgcg': false, + 'use_cgcg_short': false, + 'use_cgcg_mlp': false, + + # Tune to target sequence length e.g., 8192 + 'seq_length': 8192, + 'max_position_embeddings': 8192, + + 'hyena_medium_conv_len': 128, # default is null + 'log_attn_norms': false, + 'pos_emb': 'rotary', + 'rotary_emb_base': 1000000, + 'rotary_pct': 1, + 'prenorm': true, + 'postnorm': false, + 'pre_mlp_norm': true, + 'outer_mlp_norm': false, + 'no_weight_tying': false, + 'gpt_j_residual': false, + 'normalize_hyena_filters': false, + 'short-conv-L': 3, + 'hyena_filter_fast_decay': 0.3, + 'hyena_filter_slow_decay': 1.2, + 'hyena_filter_w': 14, + 'hyena_filter_cls': 'implicit_modal', + 'hyena_medium_filter_cls': 'explicit_single_decay', + 'explicit_filter_decay_preset': 'weak', + 'hyena_filter_order': 16, + 'hyena_filter_wd': 0., + 'use_fast_heads': false, + 'use_slow_heads': false, + 'use-hyena-filter': true, + 'output_layer_parallelism': 'column', + 'bias_dropout_fusion': false, + 'norm': 'rmsnorm', + 'rms_norm_epsilon': 1.0e-6, + 'identity_mlp': false, + 'activation': 'gelu', + 'mlp_type': 'llama', + 'scaled-upper-triang-masked-softmax-fusion': true, + 'bias-gelu-fusion': false, + 'init_method': 'small_init', + 'output_layer_init_method': 'wang_init', + 'optimizer': + { + 'type': 'Adam', + 'params': { 'lr': 0.0003, 'betas': [0.9, 0.95], 'eps': 1.0e-8 }, + }, + 'min_lr': 0.00003, + + 'data-impl': 'mmap', + + 'partition-activations': false, + 'synchronize-each-layer': false, + 'gradient_clipping': 1.0, + 'weight-decay': 0.1, + 'hidden-dropout': 0.0, + 'attention-dropout': 0.0, + 'precision': 'bfloat16', + 'bf16': { 'enabled': true }, + 'distributed-backend': 'nccl', + 'lr-decay-style': 'cosine', + 'warmup': 0.005, + 'checkpoint-factor': 2500, + 'extra_save_iters': [100], + 'eval-interval': 200, + 'eval-iters': 20, + 'log-interval': 5, + 'steps_per_print': 5, + 'keep-last-n-checkpoints': 100, + 'wall_clock_breakdown': false, + + 'tokenizer_type': CharLevelTokenizer, + 'use_fp8_input_projections': true, + 'use_fp8_output_projections': true, + 'use_fp8_mlp_projections': true, + 'use_fp8_norm': true, + 'checkpoint_strict_load': false, + 'make_gated_mlp_multiple_of': 128, + 'materialize_attn_mask': false, # default false, to save memory + 'fast_conv_proj': true, + 'hyena_short_conv_len': 7, + 'to_upper': "normalized_weighted", + 'mask_loss_control_tags': true, + 'lowercase_loss_reweighting': 0.1, +} +""" diff --git a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml new file mode 100644 index 0000000000..2e9768b116 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml @@ -0,0 +1,38 @@ +- datapaths: ["/workspace/bionemo2/sub-packages/bionemo-evo2/tests/data/mmseqs_results_rep_seq.fasta"] + output_dir: "/workspace/bionemo2/sub-packages/bionemo-evo2/tests/data" + output_prefix: promoters_ab_test + # Datasplit + train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training + valid_split: 0.0 + test_split: 0.0 + # Evo Taxonomy + taxonomy_path: null + # Raw Preprocessing Transforms + gzip_data: false + embed_reverse_complement: true + random_reverse_complement: false + subsequence_length: null + include_sequence_id: false + transcribe: "back_transcribe" + force_uppercase: true + # Tokenizer + tokenizer_type: "Byte-Level" + vocab_file: null + vocab_size: null + merges_file: null + # Either a named pretrained tokenizer model, or a path to a SentencePiece tokenizer. + pretrained_tokenizer_model: null + special_tokens: null + fast_hf_tokenizer: true + append_eod: true + enforce_sample_length: null + ftfy: false + indexed_dataset_dtype: "uint8" + # Compute + workers: 1 + preproc_concurrency: 10000 + # Filters + drop_empty_sequences: true + nnn_filter: true + # RNG + seed: 42 From a142109f036298891979d57d2c9740feb3af161b Mon Sep 17 00:00:00 2001 From: John St John Date: Wed, 4 Dec 2024 10:21:47 -0800 Subject: [PATCH 003/140] Add manual data test for evo2 --- sub-packages/bionemo-evo2/README.md | 2 +- sub-packages/bionemo-evo2/pyproject.toml | 2 +- .../bionemo-evo2/src/bionemo/evo2/README.md | 2 +- .../src/bionemo/evo2/data/README.md | 101 ++++++++++++++++++ sub-packages/bionemo-evo2/tests/README.md | 2 +- 5 files changed, 105 insertions(+), 4 deletions(-) create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index f032c8c889..39916f40d4 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -1 +1 @@ -Library containing data preprocessing, training, and inference tooling for Evo2. \ No newline at end of file +Library containing data preprocessing, training, and inference tooling for Evo2. diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index bb8270e32b..7e64db3596 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -32,4 +32,4 @@ exclude = ["test*."] version = { file = "VERSION" } [tool.uv] -cache-keys = [{ git = true }] \ No newline at end of file +cache-keys = [{ git = true }] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md index 81b4e9b765..982a6ec28d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md @@ -1 +1 @@ -Source code for BioNeMo Evo2. \ No newline at end of file +Source code for BioNeMo Evo2. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md new file mode 100644 index 0000000000..0a64e3596a --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md @@ -0,0 +1,101 @@ +# Data package +## Preprocess +### Equivalence with arc implementation +To test equivalence with the reference implementation we first downloaded processed megatrion IndexedDataset +files from Arc institute for their promotors dataset: + +```bash +$ mkdir tmp_goldstandard +$ cd tmp_goldstandard +$ scp login-eos:/lustre/fsw/healthcareeng_bionemo/arc_evo2/data/promoters/pretraining_data_promoters/data_promoters_*_text_CharLevelTokenizer_document.* ./ +``` + +```bash +$ ls -lah +-rwxr-xr-x 1 bionemo bionemo 1.2M Dec 4 00:56 data_promoters_test_text_CharLevelTokenizer_document.bin +-rwxr-xr-x 1 bionemo bionemo 20K Dec 4 00:56 data_promoters_test_text_CharLevelTokenizer_document.idx +-rwxr-xr-x 1 bionemo bionemo 392M Dec 4 00:56 data_promoters_train_text_CharLevelTokenizer_document.bin +-rwxr-xr-x 1 bionemo bionemo 6.6M Dec 4 00:56 data_promoters_train_text_CharLevelTokenizer_document.idx +-rwxr-xr-x 1 bionemo bionemo 1.2M Dec 4 00:56 data_promoters_valid_text_CharLevelTokenizer_document.bin +-rwxr-xr-x 1 bionemo bionemo 20K Dec 4 00:56 data_promoters_valid_text_CharLevelTokenizer_document.idx +``` + +Next we acquired the `fasta` file that was used to generate this and placed it into the tests/data folder of this sub-package. + +```yaml +- datapaths: ["sub-packages/bionemo-evo2/tests/data/mmseqs_results_rep_seq.fasta"] + output_dir: "sub-packages/bionemo-evo2/tests/data" + output_prefix: promoters_ab_test + # Datasplit + train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training, will verify this manually + valid_split: 0.0 + test_split: 0.0 + # Evo Taxonomy + taxonomy_path: null + # Raw Preprocessing Transforms + gzip_data: false + embed_reverse_complement: true + random_reverse_complement: false + subsequence_length: null + include_sequence_id: false + transcribe: "back_transcribe" + force_uppercase: true + # Tokenizer + tokenizer_type: "Byte-Level" + # None of the following tokenization params matters for this byte-level dataset for META/optimal Evo2 specifically. + vocab_file: null + vocab_size: null + merges_file: null + pretrained_tokenizer_model: null + special_tokens: null + fast_hf_tokenizer: true + append_eod: true # except this, this matters + enforce_sample_length: null + indexed_dataset_dtype: "uint8" + ftfy: false + # Compute + workers: 1 + preproc_concurrency: 10000 + # Filters + drop_empty_sequences: true + nnn_filter: true + # RNG + seed: 42 +``` + +Finally we generated our own bin/idx file for in this case everything going into the training set. +```bash +$ python sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py -c sub-packages/bionemo-evo2/tests/config/mmseqs_promotors_config.yaml +``` + +Next to check equivalence, we were not attempting to replicate the exact ordering of the datset, we just wanted to verify +that we get the same elements out of our processed dataset as the original. + +```python +>>> from megatron.core.datasets.indexed_dataset import IndexedDataset +>>> ds_train_ref = IndexedDataset("./data_promoters_train_text_CharLevelTokenizer_document") +>>> ds_val_ref = IndexedDataset("./data_promoters_valid_text_CharLevelTokenizer_document") +>>> ds_test_ref = IndexedDataset("./data_promoters_test_text_CharLevelTokenizer_document") +>>> ds_train_ours = IndexedDataset("../sub-packages/bionemo-evo2/tests/data/promoters_ab_test_byte-level_train") +>>> len(ds_train_ours) == len(ds_train_ref) + len(ds_test_ref) + len(ds_val_ref) +True +>>> # Example of what one of these set elements looks like, it's just a string representation of the token list for an +>>> # element of the training dataset. We can then compare all of these to make sure that the two datasets have the +>>> # same set of samples. +>>> ','.join([str(t) for t in ds_train_ref[0]]) +'67,84,71,71,65,71,67,67,84,71,65,67,67,65,84,65,65,71,84,65,71,84,71,71,67,84,65,84,65,65,67,71,65,71,71,65,65,71,65,65,71,65,84,71,65,65,71,65,71,65,84,84,65,71,65,71,65,65,65,65,84,71,65,65,84,71,84,84,67,84,84,71,65,65,71,84,65,71,67,67,65,84,84,71,84,84,71,84,65,71,84,84,71,84,84,71,84,71,84,71,84,71,84,65,84,71,84,84,71,65,71,65,84,71,84,84,84,84,71,71,71,71,84,84,84,71,84,84,65,84,65,84,65,71,65,71,65,71,65,71,65,84,71,84,65,71,84,84,84,71,71,84,71,65,65,71,65,71,84,65,71,71,65,84,84,67,84,67,84,84,65,67,84,65,71,84,71,84,71,65,65,71,65,84,84,65,84,84,65,67,84,65,71,71,84,65,65,67,84,65,65,65,84,71,65,71,65,84,84,67,84,65,84,67,65,65,67,84,65,65,71,84,67,65,84,84,65,71,65,71,65,84,84,71,71,65,65,65,84,71,84,84,84,67,84,84,84,84,65,71,71,84,84,84,65,65,84,65,65,65,71,84,84,84,71,84,84,84,71,65,65,84,84,71,65,71,65,65,65,71,65,71,65,71,65,71,71,65,71,65,71,65,67,65,84,84,71,67,84,84,84,71,65,65,71,71,71,65,71,65,71,84,84,84,71,71,71,84,71,71,71,84,71,65,71,71,65,84,84,71,65,65,65,65,84,71,65,65,65,65,65,84,71,65,65,67,84,71,65,65,65,65,65,71,71,84,71,84,84,65,84,65,71,84,71,65,67,67,84,71,84,67,65,65,65,65,65,65,71,67,84,71,84,71,65,65,71,65,65,71,84,71,84,84,65,84,67,67,65,65,71,65,65,65,84,65,84,71,71,65,84,84,71,67,84,65,65,84,67,65,84,65,67,84,65,67,84,71,84,84,67,65,84,84,65,84,71,65,84,84,84,84,65,84,71,84,71,84,67,65,84,71,84,71,84,71,84,71,67,67,84,65,84,67,65,84,67,65,84,84,67,67,84,84,65,84,65,84,84,84,84,65,71,84,84,71,71,67,65,65,65,65,65,65,65,65,65,65,65,71,65,67,84,84,71,71,65,65,71,84,65,84,84,71,65,65,65,65,67,67,65,65,65,84,67,84,71,65,84,67,84,67,65,65,67,67,84,65,71,65,67,65,65,71,84,67,71,65,84,84,65,65,65,71,67,84,65,65,65,67,67,71,65,65,65,65,67,67,71,65,65,84,67,67,67,71,65,67,67,71,71,84,84,65,65,84,84,71,65,65,65,65,67,67,71,65,84,67,67,65,0' +>>> # Create a set of all of these elements: +>>> all_ref_data = {','.join([str(t) for t in rec]) for ds in [ds_train_ref, ds_val_ref, ds_test_ref] for rec in ds} +>>> # Verify that there is no redundancy so we can do set equality safely +>>> len(all_ref_data) == len(ds_train_ours) +True +>>> len(all_ref_data) +343504 +>>> all_our_data = {','.join([str(t) for t in rec]) for ds in [ds_train_ours] for rec in ds} +>>> len(all_our_data) +343504 +>>> # Verify set equality to show that we have processed an identical dataset +>>> # (ignoring shuffling order and train/test/val splits) +>>> all_our_data == all_ref_data +True +``` diff --git a/sub-packages/bionemo-evo2/tests/README.md b/sub-packages/bionemo-evo2/tests/README.md index 5be056289a..f3e523b303 100644 --- a/sub-packages/bionemo-evo2/tests/README.md +++ b/sub-packages/bionemo-evo2/tests/README.md @@ -1 +1 @@ -Tests for BioNeMo Evo2. \ No newline at end of file +Tests for BioNeMo Evo2. From 0ad0bee3a2b160e95db2d8c91a8ba8f381ad11c4 Mon Sep 17 00:00:00 2001 From: John St John Date: Thu, 5 Dec 2024 14:24:26 -0800 Subject: [PATCH 004/140] Change remotes for submodules for now --- .gitmodules | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 0b6458ab20..d8596d8af4 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,6 @@ [submodule "3rdparty/Megatron-LM"] path = 3rdparty/Megatron-LM - url = https://github.com/NVIDIA/Megatron-LM.git + url = ssh://git@gitlab-master.nvidia.com:12051/ataghibakhsh/megatron-lm.git [submodule "3rdparty/NeMo"] path = 3rdparty/NeMo - url = https://github.com/NVIDIA/NeMo.git + url = ssh://git@gitlab-master.nvidia.com:12051/ataghibakhsh/nemo-savanna.git From 82c832f7d7cd24eb26c55d5a0563ad2220329a46 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Thu, 5 Dec 2024 14:27:42 -0800 Subject: [PATCH 005/140] Cye/nemo2 fixes --- 3rdparty/NeMo | 2 +- .../src/bionemo/evo2/run/infer.py | 51 ++++++++++++++++--- .../src/bionemo/evo2/run/train.py | 21 ++++---- 3 files changed, 56 insertions(+), 18 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 093578467e..08089dc616 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 093578467e3cee73e7e27edb2d926940515cb78d +Subproject commit 08089dc616f73fc24cdca5eeebf5ef7cd0564f19 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index ce0d5d5d6c..2a5e2d0696 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -16,8 +16,10 @@ import argparse +import nemo.lightning as nl +import torch from megatron.core.inference.common_inference_params import CommonInferenceParams -from nemo.collections.llm.inference import generate, setup_model_and_tokenizer +from nemo.collections.llm import generate def parse_args(): @@ -45,6 +47,11 @@ def parse_args(): ap.add_argument("--max-new-tokens", type=int, default=1024, help="Max new tokens during sampling") ap.add_argument("--repetition-penalty", type=float, default=1.0, help="Repetition penalty during sampling") ap.add_argument("--penalty-alpha", type=float, default=0.0, help="Penalty alpha during sampling") + # compute args: + ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Tensor Parallel Size") + ap.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Pipeline Parallel Size") + ap.add_argument("--context-parallel-size", type=int, default=1, help="Context Parallel Size") + ap.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallel") # output args: ap.add_argument("--sequence-fasta", type=str, default="sequence.fasta", help="Sequence fasta file") ap.add_argument("--proteins-fasta", type=str, default="proteins.fasta", help="Proteins fasta file") @@ -61,15 +68,43 @@ def main(): # Parse args. args = parse_args() - # Load and wrap model for inferencing. - model, tokenizer = setup_model_and_tokenizer(args.ckpt_dir) - - # Generate. - infer_params = CommonInferenceParams( - args.temperature, args.top_k, args.top_p, return_log_probs=False, num_tokens_to_generate=args.max_new_tokens + # Create PTL trainer. + trainer = nl.Trainer( + accelerator="gpu", + strategy=nl.MegatronStrategy( + tensor_model_parallel_size=args.tensor_parallel_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + context_parallel_size=args.context_parallel_size, + pipeline_dtype=torch.bfloat16, + sequence_parallel=args.sequence_parallel, + ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. + ckpt_save_optimizer=False, + ckpt_async_save=False, + save_ckpt_format="zarr", + ), + log_every_n_steps=1, + limit_val_batches=10, + num_sanity_val_steps=0, + plugins=nl.MegatronMixedPrecision( + precision="bf16-mixed", + params_dtype=torch.bfloat16, + ), ) + # transformers generate method has more options than NeMo/Megatron. - results = generate(model, tokenizer, args.prompt, random_seed=args.seed, inference_params=infer_params) + results = generate( + path=args.ckpt_dir, + prompts=[args.prompt], + trainer=trainer, + inference_params=CommonInferenceParams( + args.temperature, + args.top_k, + args.top_p, + return_log_probs=False, + num_tokens_to_generate=args.max_new_tokens, + ), + text_only=True, + ) print(results) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index ccf23502f9..c6238523cd 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -121,8 +121,8 @@ def main(): context_parallel_size=args.context_parallel_size, pipeline_dtype=torch.bfloat16, sequence_parallel=args.sequence_parallel, - ckpt_load_optimizer=True, - ckpt_save_optimizer=True, + ckpt_load_optimizer=False, # Checkpoint model state only. + ckpt_save_optimizer=False, ckpt_async_save=False, save_ckpt_format="zarr", ), @@ -145,19 +145,22 @@ def main(): ) # Auto resume setup + from nemo.lightning.pytorch.strategies.utils import RestoreConfig resume = nl.AutoResume( resume_if_exists=True, resume_ignore_no_checkpoint=True, resume_past_end=True, resume_from_directory=args.ckpt_dir, - # restore_config=( - # RestoreConfig( - # path=args.ckpt_dir, - # load_model_state = True, - # load_optim_state = True, - # ) if args.ckpt_dir else None - # ), + restore_config=( + RestoreConfig( + path=args.ckpt_dir, + load_model_state=True, + load_optim_state=False, # Load model checkpoint, no optimizer state. + ) + if args.ckpt_dir + else None + ), ) resume.setup(trainer, model) From 945506f2a22d43d5b53a2b05d62d64aeb85ac4a5 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Tue, 10 Dec 2024 08:41:09 -0800 Subject: [PATCH 006/140] Write model checkpoint context and set Evo2Dataset in the pre-training. --- .../src/bionemo/evo2/run/train.py | 49 +++++++++++++------ 1 file changed, 33 insertions(+), 16 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index c6238523cd..94a8d42016 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -20,6 +20,7 @@ from nemo import lightning as nl from nemo.collections import llm from nemo.collections.llm.gpt.data import PreTrainingDataModule +from nemo.collections.nlp.data.language_modeling.megatron import Evo2Dataset from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger from nemo.lightning.pytorch.callbacks import ModelCheckpoint @@ -30,28 +31,41 @@ def parse_args(): """Parse arguments for Evo2 model training.""" - parser = argparse.ArgumentParser(description="Train a Hyena model using NeMo 2.0") - parser.add_argument("--num-nodes", type=int, default=1, help="Number of nodes to use for training, defaults to 1") - parser.add_argument("--devices", type=int, help="Number of devices to use for training") + parser = argparse.ArgumentParser(description="Train a Hyena model using NeMo 2.0.") + parser.add_argument("--num-nodes", type=int, default=1, help="Number of nodes to use for training, defaults to 1.") + parser.add_argument("--devices", type=int, default=1, help="Number of devices to use for training, defaults to 1.") parser.add_argument("--seq-length", type=int, default=8192, help="Training sequence length") - parser.add_argument("--data-path", type=str, help="Data path") - parser.add_argument("--tensor-parallel-size", type=int, default=1, help="Tensor Parallel Size") - parser.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Pipeline Parallel Size") - parser.add_argument("--context-parallel-size", type=int, default=1, help="Context Parallel Size") - parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallel") - parser.add_argument("--micro-batch-size", type=int, default=1, help="Pipeline Parallel Size") - parser.add_argument("--global-batch-size", type=int, default=8, help="Pipeline Parallel Size") - parser.add_argument("--max-steps", type=int, help="Number of steps to train for") - parser.add_argument("--val-check-interval", type=int, help="Number of steps between val check") + parser.add_argument("--data-path", type=str, nargs="+", default=[], help="Paths to data directories for training.") + parser.add_argument( + "--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1." + ) + parser.add_argument( + "--pipeline-model-parallel-size", type=int, default=1, help="Order of pipeline parallelism. Defaults to 1." + ) + parser.add_argument( + "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." + ) + parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallelism.") + parser.add_argument("--micro-batch-size", type=int, default=1, help="Micro-batch size for data-parallel training.") + parser.add_argument("--global-batch-size", type=int, default=8, help="Global batch size for training.") + parser.add_argument("--max-steps", type=int, help="Number of training optimizer update steps.") + parser.add_argument( + "--val-check-interval", type=int, help="Number of steps between validation measurements and model checkpoints." + ) parser.add_argument( "--model-size", type=str, + choices=["7b", "40b", "test"], default="7b", - help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b)", + help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b).", + ) + parser.add_argument( + "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." + ) + parser.add_argument("--ckpt-dir", type=str, default=None, help="Directory to read checkpoints from.") + parser.add_argument( + "--tokenizer-path", type=str, default=None, help="Path to tokenizer model if relevant to tokenizer." ) - parser.add_argument("--experiment-dir", type=str, default=None, help="directory to write results to") - parser.add_argument("--ckpt-dir", type=str, default=None, help="directory to write checkpoints to") - parser.add_argument("--tokenizer-path", type=str, default=None, help="Path to tokenizer model") return parser.parse_args() @@ -66,6 +80,7 @@ def main(): data = PreTrainingDataModule( paths=args.data_path, + dataset_cls=Evo2Dataset, seq_length=args.seq_length, micro_batch_size=args.micro_batch_size, global_batch_size=args.global_batch_size, @@ -90,7 +105,9 @@ def main(): every_n_train_steps=args.val_check_interval, dirpath=args.experiment_dir, save_top_k=5, + always_save_context=True, save_optim_on_train_end=True, + save_context_on_train_end=True, ) loggers = [] From 4fc1d84fbf4b8a33c207423b60187c60fab94327 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Wed, 11 Dec 2024 14:27:48 -0800 Subject: [PATCH 007/140] Fix inference script to make sense, i.e. no seq parallelism for decoding, default 0 for topk/topp. --- .../bionemo-evo2/src/bionemo/evo2/run/infer.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 2a5e2d0696..3e7ac10d06 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -41,8 +41,8 @@ def parse_args(): "--ckpt-dir", type=str, required=True, help="Path to checkpoint directory containing pre-trained Hyena model." ) ap.add_argument("--temperature", type=float, default=1.0, help="Temperature during sampling") - ap.add_argument("--top-k", type=int, default=4, help="Top K during sampling") - ap.add_argument("--top-p", type=float, default=1.0, help="Top P during sampling") + ap.add_argument("--top-k", type=int, default=0, help="Top K during sampling") + ap.add_argument("--top-p", type=float, default=0.0, help="Top P during sampling") ap.add_argument("--cached-generation", type=bool, default=True, help="Use KV caching during generation") ap.add_argument("--max-new-tokens", type=int, default=1024, help="Max new tokens during sampling") ap.add_argument("--repetition-penalty", type=float, default=1.0, help="Repetition penalty during sampling") @@ -51,7 +51,6 @@ def parse_args(): ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Tensor Parallel Size") ap.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Pipeline Parallel Size") ap.add_argument("--context-parallel-size", type=int, default=1, help="Context Parallel Size") - ap.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallel") # output args: ap.add_argument("--sequence-fasta", type=str, default="sequence.fasta", help="Sequence fasta file") ap.add_argument("--proteins-fasta", type=str, default="proteins.fasta", help="Proteins fasta file") @@ -76,7 +75,6 @@ def main(): pipeline_model_parallel_size=args.pipeline_model_parallel_size, context_parallel_size=args.context_parallel_size, pipeline_dtype=torch.bfloat16, - sequence_parallel=args.sequence_parallel, ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. ckpt_save_optimizer=False, ckpt_async_save=False, @@ -105,7 +103,9 @@ def main(): ), text_only=True, ) - print(results) + + if torch.distributed.get_rank() == 0: + print(results) if __name__ == "__main__": From f5adde5813b869fbc225a1dd13ad79eda99bf869 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Mon, 16 Dec 2024 14:15:46 -0800 Subject: [PATCH 008/140] Cye/fix Hyena species biases --- .gitmodules | 2 +- .secrets-nb.baseline | 4 +- 3rdparty/Megatron-LM | 2 +- 3rdparty/NeMo | 2 +- CODEOWNERS | 2 + Dockerfile | 48 +- Dockerfile.arm | 321 +++++ README.md | 69 +- VERSION | 2 +- ci/scripts/build_docker_image.sh | 7 +- ci/scripts/run_pytest.sh | 16 +- .../user-guide/appendix/releasenotes-fw.md | 45 + .../examples/bionemo-esm2/finetune.md | 84 +- .../examples/bionemo-esm2/inference.ipynb | 504 +++++++ .../examples/bionemo-esm2/mutant-design.ipynb | 1154 +++++++++++++++++ .../examples/bionemo-esm2/pretrain.md | 8 +- .../geneformer-celltype-classification.ipynb | 313 ++--- .../getting-started/access-startup.md | 6 +- .../getting-started/initialization-guide.md | 6 +- internal/scripts/build_dev_image.sh | 1 + pyproject.toml | 2 + requirements-cve.txt | 3 + requirements-dev.txt | 3 +- requirements-test.txt | 2 + scripts/gpt-pretrain.py | 10 +- .../src/bionemo/core/data/load.py | 5 +- .../src/bionemo/core/data/resources/esm2.yaml | 8 + .../tests/bionemo/core/data/test_load.py | 13 +- .../core/data/test_load_notebook.ipynb | 34 +- .../src/bionemo/esm2/data/datamodule.py | 41 +- .../bionemo/esm2/model/finetune/datamodule.py | 32 +- .../src/bionemo/esm2/model/finetune/infer.py | 101 -- .../src/bionemo/esm2/model/finetune/train.py | 46 +- .../src/bionemo/esm2/model/model.py | 4 + .../src/bionemo/esm2/run/config_models.py | 24 +- .../bionemo-esm2/src/bionemo/esm2/run/main.py | 39 +- .../src/bionemo/esm2/run/recipes.py | 100 +- .../src/bionemo/esm2/scripts/infer_esm2.py | 10 + .../src/bionemo/esm2/scripts/train_esm2.py | 26 +- .../bionemo/esm2/data/test_datamodule.py | 29 - .../esm2/model/finetune/test_finetune.py | 1 + .../tests/bionemo/esm2/model/test_model.py | 1 + .../bionemo/esm2/model/test_stop_and_go.py | 82 +- .../bionemo/esm2/scripts/test_infer_esm2.py | 14 +- .../esm2/scripts/test_pydantic_train.py | 6 +- .../bionemo/esm2/scripts/test_train_esm2.py | 23 +- .../src/bionemo/evo2/data/dataset.py | 93 -- .../src/bionemo/evo2/run/train.py | 31 +- sub-packages/bionemo-example_model/README.md | 8 +- .../lightning/lightning_basic.py | 2 +- .../training_scripts/finetune_mnist.py | 2 +- .../training_scripts/pretrain_mnist.py | 2 +- .../lightning/test_lightning_basic.py | 2 +- sub-packages/bionemo-fw/pyproject.toml | 1 + .../geneformer/data/singlecell/datamodule.py | 55 +- .../bionemo/geneformer/run/config_models.py | 11 + .../src/bionemo/geneformer/run/main.py | 41 +- .../src/bionemo/geneformer/run/recipes.py | 61 +- .../geneformer/scripts/train_geneformer.py | 30 +- .../geneformer/scripts/test_pydantic_train.py | 18 +- .../scripts/test_train_geneformer.py | 23 +- .../tests/bionemo/geneformer/test_model.py | 2 +- .../bionemo/geneformer/test_stop_and_go.py | 2 +- sub-packages/bionemo-geometric/pyproject.toml | 4 + .../src/bionemo/geometric/atom_featurizers.py | 510 ++++++++ .../src/bionemo/geometric/base_featurizer.py | 139 ++ .../src/bionemo/geometric/bond_featurizers.py | 52 + .../geometric/data/electronic_data.csv | 119 ++ .../bionemo/geometric/molecule_featurizers.py | 51 + .../geometric/test_atom_featurizers.py | 396 ++++++ .../geometric/test_bond_featurizers.py | 62 + .../geometric/test_molecule_featurizers.py | 483 +++++++ .../src/bionemo/llm/data/collate.py | 2 +- .../src/bionemo/llm/data/datamodule.py | 2 +- .../bionemo-llm/src/bionemo/llm/lightning.py | 2 +- .../bionemo/llm/model/biobert/lightning.py | 2 +- .../src/bionemo/llm/model/biobert/model.py | 11 + .../llm/model/biobert/testing_utils.py | 2 +- .../src/bionemo/llm/run/config_models.py | 43 +- .../bionemo-llm/src/bionemo/llm/train.py | 6 +- .../src/bionemo/llm/utils/datamodule_utils.py | 2 +- .../src/bionemo/llm/utils/logger_utils.py | 2 +- .../tests/bionemo/llm/data/test_collate.py | 8 +- .../bionemo/llm/utils/test_logger_utils.py | 125 +- sub-packages/bionemo-noodles/.gitignore | 1 + sub-packages/bionemo-noodles/Cargo.lock | 434 +++++++ sub-packages/bionemo-noodles/Cargo.toml | 18 + sub-packages/bionemo-noodles/LICENSE | 1 + sub-packages/bionemo-noodles/README.md | 11 + sub-packages/bionemo-noodles/VERSION | 1 + sub-packages/bionemo-noodles/pyproject.toml | 35 + sub-packages/bionemo-noodles/requirements.txt | 1 + sub-packages/bionemo-noodles/rust/src/lib.rs | 662 ++++++++++ .../src/bionemo/noodles/__init__.py | 19 + .../src/bionemo/noodles/nvfaidx.py | 165 +++ .../bionemo/noodles/data/bad_index.fasta | 17 + .../bionemo/noodles/data/bad_index.fasta.fai | 1 + .../tests/bionemo/noodles/data/sample.fasta | 17 + .../bionemo/noodles/data/sample.fasta.fai | 5 + .../tests/bionemo/noodles/test_nvfaidx.py | 412 ++++++ .../examples/example_notebook.ipynb | 10 + .../bionemo/scdl/index/row_feature_index.py | 112 +- .../scdl/io/single_cell_memmap_dataset.py | 21 +- .../scdl/index/test_row_feature_index.py | 63 +- .../io/test_single_cell_memmap_dataset.py | 4 +- .../bionemo/size_aware_batching/sampler.py | 6 + .../size_aware_batching/test_sampler.py | 71 +- .../src/bionemo/testing/callbacks.py | 2 +- .../bionemo/testing/harnesses/stop_and_go.py | 14 +- .../testing/megatron_parallel_state_utils.py | 2 +- .../src/bionemo/testing/testing_callbacks.py | 26 +- sub-packages/bionemo-webdatamodule/README.md | 276 ++-- .../src/bionemo/webdatamodule/datamodule.py | 94 +- .../tests/bionemo/webdatamodule/conftest.py | 19 +- .../bionemo/webdatamodule/test_datamodule.py | 6 - tach.toml | 13 +- 116 files changed, 7153 insertions(+), 1048 deletions(-) create mode 100644 Dockerfile.arm create mode 100644 docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb create mode 100644 docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb delete mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/infer.py delete mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py create mode 100644 sub-packages/bionemo-geometric/src/bionemo/geometric/atom_featurizers.py create mode 100644 sub-packages/bionemo-geometric/src/bionemo/geometric/base_featurizer.py create mode 100644 sub-packages/bionemo-geometric/src/bionemo/geometric/bond_featurizers.py create mode 100644 sub-packages/bionemo-geometric/src/bionemo/geometric/data/electronic_data.csv create mode 100644 sub-packages/bionemo-geometric/src/bionemo/geometric/molecule_featurizers.py create mode 100644 sub-packages/bionemo-geometric/tests/bionemo/geometric/test_atom_featurizers.py create mode 100644 sub-packages/bionemo-geometric/tests/bionemo/geometric/test_bond_featurizers.py create mode 100644 sub-packages/bionemo-geometric/tests/bionemo/geometric/test_molecule_featurizers.py create mode 100644 sub-packages/bionemo-noodles/.gitignore create mode 100644 sub-packages/bionemo-noodles/Cargo.lock create mode 100644 sub-packages/bionemo-noodles/Cargo.toml create mode 120000 sub-packages/bionemo-noodles/LICENSE create mode 100644 sub-packages/bionemo-noodles/README.md create mode 120000 sub-packages/bionemo-noodles/VERSION create mode 100644 sub-packages/bionemo-noodles/pyproject.toml create mode 100644 sub-packages/bionemo-noodles/requirements.txt create mode 100644 sub-packages/bionemo-noodles/rust/src/lib.rs create mode 100644 sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py create mode 100644 sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta.fai create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta.fai create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py diff --git a/.gitmodules b/.gitmodules index d8596d8af4..b23b9d161b 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,6 @@ [submodule "3rdparty/Megatron-LM"] path = 3rdparty/Megatron-LM - url = ssh://git@gitlab-master.nvidia.com:12051/ataghibakhsh/megatron-lm.git + url = https://github.com/NVIDIA/Megatron-LM.git [submodule "3rdparty/NeMo"] path = 3rdparty/NeMo url = ssh://git@gitlab-master.nvidia.com:12051/ataghibakhsh/nemo-savanna.git diff --git a/.secrets-nb.baseline b/.secrets-nb.baseline index 567bbc1c71..1b65fbc998 100644 --- a/.secrets-nb.baseline +++ b/.secrets-nb.baseline @@ -145,9 +145,9 @@ "filename": "sub-packages/bionemo-scdl/examples/example_notebook.ipynb", "hashed_secret": "96619ff8b071d683484960c7ef1b5ab8f4d45bbc", "is_verified": false, - "line_number": 36 + "line_number": 46 } ] }, - "generated_at": "2024-10-31T19:56:40Z" + "generated_at": "2024-11-26T01:53:13Z" } diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index cbb9c5a431..14ca285dcc 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit cbb9c5a4312d537b48cf93844bf54ee94060b3bc +Subproject commit 14ca285dcc8b6862fbb992ef8de57402479c0e9f diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 08089dc616..f7899a64b5 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 08089dc616f73fc24cdca5eeebf5ef7cd0564f19 +Subproject commit f7899a64b5ce6f8fe27b5aa386a0044878f3efe8 diff --git a/CODEOWNERS b/CODEOWNERS index 731d00127f..677a0e8700 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -92,3 +92,5 @@ sub-packages/bionemo-example_model @jstjohn @malcolmgreaves @skothenhill-nv sub-packages/bionemo-geneformer @jstjohn @malcolmgreaves @skothenhill-nv sub-packages/bionemo-scdl @jstjohn @malcolmgreaves @polinabinder1 @skothenhill-nv + +sub-packages/bionemo-noodles @skothenhill-nv @malcolmgreaves @jstjohn @edawson diff --git a/Dockerfile b/Dockerfile index 9a0e5d4ead..e4065065e7 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,13 @@ # Base image with apex and transformer engine, but without NeMo or Megatron-LM. ARG BASE_IMAGE=nvcr.io/nvidia/pytorch:24.02-py3 + +FROM rust:1.82.0 as rust-env + +RUN rustup set profile minimal && \ + rustup install 1.82.0 && \ + rustup target add x86_64-unknown-linux-gnu && \ + rustup default 1.82.0 + FROM ${BASE_IMAGE} AS bionemo2-base # Install NeMo dependencies. @@ -88,22 +96,30 @@ RUN --mount=type=bind,source=./sub-packages/bionemo-geometric/requirements.txt,t WORKDIR /workspace/bionemo2 # Install 3rd-party deps and bionemo submodules. +COPY ./LICENSE /workspace/bionemo2/LICENSE COPY ./3rdparty /workspace/bionemo2/3rdparty COPY ./sub-packages /workspace/bionemo2/sub-packages +COPY --from=rust-env /usr/local/cargo /usr/local/cargo +COPY --from=rust-env /usr/local/rustup /usr/local/rustup + +ENV PATH="/usr/local/cargo/bin:/usr/local/rustup/bin:${PATH}" +ENV RUSTUP_HOME="/usr/local/rustup" + # Note, we need to mount the .git folder here so that setuptools-scm is able to fetch git tag for version. RUN --mount=type=bind,source=./.git,target=./.git \ --mount=type=bind,source=./requirements-test.txt,target=/requirements-test.txt \ --mount=type=bind,source=./requirements-cve.txt,target=/requirements-cve.txt \ < /etc/sudoers.d/$USERNAME \ + && chmod 0440 /etc/sudoers.d/$USERNAME + +# Here we delete the dist-packages directory from the pytorch base image, and copy over the dist-packages directory from +# the build image. This ensures we have all the necessary dependencies installed (megatron, nemo, etc.). +RUN < ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.json as you see fit +> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.yaml as you see fit -> NOTE: To pretrain from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the JSON with the correct field to ensure pretraining is initialized from an existing checkpoint. +> NOTE: To continue training from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the YAML with the correct field to ensure pretraining is initialized from an existing checkpoint. -To submit a training job with the passed config, first update the json file with any additional execution parameters +To submit a training job with the passed config, first update the yaml file with any additional execution parameters of your choosing: number of devices, workers, steps, etc. Second, invoke our training entrypoint. To do this, we need three things: -- Configuration file, the JSON produced by the previous step -- Model config type, in this case the pretraining config. This will validate the arguments in the config JSON against +- Configuration file, the YAML produced by the previous step +- Model config type, in this case the pretraining config. This will validate the arguments in the config YAML against those required for pretraining. Alternatively, things like fine-tuning with custom task heads may be specified here. This allows for mixing/matching Data Modules with various tasks. - Data Config type, this specifies how to parse, validate, and prepare the DataModule. This may change depending on task, @@ -242,18 +255,18 @@ for example, pretraining ESM2 uses a protein cluster oriented sampling method. I a pretrained model, a simple fasta file may be sufficient. There is a one-to-one relationship between DataConfig types and DataModule types. -> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config JSON and populate it with your WandB details. +> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config YAML and populate it with your WandB details. ``` bionemo-esm2-train \ ---data-config-t bionemo.esm2.run.config_models.ESM2DataConfig \ ---model-config-t bionemo.esm2.run.config_models.ExposedESM2PretrainConfig \ ---config my_config.json +--data-config-cls bionemo.esm2.run.config_models.ESM2DataConfig \ +--model-config-cls bionemo.esm2.run.config_models.ExposedESM2PretrainConfig \ +--config my_config.yaml ``` -> NOTE: both data-config-t and model-config-t have default values corresponding to ESM2DataConfig and ExposedESM2PretrainingConfig +> NOTE: both data-config-cls and model-config-cls have default values corresponding to ESM2DataConfig and ExposedESM2PretrainingConfig -DataConfigT and ModelConfigT can also refer to locally defined types by the user. As long as python knows how to import +DataConfigCls and ModelConfigCls can also refer to locally defined types by the user. As long as python knows how to import the specified path, they may be configured. For example, you may have a custom Dataset/DataModule that you would like to mix with an existing recipe. In this case, you define a DataConfig object with the generic specified as your DataModule type, and then pass in the config type to the training recipe. @@ -320,39 +333,39 @@ customizations for your task. ```bash TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20240506 --source $MY_DATA_SOURCE); \ bionemo-geneformer-recipe \ - --recipe 10m-pretrain \ - --dest my_config.json \ + --recipe geneformer_10m_pretrain_recipe \ + --dest my_config.yaml \ --data-path ${TEST_DATA_DIR}/cellxgene_2023-12-15_small/processed_data \ --result-dir ./results ``` -> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.json as you see fit +> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.yaml as you see fit -> NOTE: To pretrain from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the JSON with the correct field to ensure pretraining is initialized from an existing checkpoint. +> NOTE: To pretrain from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the YAML with the correct field to ensure pretraining is initialized from an existing checkpoint. -To submit a training job with the passed config, first update the json file with any additional execution parameters +To submit a training job with the passed config, first update the yaml file with any additional execution parameters of your choosing: number of devices, workers, steps, etc. Second, invoke our training entrypoint. To do this, we need three things: -- Configuration file, the JSON produced by the previous step -- Model config type, in this case the pretraining config. This will validate the arguments in the config JSON against +- Configuration file, the YAML produced by the previous step +- Model config type, in this case the pretraining config. This will validate the arguments in the config YAML against those required for pretraining. Alternatively, things like fine-tuning with custom task heads may be specified here. This allows for mixing/matching Data Modules with various tasks. - Data Config type, this specifies how to parse, validate, and prepare the DataModule. This may change depending on task, for example, while fine-tuning you may want to use a custom Dataset/DataModule that includes PERTURB-seq. In this case, the default pretraining DataConfig and DataModule will be insufficient. See ESM2 for additional example usecases. -> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config JSON and populate it with your WandB details. +> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config YAML and populate it with your WandB details. ```bash bionemo-geneformer-train \ ---data-config-t bionemo.geneformer.run.config_models.GeneformerPretrainingDataConfig \ ---model-config-t bionemo.geneformer.run.config_models.ExposedGeneformerPretrainConfig \ ---config my_config.json +--data-config-cls bionemo.geneformer.run.config_models.GeneformerPretrainingDataConfig \ +--model-config-cls bionemo.geneformer.run.config_models.ExposedGeneformerPretrainConfig \ +--config my_config.yaml ``` -> NOTE: both data-config-t and model-config-t have default values corresponding to GeneformerPretrainingDataConfig and ExposedGeneformerPretrainConfig +> NOTE: both data-config-cls and model-config-cls have default values corresponding to GeneformerPretrainingDataConfig and ExposedGeneformerPretrainConfig -DataConfigT and ModelConfigT can also refer to locally defined types by the user. As long as python knows how to import +DataConfigCls and ModelConfigCls can also refer to locally defined types by the user. As long as python knows how to import the specified path, they may be configured. For example, you may have a custom Dataset/DataModule that you would like to mix with an existing recipe. In this case, you define a DataConfig object with the generic specified as your DataModule type, and then pass in the config type to the training recipe. diff --git a/VERSION b/VERSION index cd5ac039d6..8bbe6cf74a 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.0 +2.2 diff --git a/ci/scripts/build_docker_image.sh b/ci/scripts/build_docker_image.sh index 261cbca641..d429350ec9 100755 --- a/ci/scripts/build_docker_image.sh +++ b/ci/scripts/build_docker_image.sh @@ -71,7 +71,12 @@ LABELS_ARGS="" EXTRA_ARGS="" CACHE_ARGS="" DEFAULT_BRANCH_NAME="main" -DEFAULT_DOCKERFILE_PATH="Dockerfile" +ARCH=$(uname -m) +if [[ "$ARCH" == "arm64" || "$ARCH" == "aarch64" ]]; then + DEFAULT_DOCKERFILE_PATH="Dockerfile.arm" +else + DEFAULT_DOCKERFILE_PATH="Dockerfile" +fi # Parse command-line options while [[ "$#" -gt 0 ]]; do diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 77847a61d0..c52dd28b4d 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -17,12 +17,22 @@ set -xueo pipefail export PYTHONDONTWRITEBYTECODE=1 - +# NOTE: if a non-nvidia user wants to run the test suite, just run `export BIONEMO_DATA_SOURCE=ngc` prior to this call. +export BIONEMO_DATA_SOURCE="${BIONEMO_DATA_SOURCE:-pbss}" source "$(dirname "$0")/utils.sh" if ! set_bionemo_home; then exit 1 fi -echo "Running pytest tests" -pytest -v --nbval-lax docs/ scripts/ sub-packages/ +python -m coverage erase + +for dir in docs/ ./sub-packages/bionemo-*/; do + echo "Running pytest in $dir" + python -m coverage run --parallel-mode --source=bionemo \ + -m pytest -v --nbval-lax --durations=0 --durations-min=60.0 --ignore-glob='*docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb' "$dir" + +done + +python -m coverage combine +python -m coverage report --show-missing diff --git a/docs/docs/user-guide/appendix/releasenotes-fw.md b/docs/docs/user-guide/appendix/releasenotes-fw.md index aa047f2caf..01ba9337ed 100644 --- a/docs/docs/user-guide/appendix/releasenotes-fw.md +++ b/docs/docs/user-guide/appendix/releasenotes-fw.md @@ -1,5 +1,50 @@ # Release Notes +## BioNeMo Framework v2.2 + +### New Features + +* Small Molecule Featurization + * Implemented elementary and advanced atom, bond, and full molecule featurizers. +* GH200 Support for BioNeMo + * Added a `Dockerfile.arm` that builds a BioNeMo container that runs on GH200 machines. + * Publish a version of the BioNeMo container that supports multiple architectures to NGC. + +### Updates & Improvements + +* Single-Cell Dataloader (SCDL) + * Changed metadata storage to `parquet` files, which creates a 30x speed up when iterating over a large dataset. + * Added functionality to concatenate several `anndata` files without doubling disk memory usage. +* ESM2 + * Added support for `SIGTERM` preemption checkpoint saving. + * Moved ESM-2 and Geneformer training scripts to new executables, `train_esm2` and `train_geneformer`, respectively. + * Moved inference script to a new executable `infer_esm2`, and deprecated the inference example in the fine-tuning tutorial. + * Added new Jupyter notebook tutorials for inference and zero-shot protein design. These notebooks can be deployed on the cloud resources as a [brev.dev](https://www.brev.dev/) launchable. + + +## BioNeMo Framework v2.1 + +### New Features: + +* ESM2 Implementation + * Updated the ESM-2 Model Card with detailed performance benchmarks comparing BioNeMo2 training against vanilla pytorch. + * Added ESM-2 inference endpoint for evaluating pre-trained models +* Size-Aware Batching + * Added SizeAwareBatchSampler, a pytorch data sampler that batches elements of varying sizes while ensuring that the total size of each batch does not exceed a specified maximum. + * Added BucketBatchSampler, another pytorch data sampler that groups elements of varying sizes based on predefined bucket ranges, and create batches with elements from each bucket to ensure that each batch has elements with homogeneous sizes. +* CLI Support + * Added pydantic interface for pretraining jobs via parsing JSON configuration files that enables passing customized Model and DataModules classes. + * Implemented pydantic configuration for Geneformer and ESM2 pretraining and finetuning. + * Added 'recipes' for generating validated JSON files to be used with pydantic interface. + * Added installable scripts for 2/3 respectively, bionemo-esm2-recipe, bionemo-esm2-train, bionemo-geneformer-recipe, bionemo-geneformer-train. +* Geneformer support in BioNeMo2: + * Tested pre-training scripts and fine-tuning example scripts that can be used as a starting point for users to create custom derivative models. + * Geneformer 10M and 106M checkpoints ported from BioNeMo v1 into BioNeMo v2 available and included in documentation. + * Added inference scripts +* Documentation + * Cell type classification example notebook which covers the process of converting anndata into our internal format, and running inference on that data with a geneformer checkpoint, as well as making use of the inference results. + * Updated Getting Started guide, ESM-2 tutorials + * Added Frequently Asked Questions (FAQ) page ## BioNeMo Framework v2.0 diff --git a/docs/docs/user-guide/examples/bionemo-esm2/finetune.md b/docs/docs/user-guide/examples/bionemo-esm2/finetune.md index 276a6dac29..38c56c075f 100644 --- a/docs/docs/user-guide/examples/bionemo-esm2/finetune.md +++ b/docs/docs/user-guide/examples/bionemo-esm2/finetune.md @@ -151,7 +151,7 @@ data_module = ESM2FineTuneDataModule( # Fine-Tuning the Regressor Task Head for ESM2 -Now we can put these five requirements together to fine-tune a regressor task head starting from a pre-trained ESM-2 model (`pretrain_ckpt_path`). We can take advantage of a simple training loop in ```bionemo.esm2.model.fnetune.train``` and use the ```train_model()`` function to start the fine-tuning process in the following. +Now we can put these five requirements together to fine-tune a regressor task head starting from a pre-trained 650M ESM-2 model (`pretrain_ckpt_path`). We can take advantage of a simple training loop in ```bionemo.esm2.model.fnetune.train``` and use the ```train_model()`` function to start the fine-tuning process in the following. ```python # create a List[Tuple] with (sequence, target) values @@ -174,33 +174,35 @@ data = [(seq, len(seq)/100.0) for seq in artificial_sequence_data] dataset = InMemorySingleValueDataset(data) data_module = ESM2FineTuneDataModule(train_dataset=dataset, valid_dataset=dataset) -with tempfile.TemporaryDirectory() as experiment_tempdir_name: - experiment_dir = Path(experiment_tempdir_name) - experiment_name = "finetune_regressor" - n_steps_train = 50 - seed = 42 +experiment_name = "finetune_regressor" +n_steps_train = 50 +seed = 42 - config = ESM2FineTuneSeqConfig( - # initial_ckpt_path=str(pretrain_ckpt_path) - ) +# To download a 650M pre-trained ESM2 model +pretrain_ckpt_path = load("esm2/650m:2.0") - checkpoint, metrics, trainer = train_model( - experiment_name=experiment_name, - experiment_dir=experiment_dir, # new checkpoint will land in a subdir of this - config=config, # same config as before since we are just continuing training - data_module=data_module, - n_steps_train=n_steps_train, - ) +config = ESM2FineTuneSeqConfig( + initial_ckpt_path=str(pretrain_ckpt_path) +) + +checkpoint, metrics, trainer = train_model( + experiment_name=experiment_name, + experiment_dir=Path(experiment_results_dir), # new checkpoint will land in a subdir of this + config=config, # same config as before since we are just continuing training + data_module=data_module, + n_steps_train=n_steps_train, +) ``` This example is fully implemented in ```bionemo.esm2.model.finetune.train``` and can be executed by: ```bash -python /workspace/bionemo2/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py +python -m bionemo.esm2.model.finetune.train ``` + ## Notes -1. The above example is fine-tuning a randomly initialized ESM-2 model for demonstration purposes. In order to fine-tune a pre-trained ESM-2 model, please download the ESM-2 650M checkpoint from NGC resources using the following bash command +1. The above example is fine-tuning a 650M ESM-2 model. The pre-trained checkpoints can be downloaded from NGC resources using either the following bash command or the `load` function in `bionemo.core.data.load` as shown above. ```bash - download_bionemo_data esm2/650m:2.0 --source ngc + download_bionemo_data esm2/650m:2.0 ``` and pass the output path (e.g. `.../.cache/bionemo/975d29ee980fcb08c97401bbdfdcf8ce-esm2_650M_nemo2.tar.gz.untar`) as an argument into `initial_ckpt_path` while setting the config object: ```python @@ -219,21 +221,43 @@ python /workspace/bionemo2/sub-packages/bionemo-esm2/src/bionemo/esm2/model/fine 3. We are using a small dataset of artificial sequences as our fine-tuning data in this example. You may experience over-fitting and observe no change in the validation metrics. # Fine-Tuned ESM-2 Model Inference -Once we have a checkpoint we can create a config object by pointing the path in `initial_ckpt_path` and use that for inference. Since we need to load all the parameters from this checkpoint (and don't skip the head) we reset the `nitial_ckpt_skip_keys_with_these_prefixes` in this config. Now we can use the ```bionemo.esm2.model.fnetune.train.infer``` to run inference on prediction dataset. +Now we can use ```bionemo.esm2.model.finetune.train.infer``` to run inference on an example prediction dataset. +Record the checkpoint path reported at the end of the finetuning run, after executing `python -m bionemo.esm2.model.finetune.train` (e.g. `/tmp/tmp1b5wlnba/finetune_regressor/checkpoints/finetune_regressor--reduced_train_loss=0.0016-epoch=0-last`) and use that as an argument to inference script (`--checkpoint-path`). -```python -config = ESM2FineTuneSeqConfig( - initial_ckpt_path = finetuned_checkpoint, - initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=list) -) +We download a CSV example dataset of articical sequences for this inference example. Please refer to [ESM-2 Inference](./inference) tutorial for detailed explanation of the arguments and how to create your own CSV file. + +```bash +mkdir -p $WORKDIR/esm2_finetune_tutorial + +# download sample data CSV for inference +DATA_PATH=$(download_bionemo_data esm2/testdata_esm2_infer:2.0 --source ngc) +RESULTS_PATH=$WORKDIR/esm2_finetune_tutorial/inference_results.pt + +infer_esm2 --checkpoint-path \ + --data-path $DATA_PATH \ + --results-path $RESULTS_PATH \ + --config-class ESM2FineTuneSeqConfig ``` -This example is implemented in ```bionemo.esm2.model.finetune.infer``` and can be executed by: +This will create a result `.pt` file under `$WORKDIR/esm2_finetune_tutorial/inference_results.pt` which can be loaded via PyTorch library in python environment: -```bash -python /workspace/bionemo2/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/infer.py +```python +import torch + +# Set the path to results file e.g. /workspace/bionemo2/esm2_finetune_tutorial/inference_results.pt +# results_path = /workspace/bionemo2/esm2_finetune_tutorial/inference_results.pt +results = torch.load(results_path) + +# results is a python dict which includes the following result tensors for this example: +# results['regression_output'] is a tensor with shape: torch.Size([10, 1]) ``` ## Notes -1. For demonstration purposes, executing the above command will infer a randomly initialized `ESM2FineTuneSeqModel` unless `initial_ckpt_path` is specified and set to an already trained model. -2. If a fine-tuned checkpoint is provided as (`initial_ckpt_path`) the `initial_ckpt_skip_keys_with_these_prefixes` should reset to `field(default_factory=list)` and avoid skipping any parameters. +- ESM2 Inference module takes the `--checkpoint-path` and `--config-class` arguments to create a config object by pointing the path in `initial_ckpt_path`. Since we need to load all the parameters from this checkpoint (and don't skip the head) we reset the `initial_ckpt_skip_keys_with_these_prefixes` in this config. + + ```python + config = ESM2FineTuneSeqConfig( + initial_ckpt_path = , + initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=list) + ) + ``` diff --git a/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb b/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb new file mode 100644 index 0000000000..095d7ae641 --- /dev/null +++ b/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb @@ -0,0 +1,504 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2p8Dz9VJ2kFSrTQMXVRtUMgymKx)\n", + "\n", + "
NOTE It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits.
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ESM-2 Inference\n", + "\n", + "This tutorial serves as a demo for [ESM2](https://www.science.org/doi/abs/10.1126/science.ade2574) Inference using a CSV file with `sequences` column. To pre-train the ESM2 model please refer to [ESM-2 Pretraining](./pretrain.md) tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
NOTE Some of the cells below generate long text output. We're using 
%%capture --no-display --no-stderr cell_output
to suppress this output. Comment or delete this line in the cells below to restore full output.
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Assumptions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "In this tutorial, we will demonstrate how to download ESM2 checkpoint, create a CSV file with protein sequences, and infer a ESM-2 model.\n", + "\n", + "All commands should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. For more information on how to build or pull the BioNeMo2 container, refer to the [Initialization Guide](../../getting-started/initialization-guide.md)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "import os\n", + "import torch\n", + "import shutil\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "warnings.simplefilter('ignore')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Work Directory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the work directory to store data and results:\n", + "\n", + "
NOTE We set the following to clean up the work directory created by this notebook 
cleanup : bool = True
" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "cleanup : bool = True" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Directory '/workspace/bionemo2/esm2_inference_tutorial' created.\n" + ] + } + ], + "source": [ + "work_dir=\"/workspace/bionemo2/esm2_inference_tutorial\"\n", + "\n", + "if cleanup and os.path.exists(work_dir):\n", + " shutil.rmtree(work_dir)\n", + "\n", + "if not os.path.exists(work_dir):\n", + " os.makedirs(work_dir)\n", + " print(f\"Directory '{work_dir}' created.\")\n", + "else:\n", + " print(f\"Directory '{work_dir}' already exists.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download Model Checkpoints" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following code will download the pre-trained model, `esm2n/650m:2.0`, from the NGC registry:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/bionemo/.cache/bionemo/0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997-esm2_650M_nemo2.tar.gz.untar\n" + ] + } + ], + "source": [ + "from bionemo.core.data.load import load\n", + "\n", + "checkpoint_path = load(\"esm2/650m:2.0\", source=\"ngc\")\n", + "print(checkpoint_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "We use the `InMemoryCSVDataset` class to load the protein sequence data from a `.csv` file. This data file should at least have a `sequences` column and can optionally have a `labels` column used for fine-tuning applications. Here is an example of how to create your own inference input data using a list of sequences in python:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "artificial_sequence_data = [\n", + " \"TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI\",\n", + " \"LYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"GRFNVWLGGNESKIRQVLKAVKEIGVSPTLFAVYEKN\",\n", + " \"DELTALGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"KLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI\",\n", + " \"LFGAIGNAISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP\",\n", + " \"LGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"LYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"ISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP\",\n", + " \"SGSKASSDSQDANQCCTSCEDNAPATSYCVECSEPLCETCVEAHQRVKYTKDHTVRSTGPAKT\",\n", + "]\n", + "\n", + "# Create a DataFrame\n", + "df = pd.DataFrame(artificial_sequence_data, columns=[\"sequences\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"sequences.csv\")\n", + "df.to_csv(data_path, index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar to PyTorch Lightning, ESM-2 Inference takes advantage of some key classes:\n", + "\n", + "1. `MegatronStrategy` - To launch and setup parallelism for [NeMo](https://github.com/NVIDIA/NeMo/tree/main) and [Megatron-LM](https://github.com/NVIDIA/Megatron-LM).\n", + "2. `Trainer` - To configure training configurations and logging.\n", + "3. `ESMFineTuneDataModule` - To load sequence data for both fine-tuning and inference.\n", + "4. `ESM2Config` - To configure the ESM-2 model as `BionemoLightningModule`.\n", + "\n", + "Please refer to [ESM-2 Pretraining](./pretrain.md) and [ESM-2 Fine-Tuning](./finetune.md) tutorials for detailed description of these classes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To run inference on the data created in the previous step, we can use the `infer_esm2` executable which calls `bionemo-framework/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py`. We can get a full description of inference arguments by providing `--help` in the following command:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-11-25 21:18:43 - faiss.loader - INFO - Loading faiss with AVX512 support.\n", + "2024-11-25 21:18:43 - faiss.loader - INFO - Successfully loaded faiss with AVX512 support.\n", + "[NeMo W 2024-11-25 21:18:43 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "usage: infer_esm2 [-h] --checkpoint-path CHECKPOINT_PATH --data-path DATA_PATH\n", + " --results-path RESULTS_PATH\n", + " [--precision {fp16,bf16,fp32,bf16-mixed,fp32-mixed,16-mixed,fp16-mixed,16,32}]\n", + " [--num-gpus NUM_GPUS] [--num-nodes NUM_NODES]\n", + " [--micro-batch-size MICRO_BATCH_SIZE]\n", + " [--pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE]\n", + " [--tensor-model-parallel-size TENSOR_MODEL_PARALLEL_SIZE]\n", + " [--include-hiddens] [--include-input-ids]\n", + " [--include-embeddings] [--include-logits]\n", + " [--config-class CONFIG_CLASS]\n", + "\n", + "Infer ESM2.\n", + "\n", + "options:\n", + " -h, --help show this help message and exit\n", + " --checkpoint-path CHECKPOINT_PATH\n", + " Path to the ESM2 pretrained checkpoint\n", + " --data-path DATA_PATH\n", + " Path to the CSV file containing sequences and label\n", + " columns\n", + " --results-path RESULTS_PATH\n", + " Path to the results file.\n", + " --precision {fp16,bf16,fp32,bf16-mixed,fp32-mixed,16-mixed,fp16-mixed,16,32}\n", + " Precision type to use for training.\n", + " --num-gpus NUM_GPUS Number of GPUs to use for training. Default is 1.\n", + " --num-nodes NUM_NODES\n", + " Number of nodes to use for training. Default is 1.\n", + " --micro-batch-size MICRO_BATCH_SIZE\n", + " Micro-batch size. Global batch size is inferred from\n", + " this.\n", + " --pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE\n", + " Pipeline model parallel size. Default is 1.\n", + " --tensor-model-parallel-size TENSOR_MODEL_PARALLEL_SIZE\n", + " Tensor model parallel size. Default is 1.\n", + " --include-hiddens Include hiddens in output of inference\n", + " --include-input-ids Include input_ids in output of inference\n", + " --include-embeddings Include embeddings in output of inference\n", + " --include-logits Include per-token logits in output.\n", + " --config-class CONFIG_CLASS\n", + " Model configs link model classes with losses, and\n", + " handle model initialization (including from a prior\n", + " checkpoint). This is how you can fine-tune a model.\n", + " First train with one config class that points to one\n", + " model class and loss, then implement and provide an\n", + " alternative config class that points to a variant of\n", + " that model and alternative loss. In the future this\n", + " script should also provide similar support for picking\n", + " different data modules for fine-tuning with different\n", + " data types. Choices: dict_keys(['ESM2Config',\n", + " 'ESM2FineTuneSeqConfig', 'ESM2FineTuneTokenConfig'])\n" + ] + } + ], + "source": [ + "! infer_esm2 --help" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "The hidden states (which are usually the output of each layer in a neural network) can be obtained by using `--include-hiddens` argument when calling the inference function of ESM-2 in BioNeMo Framework.\n", + "\n", + "The hidden states can be converted into fixed-size vector embeddings. This is done by removing the hidden state vectors corresponding to padding tokens, then averaging across the rest. This process is often used when the goal is to create a single vector representation from the hidden states of a model, which can be used for various sequence-level downstream tasks such as classification (e.g. subcellular localization) or regression (e.g. melting temperature prediction). To obtain the embedding results we can use `--include-embeddings` argument.\n", + "\n", + "By passing the hidden state of an amino acid sequence through the BERT language model head, we can obtain output logits at each position and transform them into probabilities. This can happen by using `--include-logits` argument. Logits here are the raw, unnormalized scores that represent the likelihood of each class and are not probabilities themselves; they can be any real number, including negative values." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now lets call `infer_esm2` executable with relevant arguments to compute and optionally return embeddings, hiddens and logits." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "results_path = os.path.join(work_dir, \"inference_results.pt\")\n", + "\n", + "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", + " --data-path {data_path} \\\n", + " --results-path {results_path} \\\n", + " --precision \"fp32\" \\\n", + " --include-hiddens \\\n", + " --include-embeddings \\\n", + " --include-logits \\\n", + " --include-input-ids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inference Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The bash command in previous step creates the `inference_results.pt` file under the work directory of this notebook (defined above) to stores the results. The `.pt` file containes a dictionary of `{'result_key': torch.Tensor}` that be loaded with PyTorch:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "token_logits\ttorch.Size([1024, 10, 128])\n", + "hidden_states\ttorch.Size([10, 1024, 1280])\n", + "input_ids\ttorch.Size([10, 1024])\n", + "embeddings\ttorch.Size([10, 1280])\n" + ] + } + ], + "source": [ + "import torch\n", + "results = torch.load(results_path)\n", + "\n", + "for key, val in results.items():\n", + " if val is not None:\n", + " print(f'{key}\\t{val.shape}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example `data` a python dict with the following keys `['token_logits', 'hidden_states', 'input_ids', 'embeddings']`. Logits (`token_logits`) tensor has a dimension of `[sequence, batch, hidden]` to improve the training performance. We will transpose the first two dimension in the following to have batch-first shape like the rest of the output tensors." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([10, 1024, 128])\n" + ] + } + ], + "source": [ + "logits = results['token_logits'].transpose(0, 1) # s, b, h -> b, s, h\n", + "print(logits.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last dimension of `token_logits` is 128, with the first 33 positions corresponding to the amino acid vocabulary, followed by 95 paddings. We use the `tokenizer.vocab_size` to filter out the paddings and only keep the 33 vocab positions." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 33 unique tokens: ['', '', '', '', 'L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C', 'X', 'B', 'U', 'Z', 'O', '.', '-', '', ''].\n", + "Logits shape after removing the paddings in hidden dimension: torch.Size([10, 1024, 33])\n" + ] + } + ], + "source": [ + "from bionemo.esm2.data.tokenizer import get_tokenizer\n", + "tokenizer = get_tokenizer()\n", + "\n", + "tokens = tokenizer.all_tokens\n", + "print(f\"There are {tokenizer.vocab_size} unique tokens: {tokens}.\")\n", + "\n", + "aa_logits = logits[..., :tokenizer.vocab_size] # filter out the 95 paddings and only keep 33 vocab positions\n", + "print(f\"Logits shape after removing the paddings in hidden dimension: {aa_logits.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's set aside the tokens corresponding to the 20 known amino acids." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "aa_tokens = ['L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C']\n", + "\n", + "aa_indices = [i for i, token in enumerate(tokens) if token in aa_tokens]\n", + "extra_indices = [i for i, token in enumerate(tokens) if token not in aa_tokens]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The sequence dimension in this example (1024) is representing the max sequence length wich includes paddings, EOS, and BOS. To filter the relevant amino acid information we can use the input sequence IDs in the results to create a mask that can be used to extract the relevant information in `aa_logits`" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "input_ids = results['input_ids'] # b, s\n", + "# mask where non-amino acid tokens are True\n", + "mask = torch.isin(input_ids, torch.tensor(extra_indices))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more in-depth example of inference and converting logits to probabilities please refer to [ESM-2 Mutant Design Tutorial](./mutant-design.ipynb)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb b/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb new file mode 100644 index 0000000000..c4a904c653 --- /dev/null +++ b/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb @@ -0,0 +1,1154 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "72f40b2c", + "metadata": {}, + "source": [ + "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2p81OcxdHAJZLSOc2KW14WW1YU8)\n", + "\n", + "
NOTE It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits. (Note: This links to the nightly release and may be out of sync with these docs.)
" + ] + }, + { + "cell_type": "markdown", + "id": "eae5c045-bec3-437f-a4e5-b5c39743d5bf", + "metadata": {}, + "source": [ + "# Zero-Shot Protein Design Using ESM-2" + ] + }, + { + "cell_type": "markdown", + "id": "35872df2-36bb-4168-be18-a15f60eed857", + "metadata": { + "tags": [] + }, + "source": [ + "*We thank Adrian Lange from A-Alpha Bio for originally contributing this recipe. This notebook has since been modified by NVIDIA.*" + ] + }, + { + "cell_type": "markdown", + "id": "dfd448e3-272a-4147-b3ad-af58b53c83d7", + "metadata": {}, + "source": [ + "## Demo Objectives" + ] + }, + { + "cell_type": "markdown", + "id": "9277c38c-2827-419b-9512-ddd64087a4e0", + "metadata": {}, + "source": [ + "1. **ESM-2nv Inference Functionality**\n", + " * Objective: Perform inference on the pre-trained ESM-2 model.\n", + " * Steps: Download model checkpoints, create CSV data file of protein sequences, and generate hidden state representations and sequence embeddings from input protein sequences.\n", + "2. **Logit and Probability Extraction**\n", + " * Objective: Obtain probability values of all possible tokens at each position in the amino acid sequence.\n", + " * Steps: Generate logits from hidden states, and transform them into probabilities.\n", + "3. **Protein Mutant Design**\n", + " * Objective: Optimize an input protein sequence to align it more closely with naturally occurring protein variants.\n", + " * Steps: Sequentially mask amino acids, extract per-position probabilities (and create a heatmap), analyze positions where single-point mutants have higher likelihood than wild-type, and develop new candidates." + ] + }, + { + "cell_type": "markdown", + "id": "e0d4987f-b76c-4978-aef3-2ef1685d1b6a", + "metadata": {}, + "source": [ + "## Background" + ] + }, + { + "cell_type": "markdown", + "id": "3bd0f2dd-816a-4025-98e1-71ac53797091", + "metadata": {}, + "source": [ + "ESM-2 is a large-scale protein language model (PLM) trained on millions of protein sequences. It can capture complex patterns and relationships in protein sequences, allowing it to be used to predict likely amino acid substitutions at different positions. By leveraging ESM-2's masked language modeling (MLM) capabilities, we can identify potential mutations that may enhance a protein's properties or align it more closely with naturally occurring variants. ESM-2 has 650M and 3B parameter versions - for this demo, we will be using ESM-2 3B." + ] + }, + { + "cell_type": "markdown", + "id": "07432049-5633-42eb-8f36-9af805babf11", + "metadata": { + "tags": [] + }, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "markdown", + "id": "dd6bed85-787b-4456-8426-55194da94852", + "metadata": {}, + "source": [ + "This notebbok should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. This tutorial assumes that a copy of the BioNeMo framework repo exists on workstation or server and has been mounted inside the container at `/workspace/bionemo2`. For more information on how to build or pull the BioNeMo2 container, refer to the [Initialization Guide](https://docs.nvidia.com/bionemo-framework/latest/user-guide/getting-started/initialization-guide/)." + ] + }, + { + "cell_type": "markdown", + "id": "408fae95-4769-4282-8731-0c83084c9390", + "metadata": {}, + "source": [ + "
NOTE Some of the cells below generate long text output. We're using 
%%capture --no-display --no-stderr cell_output
to suppress this output. Comment or delete this line in the cells below to restore full output.
" + ] + }, + { + "cell_type": "markdown", + "id": "a9e2eeed-89f1-4aed-b472-ec78065930d3", + "metadata": {}, + "source": [ + "### Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f2e561ce-d169-4846-bb09-d41b4b2898b5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "import os\n", + "import torch\n", + "import shutil\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "warnings.simplefilter('ignore')\n" + ] + }, + { + "cell_type": "markdown", + "id": "7a9a7571", + "metadata": {}, + "source": [ + "### Work Directory" + ] + }, + { + "cell_type": "markdown", + "id": "08d32bdf", + "metadata": {}, + "source": [ + "Set the work directory to store data and results:\n", + "\n", + "
NOTE We set the following to clean up the work directory created by this notebook 
cleanup : bool = True
" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1aeee242", + "metadata": {}, + "outputs": [], + "source": [ + "cleanup : bool = True" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6fba4a74", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Directory '/workspace/bionemo2/esm2_mutant_design_tutorial' created.\n" + ] + } + ], + "source": [ + "work_dir=\"/workspace/bionemo2/esm2_mutant_design_tutorial\"\n", + "\n", + "if cleanup and os.path.exists(work_dir):\n", + " shutil.rmtree(work_dir)\n", + "\n", + "if not os.path.exists(work_dir):\n", + " os.makedirs(work_dir)\n", + " print(f\"Directory '{work_dir}' created.\")\n", + "else:\n", + " print(f\"Directory '{work_dir}' already exists.\")" + ] + }, + { + "cell_type": "markdown", + "id": "f1933690-cbc5-46f5-9724-57f6a7a51ab3", + "metadata": {}, + "source": [ + "### Download Model Checkpoints\n", + "The following code will download the pre-trained model, `esm2/3b:2.0`, from the NGC registry:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "aefc431a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/bionemo/.cache/bionemo/a2248cfed1ef39f83bd32a0e08b84c0a8f39325d383e2d92767022ff7f5260ed-esm2_3B_nemo2.tar.gz.untar\n" + ] + } + ], + "source": [ + "from bionemo.core.data.load import load\n", + "\n", + "checkpoint_path = load(\"esm2/3b:2.0\", source=\"ngc\")\n", + "print(checkpoint_path)" + ] + }, + { + "cell_type": "markdown", + "id": "fac3d92c-2f63-45ab-be97-7030107760e7", + "metadata": {}, + "source": [ + "## ESM-2 Inference" + ] + }, + { + "cell_type": "markdown", + "id": "12a9c623-8e76-4936-b58a-72d4504b201c", + "metadata": {}, + "source": [ + "In this section, we will explore the key inference functionalities of the pre-trained model. " + ] + }, + { + "cell_type": "markdown", + "id": "876840a6", + "metadata": {}, + "source": [ + "### Data" + ] + }, + { + "cell_type": "markdown", + "id": "14048d53", + "metadata": {}, + "source": [ + "In the first step we prepare the data by creating a CSV file with `sequences` column that holds the protein sequences that we use as inference input." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e390dc05-3dee-4013-916a-ffb76a174408", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "sequences = [\n", + " 'MSLKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL', # length: 41\n", + " 'MIQSQINRNIRLDLADAILLSKAKKDLSFAEIADGTGLA', # length: 39\n", + "]\n", + "# Create a DataFrame\n", + "df = pd.DataFrame(sequences, columns=[\"sequences\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"sequences.csv\")\n", + "df.to_csv(data_path, index=False)" + ] + }, + { + "cell_type": "markdown", + "id": "787d02d4-e3fc-46a1-937b-ae69abfc00fa", + "metadata": { + "tags": [] + }, + "source": [ + "### Tokenizer" + ] + }, + { + "cell_type": "markdown", + "id": "577bb80f-a20b-4e85-a853-4fa8952bcb40", + "metadata": {}, + "source": [ + "Let's also check the tokenizer vocabulary." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "697745ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 33 unique tokens: ['', '', '', '', 'L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C', 'X', 'B', 'U', 'Z', 'O', '.', '-', '', ''].\n" + ] + } + ], + "source": [ + "from bionemo.esm2.data.tokenizer import get_tokenizer, BioNeMoESMTokenizer\n", + "tokenizer = get_tokenizer()\n", + "\n", + "tokens = tokenizer.all_tokens\n", + "print(f\"There are {tokenizer.vocab_size} unique tokens: {tokens}.\")" + ] + }, + { + "cell_type": "markdown", + "id": "3d4602a6-bae2-42dd-83ce-2a11f84b3c32", + "metadata": {}, + "source": [ + "Let's set aside the tokens corresponding to the 20 known amino acids." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fa1699c8-aea7-44e6-b80b-973af016e8bd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "aa_tokens = ['L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C']\n", + "\n", + "aa_indices = [i for i, token in enumerate(tokens) if token in aa_tokens]\n", + "extra_indices = [i for i, token in enumerate(tokens) if token not in aa_tokens]" + ] + }, + { + "cell_type": "markdown", + "id": "c8a87f61-e753-491c-9e32-fbd699eca723", + "metadata": {}, + "source": [ + "### Obtaining Model Outputs" + ] + }, + { + "cell_type": "markdown", + "id": "7e93ada8", + "metadata": {}, + "source": [ + "ESM-2nv was trained with a Masked Language Modeling (MLM) objective. Thus, we are able to mask a position in an amino acid sequence and obtain values for the most probable amino acids at that position, based on the surrounding context. Let's sequentially obtain these values for every position in the sequence." + ] + }, + { + "cell_type": "markdown", + "id": "b3bd0f4e-ef89-4245-abbc-06177e3883e8", + "metadata": {}, + "source": [ + "\n", + "The hidden states (which are usually the output of each layer in a neural network) can be obtained by using `--include-hiddens` argument when calling the inference function of ESM-2 in BioNeMo Framework.\n", + "\n", + "The hidden states can be converted into fixed-size vector embeddings. This is done by removing the hidden state vectors corresponding to padding tokens, then averaging across the rest. This process is often used when the goal is to create a single vector representation from the hidden states of a model, which can be used for various sequence-level downstream tasks such as classification (e.g. subcellular localization) or regression (e.g. melting temperature prediction). To obtain the embedding results we can use `--include-embeddings` argument.\n", + "\n", + "By passing the hidden state of an amino acid sequence through the BERT language model head, we can obtain output logits at each position and transform them into probabilities. This can happen by using `--include-logits` argument. Logits here are the raw, unnormalized scores that represent the likelihood of each class and are not probabilities themselves; they can be any real number, including negative values.\n", + "\n", + "When we apply the softmax function to logits, it converts them into a probability distribution over the classes, where the sum of probabilities equals 1." + ] + }, + { + "cell_type": "markdown", + "id": "e7ac5fba", + "metadata": {}, + "source": [ + "Now lets call `infer_esm2` executable with relevant arguments to compute and optionally return embeddings, hiddens and logits." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2bc577fa-32a3-4351-bc6f-60ba8f0df9f0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "results_path = os.path.join(work_dir, \"inference_results.pt\")\n", + "\n", + "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", + " --data-path {data_path} \\\n", + " --results-path {results_path} \\\n", + " --precision \"fp32\" \\\n", + " --include-hiddens \\\n", + " --include-embeddings \\\n", + " --include-logits \\\n", + " --include-input-ids" + ] + }, + { + "cell_type": "markdown", + "id": "67d09581-e784-4ccc-be88-194c8909068c", + "metadata": {}, + "source": [ + "\n", + "This will write the output of ESM-2 inference into a python dictionary and save that into `inference_results.pt` which can be loaded via PyTorch:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2b48c5a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "token_logits\ttorch.Size([1024, 2, 128])\n", + "hidden_states\ttorch.Size([2, 1024, 2560])\n", + "input_ids\ttorch.Size([2, 1024])\n", + "embeddings\ttorch.Size([2, 2560])\n" + ] + } + ], + "source": [ + "results = torch.load(results_path)\n", + "\n", + "for key, val in results.items():\n", + " if val is not None:\n", + " print(f'{key}\\t{val.shape}')" + ] + }, + { + "cell_type": "markdown", + "id": "1c656af4", + "metadata": {}, + "source": [ + "Logits (`token_logits`) tensor has a dimension of `[sequence, batch, hidden]` to improve the training performance. We will transpose the first two dimension in the following to have batch-first shape like the rest of the output tensors. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c20b133a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 1024, 128])\n" + ] + } + ], + "source": [ + "logits = results['token_logits'].transpose(0, 1) # s, b, h -> b, s, h\n", + "print(logits.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "8e005cc2", + "metadata": {}, + "source": [ + "The sequnce dimension of `toke_logits` is 1024, which includes begining-of-sequence, end-of-sequence (eos/bos) and padding. The last dimension of `token_logits` is 128, with the first 33 positions corresponding to the amino acid vocabulary, followed by 95 paddings. We use the `tokenizer.vocab_size` to filter out the paddings and only keep the 33 vocab positions." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "aa382930", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 1024, 33])\n" + ] + } + ], + "source": [ + "aa_logits = logits[..., :tokenizer.vocab_size] # filter out the 95 paddings and only keep 33 vocab positions\n", + "print(aa_logits.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "0dc369ab", + "metadata": {}, + "source": [ + "We will force the probabilities of non-amino acid tokens to become zero by calling softmax on `-inf`. These tokens IDs are listed as `extra_indices` and we set the logits values to `-inf`.\n", + "\n", + "\n", + "Now we can convert the logits to probabilities using PyTorch Softmax function. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bc1063e2", + "metadata": {}, + "outputs": [], + "source": [ + "aa_logits[..., extra_indices] = - torch.inf # force non-amino acid token probs to zero\n", + "\n", + "probs = torch.softmax(aa_logits, dim=-1)\n", + "\n", + "# check that rows sum to 1\n", + "# probs.sum(dim=-1)" + ] + }, + { + "cell_type": "markdown", + "id": "093e0633", + "metadata": {}, + "source": [ + "These steps are summerized in the `logits_to_probs()` function below:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "70cde80b", + "metadata": {}, + "outputs": [], + "source": [ + "def logits_to_probs(\n", + " logits: torch.Tensor, tokenizer: BioNeMoESMTokenizer = get_tokenizer()\n", + ") -> torch.Tensor:\n", + " \"\"\"Convert token logits to probabilities\n", + "\n", + " Args:\n", + " logits (torch.Tensor): logits tensor with the [batch, sequence, hidden] dimensions\n", + " tokenizer (BioNeMoESMTokenizer): ESM2 tokenizer\n", + "\n", + " Returns:\n", + " probabilities (torch.Tensor): probability tensor with [batch, sequence, tokenizer.vocab_size]\n", + " \"\"\"\n", + " aa_tokens = ['L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C']\n", + " extra_indices = [i for i, token in enumerate(tokenizer.all_tokens) if token not in aa_tokens]\n", + "\n", + " aa_logits = logits[..., :tokenizer.vocab_size] # filter out the 95 paddings and only keep 33 vocab positions\n", + " aa_logits[..., extra_indices] = - torch.inf # force non-amino acid token probs to zero\n", + " return torch.softmax(aa_logits, dim=-1)\n" + ] + }, + { + "cell_type": "markdown", + "id": "fb05b9ac", + "metadata": {}, + "source": [ + "#### Note\n", + "The sequence dimension in this example (1024) is representing the max sequence length wich includes paddings, EOS, and BOS. To filter the relevant amino acid information we can use the input sequence IDs in the results to create a mask:\n", + "\n", + "```python\n", + " input_ids = results['input_ids'] # b, s\n", + " # mask where non-amino acid tokens are True\n", + " mask = torch.isin(input_ids, torch.tensor(extra_indices))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e0e3a9c5-7159-49c1-8eec-17d5e22e647a", + "metadata": { + "tags": [] + }, + "source": [ + "## Mutant Design through ESM-2nv" + ] + }, + { + "cell_type": "markdown", + "id": "922d8037-60a0-4276-9c79-df31fe33317c", + "metadata": {}, + "source": [ + "In this section, we aim to optimize an input protein sequence by introducing single-point mutations that align it more closely with naturally occurring protein variants. These mutants may present properties that enhance the protein's functionality, such as improved stability or increased catalytic activity. By leveraging ESM-2's masked language modeling capabilities, we can identify amino acid substitutions with higher likelihood than the wild-type residues. This approach allows us to explore the protein sequence space efficiently, potentially discovering variants with superior characteristics." + ] + }, + { + "cell_type": "markdown", + "id": "a749c2cd-2c81-4856-8c8a-ab26db2d0524", + "metadata": { + "tags": [] + }, + "source": [ + "### Sequential Masking" + ] + }, + { + "cell_type": "markdown", + "id": "a06291d0-0913-426b-8438-972a19c025c5", + "metadata": {}, + "source": [ + "Let's take a starting sequence and scan through the positions, iteratively placing a `` token in place of the existing amino acid at each position. We will then predict probabilities at each masked location. If you only want to analyze substitutions within a predefined portion of the sequence (e.g. a specific alpha helix), you can set `start_pos` and `end_pos` accordingly, below." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bee9bca9-c818-4bbf-933b-ac3f87a17bbc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "seq = 'MSLKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL' # length: 41\n", + "\n", + "start_pos = 0\n", + "end_pos = len(seq)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d2aef066-c837-4cc9-ba90-2e095f84898a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "positions = np.arange(start_pos, end_pos)\n", + "\n", + "sequentially_masked = list()\n", + "for index in positions:\n", + " masked = seq[:index] + \"\" + seq[index+1:]\n", + " sequentially_masked.append(masked)" + ] + }, + { + "cell_type": "markdown", + "id": "c9f848e2-b458-43e4-884b-227884d94251", + "metadata": {}, + "source": [ + "Let's save the masked sequences into a CSV file and look at the first few elements of `sequentially_masked_sequences`:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0771cdf6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sequences
0<mask>SLKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL
1M<mask>LKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL
2MS<mask>KRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL
3MSL<mask>RKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL
4MSLK<mask>KNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL
\n", + "
" + ], + "text/plain": [ + " sequences\n", + "0 SLKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL\n", + "1 MLKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL\n", + "2 MSKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL\n", + "3 MSLRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL\n", + "4 MSLKKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a DataFrame\n", + "df = pd.DataFrame(sequentially_masked, columns=[\"sequences\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "masked_data_path = os.path.join(work_dir, \"sequentially_masked_sequences.csv\")\n", + "df.to_csv(masked_data_path, index=False)\n", + "\n", + "\n", + "df.head(n=5)" + ] + }, + { + "cell_type": "markdown", + "id": "ea90286c-2905-4a88-b82e-9b7791d6d81a", + "metadata": {}, + "source": [ + "### Extraction of Probabilities" + ] + }, + { + "cell_type": "markdown", + "id": "13265b21-9049-4be6-a940-6b9700826896", + "metadata": {}, + "source": [ + "We now extract the logits and convert them to probability matrix for each element of `sequentially_masked`. This can easily be done by calling the inference function above with `--include-logits` and using softmax to convert the logits to probabilities. We can then select the probability vectors corresponding to the masked positions, and combine them into a final probability matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e63cc1a3", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "sequentially_masked_results_path = os.path.join(work_dir, \"sequentially_masked_inference_results.pt\")\n", + "\n", + "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", + " --data-path {masked_data_path} \\\n", + " --results-path {sequentially_masked_results_path} \\\n", + " --precision \"fp32\" \\\n", + " --include-logits \\\n", + " --include-input-ids" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8ec1e825", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([41, 1024, 33])\n" + ] + } + ], + "source": [ + "results = torch.load(sequentially_masked_results_path)\n", + "logits = results['token_logits'].transpose(0, 1) # s, b, h -> b, s, h\n", + "\n", + "probs = logits_to_probs(logits)\n", + "print(probs.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "e8155a03", + "metadata": {}, + "source": [ + "We are only interested in the probabilities associate with the amino acid tokens. So we need to ignore padding, and eos/bos tokens. Since all the sequence have the same length we can use that to filter them:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "44584502", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([41, 41, 33])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "probas_final = probs[:, 1:positions.size+1, :]\n", + "probas_final.shape" + ] + }, + { + "cell_type": "markdown", + "id": "ab23b2a4", + "metadata": {}, + "source": [ + "Select and combine probabilities corresponding to each mask" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8a71e1cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([41, 33])\n" + ] + } + ], + "source": [ + "probas_final = probas_final[np.arange(probas_final.shape[0]), positions, :]\n", + "print(probas_final.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "5a5212ee-fff3-45ce-8e68-098931875ad5", + "metadata": {}, + "source": [ + "### Amino Acid Heatmap" + ] + }, + { + "cell_type": "markdown", + "id": "f77e4da3-9241-4b1b-a014-979897d4fb76", + "metadata": {}, + "source": [ + "Let's visualize the results. We can plot the predicted probabilities of each token across all positions of interest." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "b1eba3a7-3da9-4cfe-8215-ec7109bfc444", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create heatmap\n", + "dat = probas_final[:, aa_indices]\n", + "\n", + "plt.figure(figsize=(11, 5))\n", + "im = plt.imshow(dat.T, cmap='viridis', aspect='auto')\n", + "\n", + "# Add color scale\n", + "cbar = plt.colorbar(im)\n", + "cbar.set_label('Probability', rotation=270, labelpad=15)\n", + "\n", + "# Set y-axis labels (amino acid tokens) and x-axis labels (position in sequence)\n", + "plt.yticks(ticks=np.arange(len(aa_tokens)), labels=aa_tokens)\n", + "plt.xticks(ticks=np.arange(dat.shape[0]), labels=list(seq))\n", + "plt.gca().xaxis.set_ticks_position('bottom')\n", + "\n", + "# Add axes titles and main title\n", + "plt.xlabel('Position in Sequence')\n", + "plt.ylabel('Token Labels')\n", + "plt.title('Positional Token Probabilities')\n", + "\n", + "# Adjust layout to prevent clipping of labels\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dcefa4a8-9172-49d2-b0c6-2f23cac589da", + "metadata": { + "tags": [] + }, + "source": [ + "### Mutant Discovery" + ] + }, + { + "cell_type": "markdown", + "id": "c4d5f74f-afba-4cfc-aa6f-33237911df8a", + "metadata": {}, + "source": [ + "We can now translate the logits/probabilities back into the sequence space, by mapping the highest probability in each position to the corresponding amino acid. " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "dc1026a7", + "metadata": {}, + "outputs": [], + "source": [ + "# Predicted seq (Argmax --> Collect token IDs of predicted seq --> Convert to amino acids)\n", + "pred_idx_list = np.argmax(probas_final, axis=-1).tolist()\n", + "pred_seq = \"\".join([tokenizer.id_to_token(id) for id in pred_idx_list])\n", + "\n", + "# Original seq\n", + "true_idx_list = [tokenizer.token_to_id(seq[i]) for i in positions]\n", + "true_seq = \"\".join([tokenizer.id_to_token(id) for id in true_idx_list])" + ] + }, + { + "cell_type": "markdown", + "id": "a99cf11e-5fae-4521-b16b-7da58f72c897", + "metadata": {}, + "source": [ + "Let's compare the sequences and visually inspect the positions where a mutant is suggested over the wild-type. Note that the predicted sequence is displayed on the top, and the original sequence is on the bottom." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "07191bcb-9951-40a4-beb9-f2a008a0c91c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'MSEENKIIVVIVAAGKGSRMGSDRPKQYLKIGGKTILEHTI (Predicted Sequence)'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'..|||.|.||.|...|.|.|.|.|....||..|..|...||'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "'MSLKRKNIALIPAAGIGVRFGADKPKQYVEIGSKTVLEHVL (Input Sequence)'" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare prediction (reconstruction) to true (input sequence)\n", + "display(pred_seq + \" (Predicted Sequence)\")\n", + "display(\n", + " \"\".join(\n", + " [\".\" if a == b else \"|\" for a, b in zip(pred_seq, true_seq)]\n", + " )\n", + ")\n", + "display(true_seq + \" (Input Sequence)\")" + ] + }, + { + "cell_type": "markdown", + "id": "0ae76c54-a716-4001-b17c-95588708b31e", + "metadata": {}, + "source": [ + "Amongst the mismatches, we can:\n", + "1. Collect all positions where a mutant is suggested over the wild-type amino acid.\n", + "2. At these positions, find the mutant with the highest probability." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "0710fc32-aa0a-4ae4-9c72-9e1680694fee", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Position: 32\n", + "Mutation: S32G\n" + ] + } + ], + "source": [ + "# Collect indices where a mutant is suggested over the wild-type\n", + "matches = [c1 == c2 for c1, c2 in zip(pred_seq, true_seq)]\n", + "mismatch_index = [i for i, value in enumerate(matches) if not value]\n", + "\n", + "# Filter probability matrix to mismatches-only\n", + "probas_mismatch = probas_final[mismatch_index, :]\n", + "\n", + "# Find index of mutant with highest likelihood\n", + "index_flat = np.argmax(probas_mismatch)\n", + "index_2d = np.unravel_index(index_flat, probas_mismatch.shape)\n", + "index_of_interest = mismatch_index[index_2d[0]]\n", + "position_of_interest = positions[index_of_interest]\n", + "print(\"Position:\", position_of_interest)\n", + "print(\"Mutation:\", true_seq[position_of_interest] + str(position_of_interest) + pred_seq[position_of_interest])" + ] + }, + { + "cell_type": "markdown", + "id": "a16739fb-8b1a-4e5e-8d0b-8c3d4cf0a909", + "metadata": {}, + "source": [ + "Let's check the probability associated to mutations at this position." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1a2a31f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TokenToken IDProbability
0G60.776999
1D130.053530
2N170.052637
3E90.032759
4S80.023782
\n", + "
" + ], + "text/plain": [ + " Token Token ID Probability\n", + "0 G 6 0.776999\n", + "1 D 13 0.053530\n", + "2 N 17 0.052637\n", + "3 E 9 0.032759\n", + "4 S 8 0.023782" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sort tokens by probability\n", + "token_ids_sort = sorted(enumerate(probas_final[index_of_interest]), key=lambda x: x[1], reverse=True)\n", + "\n", + "tokens_sort = [(tokenizer.all_tokens[i], i, p.item()) for i, p in token_ids_sort]\n", + "\n", + "tokens_sort_df = pd.DataFrame(tokens_sort, columns=['Token', 'Token ID', 'Probability'])\n", + "tokens_sort_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "f440e535-f259-487d-aeed-416ed29b00ff", + "metadata": {}, + "source": [ + "It's clear that for this position, the amino acid Glycine (G) has a higher likelihood than the wild-type, Serine (S). In this way, we can use ESM-2nv to design novel mutant candidates for downstream testing.\n", + "\n", + "There are many ways that we can engineer candidates from ESM-2nv outputs. We can continue finding the top _n_ single-point mutants, find the top _n_ double- or multi-point mutants, randomly sample over the probability space generated by the input sequence, sample only within certain positions of interest (e.g. known active sites), etc. Through this process, a set of mutants can be developed for further _in silico_ or wet lab testing." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/docs/user-guide/examples/bionemo-esm2/pretrain.md b/docs/docs/user-guide/examples/bionemo-esm2/pretrain.md index 04b6529255..f273673f95 100644 --- a/docs/docs/user-guide/examples/bionemo-esm2/pretrain.md +++ b/docs/docs/user-guide/examples/bionemo-esm2/pretrain.md @@ -8,7 +8,11 @@ The ESM-2 model is a transformer-based protein language model that was pretraine In this tutorial, we will demonstrate how to create an ESM-2 pretraining data module, and create and train a ESM-2 model. -All commands should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. This tutorial assumes that a copy of the BioNeMo framework repo exists on workstation or server and has been mounted inside the container at `/workspace/bionemo2`. For more information on how to build or pull the BioNeMo2 container, refer to the [Initialization Guide](../../getting-started/initialization-guide.md). +All commands should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. The BioNeMo Framework container can run in a brev.dev launchable: [![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy/now?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU). It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credit. After launching the instance, launch a Terminal session in the Jupyter Lab UI. (Note: This links to the nightly release and may be out of sync with these docs.) + +Alternatively, more information on how to build or pull the BioNeMo2 container locally, refer to the [Initialization Guide](../../getting-started/initialization-guide.md). + +This tutorial assumes that a copy of the BioNeMo framework repo exists on workstation or server and has been mounted inside the container at `/workspace/bionemo2`. !!! note @@ -57,7 +61,7 @@ strategy = nl.MegatronStrategy( BioNeMo2 trainer is very similar to PyTorch Lightning trainer. We can configure the training configurations and logging. ```python -from pytorch_lightning.callbacks import LearningRateMonitor, RichModelSummary +from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary from bionemo.llm.lightning import PerplexityLoggingCallback num_steps = 20 diff --git a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb index 749e8615ba..3a0f566e11 100644 --- a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb +++ b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb @@ -1,5 +1,14 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2p32dFTsjecDZOrOOJCok3qZuYV)\n", + "\n", + "NOTE: it takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -14,7 +23,7 @@ "metadata": {}, "source": [ "# Geneformer Cell Type Classification Benchmark\n", - "Here we benchmark four models, with two baselines. These models are tasked with cell type classification, using the Chron’s disease small intestine dataset from Elmentaite et al. (2020), Developmental Cell. This dataset contains approximately 22,500 single cells from both healthy children aged 4-13 and chidlren with Chron’s disease. This dataset contains 31 unique cell types which we assume to be annotated accurately. This dataset was held out of our pre-training dataset as all diseased samples were removed.\n", + "Here we benchmark four models, with two baselines. These models are tasked with cell type classification, using the Crohn's disease small intestine dataset from Elmentaite et al. (2020), Developmental Cell. This dataset contains approximately 22,500 single cells from both healthy children aged 4-13 and children with Crohn's disease. This dataset contains 31 unique cell types which we assume to be annotated accurately. This dataset was held out of our pre-training dataset as all diseased samples were removed.\n", "\n", "* Baseline (1) scRNA workflow: this model uses PCA with 10 components and random forest on normalized and log transformed expression counts to produce a result.\n", "* Baseline (2) geneformer with random weight initialization. Some performance can come from large random projections, but we want to do better than that.\n", @@ -189,10 +198,10 @@ " warnings.warn(msg, FutureWarning)\n", "Found 1 files\n", "Starting to create memmap files...\n", - "Creating metadata...: 100%|███████████████████████| 1/1 [00:00<00:00, 4.53it/s]\n", + "Creating metadata...: 100%|███████████████████████| 1/1 [00:00<00:00, 4.55it/s]\n", "Done creating `metadata.json`\n", "Writing data into memmaps to /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/celltype-bench-dataset...\n", - "Merging AnnData into numpy memaps...: 100%|███████| 1/1 [00:00<00:00, 2.59it/s]\n", + "Merging AnnData into numpy memaps...: 100%|███████| 1/1 [00:00<00:00, 2.58it/s]\n", "Saving dataframe ...\n", "Done creating dataset ...\n" ] @@ -243,13 +252,19 @@ "metadata": {}, "outputs": [], "source": [ - "from bionemo.core.data.load import load\n", + "# NOTE: calling the load(...) function directly does not currently work for downloads through NGC in an interactive\n", + "# notebook environment. Get aound this below by calling the CLI download endpoint which executes in a subshell.\n", + "\n", "# 106m checkpoint\n", - "geneformer_106m = load(\"geneformer/106M_240530:2.0\")\n", + "geneformer_106m_out = !download_bionemo_data \"geneformer/106M_240530:2.0\"\n", "# 10m checkpoint\n", - "geneformer_10m = load(\"geneformer/10M_240530:2.0\")\n", + "geneformer_10m_out = !download_bionemo_data \"geneformer/10M_240530:2.0\" \n", "# 10m bionemo2 trained checkpoint\n", - "geneformer_10m_bnmo2 = load(\"geneformer/10M_241113:2.0\")" + "geneformer_10m_bnmo2_out = !download_bionemo_data \"geneformer/10M_241113:2.0\"\n", + "# Result includes a list of outputs, the last one is the path so grab that from each:\n", + "geneformer_106m = geneformer_106m_out[-1]\n", + "geneformer_10m = geneformer_10m_out[-1]\n", + "geneformer_10m_bnmo2 = geneformer_10m_bnmo2_out[-1]" ] }, { @@ -281,41 +296,41 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-13 21:26:55 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-13 21:26:57 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-11-19 20:15:40 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-11-19 20:15:42 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-13 21:26:58 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-13 21:26:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:26:58 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:26:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:26:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:26:58 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:26:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:26:58 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-11-19 20:15:43 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:15:43 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:15:43 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:15:43 infer_geneformer:77] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-13 21:26:58 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-13 21:26:58 megatron_strategy:287] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:314] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:320] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:325] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:328] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:336] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:339] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:340] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:347] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:348] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:357] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:361] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:362] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:382] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:394] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:400] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:401] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:402] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:26:58 megatron_init:403] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-11-19 20:15:43 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-11-19 20:15:43 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:15:43 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", @@ -323,13 +338,14 @@ "----------------------------------------------------------------------------------------------------\n", "\n", "WARNING: Logging before flag parsing goes to stderr.\n", - "W1113 21:26:58.640953 127959244657088 config.py:85] Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-11-13 21:26:59 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-11-13 21:26:59 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", + "W1119 20:15:43.544375 140002805535168 config.py:85] Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2024-11-19 20:15:44 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo W 2024-11-19 20:15:44 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", " warnings.warn(\n", " \n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo I 2024-11-13 21:26:59 megatron_parallel:404] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", + "[NeMo W 2024-11-19 20:15:44 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-11-19 20:15:44 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m.pt\n" ] } @@ -349,41 +365,41 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-13 21:27:15 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-13 21:27:16 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-11-19 20:16:18 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-11-19 20:16:19 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-13 21:27:17 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-13 21:27:17 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:17 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:27:17 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:17 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:17 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:27:17 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:17 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-11-19 20:16:20 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:20 infer_geneformer:77] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-13 21:27:17 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-13 21:27:17 megatron_strategy:287] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:314] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:320] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:325] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:328] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:336] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:339] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:340] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:347] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:348] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:357] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:361] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:362] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:382] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:394] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:400] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:401] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:402] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:17 megatron_init:403] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-11-19 20:16:20 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-11-19 20:16:20 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:20 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", @@ -391,13 +407,14 @@ "----------------------------------------------------------------------------------------------------\n", "\n", "WARNING: Logging before flag parsing goes to stderr.\n", - "W1113 21:27:17.893857 134759485260224 config.py:85] Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", - "[NeMo I 2024-11-13 21:27:18 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-11-13 21:27:18 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", + "W1119 20:16:21.268678 140005924843968 config.py:85] Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", + "[NeMo I 2024-11-19 20:16:22 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo W 2024-11-19 20:16:22 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", " warnings.warn(\n", " \n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo I 2024-11-13 21:27:18 megatron_parallel:404] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", + "[NeMo W 2024-11-19 20:16:22 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-11-19 20:16:22 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_bnmo2.pt\n" ] } @@ -415,50 +432,51 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-13 21:27:34 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-13 21:27:35 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-11-19 20:16:55 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-11-19 20:16:57 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-13 21:27:36 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-13 21:27:36 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:36 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:27:36 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:36 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:36 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:27:36 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:36 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-11-19 20:16:58 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:58 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:58 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:16:58 infer_geneformer:77] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-13 21:27:36 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-13 21:27:36 megatron_strategy:287] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:314] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:320] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:325] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:328] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:336] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:339] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:340] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:347] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:348] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:357] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:361] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:362] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:382] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:394] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:400] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:401] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:402] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:36 megatron_init:403] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-11-19 20:16:58 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-11-19 20:16:58 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:16:58 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "[NeMo I 2024-11-13 21:27:37 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo I 2024-11-19 20:16:58 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo I 2024-11-13 21:27:37 megatron_parallel:404] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", + "[NeMo W 2024-11-19 20:16:58 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-11-19 20:16:58 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_randomweights.pt\n" ] } @@ -478,41 +496,41 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-13 21:27:52 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-13 21:27:53 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-11-19 20:17:31 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-11-19 20:17:32 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-13 21:27:54 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-13 21:27:54 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:54 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:27:54 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:54 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:54 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-13 21:27:54 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-13 21:27:54 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-11-19 20:17:33 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:17:33 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:17:33 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-11-19 20:17:33 infer_geneformer:77] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-13 21:27:54 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-13 21:27:55 megatron_strategy:287] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:314] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:320] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:325] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:328] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:336] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:339] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:340] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:347] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:348] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:357] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:361] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:362] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:382] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:394] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:400] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:401] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:402] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-13 21:27:55 megatron_init:403] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-11-19 20:17:33 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-11-19 20:17:33 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-11-19 20:17:33 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", @@ -520,13 +538,14 @@ "----------------------------------------------------------------------------------------------------\n", "\n", "WARNING: Logging before flag parsing goes to stderr.\n", - "W1113 21:27:55.323093 137854406500800 config.py:85] Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-11-13 21:27:56 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-11-13 21:27:56 nemo_logging:349] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", + "W1119 20:17:33.781779 138558727221696 config.py:85] Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2024-11-19 20:17:34 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo W 2024-11-19 20:17:34 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", " warnings.warn(\n", " \n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo I 2024-11-13 21:27:56 megatron_parallel:404] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n", + "[NeMo W 2024-11-19 20:17:35 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-11-19 20:17:35 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n", "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_106m.pt\n" ] } @@ -735,7 +754,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_218125/2938980837.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", + "/tmp/ipykernel_369269/2938980837.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", " ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='right')\n" ] }, @@ -900,7 +919,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_218125/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_369269/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" ] }, @@ -966,7 +985,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_218125/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_369269/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" ] }, @@ -1084,7 +1103,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_218125/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_369269/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" ] }, @@ -1162,12 +1181,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_218125/805283967.py:42: FutureWarning: \n", + "/tmp/ipykernel_369269/805283967.py:42: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", " sb.barplot(x='model', y='f1_score_mean', data=df, capsize=0.2, palette='viridis', ax=ax)\n", - "/tmp/ipykernel_218125/805283967.py:53: FutureWarning: \n", + "/tmp/ipykernel_369269/805283967.py:53: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", diff --git a/docs/docs/user-guide/getting-started/access-startup.md b/docs/docs/user-guide/getting-started/access-startup.md index d5b20faf55..34b40ec0e8 100644 --- a/docs/docs/user-guide/getting-started/access-startup.md +++ b/docs/docs/user-guide/getting-started/access-startup.md @@ -11,11 +11,13 @@ BioNeMo Framework and begin exploring its features and capabilities. ## Access the BioNeMo Framework -To access the BioNeMo Framework container, you will need a free NVIDIA GPU Cloud (NGC) account and an API key linked to -that account. +### Brev.Dev Access +The BioNeMo Framework container can run in a brev.dev launchable: [![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy/now?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU). It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credit. After launching the instance, launch a Terminal session in the Jupyter Lab UI. (Note: This links to the nightly release and may be out of sync with these docs.) ### NGC Account and API Key Configuration +Another option to access the BioNeMo Framework container is to use a free NVIDIA GPU Cloud (NGC) account and an API key linked to that account. + NGC is a portal of enterprise services, software, and support for artificial intelligence and high-performance computing (HPC) workloads. The BioNeMo Docker container is hosted on the NGC Container Registry. To pull and run a container from this registry, you will need to create a free NGC account and an API Key using the following steps: diff --git a/docs/docs/user-guide/getting-started/initialization-guide.md b/docs/docs/user-guide/getting-started/initialization-guide.md index 2925a1256f..1c34ef177f 100644 --- a/docs/docs/user-guide/getting-started/initialization-guide.md +++ b/docs/docs/user-guide/getting-started/initialization-guide.md @@ -174,7 +174,7 @@ docker run --rm -d --gpus all \ -v $LOCAL_MODELS_PATH:$DOCKER_MODELS_PATH \ -v $LOCAL_RESULTS_PATH:$DOCKER_RESULTS_PATH \ {{ docker_url }}:{{ docker_tag }} \ - "jupyter lab \ + jupyter lab \ --allow-root \ --ip=* \ --port=$JUPYTER_PORT \ @@ -182,12 +182,12 @@ docker run --rm -d --gpus all \ --NotebookApp.token='' \ --NotebookApp.allow_origin='*' \ --ContentsManager.allow_hidden=True \ - --notebook-dir=$DOCKER_RESULTS_PATH" + --notebook-dir=$DOCKER_RESULTS_PATH ``` Refer to the guide below for an explanation of the recommended Jupyter Lab options: -* `"jupyter lab ..."`: The command to run inside the container, which starts a Jupyter Lab server. The options are: +* `jupyter lab ...`: The command to run inside the container, which starts a Jupyter Lab server. The options are: + `--allow-root`: Allow the Jupyter Lab server to run as the root user. + `--ip=*`: Listen on all available network interfaces, which allows access from outside the container. + `--port=$JUPYTER_PORT`: Listen on port 8888. diff --git a/internal/scripts/build_dev_image.sh b/internal/scripts/build_dev_image.sh index c4a6fa0771..f7c8e85653 100755 --- a/internal/scripts/build_dev_image.sh +++ b/internal/scripts/build_dev_image.sh @@ -10,6 +10,7 @@ DOCKER_BUILDKIT=1 docker buildx build \ -t "nvcr.io/nvidian/cvai_bnmo_trng/bionemo:dev-bionemo2-${COMMIT}" \ --target="development" \ --load \ + --cache-from nvcr.io/nvidia/clara/bionemo-framework:nightly \ --cache-to type=inline \ --label com.nvidia.bionemo.git_sha=${COMMIT} \ --label com.nvidia.bionemo.created_at=${DATE} \ diff --git a/pyproject.toml b/pyproject.toml index 342e95505c..c4b9f6e6af 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,6 +56,7 @@ bionemo-fw = { workspace = true } bionemo-geneformer = { workspace = true } bionemo-geometric = { workspace = true } bionemo-llm = { workspace = true } +bionemo-noodles = { workspace = true } bionemo-scdl = { workspace = true } bionemo-size-aware-batching = { workspace = true } bionemo-testing = { workspace = true } @@ -130,6 +131,7 @@ executionEnvironments = [ './sub-packages/bionemo-geneformer/src', './sub-packages/bionemo-geometric/src', './sub-packages/bionemo-llm/src', + './sub-packages/bionemo-noodles/src', './sub-packages/bionemo-scdl/src', './sub-packages/bionemo-size-aware-batching/src', './sub-packages/bionemo-testing/src', diff --git a/requirements-cve.txt b/requirements-cve.txt index 478254ae0b..e8228799f7 100644 --- a/requirements-cve.txt +++ b/requirements-cve.txt @@ -5,3 +5,6 @@ jupyterlab>=3.6.8 jupyter_server>=2.14.1 # https://github.com/advisories/GHSA-hrw6-wg82-cm62 Werkzeug>=3.0.3 nltk>=3.9.1 +pillow>=10.3.0 +tornado>=6.4.2 +wandb>=0.19.1 # Addresses CVE GHSA-v778-237x-gjrc diff --git a/requirements-dev.txt b/requirements-dev.txt index e8b6e13e5d..ad7b93282c 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,4 +1,4 @@ -ruff==0.0.292 +ruff==0.5.1 # Needs to match the version of ruff used in .pre-commit-config.yaml. black==23.1.0 pre-commit==3.4.0 virtualenv==20.26.3 @@ -6,3 +6,4 @@ ipdb==0.13.11 click==8.1.7 tenacity==8.5.0 tach>=0.9.0 +maturin==1.7.4 diff --git a/requirements-test.txt b/requirements-test.txt index 7eb0bedc4f..b8663cecf6 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -6,3 +6,5 @@ requests_mock==1.11.0 # For SwiftStack access awscli==1.33.33 nbval==0.11.0 +# For NvFaidx equivalence tests +pyfaidx==0.8.1.3 diff --git a/scripts/gpt-pretrain.py b/scripts/gpt-pretrain.py index 9c7f13bdfb..e856000a1e 100644 --- a/scripts/gpt-pretrain.py +++ b/scripts/gpt-pretrain.py @@ -17,19 +17,19 @@ from pathlib import Path from typing import List, Optional, Sequence, TypedDict +import lightning.pytorch as pl import numpy as np -import pytorch_lightning as pl import torch + +# In lightning.pytorch 2.0 these are commented as being "any iterable or collection of iterables" +# for now we'll use them incase the lightning type becomes something more specific in a future release. +from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS from nemo import lightning as nl from nemo.collections import llm from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning.megatron_parallel import DataT from nemo.lightning.pytorch.plugins import MegatronDataSampler - -# In pytorch_lightning 2.0 these are commented as being "any iterable or collection of iterables" -# for now we'll use them incase the lightning type becomes something more specific in a future release. -from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS from torch.utils import data from torch.utils.data import DataLoader, Dataset diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/load.py b/sub-packages/bionemo-core/src/bionemo/core/data/load.py index f942a0426f..f4c8731d5b 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/load.py +++ b/sub-packages/bionemo-core/src/bionemo/core/data/load.py @@ -15,6 +15,7 @@ import argparse import contextlib +import os import shutil import sys import tempfile @@ -39,6 +40,8 @@ "default_pbss_client", "NGCDownloader", ) +SourceOptions = Literal["ngc", "pbss"] +DEFAULT_SOURCE: SourceOptions = os.environ.get("BIONEMO_DATA_SOURCE", "ngc") # type: ignore def default_pbss_client(): @@ -109,7 +112,7 @@ def __call__(self, url: str, output_file: str | Path, _: pooch.Pooch) -> None: def load( model_or_data_tag: str, - source: Literal["ngc", "pbss"] = "pbss", + source: SourceOptions = DEFAULT_SOURCE, resources: dict[str, Resource] | None = None, cache_dir: Path | None = None, ) -> Path: diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml index 90c822e9e7..bb3b4467e3 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml @@ -40,3 +40,11 @@ sha256: 006911f92bbc0ded7ea302bbdbfab4c694b409e699c32fd49de1c527a99dba3e # pragma: allowlist secret owner: Peter St John description: Test data for ESM2 pretraining. + +- tag: esm2_inference_testdata:2.0 + ngc: nvidia/clara/esm2_inference_testdata:2.0 # TODO: upload to NGC + ngc_registry: resource + pbss: "s3://bionemo-ci/test_data/esm2/artificial_protein_sequences.csv" + sha256: 14ae3acfbf82218bc9e3e53d21a5b0594ba7c0369e169c9f1034e3fe4378d175 # pragma: allowlist secret + owner: Farhad Ramezanghorbani + description: Test data for ESM2 inference. diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py index ae413d8147..ee8146b5dd 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py @@ -110,7 +110,7 @@ def test_load_with_file(mocked_s3_download, tmp_path): ) mocked_s3_download.side_effect = lambda _1, output_file, _2: Path(output_file).write_text("test") - file_path = load("foo/bar", resources=get_all_resources(tmp_path), cache_dir=tmp_path) + file_path = load("foo/bar", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_file() assert file_path.read_text() == "test" @@ -132,7 +132,7 @@ def write_compressed_text(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_text - file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path) + file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_file() assert file_path.read_text() == "test" @@ -155,7 +155,7 @@ def write_compressed_text(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_text - file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path) + file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") # Assert the file remained compressed. assert file_path.is_file() @@ -190,7 +190,7 @@ def write_compressed_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_dir - file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path) + file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_dir() assert (file_path / "test_file").read_text() == "test" @@ -223,7 +223,7 @@ def write_tarfile_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_tarfile_dir - file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path) + file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") # Assert the file stays as a tarfile. assert file_path.is_file() @@ -259,7 +259,7 @@ def write_compressed_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_dir - file_path = load("foo/dir.gz", resources=get_all_resources(tmp_path), cache_dir=tmp_path) + file_path = load("foo/dir.gz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_dir() assert (file_path / "test_file").read_text() == "test" @@ -269,6 +269,7 @@ def test_default_pbss_client(): assert client.meta.endpoint_url == "https://pbss.s8k.io" +@pytest.mark.xfail(reason="Logging into NGC is not required to download artifacts in BioNeMo.") def test_default_ngc_client(): clt = default_ngc_client() assert clt.api_key is not None diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb index 7d61836dfc..9d4dcf5cfe 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -21,8 +21,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "Downloading data from 'nvidia/clara/esm2_pretrain_nemo2_testdata:1.0' to file '/tmp/tmp_v_0_64q/dc23f4aaad387ecc12e53d56b8176430-esm2_pretrain_nemo2_testdata:1.0'.\n", - "Untarring contents of '/tmp/tmp_v_0_64q/dc23f4aaad387ecc12e53d56b8176430-esm2_pretrain_nemo2_testdata:1.0' to '/tmp/tmp_v_0_64q/dc23f4aaad387ecc12e53d56b8176430-esm2_pretrain_nemo2_testdata:1.0.untar'\n" + "Downloading data from 'nvidia/clara/scdl_sample_test:1.0' to file '/tmp/tmpqif5bfww/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz'.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Untarring contents of '/tmp/tmpqif5bfww/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz' to '/tmp/tmpqif5bfww/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz.untar'\n" ] }, { @@ -30,22 +36,20 @@ "output_type": "stream", "text": [ "{\n", - " \"download_end\": \"2024-11-07 19:13:48\",\n", - " \"download_start\": \"2024-11-07 19:13:46\",\n", - " \"download_time\": \"2s\",\n", + " \"download_end\": \"2024-12-03 18:39:20\",\n", + " \"download_start\": \"2024-12-03 18:39:03\",\n", + " \"download_time\": \"17s\",\n", " \"files_downloaded\": 1,\n", - " \"local_path\": \"/tmp/tmp_v_0_64q/tmpgadmjb1k/esm2_pretrain_nemo2_testdata_v1.0\",\n", - " \"size_downloaded\": \"69.91 MB\",\n", + " \"local_path\": \"/tmp/tmpqif5bfww/tmprn0ysh0w/scdl_sample_test_v1.0\",\n", + " \"size_downloaded\": \"964.91 KB\",\n", " \"status\": \"COMPLETED\"\n", "}\n" ] } ], "source": [ - "# xfail -- we need to file a bug or figure out how to call the ngcsdk from a jupyter notebook\n", - "# NBVAL_RAISES_EXCEPTION\n", "with tempfile.TemporaryDirectory() as cache_dir:\n", - " load(\"esm2/testdata_esm2_pretrain:2.0\", source=\"ngc\", cache_dir=Path(cache_dir))" + " load(\"scdl/sample\", source=\"ngc\", cache_dir=Path(cache_dir))" ] }, { @@ -57,15 +61,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "Downloading data from 's3://general-purpose/esm2/pretrain/2024_03_sanity.tar.gz' to file '/tmp/tmpjnvk7m8k/f796e1ca28311606ff7dd62a067508bf-2024_03_sanity.tar.gz'.\n", - "s3://general-purpose/esm2/pretrain/2024_03_sanity.tar.gz: 100%|██████████| 73.3M/73.3M [00:01<00:00, 38.7MB/s]\n", - "Untarring contents of '/tmp/tmpjnvk7m8k/f796e1ca28311606ff7dd62a067508bf-2024_03_sanity.tar.gz' to '/tmp/tmpjnvk7m8k/f796e1ca28311606ff7dd62a067508bf-2024_03_sanity.tar.gz.untar'\n" + "Downloading data from 's3://bionemo-ci/test-data/scdl_sample_test.tar.gz' to file '/tmp/tmpl6cgwhyn/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz'.\n", + "s3://bionemo-ci/test-data/scdl_sample_test.tar.gz: 100%|██████████| 988k/988k [00:00<00:00, 2.70MB/s]\n", + "Untarring contents of '/tmp/tmpl6cgwhyn/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz' to '/tmp/tmpl6cgwhyn/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz.untar'\n" ] } ], "source": [ "with tempfile.TemporaryDirectory() as cache_dir:\n", - " load(\"esm2/testdata_esm2_pretrain:2.0\", source=\"pbss\", cache_dir=Path(cache_dir))" + " load(\"scdl/sample\", source=\"pbss\", cache_dir=Path(cache_dir))" ] } ], diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py index e065702d3d..ac08ffb47e 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py @@ -18,10 +18,10 @@ import os from typing import Literal +from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS from nemo.lightning.data import WrappedDataLoader from nemo.lightning.pytorch.plugins import MegatronDataSampler from nemo.utils import logging -from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS from bionemo.esm2.data import dataset, tokenizer from bionemo.llm.data import collate @@ -156,24 +156,27 @@ def setup(self, stage: str = "") -> None: # Create validation dataset val_clusters = dataset.create_valid_clusters(self._valid_cluster_path) - num_val_samples = infer_num_samples( - limit_batches=self.trainer.limit_val_batches, - num_samples_in_dataset=len(val_clusters), - global_batch_size=self.data_sampler.global_batch_size, - stage="val", - ) - self._valid_ds = dataset.create_valid_dataset( - clusters=self._valid_cluster_path, - db_path=self._valid_database_path, - total_samples=num_val_samples, - seed=self._seed, - max_seq_length=self._max_seq_length, - mask_prob=self._mask_prob, - mask_token_prob=self._mask_token_prob, - mask_random_prob=self._mask_random_prob, - random_mask_strategy=self._random_mask_strategy, - tokenizer=self._tokenizer, - ) + if self.trainer.limit_val_batches == 0: # disable validation + logging.info("Skip creating validation dataset because trainer.limit_val_batches=0.") + else: + num_val_samples = infer_num_samples( + limit_batches=self.trainer.limit_val_batches, + num_samples_in_dataset=len(val_clusters), + global_batch_size=self.data_sampler.global_batch_size, + stage="val", + ) + self._valid_ds = dataset.create_valid_dataset( + clusters=self._valid_cluster_path, + db_path=self._valid_database_path, + total_samples=num_val_samples, + seed=self._seed, + max_seq_length=self._max_seq_length, + mask_prob=self._mask_prob, + mask_token_prob=self._mask_token_prob, + mask_random_prob=self._mask_random_prob, + random_mask_strategy=self._random_mask_strategy, + tokenizer=self._tokenizer, + ) assert ( hasattr(self, "trainer") and self.trainer is not None diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py index 8f4e019f5f..602c56a134 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py @@ -16,15 +16,16 @@ import functools import os -from typing import Sequence, Tuple, Union +from typing import Literal, Sequence, Tuple, Union import numpy as np import pandas as pd import torch import torch.utils.data +from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS +from nemo.lightning.data import WrappedDataLoader from nemo.lightning.pytorch.plugins import MegatronDataSampler from nemo.utils import logging -from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS from torch import Tensor from torch.utils.data import Dataset @@ -38,6 +39,9 @@ from bionemo.llm.utils.datamodule_utils import infer_num_samples +Mode = Literal["train", "validation", "test", "predict"] + + class InMemoryCSVDataset(Dataset): """An in-memory dataset that tokenize strings into BertSample instances.""" @@ -224,7 +228,7 @@ def setup(self, stage: str) -> None: self._train_ds = self._create_epoch_based_dataset(self.train_dataset, num_train_samples) # Create validation dataset - if self.valid_dataset is not None: + if self.valid_dataset is not None and self.trainer.limit_val_batches != 0: num_val_samples = infer_num_samples( limit_batches=self.trainer.limit_val_batches, num_samples_in_dataset=len(self.valid_dataset), @@ -249,11 +253,21 @@ def _create_epoch_based_dataset( seed=self._seed, ) - def _create_dataloader(self, dataset, **kwargs) -> torch.utils.data.DataLoader: + def _create_dataloader(self, dataset, mode: Mode, **kwargs) -> WrappedDataLoader: + """Create dataloader for train, validation, and test stages. + + Args: + dataset: The dataset to create the dataloader for. + mode: Stage of training, which is used to determined if consumed_samples in MegatronPretrainingSampler should be initialized to 0 (validation/test), or be set to the previous value from state_dict in case of checkpoint resumption (train). + **kwargs: Additional arguments to pass to the dataloader. + """ + if mode not in ["predict", "test"]: + self.update_init_global_step() assert self._tokenizer.pad_token_id is not None, "Tokenizer must have a pad token id." - return torch.utils.data.DataLoader( - dataset, + return WrappedDataLoader( + mode=mode, + dataset=dataset, num_workers=self._num_workers, pin_memory=self._pin_memory, persistent_workers=self._persistent_workers, @@ -269,17 +283,17 @@ def _create_dataloader(self, dataset, **kwargs) -> torch.utils.data.DataLoader: def train_dataloader(self) -> TRAIN_DATALOADERS: """Returns the dataloader for training data.""" assert self._train_ds is not None, "train_dataset is not provided to ESM2FineTuneDataModule" - return self._create_dataloader(self._train_ds) + return self._create_dataloader(self._train_ds, mode="train") def val_dataloader(self) -> EVAL_DATALOADERS: """Returns the dataloader for validation data.""" assert self._valid_ds is not None, "valid_dataset is not provided to ESM2FineTuneDataModule" - return self._create_dataloader(self._valid_ds) + return self._create_dataloader(self._valid_ds, mode="validation") def predict_dataloader(self) -> EVAL_DATALOADERS: """Returns the dataloader for prediction data.""" assert self.predict_dataset is not None, "predict_dataset is not provided to ESM2FineTuneDataModule" - return self._create_dataloader(self.predict_dataset) + return self._create_dataloader(self.predict_dataset, mode="predict") def test_dataloader(self) -> EVAL_DATALOADERS: """Raises a not implemented error.""" diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/infer.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/infer.py deleted file mode 100644 index 40fd6023b1..0000000000 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/infer.py +++ /dev/null @@ -1,101 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -from typing import Sequence - -import pytorch_lightning as pl -from nemo import lightning as nl -from torch import Tensor - -from bionemo.esm2.api import ESM2GenericConfig -from bionemo.esm2.data.tokenizer import BioNeMoESMTokenizer, get_tokenizer -from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule -from bionemo.esm2.model.finetune.finetune_regressor import ESM2FineTuneSeqConfig, InMemorySingleValueDataset -from bionemo.llm.lightning import batch_collator -from bionemo.llm.model.biobert.lightning import biobert_lightning_module - - -__all__: Sequence[str] = ("infer_model",) - - -def infer_model( - config: ESM2GenericConfig, - data_module: pl.LightningDataModule, - tokenizer: BioNeMoESMTokenizer = get_tokenizer(), -) -> list[Tensor]: - """Infers a BioNeMo ESM2 model using PyTorch Lightning. - - Parameters: - config: The configuration for the ESM2 model. - data_module: The data module for training and validation. - tokenizer: The tokenizer to use. Defaults to `get_tokenizer()`. - - Returns: - A list of tensors containing the predictions of predict_dataset in datamodule - """ - strategy = nl.MegatronStrategy( - tensor_model_parallel_size=1, pipeline_model_parallel_size=1, ddp="megatron", find_unused_parameters=True - ) - - trainer = nl.Trainer( - accelerator="gpu", - devices=1, - strategy=strategy, - num_nodes=1, - plugins=nl.MegatronMixedPrecision(precision="bf16-mixed"), - ) - module = biobert_lightning_module(config=config, tokenizer=tokenizer) - results = batch_collator(trainer.predict(module, datamodule=data_module)) - - return results - - -if __name__ == "__main__": - # create a List[Tuple] with (sequence, target) values - artificial_sequence_data = [ - "TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "GRFNVWLGGNESKIRQVLKAVKEIGVSPTLFAVYEKN", - "DELTALGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "KLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LFGAIGNAISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "LGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "ISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "SGSKASSDSQDANQCCTSCEDNAPATSYCVECSEPLCETCVEAHQRVKYTKDHTVRSTGPAKT", - ] - data = [(seq, len(seq) / 100.0) for seq in artificial_sequence_data] - - dataset = InMemorySingleValueDataset(data) - - # NOTE: Due to the current limitation in inference of NeMo lightning module, partial batches with - # size < global_batch_size are not being processed with predict_step(). Therefore we set the global to len(data) - # and choose the micro_batch_size so that global batch size is divisible by micro batch size x data parallel size - data_module = ESM2FineTuneDataModule( - predict_dataset=dataset, global_batch_size=len(data), micro_batch_size=len(data) - ) - - # To download a pre-trained ESM2 model that works with this inference script, run the following command... - # $ download_bionemo_data esm2/650m:2.0 --source ngc - # ... and pass the output path (e.g. `.../.cache/bionemo/975d29ee980fcb08c97401bbdfdcf8ce-esm2_650M_nemo2.tar.gz.untar`) - # as an argument into `initial_ckpt_path` below! - config = ESM2FineTuneSeqConfig( - # initial_ckpt_path = finetuned_checkpoint, # supply the finetuned checkpoint path - # initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=list) # reset to avoid skipping the head params - ) - - results = infer_model(config, data_module) - print(results["regression_output"]) diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py index de74125549..638729e3f4 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py @@ -18,7 +18,9 @@ from pathlib import Path from typing import Sequence, Tuple -import pytorch_lightning as pl +import lightning.pytorch as pl +from lightning.pytorch.callbacks import Callback, RichModelSummary +from lightning.pytorch.loggers import TensorBoardLogger from megatron.core.optimizer.optimizer_config import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm as nllm @@ -28,9 +30,8 @@ from nemo.lightning.pytorch.callbacks.model_transform import ModelTransform from nemo.lightning.pytorch.callbacks.peft import PEFT from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule -from pytorch_lightning.callbacks import Callback, RichModelSummary -from pytorch_lightning.loggers import TensorBoardLogger +from bionemo.core.data.load import load from bionemo.esm2.api import ESM2GenericConfig from bionemo.esm2.data.tokenizer import BioNeMoESMTokenizer, get_tokenizer from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule @@ -147,6 +148,9 @@ def train_model( if __name__ == "__main__": + # set the results directory + experiment_results_dir = tempfile.TemporaryDirectory().name + # create a List[Tuple] with (sequence, target) values artificial_sequence_data = [ "TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", @@ -166,24 +170,20 @@ def train_model( dataset = InMemorySingleValueDataset(data) data_module = ESM2FineTuneDataModule(train_dataset=dataset, valid_dataset=dataset) - with tempfile.TemporaryDirectory() as experiment_tempdir_name: - experiment_dir = Path(experiment_tempdir_name) - experiment_name = "finetune_regressor" - n_steps_train = 50 - seed = 42 - - # To download a pre-trained ESM2 model that works with this inference script, run the following command... - # $ download_bionemo_data esm2/650m:2.0 --source ngc - # ... and pass the output path (e.g. `.../.cache/bionemo/975d29ee980fcb08c97401bbdfdcf8ce-esm2_650M_nemo2.tar.gz.untar`) - # as an argument into `initial_ckpt_path` below! - config = ESM2FineTuneSeqConfig( - # initial_ckpt_path=str(pretrain_ckpt_path) - ) + experiment_name = "finetune_regressor" + n_steps_train = 50 + seed = 42 - checkpoint, metrics, trainer = train_model( - experiment_name=experiment_name, - experiment_dir=experiment_dir, # new checkpoint will land in a subdir of this - config=config, # same config as before since we are just continuing training - data_module=data_module, - n_steps_train=n_steps_train, - ) + # To download a 650M pre-trained ESM2 model + pretrain_ckpt_path = load("esm2/650m:2.0") + + config = ESM2FineTuneSeqConfig(initial_ckpt_path=str(pretrain_ckpt_path)) + + checkpoint, metrics, trainer = train_model( + experiment_name=experiment_name, + experiment_dir=Path(experiment_results_dir), # new checkpoint will land in a subdir of this + config=config, # same config as before since we are just continuing training + data_module=data_module, + n_steps_train=n_steps_train, + ) + print(f"Experiment completed with checkpoint stored at {checkpoint}") diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py index 66c11c317d..d0999c2773 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py @@ -72,6 +72,7 @@ def __init__( add_binary_head: bool = True, return_embeddings: bool = False, include_embeddings: bool = False, + include_input_ids: bool = False, use_full_attention_mask: bool = False, include_hiddens: bool = False, skip_logits: bool = False, @@ -98,6 +99,7 @@ def __init__( add_binary_head (bool): Whether to add a binary head. Defaults to True. return_embeddings (bool): Whether to return embeddings. Defaults to False. include_embeddings (bool): Whether to include embeddings in the output dictionary. Defaults to False. + include_input_ids (bool): Whether to include input_ids in the output dictionary. Defaults to False. use_full_attention_mask (bool): Whether to use full attention mask. Defaults to False. include_hiddens (bool): Whether to include hidden states in the output dictionary. Defaults to False. skip_logits (bool): Skip writing the token logits in output dict @@ -125,6 +127,7 @@ def __init__( self.return_embeddings = return_embeddings self.include_embeddings = include_embeddings self.include_hiddens = include_hiddens + self.include_input_ids = include_input_ids self.skip_logits = skip_logits # megatron core pipelining currently depends on model type @@ -324,6 +327,7 @@ class ESM2GenericConfig(BioBertConfig[ESM2ModelT, MegatronLossType]): # things as part of the workflow for inference and fine-tuning. return_embeddings: bool = False include_embeddings: bool = False + include_input_ids: bool = False skip_logits: bool = False return_only_hidden_states: bool = False # return logits diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py index 7437e75f3e..5ba6739164 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py @@ -32,6 +32,8 @@ DataConfig, ExposedModelConfig, MainConfig, + deserialize_str_to_path, + serialize_path_or_str, ) @@ -63,12 +65,32 @@ class ESM2DataConfig(DataConfig[ESMDataModule]): valid_database_path: Path micro_batch_size: int = 8 - result_dir: str = "./results" + result_dir: str | Path = "./results" min_seq_length: int = 128 max_seq_length: int = 128 random_mask_strategy: RandomMaskStrategy = RandomMaskStrategy.ALL_TOKENS num_dataset_workers: int = 0 + @field_serializer( + "train_cluster_path", "train_database_path", "valid_cluster_path", "valid_database_path", "result_dir" + ) + def serialize_paths(self, value: Path) -> str: # noqa: D102 + return serialize_path_or_str(value) + + @field_validator( + "train_cluster_path", "train_database_path", "valid_cluster_path", "valid_database_path", "result_dir" + ) + def deserialize_paths(cls, value: str) -> Path: # noqa: D102 + return deserialize_str_to_path(value) + + @field_serializer("random_mask_strategy") + def serialize_spec_option(self, value: RandomMaskStrategy) -> str: # noqa: D102 + return value.value + + @field_validator("random_mask_strategy", mode="before") + def deserialize_spec_option(cls, value: str) -> RandomMaskStrategy: # noqa: D102 + return RandomMaskStrategy(value) + def construct_data_module(self, global_batch_size: int) -> ESMDataModule: """Constructs and returns an ESMDataModule instance with the provided global batch size. diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py index 5820e48438..857db8ad48 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py @@ -15,9 +15,10 @@ import argparse -import json from typing import Optional +import yaml + from bionemo.esm2.run.config_models import ESM2DataConfig, ExposedESM2PretrainConfig from bionemo.llm.run.config_models import MainConfig from bionemo.llm.train import NsysConfig, train @@ -28,13 +29,13 @@ def parse_args(): parser = argparse.ArgumentParser(description="Run ESM2 pretraining") parser.add_argument("--config", type=str, required=True, help="Path to the JSON configuration file") parser.add_argument( - "--model-config-t", + "--model-config-cls", default=ExposedESM2PretrainConfig, required=False, help="fully resolvable python import path to the ModelConfig object. Builtin options are ExposedESM2PretrainConfig.", ) parser.add_argument( - "--data-config-t", + "--data-config-cls", default=ESM2DataConfig, required=False, help="fully resolvable python import path to the ModelConfig object.", @@ -86,32 +87,32 @@ def string_to_class(path: str): module = importlib.import_module(module_path) return getattr(module, class_name) - def load_config(config_path: str, model_config_t: Optional[str], data_config_t: Optional[str]) -> MainConfig: + def load_config(config_path: str, model_config_cls: Optional[str], data_config_cls: Optional[str]) -> MainConfig: with open(config_path, "r") as f: - config_dict = json.load(f) + config_dict = yaml.safe_load(f) - # model/data_config_t is used to select the parser dynamically. - if model_config_t is None or model_config_t == "ExposedESM2PretrainConfig": - model_config_t = ExposedESM2PretrainConfig - elif model_config_t == "ExposedFineTuneSeqModel": + # model/data_config_cls is used to select the parser dynamically. + if model_config_cls is None or model_config_cls == "ExposedESM2PretrainConfig": + model_config_cls = ExposedESM2PretrainConfig + elif model_config_cls == "ExposedFineTuneSeqModel": # Hardcoded path for those who do not know the full path - # model_config_t = ExposedFineTuneSeqLenBioBertConfig + # model_config_cls = ExposedFineTuneSeqLenBioBertConfig raise NotImplementedError() - elif model_config_t == "ExposedFineTuneTokenModel": + elif model_config_cls == "ExposedFineTuneTokenModel": raise NotImplementedError() - elif isinstance(model_config_t, str): + elif isinstance(model_config_cls, str): # We assume we get a string to some importable config... e.g. in the sub-package jensen, 'bionemo.jensen.configs.MyConfig' - model_config_t = string_to_class(model_config_t) + model_config_cls = string_to_class(model_config_cls) - if data_config_t is None: - data_config_t = ESM2DataConfig - elif isinstance(data_config_t, str): - data_config_t = string_to_class(data_config_t) + if data_config_cls is None: + data_config_cls = ESM2DataConfig + elif isinstance(data_config_cls, str): + data_config_cls = string_to_class(data_config_cls) - return MainConfig[model_config_t, data_config_t](**config_dict) + return MainConfig[model_config_cls, data_config_cls](**config_dict) args = parse_args() - config = load_config(args.config, args.model_config_t, args.data_config_t) + config = load_config(args.config, args.model_config_cls, args.data_config_cls) if args.nsys_profiling: nsys_config = NsysConfig( diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/recipes.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/recipes.py index 9473cc69ce..e5cca198d3 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/recipes.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/recipes.py @@ -15,10 +15,13 @@ import argparse +from functools import partial from pathlib import Path -from typing import Optional +from typing import Callable, Optional +import yaml from nemo.utils import logging +from pydantic import BaseModel from bionemo.core.utils.dtypes import PrecisionTypes from bionemo.esm2.run.config_models import ESM2DataConfig, ExposedESM2PretrainConfig @@ -33,10 +36,10 @@ from bionemo.llm.utils.logger_utils import WandbConfig -def esm2_base_training_config() -> TrainingConfig: +def esm2_base_training_config(max_steps: int = 500000) -> TrainingConfig: """Base training config for ESM2.""" return TrainingConfig( - max_steps=500000, + max_steps=max_steps, limit_val_batches=1.0, val_check_interval=10_000, precision="bf16-mixed", @@ -44,10 +47,16 @@ def esm2_base_training_config() -> TrainingConfig: ) -def esm2_base_optimizer_scheduler_config() -> OptimizerSchedulerConfig: +def esm2_base_optimizer_scheduler_config(max_steps: Optional[int] = None) -> OptimizerSchedulerConfig: """Base optimizer scheduler config for ESM2.""" return OptimizerSchedulerConfig( - optimizer="adam", lr=4e-4, interval="step", monitor="val_loss", lr_scheduler="warmup_anneal", warmup_steps=2000 + optimizer="adam", + lr=4e-4, + interval="step", + monitor="val_loss", + lr_scheduler="warmup_anneal", + warmup_steps=2000, + max_steps=max_steps, ) @@ -125,9 +134,9 @@ def esm2_8m_recipe(args) -> MainConfig[ExposedESM2PretrainConfig, ESM2DataConfig return MainConfig( data_config=esm2_base_data_config(args), parallel_config=esm2_base_parallel_config(), - training_config=esm2_base_training_config(), # no changes for 8m + training_config=esm2_base_training_config(max_steps=args.max_steps), # no changes for 8m bionemo_model_config=esm2_8m_model_config(args.initial_ckpt_path), - optim_config=esm2_base_optimizer_scheduler_config(), # no changes for 8m + optim_config=esm2_base_optimizer_scheduler_config(max_steps=args.scheduler_max_steps), # no changes for 8m experiment_config=esm2_8m_experiment_config(args.result_dir), wandb_config=esm2_8m_wandb_config(), ) @@ -180,9 +189,9 @@ def esm2_650m_recipe(args) -> MainConfig[ExposedESM2PretrainConfig, ESM2DataConf return MainConfig( data_config=esm2_base_data_config(args), parallel_config=esm2_base_parallel_config(), - training_config=esm2_base_training_config(), # no changes for 8m + training_config=esm2_base_training_config(max_steps=args.max_steps), # no changes for 8m bionemo_model_config=esm2_650m_model_config(args.initial_ckpt_path), - optim_config=esm2_base_optimizer_scheduler_config(), # no changes for 8m + optim_config=esm2_base_optimizer_scheduler_config(max_steps=args.scheduler_max_steps), # no changes for 8m experiment_config=esm2_650m_experiment_config(args.result_dir), wandb_config=esm2_650m_wandb_config(), ) @@ -248,9 +257,9 @@ def esm2_3b_recipe(args) -> MainConfig[ExposedESM2PretrainConfig, ESM2DataConfig return MainConfig( data_config=esm2_base_data_config(args), parallel_config=esm2_3b_parallel_config(), - training_config=esm2_base_training_config(), # no changes for 8m + training_config=esm2_base_training_config(max_steps=args.max_steps), # no changes for 8m bionemo_model_config=esm2_3b_model_config(args.initial_ckpt_path), - optim_config=esm2_base_optimizer_scheduler_config(), # no changes for 8m + optim_config=esm2_base_optimizer_scheduler_config(max_steps=args.scheduler_max_steps), # no changes for 8m experiment_config=esm2_3b_experiment_config(args.result_dir), wandb_config=esm2_3b_wandb_config(), ) @@ -279,9 +288,9 @@ def tiny_train_config_recipe() -> TrainingConfig: return TrainingConfig(max_steps=10, limit_val_batches=2, val_check_interval=2) -def default_adam_optimizer_with_cosine_annealing_recipe() -> OptimizerSchedulerConfig: +def default_adam_optimizer_with_cosine_annealing_recipe(max_steps: Optional[int] = None) -> OptimizerSchedulerConfig: """Default optimizer scheduler config for ESM2.""" - return OptimizerSchedulerConfig() + return OptimizerSchedulerConfig(max_steps=max_steps) def experiment_config_recipe(result_dir="./results") -> ExperimentConfig: @@ -344,7 +353,7 @@ def esm2_tiny_test_recipe(args): seq_length=data_config.max_seq_length, initial_ckpt_path=args.initial_ckpt_path ) - optim_config = default_adam_optimizer_with_cosine_annealing_recipe() + optim_config = default_adam_optimizer_with_cosine_annealing_recipe(max_steps=args.scheduler_max_steps) experiment_config = experiment_config_recipe(args.result_dir) wandb_config = WandbConfig( project="bionemo2-demo", @@ -368,13 +377,35 @@ def esm2_tiny_test_recipe(args): return main_config +class ESM2Recipes(BaseModel): + """Pre-baked recipes for ESM2. + + THIS PYDANTIC MODEL IS NOT MEANT FOR SERIALIZATION. Only used to facilitate argparse. Each recipe should take `args` + as the only argument. We use partials so we can provide this information at runtime. Add new recipes to this model. + """ + + # Use partials so we can still parameterize the recipes from the CLI (e.g. data paths.) + esm2_tiny_test_recipe: Callable[[argparse.Namespace], MainConfig[ExposedESM2PretrainConfig, ESM2DataConfig]] = ( + partial(esm2_tiny_test_recipe) + ) + esm2_8m_recipe: Callable[[argparse.Namespace], MainConfig[ExposedESM2PretrainConfig, ESM2DataConfig]] = partial( + esm2_8m_recipe + ) + esm2_650m_recipe: Callable[[argparse.Namespace], MainConfig[ExposedESM2PretrainConfig, ESM2DataConfig]] = partial( + esm2_650m_recipe + ) + esm2_3b_recipe: Callable[[argparse.Namespace], MainConfig[ExposedESM2PretrainConfig, ESM2DataConfig]] = partial( + esm2_3b_recipe + ) + + def main(): # noqa: D103 def parse_args(): - parser = argparse.ArgumentParser(description="Create ESM2 configuration JSON.") + parser = argparse.ArgumentParser(description="Create ESM2 configuration YAML.") parser.add_argument( "--recipe", type=str, - choices=["test", "8m", "650m", "3b"], + choices=ESM2Recipes.model_fields.keys(), required=True, help="Use one of the preconfigured recipes to create a template config file.", ) @@ -382,9 +413,9 @@ def parse_args(): parser.add_argument( "--dest", type=str, - default="./esm2-recipe.json", + default="./esm2-recipe.yaml", required=True, - help="Path to the JSON configuration file.", + help="Path to the YAML configuration file.", ) parser.add_argument( @@ -411,33 +442,32 @@ def parse_args(): help="Path to an existing to a checkpoint directory to restore an existing checkpoint. Not compatible with all recipes.", ) + parser.add_argument( + "--max-steps", type=int, required=False, default=500000, help="Max steps for training. Default to 500000." + ) + + parser.add_argument( + "--scheduler-max-steps", + type=int, + required=False, + help="Set scheduler max_steps directly. Otherwise default to None, which uses max_steps from training config.", + ) + args = parser.parse_args() return args - # Simple example for creating a JSON from recipes. + # Simple example for creating a YAML from recipes. args = parse_args() - - if args.recipe == "8m": - config = esm2_8m_recipe(args) - elif args.recipe == "650m": - config = esm2_650m_recipe(args) - elif args.recipe == "3b": - config = esm2_3b_recipe(args) - elif args.recipe == "test": - # Hardcoded test recipe. - config = esm2_tiny_test_recipe(args) - else: - raise ValueError(f"Invalid recipe choice. {args.recipe=}") - - # Serialize to JSON - json_str = config.model_dump_json(indent=2) + config_partial: Callable[[argparse.Namespace], MainConfig] = ESM2Recipes().__getattribute__(args.recipe) + config = config_partial(args) # Save to file with open( args.dest, "w", ) as f: - f.write(json_str) + yaml.dump(config.model_dump(), f, indent=2) + logging.info(f"Saved configuration to {args.dest=}") diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py index 383ac84dcc..70501dce50 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py @@ -51,6 +51,7 @@ def infer_model( include_hiddens: bool = False, include_embeddings: bool = False, include_logits: bool = False, + include_input_ids: bool = False, micro_batch_size: int = 64, precision: PrecisionTypes = "bf16-mixed", tensor_model_parallel_size: int = 1, @@ -69,6 +70,7 @@ def infer_model( include_hiddens (bool, optional): Whether to include hidden states in the output. Defaults to False. include_embeddings (bool, optional): Whether to include embeddings in the output. Defaults to False. include_logits (bool, Optional): Whether to include token logits in the output. Defaults to False. + include_input_ids (bool, Optional): Whether to include input_ids in the output. Defaults to False. micro_batch_size (int, optional): Micro batch size for inference. Defaults to 64. precision (PrecisionTypes, optional): Precision type for inference. Defaults to "bf16-mixed". tensor_model_parallel_size (int, optional): Tensor model parallel size for distributed inference. Defaults to 1. @@ -122,6 +124,7 @@ def infer_model( autocast_dtype=get_autocast_dtype(precision), include_hiddens=include_hiddens, include_embeddings=include_embeddings, + include_input_ids=include_input_ids, skip_logits=not include_logits, tensor_model_parallel_size=tensor_model_parallel_size, pipeline_model_parallel_size=pipeline_model_parallel_size, @@ -152,6 +155,7 @@ def infer_esm2_entrypoint(): include_hiddens=args.include_hiddens, include_embeddings=args.include_embeddings, include_logits=args.include_logits, + include_input_ids=args.include_input_ids, micro_batch_size=args.micro_batch_size, precision=args.precision, tensor_model_parallel_size=args.tensor_model_parallel_size, @@ -228,6 +232,12 @@ def get_parser(): default=False, help="Include hiddens in output of inference", ) + parser.add_argument( + "--include-input-ids", + action="store_true", + default=False, + help="Include input_ids in output of inference", + ) parser.add_argument( "--include-embeddings", action="store_true", diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py index 7fbaf83cd3..7d05455924 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py @@ -17,13 +17,13 @@ from pathlib import Path from typing import List, Optional, Sequence, get_args +from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm from nemo.lightning import resume from nemo.lightning.pytorch import callbacks as nl_callbacks from nemo.lightning.pytorch.optim import MegatronOptimizerModule -from pytorch_lightning.callbacks import LearningRateMonitor, RichModelSummary from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype from bionemo.esm2.api import ESM2Config @@ -52,12 +52,13 @@ def main( max_seq_length: int, result_dir: Path, num_steps: int, + scheduler_num_steps: Optional[int], warmup_steps: int, limit_val_batches: int, val_check_interval: int, log_every_n_steps: Optional[int], num_dataset_workers: int, - biobert_spec_option: BiobertSpecOption, # TODO(@farhadrgh) clarify how to parse this. + biobert_spec_option: BiobertSpecOption, lr: float, micro_batch_size: int, accumulate_grad_batches: int, @@ -111,6 +112,7 @@ def main( num_dataset_workers (int): number of dataset workers biobert_spec_option (BiobertSpecOption): the biobert spec option (architecture) to use for this run lr (float): learning rate + scheduler_num_steps (Optional[int]): Number of steps in learning rate scheduler. Use num_steps if not provided. micro_batch_size (int): micro batch size, from this and parallelism settings we infer the global batch size accumulate_grad_batches (int): number of batches to accumulate gradients for experiment_name (str): experiment name, this is the name used for the wandb run, and the sub-directory of the @@ -170,7 +172,7 @@ def main( ) # for wandb integration - # Please refer to https://pytorch-lightning.readthedocs.io/en/0.7.6/api/pytorch_lightning.loggers.html" + # Please refer to https://pytorch-lightning.readthedocs.io/en/0.7.6/api/lightning.pytorch.loggers.html" wandb_config: Optional[WandbConfig] = ( None if wandb_project is None @@ -247,20 +249,27 @@ def main( variable_seq_lengths=min_seq_length != max_seq_length, ) + if scheduler_num_steps is None: + scheduler_num_steps = num_steps + model = biobert_lightning_module( esm2_config, tokenizer=tokenizer, optimizer=MegatronOptimizerModule( config=OptimizerConfig( lr=lr, - optimizer="adam", # fused_adam not supported + optimizer="adam", use_distributed_optimizer=True, weight_decay=0.01, adam_beta1=0.9, adam_beta2=0.98, ), lr_scheduler=WarmupAnnealDecayHoldScheduler( - warmup_steps=warmup_steps, max_steps=num_steps, max_lr=lr, min_lr=0.0, anneal_percentage=0.10 + warmup_steps=warmup_steps, + max_steps=scheduler_num_steps, + max_lr=lr, + min_lr=0.0, + anneal_percentage=0.10, ), ), ) @@ -328,6 +337,7 @@ def train_esm2_entrypoint(): num_dataset_workers=args.num_dataset_workers, biobert_spec_option=args.biobert_spec_option, lr=args.lr, + scheduler_num_steps=args.scheduler_num_steps, micro_batch_size=args.micro_batch_size, pipeline_model_parallel_size=args.pipeline_model_parallel_size, tensor_model_parallel_size=args.tensor_model_parallel_size, @@ -398,6 +408,12 @@ def get_parser(): default=4e-4, help="Learning rate for training. Default is 4e-4", ) + parser.add_argument( + "--scheduler-num-steps", + type=int, + required=False, + help="Number of steps for learning rate scheduler. Will use --num-steps if not given. Default is None.", + ) parser.add_argument( "--create-tensorboard-logger", action="store_true", default=False, help="Create a tensorboard logger." ) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py index f7c08c73d4..c5d0ee73fe 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py @@ -174,35 +174,6 @@ def test_create_esm_datamodule_creates_valid_dataloaders_fractional_limit_val_ba data_module.setup() -@pytest.mark.parametrize("limit_val_batches", [0, 0.0]) -def test_create_esm_datamodule_creates_valid_dataloaders_fractional_limit_val_batches_0( - dummy_protein_dataset, dummy_parquet_train_val_inputs, limit_val_batches -): - train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs - - # Initialize the data module. - data_module = ESMDataModule( - train_cluster_path=train_cluster_path, - train_database_path=dummy_protein_dataset, - valid_cluster_path=valid_cluster_path, - valid_database_path=dummy_protein_dataset, - global_batch_size=8, - micro_batch_size=4, - min_seq_length=36, - max_seq_length=36, - ) - assert data_module is not None - - data_module.trainer = mock.Mock() - data_module.trainer.max_epochs = 1 - data_module.trainer.max_steps = 10 - data_module.trainer.val_check_interval = 2 - data_module.trainer.limit_val_batches = limit_val_batches - - with pytest.raises(ValueError, match="Invalid choice of limit_val_batches size: %s" % limit_val_batches): - data_module.setup() - - def test_create_esm_datamodule_creates_valid_dataloaders_fractional_limit_val_batches_not_multiple_of_global_batch_size( dummy_protein_dataset, dummy_parquet_train_val_inputs ): diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py index 6e509525e1..1fcb2fca30 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py @@ -54,6 +54,7 @@ def pretrain_data_module(dummy_protein_dataset, dummy_parquet_train_val_inputs): micro_batch_size=4, min_seq_length=None, max_seq_length=1024, + num_workers=1, ) yield data_module diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py index 0438483901..63630cc49d 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py @@ -249,6 +249,7 @@ def test_esm2_loss(esm2_650M_config_w_ckpt, dummy_protein_dataset, dummy_parquet min_seq_length=None, max_seq_length=1024, seed=seed, + num_workers=1, ) assert data_module is not None data_module.trainer = mock.Mock() diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_stop_and_go.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_stop_and_go.py index 5231d5dfc9..eb7f22a924 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_stop_and_go.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_stop_and_go.py @@ -14,12 +14,15 @@ # limitations under the License. +import signal from pathlib import Path from typing import Literal -import pytorch_lightning as pl +import lightning.pytorch as pl +import pytest from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl +from nemo.lightning.pytorch import callbacks as nl_callbacks from nemo.lightning.pytorch.optim import MegatronOptimizerModule from typing_extensions import override @@ -31,8 +34,10 @@ from bionemo.esm2.data.tokenizer import BioNeMoESMTokenizer, get_tokenizer from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.lr_scheduler import WarmupAnnealDecayHoldScheduler +from bionemo.testing import testing_callbacks from bionemo.testing.harnesses import stop_and_go from bionemo.testing.harnesses.mode import Mode +from bionemo.testing.torch import recursive_assert_approx_equal MODEL_PRECISION: Literal["bf16-mixed"] = "bf16-mixed" @@ -76,7 +81,7 @@ def setup_model(cls, mode: Mode) -> tuple[pl.LightningModule, pl.LightningDataMo micro_batch_size=2, min_seq_length=None, max_seq_length=1024, - num_workers=0, + num_workers=1, persistent_workers=False, random_mask_strategy=RandomMaskStrategy.ALL_TOKENS, ) @@ -108,3 +113,76 @@ def setup_model(cls, mode: Mode) -> tuple[pl.LightningModule, pl.LightningDataMo module = biobert_lightning_module(config=config, tokenizer=cls.tokenizer, optimizer=optimizer) return module, data, optimizer + + +class TestESM2StopAndGoCheckpointNotAtValidation(TestESM2StopAndGo): + @override + @classmethod + def get_default_callbacks(cls): + callbacks = super().get_default_callbacks() + callbacks[Mode.STOP][nl_callbacks.PreemptionCallback] = nl_callbacks.PreemptionCallback(sig=signal.SIGUSR2) + callbacks[Mode.STOP][testing_callbacks.SignalAfterGivenStepCallback] = ( + testing_callbacks.SignalAfterGivenStepCallback(stop_step=2, signal_=signal.SIGUSR2) + ) + + return callbacks + + @override + @classmethod + def stop(cls) -> None: + # The PreemptionCallback exits the process with sys.exit(0) after the checkpoint is saved. We obviously don't + # want that here, so we catch the SystemExit exception and make sure it was called appropriately. + with pytest.raises(SystemExit) as pytest_wrapped_e: + super().stop() + + assert pytest_wrapped_e.type is SystemExit + assert pytest_wrapped_e.value.code == 0 + + @pytest.mark.parametrize( + "callback_type", + [ + testing_callbacks.LearningRateCallback, + testing_callbacks.GlobalStepStateCallback, + testing_callbacks.ConsumedSamplesCallback, + testing_callbacks.OptimizerStateCallback, + testing_callbacks.TrainInputCallback, + testing_callbacks.TrainOutputCallback, + testing_callbacks.TrainLossCallback, + testing_callbacks.ValidInputCallback, + testing_callbacks.ValidOutputCallback, + testing_callbacks.ValidLossCallback, + ], + ) + def test_stop_and_go_consistency(self, callback_type): + if callback_type in [ + testing_callbacks.ValidInputCallback, + testing_callbacks.ValidLossCallback, + testing_callbacks.ValidOutputCallback, + ]: + # On resumption from a checkpoint that wasn't created at the end of validation, the validation interval is + # shifted in the subsequent training jobs. See this slack thread for more details: + # https://nvidia.slack.com/archives/C074Z808N05/p1733171223813409 + pytest.xfail( + reason="Currently seeing issues in validation timing with PreemptionCallback. " + "See https://nvbugspro.nvidia.com/bug/4994415F." + ) + super().test_stop_and_go_consistency(callback_type) + + @pytest.mark.skip(reason="We don't expect the STOP variant to hit on_valid_epoch_end before stopping.") + def test_train_val_init_consumed_samples(self): + pass + + def test_all_valid_batch_inputs_are_identical(self): + """A watered-down version of test_stop_and_go_consistency's ValidInputCallback that only checks whether the + first batches are the same, not the over length.""" + + valid_inputs_interrupted = stop_and_go.get_callback( + self.callbacks, Mode.RESUME, testing_callbacks.ValidInputCallback + ).data + valid_inputs_continuous = stop_and_go.get_callback( + self.callbacks, Mode.CONTINUOUS, testing_callbacks.ValidInputCallback + ).data + + min_len = min(len(valid_inputs_interrupted), len(valid_inputs_continuous)) + assert min_len + recursive_assert_approx_equal(valid_inputs_interrupted[:min_len], valid_inputs_continuous[:min_len]) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py index d08a6553ec..c10ce0754e 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py @@ -21,6 +21,7 @@ from torch.utils.data import DataLoader from bionemo.core.data.load import load +from bionemo.core.utils.dtypes import get_autocast_dtype from bionemo.esm2.api import ESM2Config from bionemo.esm2.data.tokenizer import get_tokenizer from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule, InMemoryCSVDataset @@ -120,8 +121,8 @@ def test_in_memory_csv_dataset_tokenizer(): assert isinstance(tokenized_sequence, torch.Tensor) -# TODO: @pytest.mark.parametrize("config_class_name", list(SUPPORTED_CONFIGS)) -def test_infer_runs(tmpdir, dummy_protein_csv, dummy_protein_sequences): +@pytest.mark.parametrize("precision", ["fp32", "bf16-mixed"]) +def test_infer_runs(tmpdir, dummy_protein_csv, dummy_protein_sequences, precision): data_path = dummy_protein_csv result_dir = Path(tmpdir.mkdir("results")) results_path = result_dir / "esm2_infer_results.pt" @@ -134,9 +135,11 @@ def test_infer_runs(tmpdir, dummy_protein_csv, dummy_protein_sequences): results_path=results_path, min_seq_length=max_dataset_seq_len, include_hiddens=True, + precision=precision, include_embeddings=True, + include_input_ids=True, include_logits=True, - micro_batch_size=2, + micro_batch_size=3, # dataset length (10) is not multiple of 3; this validates partial batch inference # config_class=SUPPORTED_CONFIGS[config_class_name], config_class=ESM2Config, ) @@ -144,11 +147,14 @@ def test_infer_runs(tmpdir, dummy_protein_csv, dummy_protein_sequences): results = torch.load(results_path) assert isinstance(results, dict) - keys_included = ["token_logits", "hidden_states", "embeddings", "binary_logits"] + keys_included = ["token_logits", "hidden_states", "embeddings", "binary_logits", "input_ids"] assert all(key in results for key in keys_included) assert results["binary_logits"] is None assert results["embeddings"].shape[0] == len(dummy_protein_sequences) + assert results["embeddings"].dtype == get_autocast_dtype(precision) # hidden_states are [batch, sequence, hidden_dim] assert results["hidden_states"].shape[:-1] == (len(dummy_protein_sequences), max_dataset_seq_len) + # input_ids are [batch, sequence] + assert results["input_ids"].shape == (len(dummy_protein_sequences), max_dataset_seq_len) # token_logits are [sequence, batch, num_tokens] assert results["token_logits"].shape[:-1] == (max_dataset_seq_len, len(dummy_protein_sequences)) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py index a7c3ababa8..8ea2dac239 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py @@ -56,10 +56,10 @@ def test_pretrain_pydantic_cli(dummy_protein_dataset, dummy_parquet_train_val_in train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs open_port = find_free_network_port() - config = f"{result_dir}/test_config.json" + config = f"{result_dir}/test_config.yaml" # Invoke with blocking - cmd_str = f"""bionemo-esm2-recipe --dest {config} --recipe test + cmd_str = f"""bionemo-esm2-recipe --dest {config} --recipe esm2_tiny_test_recipe --train-database-path {dummy_protein_dataset} --train-cluster-path {train_cluster_path} --valid-database-path {dummy_protein_dataset} @@ -93,5 +93,5 @@ def test_pretrain_pydantic_cli(dummy_protein_dataset, dummy_parquet_train_val_in ) if result.returncode != 0: raise Exception(f"Pretrain script failed:\n{cmd_str=}\n{result.stdout=}\n{result.stderr=}") - # NOTE this looks a lot like a magic value. But we also could do json.loads(config)['experiment_config']['experiment_name'] + # NOTE this looks a lot like a magic value. But we also could do yaml.load(config)['experiment_config']['experiment_name'] assert (result_dir / "default_experiment").exists(), "Could not find test experiment directory." diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py index 9023e399eb..ab15ae0b4b 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py @@ -101,6 +101,7 @@ def test_main_runs(monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_tra wandb_project=None, wandb_offline=True, num_steps=10, + scheduler_num_steps=None, warmup_steps=5, limit_val_batches=1, val_check_interval=1, @@ -136,7 +137,7 @@ def test_main_runs(monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_tra ).is_file(), "Could not find experiment log." -@pytest.mark.parametrize("limit_val_batches", [1.0, 4, None]) +@pytest.mark.parametrize("limit_val_batches", [0.0, 1.0, 4, None]) def test_val_dataloader_in_main_runs_with_limit_val_batches( monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_train_val_inputs, limit_val_batches ): @@ -162,15 +163,16 @@ def test_val_dataloader_in_main_runs_with_limit_val_batches( valid_database_path=dummy_protein_dataset, num_nodes=1, devices=1, - min_seq_length=None, + min_seq_length=128, max_seq_length=128, result_dir=result_dir, wandb_project=None, wandb_offline=True, - num_steps=10, + scheduler_num_steps=None, + num_steps=5, warmup_steps=2, limit_val_batches=limit_val_batches, - val_check_interval=1, + val_check_interval=2, log_every_n_steps=None, num_dataset_workers=1, biobert_spec_option=BiobertSpecOption.esm2_bert_layer_with_transformer_engine_spec, @@ -219,13 +221,18 @@ def test_pretrain_cli(tmpdir, dummy_protein_dataset, dummy_parquet_train_val_inp --experiment-name test_experiment \ --num-gpus 1 \ --num-nodes 1 \ - --val-check-interval 10 \ + --val-check-interval 2 \ --num-dataset-workers 1 \ - --num-steps 55 \ + --num-steps 5 \ --max-seq-length 128 \ - --limit-val-batches 2 \ + --limit-val-batches 1 \ + --val-check-interval 2 \ --micro-batch-size 2 \ - --accumulate-grad-batches 2 + --accumulate-grad-batches 2 \ + --num-layers 2 \ + --num-attention-heads 2 \ + --hidden-size 4 \ + --ffn-hidden-size 8 """.strip() # a local copy of the environment diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py deleted file mode 100644 index 57b0b4f50c..0000000000 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/dataset.py +++ /dev/null @@ -1,93 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -from typing import ClassVar, Dict, Optional - -import torch -from megatron.core.datasets.gpt_dataset import GPTDataset - - -class Evo2Dataset(GPTDataset): - """Dataset for training Evo2.""" - - CONTROL_TAGS: ClassVar[list[int]] = [64, 35] # '@' tag for splice splits/windows, '#' for contig splits - TAG_BOUNDS = 124 # start and end delim: '|' - TAG_CHARS: ClassVar[set[int]] = {95, 59, 32} # chars only found in control tags: _, ;, space - DEFAULT_EOD = 0 - - def __getitem__(self, idx: Optional[int]) -> Dict[str, torch.Tensor]: - """Get data at the specified index.""" - databatch: dict = super().__getitem__(idx) - labels = databatch.get("labels", None) - loss_mask = databatch.get("loss_mask", None) - if labels is None or loss_mask is None: - # No next-token labels or loss to mask. - return databatch - - # Mask special label tags in loss. - control_mask = torch.isin(labels, torch.tensor(self.CONTROL_TAGS, device=labels.device)) - loss_mask[control_mask] = 0 - phylotag_mask = Evo2Dataset.mask_phylogenetic_tags( - labels, - self.TAG_BOUNDS, - self.TAG_CHARS, - self.config.tokenizer.eod if self.config.tokenizer is not None else self.DEFAULT_EOD, - ) - databatch["loss_mask"] = loss_mask * phylotag_mask - - return databatch - - @staticmethod - def mask_phylogenetic_tags(tokenized_sequence, terminal_tag_char, other_tag_chars, eod_token_id): - """Optimized version to create a phylonetic tag mask for batched tokenized sequences with correct handling of partial tags. - - Args: - tokenized_sequence (torch.Tensor): A batched tensor of shape (batch_size, seq_length). If (seq_length,) is detected, it will be converted into a (1, seq_length) tensor. - terminal_tag_char (int): The token ID representing the start and end of a phylogenetic tag ('|'). - other_tag_chars (set of int): A set of token IDs that are uniquely part of the tag ('_', ';', etc.). - eod_token_id (int): The token ID representing the end-of-document (EOD). - - Returns: - mask_vector (torch.Tensor): A batched mask of the same shape as tokenized_sequence where 1 represents non-tag tokens and 0 represents tokens within the masked region. - """ - device = tokenized_sequence.device - if len(tokenized_sequence.shape) == 1: - tokenized_sequence = tokenized_sequence.unsqueeze(dim=0) - batch_size, seq_len = tokenized_sequence.shape - mask_vector = torch.ones_like(tokenized_sequence, dtype=torch.int, device=device) - - # To address when unbalanced tags are present - terms = torch.tensor([0, seq_len - 1], device=device) - other_tags = torch.tensor(list(other_tag_chars), device=device) - for batch_idx in range(batch_size): - tag_term_locs = torch.where(tokenized_sequence[batch_idx] == terminal_tag_char)[0] - tag_end_locs = torch.where(tokenized_sequence[batch_idx] == eod_token_id)[0] - - merged_tags = torch.cat((terms, tag_term_locs, tag_end_locs)).sort()[0] - merged_tags = merged_tags.unique() - - start = 0 # First and last locations are always added - for end in merged_tags[1:]: - if torch.isin(tokenized_sequence[batch_idx][start:end], other_tags).sum() > 0: - # end token is not part of the tag - if eod_token_id == tokenized_sequence[batch_idx][end]: - end = end - 1 - if eod_token_id == tokenized_sequence[batch_idx][start]: - start = start + 1 - - mask_vector[batch_idx][start : (end + 1)] = 0 - start = end - return mask_vector diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 94a8d42016..09db859325 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -16,17 +16,22 @@ import argparse import torch +import torch._dynamo from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm from nemo.collections.llm.gpt.data import PreTrainingDataModule -from nemo.collections.nlp.data.language_modeling.megatron import Evo2Dataset +from nemo.collections.llm.gpt.data.megatron.hyena import Evo2Dataset from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger from nemo.lightning.pytorch.callbacks import ModelCheckpoint from nemo.lightning.pytorch.optim import CosineAnnealingScheduler from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule -from pytorch_lightning.loggers import WandbLogger +from nemo.lightning.pytorch.strategies.utils import RestoreConfig +from pytorch_lightning.loggers import TensorBoardLogger, WandbLogger + + +torch._dynamo.config.suppress_errors = True def parse_args(): @@ -46,6 +51,7 @@ def parse_args(): "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." ) parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallelism.") + parser.add_argument("--fp8", action="store_true", help="Set to enable FP8") parser.add_argument("--micro-batch-size", type=int, default=1, help="Micro-batch size for data-parallel training.") parser.add_argument("--global-batch-size", type=int, default=8, help="Global batch size for training.") parser.add_argument("--max-steps", type=int, help="Number of training optimizer update steps.") @@ -66,6 +72,8 @@ def parse_args(): parser.add_argument( "--tokenizer-path", type=str, default=None, help="Path to tokenizer model if relevant to tokenizer." ) + parser.add_argument("--seed", type=int, default=1234, help="Set random seed for training.") + parser.add_argument("--workers", type=int, default=0, help="Number of workers to use for data loading.") return parser.parse_args() @@ -84,8 +92,8 @@ def main(): seq_length=args.seq_length, micro_batch_size=args.micro_batch_size, global_batch_size=args.global_batch_size, - seed=1234, - num_workers=2, + seed=args.seed, + num_workers=args.workers, tokenizer=tokenizer, ) @@ -120,10 +128,11 @@ def main(): project="hyena_ux_test", save_dir=args.experiment_dir, ) - # wandb_logger = TensorBoardLogger( - # save_dir='dummy', ## NOTE: this gets overwritten by default - # ) loggers.append(wandb_logger) + tb_logger = TensorBoardLogger( + save_dir="dummy", ## NOTE: this gets overwritten by default + ) + loggers.append(tb_logger) nemo_logger = NeMoLogger(log_dir=args.experiment_dir, wandb=wandb_logger) @@ -141,7 +150,7 @@ def main(): ckpt_load_optimizer=False, # Checkpoint model state only. ckpt_save_optimizer=False, ckpt_async_save=False, - save_ckpt_format="zarr", + save_ckpt_format="torch_dist", ), logger=loggers, callbacks=[checkpoint_callback], @@ -151,6 +160,9 @@ def main(): plugins=nl.MegatronMixedPrecision( precision="bf16-mixed", params_dtype=torch.bfloat16, + fp8="hybrid" if args.fp8 else None, + fp8_amax_history_len=16 if args.fp8 else 1, + fp8_amax_compute_algo="max" if args.fp8 else "most_recent", ), val_check_interval=args.val_check_interval, ) @@ -161,9 +173,6 @@ def main(): resume_if_exists=True, ) - # Auto resume setup - from nemo.lightning.pytorch.strategies.utils import RestoreConfig - resume = nl.AutoResume( resume_if_exists=True, resume_ignore_no_checkpoint=True, diff --git a/sub-packages/bionemo-example_model/README.md b/sub-packages/bionemo-example_model/README.md index 20b1faea75..4abb4f219b 100644 --- a/sub-packages/bionemo-example_model/README.md +++ b/sub-packages/bionemo-example_model/README.md @@ -4,9 +4,11 @@ This is a minimalist package containing an example model that makes use of bionemo2 and nemo conventions. It contains the necessary models, dataloaders, datasets, and custom loss fucntions. The referenced classes and function are in `bionemo.example_model.lightning.lightning_basic`. -This tutorial demonstrates the creation of a simple MNIST model. This should be run in a BioNeMo container. For this tutorial, we will reuse elements from the BioNeMo example_model package. +This tutorial demonstrates the creation of a simple MNIST model. This should be run in a BioNeMo container. The BioNeMo Framework container can run in a brev.dev launchable: [![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU). It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credit. Notebooks and a shell interface can be launced by clicking `Open Notebook`. (Note: This links to the nightly release and may be out of sync with these docs.) +For this tutorial, we will reuse elements from the BioNeMo example_model package. + `Megatron`/`NeMo` modules and datasets are special derivatives of PyTorch modules and datasets that extend and accelerate the distributed training and inference capabilities of PyTorch. Some distinctions of Megatron/NeMo are: @@ -73,7 +75,7 @@ Similarly, `ExampleFineTuneConfig` extends `ExampleGenericConfig` for finetuning # Training Module -It is helfpul to have a training module that inherits from `pytorch_lightning.LightningModule` which organizes the model architecture, training, validation, and testing logic while abstracting away boilerplate code, enabling easier and more scalable training. This wrapper can be used for all model and loss combinations specified in the config. +It is helfpul to have a training module that inherits from `lightning.pytorch.LightningModule` which organizes the model architecture, training, validation, and testing logic while abstracting away boilerplate code, enabling easier and more scalable training. This wrapper can be used for all model and loss combinations specified in the config. In `bionemo.example_model.lightning.lightning_basic`, we define `BionemoLightningModule`. In this example, `training_step`, `validation_step`, and `predict_step` define the training, validation, and prediction loops are independent of the forward method. In nemo: @@ -97,7 +99,7 @@ We specify a training strategy of type `nemo.lightning.MegatronStrategy`. This s We specify a trainer of type `nemo.lightning.Trainer`, which is an extension of the pytorch lightning trainer. This is where the devices, validation intervals, maximal steps, maximal number of epochs, and how frequently to log are specified. -we specify a nemo-logger. We can set TensorBoard and WandB logging, along with extra loggers. Here, we specify a `CSVLogger` from pytorch_lightning.loggers. +we specify a nemo-logger. We can set TensorBoard and WandB logging, along with extra loggers. Here, we specify a `CSVLogger` from lightning.pytorch.loggers. We can now proceed to training. The first pre-training scripts is `bionemo/example_model/training_scripts/pretrain_mnist.py` diff --git a/sub-packages/bionemo-example_model/src/bionemo/example_model/lightning/lightning_basic.py b/sub-packages/bionemo-example_model/src/bionemo/example_model/lightning/lightning_basic.py index b7795feaa2..396c3ef38e 100644 --- a/sub-packages/bionemo-example_model/src/bionemo/example_model/lightning/lightning_basic.py +++ b/sub-packages/bionemo-example_model/src/bionemo/example_model/lightning/lightning_basic.py @@ -19,7 +19,6 @@ from dataclasses import dataclass, field from typing import Any, Dict, Generic, List, Optional, Sequence, Tuple, Type, TypedDict, TypeVar -import pytorch_lightning as pl import torch from megatron.core import ModelParallelConfig from megatron.core.optimizer.optimizer_config import OptimizerConfig @@ -35,6 +34,7 @@ from torchvision import transforms from torchvision.datasets import MNIST +import lightning.pytorch as pl from bionemo.core import BIONEMO_CACHE_DIR from bionemo.core.data.multi_epoch_dataset import IdentityMultiEpochDatasetWrapper, MultiEpochDatasetResampler from bionemo.llm.api import MegatronLossType diff --git a/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/finetune_mnist.py b/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/finetune_mnist.py index f03b6856f5..b0e081fd34 100644 --- a/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/finetune_mnist.py +++ b/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/finetune_mnist.py @@ -17,11 +17,11 @@ import argparse from pathlib import Path +from lightning.pytorch.loggers import CSVLogger, TensorBoardLogger from nemo import lightning as nl from nemo.collections import llm from nemo.lightning import NeMoLogger, resume from nemo.lightning.pytorch import callbacks as nl_callbacks -from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger from bionemo.example_model.lightning.lightning_basic import ( BionemoLightningModule, diff --git a/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py b/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py index 954af6ceb5..a5adac3cc2 100644 --- a/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py +++ b/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py @@ -16,10 +16,10 @@ from pathlib import Path +from lightning.pytorch.loggers import CSVLogger, TensorBoardLogger from nemo import lightning as nl from nemo.collections import llm from nemo.lightning import NeMoLogger, resume -from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger from bionemo.example_model.lightning.lightning_basic import ( BionemoLightningModule, diff --git a/sub-packages/bionemo-example_model/tests/bionemo/example_model/lightning/test_lightning_basic.py b/sub-packages/bionemo-example_model/tests/bionemo/example_model/lightning/test_lightning_basic.py index 651c87887c..d505cf6247 100644 --- a/sub-packages/bionemo-example_model/tests/bionemo/example_model/lightning/test_lightning_basic.py +++ b/sub-packages/bionemo-example_model/tests/bionemo/example_model/lightning/test_lightning_basic.py @@ -20,11 +20,11 @@ import pytest import torch from _pytest.compat import LEGACY_PATH +from lightning.pytorch.loggers import TensorBoardLogger from nemo import lightning as nl from nemo.collections import llm from nemo.lightning import NeMoLogger, io, resume from nemo.lightning.pytorch import callbacks as nl_callbacks -from pytorch_lightning.loggers import TensorBoardLogger from bionemo.core import BIONEMO_CACHE_DIR from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype diff --git a/sub-packages/bionemo-fw/pyproject.toml b/sub-packages/bionemo-fw/pyproject.toml index fd3551f152..4090dabd7a 100644 --- a/sub-packages/bionemo-fw/pyproject.toml +++ b/sub-packages/bionemo-fw/pyproject.toml @@ -17,6 +17,7 @@ dependencies = [ 'bionemo-geneformer', 'bionemo-geometric', 'bionemo-llm', + 'bionemo-noodles', 'bionemo-scdl', 'bionemo-size-aware-batching', 'bionemo-webdatamodule', diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py index 5e190871ef..9ab6d0a021 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py @@ -193,18 +193,6 @@ def setup(self, stage: str = "") -> None: # noqa: D102 assert max_train_steps > 0, "Please specify trainer.max_steps" num_train_samples = int(max_train_steps * self.data_sampler.global_batch_size) - num_val_samples = infer_num_samples( - limit_batches=self.trainer.limit_val_batches, - num_samples_in_dataset=len(self._val_dataset_ori), - global_batch_size=self.data_sampler.global_batch_size, - stage="val", - ) - num_test_samples = infer_num_samples( - limit_batches=self.trainer.limit_test_batches, - num_samples_in_dataset=len(self._test_dataset_ori), - global_batch_size=self.data_sampler.global_batch_size, - stage="test", - ) # This happens exactly once during setup. self._train_ds = MultiEpochDatasetResampler( @@ -213,18 +201,37 @@ def setup(self, stage: str = "") -> None: # noqa: D102 shuffle=True, seed=self.seed, ) - self._validation_ds = MultiEpochDatasetResampler( - self._val_dataset_ori, - num_samples=num_val_samples, - shuffle=False, - seed=self.seed, - ) - self._test_ds = MultiEpochDatasetResampler( - self._test_dataset_ori, - num_samples=num_test_samples, - shuffle=False, - seed=self.seed, - ) + if self.trainer.limit_val_batches == 0: # disable validation + logging.info("Skip creating validation dataset because trainer.limit_val_batches=0.") + else: + num_val_samples = infer_num_samples( + limit_batches=self.trainer.limit_val_batches, + num_samples_in_dataset=len(self._val_dataset_ori), + global_batch_size=self.data_sampler.global_batch_size, + stage="val", + ) + self._validation_ds = MultiEpochDatasetResampler( + self._val_dataset_ori, + num_samples=num_val_samples, + shuffle=False, + seed=self.seed, + ) + if self.trainer.limit_test_batches == 0: # disable testing + logging.info("Skip creating test dataset because trainer.limit_test_batches=0.") + + else: + num_test_samples = infer_num_samples( + limit_batches=self.trainer.limit_test_batches, + num_samples_in_dataset=len(self._test_dataset_ori), + global_batch_size=self.data_sampler.global_batch_size, + stage="test", + ) + self._test_ds = MultiEpochDatasetResampler( + self._test_dataset_ori, + num_samples=num_test_samples, + shuffle=False, + seed=self.seed, + ) else: assert self._predict_dataset_ori is not None self._predict_ds = MultiEpochDatasetResampler( diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py index ff64d45f58..d01e57b37e 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py @@ -18,6 +18,7 @@ from typing import List, Optional, Type from nemo.utils import logging +from pydantic import field_serializer, field_validator from tokenizers import Tokenizer from bionemo.geneformer.api import GeneformerConfig @@ -27,6 +28,8 @@ from bionemo.llm.run.config_models import ( DataConfig, ExposedModelConfig, + deserialize_str_to_path, + serialize_path_or_str, ) @@ -70,6 +73,14 @@ class GeneformerPretrainingDataConfig(DataConfig[SingleCellDataModule]): seq_length: int = 2048 num_dataset_workers: int = 0 + @field_serializer("result_dir") + def serialize_paths(self, value: pathlib.Path) -> str: # noqa: D102 + return serialize_path_or_str(value) + + @field_validator("result_dir") + def deserialize_paths(cls, value: str) -> pathlib.Path: # noqa: D102 + return deserialize_str_to_path(value) + @property def train_data_path(self) -> str: # noqa: D102 return self.data_dir + "/train" diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py index 24f1682e18..4b49946cef 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py @@ -15,9 +15,10 @@ import argparse -import json from typing import Optional +import yaml + from bionemo.geneformer.run.config_models import ( ExposedFineTuneSeqLenBioBertConfig, ExposedGeneformerPretrainConfig, @@ -32,16 +33,16 @@ def parse_args(): parser = argparse.ArgumentParser(description="Run Geneformer pretraining") parser.add_argument("--config", type=str, required=True, help="Path to the JSON configuration file") parser.add_argument( - "--model-config-t", + "--model-config-cls", default=ExposedGeneformerPretrainConfig, required=False, - help="fully resolvable python import path to the ModelConfig object. Builtin options are ExposedGeneformerPretrainConfig and ExposedFineTuneSeqLenBioBertConfig.", + help="fully resolvable python import path to the ModelConfig class. Builtin options are ExposedGeneformerPretrainConfig and ExposedFineTuneSeqLenBioBertConfig.", ) parser.add_argument( - "--data-config-t", + "--data-config-cls", default=GeneformerPretrainingDataConfig, required=False, - help="fully resolvable python import path to the ModelConfig object.", + help="fully resolvable python import path to the class.", ) parser.add_argument( "--resume-if-exists", @@ -91,28 +92,28 @@ def string_to_class(path: str): module = importlib.import_module(module_path) return getattr(module, class_name) - def load_config(config_path: str, model_config_t: Optional[str], data_config_t: Optional[str]) -> MainConfig: + def load_config(config_path: str, model_config_cls: Optional[str], data_config_cls: Optional[str]) -> MainConfig: with open(config_path, "r") as f: - config_dict = json.load(f) + config_dict = yaml.safe_load(f) - # model/data_config_t is used to select the parser dynamically. - if model_config_t is None or model_config_t == "ExposedGeneformerPretrainConfig": - model_config_t = ExposedGeneformerPretrainConfig - elif model_config_t == "ExposedFineTuneSeqLenBioBertConfig": + # model/data_config_cls is used to select the parser dynamically. + if model_config_cls is None or model_config_cls == "ExposedGeneformerPretrainConfig": + model_config_cls = ExposedGeneformerPretrainConfig + elif model_config_cls == "ExposedFineTuneSeqLenBioBertConfig": # Hardcoded path for those who do not know the full path - model_config_t = ExposedFineTuneSeqLenBioBertConfig - elif isinstance(model_config_t, str): + model_config_cls = ExposedFineTuneSeqLenBioBertConfig + elif isinstance(model_config_cls, str): # We assume we get a string to some importable config... e.g. in the sub-package jensen, 'bionemo.jensen.configs.MyConfig' - model_config_t = string_to_class(model_config_t) + model_config_cls = string_to_class(model_config_cls) - if data_config_t is None: - data_config_t = GeneformerPretrainingDataConfig - elif isinstance(data_config_t, str): - data_config_t = string_to_class(data_config_t) - return MainConfig[model_config_t, data_config_t](**config_dict) + if data_config_cls is None: + data_config_cls = GeneformerPretrainingDataConfig + elif isinstance(data_config_cls, str): + data_config_cls = string_to_class(data_config_cls) + return MainConfig[model_config_cls, data_config_cls](**config_dict) args = parse_args() - config = load_config(args.config, args.model_config_t, args.data_config_t) + config = load_config(args.config, args.model_config_cls, args.data_config_cls) if args.nsys_profiling: nsys_config = NsysConfig( diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/recipes.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/recipes.py index 2cbc1e3c1b..bc15033869 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/recipes.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/recipes.py @@ -15,9 +15,11 @@ import argparse from functools import partial -from typing import List, Optional +from typing import Callable, List, Optional +import yaml from nemo.utils import logging +from pydantic import BaseModel from bionemo.core.utils.dtypes import PrecisionTypes from bionemo.geneformer.run.config_models import ( @@ -537,13 +539,38 @@ def geneformer_10m_finetune_recipe( return main_config +class GeneformerRecipes(BaseModel): + """Pre-baked recipes for Geneformer. + + THIS PYDANTIC MODEL IS NOT MEANT FOR SERIALIZATION. Only used to facilitate argparse. Each recipe should take `args` + as the only argument. We use partials so we can provide this information at runtime. Add new recipes to this model. + """ + + # Use partials so we can still parameterize the recipes from the CLI (e.g. data paths.) + geneformer_10m_finetune_recipe: Callable[ + [argparse.Namespace], MainConfig[ExposedFineTuneSeqLenBioBertConfig, GeneformerPretrainingDataConfig] + ] = partial(geneformer_10m_finetune_recipe) + geneformer_10m_pretrain_recipe: Callable[ + [argparse.Namespace], MainConfig[ExposedGeneformerPretrainConfig, GeneformerPretrainingDataConfig] + ] = partial(geneformer_10m_pretrain_recipe) + geneformer_106m_pretrain_recipe: Callable[ + [argparse.Namespace], MainConfig[ExposedGeneformerPretrainConfig, GeneformerPretrainingDataConfig] + ] = partial(geneformer_106m_pretrain_recipe) + geneformer_tiny_test_recipe: Callable[ + [argparse.Namespace], MainConfig[ExposedGeneformerPretrainConfig, GeneformerPretrainingDataConfig] + ] = partial(pretrain_tiny_test_recipe) + finetune_test_recipe: Callable[ + [argparse.Namespace], MainConfig[ExposedFineTuneSeqLenBioBertConfig, GeneformerPretrainingDataConfig] + ] = partial(finetune_test_recipe) + + def main(): # noqa: D103 def parse_args(): - parser = argparse.ArgumentParser(description="Create Geneformer configuration JSON.") + parser = argparse.ArgumentParser(description="Create Geneformer configuration YAML.") parser.add_argument( "--recipe", type=str, - choices=["test", "10m-pretrain", "106m-pretrain", "test-finetune", "finetune"], + choices=GeneformerRecipes.model_fields.keys(), required=True, help="Use one of the preconfigured recipes to create a template config file.", ) @@ -551,9 +578,9 @@ def parse_args(): parser.add_argument( "--dest", type=str, - default="./geneformer-recipe.json", + default="./geneformer-recipe.yaml", required=True, - help="Path to the JSON configuration file.", + help="Path to the YAML configuration file.", ) parser.add_argument( @@ -574,33 +601,17 @@ def parse_args(): args = parser.parse_args() return args - """Simple example for creating a JSON from recipes.""" + """Simple example for creating a YAML from recipes.""" args = parse_args() - - if args.recipe == "test": - config = pretrain_tiny_test_recipe(args) - elif args.recipe == "10m-pretrain": - config = geneformer_10m_pretrain_recipe(args) - elif args.recipe == "106m-pretrain": - config = geneformer_106m_pretrain_recipe(args) - elif args.recipe == "test-finetune": - # Uses a bigger model because we have a pretrained model for it. - config = finetune_test_recipe(args) - elif args.recipe == "finetune": - # NOTE: this recipe finetunes a regression model on the masked tokens, if youre looking to finetune with a custom task, youll need to define your own classes. - config = geneformer_10m_finetune_recipe(args) - else: - raise ValueError("Invalid recipe choice.") - - # Serialize to JSON - json_str = config.model_dump_json(indent=2) + config_partial: Callable[[argparse.Namespace], MainConfig] = GeneformerRecipes().__getattribute__(args.recipe) + config = config_partial(args) # Save to file with open( args.dest, "w", ) as f: - f.write(json_str) + yaml.dump(config.model_dump(), f, indent=2) logging.info(f"Saved configuration to {args.dest=}") diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py index a41dcc7e4f..b4dad05ac3 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py @@ -26,6 +26,7 @@ from typing import Dict, List, Optional, Sequence, Type, get_args import torch +from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary from megatron.core.distributed import DistributedDataParallelConfig from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl @@ -36,7 +37,6 @@ from nemo.lightning.pytorch.optim.lr_scheduler import CosineAnnealingScheduler from nemo.utils import logging from nemo.utils.exp_manager import TimingCallback -from pytorch_lightning.callbacks import LearningRateMonitor, RichModelSummary from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype from bionemo.geneformer.api import FineTuneSeqLenBioBertConfig, GeneformerConfig @@ -81,6 +81,10 @@ def main( create_tensorboard_logger: bool = False, nemo1_init_path: Path | None = None, restore_from_checkpoint_path: Path | None = None, + num_layers: int = 6, + hidden_size: int = 256, + ffn_hidden_size: int = 512, + num_attention_heads: int = 4, save_last_checkpoint: bool = True, metric_to_monitor_for_checkpoints: str = "val_loss", save_top_k: int = 2, @@ -134,6 +138,10 @@ def main( create_tensorboard_logger (bool): create the tensorboard logger restore_from_checkpoint_path (path): If set, restores the model from the directory passed in. Expects the checkpoint to be created by using the ModelCheckpoint class and always_save_context=True. + num_layers (int): Number of layers in geneformer. Default to 6. + hidden_size (int): Hidden size in geneformer. Default to 256. + ffn_hidden_size (int): Feedforward hidden size in geneformer. Default to 512. + num_attention_heads (int): Number of attention heads in geneformer. Default to 4. log_every_n_steps (int): log at this interval. nsys_profiling (bool): Whether to enable the nsys profiling callback hooks. You still need to execute the function with nsys on the command line, but this enables more useful outputs in your nsys profiles, as @@ -195,7 +203,7 @@ def main( ) # for wandb integration - # Please refer to https://pytorch-lightning.readthedocs.io/en/0.7.6/api/pytorch_lightning.loggers.html" + # Please refer to https://pytorch-lightning.readthedocs.io/en/0.7.6/api/lightning.pytorch.loggers.html" wandb_options: Optional[WandbConfig] = ( None if wandb_project is None @@ -273,11 +281,10 @@ def main( num_workers=num_dataset_workers, ) geneformer_config = config_class( - # TODO let users set different num layers/model shapes here to support bigger/smaller architectures - num_layers=6, - hidden_size=256, - ffn_hidden_size=512, - num_attention_heads=4, + num_layers=num_layers, + hidden_size=hidden_size, + ffn_hidden_size=ffn_hidden_size, + num_attention_heads=num_attention_heads, seq_length=seq_length, bias_dropout_fusion=True, # TODO fix the recompilation issue, but for now it's faster even with recompilations bias_activation_fusion=True, # TODO same note as above. Set these to False to see recompilation go away @@ -541,7 +548,14 @@ def get_parser(): default=None, help="Path to the checkpoint directory to restore from. Will override `--resume-if-exists` when set.", ) - + parser.add_argument("--num-layers", type=int, default=6, help="Number of layers in geneformer. Default to 6.") + parser.add_argument("--hidden-size", type=int, default=256, help="Hidden size in geneformer. Default to 256.") + parser.add_argument( + "--ffn-hidden-size", type=int, default=512, help="Feedforward hidden size in geneformer. Default to 512." + ) + parser.add_argument( + "--num-attention-heads", type=int, default=4, help="Number of attention heads in geneformer. Default to 4." + ) # TODO consider whether nemo.run or some other method can simplify this config class lookup. config_class_options: Dict[str, Type[BioBertConfig]] = { "GeneformerConfig": GeneformerConfig, diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py index b7a4280017..ab7584e23b 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py @@ -42,10 +42,10 @@ def test_pretrain_cli_from_ckpt(tmpdir): open_port = find_free_network_port() # NOTE: if this test is ever failing, you may want to put the config somewhere easily accessible. - config = f"{result_dir}/test_config.json" - # Invoke with blocking, continue when finished (and the json config is generated) + config = f"{result_dir}/test_config.yaml" + # Invoke with blocking, continue when finished (and the yaml config is generated) checkpoint_path: Path = load("geneformer/10M_240530:2.0") - cmd_str = f"""bionemo-geneformer-recipe --dest {config} --recipe test --data-path {data_path} --result-dir {result_dir} --initial-ckpt-path {checkpoint_path}""".strip() + cmd_str = f"""bionemo-geneformer-recipe --dest {config} --recipe geneformer_tiny_test_recipe --data-path {data_path} --result-dir {result_dir} --initial-ckpt-path {checkpoint_path}""".strip() env = dict(**os.environ) # a local copy of the environment env["MASTER_PORT"] = str(open_port) cmd = shlex.split(cmd_str) @@ -83,9 +83,9 @@ def test_pretrain_cli(tmpdir): result_dir = Path(tmpdir.mkdir("results")) open_port = find_free_network_port() - config = f"{result_dir}/test_config.json" + config = f"{result_dir}/test_config.yaml" # Invoke with blocking - cmd_str = f"""bionemo-geneformer-recipe --dest {config} --recipe test --data-path {data_path} --result-dir {result_dir}""".strip() + cmd_str = f"""bionemo-geneformer-recipe --dest {config} --recipe geneformer_tiny_test_recipe --data-path {data_path} --result-dir {result_dir}""".strip() # continue when finished env = dict(**os.environ) # a local copy of the environment env["MASTER_PORT"] = str(open_port) @@ -113,7 +113,7 @@ def test_pretrain_cli(tmpdir): ) if result.returncode != 0: raise Exception(f"Pretrain script failed:\n{cmd_str=}\n{result.stdout=}\n{result.stderr=}") - # NOTE this looks a lot like a magic value. But we also could do json.loads(config)['experiment_config']['experiment_name'] + # NOTE this looks a lot like a magic value. But we also could do yaml.loads(config)['experiment_config']['experiment_name'] assert (result_dir / "test-experiment").exists(), "Could not find test experiment directory." @@ -125,10 +125,10 @@ def test_finetune_cli(tmpdir): open_port = find_free_network_port() - config = f"{result_dir}/test_config.json" + config = f"{result_dir}/test_config.yaml" # TODO add initial path - cmd_str = f"""bionemo-geneformer-recipe --dest {config} --recipe test-finetune --data-path {data_path} --result-dir {result_dir} --initial-ckpt-path {checkpoint_path}""".strip() + cmd_str = f"""bionemo-geneformer-recipe --dest {config} --recipe finetune_test_recipe --data-path {data_path} --result-dir {result_dir} --initial-ckpt-path {checkpoint_path}""".strip() # continue when finished env = dict(**os.environ) # a local copy of the environment env["MASTER_PORT"] = str(open_port) @@ -145,7 +145,7 @@ def test_finetune_cli(tmpdir): if result.returncode != 0: raise Exception(f"Pretrain recipe failed:\n{cmd_str=}\n{result.stdout=}\n{result.stderr=}") - cmd_str = f"bionemo-geneformer-train --conf {config} --model-config-t ExposedFineTuneSeqLenBioBertConfig" + cmd_str = f"bionemo-geneformer-train --conf {config} --model-config-cls ExposedFineTuneSeqLenBioBertConfig" env = dict(**os.environ) # a local copy of the environment open_port = find_free_network_port() env["MASTER_PORT"] = str(open_port) diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py index 4bfec250f7..80e0d900cc 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py @@ -37,7 +37,8 @@ def test_bionemo2_rootdir(): assert data_path.is_dir(), "Test data directory is supposed to be a directory." -def test_main_runs(tmpdir): +@pytest.mark.parametrize("limit_val_batches", [0.0, 1]) +def test_val_dataloader_in_main_runs_with_limit_val_batches(tmpdir, limit_val_batches: float): result_dir = Path(tmpdir.mkdir("results")) with megatron_parallel_state_utils.distributed_model_parallel_state(): @@ -49,9 +50,9 @@ def test_main_runs(tmpdir): result_dir=result_dir, wandb_project=None, wandb_offline=True, - num_steps=55, - limit_val_batches=1, - val_check_interval=1, + num_steps=5, + limit_val_batches=limit_val_batches, + val_check_interval=2, num_dataset_workers=0, biobert_spec_option=BiobertSpecOption.bert_layer_local_spec, lr=1e-4, @@ -63,6 +64,10 @@ def test_main_runs(tmpdir): experiment_name="test_experiment", resume_if_exists=False, create_tensorboard_logger=False, + num_layers=2, + num_attention_heads=2, + hidden_size=4, + ffn_hidden_size=4 * 2, ) assert (result_dir / "test_experiment").exists(), "Could not find test experiment directory." @@ -91,13 +96,17 @@ def test_pretrain_cli(tmpdir): --experiment-name test_experiment \ --num-gpus 1 \ --num-nodes 1 \ - --val-check-interval 10 \ + --val-check-interval 2 \ --num-dataset-workers 0 \ - --num-steps 55 \ + --num-steps 5 \ --seq-length 128 \ --limit-val-batches 2 \ --micro-batch-size 2 \ - --accumulate-grad-batches 2 + --accumulate-grad-batches 2 \ + --num-layers 2 \ + --num-attention-heads 2 \ + --hidden-size 4 \ + --ffn-hidden-size 8 """.strip() env = dict(**os.environ) # a local copy of the environment env["MASTER_PORT"] = str(open_port) diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py index c9338ee731..3252df2ced 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py @@ -23,6 +23,7 @@ import pytest import torch import torch.utils.data +from lightning.pytorch.loggers import TensorBoardLogger from megatron.core.optimizer.optimizer_config import OptimizerConfig from megatron.core.transformer.module import Float16Module from nemo import lightning as nl @@ -34,7 +35,6 @@ from nemo.lightning.pytorch.callbacks.peft import PEFT from nemo.lightning.pytorch.optim.lr_scheduler import WarmupPolicyScheduler from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule -from pytorch_lightning.loggers import TensorBoardLogger from torch.nn import functional as F from tqdm import tqdm diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py index 665af8def9..07f91f6160 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py @@ -28,7 +28,7 @@ import pathlib from typing import Literal -import pytorch_lightning as pl +import lightning.pytorch as pl import torch from megatron.core.optimizer.optimizer_config import OptimizerConfig from nemo import lightning as nl diff --git a/sub-packages/bionemo-geometric/pyproject.toml b/sub-packages/bionemo-geometric/pyproject.toml index cf7a4cab19..27532829ed 100644 --- a/sub-packages/bionemo-geometric/pyproject.toml +++ b/sub-packages/bionemo-geometric/pyproject.toml @@ -22,6 +22,10 @@ dependencies = [ 'rdkit==2023.9.6', ] +# Make sure that the data CSV files are being packaged alongside the python files. +[tool.setuptools.package-data] +"bionemo.geometric" = ["**/*.csv"] + [tool.setuptools.packages.find] where = ["src"] include = ["bionemo.*"] diff --git a/sub-packages/bionemo-geometric/src/bionemo/geometric/atom_featurizers.py b/sub-packages/bionemo-geometric/src/bionemo/geometric/atom_featurizers.py new file mode 100644 index 0000000000..3aa0136197 --- /dev/null +++ b/sub-packages/bionemo-geometric/src/bionemo/geometric/atom_featurizers.py @@ -0,0 +1,510 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path +from typing import Iterable, Optional + +import pandas as pd +import torch +from rdkit import Chem +from rdkit.Chem import Mol, rdMolDescriptors +from rdkit.Chem.rdchem import ChiralType, HybridizationType +from rdkit.Chem.Scaffolds import MurckoScaffold + +from bionemo.geometric.base_featurizer import ( + BaseAtomFeaturizer, +) + + +ALL_ATOM_FEATURIZERS = [ + "PeriodicTableFeaturizer", + "ElectronicPropertyFeaturizer", + "ScaffoldFeaturizer", + "SmartsFeaturizer", + "CrippenFeaturizer", +] + + +class AtomicNumberFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its atomic number.""" + + def __init__(self, dim_atomic_num: Optional[int] = None) -> None: + """Initializes AtomicNumberFeaturizer class.""" + DIM_ATOMIC_NUM = 118 + self.dim_atomic_num = dim_atomic_num if dim_atomic_num else DIM_ATOMIC_NUM + + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return self.dim_atomic_num + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor of integers representing atomic numbers of atoms. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([mol.GetAtomWithIdx(a).GetAtomicNum() for a in _atom_indices], dtype=torch.int) + + +class DegreeFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its degree (excluding hydrogens) of connectivity.""" + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 6 + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor of integers representing degree of connectivity of atoms. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([mol.GetAtomWithIdx(a).GetDegree() for a in _atom_indices], dtype=torch.int) + + +class TotalDegreeFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its total degree (including hydrogens) of connectivity.""" + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 6 + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor of integers representing total connectivity (including hydrogens) of atoms. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([mol.GetAtomWithIdx(a).GetTotalDegree() for a in _atom_indices], dtype=torch.int) + + +class ChiralTypeFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its chirality type.""" + + def __init__(self) -> None: + """Initializes ChiralTypeFeaturizer class.""" + self.dim_chiral_types = len(ChiralType.values) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return self.dim_chiral_types + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor representing chirality type of atoms as integers. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([int(mol.GetAtomWithIdx(a).GetChiralTag()) for a in _atom_indices], dtype=torch.int) + + +class TotalNumHFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by total number of hydrogens.""" + + def __init__(self) -> None: + """Initializes TotalNumHFeaturizer class.""" + self.dim_total_num_hydrogen = 5 # 4 + 1 (no hydrogens) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return self.dim_total_num_hydrogen + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor of integers representing total number of hydrogens on atoms. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([mol.GetAtomWithIdx(a).GetTotalNumHs() for a in _atom_indices], dtype=torch.int) + + +class HybridizationFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its hybridization type.""" + + def __init__(self) -> None: + """Initializes HybridizationFeaturizer class.""" + self.dim_hybridization_types = len(HybridizationType.values) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return self.dim_hybridization_types + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor representing hybridization type of atoms as integers. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([int(mol.GetAtomWithIdx(a).GetHybridization()) for a in _atom_indices], dtype=torch.int) + + +class AromaticityFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom based on its aromaticity.""" + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 1 + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes features of atoms of all of select atoms. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor of representing if atoms are aromatic as integers. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor([int(mol.GetAtomWithIdx(a).GetIsAromatic()) for a in _atom_indices], dtype=torch.int) + + +class PeriodicTableFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its position (period and group) in the periodic table.""" + + def __init__(self) -> None: + """Initializes PeriodicTableFeaturizer class.""" + self.pt = Chem.GetPeriodicTable() + # The number of elements per period in the periodic table + self.period_limits = [2, 10, 18, 36, 54, 86, 118] + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 25 + + def get_period(self, atom: Chem.Atom) -> int: + """Returns periodic table period of atom.""" + atomic_number = atom.GetAtomicNum() + + # Determine the period based on atomic number. + for period, limit in enumerate(self.period_limits, start=1): + if atomic_number <= limit: + return period + return None + + def get_group(self, atom: Chem.Atom) -> int: + """Returns periodic table group of atom.""" + group = self.pt.GetNOuterElecs(atom.GetAtomicNum()) + return group + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes periodic table position of atoms of all or select atoms specific in `atom_indices`. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor of representing positions of atoms in periodic table. First index represents period and second index represents group. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return torch.tensor( + [(self.get_period(mol.GetAtomWithIdx(a)), self.get_group(mol.GetAtomWithIdx(a))) for a in _atom_indices], + dtype=torch.int, + ) + + +class AtomicRadiusFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its bond, covalent, and vdW radii.""" + + def __init__(self) -> None: + """Initializes AtomicRadiusFeaturizer class.""" + self.pt = Chem.GetPeriodicTable() + self._min_val = torch.Tensor( + [ + 0.0, # Bond radius + 0.28, # Covalent radius + 1.2, # van der Waals radius + ] + ) + + self._max_val = torch.Tensor( + [ + 2.4, # Bond radius + 2.6, # Covalent radius + 3.0, # van der Waals radius + ] + ) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 3 + + @property + def min_val(self) -> torch.tensor: + """Returns minimum values for features: bond, covalent, and vdW radius.""" + return self._min_val + + @property + def max_val(self) -> torch.tensor: + """Returns maximum values for features: bond, covalent, and vdW radius.""" + return self._max_val + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.Tensor: + """Computes bond radius, covalent radius, and van der Waals radius without normalization. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.Tensor of different atomic radii. Each atom is featurizer by bond radius, covalent radius, and van der Waals radius. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + + feats = [] + for aidx in _atom_indices: + atomic_num = mol.GetAtomWithIdx(aidx).GetAtomicNum() + feats.append([self.pt.GetRb0(atomic_num), self.pt.GetRcovalent(atomic_num), self.pt.GetRvdw(atomic_num)]) + + return torch.Tensor(feats) + + +class ElectronicPropertyFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by its electronic properties. + + This class computes electronic properties like electronegativity, ionization energy, and electron affinity. + """ + + def __init__(self, data_file=None) -> None: + """Initializes PeriodicTableFeaturizer class. + + Args: + data_file: Path to the data file. + """ + if data_file is None: + # Use default + root_path = Path(__file__).resolve().parent + data_file = root_path / "data" / "electronic_data.csv" + self.data_df = pd.read_csv(data_file).set_index("AtomicNumber") + + self.pauling_en_dict = self.data_df["Electronegativity"].to_dict() + self.ie_dict = self.data_df["IonizationEnergy"].to_dict() + self.ea_dict = self.data_df["ElectronAffinity"].to_dict() + + self._min_val = torch.Tensor( + [ + self.data_df["Electronegativity"].min(), + self.data_df["IonizationEnergy"].min(), + self.data_df["ElectronAffinity"].min(), + ] + ) + + self._max_val = torch.Tensor( + [ + self.data_df["Electronegativity"].max(), + self.data_df["IonizationEnergy"].max(), + self.data_df["ElectronAffinity"].max(), + ] + ) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 3 + + @property + def min_val(self) -> torch.Tensor: + """Returns minimum values for features: electronegativity, ionization energy, electron affinity.""" + return self._min_val + + @property + def max_val(self) -> torch.Tensor: + """Returns maximum values for features: electronegativity, ionization energy, electron affinity.""" + return self._max_val + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.Tensor: + """Returns electronic features of the atom. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.Tensor consisting of Pauling scale electronegativity, ionization energy, and electron affinity for each atom. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + + feats = [] + for aidx in _atom_indices: + atomic_num = mol.GetAtomWithIdx(aidx).GetAtomicNum() + feats.append([self.pauling_en_dict[atomic_num], self.ie_dict[atomic_num], self.ea_dict[atomic_num]]) + return torch.Tensor(feats) + + +class ScaffoldFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom based on whether it is present in Bemis-Murcko scaffold.""" + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 1 + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Returns position of the atoms with respect to Bemis-Murcko scaffold. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.tensor indicating if atoms are present in the Bemis-Murcko scaffold of the molecule. + """ + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + + scaffold = MurckoScaffold.GetScaffoldForMol(mol) + scaffold_atom_idx = set(mol.GetSubstructMatch(scaffold)) + + feats = [int(aidx in scaffold_atom_idx) for aidx in _atom_indices] + return torch.tensor(feats, dtype=torch.int) + + +class SmartsFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by hydrogen donor/acceptor and acidity/basicity.""" + + def __init__(self): + """Initializes SmartsFeaturizer class.""" + self.hydrogen_donor = Chem.MolFromSmarts("[$([N;!H0;v3,v4&+1]),$([O,S;H1;+0]),n&H1&+0]") + self.hydrogen_acceptor = Chem.MolFromSmarts( + "[$([O,S;H1;v2;!$(*-*=[O,N,P,S])]),$([O,S;H0;v2]),$([O,S;-]),$([N;v3;!$(N-*=[O,N,P,S])])," + "n&H0&+0,$([o,s;+0;!$([o,s]:n);!$([o,s]:c:n)])]" + ) + self.acidic = Chem.MolFromSmarts("[$([C,S](=[O,S,P])-[O;H1,-1])]") + self.basic = Chem.MolFromSmarts( + "[#7;+,$([N;H2&+0][$([C,a]);!$([C,a](=O))]),$([N;H1&+0]([$([C,a]);!$([C,a](=O))])[$([C,a]);" + "!$([C,a](=O))]),$([N;H0&+0]([C;!$(C(=O))])([C;!$(C(=O))])[C;!$(C(=O))])]" + ) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 4 + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.tensor: + """Computes matches by prefixed SMARTS patterns. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + An torch.tensor indicating if atoms are hydrogen bond donors, hydrogen bond acceptors, acidic, or basic. + """ + hydrogen_donor_match = sum(mol.GetSubstructMatches(self.hydrogen_donor), ()) + hydrogen_acceptor_match = sum(mol.GetSubstructMatches(self.hydrogen_acceptor), ()) + acidic_match = sum(mol.GetSubstructMatches(self.acidic), ()) + basic_match = sum(mol.GetSubstructMatches(self.basic), ()) + + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + feats = [ + [ + aidx in hydrogen_donor_match, + aidx in hydrogen_acceptor_match, + aidx in acidic_match, + aidx in basic_match, + ] + for aidx in _atom_indices + ] + + return torch.tensor(feats, dtype=torch.int) + + +class CrippenFeaturizer(BaseAtomFeaturizer): + """Class for featurizing atom by Crippen logP and molar refractivity.""" + + def __init__(self): + """Initializes CrippenFeaturizer class.""" + self._min_val = torch.Tensor( + [ + -2.996, # logP + 0.0, # MR + ] + ) + + self._max_val = torch.Tensor( + [ + 0.8857, # logP + 6.0, # MR + ] + ) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return 2 + + @property + def min_val(self) -> torch.tensor: + """Returns minimum values for features: logP and molar refractivity.""" + return self._min_val + + @property + def max_val(self) -> torch.tensor: + """Returns maximum values for features: logP and molar refractivity.""" + return self._max_val + + def get_atom_features(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> torch.Tensor: + """Compute atomic contributions to Crippen logP and molar refractivity. + + Args: + mol: An RDkit Chem.Mol object + atom_indices: Indices of atoms for feature computation. By default, features for all atoms is computed. + + Returns: + A torch.Tensor featurizing atoms by its atomic contribution to logP and molar refractivity. + """ + logp_mr_list = torch.Tensor(rdMolDescriptors._CalcCrippenContribs(mol)) + logp_mr_list = torch.clamp(logp_mr_list, min=self.min_val, max=self.max_val) + _atom_indices = atom_indices if atom_indices else range(mol.GetNumAtoms()) + return logp_mr_list[_atom_indices, :] diff --git a/sub-packages/bionemo-geometric/src/bionemo/geometric/base_featurizer.py b/sub-packages/bionemo-geometric/src/bionemo/geometric/base_featurizer.py new file mode 100644 index 0000000000..72631ae098 --- /dev/null +++ b/sub-packages/bionemo-geometric/src/bionemo/geometric/base_featurizer.py @@ -0,0 +1,139 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod, abstractproperty +from typing import Iterable, Optional + +import torch +from rdkit.Chem import Atom, Mol + + +class BaseAtomFeaturizer(ABC): + """Abstract base featurizer class for all atom featurization classes.""" + + @abstractproperty + def n_dim(self) -> int: + """Number of dimensions of computed feature.""" + ... + + @abstractmethod + def get_atom_features(self): + """Computes atom features.""" + ... + + def __call__(self, mol: Mol, atom_indices: Optional[Iterable] = None) -> list[int]: + """Returns computed atom features.""" + return self.get_atom_features(mol, atom_indices) + + +class BaseBondFeaturizer(ABC): + """Abstract base featurizer class for all bond featurization classes.""" + + @abstractproperty + def n_dim(self) -> int: + """Number of dimensions of computed feature.""" + ... + + @abstractmethod + def get_bond_features(self): + """Computes bond features.""" + ... + + def __call__(self, mol: Mol, bond_indices: Optional[Iterable] = None) -> list[int]: + """Returns computed bond features.""" + return self.get_bond_features(mol, bond_indices) + + +class BaseMoleculeFeaturizer(ABC): + """Abstract base featurizer class for molecule featurization classes.""" + + @abstractproperty + def n_dim(self) -> int: + """Number of dimensions of computed feature.""" + ... + + @abstractmethod + def get_molecule_features(self, mol: Mol) -> torch.Tensor: + """Computes molecule features.""" + ... + + def __call__(self, mol: Mol) -> torch.Tensor: + """Returns computed molecule features.""" + return self.get_molecule_features(mol) + + +def one_hot_enc(val: int, num_class: int) -> list[bool]: + """Performs one-hot encoding on an integer value. + + This function creates a one-hot encoded representation of the input value + as a list of boolean values. The resulting list has a length equal to + `num_class`, where only the element at index `val` is set to True. + + Args: + val (int): An integer representing the value to be one-hot encoded. + Must be in the range [0, num_class - 1]. + num_class (int): An integer representing the total number of classes or + possible classes. + + Returns: + One-hot encoding of `val`. + """ + one_hot = [False] * num_class + one_hot[val] = True + return one_hot + + +def get_boolean_atomic_prop(atom: Atom, prop_list=None) -> list[bool]: + """Retrieves boolean atomic properties for a given atom. + + This function fetches boolean properties of an atom. If a specific list of + properties is provided, it retrieves those properties. Otherwise, it fetches + all available boolean properties for the atom. + + Args: + atom: The atom object to retrieve properties from. + prop_list (list, optional): A list of specific property names to retrieve. + If None, all available properties will be fetched. Defaults to None. + + Returns: + list: A list of boolean values corresponding to the requested properties. + """ + _prop_list = prop_list if prop_list else atom.GetPropNames() + + return [atom.GetBoolProp(prop) for prop in _prop_list] + + +def get_double_atomic_prop(atom, prop_list=None) -> list[float]: + """Retrieves double atomic properties for a given atom. + + This function fetches double properties of an atom. If a specific list of + properties is provided, it retrieves those properties. Otherwise, it fetches + all available double properties for the atom. + + Args: + atom: The atom object to retrieve properties from. + prop_list (list, optional): A list of specific property names to retrieve. + If None, all available properties will be fetched. Defaults to None. + + Returns: + list: A list of float values corresponding to the requested properties. + """ + if prop_list is not None: + _prop_list = prop_list + else: + _prop_list = atom.GetPropNames() + + return [atom.GetDoubleProp(prop) for prop in _prop_list] diff --git a/sub-packages/bionemo-geometric/src/bionemo/geometric/bond_featurizers.py b/sub-packages/bionemo-geometric/src/bionemo/geometric/bond_featurizers.py new file mode 100644 index 0000000000..422c1f4373 --- /dev/null +++ b/sub-packages/bionemo-geometric/src/bionemo/geometric/bond_featurizers.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Iterable, Optional + +from rdkit.Chem import Mol + +from bionemo.geometric.base_featurizer import BaseBondFeaturizer + + +ALL_BOND_FEATURIZERS = ["RingFeaturizer"] + + +class RingFeaturizer(BaseBondFeaturizer): + """Class for featurizing bond its ring membership.""" + + def __init__(self, n_ring_sizes=7) -> None: + """Initializes RingFeaturizer class.""" + self.n_ring_sizes = n_ring_sizes # ring size 3 - 8 and UNK + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return self.n_ring_sizes + + def get_bond_features(self, mol: Mol, bond_indices: Optional[Iterable]) -> list[tuple[int]]: + """Computes ring sizes a bonds of the molecule are present in. + + Args: + mol: An RDkit Chem.Mol object + bond_indices: Indices of bonds for feature computation. By default, features for all bonds is computed. + + Returns: + An list of tuples indicating the size of ring(s) the bonds are present in. + """ + _bond_indices = bond_indices if bond_indices else range(mol.GetNumBonds()) + + ri = mol.GetRingInfo() + return [ri.BondRingSizes(bidx) for bidx in _bond_indices] diff --git a/sub-packages/bionemo-geometric/src/bionemo/geometric/data/electronic_data.csv b/sub-packages/bionemo-geometric/src/bionemo/geometric/data/electronic_data.csv new file mode 100644 index 0000000000..b02224d5c6 --- /dev/null +++ b/sub-packages/bionemo-geometric/src/bionemo/geometric/data/electronic_data.csv @@ -0,0 +1,119 @@ +AtomicNumber,Symbol,Electronegativity,IonizationEnergy,ElectronAffinity +1,H,2.2,13.598,0.754 +2,He,1.732315789473684,24.587,1.072140350877193 +3,Li,0.98,5.392,0.618 +4,Be,1.57,9.323,1.072140350877193 +5,B,2.04,8.298,0.277 +6,C,2.55,11.26,1.263 +7,N,3.04,14.534,1.072140350877193 +8,O,3.44,13.618,1.461 +9,F,3.98,17.423,3.339 +10,Ne,1.732315789473684,21.565,1.072140350877193 +11,Na,0.93,5.139,0.548 +12,Mg,1.31,7.646,1.072140350877193 +13,Al,1.61,5.986,0.441 +14,Si,1.9,8.152,1.385 +15,P,2.19,10.487,0.746 +16,S,2.58,10.36,2.077 +17,Cl,3.16,12.968,3.617 +18,Ar,1.732315789473684,15.76,1.072140350877193 +19,K,0.82,4.341,0.501 +20,Ca,1.0,6.113,1.072140350877193 +21,Sc,1.36,6.561,0.188 +22,Ti,1.54,6.828,0.079 +23,V,1.63,6.746,0.525 +24,Cr,1.66,6.767,0.666 +25,Mn,1.55,7.434,1.072140350877193 +26,Fe,1.83,7.902,0.163 +27,Co,1.88,7.881,0.661 +28,Ni,1.91,7.64,1.156 +29,Cu,1.9,7.726,1.228 +30,Zn,1.65,9.394,1.072140350877193 +31,Ga,1.81,5.999,0.3 +32,Ge,2.01,7.9,1.35 +33,As,2.18,9.815,0.81 +34,Se,2.55,9.752,2.021 +35,Br,2.96,11.814,3.365 +36,Kr,3.0,14.0,1.072140350877193 +37,Rb,0.82,4.177,0.468 +38,Sr,0.95,5.695,1.072140350877193 +39,Y,1.22,6.217,0.307 +40,Zr,1.33,6.634,0.426 +41,Nb,1.6,6.759,0.893 +42,Mo,2.16,7.092,0.746 +43,Tc,1.9,7.28,0.55 +44,Ru,2.2,7.361,1.05 +45,Rh,2.28,7.459,1.137 +46,Pd,2.2,8.337,0.557 +47,Ag,1.93,7.576,1.302 +48,Cd,1.69,8.994,1.072140350877193 +49,In,1.78,5.786,0.3 +50,Sn,1.96,7.344,1.2 +51,Sb,2.05,8.64,1.07 +52,Te,2.1,9.01,1.971 +53,I,2.66,10.451,3.059 +54,Xe,2.6,12.13,1.072140350877193 +55,Cs,0.79,3.894,0.472 +56,Ba,0.89,5.212,1.072140350877193 +57,La,1.1,5.577,0.5 +58,Ce,1.12,5.539,0.5 +59,Pr,1.13,5.464,1.072140350877193 +60,Nd,1.14,5.525,1.072140350877193 +61,Pm,1.732315789473684,5.55,1.072140350877193 +62,Sm,1.17,5.644,1.072140350877193 +63,Eu,1.732315789473684,5.67,1.072140350877193 +64,Gd,1.2,6.15,1.072140350877193 +65,Tb,1.732315789473684,5.864,1.072140350877193 +66,Dy,1.22,5.939,1.072140350877193 +67,Ho,1.23,6.022,1.072140350877193 +68,Er,1.24,6.108,1.072140350877193 +69,Tm,1.25,6.184,1.072140350877193 +70,Yb,1.732315789473684,6.254,1.072140350877193 +71,Lu,1.27,5.426,1.072140350877193 +72,Hf,1.3,6.825,1.072140350877193 +73,Ta,1.5,7.89,0.322 +74,W,2.36,7.98,0.815 +75,Re,1.9,7.88,0.15 +76,Os,2.2,8.7,1.1 +77,Ir,2.2,9.1,1.565 +78,Pt,2.28,9.0,2.128 +79,Au,2.54,9.226,2.309 +80,Hg,2.0,10.438,1.072140350877193 +81,Tl,1.62,6.108,0.2 +82,Pb,2.33,7.417,0.36 +83,Bi,2.02,7.289,0.946 +84,Po,2.0,8.417,1.9 +85,At,2.2,9.5,2.8 +86,Rn,1.732315789473684,10.745,1.072140350877193 +87,Fr,0.7,3.9,0.47 +88,Ra,0.9,5.279,1.072140350877193 +89,Ac,1.1,5.17,1.072140350877193 +90,Th,1.3,6.08,1.072140350877193 +91,Pa,1.5,5.89,1.072140350877193 +92,U,1.38,6.194,1.072140350877193 +93,Np,1.36,6.266,1.072140350877193 +94,Pu,1.28,6.06,1.072140350877193 +95,Am,1.3,5.993,1.072140350877193 +96,Cm,1.3,6.02,1.072140350877193 +97,Bk,1.3,6.23,1.072140350877193 +98,Cf,1.3,6.3,1.072140350877193 +99,Es,1.3,6.42,1.072140350877193 +100,Fm,1.3,6.5,1.072140350877193 +101,Md,1.3,6.58,1.072140350877193 +102,No,1.3,6.65,1.072140350877193 +103,Lr,1.3,7.997254901960784,1.072140350877193 +104,Rf,1.732315789473684,7.997254901960784,1.072140350877193 +105,Db,1.732315789473684,7.997254901960784,1.072140350877193 +106,Sg,1.732315789473684,7.997254901960784,1.072140350877193 +107,Bh,1.732315789473684,7.997254901960784,1.072140350877193 +108,Hs,1.732315789473684,7.997254901960784,1.072140350877193 +109,Mt,1.732315789473684,7.997254901960784,1.072140350877193 +110,Ds,1.732315789473684,7.997254901960784,1.072140350877193 +111,Rg,1.732315789473684,7.997254901960784,1.072140350877193 +112,Cn,1.732315789473684,7.997254901960784,1.072140350877193 +113,Nh,1.732315789473684,7.997254901960784,1.072140350877193 +114,Fl,1.732315789473684,7.997254901960784,1.072140350877193 +115,Mc,1.732315789473684,7.997254901960784,1.072140350877193 +116,Lv,1.732315789473684,7.997254901960784,1.072140350877193 +117,Ts,1.732315789473684,7.997254901960784,1.072140350877193 +118,Og,1.732315789473684,7.997254901960784,1.072140350877193 diff --git a/sub-packages/bionemo-geometric/src/bionemo/geometric/molecule_featurizers.py b/sub-packages/bionemo-geometric/src/bionemo/geometric/molecule_featurizers.py new file mode 100644 index 0000000000..c885074a64 --- /dev/null +++ b/sub-packages/bionemo-geometric/src/bionemo/geometric/molecule_featurizers.py @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import torch +from rdkit.Chem import Descriptors, Mol + +from bionemo.geometric.base_featurizer import ( + BaseMoleculeFeaturizer, +) + + +class RDkit2DDescriptorFeaturizer(BaseMoleculeFeaturizer): + """Class for featurizing molecule by computed RDkit descriptors. + + Typical usage example: + rdf = RDkit2DDescriptorFeaturizer() + rdf(Chem.MolFromSmiles("CCO")) + """ + + def __init__(self) -> None: + """Initializes RDkit2DDescriptorFeaturizer class.""" + self.n_rdkit_descriptors = len(Descriptors.descList) + + @property + def n_dim(self) -> int: + """Returns dimensionality of the computed features.""" + return self.n_rdkit_descriptors + + def get_molecule_features(self, mol: Mol) -> torch.Tensor: + """Returns features of the molecule. + + Args: + mol: An RDkit Chem.Mol object + + Returns: + A torch.tensor representing RDkit-computed 2D descriptors of the molecule. + """ + return torch.Tensor([f(mol) for desc_name, f in Descriptors.descList]) diff --git a/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_atom_featurizers.py b/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_atom_featurizers.py new file mode 100644 index 0000000000..20a8b7dec2 --- /dev/null +++ b/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_atom_featurizers.py @@ -0,0 +1,396 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch +from rdkit import Chem + +from bionemo.geometric.atom_featurizers import ( + AromaticityFeaturizer, + AtomicNumberFeaturizer, + AtomicRadiusFeaturizer, + ChiralTypeFeaturizer, + CrippenFeaturizer, + DegreeFeaturizer, + ElectronicPropertyFeaturizer, + HybridizationFeaturizer, + PeriodicTableFeaturizer, + ScaffoldFeaturizer, + SmartsFeaturizer, + TotalDegreeFeaturizer, + TotalNumHFeaturizer, +) + + +@pytest.fixture(scope="module") +def test_mol(): + return Chem.MolFromSmiles("NC(=O)c1cn(-c2ccc(S(N)(=O)=O)cc2)nc1-c1ccc(Cl)cc1") # CHEMBL3126825 + + +@pytest.fixture(scope="module") +def acetic_acid(): + return Chem.MolFromSmiles("CC(=O)O") + + +@pytest.fixture(scope="module") +def methylamine(): + return Chem.MolFromSmiles("CN") + + +@pytest.fixture(scope="module") +def chiral_mol(): + return Chem.MolFromSmiles("Cn1cc(C(=O)N2CC[C@@](O)(c3ccccc3)[C@H]3CCCC[C@@H]32)ccc1=O") + + +def test_atomic_num_featurizer(test_mol): + anf = AtomicNumberFeaturizer() + anf_feats = anf(test_mol) + + # Indicates the atomic number of the atom + anf_feats_ref = torch.tensor( + [7, 6, 8, 6, 6, 7, 6, 6, 6, 6, 16, 7, 8, 8, 6, 6, 7, 6, 6, 6, 6, 6, 17, 6, 6], dtype=torch.int + ) + assert torch.allclose(anf_feats, anf_feats_ref) + + +def test_degree_featurizer(test_mol): + df = DegreeFeaturizer() + df_feats = df(test_mol) + + # Indicates the total degree of connectivty (excluding hydrogens) of the atom + df_feats_ref = torch.tensor( + [1, 3, 1, 3, 2, 3, 3, 2, 2, 3, 4, 1, 1, 1, 2, 2, 2, 3, 3, 2, 2, 3, 1, 2, 2], dtype=torch.int + ) + assert torch.allclose(df_feats, df_feats_ref) + + +def test_total_degree_featurizer(test_mol): + tdf = TotalDegreeFeaturizer() + + tdf_feats = tdf(test_mol) + + # Indicates the total degree of connectivity (including hydrogens) of the atom + tdf_feats_ref = torch.tensor( + [3, 3, 1, 3, 3, 3, 3, 3, 3, 3, 4, 3, 1, 1, 3, 3, 2, 3, 3, 3, 3, 3, 1, 3, 3], dtype=torch.int + ) + assert torch.allclose(tdf_feats, tdf_feats_ref) + + +def test_chiral_type_featurizer(chiral_mol): + cf = ChiralTypeFeaturizer() + + cf_feats = cf(chiral_mol) + + # Indicates the type of atomic chirality as an integer + cf_feats_ref = torch.tensor( + [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0], dtype=torch.int + ) + assert torch.allclose(cf_feats, cf_feats_ref) + + +def test_total_numh_featurizer(test_mol): + num_hf = TotalNumHFeaturizer() + + h2_feats = num_hf(test_mol) + + # Indicates the total number of hydrogens on the atom + h2_feats_ref = torch.tensor( + [2, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 2, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1], dtype=torch.int + ) + assert torch.allclose(h2_feats, h2_feats_ref) + + +def test_hybridization_featurizer(test_mol, chiral_mol): + hf = HybridizationFeaturizer() + + hf_feats = hf(test_mol) + + # Indicated the hybridization of the atom as an integer + hf_feats_ref = torch.tensor( + [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3], dtype=torch.int + ) + assert torch.allclose(hf_feats, hf_feats_ref) + + +def test_aromaticity_featurizer(test_mol): + af = AromaticityFeaturizer() + af_feats = af(test_mol) + + # Indices if the atom is aromatic or not + af_feats_ref = torch.tensor( + [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1], dtype=torch.int + ) + assert torch.allclose(af_feats, af_feats_ref) + + +def test_periodic_table_featurizer(test_mol): + pt = PeriodicTableFeaturizer() + + pt_feats = pt(test_mol) + + # The reference is a tensor of dimension 2 + # 1st dim: Atoms in the molecule + # 2nd dim: [period, group] of the atom's position in the periodic table respectively. + # Example: pt_feats_ref[1, 0] indicates the period of the 2nd atom in the molecule. + pt_feats_ref = torch.tensor( + [ + (2, 5), + (2, 4), + (2, 6), + (2, 4), + (2, 4), + (2, 5), + (2, 4), + (2, 4), + (2, 4), + (2, 4), + (3, 6), + (2, 5), + (2, 6), + (2, 6), + (2, 4), + (2, 4), + (2, 5), + (2, 4), + (2, 4), + (2, 4), + (2, 4), + (2, 4), + (3, 7), + (2, 4), + (2, 4), + ], + dtype=torch.int, + ) + + assert torch.allclose(pt_feats, pt_feats_ref) + + +def test_electronic_property_featurizer(test_mol): + ep = ElectronicPropertyFeaturizer() + + ep_feats = ep(test_mol) + + # Reference is a tensor of dimension 2 + # 1st dim: Atoms in the molecule + # 2nd dim: [electronegativity, ionization energy, electron affinity] + ep_feats_ref = torch.Tensor( + [ + [3.04, 14.534, 1.0721403509], + [2.55, 11.26, 1.263], + [3.44, 13.618, 1.461], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [3.04, 14.534, 1.0721403509], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [2.58, 10.36, 2.077], + [3.04, 14.534, 1.0721403509], + [3.44, 13.618, 1.461], + [3.44, 13.618, 1.461], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [3.04, 14.534, 1.0721403509], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + [3.16, 12.968, 3.617], + [2.55, 11.26, 1.263], + [2.55, 11.26, 1.263], + ] + ) + + assert torch.allclose(ep_feats, ep_feats_ref) + + +def test_scaffold_featurizer(test_mol): + sf = ScaffoldFeaturizer() + sf_feats = sf(test_mol) + + # Indices if atom is present in the Bemis-Murcko scaffold of the molecule + sf_feats_ref = torch.tensor( + [ + False, + False, + False, + True, + True, + True, + True, + True, + True, + True, + False, + False, + False, + False, + True, + True, + True, + True, + True, + True, + True, + True, + False, + True, + True, + ], + dtype=torch.int, + ) + assert torch.allclose(sf_feats, sf_feats_ref) + + +def test_smarts_featurizer(test_mol, acetic_acid, methylamine): + sf = SmartsFeaturizer() + sf_feats = sf(test_mol) + + # Reference is a tensor of dim 2 + # 1st dim: Atoms in the molecules + # 2nd dim: [hydrogen bond donor, hydrogen bond acceptor, acidic, basic] + + sf_feats_ref = torch.tensor( + [ + [True, False, False, False], + [False, False, False, False], + [False, True, False, False], + [False, False, False, False], + [False, False, False, False], + [False, True, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [True, False, False, False], + [False, True, False, False], + [False, True, False, False], + [False, False, False, False], + [False, False, False, False], + [False, True, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + [False, False, False, False], + ], + dtype=torch.int, + ) + assert torch.allclose(sf_feats, sf_feats_ref) + + sf_feats = sf(acetic_acid) + sf_feats_ref = torch.tensor( + [ + [False, False, False, False], + [False, False, True, False], + [False, True, False, False], + [True, False, False, False], + ], + dtype=torch.int, + ) + assert torch.allclose(sf_feats, sf_feats_ref) + + sf_feats = sf(methylamine) + sf_feats_ref = torch.tensor([[False, False, False, False], [True, True, False, True]], dtype=torch.int) + assert torch.allclose(sf_feats, sf_feats_ref) + + +def test_crippen_featurizer(test_mol): + cf = CrippenFeaturizer() + + cf_feats = cf(test_mol) + + # Reference is of dimension 2 + # 1st dimension: Atoms in the molecule + # 2nd dimension: [logP, molar refractivity] + cf_feats_ref = torch.Tensor( + [ + [-1.019e00, 2.262e00], + [-2.783e-01, 5.007e00], + [1.129e-01, 2.215e-01], + [1.360e-01, 3.509e00], + [1.581e-01, 3.350e00], + [-3.239e-01, 2.202e00], + [2.713e-01, 3.904e00], + [1.581e-01, 3.350e00], + [1.581e-01, 3.350e00], + [1.893e-01, 2.673e00], + [-2.400e-03, 6.000e00], + [-1.019e00, 2.262e00], + [-3.339e-01, 7.774e-01], + [-3.339e-01, 7.774e-01], + [1.581e-01, 3.350e00], + [1.581e-01, 3.350e00], + [-3.239e-01, 2.202e00], + [2.713e-01, 3.904e00], + [2.713e-01, 3.904e00], + [1.581e-01, 3.350e00], + [1.581e-01, 3.350e00], + [2.450e-01, 3.564e00], + [6.895e-01, 5.853e00], + [1.581e-01, 3.350e00], + [1.581e-01, 3.350e00], + ] + ) + + assert torch.allclose(cf_feats, cf_feats_ref) + + +def test_atomic_radius_featurizer(test_mol): + arf = AtomicRadiusFeaturizer() + arf_feats = arf(test_mol) + + # Reference is a tensor of dimension 2 + # 1st dim: Atoms in the molecule + # 2nd dim: [bond radius, covalent radius, vdW radius] + arf_feats_ref = torch.Tensor( + [ + [0.7, 0.71, 1.6], + [0.77, 0.76, 1.7], + [0.66, 0.66, 1.55], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.7, 0.71, 1.6], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [1.04, 1.05, 1.8], + [0.7, 0.71, 1.6], + [0.66, 0.66, 1.55], + [0.66, 0.66, 1.55], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.7, 0.71, 1.6], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + [0.997, 1.02, 1.8], + [0.77, 0.76, 1.7], + [0.77, 0.76, 1.7], + ] + ) + + assert torch.allclose(arf_feats, arf_feats_ref) diff --git a/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_bond_featurizers.py b/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_bond_featurizers.py new file mode 100644 index 0000000000..5eaf925c7f --- /dev/null +++ b/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_bond_featurizers.py @@ -0,0 +1,62 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +from rdkit import Chem + +from bionemo.geometric.bond_featurizers import RingFeaturizer + + +@pytest.fixture(scope="module") +def test_mol2(): + return Chem.MolFromSmiles("C[C@H]1CN(c2ncnc3[nH]cc(-c4cccc(F)c4)c23)CCO1") # CHEMBL3927167 + + +def test_ring_featurizer(test_mol2): + rf = RingFeaturizer() + rf_feats = rf(test_mol2) + + # Reference is a list of tuples + # Each tuple contains the sizes of the rings the bond is present it + rf_feats_ref = [ + (), + (6,), + (6,), + (), + (6,), + (6,), + (6,), + (6,), + (5,), + (5,), + (5,), + (), + (6,), + (6,), + (6,), + (6,), + (), + (6,), + (5,), + (6,), + (6,), + (6,), + (6,), + (6,), + (6, 5), + (6,), + ] + assert rf_feats == rf_feats_ref diff --git a/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_molecule_featurizers.py b/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_molecule_featurizers.py new file mode 100644 index 0000000000..cb5384513f --- /dev/null +++ b/sub-packages/bionemo-geometric/tests/bionemo/geometric/test_molecule_featurizers.py @@ -0,0 +1,483 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import re + +import pytest +import torch +from rdkit import Chem +from rdkit.Chem import Descriptors + +from bionemo.geometric.molecule_featurizers import RDkit2DDescriptorFeaturizer + + +@pytest.fixture(scope="module") +def sample_mol(): + return Chem.MolFromSmiles("NC(=O)c1cn(-c2ccc(S(N)(=O)=O)cc2)nc1-c1ccc(Cl)cc1") # CHEMBL3126825 + + +@pytest.fixture(scope="module") +def sample_mol2(): + return Chem.MolFromSmiles("C[C@H]1CN(c2ncnc3[nH]cc(-c4cccc(F)c4)c23)CCO1") # CHEMBL3927167 + + +def test_rdkit2d_descriptor_featurizer(sample_mol, sample_mol2): + rdf = RDkit2DDescriptorFeaturizer() + mol_feats = rdf(sample_mol) + + # separate out int and float descriptors + int_desc_idx = [ + idx for idx, (name, _) in enumerate(Descriptors.descList) if re.search(r"(num|fr_|count)", name, re.IGNORECASE) + ] + float_desc_idx = list(set(range(len(Descriptors.descList))) - set(int_desc_idx)) + + # 2D RDkit descriptors listed in rdkit.Chem.Descriptors.descList + mol_feats_ref = torch.Tensor( + [ + 11.739234088578126, + 11.739234088578126, + 0.017170781893004028, + -3.781515243079616, + 0.7220230649240628, + 11.44, + 376.82500000000005, + 363.7210000000001, + 376.039688956, + 128, + 0, + 0.25206014374186, + -0.36548056472166857, + 0.36548056472166857, + 0.25206014374186, + 1.04, + 1.64, + 2.16, + 35.49569200759094, + 10.087164052685537, + 2.1660855035461717, + -2.027864781099429, + 2.2489599335785333, + -2.116891175408362, + 7.8876058111792995, + 0.10006104487344632, + 3.002802610441619, + 2.0768149956684177, + 1041.9888121550669, + 18.189869965382485, + 12.756237786950482, + 14.328663313896664, + 11.753038761063381, + 7.041763285225907, + 8.966047236156697, + 5.246005089352769, + 7.243863927292341, + 3.5271517413640963, + 4.708359290115149, + 2.2960288277468415, + 2.937456811390436, + -2.679999999999999, + 443165.6204594159, + 17.153053800207758, + 6.320498570343795, + 3.553955393718707, + 148.42311271634844, + 5.733667477162185, + 5.693927994848461, + 0.0, + 10.023291153407584, + 5.907179729351506, + 0.0, + 4.794537184071822, + 18.238573657082064, + 5.098681808301038, + 0.0, + 23.733674027155736, + 36.39820241076966, + 16.782928377051398, + 16.146321241898335, + 13.212334168400758, + 27.531410772991606, + 0.0, + 9.780484743446223, + 10.872641214770127, + 4.895483475517775, + 0.0, + 65.31386492474428, + 0.0, + 16.944765761229018, + 10.872641214770127, + 0.0, + 0.0, + 11.600939890232516, + 24.105461457126665, + 10.023291153407584, + 0.0, + 10.357988675768818, + 59.623263594823726, + 5.022633313741326, + 16.944765761229018, + 0.0, + 121.07000000000001, + 15.930470882759089, + 13.212334168400758, + 0.0, + 10.45893496721477, + 21.967399074970345, + 0.0, + 35.1441147806047, + 24.26546827384644, + 0.0, + 5.098681808301038, + 22.473581105002644, + 24.089632667996874, + 5.877622127433703, + 11.722063306685122, + 10.022775328080856, + 7.306696335665342, + -0.627448034769462, + 12.600266576990965, + 1.4843513794406649, + 0.0, + -3.781515243079616, + 0.0, + 25, + 4, + 7, + 0, + 0, + 0, + 2, + 1, + 3, + 5, + 2, + 9, + 4, + 0, + 0, + 0, + 3, + 1.9389999999999998, + 93.90109999999999, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ] + ) + + assert torch.allclose(mol_feats[float_desc_idx], mol_feats_ref[float_desc_idx]) + assert torch.all(mol_feats[int_desc_idx] == mol_feats_ref[int_desc_idx]) + + mol_feats = rdf(sample_mol2) + mol_feats_ref = torch.Tensor( + [ + 13.59718565265102, + 13.59718565265102, + 0.1577100655076844, + -0.2544035021415971, + 0.790191047029685, + 18.52173913043478, + 312.3480000000001, + 295.212, + 312.138639384, + 118, + 0, + 0.14300203502449213, + -0.3748311129862186, + 0.3748311129862186, + 0.14300203502449213, + 1.3478260869565217, + 2.260869565217391, + 3.0869565217391304, + 19.142144572357893, + 10.056111934300976, + 2.2213633877518912, + -2.319743090015102, + 2.338456916736118, + -2.4119088332112777, + 6.006799652275313, + 0.05302438950277102, + 2.9869932884921298, + 1.8682589828156948, + 847.4805792241272, + 15.81119030894213, + 12.79062577785999, + 12.79062577785999, + 11.220346690612276, + 7.667349370161911, + 7.667349370161911, + 5.7610037335759205, + 5.7610037335759205, + 4.1260534814726375, + 4.1260534814726375, + 3.0806881394164973, + 3.0806881394164973, + -2.4699999999999993, + 351363.0075186177, + 14.143261835899917, + 5.624189240497252, + 2.5482703016171846, + 132.67641196129384, + 14.620751205597735, + 23.609580914413193, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 14.358372089569237, + 0.0, + 0.0, + 12.13273413692322, + 24.619922828310838, + 24.849807875135223, + 18.097072566726016, + 9.127278001474869, + 16.85126421306755, + 0.0, + 14.951935562841626, + 0.0, + 13.027703587438927, + 24.59630450718855, + 42.606852761269955, + 0.0, + 11.126902983393991, + 4.899909730850478, + 10.208277825509848, + 0.0, + 0.0, + 40.75229672692799, + 4.736862953800049, + 5.817220841045895, + 6.923737199690624, + 36.78963192022406, + 0.0, + 22.160304418626517, + 0.0, + 54.040000000000006, + 0.0, + 4.39041504767482, + 0.0, + 11.921187228794198, + 6.606881964512918, + 41.067680008286686, + 12.13273413692322, + 12.393687143226153, + 12.263210640074686, + 26.775582493382725, + 4.736862953800049, + 19.208401570721648, + 0.0, + 14.165834278155707, + 0.9233333333333335, + 2.482647156084657, + 0.6119494834971028, + 6.578309193078312, + 3.5794837333081375, + 4.283374585154437, + 0.0, + 0.29411764705882354, + 23, + 1, + 5, + 0, + 1, + 1, + 1, + 2, + 3, + 4, + 1, + 6, + 2, + 0, + 1, + 1, + 4, + 2.9891000000000014, + 86.90970000000003, + 0, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + ] + ) + + assert torch.allclose(mol_feats[float_desc_idx], mol_feats_ref[float_desc_idx]) + assert torch.all(mol_feats[int_desc_idx] == mol_feats_ref[int_desc_idx]) diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py b/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py index d97ca3c127..0b150255ed 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py @@ -101,7 +101,7 @@ def bert_padding_collate_fn( "text": padding_value, "types": 0, "attention_mask": False, - "labels": -1, + "labels": -100, # This should match the masked value used in the MLM loss mask. "loss_mask": False, "is_random": 0, } diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/data/datamodule.py b/sub-packages/bionemo-llm/src/bionemo/llm/data/datamodule.py index 2bacb71fac..b86674ce7b 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/data/datamodule.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/data/datamodule.py @@ -16,7 +16,7 @@ from typing import Any, Dict -import pytorch_lightning as pl +import lightning.pytorch as pl from nemo.utils import logging diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py index e766e2e559..5219d830f9 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py @@ -15,7 +15,7 @@ from typing import Any, Callable, Dict, Generic, Iterable, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union -import pytorch_lightning as pl +import lightning.pytorch as pl import torch.distributed from megatron.core import parallel_state from megatron.core.optimizer.optimizer_config import OptimizerConfig diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/lightning.py b/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/lightning.py index 8d93adee2a..810ee37a77 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/lightning.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/lightning.py @@ -16,7 +16,7 @@ from typing import Callable, Dict, Iterable, Optional, Protocol, Sequence, TypedDict, cast -import pytorch_lightning as pl +import lightning.pytorch as pl import torch.distributed from apex.optimizers import FusedAdam from megatron.core import parallel_state diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/model.py b/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/model.py index 057859c388..cc14b6f7d9 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/model.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/model.py @@ -81,7 +81,12 @@ _OVERRIDE_BIOBERT_CONFIG_DEFAULTS: List[str] = OVERRIDE_BIONEMO_CONFIG_DEFAULTS + [ "return_only_hidden_states", "include_embeddings", + "include_input_ids", "include_hiddens", + # Precision override for starting from a checkpoint and casting to a different precision + "params_dtype", + "pipeline_dtype", + "autocast_dtype", # Model parallelism settings! Important to override these if the user requests different settings from how # a model was trained (common). See https://github.com/NVIDIA/bionemo-framework/issues/275 "tensor_model_parallel_size", @@ -164,6 +169,7 @@ def __init__( # noqa: D107 include_embeddings: bool = False, use_full_attention_mask: bool = False, include_hiddens: bool = False, + include_input_ids: bool = False, skip_logits: bool = False, # Useful for inference time. ): # TODO (@jstjohn) come up with a cleaner way for this model to return a set of things the user wants. @@ -195,6 +201,7 @@ def __init__( # noqa: D107 self.return_embeddings = return_embeddings self.include_embeddings = include_embeddings self.include_hiddens = include_hiddens + self.include_input_ids = include_input_ids self.skip_logits = skip_logits # megatron core pipelining currently depends on model type @@ -453,6 +460,8 @@ def forward( output = {"token_logits": logits, "binary_logits": binary_logits} if self.include_hiddens: output["hidden_states"] = hidden_states.transpose(0, 1).contiguous() # [s b h] => [b s h] + if self.include_input_ids: + output["input_ids"] = input_ids if self.include_embeddings: output["embeddings"] = output_embeddings return output @@ -515,6 +524,7 @@ class BioBertConfig( include_embeddings: bool = False return_only_hidden_states: bool = False include_hiddens: bool = False # Include hidden layers in the output of the model + include_input_ids: bool = False skip_logits: bool = False # useful for inference core_attention_override: Type[torch.nn.Module] | None = None @@ -565,6 +575,7 @@ def configure_model(self, tokenizer: AutoTokenizer) -> MegatronBioBertModelType: use_full_attention_mask=use_full_attention_mask, include_hiddens=self.include_hiddens, skip_logits=self.skip_logits, + include_input_ids=self.include_input_ids, ) # TODO (@skothenhill) this is a hack to load the old checkpoint. # This should be removed once we have a proper checkpoint conversion diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/testing_utils.py b/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/testing_utils.py index 9e4b46293e..40fd162a38 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/testing_utils.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/model/biobert/testing_utils.py @@ -14,7 +14,7 @@ # limitations under the License. -import pytorch_lightning as pl +import lightning.pytorch as pl import torch.nn.functional as F diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py b/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py index c3c2ef292d..e6c0f6177d 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py @@ -19,7 +19,7 @@ from dataclasses import field from typing import Any, Callable, Dict, Generic, List, Literal, Optional, Type, TypeVar -import pytorch_lightning as pl +import lightning.pytorch as pl import torch from pydantic import BaseModel, field_serializer, field_validator, model_validator from torch.nn import functional as F @@ -46,6 +46,21 @@ } +def deserialize_str_to_path(path: str) -> pathlib.Path: + """General purpose deserialize for string/path objects. Since YAML has no native representation for pathlib.Path, we serialize to strings. Import this method as a @field_validator.""" + return pathlib.Path(path) + + +def serialize_path_or_str(path: str | pathlib.Path) -> str: + """General purpose serialization for string/path objects. Since YAML has no native representation for pathlib.Path, we serialize to strings. Import this method as a @field_serializer.""" + if isinstance(path, pathlib.Path): + return str(path) + elif isinstance(path, str): + return path + else: + raise ValueError(f"Expected str or pathlib.Path, got {type(path)}") + + class DataConfig(BaseModel, Generic[DataModuleT], ABC): """Base class for all data configurations. @@ -58,6 +73,14 @@ class DataConfig(BaseModel, Generic[DataModuleT], ABC): num_dataset_workers: int = 0 seq_length: int = 128 + @field_serializer("result_dir") + def serialize_paths(self, value: pathlib.Path) -> str: # noqa: D102 + return serialize_path_or_str(value) + + @field_validator("result_dir") + def deserialize_paths(cls, value: str) -> pathlib.Path: # noqa: D102 + return deserialize_str_to_path(value) + @abstractmethod def construct_data_module(self, global_batch_size: int) -> DataModuleT: """Construct the data module from the configuration. Cannot be defined generically.""" @@ -158,6 +181,14 @@ def exposed_to_internal_bionemo_model_config(self) -> ModelConfigT: nemo1_ckpt_path: Optional[str] = None biobert_spec_option: BiobertSpecOption = BiobertSpecOption.bert_layer_with_transformer_engine_spec + @field_serializer("biobert_spec_option") + def serialize_spec_option(self, value: BiobertSpecOption) -> str: # noqa: D102 + return value.value + + @field_validator("biobert_spec_option", mode="before") + def deserialize_spec_option(cls, value: str) -> BiobertSpecOption: # noqa: D102 + return BiobertSpecOption(value) + @field_validator("activation_func", mode="before") @classmethod def validate_activation_func(cls, activation_func: str) -> Callable: @@ -294,6 +325,7 @@ class OptimizerSchedulerConfig(BaseModel): monitor (str): Metric to monitor for learning rate adjustments. Default is "val_loss". warmup_steps (int): Number of warmup steps for use with the warmup annealing learning rate scheduler. Default is 0. lr_scheduler (Literal['warmup_anneal', 'cosine']): Type of learning rate scheduler to use. Default is 'warmup_anneal'. NOTE this is likely to change. + max_steps (Optional[int]): max_steps used in optimizer. Default to None which uses max_steps from TrainingConfig. """ lr: float = 1e-4 @@ -304,6 +336,7 @@ class OptimizerSchedulerConfig(BaseModel): cosine_hold_frac: float = 0.05 warmup_steps: int = 0 lr_scheduler: Literal["warmup_anneal", "cosine"] = "warmup_anneal" + max_steps: Optional[int] = None class ExperimentConfig(BaseModel): @@ -330,6 +363,14 @@ class ExperimentConfig(BaseModel): save_top_k: int = 2 create_tensorboard_logger: bool = False + @field_serializer("result_dir") + def serialize_paths(self, value: pathlib.Path) -> str: # noqa: D102 + return serialize_path_or_str(value) + + @field_validator("result_dir") + def deserialize_paths(cls, value: str) -> pathlib.Path: # noqa: D102 + return deserialize_str_to_path(value) + # DataConfig -> some config that can make a data module (see ABC definition.) DataConfigT = TypeVar("DataConfigT", bound=DataConfig) diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/train.py b/sub-packages/bionemo-llm/src/bionemo/llm/train.py index cae6f9c848..7626deb43c 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/train.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/train.py @@ -19,6 +19,7 @@ from dataclasses import field from typing import Optional +from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm @@ -28,7 +29,6 @@ from nemo.lightning.pytorch.optim.lr_scheduler import CosineAnnealingScheduler from nemo.utils import logging from pydantic import BaseModel -from pytorch_lightning.callbacks import LearningRateMonitor, RichModelSummary from bionemo.llm.lightning import BionemoLightningModule, PerplexityLoggingCallback from bionemo.llm.model.biobert.lightning import biobert_lightning_module @@ -203,7 +203,7 @@ def train( # TODO: need an abstraction for LrSchedulerConfig if optim_config.lr_scheduler == "cosine": lr_scheduler = CosineAnnealingScheduler( - max_steps=training_config.max_steps, + max_steps=training_config.max_steps if optim_config.max_steps is None else optim_config.max_steps, min_lr=optim_config.lr / 100, warmup_steps=int(math.ceil(training_config.max_steps * optim_config.cosine_rampup_frac)), interval=optim_config.interval, @@ -213,7 +213,7 @@ def train( elif optim_config.lr_scheduler == "warmup_anneal": lr_scheduler = WarmupAnnealDecayHoldScheduler( warmup_steps=optim_config.warmup_steps, - max_steps=training_config.max_steps, + max_steps=training_config.max_steps if optim_config.max_steps is None else optim_config.max_steps, max_lr=optim_config.lr, min_lr=optim_config.lr / 10.0, anneal_percentage=0.10, diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py index 200438d444..57aab0759e 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py @@ -137,7 +137,7 @@ def infer_num_samples( If limit_batches is a float between 0 and 1, the number of samples is inferred as a fraction of the number of samples in the dataset. If limit_batches is an integer greater than or equal to 1, the number of limited samples is inferred - as the product of limit_batches and global batch size. If limit_batches is None, it defaultsto 1.0, indicating that + as the product of limit_batches and global batch size. If limit_batches is None, it defaults to 1.0, indicating that all dataset samples should be used. """ limit_batches = 1.0 if limit_batches is None else limit_batches # validation data does not require upsampling diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py index ebba878c66..912d67bf7b 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py @@ -15,11 +15,11 @@ import pathlib from typing import Any, Dict, List, Optional, Sequence +from lightning.pytorch.loggers import TensorBoardLogger, WandbLogger from nemo.lightning.nemo_logger import NeMoLogger from nemo.lightning.pytorch import callbacks as nemo_callbacks from nemo.utils import logging from pydantic import BaseModel -from pytorch_lightning.loggers import TensorBoardLogger, WandbLogger __all__: Sequence[str] = ( diff --git a/sub-packages/bionemo-llm/tests/bionemo/llm/data/test_collate.py b/sub-packages/bionemo-llm/tests/bionemo/llm/data/test_collate.py index e4929b9a22..d06aff3696 100644 --- a/sub-packages/bionemo-llm/tests/bionemo/llm/data/test_collate.py +++ b/sub-packages/bionemo-llm/tests/bionemo/llm/data/test_collate.py @@ -116,7 +116,7 @@ def test_bert_padding_collate_fn_with_padding(): "text": torch.tensor([4, 5, 6, 7, 8]), "types": torch.zeros((5,), dtype=torch.int64), "attention_mask": torch.tensor([True, True, True, True, True]), - "labels": torch.tensor([-1, 5, -1, 7, 8]), + "labels": torch.tensor([-100, 5, -100, 7, 8]), "loss_mask": torch.tensor([False, True, False, True, True]), "is_random": torch.zeros((5,), dtype=torch.int64), } @@ -134,7 +134,7 @@ def test_bert_padding_collate_fn_with_padding(): torch.tensor([[True, True, False, False, False], [True, True, True, True, True]]), ) ) - assert torch.all(torch.eq(collated_batch["labels"], torch.tensor([[7, 8, 9, -1, -1], [-1, 5, -1, 7, 8]]))) + assert torch.all(torch.eq(collated_batch["labels"], torch.tensor([[7, 8, 9, -100, -100], [-100, 5, -100, 7, 8]]))) assert torch.all( torch.eq( collated_batch["loss_mask"], @@ -158,7 +158,7 @@ def test_bert_padding_collate_fn_with_max_length_truncates(): "text": torch.tensor([4, 5, 6, 7, 8]), "types": torch.zeros((5,), dtype=torch.int64), "attention_mask": torch.tensor([True, True, True, True, True]), - "labels": torch.tensor([-1, 5, -1, 7, 8]), + "labels": torch.tensor([-100, 5, -100, 7, 8]), "loss_mask": torch.tensor([False, True, False, True, True]), "is_random": torch.zeros((5,), dtype=torch.int64), } @@ -175,7 +175,7 @@ def test_bert_padding_collate_fn_with_max_length_truncates(): collated_batch["attention_mask"], torch.tensor([[True, True, False, False], [True, True, True, True]]) ) ) - assert torch.all(torch.eq(collated_batch["labels"], torch.tensor([[7, 8, 9, -1], [-1, 5, -1, 7]]))) + assert torch.all(torch.eq(collated_batch["labels"], torch.tensor([[7, 8, 9, -100], [-100, 5, -100, 7]]))) assert torch.all( torch.eq(collated_batch["loss_mask"], torch.tensor([[True, False, True, False], [False, True, False, True]])) ) diff --git a/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_logger_utils.py b/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_logger_utils.py index 8d8c9d5b5c..179ac81b08 100644 --- a/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_logger_utils.py +++ b/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_logger_utils.py @@ -13,9 +13,132 @@ # See the License for the specific language governing permissions and # limitations under the License. -from bionemo.llm.utils.logger_utils import setup_nemo_lightning_logger +import logging +import pathlib + +import pytest +from lightning.pytorch.loggers import TensorBoardLogger, WandbLogger +from nemo import lightning as nl +from nemo.lightning.nemo_logger import NeMoLogger + +from bionemo.llm.utils.logger_utils import WandbConfig, setup_nemo_lightning_logger + + +@pytest.fixture +def project_name() -> str: + return "test_project" + + +@pytest.fixture +def wandb_config(project_name): + return WandbConfig( + entity=None, + project=project_name, + tags=["tag1", "tag2"], + group="test_group", + job_type="test_job", + offline=True, # ensure no actual communication with wandb servers + id=None, + anonymous=False, + log_model=False, + ) def test_construct_logger_no_wandb(): logger = setup_nemo_lightning_logger("test") assert logger.name == "test" + + +def test_setup_logger_all_loggers(tmp_path, wandb_config, project_name, caplog): + # Use a unique experiment name + exp_name = "unit-test-loggers" + root_dir = tmp_path # provided by pytest as a temporary directory + + with caplog.at_level(logging.WARNING): + logger = setup_nemo_lightning_logger( + name=exp_name, + root_dir=root_dir, + initialize_tensorboard_logger=True, + wandb_config=wandb_config, + ckpt_callback=None, + ) + + # Checks on the returned logger + assert isinstance(logger, NeMoLogger), "The returned logger should be a NeMoLogger instance." + assert logger.name == exp_name + + # Check that directories are set up correctly + expected_save_dir = root_dir / exp_name + assert logger.save_dir == expected_save_dir, "NeMoLogger save_dir should match expected path." + assert not expected_save_dir.exists(), "Expected experiment directory should not be created yet." + + # Check TensorBoard logger initialization + tb_logger = logger.tensorboard + assert isinstance(tb_logger, TensorBoardLogger), "TensorBoardLogger should be created." + tb_log_dir = pathlib.Path(tb_logger.log_dir) + assert not tb_log_dir.is_dir(), "TensorBoard log directory should not exist yet." + assert tb_logger.name == exp_name, "TensorBoardLogger name should match experiment name." + + # Check WandB logger initialization + wandb_logger = logger.wandb + assert isinstance(wandb_logger, WandbLogger), "WandBLogger should be created." + # Validate that wandb_logger uses correct save_dir and name + # WandbLogger's experiment is lazily created, so just check configured values + assert wandb_logger.name != exp_name, "WandBLogger name should not match experiment name." + assert wandb_logger.name == project_name, "WandBLogger name should match project name." + assert pathlib.Path(wandb_logger.save_dir) == expected_save_dir, "WandBLogger save_dir should match expected path." + # Since we provided wandb_config and tensorboard was enabled, we should NOT see + # the warnings about them being turned off. + assert "WandB is currently turned off." not in caplog.text + assert "User-set tensorboard is currently turned off." not in caplog.text + + +def test_nemo_logger_initilized(tmp_path, wandb_config, project_name, caplog): + # Use a unique experiment name + exp_name = "unit-test-loggers" + root_dir = tmp_path # provided by pytest as a temporary directory + trainer = nl.Trainer(devices=1, accelerator="gpu", num_nodes=1) + + logger = setup_nemo_lightning_logger( + name=exp_name, + root_dir=root_dir, + initialize_tensorboard_logger=True, + wandb_config=wandb_config, + ckpt_callback=None, + ) + + # as in https://github.com/NVIDIA/NeMo/blob/bb895bc4b28ba99d707cb907c4496297a2a7b533/nemo/collections/llm/api.py#L852C22-L856C6 + logger.setup(trainer=trainer) + + # Check that directories are set up correctly + expected_save_dir = root_dir / exp_name + assert expected_save_dir.exists(), "Expected experiment directory should not be created yet." + + # Check TensorBoard logger initialization + tb_logger = logger.tensorboard + tb_log_dir = pathlib.Path(tb_logger.log_dir) + assert not tb_log_dir.is_dir(), "TensorBoard log directory should not exist yet." + + # Trigger lazy creation of experiment in loggers so loggers have their metadata available + # following trainer setup at the start of the training in + # https://github.com/Lightning-AI/pytorch-lightning/blob/de7c28ae865b5c9fd3ff21debebb994605f7f420/src/lightning/pytorch/trainer/trainer.py#L944 + # which executes + # https://github.com/Lightning-AI/pytorch-lightning/blob/caa9e1e59436913e365bf52eeb2b07e3bf67efac/src/lightning/pytorch/trainer/call.py#L94C1-L97C34 + for _logger in trainer.loggers: + if hasattr(_logger, "experiment"): + _ = _logger.experiment + + +def test_setup_logger_wandb_experiment(tmp_path, wandb_config, project_name, caplog): + exp_name = "unit-test-loggers" + root_dir = tmp_path # provided by pytest as a temporary directory + + logger = setup_nemo_lightning_logger( + name=exp_name, + root_dir=root_dir, + initialize_tensorboard_logger=True, + wandb_config=wandb_config, + ckpt_callback=None, + ) + wandb_logger = logger.wandb + _ = wandb_logger.experiment diff --git a/sub-packages/bionemo-noodles/.gitignore b/sub-packages/bionemo-noodles/.gitignore new file mode 100644 index 0000000000..ea8c4bf7f3 --- /dev/null +++ b/sub-packages/bionemo-noodles/.gitignore @@ -0,0 +1 @@ +/target diff --git a/sub-packages/bionemo-noodles/Cargo.lock b/sub-packages/bionemo-noodles/Cargo.lock new file mode 100644 index 0000000000..ffe0dfefd5 --- /dev/null +++ b/sub-packages/bionemo-noodles/Cargo.lock @@ -0,0 +1,434 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "adler2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" + +[[package]] +name = "autocfg" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" + +[[package]] +name = "bitflags" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" + +[[package]] +name = "bstr" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "crc32fast" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80" + +[[package]] +name = "flate2" +version = "1.0.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "indoc" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306" + +[[package]] +name = "libc" +version = "0.2.162" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398" + +[[package]] +name = "lock_api" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "memmap2" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f" +dependencies = [ + "libc", +] + +[[package]] +name = "memoffset" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1" +dependencies = [ + "autocfg", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1" +dependencies = [ + "adler2", +] + +[[package]] +name = "noodles-bgzf" +version = "0.33.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b50aaa8f0a3c8a0b738b641a6d1a78d9fd30a899ab2d398779ee3c4eb80f1c1" +dependencies = [ + "byteorder", + "bytes", + "crossbeam-channel", + "flate2", +] + +[[package]] +name = "noodles-core" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5a8c6b020d1205abef2b0fab4463a6c5ecc3c8f4d561ca8b0d1a42323376200" +dependencies = [ + "bstr", +] + +[[package]] +name = "noodles-fasta" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fde46cd7109fec9bb035ddceb95476531d057c1e61106b79a3a5b8d7ee7d5ee9" +dependencies = [ + "bstr", + "bytes", + "memchr", + "noodles-bgzf", + "noodles-core", +] + +[[package]] +name = "noodles_fasta_wrapper" +version = "0.1.0" +dependencies = [ + "memmap2", + "noodles-core", + "noodles-fasta", + "pyo3", +] + +[[package]] +name = "once_cell" +version = "1.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" + +[[package]] +name = "parking_lot" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + +[[package]] +name = "proc-macro2" +version = "1.0.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pyo3" +version = "0.18.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3b1ac5b3731ba34fdaa9785f8d74d17448cd18f30cf19e0c7e7b1fdb5272109" +dependencies = [ + "cfg-if", + "indoc", + "libc", + "memoffset", + "parking_lot", + "pyo3-build-config", + "pyo3-ffi", + "pyo3-macros", + "unindent", +] + +[[package]] +name = "pyo3-build-config" +version = "0.18.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cb946f5ac61bb61a5014924910d936ebd2b23b705f7a4a3c40b05c720b079a3" +dependencies = [ + "once_cell", + "target-lexicon", +] + +[[package]] +name = "pyo3-ffi" +version = "0.18.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd4d7c5337821916ea2a1d21d1092e8443cf34879e53a0ac653fbb98f44ff65c" +dependencies = [ + "libc", + "pyo3-build-config", +] + +[[package]] +name = "pyo3-macros" +version = "0.18.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d39c55dab3fc5a4b25bbd1ac10a2da452c4aca13bb450f22818a002e29648d" +dependencies = [ + "proc-macro2", + "pyo3-macros-backend", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "pyo3-macros-backend" +version = "0.18.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97daff08a4c48320587b5224cc98d609e3c27b6d437315bd40b605c98eeb5918" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "redox_syscall" +version = "0.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f" +dependencies = [ + "bitflags", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "serde" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.87", +] + +[[package]] +name = "smallvec" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.87" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "target-lexicon" +version = "0.12.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1" + +[[package]] +name = "unicode-ident" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe" + +[[package]] +name = "unindent" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c" + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" diff --git a/sub-packages/bionemo-noodles/Cargo.toml b/sub-packages/bionemo-noodles/Cargo.toml new file mode 100644 index 0000000000..f5ea230dbd --- /dev/null +++ b/sub-packages/bionemo-noodles/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "noodles_fasta_wrapper" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib"] +name = "noodles_fasta_wrapper" # The name of the library +path = "rust/src/lib.rs" # Path to the library file + +[dependencies] +pyo3 = { version = "0.18", features = ["extension-module"] } +noodles-fasta = "0.45.0" # Update to the latest version of noodles +noodles-core = "*" +memmap2 = "*" + +[package.metadata.pyo3] +name = "noodles_fasta_wrapper" diff --git a/sub-packages/bionemo-noodles/LICENSE b/sub-packages/bionemo-noodles/LICENSE new file mode 120000 index 0000000000..61bc2cda7e --- /dev/null +++ b/sub-packages/bionemo-noodles/LICENSE @@ -0,0 +1 @@ +../../LICENSE/license.txt \ No newline at end of file diff --git a/sub-packages/bionemo-noodles/README.md b/sub-packages/bionemo-noodles/README.md new file mode 100644 index 0000000000..c0bb45286c --- /dev/null +++ b/sub-packages/bionemo-noodles/README.md @@ -0,0 +1,11 @@ +# bionemo-noodles + +To install, execute the following: +```bash +pip install -e . +``` + +To run unit tests, execute: +```bash +pytest -v . +``` diff --git a/sub-packages/bionemo-noodles/VERSION b/sub-packages/bionemo-noodles/VERSION new file mode 120000 index 0000000000..558194c5a5 --- /dev/null +++ b/sub-packages/bionemo-noodles/VERSION @@ -0,0 +1 @@ +../../VERSION \ No newline at end of file diff --git a/sub-packages/bionemo-noodles/pyproject.toml b/sub-packages/bionemo-noodles/pyproject.toml new file mode 100644 index 0000000000..73a7505ec9 --- /dev/null +++ b/sub-packages/bionemo-noodles/pyproject.toml @@ -0,0 +1,35 @@ +[build-system] +requires = ["maturin>=1.0,<2.0"] +build-backend = "maturin" + +[project] +name = "bionemo-noodles" +readme = "README.md" +description = "Python wrapper around [noodles](https://github.com/zaeleus/noodles)." +authors = [{ name = "BioNeMo Team", email = "bionemofeedback@nvidia.com" }] +requires-python = ">=3.10" +license = { file = "LICENSE" } +dynamic = ["version"] +dependencies = [ + # internal + 'bionemo-core', + # external +] + +[tool.maturin] +bindings = "pyo3" +# TODO can we provide more compatability? +compatibility = "linux" +python-source = "src" +# we could make this bionemo.noodles.fasta_wrapper, but that would require it to be its own namespaced package. +module-name = "bionemo.noodles_fasta_wrapper" +version = { file = "VERSION" } + +[tool.setuptools.packages.find] +where = ["src"] +include = ["bionemo.*"] +namespaces = true +exclude = ["test*."] + +[tool.uv] +cache-keys = [{ git = true }] diff --git a/sub-packages/bionemo-noodles/requirements.txt b/sub-packages/bionemo-noodles/requirements.txt new file mode 100644 index 0000000000..dbf962fd41 --- /dev/null +++ b/sub-packages/bionemo-noodles/requirements.txt @@ -0,0 +1 @@ +maturin diff --git a/sub-packages/bionemo-noodles/rust/src/lib.rs b/sub-packages/bionemo-noodles/rust/src/lib.rs new file mode 100644 index 0000000000..04199345ea --- /dev/null +++ b/sub-packages/bionemo-noodles/rust/src/lib.rs @@ -0,0 +1,662 @@ +use memmap2::Mmap; +use noodles_fasta::{self as fasta, fai}; +use pyo3::prelude::*; +use pyo3::types::PyType; +use std::fs::File; +use std::io; +use std::path::Path; +use std::path::PathBuf; + +/// Python wrapper around the faidx Record struct. +/// Fields: +/// - name: name of the record, corresponds to a sequence id in the indexed fasta file. +/// - length: length of the record, number of bases/nucleotides/characters in the record, including Ns. +/// - offset: offset of the record's first base/nucleotide/character in bytes, from the start of the file. +/// - line_bases: number of bases per line in the fasta file +/// - line_width: number of bytes per line in the fasta file, including newlines, return carriages, etc. +#[pyclass] +#[derive(Clone)] +struct PyFaidxRecord { + name: String, + length: u64, + offset: u64, + line_bases: u64, + line_width: u64, +} + +#[pymethods] +impl PyFaidxRecord { + #[getter] + fn name(&self) -> &str { + &self.name + } + + #[getter] + fn length(&self) -> u64 { + self.length + } + + #[getter] + fn offset(&self) -> u64 { + self.offset + } + + #[getter] + fn line_bases(&self) -> u64 { + self.line_bases + } + + #[getter] + fn line_width(&self) -> u64 { + self.line_width + } + fn __str__(&self) -> String { + format!( + "PyFaidxRecord(name={}, length={}, offset={}, line_bases={}, line_width={})", + self.name, self.length, self.offset, self.line_bases, self.line_width + ) + } + + fn __repr__(&self) -> String { + format!( + "", + self.name, self.length, self.offset, self.line_bases, self.line_width + ) + } +} + +impl From<&fai::Record> for PyFaidxRecord { + fn from(record: &fai::Record) -> Self { + Self { + name: String::from_utf8_lossy(record.name()).to_string(), + length: record.length(), + offset: record.offset(), + line_bases: record.line_bases(), + line_width: record.line_width(), + } + } +} + +#[pyclass] +struct PyIndexedMmapFastaReader { + inner: IndexedMmapFastaReader, +} + +#[pymethods] +impl PyIndexedMmapFastaReader { + #[new] + #[pyo3(signature = (fasta_path, ignore_existing_fai = true))] + fn new(fasta_path: &str, ignore_existing_fai: bool) -> PyResult { + match IndexedMmapFastaReader::new(fasta_path, ignore_existing_fai) { + Ok(inner) => Ok(Self { inner }), + Err(e) => { + let py_err = match e.kind() { + std::io::ErrorKind::NotFound => { + pyo3::exceptions::PyFileNotFoundError::new_err(format!("{}", e)) + } + std::io::ErrorKind::PermissionDenied => { + pyo3::exceptions::PyPermissionError::new_err(format!("{}", e)) + } + _ => pyo3::exceptions::PyRuntimeError::new_err(format!("{}", e)), + }; + Err(py_err) + } + } + } + /// Create a new IndexedMmapFastaReader from a fasta file and a fai file explicitly. + #[classmethod] + fn from_fasta_and_faidx( + _cls: &PyType, + fasta_filename: &str, + fasta_fai_filename: &str, + ) -> PyResult { + match IndexedMmapFastaReader::from_fasta_and_faidx(fasta_filename, fasta_fai_filename) { + Ok(inner) => Ok(Self { inner }), + Err(e) => { + let py_err = match e.kind() { + std::io::ErrorKind::NotFound => { + pyo3::exceptions::PyFileNotFoundError::new_err(format!("{}", e)) + } + std::io::ErrorKind::PermissionDenied => { + pyo3::exceptions::PyPermissionError::new_err(format!("{}", e)) + } + _ => pyo3::exceptions::PyRuntimeError::new_err(format!("{}", e)), + }; + Err(py_err) + } + } + } + + #[staticmethod] + fn create_faidx(fasta_filename: &str) -> PyResult { + match IndexedMmapFastaReader::create_faidx(fasta_filename) { + Ok(fai_filename) => Ok(fai_filename), + Err(e) => { + let py_err = match e.kind() { + std::io::ErrorKind::AlreadyExists => { + pyo3::exceptions::PyFileExistsError::new_err(format!("{}", e)) + } + std::io::ErrorKind::PermissionDenied => { + pyo3::exceptions::PyPermissionError::new_err(format!("{}", e)) + } + _ => pyo3::exceptions::PyRuntimeError::new_err(format!("{}", e)), + }; + Err(py_err) + } + } + } + + fn records(&self) -> Vec { + return self + .inner + .index + .as_ref() + .iter() + .map(|record| PyFaidxRecord::from(record)) + .collect(); + } + fn read_sequence_mmap(&self, region_str: &str) -> PyResult { + self.inner + .read_sequence_mmap(region_str) + .map_err(|e| match e.kind() { + std::io::ErrorKind::InvalidInput => { + pyo3::exceptions::PyValueError::new_err(format!("Invalid input: {}", e)) + } + std::io::ErrorKind::NotFound => { + pyo3::exceptions::PyFileNotFoundError::new_err(format!("File not found: {}", e)) + } + std::io::ErrorKind::PermissionDenied => { + pyo3::exceptions::PyPermissionError::new_err(format!( + "Permission denied: {}", + e + )) + } + _ => pyo3::exceptions::PyRuntimeError::new_err(format!("Unexpected error: {}", e)), + }) + } +} + +#[pymodule] +fn noodles_fasta_wrapper(_: Python, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + Ok(()) +} + +struct IndexedMmapFastaReader { + mmap_reader: memmap2::Mmap, + index: fai::Index, +} + +impl IndexedMmapFastaReader { + fn from_fasta_and_faidx(fasta_path: &str, fasta_fai_path: &str) -> std::io::Result { + let fasta_path = Path::new(fasta_path); + if !fasta_path.exists() { + return Err(std::io::Error::new( + std::io::ErrorKind::NotFound, + format!("Fasta file {} not found", fasta_path.display()), + )); + } + let index = load_index_from_filename(fasta_fai_path)?; + let fd = File::open(fasta_path)?; + let mmap_reader = unsafe { memmap2::MmapOptions::new().map(&fd) }?; + Ok(IndexedMmapFastaReader { mmap_reader, index }) + } + + fn from_fasta(fasta_path: &str) -> std::io::Result { + let fasta_path = Path::new(fasta_path); + let fd = File::open(fasta_path)?; + let index: fai::Index = fasta::io::index(fasta_path).map_err(|e| { + std::io::Error::new( + std::io::ErrorKind::Other, + format!( + "For fasta file {}, Failed to create index: {}", + fasta_path.display(), + e + ), + ) + })?; + let mmap_reader = unsafe { memmap2::MmapOptions::new().map(&fd) }?; + Ok(IndexedMmapFastaReader { mmap_reader, index }) + } + + fn create_faidx(fasta_filename: &str) -> std::io::Result { + let fasta_path = Path::new(fasta_filename); + let index: fai::Index = fasta::io::index(fasta_path).map_err(|e| { + std::io::Error::new( + std::io::ErrorKind::Other, + format!( + "For fasta file {}, Failed to create index: {}", + fasta_path.display(), + e + ), + ) + })?; + + let fai_filename = fasta_filename.to_string() + ".fai"; + let fai_path = Path::new(&fai_filename); // Convert back to a Path + if fai_path.exists() { + return Err(std::io::Error::new( + std::io::ErrorKind::AlreadyExists, + format!("Fai file {} already exists", fai_path.display()), + )); + } + + let fai_file = File::create(&fai_path).map_err(|e| { + std::io::Error::new( + std::io::ErrorKind::Other, + format!("Failed to create .fai file: {}", e), + ) + })?; + let mut writer = fai::Writer::new(fai_file); + writer.write_index(&index).map_err(|e| { + std::io::Error::new( + std::io::ErrorKind::Other, + format!("Failed to write .fai index: {}", e), + ) + })?; + + return Ok(fai_filename); + } + + fn new(fasta_path: &str, ignore_existing_fai: bool) -> std::io::Result { + if !ignore_existing_fai { + // load the .fai files if they exist + let fasta_fai_path = fasta_path.to_string() + ".fai"; + Self::from_fasta_and_faidx(fasta_path, &fasta_fai_path as &str) + } else { + Self::from_fasta(fasta_path) + } + } + + fn read_sequence_mmap(&self, region_str: &str) -> std::io::Result { + // given a region string, query the value inside the mmap. + let query_result = &read_sequence_mmap(&self.index, &self.mmap_reader, region_str)?; + let result = String::from_utf8_lossy(query_result).into_owned(); + return Ok(result); + } +} + +/// gets the byte offset for the last base of the record, as its not available in the index. +fn fai_record_end_offset(record: &fai::Record) -> usize { + let length = record.length() - 1; + let num_full_lines = length / record.line_bases(); + let num_bases_remain = length % record.line_bases(); + + let bytes_to_last_line_in_record = num_full_lines * record.line_width(); + let bytes_to_end = bytes_to_last_line_in_record + num_bases_remain; + + return (record.offset() + bytes_to_end) as usize; +} + +/// Given a record and an interval, compute the byte offset for the last byte included in the interval. +fn query_end_offset( + record: &fai::Record, + interval: &noodles_core::region::Interval, +) -> io::Result { + // This is lifted from how we compute offset for start position, should be the same. + let end = interval + .end() // Extract the end position + .map(|position| usize::from(position) - 1) + .unwrap_or_default(); // Default to 0 if unbounded + + // TODO: technically a region with no end is valid, but we pretend its not! + // subtract 1 to get back to zero based indexing. + let end = u64::try_from(end).map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?; + + let pos = record.offset() // Start of the contig in bytes + + end / record.line_bases() * record.line_width() // Full lines before `end` + + end % record.line_bases(); // Byte offset within the last line + + Ok(pos as usize) +} + +/// Given an index, a memory-mapped file, and a region string, read the sequence from the file. +/// This function unwraps the region string, clams the query to the final read, and then invokes the read function. +fn read_sequence_mmap(index: &fai::Index, reader: &Mmap, region_str: &str) -> io::Result> { + let region: noodles_core::region::Region = region_str.parse().map_err(|e| { + std::io::Error::new( + std::io::ErrorKind::InvalidInput, + format!("{} Invalid region: {}", e, region_str), + ) + })?; + + // byte offset for the start of this contig + sequence. + let start = index.query(®ion)?; + + // index record for this contig. + let record = index + .as_ref() + .iter() + .find(|record| record.name() == region.name()) + .ok_or_else(|| { + io::Error::new( + io::ErrorKind::InvalidInput, + format!("invalid reference sequence name: {}", region.name(),), + ) + })?; + + // byte offset for the end of this query + let mut end = query_end_offset(record, ®ion.interval())?; + // byte offset for the end of this record, we want to take the smaller of these two, as sometimes we can have silly queries like chr1:1-9999999999999999 + end = end.min(fai_record_end_offset(record)); + + // call out to our reader and populate the result. + let mut result = vec![]; + let _ = read_range_from_mmap( + reader, + start as usize, + end as usize, // last offset for the sequence + &record, + &mut result, + ); + return Ok(result); +} + +/// Compute the number of bytes from start to the end of the line, half interval. +/// this means the returned position will the byte offset of a newline. +fn bases_remaining_in_first_line_read( + region_start: usize, + start: usize, + line_bases: usize, + line_width: usize, +) -> usize { + let lines_to_start = (start - region_start) / line_width; + let current_line_start = (line_width * lines_to_start) + region_start; + let bases_we_skip = start - current_line_start; + let bases_left_in_line = line_bases - bases_we_skip; + + return bases_left_in_line; +} + +fn read_range_from_mmap( + mmap: &Mmap, // Memory-mapped file + start: usize, // Start position in the file (from the index) + end: usize, // bases to read + index_record: &fai::Record, // index record for the contig + buf: &mut Vec, // Buffer to store the sequence +) -> io::Result { + // Reads all of the nucleotides from the `start` offset to the `end` offset. + // The approach roughly goes like this: + // 1) read as many bytes as we can until the first newline. This is done analytically so we can make batch reads. + // 2) read as many complete lines as we can, skipping newlines. Again this is done analytically. + // 3) read any remaining nucleotides. + + // some convenient unpacking + let line_bases: usize = index_record.line_bases() as usize; + let line_width: usize = index_record.line_width() as usize; + let region_start: usize = index_record.offset() as usize; + + let mut position = start; + + // if we are in the middle of a line, figure out how far to the end + let first_read_to_end = + position + bases_remaining_in_first_line_read(region_start, start, line_bases, line_width); + + // Handle the special case where we are a subset of a line + if first_read_to_end > end { + buf.extend_from_slice(&mmap[position..end + 1]); + return Ok(buf.len()); + } else { + // otherwise, read to the end of the line + buf.extend_from_slice(&mmap[position..first_read_to_end]); + let bytes_read = first_read_to_end - position; + position = position + bytes_read + (line_width - line_bases); + } + + // figure out how many full lines are left. + let full_lines_to_read = (end - position) / line_width; + let mut full_lines_read: usize = 0; + + // read as many full lines as we can + while full_lines_read < full_lines_to_read { + buf.extend_from_slice(&mmap[position..position + line_bases]); + full_lines_read += 1; + position += line_width; + } + + // if there are any bytes left, read them. + let remaining_bytes = (end + 1) - position; + buf.extend_from_slice(&mmap[position..position + remaining_bytes]); + Ok(buf.len()) +} + +fn load_index_from_filename(fai_path: &str) -> Result { + let fai_path = PathBuf::from(fai_path); + let fai_fd = File::open(fai_path)?; + let mut reader = fai::io::Reader::new(std::io::BufReader::new(fai_fd)); // Wrap the File in a BufReader + let idx = reader.read_index(); + return idx; +} + +#[test] +fn test_query_end_offset() { + // tests a single row, end of line position + let record = fai::Record::new("chr1", 12, 6, 12, 13); + + let region_str = "chr1:1-12"; + let region: noodles_core::region::Region = region_str.parse().unwrap(); + + let result = query_end_offset(&record, ®ion.interval()).unwrap(); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 [17] 18 + assert_eq!(result, 17); + + let record = fai::Record::new("chr1", 24, 6, 12, 13); + let region_str = "chr1:1-24"; + let region: noodles_core::region::Region = region_str.parse().unwrap(); + + let result = query_end_offset(&record, ®ion.interval()).unwrap(); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 17 18 + // 19 20 21 22 23 24 25 26 27 28 29 [30] 31 + assert_eq!(result, 30); + + // tests a three row, beginning of line position + let record = fai::Record::new("chr1", 25, 6, 12, 13); + let region_str = "chr1:1-25"; + let region: noodles_core::region::Region = region_str.parse().unwrap(); + + let result = query_end_offset(&record, ®ion.interval()).unwrap(); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 17 18 + // 19 20 21 22 23 24 25 26 27 28 29 30 31 + // [32] 33 + assert_eq!(result, 32); + + // tests a random position within a row. + let region_str = "chr1:1-6"; + let region: noodles_core::region::Region = region_str.parse().unwrap(); + + let result = query_end_offset(&record, ®ion.interval()).unwrap(); + // 01 02 03 04 05 + // 06 07 08 09 10 [11] 12 13 14 15 16 17 18 + assert_eq!(result, 11); +} + +#[test] +fn test_fai_record_end_offset() { + // tests a single row, end of line position + let record = fai::Record::new("chr1", 12, 6, 12, 13); + + // expect 17 because offset is 6, 12 characters to read, this is the offset OF THE LAST CHAR, it IS NOT a bound (e.g its inclusive) + let result = fai_record_end_offset(&record); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 [17] 18 + // 19 20 21 22 23 24 25 26 27 28 29 30 31 + assert_eq!(result, 17); + + // tests a two row, end of line position + let record = fai::Record::new("chr1", 24, 6, 12, 13); + let result = fai_record_end_offset(&record); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 17 18 + // 19 20 21 22 23 24 25 26 27 28 29 [30] 31 + assert_eq!(result, 30); + + // tests a three row, beginning of line position + let record = fai::Record::new("chr1", 25, 6, 12, 13); + let result = fai_record_end_offset(&record); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 17 18 + // 19 20 21 22 23 24 25 26 27 28 29 30 31 + // [32] 33 + assert_eq!(result, 32); + + // tests a two row, middle of line position + let record = fai::Record::new("chr1", 20, 6, 12, 13); + let result = fai_record_end_offset(&record); + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 17 18 + // 19 20 21 22 23 24 25 [26] 27 28 29 30 31 + assert_eq!(result, 26); +} + +#[test] +fn test_bases_remaining_in_first_line_read() { + // >seq1 + // ACGTACACGTAC + // ACGTACGTACGT + + // 01 02 03 04 05 + // 06 07 08 09 10 11 12 13 14 15 16 17 18 + // 19 20 21 [22] 23 24 25 26 27 28 29 30 31 + // + // region_start = 6 + // start = 22 (16 in base space) + // line_width = 13 + // line_bases = 12 + + // tests a three row, beginning of line position + let record = fai::Record::new("chr1", 25, 6, 12, 13); + let start = 22; + let result = bases_remaining_in_first_line_read( + record.offset() as usize, + start, + record.line_bases() as usize, + record.line_width() as usize, + ); + assert_eq!(result, 9); + + let start = 6; + // mem[6:6+12] + // this is the null case, where first base is the first character + let result = bases_remaining_in_first_line_read( + record.offset() as usize, + start, + record.line_bases() as usize, + record.line_width() as usize, + ); + assert_eq!(result, record.line_bases() as usize); // should be equal to line_bases since we need to read the whole line. + + // now we are at the very last character + let start = 17; + let result = bases_remaining_in_first_line_read( + record.offset() as usize, + start, + record.line_bases() as usize, + record.line_width() as usize, + ); + // expect the last position, so the read will be just 1! + assert_eq!(result, 1); +} + +#[test] +fn test_invalid_fai_fails() { + let fai_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) // Base directory of the project + .join("tests/bionemo/noodles/data/bad_index.fasta.fai"); + let fai_fd = File::open(&fai_path).unwrap(); + let mut reader = fai::io::Reader::new(std::io::BufReader::new(fai_fd)); // Wrap the File in a BufReader + let index: Result = reader.read_index(); + assert!(index.is_err()); + + // tests our impl to make sures it matches above + let index = load_index_from_filename(&fai_path.to_str().unwrap()); + assert!(index.is_err()); +} + +#[test] +fn test_create_from_fasta_faidx_no_fai() { + IndexedMmapFastaReader::from_fasta_and_faidx( + "tests/bionemo/noodles/data/sample.fasta", + "tests/bionemo/noodles/data/sample.fasta.fai", + ) + .unwrap(); + assert!(IndexedMmapFastaReader::from_fasta_and_faidx( + "tests/bionemo/noodles/data/sample.fasta", + "asdfasdfasdf" + ) + .is_err()); +} + +#[test] +fn test_valid_fai_is_read() { + let fai_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) // Base directory of the project + .join("tests/bionemo/noodles/data/sample.fasta.fai"); + let fai_fd = File::open(&fai_path).unwrap(); + let mut reader = fai::io::Reader::new(std::io::BufReader::new(fai_fd)); // Wrap the File in a BufReader + let index = reader.read_index().unwrap(); + + let records: Vec<_> = index.as_ref().iter().collect(); + assert_eq!(records.len(), 5); + + // test our implementation to ensure it matches. + let index = load_index_from_filename(&fai_path.to_str().unwrap()).unwrap(); + let records: Vec<_> = index.as_ref().iter().collect(); + assert_eq!(records.len(), 5); +} + +#[test] +fn test_mmap_reads() { + let fasta_filename = PathBuf::from(env!("CARGO_MANIFEST_DIR")) // Base directory of the project + .join("tests/bionemo/noodles/data/sample.fasta"); + let reader = IndexedMmapFastaReader::from_fasta(fasta_filename.to_str().unwrap()).unwrap(); + + // Note these are the same tests we use in python, but having them here can prevent us from building a wheel with broken code. + assert_eq!(reader.read_sequence_mmap("chr1:1-1").unwrap(), "A"); + assert_eq!(reader.read_sequence_mmap("chr1:1-2").unwrap(), "AC"); + assert_eq!(reader.read_sequence_mmap("chr1:1-100000").unwrap(), "ACTGACTGACTG"); + assert_eq!(reader.read_sequence_mmap("chr2:1-2").unwrap(), "GG"); + assert_eq!(reader.read_sequence_mmap("chr2:1-1000000").unwrap(), "GGTCAAGGTCAA"); + //Recall to get python based assert_eq!(readering we add 1 to both start and end, so 1-13 is a 12 character string(full sequence) + assert_eq!(reader.read_sequence_mmap("chr2:1-11").unwrap(), "GGTCAAGGTCA"); + assert_eq!(reader.read_sequence_mmap("chr2:1-12").unwrap(), "GGTCAAGGTCAA"); + assert_eq!(reader.read_sequence_mmap("chr2:1-13").unwrap(), "GGTCAAGGTCAA"); + + assert_eq!(reader.read_sequence_mmap("chr3:1-2").unwrap(), "AG"); + assert_eq!(reader.read_sequence_mmap("chr3:1-13").unwrap(), "AGTCAAGGTCCAC"); + assert_eq!(reader.read_sequence_mmap("chr3:1-14").unwrap(), "AGTCAAGGTCCACG"); // adds first character from next line + assert_eq!( + reader.read_sequence_mmap("chr3:1-83").unwrap(), + "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCA" + ); + assert_eq!( + reader.read_sequence_mmap("chr3:1-84").unwrap(), + "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG" + ); + assert_eq!( + reader.read_sequence_mmap("chr3:1-10000").unwrap(), + "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG" + ); + assert_eq!(reader.read_sequence_mmap("chr3:84-84").unwrap(), "G"); + + // Handles End of assert_eq!(reader + // Full sequence + assert_eq!(reader.read_sequence_mmap("chr5:1-1000000").unwrap(), "A"); + // Only one char, should succeed + assert_eq!(reader.read_sequence_mmap("chr5:1-2").unwrap(), "A"); + + // Handles end of multi line but non-full sequence entry + // Full sequence + assert_eq!(reader.read_sequence_mmap("chr4:1-16").unwrap(), "CCCCCCCCCCCCACGT"); + assert_eq!(reader.read_sequence_mmap("chr4:1-17").unwrap(), "CCCCCCCCCCCCACGT"); + assert_eq!( + reader.read_sequence_mmap("chr4:1-1000000").unwrap(), + "CCCCCCCCCCCCACGT" + ); + + assert_eq!(reader.read_sequence_mmap("chr4:1-17").unwrap(), "CCCCCCCCCCCCACGT"); + + assert_eq!(reader.read_sequence_mmap("chr4:3-16").unwrap(), "CCCCCCCCCCACGT"); + assert_eq!(reader.read_sequence_mmap("chr4:17-17").unwrap(), ""); +} diff --git a/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py b/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py new file mode 100644 index 0000000000..82cb0023a7 --- /dev/null +++ b/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py @@ -0,0 +1,19 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +from bionemo.noodles_fasta_wrapper import PyFaidxRecord, PyIndexedMmapFastaReader + + +__all__ = ("PyFaidxRecord", "PyIndexedMmapFastaReader") diff --git a/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py b/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py new file mode 100644 index 0000000000..938b1793fc --- /dev/null +++ b/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py @@ -0,0 +1,165 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path +from typing import Dict, Optional, Sequence + +from bionemo.noodles import PyFaidxRecord, PyIndexedMmapFastaReader + + +__all__: Sequence[str] = ( + "SequenceAccessor", + "NvFaidx", +) + + +class SequenceAccessor: + """SequenceAccessor provides a dictionary-like interface to a single sequence in an indexed FASTA file. + + This allows for random access to the sequence, either by index, or by slice. + """ + + def __init__(self, reader: PyIndexedMmapFastaReader, seqid: str, length: int) -> None: + """Construct a SequenceAccessor object. + + Args: + reader (PyIndexedMmapFastaReader): The indexed reader object that provides access to the underlying FASTA file. + seqid (str): The sequence identifier. + length (int): The length of the sequence. + """ + self.reader = reader + self.seqid = seqid + self.length = length + + def __getitem__(self, key: int | slice) -> str: # noqa: D105 + if isinstance(key, slice): + # Provide defaults for missing arguments in the slice. + start = key.start if key.start is not None else 0 + stop = key.stop if key.stop is not None else self.length + + # Handle negative cases, remember, you can be arbitrarily negative in a slice. + if start < 0: + start += self.length + if stop < 0: + stop += self.length + + # Clamp normalized indices to valid range + start = max(0, min(self.length, start)) + stop = max(0, min(self.length, stop)) + + # Bounds checking after normalization + if start > stop: + return "" # Return empty string for an empty slice + + # Construct region string + region_str = f"{self.seqid}:{start + 1}-{stop}" # +1 for 1-based indexing + return self.reader.read_sequence_mmap(region_str) + + elif isinstance(key, int): + # Normalize single integer for negative indexing + if key < 0: + key += self.length + + # Bounds checking + if key < 0 or key >= self.length: + raise IndexError(f"Position {key} is out of bounds for '{self.seqid}' with length {self.length}.") + + # Query single nucleotide by creating a 1-length region + region_str = f"{self.seqid}:{key + 1}-{key + 1}" # +1 for 1-based indexing + return self.reader.read_sequence_mmap(region_str) + + else: + raise TypeError("Index must be an integer or a slice.") + + +class NvFaidx: + """NvFaidx is a rest + pyo3 replacement for PyFaidx that provides a dictionary-like interface to reference genomes. + + NvFaidx is built using Noodles as a backend for Fai objects, and memory maps for backing the underlying fasta. + Using a backend of Memmaps provide the following benefits: + - The kernel implements this mechanism by using page faults + - Each read in a mmap'd file results in a page fault: there's nothing in memory to read! + - The kernel handles this page fault by going to the disk, reading the file in the specified offset + index, + then returning to the user process with what it just read, preventing penalties from context switching. + + *Context*: PyFaidx or _any_ buffered read based index is not process safe, and therefore does not play nice with pytorch dataloaders. + Due to the order of operations, the underlying file handle is shared between processes, when `seek()` is called to perform random lookups, + this can cause unexpected behavior in the forked processes. + Ref: https://github.com/mdshw5/pyfaidx/issues/211 + + For a good solution we need three things: + 1) Safe index creation, in multi-process or multi-node scenarios, this should be restricted to a single node + where all workers block until it is complete (not implemented above) + 2) Index object instantion must be fast. + 3) Read-only use of the index object must be both thread safe and process safe with python. + """ + + def __init__(self, fasta_path: str | Path, faidx_path: Optional[str | Path] = None, ignore_existing_fai=True): + """Construct a dict-like object representing a memmapped, indexed FASTA file. + + Args: + fasta_path (str): Path to the FASTA file. + faidx_path (str): Path to the FAI index file. If None, one will be created. + ignore_existing_fai (bool): If True, ignore any existing FAI file and create an in-memory index. Note that + this will also ignore `faidx_path`. + """ + if isinstance(fasta_path, Path): + fasta_path = str(fasta_path) + elif not isinstance(fasta_path, str): + raise TypeError(f"fasta_path must be a `str` or `pathlib.Path`, got: {type(fasta_path)}") + + if isinstance(faidx_path, Path): + faidx_path = str(faidx_path) + elif not isinstance(faidx_path, str) and faidx_path is not None: + raise TypeError(f"faidx_path must be a `str`, `pathlib.Path`, or None. got: {type(faidx_path)}") + + if ignore_existing_fai: + self.reader = PyIndexedMmapFastaReader(fasta_path, ignore_existing_fai=ignore_existing_fai) + elif faidx_path is not None: + self.reader = PyIndexedMmapFastaReader.from_fasta_and_faidx(fasta_path, faidx_path) + else: + # Builds a FAIDX object in memory by default. + self.reader = PyIndexedMmapFastaReader(fasta_path) + + self.records: Dict[str, PyFaidxRecord] = {record.name: record for record in self.reader.records()} + + def __getitem__(self, seqid: str) -> SequenceAccessor: # noqa: D105 + if seqid not in self.records: + raise KeyError(f"Sequence '{seqid}' not found in index.") + + # Return a SequenceAccessor for slicing access + record_length = self.records[seqid].length + return SequenceAccessor(self.reader, seqid, record_length) + + def __contains__(self, seqid: str) -> bool: # noqa: D105 + return seqid in self.records + + def __len__(self) -> int: # noqa: D105 + return len(self.records) + + def keys(self) -> set[str]: # noqa: D102 + return set(self.records.keys()) + + @staticmethod + def create_faidx(fasta_filename: str | Path) -> str: + """Create a FAI index for a FASTA file, the result is saved in the same location as `fasta_filename`, with a .fai extension. + + Args: + fasta_filename (str): Path to the FASTA file to be indexed. + """ + if isinstance(fasta_filename, Path): + fasta_filename = str(fasta_filename) + return PyIndexedMmapFastaReader.create_faidx(fasta_filename) diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta new file mode 100644 index 0000000000..43d65a505b --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta @@ -0,0 +1,17 @@ +>chr1 +ACTGACTGACTG +>chr2 +GGTCAAGGTCAA +>chr3 +AGTCAAGGTCCA +CGTCAAGGTCCC +GGTCAAGGTCCG +TGTCAAGGTCCT +AGTCAAGGTCAA +CGTCAAGGTCAC +GGTCAAGGTCAG +>chr4 +CCCCCCCCCCCC +ACGT +>chr5 +A diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta.fai b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta.fai new file mode 100644 index 0000000000..3217422ce9 --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/bad_index.fasta.fai @@ -0,0 +1 @@ +this is not a valid fasta index!!!!!! diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta new file mode 100644 index 0000000000..43d65a505b --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta @@ -0,0 +1,17 @@ +>chr1 +ACTGACTGACTG +>chr2 +GGTCAAGGTCAA +>chr3 +AGTCAAGGTCCA +CGTCAAGGTCCC +GGTCAAGGTCCG +TGTCAAGGTCCT +AGTCAAGGTCAA +CGTCAAGGTCAC +GGTCAAGGTCAG +>chr4 +CCCCCCCCCCCC +ACGT +>chr5 +A diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta.fai b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta.fai new file mode 100644 index 0000000000..8e350070bf --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/sample.fasta.fai @@ -0,0 +1,5 @@ +chr1 12 6 12 13 +chr2 12 25 12 13 +chr3 84 44 12 13 +chr4 16 141 12 13 +chr5 1 165 1 2 diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py new file mode 100644 index 0000000000..bba6414642 --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py @@ -0,0 +1,412 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import os +import pathlib +import random +import tempfile + +import pyfaidx +import pytest +import torch + +from bionemo.noodles import PyIndexedMmapFastaReader +from bionemo.noodles.nvfaidx import NvFaidx + + +@pytest.fixture +def sample_fasta(): + return str(pathlib.Path(__file__).parent.parent.parent / "bionemo/noodles/data/sample.fasta") + + +def test_create_faidx(): + filename = create_test_fasta(num_seqs=2, seq_length=200) + faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename) + assert os.path.exists(faidx_filename) + assert faidx_filename == filename + ".fai" + + index = PyIndexedMmapFastaReader.from_fasta_and_faidx(filename, faidx_filename) + # By default does not build the index from an existing file, but the result should be equivalent. + index2 = PyIndexedMmapFastaReader(filename) + assert index.read_sequence_mmap("contig1:1-1") == index2.read_sequence_mmap("contig1:1-1") + assert index.read_sequence_mmap("contig1:1-10") == index2.read_sequence_mmap("contig1:1-10") + assert index.read_sequence_mmap("contig1:10-200") == index2.read_sequence_mmap("contig1:10-200") + + +def test_from_fasta_and_faidx_no_such_faidx(): + filename = create_test_fasta(num_seqs=2, seq_length=200) + faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename) + os.remove(faidx_filename) + # And this should fail. + with pytest.raises(FileNotFoundError): + _ = PyIndexedMmapFastaReader.from_fasta_and_faidx(filename, faidx_filename) + + +def test_from_fasta_and_faidx(): + # Smoke test, this should all work + filename = create_test_fasta(num_seqs=2, seq_length=200) + faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename) + index = PyIndexedMmapFastaReader.from_fasta_and_faidx(filename, faidx_filename) + index2 = PyIndexedMmapFastaReader(filename, ignore_existing_fai=True) + # Test against constructor for equivalence. + assert index.read_sequence_mmap("contig1:1-1") == index2.read_sequence_mmap("contig1:1-1") + assert index.read_sequence_mmap("contig1:1-10") == index2.read_sequence_mmap("contig1:1-10") + assert index.read_sequence_mmap("contig1:10-200") == index2.read_sequence_mmap("contig1:10-200") + + # now we are going to rename the file, and then try again, we expect the same outcome. + new_faidx_name = os.path.dirname(faidx_filename) + "/asdfasdfasdf" + os.rename(faidx_filename, new_faidx_name) + # Sanity checks for our test. + assert not os.path.exists(faidx_filename) + + # Now we expect equivalent output even though its using the asdfasdfasdf fai file, and we know the implicit one is missing. + index = PyIndexedMmapFastaReader.from_fasta_and_faidx(filename, new_faidx_name) + # Test against constructor for equivalence. + assert index.read_sequence_mmap("contig1:1-1") == index2.read_sequence_mmap("contig1:1-1") + assert index.read_sequence_mmap("contig1:1-10") == index2.read_sequence_mmap("contig1:1-10") + assert index.read_sequence_mmap("contig1:10-200") == index2.read_sequence_mmap("contig1:10-200") + + +def test_memmap_index(sample_fasta): + # There exists an equivalent test in Rust. + fasta_path = sample_fasta + index = PyIndexedMmapFastaReader(fasta_path) + assert index.read_sequence_mmap("chr1:1-1") == "A" + assert index.read_sequence_mmap("chr1:1-2") == "AC" + assert index.read_sequence_mmap("chr1:1-100000") == "ACTGACTGACTG" + assert index.read_sequence_mmap("chr2:1-2") == "GG" + assert index.read_sequence_mmap("chr2:1-1000000") == "GGTCAAGGTCAA" + # Recall to get python based indexing we add 1 to both start and end, so 1-13 is a 12 character string(full sequence) + assert index.read_sequence_mmap("chr2:1-11") == "GGTCAAGGTCA" + assert index.read_sequence_mmap("chr2:1-12") == "GGTCAAGGTCAA" + assert index.read_sequence_mmap("chr2:1-13") == "GGTCAAGGTCAA" + + assert index.read_sequence_mmap("chr3:1-2") == "AG" + assert index.read_sequence_mmap("chr3:1-13") == "AGTCAAGGTCCAC" + assert index.read_sequence_mmap("chr3:1-14") == "AGTCAAGGTCCACG" # adds first character from next line + assert ( + index.read_sequence_mmap("chr3:1-83") + == "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCA" + ) + assert ( + index.read_sequence_mmap("chr3:1-84") + == "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG" + ) + assert ( + index.read_sequence_mmap("chr3:1-10000") + == "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG" + ) + assert index.read_sequence_mmap("chr3:84-84") == "G" + + # Handles End of Index + # Full sequence + assert index.read_sequence_mmap("chr5:1-1000000") == "A" + # Only one char, should succeed + assert index.read_sequence_mmap("chr5:1-2") == "A" + + # Handles end of multi line but non-full sequence entry + # Full sequence + assert index.read_sequence_mmap("chr4:1-16") == "CCCCCCCCCCCCACGT" + assert index.read_sequence_mmap("chr4:1-17") == "CCCCCCCCCCCCACGT" + assert index.read_sequence_mmap("chr4:1-1000000") == "CCCCCCCCCCCCACGT" + + assert index.read_sequence_mmap("chr4:1-17") == "CCCCCCCCCCCCACGT" + + assert index.read_sequence_mmap("chr4:3-16") == "CCCCCCCCCCACGT" + assert index.read_sequence_mmap("chr4:17-17") == "" + + +def test_getitem_bounds(sample_fasta): + # NOTE make this the correct path, check this file in since we are checking exactness of queries. + index = NvFaidx(sample_fasta) + # first element + assert index["chr1"][0] == "A" + # normal, in range, query + assert index["chr1"][1:4] == "CTG" + # Going beyond the max bound in a slice should truncate at the end of the sequence + assert index["chr1"][1:10000] == "CTGACTGACTG" + # Slice up to the last element + assert index["chr1"][0:-1] == "ACTGACTGACT" + # equivalent to above + assert index["chr1"][:-1] == "ACTGACTGACT" + # -1 should get the last element + assert index["chr1"][-1:] == "G" + + # Invalid contig should throw an exception + with pytest.raises(KeyError): + index["asdfasdfasdfsadf"][-1:] + + +def _test_faidx_generic(faidx_obj): + # This is a generic test that should work for both the pyfaidx and nvfaidx implementations. + index = faidx_obj + assert index["chr1"][0:1] == "A" + assert index["chr1"][0:2] == "AC" + assert index["chr1"][0:100000] == "ACTGACTGACTG" + assert index["chr2"][0:2] == "GG" + assert index["chr2"][0:100000] == "GGTCAAGGTCAA" + + assert index["chr3"][0:2] == "AG" + assert index["chr3"][0:13] == "AGTCAAGGTCCAC" + # in progress + assert index["chr3"][0:14] == "AGTCAAGGTCCACG" # adds first character from next line + assert index["chr3"][0:83] == "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCA" + assert ( + index["chr3"][0:84] == "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG" + ) + assert ( + index["chr3"][0:10000] + == "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG" + ) + assert index["chr3"][83:84] == "G" + + # Handles End of Index + # Full sequence + assert index["chr5"][0:1000000] == "A" + # chr5 has one char, even though this spans 2, it returns len(1) + assert index["chr5"][0:2] == "A" + + # Handles end of multi line but non-full sequence entry + # Full sequence + assert index["chr4"][0:16] == "CCCCCCCCCCCCACGT" + assert index["chr4"][0:17] == "CCCCCCCCCCCCACGT" + assert index["chr4"][0:1000000] == "CCCCCCCCCCCCACGT" + + # This one failing is bad, it means we are not calculating the newlines correctly in some conditions. + assert index["chr4"][0:17] == "CCCCCCCCCCCCACGT" + + # Should see this is out of bounds and return empty or throw an error + assert index["chr4"][17:17] == "" + + +def test_nvfaidx_python_interface(sample_fasta): + nvfaidx_index = NvFaidx(sample_fasta) + pyfaidx_index = pyfaidx.Fasta(sample_fasta) + _test_faidx_generic(nvfaidx_index) + _test_faidx_generic(pyfaidx_index) + + +def test_pyfaidx_nvfaidx_equivalence(): + fasta = create_test_fasta(num_seqs=2, seq_length=200000) + pyfaidx_fasta = pyfaidx.Fasta(fasta) + nvfaidx_fasta = NvFaidx(fasta) + + for i in range(100): + # Deterministically generate regions to grab + seqid = f"contig{i % 2 + 1}" + start = i * 1000 + end = start + 1000 + + if not pyfaidx_fasta[seqid][start:end] == nvfaidx_fasta[seqid][start:end]: + raise Exception(f"Pyfaidx and NvFaidx do not match. correct={i}") + + +class TestDataset(torch.utils.data.Dataset): + def __init__(self, fasta_path, fasta_cls): + self.fasta = fasta_cls(fasta_path) + self.keys = list(self.fasta.keys()) + + def __len__(self): + # Gigantic, we dont care. + return 99999999999 + + def __getitem__(self, idx): + # Always return the same thing to keep it easy, we assume the fasta_created is doing the right thing. + return str(self.fasta["contig1"][150000:160000]) + + +@pytest.mark.skip +@pytest.mark.xfail(reason="This is a known failure mode for pyfaidx that we are trying to prevent with nvfaidx.") +def test_parallel_index_creation_pyfaidx(): + """ + PyFaidx is a python replacement for faidx that provides a dictionary-like interface to reference genomes. Pyfaidx + is not process safe, and therefore does not play nice with pytorch dataloaders. + + Ref: https://github.com/mdshw5/pyfaidx/issues/211 + + Naively, this problem can be fixed by keeping index objects private to each process. However, instantiating this object can be quite slow. + In the case of hg38, this can take between 15-30 seconds. + + For a good solution we need three things: + 1) Safe index creation, in multi-process or multi-node scenarios, this should be restricted to a single node where all workers block until it is complete (not implemented above) + 2) Index object instantion must be fast. + 3) Read-only use of the index object must be both thread safe and process safe with python. + """ + fasta = create_test_fasta(num_seqs=2, seq_length=200000) + dl = torch.utils.data.DataLoader(TestDataset(fasta, fasta_cls=pyfaidx.Fasta), batch_size=16, num_workers=16) + max_i = 1000 + for i, batch in enumerate(dl): + # assert length of all elements in batch is 10000 + if i > max_i: + break + lens = [len(x) for x in batch] + lens_equal = [x == 10000 for x in lens] + assert all(lens_equal), (set(lens), sum(lens_equal)) + + +def test_parallel_index_creation_nvfaidx(): + fasta = create_test_fasta(num_seqs=2, seq_length=200000) + + dl = torch.utils.data.DataLoader(TestDataset(fasta, fasta_cls=NvFaidx), batch_size=32, num_workers=16) + max_i = 1000 + # NOTE this shouldnt be failing uh oh + for i, batch in enumerate(dl): + if i > max_i: + break + lens = [len(x) for x in batch] + lens_equal = [x == 10000 for x in lens] + assert all(lens_equal), (set(lens), sum(lens_equal)) + + +def test_file_errors(): + # test missing fasta file + # test failure to parse fasta file + # test incomplete fai file + with pytest.raises(FileNotFoundError): + _ = PyIndexedMmapFastaReader("asdflasdfaslkdfasdf.fasta") + + temp_dir = tempfile.mkdtemp() + fasta_path = os.path.join(temp_dir, "not_a_fasta.fasta") + with open(fasta_path, "w") as fasta_file: + fasta_file.write("this is not a fasta file.\n") + + # Should fail due to invalid fasta file when it tries to create the faidx + with pytest.raises(RuntimeError): + _ = PyIndexedMmapFastaReader(fasta_path, ignore_existing_fai=True) + + test_fa = create_test_fasta(num_seqs=2, seq_length=20) + # now we are going to corrupt the .fai file + with open(test_fa + ".fai", "w") as f: + f.write("this is not a valid fai file") + with pytest.raises(RuntimeError): + _ = PyIndexedMmapFastaReader(test_fa, ignore_existing_fai=False) + + # But if we create an index in memory, should work! + _ = PyIndexedMmapFastaReader(test_fa, ignore_existing_fai=True) + + # test failure due to lack of fai + with pytest.raises(FileNotFoundError): + new_test_fasta = create_test_fasta(num_seqs=1, seq_length=200) + _ = PyIndexedMmapFastaReader(new_test_fasta, ignore_existing_fai=False) + + +## Benchmarks +def measure_index_creation_time(): + """Observed performance. + + 8x speedup for NvFaidx when using + """ + import time + + # Too slow gen a big genome + fasta = create_test_fasta(num_seqs=10, seq_length=200_000) + if os.path.exists(fasta + ".fai"): + os.remove(fasta + ".fai") + start = time.time() + _ = pyfaidx.Fasta(fasta) + end = time.time() + elapsed_pyfaidx = end - start + + # Remove the .fai file to prevent cheating. + if os.path.exists(fasta + ".fai"): + os.remove(fasta + ".fai") + start = time.time() + _ = NvFaidx(fasta, ignore_existing_fai=True) + end = time.time() + elapsed_nvfaidx = end - start + + # Now time the creation of the index file + start = time.time() + _ = PyIndexedMmapFastaReader.create_faidx(fasta) + end = time.time() + elapsed_creation = end - start + + start = time.time() + NvFaidx(fasta, ignore_existing_fai=False) + end = time.time() + elapsed_existing = end - start + + print(f"pyfaidx instantiation: {elapsed_pyfaidx=}") + print(f"nvfaidx instantiation: {elapsed_nvfaidx=}") + print(f"nvfaidx instantiation faster by: {elapsed_pyfaidx/elapsed_nvfaidx=}") + + print(f"NvFaidx Index creation time to disk: {elapsed_creation=}") + print(f"NvFaidx instantiation with existing: {elapsed_existing=}") + + +def measure_query_time(): + """Observed perf: + + 2.3x faster nvfaidx when doing queries through our SequenceAccessor implementation in python land. + """ + import time + + import numpy as np + + num_iters = 1000 + fasta = create_test_fasta(num_seqs=10, seq_length=200000) + + start_points = np.random.randint(0, 200000, size=num_iters) + end_points = start_points + np.random.randint(1, 1000, size=num_iters) # Adjust range size + + # So we are a little slower + fasta_idx = NvFaidx(fasta) + start = time.time() + for i in range(num_iters): + _ = fasta_idx["contig1"][start_points[i] : end_points[i]] + end = time.time() + elapsed_nvfaidx = end - start + + fasta_idx = pyfaidx.Fasta(fasta) + start = time.time() + for _ in range(num_iters): + _ = fasta_idx["contig1"][150000:160000] + end = time.time() + elapsed_pyfaidx = end - start + + print(f"pyfaidx query/s: {elapsed_pyfaidx/num_iters=}") + print(f"nvfaidx query/s: {elapsed_nvfaidx/num_iters=}") + print(f"nvfaidx query faster by: {elapsed_pyfaidx/elapsed_nvfaidx=}") + + +# Utility function +def create_test_fasta(num_seqs=2, seq_length=1000): + """ + Creates a FASTA file with random sequences. + + Args: + num_seqs (int): Number of sequences to include in the FASTA file. + seq_length (int): Length of each sequence. + + Returns: + str: File path to the generated FASTA file. + """ + temp_dir = tempfile.mkdtemp() + fasta_path = os.path.join(temp_dir, "test.fasta") + + with open(fasta_path, "w") as fasta_file: + for i in range(1, num_seqs + 1): + # Write the header + fasta_file.write(f">contig{i}\n") + + # Generate a random sequence of the specified length + sequence = "".join(random.choices("ACGT", k=seq_length)) + + # Split the sequence into lines of 60 characters for FASTA formatting + for j in range(0, len(sequence), 80): + fasta_file.write(sequence[j : j + 80] + "\n") + + return fasta_path diff --git a/sub-packages/bionemo-scdl/examples/example_notebook.ipynb b/sub-packages/bionemo-scdl/examples/example_notebook.ipynb index 325fbe83a9..adc9c4db30 100644 --- a/sub-packages/bionemo-scdl/examples/example_notebook.ipynb +++ b/sub-packages/bionemo-scdl/examples/example_notebook.ipynb @@ -1,6 +1,16 @@ { "cells": [ { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2pDvxgSkyyfh2QPeHZ4aGvtuqBY)\n", + "\n", + "
NOTE It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits.
" + ] + }, + +{ "cell_type": "code", "execution_count": null, "metadata": {}, diff --git a/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py b/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py index 17c5540299..65faa129f5 100644 --- a/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py +++ b/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py @@ -17,10 +17,12 @@ import importlib.metadata from pathlib import Path -from typing import List, Optional, Sequence, Tuple +from typing import Optional, Sequence, Tuple import numpy as np import pandas as pd +import pyarrow as pa +import pyarrow.parquet as pq __all__: Sequence[str] = ("RowFeatureIndex",) @@ -37,7 +39,10 @@ class RowFeatureIndex: correspondto a given row. For examples if the array is [-1, 200, 201], rows 0 to 199 correspond to _feature_arr[0] and 200 corresponds to _feature_arr[1] - _feature_arr: list of feature dataframes + _feature_arr: list of feature dictionaries for each dataset + _num_genes_per_row: list that tracks the feature length (number of genes) for each dataset. + Extracting this information repeatedly from self._feature_arr would be cumbersome which is why we + add this attribute. _labels: list of labels _version: The version of the dataset """ @@ -45,9 +50,26 @@ class RowFeatureIndex: def __init__(self) -> None: """Instantiates the index.""" self._cumulative_sum_index: np.array = np.array([-1]) - self._feature_arr: List[pd.DataFrame] = [] + self._feature_arr: list[dict[str, np.ndarray]] = [] + self._num_genes_per_row: list[int] = [] self._version = importlib.metadata.version("bionemo.scdl") - self._labels: List[str] = [] + self._labels: list[str] = [] + + def _get_dataset_id(self, row) -> int: + """Gets the dataset id for a specified row index. + + Args: + row (int): The index of the row. + + Returns: + An int representing the dataset id the row belongs to. + """ + # creates a mask for values where cumulative sum > row + mask = ~(self._cumulative_sum_index > row) + # Sum these to get the index of the first range > row + # Subtract one to get the range containing row. + d_id = sum(mask) - 1 + return d_id def version(self) -> str: """Returns a version number. @@ -60,36 +82,42 @@ def __len__(self) -> int: """The length is the number of rows or RowFeatureIndex length.""" return len(self._feature_arr) - def append_features(self, n_obs: int, features: pd.DataFrame, label: Optional[str] = None) -> None: + def append_features( + self, n_obs: int, features: dict[str, np.ndarray], num_genes: int, label: Optional[str] = None + ) -> None: """Updates the index with the given features. - The dataframe is inserted into the feature array by adding a - new span to the row lookup index. + The dict is inserted into the feature array by adding a + new span to the row lookup index. Additionally, we update the number of genes for the newly added row. Args: n_obs (int): The number of times that these feature occur in the class. - features (pd.DataFrame): Corresponding features. + features (dict): Corresponding features. + num_genes (int): the length of the features for each feature key in features (i.e., number of genes) label (str): Label for the features. """ + if isinstance(features, pd.DataFrame): + raise TypeError("Expected a dictionary, but received a Pandas DataFrame.") csum = max(self._cumulative_sum_index[-1], 0) self._cumulative_sum_index = np.append(self._cumulative_sum_index, csum + n_obs) self._feature_arr.append(features) + self._num_genes_per_row.append(num_genes) self._labels.append(label) - def lookup(self, row: int, select_features: Optional[List[str]] = None) -> Tuple[pd.DataFrame, str]: + def lookup(self, row: int, select_features: Optional[list[str]] = None) -> Tuple[list[np.ndarray], str]: """Find the features at a given row. It is assumed that the row is non-zero._cumulative_sum_index contains pointers to which rows correspond - to given dataframes. To obtain a specific row, we determine where it is - located in _cumulative_sum_index and then look up that dataframe in + to given dictionaries. To obtain a specific row, we determine where it is + located in _cumulative_sum_index and then look up that dictionary in _feature_arr Args: row (int): The row in the feature index. - select_features (List[str]): a list of features to select + select_features (list[str]): a list of features to select Returns - pd.DataFrame: dataframe of features in that row + list[np.ndarray]: list of np arrays with the feature values in that row of the specified features str: optional label for the row Raises: IndexError: An error occured due to input row being negative or it @@ -99,31 +127,32 @@ def lookup(self, row: int, select_features: Optional[List[str]] = None) -> Tuple if row < 0: raise IndexError(f"Row index {row} is not valid. It must be non-negative.") if len(self._cumulative_sum_index) < 2: - raise IndexError("There are no dataframes to lookup.") + raise IndexError("There are no features to lookup.") if row > self._cumulative_sum_index[-1]: raise IndexError( f"Row index {row} is larger than number of rows in FeatureIndex ({self._cumulative_sum_index[-1]})." ) - # This line does the following: - # creates a mask for values where cumulative sum > row - mask = ~(self._cumulative_sum_index > row) - # Sum these to get the index of the first range > row - # Subtract one to get the range containing row. - d_id = sum(mask) - 1 + d_id = self._get_dataset_id(row) # Retrieve the features for the identified value. - features = self._feature_arr[d_id] + features_dict = self._feature_arr[d_id] # If specific features are to be selected, filter the features. if select_features is not None: - features = features[select_features] + features = [] + for feature in select_features: + if feature not in features_dict: + raise ValueError(f"Provided feature column {feature} in select_features not present in dataset.") + features.append(features_dict[feature]) + else: + features = [features_dict[f] for f in features_dict] # Return the features for the identified range. return features, self._labels[d_id] def number_vars_at_row(self, row: int) -> int: - """Return number of variables (legnth of the dataframe) in a given row. + """Return number of variables in a given row. Args: row (int): The row in the feature index. @@ -131,10 +160,9 @@ def number_vars_at_row(self, row: int) -> int: Returns: The length of the features at the row """ - feats, _ = self.lookup(row=row) - return len(feats) + return self._num_genes_per_row[self._get_dataset_id(row)] - def column_dims(self) -> List[int]: + def column_dims(self) -> list[int]: """Return the number of columns in all rows. Args: @@ -143,13 +171,12 @@ def column_dims(self) -> List[int]: Returns: A list containing the lengths of the features in every row """ - # Just take the total dim of the DataFrame(s) - return [len(feats) for feats in self._feature_arr] + return self._num_genes_per_row - def number_of_values(self) -> List[int]: + def number_of_values(self) -> list[int]: """Get the total number of values in the array. - For each row, the length of the corresponding dataframe is counted. + For each row, the number of genes is counted. Returns: A list containing the lengths of the features in every block of rows @@ -160,12 +187,12 @@ def number_of_values(self) -> List[int]: self._cumulative_sum_index[i] - max(self._cumulative_sum_index[i - 1], 0) for i in range(1, len(self._cumulative_sum_index)) ] - - vals = [n_rows * len(self._feature_arr[i]) for i, n_rows in enumerate(rows)] + vals = [] + vals = [n_rows * self._num_genes_per_row[i] for i, n_rows in enumerate(rows)] return vals def number_of_rows(self) -> int: - """The number of rows in the dataframe. + """The number of rows in the index"". Returns: An integer corresponding to the number or rows in the index @@ -201,7 +228,8 @@ def concat(self, other_row_index: RowFeatureIndex, fail_on_empty_index: bool = T for i, feats in enumerate(list(other_row_index._feature_arr)): c_span = other_row_index._cumulative_sum_index[i + 1] label = other_row_index._labels[i] - self.append_features(c_span, feats, label) + num_genes = other_row_index._num_genes_per_row[i] + self.append_features(c_span, feats, num_genes, label) return self @@ -213,10 +241,11 @@ def save(self, datapath: str) -> None: """ Path(datapath).mkdir(parents=True, exist_ok=True) num_digits = len(str(len(self._feature_arr))) + for index, feature_dict in enumerate(self._feature_arr): + table = pa.table({column: pa.array(values) for column, values in feature_dict.items()}) + dataframe_str_index = f"{index:0{num_digits}d}" + pq.write_table(table, f"{datapath}/dataframe_{dataframe_str_index}.parquet") - for dataframe_index, dataframe in enumerate(self._feature_arr): - dataframe_str_index = f"{dataframe_index:0{num_digits}d}" - dataframe.to_parquet(f"{datapath}/dataframe_{dataframe_str_index}.parquet", index=False) np.save(Path(datapath) / "cumulative_sum_index.npy", self._cumulative_sum_index) np.save(Path(datapath) / "labels.npy", self._labels) np.save(Path(datapath) / "version.npy", np.array(self._version)) @@ -232,7 +261,14 @@ def load(datapath: str) -> RowFeatureIndex: """ new_row_feat_index = RowFeatureIndex() parquet_data_paths = sorted(Path(datapath).rglob("*.parquet")) - new_row_feat_index._feature_arr = [pd.read_parquet(csv_path) for csv_path in parquet_data_paths] + data_tables = [pq.read_table(csv_path) for csv_path in parquet_data_paths] + new_row_feat_index._feature_arr = [ + {column: table[column].to_numpy() for column in table.column_names} for table in data_tables + ] + new_row_feat_index._num_genes_per_row = [ + len(feats[next(iter(feats.keys()))]) for feats in new_row_feat_index._feature_arr + ] + new_row_feat_index._cumulative_sum_index = np.load(Path(datapath) / "cumulative_sum_index.npy") new_row_feat_index._labels = np.load(Path(datapath) / "labels.npy", allow_pickle=True) new_row_feat_index._version = np.load(Path(datapath) / "version.npy").item() diff --git a/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py b/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py index 932c16e58f..8569149127 100644 --- a/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py +++ b/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py @@ -339,7 +339,7 @@ def get_row( index: int, return_features: bool = False, feature_vars: Optional[List[str]] = None, - ) -> Tuple[Tuple[np.ndarray, np.ndarray], pd.DataFrame]: + ) -> Tuple[Tuple[np.ndarray, np.ndarray], List[np.ndarray]]: """Returns a given row in the dataset along with optional features. Args: @@ -348,7 +348,7 @@ def get_row( feature_vars: Optional, feature variables to extract Return: [Tuple[np.ndarray, np.ndarray]: data values and column pointes - pd.DataFrame: optional, corresponding features. + List[np.ndarray]: optional, corresponding features. """ start = self.row_index[index] end = self.row_index[index + 1] @@ -365,7 +365,7 @@ def get_row_padded( index: int, return_features: bool = False, feature_vars: Optional[List[str]] = None, - ) -> Tuple[np.ndarray, pd.DataFrame]: + ) -> Tuple[np.ndarray, List[np.ndarray]]: """Returns a padded version of a row in the dataset. A padded version is one where the a sparse array representation is @@ -378,7 +378,7 @@ def get_row_padded( feature_vars: Optional, feature variables to extract Return: np.ndarray: conventional row representation - pd.DataFrame: optional, corresponding features. + List[np.ndarray]: optional, corresponding features. """ (row_values, row_column_pointer), features = self.get_row(index, return_features, feature_vars) return ( @@ -611,14 +611,15 @@ def load_h5ad( file_size_MB = os.path.getsize(anndata_path) / (1_024**2) if file_size_MB < self.paginated_load_cutoff: - features, num_rows = self.regular_load_h5ad(anndata_path) + features_df, num_rows = self.regular_load_h5ad(anndata_path) else: - features, num_rows = self.paginated_load_h5ad(anndata_path) - - # Collect features and store in FeatureIndex - self._feature_index.append_features(n_obs=num_rows, features=features, label=anndata_path) + features_df, num_rows = self.paginated_load_h5ad(anndata_path) + features = {col: np.array(features_df[col].values) for col in features_df.columns} + self._feature_index.append_features( + n_obs=num_rows, features=features, num_genes=len(features[next(iter(features.keys()))]), label=anndata_path + ) self.save() def save(self, output_path: Optional[str] = None) -> None: @@ -661,7 +662,7 @@ def save(self, output_path: Optional[str] = None) -> None: def number_of_values(self) -> int: """Get the total number of values in the array. - For each index, the length of the corresponding dataframe is counted. + For each index, the length of the corresponding np.ndarray of features is counted. Returns: The sum of lengths of the features in every row diff --git a/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py b/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py index 8ef82158a9..e1fd5a0e7e 100644 --- a/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py +++ b/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py @@ -16,6 +16,7 @@ import re +import numpy as np import pandas as pd import pytest @@ -30,10 +31,9 @@ def create_first_RowFeatureIndex() -> RowFeatureIndex: Returns: A RowFeatureIndex with known values. """ - - one_feats = pd.DataFrame({"feature_name": ["FF", "GG", "HH"], "feature_int": [1, 2, 3]}) + one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} index = RowFeatureIndex() - index.append_features(12, one_feats) + index.append_features(12, one_feats, len(one_feats["feature_name"])) return index @@ -45,7 +45,18 @@ def create_second_RowFeatureIndex() -> RowFeatureIndex: Returns: A RowFeatureIndex with known values. """ + two_feats = { + "feature_name": np.array(["FF", "GG", "HH", "II", "ZZ"]), + "gene_name": np.array(["RET", "NTRK", "PPARG", "TSHR", "EGFR"]), + "spare": np.array([None, None, None, None, None]), + } + + index2 = RowFeatureIndex() + index2.append_features(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") + return index2 + +def test_dataframe_results_in_error(): two_feats = pd.DataFrame( { "feature_name": ["FF", "GG", "HH", "II", "ZZ"], @@ -53,9 +64,10 @@ def create_second_RowFeatureIndex() -> RowFeatureIndex: "spare": [None, None, None, None, None], } ) - index2 = RowFeatureIndex() - index2.append_features(8, two_feats, "MY_DATAFRAME") - return index2 + index = RowFeatureIndex() + with pytest.raises(TypeError) as error_info: + index.append_features(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") + assert "Expected a dictionary, but received a Pandas DataFrame." in str(error_info.value) def test_feature_index_internals_on_empty_index(): @@ -75,14 +87,13 @@ def test_feature_index_internals_on_single_index(create_first_RowFeatureIndex): def test_feature_index_internals_on_append(create_first_RowFeatureIndex): - two_feats = pd.DataFrame( - { - "feature_name": ["FF", "GG", "HH", "II", "ZZ"], - "gene_name": ["RET", "NTRK", "PPARG", "TSHR", "EGFR"], - "spare": [None, None, None, None, None], - } - ) - create_first_RowFeatureIndex.append_features(8, two_feats, "MY_DATAFRAME") + one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} + two_feats = { + "feature_name": np.array(["FF", "GG", "HH", "II", "ZZ"]), + "gene_name": np.array(["RET", "NTRK", "PPARG", "TSHR", "EGFR"]), + "spare": np.array([None, None, None, None, None]), + } + create_first_RowFeatureIndex.append_features(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") assert len(create_first_RowFeatureIndex) == 2 assert create_first_RowFeatureIndex.number_vars_at_row(1) == 3 assert create_first_RowFeatureIndex.number_vars_at_row(13) == 5 @@ -92,11 +103,14 @@ def test_feature_index_internals_on_append(create_first_RowFeatureIndex): assert create_first_RowFeatureIndex.number_of_values()[1] == (8 * 5) assert create_first_RowFeatureIndex.number_of_rows() == 20 feats, label = create_first_RowFeatureIndex.lookup(row=3, select_features=None) - assert list(feats.columns) == ["feature_name", "feature_int"] + assert np.all(feats[0] == one_feats["feature_name"]) + assert np.all(feats[1] == one_feats["feature_int"]) assert label is None feats, label = create_first_RowFeatureIndex.lookup(row=15, select_features=None) + assert np.all(feats[0] == two_feats["feature_name"]) + assert np.all(feats[1] == two_feats["gene_name"]) + assert np.all(feats[2] == two_feats["spare"]) assert label == "MY_DATAFRAME" - assert list(feats.columns) == ["feature_name", "gene_name", "spare"] def test_concat_length( @@ -133,18 +147,27 @@ def test_concat_lookup_results( create_first_RowFeatureIndex, create_second_RowFeatureIndex, ): + one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} + two_feats = { + "feature_name": np.array(["FF", "GG", "HH", "II", "ZZ"]), + "gene_name": np.array(["RET", "NTRK", "PPARG", "TSHR", "EGFR"]), + "spare": np.array([None, None, None, None, None]), + } create_first_RowFeatureIndex.concat(create_second_RowFeatureIndex) feats, label = create_first_RowFeatureIndex.lookup(row=3, select_features=None) - assert list(feats.columns) == ["feature_name", "feature_int"] + assert np.all(feats[0] == one_feats["feature_name"]) + assert np.all(feats[1] == one_feats["feature_int"]) assert label is None feats, label = create_first_RowFeatureIndex.lookup(row=15, select_features=None) + assert np.all(feats[0] == two_feats["feature_name"]) + assert np.all(feats[1] == two_feats["gene_name"]) + assert np.all(feats[2] == two_feats["spare"]) assert label == "MY_DATAFRAME" - assert list(feats.columns) == ["feature_name", "gene_name", "spare"] def test_feature_lookup_empty(): index = RowFeatureIndex() - with pytest.raises(IndexError, match=r"There are no dataframes to lookup"): + with pytest.raises(IndexError, match=r"There are no features to lookup"): index.lookup(row=1) @@ -177,4 +200,4 @@ def test_save_reload_row_feature_index_identical( features_one, labels_one = create_first_RowFeatureIndex.lookup(row=row, select_features=None) features_reload, labels_reload = index_reload.lookup(row=row, select_features=None) assert labels_one == labels_reload - pd.testing.assert_frame_equal(features_one, features_reload) + assert np.all(np.array(features_one, dtype=object) == np.array(features_reload)) diff --git a/sub-packages/bionemo-scdl/tests/bionemo/scdl/io/test_single_cell_memmap_dataset.py b/sub-packages/bionemo-scdl/tests/bionemo/scdl/io/test_single_cell_memmap_dataset.py index f29bd27b52..518866f1ff 100644 --- a/sub-packages/bionemo-scdl/tests/bionemo/scdl/io/test_single_cell_memmap_dataset.py +++ b/sub-packages/bionemo-scdl/tests/bionemo/scdl/io/test_single_cell_memmap_dataset.py @@ -191,10 +191,10 @@ def test_SingleCellMemMapDataset_get_row_colum(generate_dataset): def test_SingleCellMemMapDataset_get_row_padded(generate_dataset): - padded_row, feats = generate_dataset.get_row_padded(0, return_features=True, feature_vars="feature_name") + padded_row, feats = generate_dataset.get_row_padded(0, return_features=True, feature_vars=["feature_name"]) assert len(padded_row) == 10 assert padded_row[2] == 6.0 - assert len(feats) == 10 + assert len(feats[0]) == 10 assert generate_dataset.get_row_padded(0)[0][0] == 0.0 assert generate_dataset.data[0] == 6.0 assert generate_dataset.data[1] == 19.0 diff --git a/sub-packages/bionemo-size-aware-batching/src/bionemo/size_aware_batching/sampler.py b/sub-packages/bionemo-size-aware-batching/src/bionemo/size_aware_batching/sampler.py index 97ba450dfb..3684a595a4 100644 --- a/sub-packages/bionemo-size-aware-batching/src/bionemo/size_aware_batching/sampler.py +++ b/sub-packages/bionemo-size-aware-batching/src/bionemo/size_aware_batching/sampler.py @@ -453,6 +453,12 @@ def __init__( f"base_batch_sampler_class should be a batch sampler class inherited from torch.utils.data.Sampler, but got base_batch_sampler_class={base_batch_sampler_class}" ) + base_batch_sampler_shared_kwargs = ( + {} if base_batch_sampler_shared_kwargs is None else base_batch_sampler_shared_kwargs + ) + base_batch_sampler_individual_kwargs = ( + {} if base_batch_sampler_individual_kwargs is None else base_batch_sampler_individual_kwargs + ) if not isinstance(base_batch_sampler_shared_kwargs, dict): raise TypeError( f"base_batch_sampler_shared_kwargs should be a dictionary, but got base_batch_sampler_shared_kwargs={base_batch_sampler_shared_kwargs}" diff --git a/sub-packages/bionemo-size-aware-batching/tests/bionemo/size_aware_batching/test_sampler.py b/sub-packages/bionemo-size-aware-batching/tests/bionemo/size_aware_batching/test_sampler.py index 0aef4fe9f9..442f17b0e7 100644 --- a/sub-packages/bionemo-size-aware-batching/tests/bionemo/size_aware_batching/test_sampler.py +++ b/sub-packages/bionemo-size-aware-batching/tests/bionemo/size_aware_batching/test_sampler.py @@ -13,7 +13,9 @@ # See the License for the specific language governing permissions and # limitations under the License. +import functools import itertools +import operator from warnings import warn import pytest @@ -500,35 +502,16 @@ def test_iter_bucket_batch_sampler_with_shuffle(sample_data): base_batch_sampler_shared_kwargs=base_batch_sampler_shared_kwargs, base_batch_sampler_individual_kwargs=base_batch_sampler_individual_kwargs, shuffle=True, - generator=torch.Generator().manual_seed(0), + generator=torch.Generator(), ) + batch_lists_first_iter = list(iter(batch_sampler)) - ref_batch_lists_first_iter = [ - [24, 17, 16, 22, 19], - [2, 5], - [12, 10, 11], - [3, 0], - [15, 18, 20, 21, 23], - [7, 13, 6], - [14, 9, 8], - [1, 4], - ] - assert batch_lists_first_iter == ref_batch_lists_first_iter + assert set(functools.reduce(operator.iadd, batch_lists_first_iter, [])) == set(range(25)) + sample_bucket_indices = [0] * 6 + [1] * 9 + [2] * 10 + assert all(len({sample_bucket_indices[k] for k in batch}) == 1 for batch in batch_lists_first_iter) batch_lists_second_iter = list(iter(batch_sampler)) - ref_batch_lists_second_iter = [ - [14, 9, 13], - [23, 16, 20, 21, 15], - [5, 0], - [8, 10, 11], - [17, 24, 22, 18, 19], - [12, 6, 7], - [4, 2], - [3, 1], - ] - - assert batch_lists_second_iter == ref_batch_lists_second_iter - assert batch_lists_first_iter != ref_batch_lists_second_iter + assert batch_lists_first_iter != batch_lists_second_iter def test_bucket_batch_sampler_with_size_aware_batch_sampler(sample_data): @@ -564,7 +547,7 @@ def cost_of_element(index): batch_lists_second_iter = list(iter(batch_sampler)) assert batch_lists_second_iter == ref_batch_lists - # with shuffling + # with shuffle batch_sampler = BucketBatchSampler( sizes=sizes, bucket_boundaries=bucket_boundaries, @@ -572,42 +555,16 @@ def cost_of_element(index): base_batch_sampler_shared_kwargs={"sizeof": cost_of_element}, base_batch_sampler_individual_kwargs={"max_total_size": [10, 30, 50]}, shuffle=True, - generator=torch.Generator().manual_seed(0), + generator=torch.Generator(), ) batch_lists_first_iter = list(iter(batch_sampler)) - ref_batch_lists_first_iter = [ - [24, 17], - [2, 5, 3, 0], - [12, 10], - [11, 7], - [16, 22], - [19, 15], - [13, 6], - [14, 9], - [18, 20], - [1, 4], - [8], - [21, 23], - ] - assert batch_lists_first_iter == ref_batch_lists_first_iter + assert set(functools.reduce(operator.iadd, batch_lists_first_iter, [])) == set(range(25)) + sample_bucket_indices = [0] * 6 + [1] * 9 + [2] * 10 + assert all(len({sample_bucket_indices[k] for k in batch}) == 1 for batch in batch_lists_first_iter) batch_lists_second_iter = list(iter(batch_sampler)) - ref_batch_lists_second_iter = [ - [15, 18], - [23, 16], - [9, 7, 11], - [5, 2, 1], - [4, 0, 3], - [22, 21], - [12, 8], - [13, 6], - [20, 19], - [24, 17], - [14, 10], - ] - assert batch_lists_second_iter == ref_batch_lists_second_iter - assert batch_lists_first_iter != ref_batch_lists_second_iter + assert batch_lists_first_iter != batch_lists_second_iter def test_iter_bucket_batch_sampler_with_empty_buckets(sample_data): diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/callbacks.py b/sub-packages/bionemo-testing/src/bionemo/testing/callbacks.py index 0c84297039..ed49eeb498 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/callbacks.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/callbacks.py @@ -18,7 +18,7 @@ from typing import Dict, List import torch -from pytorch_lightning import Callback +from lightning.pytorch import Callback class MetricTracker(Callback): # noqa: D101 diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/harnesses/stop_and_go.py b/sub-packages/bionemo-testing/src/bionemo/testing/harnesses/stop_and_go.py index 85ed5703e0..c060e12f84 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/harnesses/stop_and_go.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/harnesses/stop_and_go.py @@ -19,9 +19,9 @@ from abc import ABC, abstractmethod from typing import Dict, Literal, Sequence, Type, TypeVar +import lightning.pytorch as pl import nemo.lightning as nl import pytest -import pytorch_lightning as pl from nemo.collections import llm from nemo.lightning import resume from nemo.lightning.nemo_logger import NeMoLogger @@ -314,6 +314,10 @@ def run_stop_and_go(cls): cls.stop() cls.resume() + # Cleanup and reinitialize the temporary directory so we don't conflict with a previous checkpoint. + cls.tempdir.cleanup() + cls.tempdir = tempfile.TemporaryDirectory() + # Continuous model training. cls.continuous() @@ -363,11 +367,3 @@ def test_train_val_init_consumed_samples(self): assert val_consumed_go == 0 assert train_consumed_stop == 0 assert train_consumed_go > 0 - - def test_identical_number_of_validation_batches(self): - """Ensures that the input tensors for training are identical for the interrupted and continuous tests.""" - callback_type = testing_callbacks.ValidLossCallback - interrupted_callback = get_callback(self.callbacks, Mode.RESUME, callback_type) - continuous_callback = get_callback(self.callbacks, Mode.CONTINUOUS, callback_type) - assert interrupted_callback.data, f"No data found for {callback_type}" - assert len(interrupted_callback.data) == len(continuous_callback.data) diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py index e4d2a4f316..1686de309d 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py @@ -36,8 +36,8 @@ def my_test(): from unittest import mock from unittest.mock import MagicMock +import lightning.pytorch as pl import megatron.core.num_microbatches_calculator -import pytorch_lightning as pl import torch import torch.distributed from megatron.core import parallel_state diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/testing_callbacks.py b/sub-packages/bionemo-testing/src/bionemo/testing/testing_callbacks.py index c591d723ff..b099d64ba9 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/testing_callbacks.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/testing_callbacks.py @@ -14,23 +14,25 @@ # limitations under the License. +import os +import signal from abc import ABC, abstractmethod from typing import Any, Dict, List, Optional, Union import numpy as np import torch +from lightning.pytorch import Callback, LightningModule, Trainer from nemo.lightning import io from nemo.lightning.data import MegatronPretrainingSampler from nemo.lightning.megatron_parallel import CallbackMethods, DataT, MegatronLossReduction, MegatronStep from overrides import override -from pytorch_lightning import Callback, LightningModule, Trainer from bionemo.testing.harnesses.mode import Mode from bionemo.testing.torch import recursive_detach -class StopAfterValidEpochEndCallback(Callback): - """A callback that raises a StopAndGoException after the validation epoch. +class StopAfterValidEpochEndCallback(Callback, CallbackMethods): + """A callback that stops training after the validation epoch. Use this callback for pytest based Stop and go tests. """ @@ -41,6 +43,24 @@ def on_validation_epoch_end(self, trainer: Trainer, pl_module: LightningModule): trainer.should_stop = True +class SignalAfterGivenStepCallback(Callback, CallbackMethods): + """A callback that emits a given signal to the current process at the defined step. + + Use this callback for pytest based Stop and go tests. + """ + + def __init__(self, stop_step: int, signal_: signal.Signals = signal.SIGUSR2): + """Initializes the callback with the given stop_step.""" + self.stop_step = stop_step + self.signal = signal_ + + def on_megatron_step_start(self, step: MegatronStep) -> MegatronStep: + """Stop training if the global step is greater than or equal to the stop_step.""" + if step.trainer.global_step >= self.stop_step: + os.kill(os.getpid(), self.signal) + return step + + class BaseInterruptedVsContinuousCallback(Callback, CallbackMethods, io.IOMixin): """Base class for serializable stop-and-go callback to compare continuous to interrupted training. diff --git a/sub-packages/bionemo-webdatamodule/README.md b/sub-packages/bionemo-webdatamodule/README.md index b06442c66a..0aaa821240 100644 --- a/sub-packages/bionemo-webdatamodule/README.md +++ b/sub-packages/bionemo-webdatamodule/README.md @@ -16,29 +16,30 @@ pytest -v . class WebDataModule(L.LightningDataModule) ``` -A LightningDataModule for using webdataset tar files to setup dataset and -dataloader. This data module takes as input a dictionary: Split -> tar file -directory and vaiours webdataset config settings. In its setup() function, it -creates the webdataset object chaining up the input `pipeline_wds` workflow. In -its train/val/test_dataloader(), it creates the WebLoader object chaining up the -`pipeline_prebatch_wld` workflow - -Examples --------- - -1. create the data module with input directory to webdataset tar files. -Depending on which of the downstream Lightning.Trainer methods are called, -e.g., `Trainer.fit()`, `Trainer.validate()`, `Trainer.test()` or -`Trainer.predict()`, only a subset of the train, val and test splits need to -be specified in the various input options to the data module: - -- `Trainer.fit()` requires the `train` and `val` splits -- `Trainer.validate()` requires the `val` split -- `Trainer.test()` requires the `test` splits -- `Trainer.predict()` requires the `test` splits - -Here is an example of constructing the data module for `Trainer.fit()`: -``` +A LightningDataModule for using webdataset tar files. + +`WebDataModule` is a `LightningDataModule` for using webdataset tar files to setup PyTorch +datasets and dataloaders. This data module takes as input a dictionary: Split -> tar file +directory and vaiours webdataset config settings. In its setup() function, it creates the +webdataset object chaining up the input `pipeline_wds` workflow. In its train/val/test_dataloader(), +it creates the WebLoader object chaining up the `pipeline_prebatch_wld` workflow. + +**Examples**: + + -------- + 1. create the data module with input directory to webdataset tar files. + Depending on which of the downstream Lightning.Trainer methods are called, + e.g., `Trainer.fit()`, `Trainer.validate()`, `Trainer.test()` or + `Trainer.predict()`, only a subset of the train, val and test splits need to + be specified in the various input options to the data module: + + - `Trainer.fit()` requires the `train` and `val` splits + - `Trainer.validate()` requires the `val` split + - `Trainer.test()` requires the `test` splits + - `Trainer.predict()` requires the `test` splits + + Here is an example of constructing the data module for `Trainer.fit()`: +```python >>> from bionemo.webdatamodule.datamodule import Split, WebDataModule >>> >>> tar_file_prefix = "shards" @@ -59,9 +60,6 @@ Here is an example of constructing the data module for `Trainer.fit()`: >>> # for details) >>> suffix_keys_wds = "tensor.pyd" >>> ->>> # see the API doc for the definition of global_batch_size ->>> global_batch_size = 16 ->>> >>> seed = 27193781 >>> >>> # Specify the routines to process the samples in the WebDataset object. @@ -110,14 +108,25 @@ Here is an example of constructing the data module for `Trainer.fit()`: >>> split : {"num_workers": 2} for split in Split >>> } >>> +>>> invoke_wds = { +>>> split: [("with_epoch", {"nbatches" : 5})] for split in Split +>>> } +>>> +>>> invoke_wld = { +>>> split: [("with_epoch", {"nbatches" : 5}] for split in Split +>>> } +>>> >>> # construct the data module ->>> data_module = WebDataModule(dirs_of_tar_files, n_samples, suffix_keys_wds, - global_batch_size, +>>> data_module = WebDataModule(suffix_keys_wds, + dirs_of_tar_files, prefix_tars_wds=tar_file_prefix, pipeline_wds=pipeline_wds, pipeline_prebatch_wld=pipeline_prebatch_wld, kwargs_wds=kwargs_wds, - kwargs_wld=kwargs_wld) + kwargs_wld=kwargs_wld, + invoke_wds=invoke_wds, + invoke_wld=invoke_wld, + ) ``` @@ -126,64 +135,62 @@ Here is an example of constructing the data module for `Trainer.fit()`: ```python def __init__( - dirs_tars_wds: Dict[Split, str], - n_samples: Dict[Split, int], - suffix_keys_wds: Union[str, Iterable[str]], - global_batch_size: int, - prefix_tars_wds: str = "wdshards", - pipeline_wds: Optional[Dict[Split, Union[Iterable[Iterable[Any]], - Iterable[Any]]]] = None, - pipeline_prebatch_wld: Optional[Dict[Split, - Union[Iterable[Iterable[Any]], - Iterable[Any]]]] = None, - kwargs_wds: Optional[Dict[Split, Dict[str, Any]]] = None, - kwargs_wld: Optional[Dict[Split, Dict[str, Any]]] = None) + suffix_keys_wds: Union[str, Iterable[str]], + dirs_tars_wds: Dict[Split, str], + prefix_tars_wds: str = "wdshards", + pipeline_wds: Optional[Dict[Split, Union[Iterable[Iterable[Any]], + Iterable[Any]]]] = None, + pipeline_prebatch_wld: Optional[Dict[Split, Union[Iterable[Iterable[Any]], + Iterable[Any]]]] = None, + kwargs_wds: Optional[Dict[Split, Dict[str, Any]]] = None, + kwargs_wld: Optional[Dict[Split, Dict[str, Any]]] = None, + invoke_wds: Optional[Dict[Split, List[Tuple[str, Dict[str, Any]]]]] = None, + invoke_wld: Optional[Dict[Split, List[Tuple[str, Dict[str, + Any]]]]] = None) ``` -constructor +Constructor. **Arguments**: -- `dirs_tars_wds` _Dict[Split, str]_ - input dictionary: Split -> tar file - directory that contains the webdataset tar files for each split -- `n_samples` _Dict[Split, int]_ - input dictionary: Split -> number of - data samples for each split -- `suffix_keys_wds` _Union[str, Iterable[str]]_ - a set of keys each +- `suffix_keys_wds` - a set of keys each corresponding to a data object in the webdataset tar file dictionary. The data objects of these keys will be extracted and tupled for each sample in the tar files -- `global_batch_size` _int_ - size of batch summing across nodes in Data - Distributed Parallel, i.e., local_batch_size * n_nodes. NOTE: - this data module doesn't rely on the input `global_batch_size` - for batching the samples. The batching is supposed to be done as - a part of the input `pipeline_prebatch_wld`. `global_batch_size` - is only used to compute a (pseudo-) epoch length for the data - loader so that the loader yield approximately n_samples // - global_batch_size batches +- `dirs_tars_wds` - input dictionary: Split -> tar file + directory that contains the webdataset tar files for each split Kwargs: -- `prefix_tars_wds` _str_ - name prefix of the input webdataset tar +- `prefix_tars_wds` - name prefix of the input webdataset tar files. The input tar files are globbed by "{dirs_tars_wds[split]}/{prefix_tars_wds}-*.tar" - pipeline_wds (Optional[Dict[Split, Union[Iterable[Iterable[Any]], -- `Iterable[Any]]]])` - a dictionary of webdatast composable, i.e., +- `pipeline_wds` - a dictionary of webdatast composable, i.e., functor that maps a iterator to another iterator that transforms the data sample yield from the dataset object, for different splits, or an iterable to such a sequence of such iterators. For example, this can be used to transform the sample in the worker before sending it to the main process of the dataloader - pipeline_prebatch_wld (Optional[Dict[Split, - Union[Iterable[Iterable[Any]], Iterable[Any]]]]): a dictionary +- `pipeline_prebatch_wld` - a dictionary of webloader composable, i.e., functor that maps a iterator to another iterator that transforms the data sample yield from the WebLoader object, for different splits, or an iterable to a seuqnence of such iterators. For example, this can be used for batching the samples. NOTE: this is applied before batching is yield from the WebLoader -- `kwargs_wds` _Optional[Dict[Split, Dict[str, Any]]]_ - kwargs for the - WebDataset.__init__() -- `kwargs_wld` _Optional[Dict[Split, Dict[str, Any]]]_ - kwargs for the - WebLoader.__init__(), e.g., num_workers, of each split +- `kwargs_wds` - kwargs for the WebDataset.__init__() + kwargs_wld : kwargs for the WebLoader.__init__(), e.g., num_workers, of each split +- `invoke_wds` - a dictionary of WebDataset methods to be called upon WebDataset + construction. These methods must return the WebDataset object itself. Examples + are .with_length() and .with_epoch(). These methods will be applied towards + the end of returning the WebDataset object, i.e., after the pipline_wds + have been applied. The inner list of tuples each has its first element as the + method name and the second element as the corresponding method's kwargs. +- `invoke_wld` - a dictionary of WebLoader methods to be called upon WebLoader + construction. These methods must return the WebLoader object itself. Examples + are .with_length() and .with_epoch(). These methods will be applied towards + the end of returning the WebLoader object, i.e., after the pipelin_prebatch_wld + have been applied. The inner list of tuples each has its first element as the + method name and the second element as the corresponding method's kwargs. @@ -193,11 +200,10 @@ constructor def prepare_data() -> None ``` -This is called only by the main process by the Lightning workflow. Do -not rely on this data module object's state update here as there is no -way to communicate the state update to other subprocesses. +This is called only by the main process by the Lightning workflow. -Returns: None +Do not rely on this data module object's state update here as there is no +way to communicate the state update to other subprocesses. Is a **no-op**. @@ -207,45 +213,86 @@ Returns: None def setup(stage: str) -> None ``` -This is called on all Lightning-managed nodes in a multi-node -training session - +This is called on all Lightning-managed nodes in a multi-node training session. **Arguments**: -- `stage` _str_ - "fit", "test" or "predict" -- `Returns` - None +- `stage` - "fit", "test" or "predict" -## PickledDataWDS + + +#### train\_dataloader ```python -class PickledDataWDS(WebDataModule) +def train_dataloader() -> wds.WebLoader ``` -A LightningDataModule to process pickled data into webdataset tar files -and setup dataset and dataloader. This inherits the webdataset setup from -its parent module `WebDataModule`. This data module takes a directory of -pickled data files, data filename prefixes for train/val/test splits, data -filename suffixes and prepare webdataset tar files by globbing the specific -pickle data files `{dir_pickles}/{name_subset[split]}.{suffix_pickles}` and -outputing to webdataset tar file with the dict structure: +Webdataset for the training data. + + + +#### val\_dataloader + +```python +def val_dataloader() -> wds.WebLoader ``` - {"__key__" : name.replace(".", "-"), - suffix_pickles : pickled.dumps(data) } + +Webdataset for the validation data. + + + +#### test\_dataloader + +```python +def test_dataloader() -> wds.WebLoader ``` + +Webdataset for the test data. + + + +#### predict\_dataloader + +```python +def predict_dataloader() -> wds.WebLoader +``` + +Alias for :func:`test_dataloader`. + + + +## PickledDataWDS Objects + +```python +class PickledDataWDS(WebDataModule) +``` + +A LightningDataModule to process pickled data into webdataset tar files. + +`PickledDataWDS` is a LightningDataModule to process pickled data into webdataset tar files +and setup dataset and dataloader. This inherits the webdataset setup from its parent module +`WebDataModule`. This data module takes a directory of pickled data files, data filename +prefixes for train/val/test splits, data filename suffixes and prepare webdataset tar files +by globbing the specific pickle data files `{dir_pickles}/{name_subset[split]}.{suffix_pickles}` +and outputing to webdataset tar file with the dict structure: NOTE: this assumes only one pickled file is processed for each sample. In its setup() function, it creates the webdataset object chaining up the input `pipeline_wds` workflow. In its train/val/test_dataloader(), it creates the WebLoader object chaining up the `pipeline_prebatch_wld` workflow. -Examples --------- +``` + {"__key__" : name.replace(".", "-"), + suffix_pickles : pickled.dumps(data) } +``` -1. create the data module with a directory of pickle files and the file name -prefix thereof for different splits to used by `Lightning.Trainer.fit()` +**Examples**: -``` ->>> from bionemo.webdatamodule.datamodule import Split, PickledDataWDS + -------- + 1. create the data module with a directory of pickle files and the file name + prefix thereof for different splits to used by `Lightning.Trainer.fit()` + +```python +>>> from bionemo.core.data.datamodule import Split, PickledDataWDS >>> dir_pickles = "/path/to/my/pickles/dir" @@ -265,10 +312,11 @@ prefix thereof for different splits to used by `Lightning.Trainer.fit()` >>> n_tars_wds = 5 >>> prefix_tars_wds = "myshards" ->>> output_dir_tar_files = "/path/to/output/tars/dir" - ->>> # see the `WebDataModule` API doc for the definition of global_batch_size ->>> global_batch_size = 16 +>>> output_dir_tar_files = { + Split.train : "/path/to/output/tars/dir-train", + Split.val : "/path/to/output/tars/dir-val", + Split.test : "/path/to/output/tars/dir-test", + } >>> # user can optionally customize the data processing routines and kwargs used >>> # in the WebDataset and WebLoader (see the examples in `WebDataModule`) @@ -281,21 +329,25 @@ prefix thereof for different splits to used by `Lightning.Trainer.fit()` >>> kwargs_wld = { Split.train: ..., Split.val: ... } +>>> invoke_wds = { Split.train: ..., Split.val: ... } + +>>> invoke_wld = { Split.train: ..., Split.val: ... } + >>> # create the data module >>> data_module = PickledDataWDS( >>> dir_pickles, ->>> suffix_pickles, >>> names_subset, ->>> output_dir_tar_files, ->>> global_batch_size, # `WebDataModule` args +>>> suffix_pickles, # `WebDataModule` args +>>> output_dir_tar_files, # `WebDataModule` args >>> n_tars_wds=n_tars_wds, >>> prefix_tars_wds=prefix_tars_wds, # `WebDataModule` kwargs >>> pipeline_wds=pipeline_wds, # `WebDataModule` kwargs >>> pipeline_prebatch_wld=pipelines_wdl_batch, # `WebDataModule` kwargs >>> kwargs_wds=kwargs_wds, # `WebDataModule` kwargs >>> kwargs_wld=kwargs_wld, # `WebDataModule` kwargs +>>> invoke_wds=invoke_wds, # `WebDataModule` kwargs +>>> invoke_wld=invoke_wld, # `WebDataModule` kwargs >>> ) - ``` @@ -304,33 +356,22 @@ prefix thereof for different splits to used by `Lightning.Trainer.fit()` ```python def __init__(dir_pickles: str, - suffix_pickles: str, names_subset: Dict[Split, List[str]], - prefix_dir_tars_wds: str, *args, n_tars_wds: Optional[int] = None, - **kwargs) + **kwargs) -> None ``` -constructor +Constructor. **Arguments**: -- `dir_pickles` _str_ - input directory of pickled data files -- `suffix_pickles` _str_ - filename suffix of the input data in - dir_pickles. This is also used as the key mapped to the - tarballed pickled object in the webdataset -- `names_subset` _Dict[Split, List[str]]_ - list of filename prefix of +- `dir_pickles` - input directory of pickled data files +- `names_subset` - list of filename prefix of the data samples to be loaded in the dataset and dataloader for each of the split -- `prefix_dir_tars_wds` _str_ - directory name prefix to store the output - webdataset tar files. The actual directories storing the train, val - and test sets will be suffixed with "train", "val" and "test" - respectively. - `*args` - arguments passed to the parent WebDataModule - - Kwargs: -- `n_tars_wds` _int_ - attempt to create at least this number of +- `n_tars_wds` - attempt to create at least this number of webdataset shards - `**kwargs` - arguments passed to the parent WebDataModule @@ -342,12 +383,11 @@ constructor def prepare_data() -> None ``` -This is called only by the main process by the Lightning workflow. Do -not rely on this data module object's state update here as there is no +This is called only by the main process by the Lightning workflow. + +Do not rely on this data module object's state update here as there is no way to communicate the state update to other subprocesses. The nesting `pickles_to_tars` function goes through the data name prefixes in the different splits, read the corresponding pickled file and output a webdataset tar archive with the dict structure: {"__key__" : name.replace(".", "-"), suffix_pickles : pickled.dumps(data) }. - -Returns: None diff --git a/sub-packages/bionemo-webdatamodule/src/bionemo/webdatamodule/datamodule.py b/sub-packages/bionemo-webdatamodule/src/bionemo/webdatamodule/datamodule.py index 5d56035097..38a6afefd2 100644 --- a/sub-packages/bionemo-webdatamodule/src/bionemo/webdatamodule/datamodule.py +++ b/sub-packages/bionemo-webdatamodule/src/bionemo/webdatamodule/datamodule.py @@ -16,7 +16,7 @@ import glob from enum import Enum, auto -from typing import Any, Dict, Iterable, List, Optional, Union, get_args +from typing import Any, Dict, Iterable, List, Optional, Tuple, Union, get_args import lightning as L import webdataset as wds @@ -55,7 +55,7 @@ class WebDataModule(L.LightningDataModule): - `Trainer.predict()` requires the `test` splits Here is an example of constructing the data module for `Trainer.fit()`: - ``` + ```python >>> from bionemo.webdatamodule.datamodule import Split, WebDataModule >>> >>> tar_file_prefix = "shards" @@ -76,9 +76,6 @@ class WebDataModule(L.LightningDataModule): >>> # for details) >>> suffix_keys_wds = "tensor.pyd" >>> - >>> # see the API doc for the definition of global_batch_size - >>> global_batch_size = 16 - >>> >>> seed = 27193781 >>> >>> # Specify the routines to process the samples in the WebDataset object. @@ -127,48 +124,50 @@ class WebDataModule(L.LightningDataModule): >>> split : {"num_workers": 2} for split in Split >>> } >>> + >>> invoke_wds = { + >>> split: [("with_epoch", {"nbatches" : 5})] for split in Split + >>> } + >>> + >>> invoke_wld = { + >>> split: [("with_epoch", {"nbatches" : 5}] for split in Split + >>> } + >>> >>> # construct the data module - >>> data_module = WebDataModule(n_samples, suffix_keys_wds, - dirs_of_tar_files, global_batch_size, + >>> data_module = WebDataModule(suffix_keys_wds, + dirs_of_tar_files, prefix_tars_wds=tar_file_prefix, pipeline_wds=pipeline_wds, pipeline_prebatch_wld=pipeline_prebatch_wld, kwargs_wds=kwargs_wds, - kwargs_wld=kwargs_wld) + kwargs_wld=kwargs_wld, + invoke_wds=invoke_wds, + invoke_wld=invoke_wld, + ) ``` """ def __init__( self, - n_samples: Dict[Split, int], suffix_keys_wds: Union[str, Iterable[str]], dirs_tars_wds: Dict[Split, str], - global_batch_size: int, prefix_tars_wds: str = "wdshards", pipeline_wds: Optional[Dict[Split, Union[Iterable[Iterable[Any]], Iterable[Any]]]] = None, pipeline_prebatch_wld: Optional[Dict[Split, Union[Iterable[Iterable[Any]], Iterable[Any]]]] = None, kwargs_wds: Optional[Dict[Split, Dict[str, Any]]] = None, kwargs_wld: Optional[Dict[Split, Dict[str, Any]]] = None, + invoke_wds: Optional[Dict[Split, List[Tuple[str, Dict[str, Any]]]]] = None, + invoke_wld: Optional[Dict[Split, List[Tuple[str, Dict[str, Any]]]]] = None, ): """Constructor. Args: - n_samples: input dictionary: Split -> number of data samples for each split suffix_keys_wds: a set of keys each corresponding to a data object in the webdataset tar file dictionary. The data objects of these keys will be extracted and tupled for each sample in the tar files dirs_tars_wds: input dictionary: Split -> tar file directory that contains the webdataset tar files for each split - global_batch_size: size of batch summing across nodes in Data - Distributed Parallel, i.e., local_batch_size * n_nodes. NOTE: - this data module doesn't rely on the input `global_batch_size` - for batching the samples. The batching is supposed to be done as - a part of the input `pipeline_prebatch_wld`. `global_batch_size` - is only used to compute a (pseudo-) epoch length for the data - loader so that the loader yield approximately n_samples // - global_batch_size batches Kwargs: prefix_tars_wds: name prefix of the input webdataset tar files. The input tar files are globbed by @@ -189,22 +188,23 @@ def __init__( yield from the WebLoader kwargs_wds: kwargs for the WebDataset.__init__() kwargs_wld : kwargs for the WebLoader.__init__(), e.g., num_workers, of each split + invoke_wds: a dictionary of WebDataset methods to be called upon WebDataset + construction. These methods must return the WebDataset object itself. Examples + are .with_length() and .with_epoch(). These methods will be applied towards + the end of returning the WebDataset object, i.e., after the pipline_wds + have been applied. The inner list of tuples each has its first element as the + method name and the second element as the corresponding method's kwargs. + invoke_wld: a dictionary of WebLoader methods to be called upon WebLoader + construction. These methods must return the WebLoader object itself. Examples + are .with_length() and .with_epoch(). These methods will be applied towards + the end of returning the WebLoader object, i.e., after the pipelin_prebatch_wld + have been applied. The inner list of tuples each has its first element as the + method name and the second element as the corresponding method's kwargs. """ super().__init__() self._dirs_tars_wds = dirs_tars_wds - keys_subset = self._dirs_tars_wds.keys() - - if n_samples.keys() != keys_subset: - raise RuntimeError( - f"Input n_samples has different keys than " f"dirs_tars_wds: {n_samples.keys()} vs " f"{keys_subset}" - ) - - self._n_samples = n_samples - - self._global_batch_size = global_batch_size - if not isinstance(suffix_keys_wds, get_args(Union[str, Iterable])): raise TypeError("suffix_keys_wds can only be str or Iterable[str]") @@ -218,6 +218,9 @@ def __init__( self._kwargs_wds = kwargs_wds + self._invoke_wds = invoke_wds + self._invoke_wld = invoke_wld + # to be created later in setup self._dataset = {} @@ -254,6 +257,11 @@ def _setup_wds(self, split: Split) -> wds.WebDataset: dataset = dataset.compose(*self._pipeline_wds[split]) else: dataset = dataset.compose(self._pipeline_wds[split]) + + if self._invoke_wds is not None and self._invoke_wds[split] is not None: + for method in self._invoke_wds[split]: + name_method, kwargs_method = method + dataset = getattr(dataset, name_method)(**kwargs_method) return dataset def setup(self, stage: str) -> None: @@ -291,10 +299,8 @@ def _setup_dataloader(self, split: Split) -> wds.WebLoader: f"_setup_dataloader() is called with {split} split without setting up the corresponding dataset." ) dataset = self._dataset[split] - n_samples = self._n_samples[split] - n_batches = (n_samples + self._global_batch_size - 1) // self._global_batch_size kwargs = self._kwargs_wld[split] if self._kwargs_wld is not None else None - loader = wds.WebLoader(dataset, batch_size=None, **(kwargs if kwargs is not None else {})) + loader = wds.WebLoader(dataset, **(kwargs if kwargs is not None else {})) if self._pipeline_prebatch_wld is not None and self._pipeline_prebatch_wld[split] is not None: if isinstance(self._pipeline_prebatch_wld[split], Iterable): @@ -302,7 +308,10 @@ def _setup_dataloader(self, split: Split) -> wds.WebLoader: else: loader = loader.compose(self._pipeline_prebatch_wld[split]) - loader = loader.with_epoch(n_batches) + if self._invoke_wld is not None and self._invoke_wld[split] is not None: + for method in self._invoke_wld[split]: + name_method, kwargs_method = method + loader = getattr(loader, name_method)(**kwargs_method) return loader @@ -346,7 +355,7 @@ class PickledDataWDS(WebDataModule): 1. create the data module with a directory of pickle files and the file name prefix thereof for different splits to used by `Lightning.Trainer.fit()` - ``` + ```python >>> from bionemo.core.data.datamodule import Split, PickledDataWDS >>> dir_pickles = "/path/to/my/pickles/dir" @@ -373,9 +382,6 @@ class PickledDataWDS(WebDataModule): Split.test : "/path/to/output/tars/dir-test", } - >>> # see the `WebDataModule` API doc for the definition of global_batch_size - >>> global_batch_size = 16 - >>> # user can optionally customize the data processing routines and kwargs used >>> # in the WebDataset and WebLoader (see the examples in `WebDataModule`) @@ -387,19 +393,24 @@ class PickledDataWDS(WebDataModule): >>> kwargs_wld = { Split.train: ..., Split.val: ... } + >>> invoke_wds = { Split.train: ..., Split.val: ... } + + >>> invoke_wld = { Split.train: ..., Split.val: ... } + >>> # create the data module >>> data_module = PickledDataWDS( >>> dir_pickles, >>> names_subset, >>> suffix_pickles, # `WebDataModule` args >>> output_dir_tar_files, # `WebDataModule` args - >>> global_batch_size, # `WebDataModule` args >>> n_tars_wds=n_tars_wds, >>> prefix_tars_wds=prefix_tars_wds, # `WebDataModule` kwargs >>> pipeline_wds=pipeline_wds, # `WebDataModule` kwargs >>> pipeline_prebatch_wld=pipelines_wdl_batch, # `WebDataModule` kwargs >>> kwargs_wds=kwargs_wds, # `WebDataModule` kwargs >>> kwargs_wld=kwargs_wld, # `WebDataModule` kwargs + >>> invoke_wds=invoke_wds, # `WebDataModule` kwargs + >>> invoke_wld=invoke_wld, # `WebDataModule` kwargs >>> ) ``` """ @@ -419,15 +430,12 @@ def __init__( names_subset: list of filename prefix of the data samples to be loaded in the dataset and dataloader for each of the split - *args: arguments passed to the parent WebDataModule after its - `n_samples` args (where `n_samples` is deduced from the length of - `names_subset` arg of this class) + *args: arguments passed to the parent WebDataModule n_tars_wds: attempt to create at least this number of webdataset shards **kwargs: arguments passed to the parent WebDataModule """ super().__init__( - {split: len(names_subset[split]) for split in names_subset.keys()}, *args, **kwargs, ) diff --git a/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/conftest.py b/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/conftest.py index 3c9c024d4a..a90a2d0ae2 100644 --- a/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/conftest.py +++ b/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/conftest.py @@ -107,7 +107,6 @@ def gen_test_data(tmp_path_factory, gen_pickle_files, request): def _create_webdatamodule(gen_test_data, num_workers=2): (_, dirs_tars_wds, _, suffix_keys_wds, prefix_tars_wds, n_samples, _) = gen_test_data local_batch_size = 2 - global_batch_size = 2 seed_rng_shfl = 82838392 batch = batched(local_batch_size, collation_fn=lambda list_samples: torch.vstack(list_samples)) @@ -146,16 +145,21 @@ def _create_webdatamodule(gen_test_data, num_workers=2): kwargs_wld = {split: {"num_workers": num_workers} for split in Split} + global_batch_size = 2 + invoke_wld = { + split: [("with_epoch", {"nbatches": (n_samples[split] + global_batch_size - 1) // global_batch_size})] + for split in Split + } + data_module = WebDataModule( - n_samples, suffix_keys_wds, dirs_tars_wds, - global_batch_size, prefix_tars_wds=prefix_tars_wds, pipeline_wds=pipeline_wds, pipeline_prebatch_wld=pipeline_prebatch_wld, kwargs_wds=kwargs_wds, kwargs_wld=kwargs_wld, + invoke_wld=invoke_wld, ) return data_module, dirs_tars_wds @@ -224,7 +228,6 @@ def _create_pickleddatawds(tmp_path_factory, gen_test_data): names, ) = gen_test_data local_batch_size = 2 - global_batch_size = 2 seed_rng_shfl = 82838392 n_tars_wds = 3 @@ -264,18 +267,24 @@ def _create_pickleddatawds(tmp_path_factory, gen_test_data): kwargs_wld = {split: {"num_workers": 2} for split in Split} + global_batch_size = 2 + invoke_wld = { + split: [("with_epoch", {"nbatches": (n_samples[split] + global_batch_size - 1) // global_batch_size})] + for split in Split + } + data_module = PickledDataWDS( dir_pickles, names, suffix_keys_wds, dirs_tars_wds, - global_batch_size, n_tars_wds=n_tars_wds, prefix_tars_wds=prefix_tars_wds, pipeline_wds=pipeline_wds, pipeline_prebatch_wld=pipeline_prebatch_wld, kwargs_wds=kwargs_wds, kwargs_wld=kwargs_wld, + invoke_wld=invoke_wld, ) return data_module, dirs_tars_wds, n_tars_wds diff --git a/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/test_datamodule.py b/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/test_datamodule.py index ba9f000b0a..923c8ce350 100644 --- a/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/test_datamodule.py +++ b/sub-packages/bionemo-webdatamodule/tests/bionemo/webdatamodule/test_datamodule.py @@ -26,9 +26,6 @@ @pytest.mark.parametrize("split", list(Split)) def test_webdatamodule_init(split, create_webdatamodule): data_module, dirs_tars_wds = create_webdatamodule - assert data_module._n_samples[split] == 10, ( - f"Wrong {split}-set size: " f"expected 10 " f"but got {data_module._n_samples[split]}" - ) assert data_module._dirs_tars_wds[split] == f"{dirs_tars_wds[split]}", ( f"Wrong tar files directory: " f"expected {dirs_tars_wds[split]} " @@ -169,9 +166,6 @@ def test_webdatamodule_in_lightning( @pytest.mark.parametrize("split", list(Split)) def test_pickleddatawds_init(split, create_pickleddatawds): data_module, dirs_tars_wds, _ = create_pickleddatawds - assert data_module._n_samples[split] == 10, ( - f"Wrong {split}-set size: " f"expected 10 " f"but got {data_module._n_samples[split]}" - ) assert data_module._dirs_tars_wds[split] == dirs_tars_wds[split], ( f"Wrong tar files directory: " f"expected {dirs_tars_wds[split]} " diff --git a/tach.toml b/tach.toml index b28c38ae7f..1a09b9b94f 100644 --- a/tach.toml +++ b/tach.toml @@ -43,10 +43,15 @@ depends_on = [ path = "bionemo.fw" depends_on = [ { path = "bionemo.core" }, - { path = "bionemo.llm" }, { path = "bionemo.esm2" }, { path = "bionemo.geneformer" }, + { path = "bionemo.geometric" }, + { path = "bionemo.llm" }, + { path = "bionemo.noodles" }, + { path = "bionemo.scdl" }, + { path = "bionemo.size_aware_batching" }, { path = "bionemo.webdatamodule" }, + { path = "bionemo.noodles" }, ] [[modules]] @@ -68,6 +73,12 @@ depends_on = [ { path = "bionemo.core" }, ] +[[modules]] +path = "bionemo.noodles" +depends_on = [ + { path = "bionemo.core" }, +] + [[modules]] path = "bionemo.scdl" depends_on = [ From b9dfd5c967b0dea77f94f79d28f92faf31bb536a Mon Sep 17 00:00:00 2001 From: John St John Date: Wed, 18 Dec 2024 16:19:38 -0800 Subject: [PATCH 009/140] Hyena golden value test --- 3rdparty/NeMo | 2 +- Dockerfile | 15 +-- .../src/bionemo/core/data/resources/evo2.yaml | 23 ++++ .../bionemo-evo2/tests/bionemo/test_evo2.py | 124 ++++++++++++++++++ 4 files changed, 153 insertions(+), 11 deletions(-) create mode 100644 sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py diff --git a/3rdparty/NeMo b/3rdparty/NeMo index f7899a64b5..4d680f45b3 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit f7899a64b5ce6f8fe27b5aa386a0044878f3efe8 +Subproject commit 4d680f45b396529871920155f0d05ceb361a5624 diff --git a/Dockerfile b/Dockerfile index e4065065e7..15ec135ad9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,5 @@ # Base image with apex and transformer engine, but without NeMo or Megatron-LM. -ARG BASE_IMAGE=nvcr.io/nvidia/pytorch:24.02-py3 +ARG BASE_IMAGE=nvcr.io/nvidia/pytorch:24.10-py3 FROM rust:1.82.0 as rust-env @@ -25,7 +25,7 @@ RUN git clone https://github.com/NVIDIA/apex.git && \ --config-settings "--build-option=--cpp_ext --cuda_ext --fast_layer_norm --distributed_adam --deprecated_fused_adam --group_norm" # Transformer Engine pre-1.7.0. 1.7 standardizes the meaning of bits in the attention mask to match -ARG TE_COMMIT=c27ee60ec746210bcea4ec33958dbbff06706506 +ARG TE_COMMIT=2215fa5c7557b66034068816020f9f611019e457 RUN git clone https://github.com/NVIDIA/TransformerEngine.git && \ cd TransformerEngine && \ git fetch origin ${TE_COMMIT} && \ @@ -49,11 +49,11 @@ RUN apt-get install -y gnupg # Check the nemo dependency for causal conv1d and make sure this checkout # tag matches. If not, update the tag in the following line. RUN CAUSAL_CONV1D_FORCE_BUILD=TRUE pip --disable-pip-version-check --no-cache-dir install \ - git+https://github.com/Dao-AILab/causal-conv1d.git@v1.2.0.post2 + git+https://github.com/Dao-AILab/causal-conv1d.git@v1.2.2.post1 # Mamba dependancy installation RUN pip --disable-pip-version-check --no-cache-dir install \ - git+https://github.com/state-spaces/mamba.git@v2.0.3 + git+https://github.com/state-spaces/mamba.git@v2.2.2 RUN pip install hatchling # needed to install nemo-run ARG NEMU_RUN_TAG=34259bd3e752fef94045a9a019e4aaf62bd11ce2 @@ -72,12 +72,7 @@ RUN apt-get update && \ rm -rf /var/lib/apt/lists/* RUN apt purge -y libslurm37 libpmi2-0 && \ apt autoremove -y -RUN source /usr/local/nvm/nvm.sh && \ - NODE_VER=$(nvm current) && \ - nvm deactivate && \ - nvm uninstall $NODE_VER && \ - sed -i "/NVM/d" /root/.bashrc && \ - sed -i "/nvm.sh/d" /etc/bash.bashrc + # Use UV to install python packages from the workspace. This just installs packages into the system's python # environment, and does not use the current uv.lock file. diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml new file mode 100644 index 0000000000..3faa65e196 --- /dev/null +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -0,0 +1,23 @@ +- tag: 7b-8k:1.0 + ngc: null + ngc_registry: model + pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_nemo2.tar.gz" + sha256: cc36769cc80c19b7105e8341f51a89230ba704dbe11c982603378fc418425640 # pragma: allowlist secret + owner: John St John + description: > + A 7b parameter evo2 model used in testing + +- tag: 7b-8k-nofp8-te-goldvalue-testdata:1.0 + ngc: null + ngc_registry: resource + pbss: "s3://bionemo-ci/test_data/evo2/final_7b_no_fp8_golden_value.pt" + sha256: dee5372fc6011dffc3f3933440623993b1870961fec6a24d1a3a874c940259b2 # pragma: allowlist secret + owner: John St John + description: > + Test data for Evo2 inference. Built using the `evo2/7b-8k:1.0` checkpoint on an H100 GPU and the following DNA: + GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAG + ATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAA + CCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGG + TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA + CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT + ATAATTTTAATTTATATAAT \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py new file mode 100644 index 0000000000..f0eff07bdf --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py @@ -0,0 +1,124 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import logging +from pathlib import Path +from typing import Literal, Set + +import torch +from megatron.core.transformer.enums import AttnBackend +from megatron.core.transformer.module import Float16Module +from nemo.collections import llm +from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer +from nemo.lightning.io.pl import MegatronCheckpointIO +from transformer_engine.pytorch.utils import get_cudnn_version +from transformer_engine.pytorch.utils import get_device_compute_capability + +from bionemo.llm.utils.weight_utils import ( + MegatronModelType, + _key_in_filter, + _munge_key_megatron_to_nemo2, + _munge_sharded_tensor_key_megatron_to_nemo2, +) +from bionemo.testing.megatron_parallel_state_utils import distributed_model_parallel_state +from bionemo.core.data.load import load + +logger = logging.getLogger(__name__) +logger.setLevel(logging.DEBUG) # Capture all levels in the logger itself + + +def load_weights_sharded_inplace_nemo2_to_mcore( + model: MegatronModelType, + distributed_checkpoint_dir: str | Path, + skip_keys_with_these_prefixes: Set[str], + ckpt_format: Literal["zarr", "torch_dist"] = "zarr", +): + logger.info("Start setting up state dict") + sharded_state_dict = { + _munge_key_megatron_to_nemo2(k): _munge_sharded_tensor_key_megatron_to_nemo2(v) + for k, v in model.sharded_state_dict().items() + if not _key_in_filter( + k, skip_keys_with_these_prefixes + ) # and "_extra_state" not in k # extra state is needed for fp8 sharded states + } + MegatronCheckpointIO(save_ckpt_format=ckpt_format).load_checkpoint( + distributed_checkpoint_dir, sharded_state_dict=sharded_state_dict + ) + + +def test_golden_values(): + """Step 1: + # add local .ssh/*.pub key to eos ~/.ssh/authorized_keys + mkdir -p arc_model/checkpoints/ + rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/interleaved_hyena_7b arc_model/checkpoints/ + mkdir -p arc_model/gold_standards/ + rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/interleaved_7b_golden_value.pt arc_model/gold_standards/ + rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/final_7b_no_fp8_golden_value.pt arc_model/gold_standards/ + """ + try: + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k:1.0") / "weights" + gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") + except ValueError as e: + if e.args[0].endswith("does not have an NGC URL."): + raise ValueError( + "Please re-run test with `BIONEMO_DATA_SOURCE=pbss py.test ...`, " + "one or more files are missing from ngc." + ) + else: + raise e + with torch.inference_mode(), distributed_model_parallel_state(): + hyena_config = llm.Hyena7bConfig(use_te=True) + tokenizer = get_nmt_tokenizer( + "byte-level", + ) + raw_megatron_model = hyena_config.configure_model(tokenizer).eval().cuda() + device = raw_megatron_model.parameters().__next__().device + load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "zarr") + model = Float16Module(hyena_config, raw_megatron_model) + input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAAT" + input_ids = torch.tensor(tokenizer.text_to_ids(input_seq)).int().unsqueeze(0).to(device) + position_ids = torch.arange(len(input_seq)).unsqueeze(0).to(device) + attention_mask = None + outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) + gold_standard_no_fp8 = torch.load(gold_standard_no_fp8).to( + device=outputs.device, dtype=outputs.dtype + ) + our_generation_str = "".join( + [chr(idx) for idx in outputs.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy().tolist()] + ) + their_generation_str_no_fp8 = "".join( + [ + chr(idx) + for idx in gold_standard_no_fp8.softmax(dim=-1) + .argmax(dim=-1) + .flatten() + .detach() + .cpu() + .numpy() + .tolist() + ] + ) + char_matches_ours_v_theirs_no_fp8 = [ + our_generation_str[i] == their_generation_str_no_fp8[i] for i in range(len(their_generation_str_no_fp8)) + ] + token_similarity_vs_no_fp8 = sum(char_matches_ours_v_theirs_no_fp8) / len(char_matches_ours_v_theirs_no_fp8) + # We can get exact very tight numerical precision on H100 with cudnn 9.5+ (nvidia docker 24.10-py3 or better) + if get_cudnn_version() >= (9, 5, 0) and get_device_compute_capability() >= (9, 0): + assert token_similarity_vs_no_fp8 == 1.0 + torch.testing.assert_close(outputs, gold_standard_no_fp8) + else: + assert token_similarity_vs_no_fp8 >= 0.996 + torch.testing.assert_close(outputs, gold_standard_no_fp8, atol=0.3, rtol=3) From e6278d9776dbb79c5b7aa83a54ce631a8ff7b418 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Fri, 20 Dec 2024 17:01:01 -0800 Subject: [PATCH 010/140] [cye/blended-training] Expose blended weights for training Hyena. --- 3rdparty/NeMo | 2 +- Dockerfile | 5 +- .../src/bionemo/evo2/data/preprocess.py | 33 +- .../src/bionemo/evo2/data/tokenizer.py | 2 +- .../src/bionemo/evo2/run/train.py | 289 ++++++++++++++++-- .../bionemo/evo2/{data => utils}/config.py | 9 +- .../tests/config/test_dataset_config.yaml | 81 +++++ .../src/bionemo/llm/utils/datamodule_utils.py | 14 +- 8 files changed, 387 insertions(+), 48 deletions(-) rename sub-packages/bionemo-evo2/src/bionemo/evo2/{data => utils}/config.py (87%) create mode 100644 sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 4d680f45b3..191593a527 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 4d680f45b396529871920155f0d05ceb361a5624 +Subproject commit 191593a5274c989856a277531c1cc5195f5f1653 diff --git a/Dockerfile b/Dockerfile index 15ec135ad9..d311fca969 100644 --- a/Dockerfile +++ b/Dockerfile @@ -59,6 +59,10 @@ RUN pip install hatchling # needed to install nemo-run ARG NEMU_RUN_TAG=34259bd3e752fef94045a9a019e4aaf62bd11ce2 RUN pip install nemo_run@git+https://github.com/NVIDIA/NeMo-Run.git@${NEMU_RUN_TAG} +# Used for straggler detection in large runs. +ARG RESIL_COMMIT="97aad77609d2e25ed38ac5c99f0c13f93c48464e" +RUN pip install --no-cache-dir "git+https://github.com/NVIDIA/nvidia-resiliency-ext.git@${RESIL_COMMIT}" + RUN mkdir -p /workspace/bionemo2/ # Delete the temporary /build directory. @@ -183,7 +187,6 @@ RUN < train_split: + if roll < 1 - test_split: + split = "val" + else: + split = "test" + return split @staticmethod def _get_evo_seq_id(filename: str): + """TODO(@cye) Consider deprecating the Taxonomy resources from Arc in favor of an explicit SeqID -> Taxonomy mapping via config.""" try: return ".".join(filename.split("/")[-1].split(".")[:-1]) except Exception: @@ -97,6 +116,7 @@ def _get_evo_seq_id(filename: str): @staticmethod def _get_evo_phyla_from_lineage_string(lineage_str: str): + """TODO(@cye) Consider deprecating the Taxonomy resources from Arc in favor of an explicit SeqID -> Taxonomy mapping via config.""" try: return lineage_str.split(";")[1].split("_")[-1] except Exception: @@ -104,6 +124,7 @@ def _get_evo_phyla_from_lineage_string(lineage_str: str): @staticmethod def _load_evo_taxonomy(fname): + """TODO(@cye) Consider deprecating the Taxonomy resources from Arc in favor of an explicit SeqID -> Taxonomy mapping via config.""" df = pd.read_csv(fname, sep="\t") id_to_taxonomy = {} for _, row in df.iterrows(): @@ -242,13 +263,7 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): # Release semaphore for the task associated with the result. semaphore.release() # Randomly assign all sequences from this document to train, val, or test. - roll = random.random() - split = "train" - if roll > evo2_preproc_config.train_split: - if roll < 1 - evo2_preproc_config.test_split: - split = "val" - else: - split = "test" + split = Evo2Preprocessor._train_val_test_split(preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split) for sequence in result: sequence["split"] = split yield sequence @@ -283,6 +298,8 @@ def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): val_builder.add_item(torch.Tensor(sequence["tokens"])) elif sequence["split"] == "test": test_builder.add_item(torch.Tensor(sequence["tokens"])) + # IMPORTANT TODO(@cye): Split documents by filename instead of all datasets + # into one document, to check that BlendedDataset weighting make sense. train_builder.end_document() val_builder.end_document() test_builder.end_document() diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py index 6c4e2afa47..d6dc73e597 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py @@ -18,7 +18,7 @@ from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer -from bionemo.evo2.data.config import Evo2PreprocessingConfig +from bionemo.evo2.utils.config import Evo2PreprocessingConfig class Evo2Tokenizer: diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 09db859325..3aeaad59db 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -14,9 +14,15 @@ # limitations under the License. import argparse +from collections import defaultdict +from dataclasses import dataclass +import nvidia_resiliency_ext.ptl_resiliency as res_module import torch -import torch._dynamo +import yaml +from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary +from lightning.pytorch.loggers import TensorBoardLogger, WandbLogger +from megatron.core.distributed import DistributedDataParallelConfig from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm @@ -24,11 +30,16 @@ from nemo.collections.llm.gpt.data.megatron.hyena import Evo2Dataset from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger +from nemo.lightning.pytorch import callbacks as nl_callbacks from nemo.lightning.pytorch.callbacks import ModelCheckpoint +from nemo.lightning.pytorch.callbacks.megatron_comm_overlap import MegatronCommOverlapCallback from nemo.lightning.pytorch.optim import CosineAnnealingScheduler from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule from nemo.lightning.pytorch.strategies.utils import RestoreConfig -from pytorch_lightning.loggers import TensorBoardLogger, WandbLogger +from nemo.utils.exp_manager import TimingCallback + +from bionemo.evo2.utils.config import Evo2BlendedDatasetConfig +from bionemo.llm.utils.datamodule_utils import infer_global_batch_size torch._dynamo.config.suppress_errors = True @@ -37,10 +48,16 @@ def parse_args(): """Parse arguments for Evo2 model training.""" parser = argparse.ArgumentParser(description="Train a Hyena model using NeMo 2.0.") + parser.add_argument( + "-d", + "--dataset-config", + type=str, + required=True, + help="Path to the blended / weighted training dataset configuration YAML.", + ) parser.add_argument("--num-nodes", type=int, default=1, help="Number of nodes to use for training, defaults to 1.") parser.add_argument("--devices", type=int, default=1, help="Number of devices to use for training, defaults to 1.") parser.add_argument("--seq-length", type=int, default=8192, help="Training sequence length") - parser.add_argument("--data-path", type=str, nargs="+", default=[], help="Paths to data directories for training.") parser.add_argument( "--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1." ) @@ -50,14 +67,31 @@ def parse_args(): parser.add_argument( "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." ) + parser.add_argument("--wandb-project", type=str, default="bionemo_hyena", help="Wandb project name") + parser.add_argument("--wandb-run-id", type=str, default=None, help="Wandb run identifier") parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallelism.") parser.add_argument("--fp8", action="store_true", help="Set to enable FP8") parser.add_argument("--micro-batch-size", type=int, default=1, help="Micro-batch size for data-parallel training.") - parser.add_argument("--global-batch-size", type=int, default=8, help="Global batch size for training.") + parser.add_argument( + "--global-batch-size", + type=int, + default=None, + help="Global batch size for training. If set to None, infer it from the TP, CP, and PP parameters.", + ) + parser.add_argument( + "--grad-acc-batches", type=int, default=1, help="Number of batches to accumulate gradients over." + ) parser.add_argument("--max-steps", type=int, help="Number of training optimizer update steps.") parser.add_argument( "--val-check-interval", type=int, help="Number of steps between validation measurements and model checkpoints." ) + parser.add_argument("--grad-reduce-in-fp32", action="store_true", default=False, help="Gradient reduce in FP32.") + parser.add_argument( + "--no-aligned-megatron-ddp", action="store_true", default=False, help="Do not do aligned gradient updates etc." + ) + parser.add_argument("--use-megatron-comm-overlap-llama3-8k", action="store_true", default=False) + parser.add_argument("--align-param-gather", action="store_true", default=False) + parser.add_argument("--straggler-detection", action="store_true", default=False) parser.add_argument( "--model-size", type=str, @@ -68,47 +102,178 @@ def parse_args(): parser.add_argument( "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." ) - parser.add_argument("--ckpt-dir", type=str, default=None, help="Directory to read checkpoints from.") parser.add_argument( - "--tokenizer-path", type=str, default=None, help="Path to tokenizer model if relevant to tokenizer." + "--ckpt-dir", + type=str, + default=None, + help="Directory to restore an initial checkpoint from. Use this for supervised fine-tuning.", + ) + parser.add_argument("--defer-embedding-wgrad-compute", action="store_true", default=False) + parser.add_argument( + "--restore-optimizer-from-ckpt", + action="store_true", + help="Restore optimizer state from initial checkpoint. Defaults to False.", ) parser.add_argument("--seed", type=int, default=1234, help="Set random seed for training.") parser.add_argument("--workers", type=int, default=0, help="Number of workers to use for data loading.") - + parser.add_argument( + "--gc-interval", + type=int, + default=0, + help="Set to a value > 0 if you want to synchronize garbage collection, will do gc every gc-interval steps.", + ) + parser.add_argument( + "--enable-preemption", + action="store_true", + default=False, + help="Enable preemption hooks. If enabled this will save a checkpoint whenver slurm exits.", + ) + parser.add_argument( + "--ckpt-async-save", + action="store_true", + default=False, + ) + parser.add_argument( + "--wgrad-deferral-limit", + type=int, + default=22, + help="Unused unless you also do --defer-embedding-wgrad-compute.", + ) return parser.parse_args() +@dataclass +class TPOverlapCfg: + pass + + +@dataclass +class PipelineOverlapCfg(TPOverlapCfg): + num_sm: int + cga_size: int + num_splits: int + set_sm_margin: bool + fp8_buf: bool = (False,) + method: str = "pipeline" + + +@dataclass +class RingExchangeOverlapCfg(TPOverlapCfg): + aggregate: bool = False + method: str = "ring_exchange" + num_sm: int = 1 + set_sm_margin: bool = False + + +@dataclass +class BulkOverlapCfg(TPOverlapCfg): + num_sm: int + cga_size: int + set_sm_margin: bool + method: str = "bulk" + + +@dataclass +class TransformerLayerTPOverlapCfg: + qkv_dgrad: TPOverlapCfg + qkv_wgrad: TPOverlapCfg + fc1_dgrad: TPOverlapCfg + fc1_wgrad: TPOverlapCfg + qkv_fprop: TPOverlapCfg + proj_dgrad: TPOverlapCfg + fc1_fprop: TPOverlapCfg + fc2_dgrad: TPOverlapCfg + proj_fprop: TPOverlapCfg + fc2_fprop: TPOverlapCfg + + +# TODO: Add more configs and create a getter function for expose a single api +# Model configs: H100/70B/TP8/MBS1/SeqLen8K +userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192 = TransformerLayerTPOverlapCfg( + qkv_dgrad=BulkOverlapCfg(num_sm=4, cga_size=2, set_sm_margin=False), + qkv_wgrad=BulkOverlapCfg(num_sm=24, cga_size=2, set_sm_margin=False), + fc1_dgrad=BulkOverlapCfg(num_sm=2, cga_size=2, set_sm_margin=False), + fc1_wgrad=BulkOverlapCfg(num_sm=4, cga_size=2, set_sm_margin=False), + qkv_fprop=RingExchangeOverlapCfg(aggregate=False), + proj_dgrad=RingExchangeOverlapCfg(aggregate=False), + fc1_fprop=RingExchangeOverlapCfg(aggregate=False), + fc2_dgrad=RingExchangeOverlapCfg(aggregate=False), + proj_fprop=PipelineOverlapCfg(num_sm=24, cga_size=2, num_splits=4, set_sm_margin=True), + fc2_fprop=PipelineOverlapCfg(num_sm=16, cga_size=2, num_splits=4, set_sm_margin=True), +) + + +def parse_dataset_config(dataset_config_path: str): + """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena.""" + blended_dataset_config = defaultdict(list) + weight_sums = defaultdict(float) + with open(dataset_config_path, "r") as config_file: + dataset_config_batch = yaml.safe_load(config_file) + for dataset_config in dataset_config_batch: + # Validate. + config_model = Evo2BlendedDatasetConfig(**dataset_config) + # Integrate the weights for renormalization. + weight_sums[config_model.dataset_split] += abs(config_model.dataset_weight) + for dataset_config in dataset_config_batch: + # Validate. + config_model = Evo2BlendedDatasetConfig(**dataset_config) + # Add indexed dataset to split and associate with blended training weight. + blended_dataset_config[config_model.dataset_split].extend( + [config_model.dataset_weight / weight_sums[config_model.dataset_split], config_model.dataset_prefix] + ) + return blended_dataset_config + + def main(): """Main function to run Evo2 training.""" args = parse_args() + # Parse dataset configuration. + blended_dataset_config = parse_dataset_config(args.dataset_config) + + # Instantiate tokenizer. tokenizer = get_nmt_tokenizer( "byte-level", ) + # Infer global batch size. + global_batch_size = args.global_batch_size + if global_batch_size is None: + global_batch_size = infer_global_batch_size( + micro_batch_size=args.micro_batch_size, + num_nodes=args.num_nodes, + devices=args.devices, + accumulate_grad_batches=args.grad_acc_batches, + tensor_model_parallel_size=args.tensor_parallel_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + context_model_parallel_size=args.context_parallel_size, + ) + + # Instantiate pre-training module. data = PreTrainingDataModule( - paths=args.data_path, + paths=blended_dataset_config, dataset_cls=Evo2Dataset, seq_length=args.seq_length, micro_batch_size=args.micro_batch_size, - global_batch_size=args.global_batch_size, + global_batch_size=global_batch_size, seed=args.seed, num_workers=args.workers, tokenizer=tokenizer, ) if args.model_size == "7b": - hyena_config = llm.Hyena7bConfig() + hyena_config = llm.Hyena7bConfig(wgrad_deferral_limit=args.wgrad_deferral_limit, defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute) elif args.model_size == "40b": - hyena_config = llm.Hyena40bConfig() + hyena_config = llm.Hyena40bConfig(wgrad_deferral_limit=args.wgrad_deferral_limit, defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute) elif args.model_size == "test": - hyena_config = llm.HyenaTestConfig() + hyena_config = llm.HyenaTestConfig(wgrad_deferral_limit=args.wgrad_deferral_limit, defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute) else: raise ValueError(f"Invalid model size: {args.model_size}") hyena_config.seq_length = args.seq_length model = llm.GPTModel(hyena_config, tokenizer=data.tokenizer) + # Setup callbacks. checkpoint_callback = ModelCheckpoint( every_n_train_steps=args.val_check_interval, dirpath=args.experiment_dir, @@ -117,15 +282,58 @@ def main(): save_optim_on_train_end=True, save_context_on_train_end=True, ) + callbacks = [ + checkpoint_callback, + RichModelSummary(max_depth=4), + LearningRateMonitor(), + TimingCallback(), + ] + if args.enable_preemption: + callbacks.append(nl_callbacks.PreemptionCallback()) + + if args.straggler_detection: + callbacks.append( + res_module.StragglerDetectionCallback( + report_time_interval=300, + calc_relative_gpu_perf=True, + calc_individual_gpu_perf=True, + num_gpu_perf_scores_to_print=5, + gpu_relative_perf_threshold=0.7, + gpu_individual_perf_threshold=0.7, + stop_if_detected=True, + enable_ptl_logging=True, + ) + ) + if args.use_megatron_comm_overlap_llama3_8k: + callbacks.append( + MegatronCommOverlapCallback( + tp_comm_overlap=True, + tp_comm_overlap_cfg=userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, + defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute, + wgrad_deferral_limit=args.wgrad_deferral_limit, + overlap_param_gather_with_optimizer_step=False, # Currently disabled due to an issue with checkpointing. + align_param_gather=args.align_param_gather, + ) + ) + + if args.gc_interval > 0: + callbacks.append( + nl_callbacks.GarbageCollectionCallback( + gc_interval_train=args.gc_interval, gc_interval_val=args.gc_interval + ) + ) loggers = [] wandb_logger = WandbLogger( name=( f"hyena-size-{args.model_size}-TP{args.tensor_parallel_size}-" f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" - f"-GBS{args.global_batch_size}-MBS{args.micro_batch_size}" + f"-GBS{global_batch_size}-MBS{args.micro_batch_size}" + f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" + f"-NODES{args.num_nodes}" ), - project="hyena_ux_test", + id=args.wandb_run_id, # set this to use the same curve name for restarts. + project="bionemo_hyena", save_dir=args.experiment_dir, ) loggers.append(wandb_logger) @@ -135,28 +343,47 @@ def main(): loggers.append(tb_logger) nemo_logger = NeMoLogger(log_dir=args.experiment_dir, wandb=wandb_logger) - + if args.no_aligned_megatron_ddp: + ddp: str | DistributedDataParallelConfig = DistributedDataParallelConfig( + check_for_nan_in_grad=True, + grad_reduce_in_fp32=args.grad_reduce_in_fp32, + align_param_gather=args.align_param_gather, + ) + else: + ddp = DistributedDataParallelConfig( + check_for_nan_in_grad=True, + grad_reduce_in_fp32=args.grad_reduce_in_fp32, + overlap_grad_reduce=True, + overlap_param_gather=True, + average_in_collective=True, + align_param_gather=args.align_param_gather, + use_distributed_optimizer=True, # this should inherit from the optimizer config, but just in case... + ) + # Initialize Megatron Strategy and Trainer. + strategy = nl.MegatronStrategy( + ddp=ddp, + tensor_model_parallel_size=args.tensor_parallel_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + context_parallel_size=args.context_parallel_size, + pipeline_dtype=torch.bfloat16, + sequence_parallel=args.sequence_parallel, + ckpt_load_optimizer=True, + ckpt_save_optimizer=True, + ckpt_async_save=args.ckpt_async_save, + save_ckpt_format="torch_dist", + ) trainer = nl.Trainer( devices=args.devices, num_nodes=args.num_nodes, max_steps=args.max_steps, accelerator="gpu", - strategy=nl.MegatronStrategy( - tensor_model_parallel_size=args.tensor_parallel_size, - pipeline_model_parallel_size=args.pipeline_model_parallel_size, - context_parallel_size=args.context_parallel_size, - pipeline_dtype=torch.bfloat16, - sequence_parallel=args.sequence_parallel, - ckpt_load_optimizer=False, # Checkpoint model state only. - ckpt_save_optimizer=False, - ckpt_async_save=False, - save_ckpt_format="torch_dist", - ), + strategy=strategy, logger=loggers, - callbacks=[checkpoint_callback], + callbacks=callbacks, log_every_n_steps=1, limit_val_batches=10, num_sanity_val_steps=0, + use_distributed_sampler=False, plugins=nl.MegatronMixedPrecision( precision="bf16-mixed", params_dtype=torch.bfloat16, @@ -176,13 +403,13 @@ def main(): resume = nl.AutoResume( resume_if_exists=True, resume_ignore_no_checkpoint=True, - resume_past_end=True, - resume_from_directory=args.ckpt_dir, + resume_past_end=False, + resume_from_directory=args.experiment_dir, restore_config=( RestoreConfig( path=args.ckpt_dir, load_model_state=True, - load_optim_state=False, # Load model checkpoint, no optimizer state. + load_optim_state=args.restore_optimizer_from_ckpt, ) if args.ckpt_dir else None @@ -202,7 +429,7 @@ def main(): sched = CosineAnnealingScheduler( max_steps=trainer.max_steps, warmup_steps=2500, - min_lr=0.00003, + min_lr=0.000003, ) opt = MegatronOptimizerModule(opt_config, sched) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py similarity index 87% rename from sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py rename to sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index 172dc0ad0f..b0c3eb95be 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -20,6 +20,13 @@ from pydantic import BaseModel +class Evo2BlendedDatasetConfig(BaseModel): + """Pydantic model class that specifies indexed datasets, dataset weights, and datasplits assignments for training.""" + dataset_prefix: None | str = None + dataset_weight: None | float = None + dataset_split: Literal["train", "validation", "test"] + + class Evo2PreprocessingConfig(BaseModel): """Class specifying the configuration schema for Evo2 data preprocessing.""" @@ -27,7 +34,7 @@ class Evo2PreprocessingConfig(BaseModel): datapaths: list[Path] = [] output_dir: None | Path = None output_prefix: None | str = None - # Datasplit + # Random Datasplit train_split: float = 0.7 valid_split: float = 0.2 test_split: float = 0.1 diff --git a/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml new file mode 100644 index 0000000000..47588ef1d2 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml @@ -0,0 +1,81 @@ +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.18 +- dataset_prefix: /workspace/bionemo2/data/gtdb_imgpr/pretraining_data_gtdb_imgpr/data_gtdb_imgpr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.24 +- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.03 +- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.02 +- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.09 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.09 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.35 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.0003 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.18 +- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.24 +- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.03 +- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.02 +- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.09 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.09 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.35 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.0003 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.18 +- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.24 +- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.03 +- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.02 +- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.09 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.09 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.35 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.0003 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py index 57aab0759e..d953df92c7 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py @@ -61,6 +61,7 @@ def infer_global_batch_size( accumulate_grad_batches: int = 1, tensor_model_parallel_size: int = 1, pipeline_model_parallel_size: int = 1, + context_model_parallel_size: int = 1, ) -> int: """Infers the global batch size based on the micro batch size, number of nodes, devices, accumulation of gradient batches, and model parallel sizes. @@ -84,11 +85,12 @@ def infer_global_batch_size( accumulate_grad_batches, tensor_model_parallel_size, pipeline_model_parallel_size, + context_model_parallel_size, ] ): raise ValueError( f"All arguments must be of type int, got {type(micro_batch_size)}, {type(num_nodes)}, {type(devices)}, " - f"{type(accumulate_grad_batches)}, {type(tensor_model_parallel_size)}, and {type(pipeline_model_parallel_size)}" + f"{type(accumulate_grad_batches)}, {type(tensor_model_parallel_size)}, {type(pipeline_model_parallel_size)}, and {type(context_model_parallel_size)}" ) if micro_batch_size <= 0: raise ValueError(f"micro_batch_size must be greater than 0, got {micro_batch_size}") @@ -102,15 +104,17 @@ def infer_global_batch_size( raise ValueError(f"tensor_model_parallel_size must be greater than 0, got {tensor_model_parallel_size}") if pipeline_model_parallel_size <= 0: raise ValueError(f"pipeline_model_parallel_size must be greater than 0, got {pipeline_model_parallel_size}") + if context_model_parallel_size <= 0: + raise ValueError(f"context_model_parallel_size must be greater than 0, got {context_model_parallel_size}") world_size = num_nodes * devices - if world_size % (tensor_model_parallel_size * pipeline_model_parallel_size) != 0: + if world_size % (tensor_model_parallel_size * pipeline_model_parallel_size * context_model_parallel_size) != 0: raise ValueError( - f"world_size must be divisible by tensor_model_parallel_size * pipeline_model_parallel_size, " - f"got {world_size} and {tensor_model_parallel_size} * {pipeline_model_parallel_size}" + f"world_size must be divisible by tensor_model_parallel_size * pipeline_model_parallel_size * context_model_parallel_size, " + f"got {world_size} and TP{tensor_model_parallel_size} * PP{pipeline_model_parallel_size} * CP{context_model_parallel_size}" ) - model_parallel_size = tensor_model_parallel_size * pipeline_model_parallel_size + model_parallel_size = tensor_model_parallel_size * pipeline_model_parallel_size * context_model_parallel_size data_parallel_size = world_size // model_parallel_size global_batch_size = micro_batch_size * data_parallel_size * accumulate_grad_batches return global_batch_size From dd0aab18f8018c536f652b2f81355cf2f059f57c Mon Sep 17 00:00:00 2001 From: John St John Date: Mon, 23 Dec 2024 08:08:55 -0800 Subject: [PATCH 011/140] Changes for 256 node training run --- requirements-cve.txt | 2 ++ sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/requirements-cve.txt b/requirements-cve.txt index e8228799f7..2794921a1a 100644 --- a/requirements-cve.txt +++ b/requirements-cve.txt @@ -8,3 +8,5 @@ nltk>=3.9.1 pillow>=10.3.0 tornado>=6.4.2 wandb>=0.19.1 # Addresses CVE GHSA-v778-237x-gjrc +lightning<=2.4 +pytorch_lightning<=2.4 \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 3aeaad59db..ebf6c1f1e7 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -330,7 +330,7 @@ def main(): f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" f"-GBS{global_batch_size}-MBS{args.micro_batch_size}" f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" - f"-NODES{args.num_nodes}" + f"-NODES{args.num_nodes}-FP8{args.fp8}" ), id=args.wandb_run_id, # set this to use the same curve name for restarts. project="bionemo_hyena", From 0560ee45747033cebe87dd1f0a49d41e50e93f28 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Mon, 23 Dec 2024 18:11:28 -0800 Subject: [PATCH 012/140] Integrate BioNeMo Noodles into Hyena data preprocessing. --- CODEOWNERS | 2 +- Dockerfile | 4 +- Dockerfile.arm | 1 + ci/scripts/run_pytest.sh | 10 +- .../user-guide/appendix/releasenotes-fw.md | 2 + .../examples/bionemo-esm2/finetune.md | 10 +- .../examples/bionemo-esm2/inference.ipynb | 65 +- .../examples/bionemo-esm2/mutant-design.ipynb | 90 +-- .../geneformer-celltype-classification.ipynb | 602 +++++++++--------- docs/mkdocs.yml | 2 +- requirements-cve.txt | 2 +- .../bionemo/esm2/model/finetune/datamodule.py | 6 +- .../src/bionemo/esm2/scripts/infer_esm2.py | 34 +- .../bionemo/esm2/scripts/test_infer_esm2.py | 80 ++- sub-packages/bionemo-evo2/pyproject.toml | 4 +- .../src/bionemo/evo2/data/preprocess.py | 51 +- .../src/bionemo/evo2/utils/config.py | 1 - .../tests/config/test_preproc_config.yaml | 8 +- .../geneformer/scripts/infer_geneformer.py | 49 +- .../tests/bionemo/geneformer/test_model.py | 4 + .../src/bionemo/llm/data/collate.py | 4 + .../bionemo-llm/src/bionemo/llm/lightning.py | 5 +- .../src/bionemo/llm/utils/callbacks.py | 100 +++ .../tests/bionemo/llm/utils/test_callbacks.py | 110 ++++ sub-packages/bionemo-noodles/rust/src/lib.rs | 134 +++- .../src/bionemo/noodles/__init__.py | 18 +- .../src/bionemo/noodles/nvfaidx.py | 77 ++- .../tests/bionemo/noodles/test_nvfaidx.py | 89 ++- .../bionemo/noodles/test_sequence_ops.py | 159 +++++ .../bionemo/scdl/index/row_feature_index.py | 28 +- .../scdl/index/test_row_feature_index.py | 70 +- 31 files changed, 1304 insertions(+), 517 deletions(-) create mode 100644 sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py create mode 100644 sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_callbacks.py create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/test_sequence_ops.py diff --git a/CODEOWNERS b/CODEOWNERS index 677a0e8700..044d1864ad 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -93,4 +93,4 @@ sub-packages/bionemo-geneformer @jstjohn @malcolmgreaves @skothenhill-nv sub-packages/bionemo-scdl @jstjohn @malcolmgreaves @polinabinder1 @skothenhill-nv -sub-packages/bionemo-noodles @skothenhill-nv @malcolmgreaves @jstjohn @edawson +sub-packages/bionemo-noodles @skothenhill-nv @malcolmgreaves @jstjohn @edawson @cspades diff --git a/Dockerfile b/Dockerfile index d311fca969..a2900c74cc 100644 --- a/Dockerfile +++ b/Dockerfile @@ -84,7 +84,8 @@ COPY --from=ghcr.io/astral-sh/uv:0.4.25 /uv /usr/local/bin/uv ENV UV_LINK_MODE=copy \ UV_COMPILE_BYTECODE=1 \ UV_PYTHON_DOWNLOADS=never \ - UV_SYSTEM_PYTHON=true + UV_SYSTEM_PYTHON=true \ + UV_NO_CACHE=1 # Install the bionemo-geomtric requirements ahead of copying over the rest of the repo, so that we can cache their # installation. These involve building some torch extensions, so they can take a while to install. @@ -187,6 +188,7 @@ RUN < \ --data-path $DATA_PATH \ @@ -239,13 +239,13 @@ infer_esm2 --checkpoint-path \ --config-class ESM2FineTuneSeqConfig ``` -This will create a result `.pt` file under `$WORKDIR/esm2_finetune_tutorial/inference_results.pt` which can be loaded via PyTorch library in python environment: +This will create a result `.pt` file under `$WORKDIR/esm2_finetune_tutorial/predictions__rank_0.pt` which can be loaded via PyTorch library in python environment: ```python import torch -# Set the path to results file e.g. /workspace/bionemo2/esm2_finetune_tutorial/inference_results.pt -# results_path = /workspace/bionemo2/esm2_finetune_tutorial/inference_results.pt +# Set the path to results file e.g. /workspace/bionemo2/esm2_finetune_tutorial/predictions__rank_0.pt +# results_path = /workspace/bionemo2/esm2_finetune_tutorial/predictions__rank_0.pt results = torch.load(results_path) # results is a python dict which includes the following result tensors for this example: diff --git a/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb b/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb index 095d7ae641..5dfd17964f 100644 --- a/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb +++ b/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb @@ -152,7 +152,7 @@ "source": [ "from bionemo.core.data.load import load\n", "\n", - "checkpoint_path = load(\"esm2/650m:2.0\", source=\"ngc\")\n", + "checkpoint_path = load(\"esm2/650m:2.0\")\n", "print(checkpoint_path)" ] }, @@ -238,11 +238,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "2024-11-25 21:18:43 - faiss.loader - INFO - Loading faiss with AVX512 support.\n", - "2024-11-25 21:18:43 - faiss.loader - INFO - Successfully loaded faiss with AVX512 support.\n", - "[NeMo W 2024-11-25 21:18:43 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "2024-12-16 20:19:23 - faiss.loader - INFO - Loading faiss with AVX512 support.\n", + "2024-12-16 20:19:23 - faiss.loader - INFO - Successfully loaded faiss with AVX512 support.\n", + "[NeMo W 2024-12-16 20:19:24 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", + "[NeMo W 2024-12-16 20:19:24 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cm = get_cmap(\"Set1\")\n", + " \n", "usage: infer_esm2 [-h] --checkpoint-path CHECKPOINT_PATH --data-path DATA_PATH\n", " --results-path RESULTS_PATH\n", " [--precision {fp16,bf16,fp32,bf16-mixed,fp32-mixed,16-mixed,fp16-mixed,16,32}]\n", @@ -250,9 +253,9 @@ " [--micro-batch-size MICRO_BATCH_SIZE]\n", " [--pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE]\n", " [--tensor-model-parallel-size TENSOR_MODEL_PARALLEL_SIZE]\n", - " [--include-hiddens] [--include-input-ids]\n", - " [--include-embeddings] [--include-logits]\n", - " [--config-class CONFIG_CLASS]\n", + " [--prediction-interval {epoch,batch}] [--include-hiddens]\n", + " [--include-input-ids] [--include-embeddings]\n", + " [--include-logits] [--config-class CONFIG_CLASS]\n", "\n", "Infer ESM2.\n", "\n", @@ -264,7 +267,7 @@ " Path to the CSV file containing sequences and label\n", " columns\n", " --results-path RESULTS_PATH\n", - " Path to the results file.\n", + " Path to the results directory.\n", " --precision {fp16,bf16,fp32,bf16-mixed,fp32-mixed,16-mixed,fp16-mixed,16,32}\n", " Precision type to use for training.\n", " --num-gpus NUM_GPUS Number of GPUs to use for training. Default is 1.\n", @@ -277,6 +280,8 @@ " Pipeline model parallel size. Default is 1.\n", " --tensor-model-parallel-size TENSOR_MODEL_PARALLEL_SIZE\n", " Tensor model parallel size. Default is 1.\n", + " --prediction-interval {epoch,batch}\n", + " Intervals to write DDP predictions into disk\n", " --include-hiddens Include hiddens in output of inference\n", " --include-input-ids Include input_ids in output of inference\n", " --include-embeddings Include embeddings in output of inference\n", @@ -327,12 +332,12 @@ "source": [ "%%capture --no-display --no-stderr cell_output\n", "\n", - "results_path = os.path.join(work_dir, \"inference_results.pt\")\n", - "\n", "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", " --data-path {data_path} \\\n", - " --results-path {results_path} \\\n", - " --precision \"fp32\" \\\n", + " --results-path {work_dir} \\\n", + " --micro-batch-size 3 \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\" \\\n", " --include-hiddens \\\n", " --include-embeddings \\\n", " --include-logits \\\n", @@ -350,7 +355,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The bash command in previous step creates the `inference_results.pt` file under the work directory of this notebook (defined above) to stores the results. The `.pt` file containes a dictionary of `{'result_key': torch.Tensor}` that be loaded with PyTorch:" + "Inference predictions are stored into `.pt` files for each device. Since we only used one device to run the inference (`--num-gpus 1`) in the previous step, the results were written to `{work_dir}/predictions__rank_0.pt` under the work directory of this notebook (defined above). The `.pt` file containes a dictionary of `{'result_key': torch.Tensor}` that be loaded with PyTorch:" ] }, { @@ -371,7 +376,7 @@ ], "source": [ "import torch\n", - "results = torch.load(results_path)\n", + "results = torch.load(f\"{work_dir}/predictions__rank_0.pt\")\n", "\n", "for key, val in results.items():\n", " if val is not None:\n", @@ -472,6 +477,38 @@ "mask = torch.isin(input_ids, torch.tensor(extra_indices))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DDP Inference Support\n", + "\n", + "Although this tutorial is utilizing one devive to run the inference, distributed inference is supported for ESM2 in BioNeMo Framework. One can simply set the the `--num-gpus n` to run distributed inference on `n` devices. The output predictions will be written into `predictions__rank_<0...n-1>.pt` under the `--results-path` provided. Moreover, by optionally including input token IDs with `--include-input-ids` we can snure 1:1 mapping between input sequences and output predictions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following snippet can be used to load and collate the predictions into a single dictionary.\n", + "\n", + "\n", + "```python\n", + "import glob\n", + "from bionemo.llm.lightning import batch_collator\n", + "\n", + "collated_preditions = batch_collator([torch.load(path) for path in glob.glob(f\"{work_dir}/predictions__rank_*.pt\")])\n", + "for key, val in collated_preditions.items():\n", + " if val is not None:\n", + " print(f'{key}\\t{val.shape}')\n", + "\n", + "# token_logits\ttorch.Size([1024, 10, 128])\n", + "# hidden_states\ttorch.Size([10, 1024, 1280])\n", + "# input_ids torch.Size([10, 1024])\n", + "# embeddings\ttorch.Size([10, 1280])\n", + "```" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb b/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb index c4a904c653..3542d69fcc 100644 --- a/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb +++ b/docs/docs/user-guide/examples/bionemo-esm2/mutant-design.ipynb @@ -83,7 +83,7 @@ "id": "dd6bed85-787b-4456-8426-55194da94852", "metadata": {}, "source": [ - "This notebbok should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. This tutorial assumes that a copy of the BioNeMo framework repo exists on workstation or server and has been mounted inside the container at `/workspace/bionemo2`. For more information on how to build or pull the BioNeMo2 container, refer to the [Initialization Guide](https://docs.nvidia.com/bionemo-framework/latest/user-guide/getting-started/initialization-guide/)." + "This notebbok should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. This tutorial assumes that a copy of the BioNeMo framework repo exists on workstation or server and has been mounted inside the container at `/workspace/bionemo2`. For more information on how to build or pull the BioNeMo2 container, refer to the [Initialization Guide](../../getting-started/initialization-guide.md)." ] }, { @@ -186,7 +186,15 @@ "metadata": {}, "source": [ "### Download Model Checkpoints\n", - "The following code will download the pre-trained model, `esm2/3b:2.0`, from the NGC registry:" + "The following code will download the pre-trained model from the NGC registry:" + ] + }, + { + "cell_type": "markdown", + "id": "6fe15e8c", + "metadata": {}, + "source": [ + "
NOTE The experiments in this notebook were run by using an ESM-2 3B model. Here we downsize to 650M model that allows execution on a larger set of NVIDIA GPUs (when the memory is insufficient for 3B). To reproduce the original experiment download the 3B checkpoint by adding this change to the next cell: 
checkpoint = \"esm2/3b:2.0\"
" ] }, { @@ -194,20 +202,12 @@ "execution_count": 4, "id": "aefc431a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/bionemo/.cache/bionemo/a2248cfed1ef39f83bd32a0e08b84c0a8f39325d383e2d92767022ff7f5260ed-esm2_3B_nemo2.tar.gz.untar\n" - ] - } - ], + "outputs": [], "source": [ "from bionemo.core.data.load import load\n", "\n", - "checkpoint_path = load(\"esm2/3b:2.0\", source=\"ngc\")\n", - "print(checkpoint_path)" + "checkpoint = \"esm2/650m:2.0\" # change to \"esm2/3b:2.0\" to use the ESM-2 3B model\n", + "checkpoint_path = load(checkpoint, source=\"ngc\")" ] }, { @@ -378,12 +378,14 @@ "source": [ "%%capture --no-display --no-stderr cell_output\n", "\n", - "results_path = os.path.join(work_dir, \"inference_results.pt\")\n", + "example_dir = os.path.join(work_dir, \"inference_example\")\n", + "os.makedirs(example_dir, exist_ok=True)\n", "\n", "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", " --data-path {data_path} \\\n", - " --results-path {results_path} \\\n", - " --precision \"fp32\" \\\n", + " --results-path {example_dir} \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\" \\\n", " --include-hiddens \\\n", " --include-embeddings \\\n", " --include-logits \\\n", @@ -395,8 +397,7 @@ "id": "67d09581-e784-4ccc-be88-194c8909068c", "metadata": {}, "source": [ - "\n", - "This will write the output of ESM-2 inference into a python dictionary and save that into `inference_results.pt` which can be loaded via PyTorch:" + "This will write the output of ESM-2 inference into a python dictionary and save that into `predictions__rank_0.pt` which can be loaded via PyTorch. DDP inference is supported in BioNeMo Framework and can be utilized by setting `--num-gpus n` to use `n` devices. The output predictions are then written to n distinct files `predictions__rank_<0...n-1>.pt`. Please refer to [ESM-2 Inference Tutorial](./inference.ipynb) for more information regarding the DDP support and how to interpret the prediction outputs." ] }, { @@ -410,14 +411,14 @@ "output_type": "stream", "text": [ "token_logits\ttorch.Size([1024, 2, 128])\n", - "hidden_states\ttorch.Size([2, 1024, 2560])\n", + "hidden_states\ttorch.Size([2, 1024, 1280])\n", "input_ids\ttorch.Size([2, 1024])\n", - "embeddings\ttorch.Size([2, 2560])\n" + "embeddings\ttorch.Size([2, 1280])\n" ] } ], "source": [ - "results = torch.load(results_path)\n", + "results = torch.load(f\"{example_dir}/predictions__rank_0.pt\")\n", "\n", "for key, val in results.items():\n", " if val is not None:\n", @@ -736,12 +737,11 @@ "source": [ "%%capture --no-display --no-stderr cell_output\n", "\n", - "sequentially_masked_results_path = os.path.join(work_dir, \"sequentially_masked_inference_results.pt\")\n", - "\n", "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", " --data-path {masked_data_path} \\\n", - " --results-path {sequentially_masked_results_path} \\\n", - " --precision \"fp32\" \\\n", + " --results-path {work_dir} \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\" \\\n", " --include-logits \\\n", " --include-input-ids" ] @@ -761,8 +761,10 @@ } ], "source": [ - "results = torch.load(sequentially_masked_results_path)\n", - "logits = results['token_logits'].transpose(0, 1) # s, b, h -> b, s, h\n", + "results = torch.load(f\"{work_dir}/predictions__rank_0.pt\")\n", + "\n", + "# cast to FP32 since BFloat16 is an unsupported ScalarType in numpy\n", + "logits = results['token_logits'].transpose(0, 1).to(dtype=torch.float32) # s, b, h -> b, s, h\n", "\n", "probs = logits_to_probs(logits)\n", "print(probs.shape)" @@ -851,7 +853,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -940,7 +942,7 @@ { "data": { "text/plain": [ - "'MSEENKIIVVIVAAGKGSRMGSDRPKQYLKIGGKTILEHTI (Predicted Sequence)'" + "'MSEKKKVVALILAAGKGSRLGAGRPKQFLKIGGKTILERTL (Predicted Sequence)'" ] }, "metadata": {}, @@ -949,7 +951,7 @@ { "data": { "text/plain": [ - "'..|||.|.||.|...|.|.|.|.|....||..|..|...||'" + "'..|.|.||...|...|.|.|..||...|||..|..|..||.'" ] }, "metadata": {}, @@ -1065,31 +1067,31 @@ " 0\n", " G\n", " 6\n", - " 0.776999\n", + " 0.827384\n", " \n", " \n", " 1\n", " D\n", " 13\n", - " 0.053530\n", + " 0.055431\n", " \n", " \n", " 2\n", - " N\n", - " 17\n", - " 0.052637\n", + " E\n", + " 9\n", + " 0.032586\n", " \n", " \n", " 3\n", - " E\n", - " 9\n", - " 0.032759\n", + " N\n", + " 17\n", + " 0.030137\n", " \n", " \n", " 4\n", " S\n", " 8\n", - " 0.023782\n", + " 0.018279\n", " \n", " \n", "\n", @@ -1097,11 +1099,11 @@ ], "text/plain": [ " Token Token ID Probability\n", - "0 G 6 0.776999\n", - "1 D 13 0.053530\n", - "2 N 17 0.052637\n", - "3 E 9 0.032759\n", - "4 S 8 0.023782" + "0 G 6 0.827384\n", + "1 D 13 0.055431\n", + "2 E 9 0.032586\n", + "3 N 17 0.030137\n", + "4 S 8 0.018279" ] }, "execution_count": 25, diff --git a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb index 3a0f566e11..35e1f88830 100644 --- a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb +++ b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb @@ -6,16 +6,7 @@ "source": [ "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2p32dFTsjecDZOrOOJCok3qZuYV)\n", "\n", - "NOTE: it takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "cleanup:bool=True" + "
NOTE It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits.
" ] }, { @@ -34,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -73,7 +64,7 @@ " 'vein endothelial cell']" ] }, - "execution_count": 2, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -92,20 +83,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(8192, 60664)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#NBVAL_CHECK_OUTPUT\n", "import random\n", @@ -125,25 +105,20 @@ " indices = list(range(len(adata)))\n", " random.shuffle(indices)\n", "\n", - "micro_batch_size:int = 32\n", - "num_steps:int = 256\n", - "selection = sorted(indices[:micro_batch_size*num_steps])\n", - "# NOTE: there's a current constraint that predict_step needs to be a function of micro-batch-size.\n", - "# this is something we are working on fixing. A quick hack is to set micro-batch-size=1, but this is\n", - "# slow. In this notebook we are going to use mbs=32 and subsample the anndata.\n", - "adata = adata[selection].copy() # so it's not a view\n", - "adata.shape" + "micro_batch_size:int = 32" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import shutil\n", "from bionemo.core import BIONEMO_CACHE_DIR\n", - "cleanup:bool=True\n", + "\n", + "cleanup : bool = True\n", + "\n", "notebook_workdir = BIONEMO_CACHE_DIR / \"notebook_tutorials\" / \"geneformer_celltype_classification\"\n", "if cleanup and notebook_workdir.exists():\n", " shutil.rmtree(notebook_workdir)\n", @@ -163,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -198,10 +173,10 @@ " warnings.warn(msg, FutureWarning)\n", "Found 1 files\n", "Starting to create memmap files...\n", - "Creating metadata...: 100%|███████████████████████| 1/1 [00:00<00:00, 4.55it/s]\n", + "Creating metadata...: 100%|███████████████████████| 1/1 [00:00<00:00, 2.05it/s]\n", "Done creating `metadata.json`\n", "Writing data into memmaps to /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/celltype-bench-dataset...\n", - "Merging AnnData into numpy memaps...: 100%|███████| 1/1 [00:00<00:00, 2.58it/s]\n", + "Merging AnnData into numpy memaps...: 100%|███████| 1/1 [00:01<00:00, 1.49s/it]\n", "Saving dataframe ...\n", "Done creating dataset ...\n" ] @@ -220,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -234,7 +209,7 @@ " 'metadata.json']" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -246,14 +221,20 @@ "files" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download Model Checkpoints" + ] + }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "# NOTE: calling the load(...) function directly does not currently work for downloads through NGC in an interactive\n", - "# notebook environment. Get aound this below by calling the CLI download endpoint which executes in a subshell.\n", + "from bionemo.core.data.load import load\n", "\n", "# 106m checkpoint\n", "geneformer_106m_out = !download_bionemo_data \"geneformer/106M_240530:2.0\"\n", @@ -269,14 +250,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "result_path_10m = notebook_workdir / \"results_10m.pt\"\n", - "result_path_10m_bnmo2 = notebook_workdir / \"results_10m_bnmo2.pt\"\n", - "results_path_10m_random = notebook_workdir / \"results_10m_randomweights.pt\"\n", - "result_path_106m = notebook_workdir / \"results_106m.pt\"" + "result_path_10m = notebook_workdir / \"results_10m\"\n", + "result_path_10m_bnmo2 = notebook_workdir / \"results_10m_bnmo2\"\n", + "results_path_10m_random = notebook_workdir / \"results_10m_randomweights\"\n", + "result_path_106m = notebook_workdir / \"results_106m\"" ] }, { @@ -289,48 +270,51 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-19 20:15:40 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-19 20:15:42 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-16 20:19:36 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-19 20:15:43 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:15:43 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:15:43 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:15:43 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:15:43 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-16 20:19:36 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cm = get_cmap(\"Set1\")\n", + " \n", + "[NeMo W 2024-12-16 20:19:37 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-12-16 20:19:38 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-16 20:19:38 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:19:38 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:19:38 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:19:39 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:19:39 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:19:39 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:19:39 infer_geneformer:82] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-19 20:15:43 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-19 20:15:43 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:15:43 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-12-16 20:19:39 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-12-16 20:19:39 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:19:39 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", @@ -338,68 +322,76 @@ "----------------------------------------------------------------------------------------------------\n", "\n", "WARNING: Logging before flag parsing goes to stderr.\n", - "W1119 20:15:43.544375 140002805535168 config.py:85] Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-11-19 20:15:44 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-11-19 20:15:44 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", + "W1216 20:19:39.949693 140641974060864 config.py:85] Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2024-12-16 20:19:41 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo W 2024-12-16 20:19:41 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", " warnings.warn(\n", " \n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-11-19 20:15:44 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-11-19 20:15:44 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", - "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m.pt\n" + "[NeMo W 2024-12-16 20:19:41 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-12-16 20:19:41 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" ] } ], "source": [ - "# NOTE: due to a an issue we are working on fixing, predict results have the last batch dropped\n", - "# so set micro-batch-size=1 to make sure we get all results.\n", - "!infer_geneformer --data-dir {data_dir} --checkpoint-path {geneformer_10m} --result-path {result_path_10m} --micro-batch-size {micro_batch_size} --seq-len 2048 --num-dataset-workers 10" + "!infer_geneformer \\\n", + " --data-dir {data_dir} \\\n", + " --checkpoint-path {geneformer_10m} \\\n", + " --results-path {result_path_10m} \\\n", + " --micro-batch-size {micro_batch_size} \\\n", + " --seq-len 2048 \\\n", + " --num-dataset-workers 10 \\\n", + " --num-gpus 1 \\\n", + " --include-input-ids" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-19 20:16:18 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-19 20:16:19 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-16 20:21:10 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-19 20:16:20 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:16:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:20 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-16 20:21:11 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cm = get_cmap(\"Set1\")\n", + " \n", + "[NeMo W 2024-12-16 20:21:11 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-12-16 20:21:12 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:21:12 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:21:12 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:21:13 infer_geneformer:82] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-19 20:16:20 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-19 20:16:20 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:20 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-12-16 20:21:13 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-12-16 20:21:13 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:21:13 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", @@ -407,130 +399,147 @@ "----------------------------------------------------------------------------------------------------\n", "\n", "WARNING: Logging before flag parsing goes to stderr.\n", - "W1119 20:16:21.268678 140005924843968 config.py:85] Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", - "[NeMo I 2024-11-19 20:16:22 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-11-19 20:16:22 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", + "W1216 20:21:13.782941 140199712900928 config.py:85] Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", + "[NeMo I 2024-12-16 20:21:14 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo W 2024-12-16 20:21:14 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", " warnings.warn(\n", " \n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-11-19 20:16:22 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-11-19 20:16:22 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", - "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_bnmo2.pt\n" + "[NeMo W 2024-12-16 20:21:15 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-12-16 20:21:15 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" ] } ], "source": [ - "!infer_geneformer --data-dir {data_dir} --checkpoint-path {geneformer_10m_bnmo2} --result-path {result_path_10m_bnmo2} --micro-batch-size {micro_batch_size} --seq-len 2048 --num-dataset-workers 10" + "!infer_geneformer \\\n", + " --data-dir {data_dir} \\\n", + " --checkpoint-path {geneformer_10m_bnmo2} \\\n", + " --results-path {result_path_10m_bnmo2} \\\n", + " --micro-batch-size {micro_batch_size} \\\n", + " --seq-len 2048 \\\n", + " --num-dataset-workers 10 \\\n", + " --num-gpus 1 \\\n", + " --include-input-ids" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-19 20:16:55 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-19 20:16:57 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-16 20:22:40 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-19 20:16:58 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:58 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:58 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:16:58 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:16:58 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-16 20:22:40 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cm = get_cmap(\"Set1\")\n", + " \n", + "[NeMo W 2024-12-16 20:22:40 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-12-16 20:22:41 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:22:41 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:22:41 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:22:42 infer_geneformer:82] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-19 20:16:58 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-19 20:16:58 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:16:58 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-12-16 20:22:42 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-12-16 20:22:42 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:22:42 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "[NeMo I 2024-11-19 20:16:58 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo I 2024-12-16 20:22:42 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-11-19 20:16:58 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-11-19 20:16:58 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", - "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_randomweights.pt\n" + "[NeMo W 2024-12-16 20:22:42 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-12-16 20:22:42 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" ] } ], "source": [ - "# NOTE: due to a an issue we are working on fixing, predict results have the last batch dropped\n", - "# so set micro-batch-size=1 to make sure we get all results.\n", - "!infer_geneformer --data-dir {data_dir} --result-path {results_path_10m_random} --micro-batch-size {micro_batch_size} --seq-len 2048 --num-dataset-workers 10" + "!infer_geneformer \\\n", + " --data-dir {data_dir} \\\n", + " --results-path {results_path_10m_random} \\\n", + " --micro-batch-size {micro_batch_size} \\\n", + " --seq-len 2048 \\\n", + " --num-dataset-workers 10 \\\n", + " --num-gpus 1 \\\n", + " --include-input-ids" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-11-19 20:17:31 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-11-19 20:17:32 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-16 20:24:08 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-11-19 20:17:33 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:17:33 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:17:33 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-11-19 20:17:33 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-11-19 20:17:33 infer_geneformer:77] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-16 20:24:08 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + " cm = get_cmap(\"Set1\")\n", + " \n", + "[NeMo W 2024-12-16 20:24:09 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", + "[NeMo W 2024-12-16 20:24:10 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:24:10 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:24:10 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-16 20:24:10 infer_geneformer:82] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-11-19 20:17:33 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-11-19 20:17:33 megatron_strategy:310] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-11-19 20:17:33 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2024-12-16 20:24:10 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", + "[NeMo I 2024-12-16 20:24:10 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-16 20:24:10 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", @@ -538,22 +547,27 @@ "----------------------------------------------------------------------------------------------------\n", "\n", "WARNING: Logging before flag parsing goes to stderr.\n", - "W1119 20:17:33.781779 138558727221696 config.py:85] Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-11-19 20:17:34 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-11-19 20:17:34 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", + "W1216 20:24:11.353403 140648060589888 config.py:85] Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2024-12-16 20:24:12 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "[NeMo W 2024-12-16 20:24:12 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", " warnings.warn(\n", " \n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-11-19 20:17:35 megatron_strategy:324] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-11-19 20:17:35 megatron_parallel:550] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n", - "Writing output ['embeddings'] into /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_106m.pt\n" + "[NeMo W 2024-12-16 20:24:13 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2024-12-16 20:24:13 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n" ] } ], "source": [ - "# NOTE: due to a an issue we are working on fixing, predict results have the last batch dropped\n", - "# so set micro-batch-size=1 to make sure we get all results.\n", - "!infer_geneformer --data-dir {data_dir} --checkpoint-path {geneformer_106m} --result-path {result_path_106m} --micro-batch-size {micro_batch_size} --seq-len 2048 --num-dataset-workers 10" + "!infer_geneformer \\\n", + " --data-dir {data_dir} \\\n", + " --checkpoint-path {geneformer_106m} \\\n", + " --results-path {result_path_106m} \\\n", + " --micro-batch-size {micro_batch_size} \\\n", + " --seq-len 2048 \\\n", + " --num-dataset-workers 10 \\\n", + " --num-gpus 1 \\\n", + " --include-input-ids" ] }, { @@ -566,7 +580,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -635,16 +649,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(8192, 256)" + "(22502, 256)" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -652,23 +666,23 @@ "source": [ "#NBVAL_CHECK_OUTPUT\n", "import torch\n", - "infer_Xs_10m = torch.load(result_path_10m)['embeddings'].float().cpu().numpy()\n", + "infer_Xs_10m = torch.load(result_path_10m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_10m), (len(adata), len(infer_Xs_10m))\n", "infer_Xs_10m.shape" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(8192, 256)" + "(22502, 256)" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -676,46 +690,46 @@ "source": [ "#NBVAL_CHECK_OUTPUT\n", "import torch\n", - "infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2)['embeddings'].float().cpu().numpy()\n", + "infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2 / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_10m_bnmo2), (len(adata), len(infer_Xs_10m))\n", "infer_Xs_10m_bnmo2.shape" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(8192, 768)" + "(22502, 768)" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#NBVAL_CHECK_OUTPUT\n", - "infer_Xs_106m = torch.load(result_path_106m)['embeddings'].float().cpu().numpy()\n", + "infer_Xs_106m = torch.load(result_path_106m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_106m), (len(adata), len(infer_Xs_106m))\n", "infer_Xs_106m.shape" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(8192, 256)" + "(22502, 256)" ] }, - "execution_count": 17, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -723,14 +737,14 @@ "source": [ "#NBVAL_CHECK_OUTPUT\n", "import torch\n", - "infer_Xs_10m_random = torch.load(results_path_10m_random)['embeddings'].float().cpu().numpy()\n", + "infer_Xs_10m_random = torch.load(results_path_10m_random / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_10m_random), (len(adata), len(infer_Xs_10m_random))\n", "infer_Xs_10m_random.shape" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -747,14 +761,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_369269/2938980837.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", + "/tmp/ipykernel_109448/2938980837.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", " ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='right')\n" ] }, @@ -764,13 +778,13 @@ "Text(0.5, 1.0, 'Cell type counts for classification dataset')" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -795,14 +809,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 1 1 19 ... 17 14 14]\n" + "[ 1 29 1 ... 14 12 3]\n" ] } ], @@ -816,12 +830,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -838,7 +852,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -874,7 +888,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -888,8 +902,6 @@ "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] }, @@ -898,11 +910,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.777 (+/- 0.035)\n", - "precision: 0.627 (+/- 0.052)\n", - "recall: 0.549 (+/- 0.019)\n", - "f1_score: 0.561 (+/- 0.028)\n", - "roc_auc: 0.971 (+/- 0.007)\n" + "accuracy: 0.789 (+/- 0.026)\n", + "precision: 0.682 (+/- 0.033)\n", + "recall: 0.573 (+/- 0.014)\n", + "f1_score: 0.593 (+/- 0.012)\n", + "roc_auc: 0.973 (+/- 0.007)\n" ] } ], @@ -912,20 +924,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_369269/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", - " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -940,7 +944,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -964,11 +968,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.397 (+/- 0.015)\n", - "precision: 0.138 (+/- 0.041)\n", - "recall: 0.092 (+/- 0.005)\n", - "f1_score: 0.079 (+/- 0.005)\n", - "roc_auc: 0.737 (+/- 0.009)\n" + "accuracy: 0.418 (+/- 0.015)\n", + "precision: 0.204 (+/- 0.023)\n", + "recall: 0.100 (+/- 0.007)\n", + "f1_score: 0.089 (+/- 0.007)\n", + "roc_auc: 0.769 (+/- 0.014)\n" ] } ], @@ -978,20 +982,20 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_369269/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_109448/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1006,17 +1010,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", @@ -1028,11 +1028,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.838 (+/- 0.018)\n", - "precision: 0.802 (+/- 0.037)\n", - "recall: 0.679 (+/- 0.023)\n", - "f1_score: 0.705 (+/- 0.025)\n", - "roc_auc: 0.987 (+/- 0.007)\n" + "accuracy: 0.849 (+/- 0.018)\n", + "precision: 0.840 (+/- 0.020)\n", + "recall: 0.722 (+/- 0.019)\n", + "f1_score: 0.751 (+/- 0.015)\n", + "roc_auc: 0.990 (+/- 0.002)\n" ] } ], @@ -1042,12 +1042,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1062,17 +1062,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] @@ -1082,11 +1078,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.835 (+/- 0.021)\n", - "precision: 0.809 (+/- 0.045)\n", - "recall: 0.686 (+/- 0.026)\n", - "f1_score: 0.719 (+/- 0.029)\n", - "roc_auc: 0.987 (+/- 0.007)\n" + "accuracy: 0.849 (+/- 0.021)\n", + "precision: 0.849 (+/- 0.029)\n", + "recall: 0.718 (+/- 0.031)\n", + "f1_score: 0.752 (+/- 0.028)\n", + "roc_auc: 0.989 (+/- 0.003)\n" ] } ], @@ -1096,20 +1092,12 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_369269/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", - " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1124,27 +1112,19 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.905 (+/- 0.015)\n", - "precision: 0.913 (+/- 0.025)\n", - "recall: 0.820 (+/- 0.016)\n", - "f1_score: 0.843 (+/- 0.018)\n", - "roc_auc: 0.992 (+/- 0.005)\n" + "accuracy: 0.911 (+/- 0.016)\n", + "precision: 0.917 (+/- 0.019)\n", + "recall: 0.834 (+/- 0.019)\n", + "f1_score: 0.857 (+/- 0.019)\n", + "roc_auc: 0.995 (+/- 0.002)\n" ] } ], @@ -1154,12 +1134,12 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAKPCAYAAABTiDpeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeViN+f/48eeptG8iCaXSIiFZJ1sZTFlSw8jSSGOf0VizfQgxZCe7sRQGYaxfjSyRIUtZylKiSOYzWcY2soTy+6Nf98fRdkpSvB/Xda7Lue/3dt/3mea8znuTvX379i2CIAiCIAiCIAiCROlTN0AQBEEQBEEQBKGsEYGSIAiCIAiCIAjCe0SgJAiCIAiCIAiC8B4RKAmCIAiCIAiCILxHBEqCIAiCIAiCIAjvEYGSIAiCIAiCIAjCe0SgJAiCIAiCIAiC8B4RKAmCIAiCIAiCILxHBEqCIAiCIAiCIAjvEYGSIAiCIAiCIAjCe0SgJAiCIAiCIAhCmfXnn3/i5uZGtWrVkMlk7N69u9A8kZGRNGzYEDU1NSwtLQkJCSlyvSJQEgRBEARBEAShzHr27Bn29vYsW7ZMofQ3b96kU6dOtGnThtjYWEaMGMGAAQM4cOBAkeqVvX379m1xGiwIgiAIgiAIglCaZDIZu3btwsPDI98048aNIywsjMuXL0vHevbsyePHjwkPD1e4LtGjJAiC8JH4+PjI/SF3dnZmxIgRn6w9giAIglAWZGRk8O+//8q9MjIySqz8U6dO0a5dO7ljLi4unDp1qkjlqJRYiwRBEMooHx8f1q9fL703MDCgSZMmzJkzh/r163/ClhXs3V/CBEEQBKEgdevW/eh1aDj4lkg549wrExAQIHdsypQpTJ06tUTKv3PnDkZGRnLHjIyM+Pfff3nx4gUaGhoKlSMCJUEQvgiurq4EBwcD2X9AJ02aROfOnUlNTf3ELStYk2F7FE4bs9gdAMvaiv/PMunq5WLnqWWjWJ7kxOz0RjVrK1zH3VtXi92usnr9ZlZ2CteRcv1KsdtV1vKU1XaVVp7SbpeOsZXCeZ6mXf/obSvt6ze3Vvy/s5vXPv5/Z6V9/R+drGQGo02YMIFRo0bJHVNTUyuRskuSGHonCMIXQU1NjapVq1K1alUaNGjA+PHjuX37Nvfv3883T1ZWFnPmzMHS0hI1NTVMTU2ZMWOGdP727dt4enqir6+PgYEB7u7upKSklMLVCIIgCEL5paamhq6urtyrJAOlqlWrcvfuXbljd+/eRVdXV+HeJBCBkiAIX6D09HR+++03LC0tqVSpUr7pJkyYwKxZs/D39yc+Pp7NmzdLXfmvX7/GxcUFHR0djh8/TlRUFNra2ri6uvLq1avSuhRBEARBKD0yWcm8PjJHR0ciIiLkjh06dAhHR8cilSOG3gmC8EXYt28f2traQPYyo8bGxuzbtw8lpbx/L3r69ClBQUEsXbqUvn37AlCrVi1atmwJwNatW8nKymLNmjXI/v8f/eDgYPT19YmMjOSbb74phasSBEEQhFJUQkPviio9PZ2kpCTp/c2bN4mNjcXAwABTU1MmTJjAf//7XzZs2ADAkCFDWLp0KWPHjqVfv34cOXKEbdu2ERYWVqR6RaAkCMIXoU2bNqxYsQKAR48esXz5cjp06EB0dDQ1a9bMlT4hIYGMjAzatm2bZ3lxcXEkJSWho6Mjd/zly5ckJycXuX0ZGRm5VvwRPVOCIAiCAGfPnqVNmzbS+5z5TX379iUkJIS0tDS5Ocfm5uaEhYUxcuRIgoKCqFGjBmvWrMHFxaVI9YpASRCEL4KWlhaWlpbS+zVr1qCnp8fq1av55ZdfcqUvbAxzeno6jRo1YtOmTbnOGRoaFrl9gYGBuVYA+vHHH4HqRS5LEARBED6KUhg2lxdnZ2cK2vo1JCQkzzwXLlz4oHrFHCVBEL5IMpkMJSUlXrx4ked5KysrNDQ0co1xztGwYUOuX79OlSpVsLS0lHvp6ekVuT0TJkzgyZMncq8BAwYUuRxBEARB+GhkSiXzKifKT0sFQRA+QEZGBnfu3OHOnTskJCTw888/k56ejpubW57p1dXVGTduHGPHjmXDhg0kJydz+vRp1q5dC4CXlxeVK1fG3d2d48ePc/PmTSIjIxk2bBh//fVXkduX1wpAqqqqH3TNgiAIgiAUnxh6JwjCFyE8PBxjY2MAdHR0qF27Ntu3b8fZ2TnfPP7+/qioqDB58mT+/vtvjI2NGTJkCACampr8+eefjBs3jq5du/L06VOqV69O27Zt0dXVLY1LEgRBEITS9YmG3n0qIlASBOGzFxISkuf45cIoKSkxceJEJk6cmOf5qlWrsn79+gLrfVdkZGSR2yAIgiAIZUY5GjZXEmRvC5oZJQhfmJSUFMzNzblw4QINGjTIN52zszMNGjRg0aJFpdY2RRSnXTKZjF27duHh4fHJ2/K5MTMzY8SIEYwYMQIo+r2+fLmUdloXBEEQyr26det+9Do0vhpXIuW8OD27RMr52L6ssFD4IHfu3OHnn3/GwsICNTU1TExMcHNzk5vsbmZmhkwmQyaToaGhgZmZGZ6enhw5ciTfch88eECNGjWQyWQ8fvy4FK4kfyYmJqSlpUl/bCIjI/Ns186dO5k+ffonaOGXJSQkBH19/Q8qIyUlRfpM5vcqTm+TIAiCIHxxysmGsyVFDL0TFJKSkkKLFi3Q19dn7ty51KtXj9evX3PgwAGGDh3K1atXpbTTpk1j4MCBvHr1ipSUFH777TfatWvH9OnT8xzC1L9/f+rXr89///vf0rykPCkrK1O1atVC0xkYGJRCa4SSkBP85pg3bx7h4eEcPnxYOlacVepKi2VtxX8hTLqa3QPVZFz+P0y8L2b21wCYW9spnOfmtStFaltOu4pzLcXJo1/dWuE8j/97DYDqFrYK5/nvjYQita20r7+s5fmQOmrZKJ4nOfHzu/7PIU9Zbde7eWrUUvy//7+Ss//7V/RvRlH/XrzbruLk+ei+sKF3X9bVCsX2008/IZPJiI6Oplu3blhbW2NnZ8eoUaM4ffq0XFodHR2qVq2KqakprVu35tdff8Xf35/JkyeTmJgol3bFihU8fvwYPz8/hdrh4+ODh4cHAQEBGBoaoqury5AhQ+Q25szIyGDYsGFUqVIFdXV1WrZsSUxMjHT+0aNHeHl5YWhoiIaGBlZWVgQHBwP/632IjY0lJSVF2tysYsWKyGQyfHx8gOxhZTnDqf7zn//QrFmzXG21t7dn2rRp0vs1a9Zga2uLuro6tWvXZvny5Qpdc44HDx7Qq1cvqlevjqamJvXq1WPLli0F5jEzM2P69On06tULLS0tqlevzrJly3Kl++eff/j222/R1NTEysqKvXv3SucyMzPp378/5ubmaGhoYGNjQ1BQkEJtfvPmDb6+vujp6VG5cmX8/f3l9kHIyMjAz8+P6tWro6WlRbNmzaR5PJGRkfzwww88efJE6vmZOnUqABs3bqRx48bSZ613797cu3cvzzbkBL85L21tbVRUVOSO5bdn0uPHjxk8eDBGRkaoq6tTt25d9u3bJ50/ceIErVq1QkNDAxMTE4YNG8azZ88UujeCIAiCUO58YT1KIlASCvXw4UPCw8MZOnQoWlpauc4rMjRq+PDhvH37lj179kjH4uPjmTZtGhs2bEBJSfGPYkREBAkJCURGRrJlyxZ27twpt1Hn2LFj2bFjB+vXr+f8+fNYWlri4uLCw4cPgeyVzOLj49m/fz8JCQmsWLGCypUr56rHxMSEHTt2AJCYmEhaWlqeAYKXlxfR0dEkJydLx65cucLFixfp3bs3AJs2bWLy5MnMmDGDhIQEZs6cib+/f4ELAbzv5cuXNGrUiLCwMC5fvsygQYPo06cP0dHRBeabO3cu9vb2XLhwgfHjxzN8+HAOHToklyYgIABPT08uXrxIx44d8fLyku5XVlYWNWrUYPv27cTHxzN58mT+85//sG3btkLbvH79elRUVIiOjiYoKIgFCxawZs0a6byvry+nTp0iNDSUixcv0r17d1xdXbl+/TrNmzdn0aJF6OrqkpaWRlpamhRQv379munTpxMXF8fu3btJSUmRgtiSkpWVRYcOHYiKiuK3334jPj6eWbNmoaysDEBycjKurq5069aNixcvsnXrVk6cOIGvr2+JtkMQBEEQhE9DDL0TCpWUlMTbt2+pXbt2scswMDCgSpUqpKSkANk9Cb169WLu3LmYmppy48YNhctSVVVl3bp1aGpqYmdnx7Rp0xgzZgzTp0/nxYsXrFixgpCQEDp06ADA6tWrOXToEGvXrmXMmDGkpqbi4OBA48aNgexel7woKytLQ+yqVKmSb0BoZ2eHvb09mzdvxt/fH8gOjJo1a4alpSUAU6ZMYf78+XTt2hUAc3Nz4uPjWbVqFX379lXouqtXry7X8/bzzz9z4MABtm3bRtOmTfPN16JFC8aPHw+AtbU1UVFRLFy4kPbt20tpfHx86NWrFwAzZ85k8eLFREdH4+rqSoUKFeQCUXNzc06dOsW2bdvw9PQssM0mJiYsXLgQmUyGjY0Nly5dYuHChQwcOJDU1FSCg4NJTU2lWrVqAPj5+REeHk5wcDAzZ85ET08PmUyWazhkv379pH9bWFiwePFimjRpQnp6Otra2oXdSoUcPnyY6OhoEhISsLa2lurKERgYiJeXl9SzaGVlxeLFi3FycmLFihWoq6uXSDsEQRAEocwQQ+8EQV5JLYz49u1bZP+/u3XChAnY2try/fff55k2NTUVbW1t6TVz5kzpnL29PZqamtJ7R0dH0tPTuX37NsnJybx+/ZoWLVpI5ytUqEDTpk1JSMgeJ/zjjz8SGhpKgwYNGDt2LCdPnvzga/Py8mLz5s3SdW7ZsgUvLy8Anj17RnJyMv3795e7pl9++UWuF6owmZmZTJ8+nXr16mFgYIC2tjYHDhwgNTW1wHyOjo653ufcixz169eX/q2lpYWurq7cULZly5bRqFEjDA0N0dbW5tdff5XqPX78uNx1bdq0Scr31VdfSc88p+7r16+TmZnJpUuXyMzMxNraWi7/sWPHCr0v586dw83NDVNTU3R0dHBycgIo9F4URWxsLDVq1JCCpPfFxcUREhIi13YXFxeysrK4efNmkevLyMjg33//lXu9O6RUEARBED65L2zonehREgplZWWFTCaTW7ChqB48eMD9+/cxNzcH4MiRI1y6dInff/8d+F8wVrlyZSZOnIi/vz+xsbFS/pJcPKFDhw7cunWLP/74g0OHDtG2bVuGDh3KvHnzil1mr169GDduHOfPn+fFixfcvn2bHj16AJCeng5k92y9P5cpZxiXIubOnUtQUBCLFi2iXr16aGlpMWLEiBL5Ml2hQgW59zKZjKysLABCQ0Px8/Nj/vz5ODo6oqOjw9y5czlz5gwAjRs3lntWRkZGCtWZnp6OsrIy586dy3UfCuoVevbsGS4uLri4uLBp0yYMDQ1JTU3FxcWlRAOL/OYt5UhPT2fw4MEMGzYs1zlTU9Mi1xcYGCjXcwfZQf2CxUWbyyYIgiAIQskQgZJQKAMDA1xcXFi2bBnDhg3LNU/p8ePHhc5TCgoKQklJSdo/ZseOHbx48UI6HxMTQ79+/Th+/Di1atVCRUVFGrb2vri4OF68eCF9kT19+jTa2tqYmJhQuXJlVFVViYqKombNmkD2fJaYmBhpiBSAoaEhffv2pW/fvrRq1YoxY8bkGSipqqoC2b05BalRowZOTk5s2rSJFy9e0L59e6pUqQJkBw7VqlXjxo0bUi9TcURFReHu7i71wmVlZXHt2jXq1KlTYL73F9s4ffo0traKr/ATFRVF8+bN+emnn6Rj7/b4aGho5PuscoKpd+u2srJCWVkZBwcHMjMzuXfvHq1atcozv6qqaq57f/XqVR48eMCsWbMwMTEB4OzZswpfj6Lq16/PX3/9xbVr1/LsVWrYsCHx8fH5XntRTZgwgVGjRskdS0pKKpGyBUEQBKFEfGFD70SgJChk2bJltGjRgqZNmzJt2jTq16/PmzdvOHToECtWrJAbyvX06VPu3LnD69evuXnzJr/99htr1qwhMDBQ+lJZq1YtufL/+ecfAGxtbQsNul69ekX//v2ZNGkSKSkpTJkyBV9fX5SUlNDS0uLHH39kzJgxGBgYYGpqypw5c3j+/Dn9+/cHYPLkyTRq1Ag7OzsyMjLYt29fvoFDzZo1kclk7Nu3j44dO6KhoZFvb4eXlxdTpkzh1atXLFy4UO5cQEAAw4YNQ09PD1dXVzIyMjh79iyPHj3K9eU4P1ZWVvz++++cPHmSihUrsmDBAu7evVtooBQVFcWcOXPw8PDg0KFDbN++nbCwMIXqzKl3w4YNHDhwAHNzczZu3EhMTIzUO1iQ1NRURo0axeDBgzl//jxLlixh/vz5QPZ8KS8vL7y9vZk/fz4ODg7cv3+fiIgI6tevT6dOnTAzMyM9PZ2IiAhpyKWpqSmqqqosWbKEIUOGcPny5Y+yp5WTkxOtW7emW7duLFiwAEtLS65evYpMJsPV1ZVx48bx1Vdf4evry4ABA9DS0iI+Pp5Dhw6xdOnSItenpqaGmpqa3LGcQF0QBEEQyoQvLFD6sq5WKDYLCwvOnz9PmzZtGD16NHXr1qV9+/ZERESwYsUKubSTJ0/G2NgYS0tL+vTpw5MnT4iIiGDcuJLZzblt27ZYWVnRunVrevToQZcuXaRlowFmzZpFt27d6NOnDw0bNiQpKYkDBw5QsWJFIPvL54QJE6hfvz6tW7dGWVmZ0NDQPOuqXr06AQEBjB8/HiMjowJXNPvuu+948OABz58/l3rOcgwYMIA1a9YQHBxMvXr1cHJyIiQkRC7YcHZ2LnDltkmTJtGwYUNcXFxwdnamatWquerJy+jRozl79iwODg788ssvLFiwABcXl0Lz5Rg8eDBdu3alR48eNGvWjAcPHsj1LhXE29ubFy9e0LRpU4YOHcrw4cMZNGiQdD44OBhvb29Gjx6NjY0NHh4exMTESEPXmjdvzpAhQ+jRoweGhobMmTMHQ0NDQkJC2L59O3Xq1GHWrFkfNGyyIDt27KBJkyb06tWLOnXqMHbsWKmHq379+hw7doxr167RqlUrHBwcmDx5srQwhSAIgiAI5ZvsbUnN1BeEUuDj48Pjx4/ZvXv3p25KiatZsyYBAQElusy1mZkZI0aMkBt2KJQfly9fFhvOig1ny30eseFs2WxXaeUpq+16N8/nsuFs3bqKpy8ujTYlM4LjxVH/EinnYxOBklCulEagJJPJ2LVrV4G9NSXdjitXrtCrVy9iY2OLtKdUYe1SJFD6WMHU5xzUKsrZ2ZkGDRqwaNEioOj3+vLlUtppXRAEQSj3SiVQ+npGiZTz4sjEEinnYxND7wSF3blzh59//hkLCwvU1NQwMTHBzc2NiIgIKY2ZmRkymQyZTIaGhgZmZmZ4enpy5EjuX7hjYmJo27Yt+vr6VKxYERcXF+Li4krzkvKUlpYm7cGUkpKCTCaTW9UNshenCAkJKbE67ezsuHjx4gcFSZ+jyMhIZDIZjx8//qBycj6T+b3eHbopCIIgCIIAYjEHQUEpKSm0aNECfX195s6dS7169Xj9+jUHDhxg6NChckuHT5s2jYEDB/Lq1StSUlL47bffaNeuHdOnT2fixOxfENLT03F1daVLly4sX76cN2/eMGXKFFxcXLh9+3au5apzlGRwkp/3NzfNi56e3kdvR0nI2eD3S5eWlib9e+vWrUyePJnExETpWEltUvsxFGe4hoWN4sPobiRmD6NrMj5S4Twxs5yL1LbyMPTG1LLgRVHelZoUX6R6ysP1l9WhV8bmim90nnbzarHrKavX/znkKavtKq08pd2uj64c7YFUEsTP14JCfvrpJ2QyGdHR0XTr1g1ra2vs7OwYNWpUruWndXR0qFq1KqamprRu3Zpff/0Vf39/uS+nV69e5eHDh0ybNg0bGxvs7OyYMmUKd+/e5datW/m2Y+rUqTRo0IBVq1ZhYmKCpqYmnp6ePHnyREqTlZXFtGnTqFGjBmpqajRo0IDw8HDp/KtXr/D19cXY2Bh1dXVq1qxJYGCgdF4mk0nDxXIWW3BwcEAmk+Hs7AxkDyvLGZr366+/Uq1aNWnfoRzu7u7069dPer9nzx4aNmyIuro6FhYWBAQE8ObNGwWfQPYS5f3798fc3BwNDQ1sbGwICgoqMI+zszO+vr74+vqip6dH5cqV8ff3z7WJ8PPnz+nXrx86OjqYmpry66+/yp0fN24c1tbWaGpqYmFhgb+/P69fv1ao3QEBARgaGqKrq8uQIUPk9jrKysoiMDBQuiZ7e3tpb62UlBTatGkDQMWKFZHJZNL8rfDwcFq2bIm+vj6VKlWic+fOBW5SW7VqVemlp6eHTCaTO5ZfoJSRkcG4ceMwMTFBTU0NS0tL1q5dK52/fPkyHTp0QFtbGyMjI/r06SOt4CgIgiAInx2ZUsm8yony01Lhk3n48CHh4eEMHTo01x5KQKHLeQMMHz6ct2/fsmfPHgBsbGyoVKkSa9eu5dWrV7x48YK1a9dia2uLmZlZgWUlJSWxbds2/u///o/w8HAuXLggtwpbUFAQ8+fPZ968eVy8eBEXFxe6dOnC9evXAVi8eDF79+5l27ZtJCYmsmnTpnzrjI6OBuDw4cOkpaWxc+fOXGm6d+/OgwcPOHr0qHQs557l7Jt0/PhxvL29GT58OPHx8axatYqQkBBmzFB8rG9WVhY1atRg+/btxMfHM3nyZP7zn/+wbdu2AvOtX78eFRUVoqOjCQoKYsGCBaxZs0Yuzfz582ncuLF0L3/88Ue5HhcdHR1CQkKIj48nKCiI1atX51oCPS8REREkJCQQGRnJli1b2Llzp9ymqoGBgWzYsIGVK1dy5coVRo4cyffff8+xY8cwMTFhx44dACQmJpKWliYFhs+ePWPUqFGcPXuWiIgIlJSU+Pbbb3MFqx/K29ubLVu2sHjxYhISEli1apUUVD1+/Jivv/4aBwcHzp49S3h4OHfv3sXT07NE2yAIgiAIZYZMVjKvckIMvRMKlZSUxNu3b6ldW/EhEO8zMDCgSpUq0lAwHR0dIiMj8fDwkPbAsbKy4sCBA6ioFPyxfPnyJRs2bKB69eoALFmyhE6dOjF//nyqVq3KvHnzGDduHD179gRg9uzZHD16lEWLFrFs2TJSU1OxsrKiZcuWyGQyaWPavBgaGgJQqVKlfIfkVaxYkQ4dOrB582batm0LwO+//07lypWlHpGcJcb79u0LZC+3Pn36dMaOHcuUKVMUuYVUqFBBLsgwNzfn1KlTbNu2rcAv5yYmJixcuBCZTIaNjQ2XLl1i4cKFDBw4UErTsWNHKdgcN24cCxcu5OjRo9jY2ADZS5PnMDMzw8/Pj9DQUMaOHVtgm1VVVVm3bh2amprY2dkxbdo0xowZw/Tp03n9+jUzZ87k8OHDODo6SvflxIkTrFq1CicnJwwMDACoUqWKXEDerVs3uXrWrVuHoaEh8fHxJTaZ9dq1a2zbto1Dhw7Rrl07qX05li5dioODAzNnzpRrh4mJSb6b1AqCIAiCUH6IHiWhUCW1MOLbt2+R/f9fEV68eEH//v1p0aIFp0+fJioqirp169KpUydevHgBZM8byXkNGTJEKsfU1FQKkgAcHR3JysoiMTGRf//9l7///psWLVrI1d2iRQtpU1wfHx9iY2OxsbFh2LBhHDx48IOvzcvLix07dpCRkQHApk2b6Nmzp7Q4Q1xcHNOmTZO7poEDB5KWlsbz588VrmfZsmU0atQIQ0NDtLW1+fXXX0lNTS0wz1dffSXdd8i+X9evX5f2A4LsPYFy5AxLu3fvnnRs69attGjRQhqmNmnSJKne1NRUuet6N3DI2ST23brT09O5ffs2SUlJPH/+nPbt28vl37BhQ4HD6ACuX79Or169sLCwQFdXV+oRLOxeFEVsbCzKyso4OTnleT4uLo6jR4/KtT3nx4TC2p+XjIwM/v33X7nXu8MUBUEQBOGT+8KG3okeJaFQVlZWyGQyuQUbiurBgwfcv39fmvOzefNmUlJSOHXqlBRMbN68mYoVK7Jnzx569uwpt9Kcrq7uB13Duxo2bMjNmzfZv38/hw8fxtPTk3bt2klzY4rDzc2Nt2/fEhYWRpMmTTh+/Ljc0LT09HQCAgLo2rVrrrzq6uoK1REaGoqfnx/z58/H0dERHR0d5s6dy5kzZ4rd7hzvL54hk8mkYWynTp3Cy8uLgIAAXFxc0NPTIzQ0lPnz5wNQrVo1uWeV0wtUmPT0dADCwsLkAl8ANTW1AvO6ublRs2ZNVq9eLc0Pq1u3bokGFhoaGgWeT09Px83NjdmzZ+c6Z2xsXOT6AgMD5XoMAX788UcWLF5e5LIEQRAE4aMoR8PmSoIIlIRCGRgY4OLiwrJlyxg2bFiueUqPHz8udJ5SUFAQSkpK0gIIz58/R0lJSa6nI+d9zhd0S0vLPMtKTU3l77//plq1agCcPn0aJSUlbGxs0NXVpVq1akRFRcn1BERFRdG0aVPpva6uLj169KBHjx589913uLq68vDhw1xf8lVVVQHkel/yoq6uTteuXdm0aRNJSUnY2NjQsGFD6XzDhg1JTEzM95oUERUVRfPmzeXmYynSc/F+IHX69GmsrKxQVlZWqN6TJ09Ss2ZNacVCQG7BDRUVlXyvKy4ujhcvXkhBx+nTp9HW1sbExAQDAwPU1NRITU3Nt9cmr/v/4MEDEhMTWb16Na1atQLgxIkTCl1LUdSrV4+srCyOHTsmDb17V8OGDdmxYwdmZmaFDhdVxIQJExg1apTcsaSkpA8uVxAEQRCE4hGBkqCQZcuW0aJFC5o2bcq0adOoX78+b9684dChQ6xYsUIa1gbw9OlT7ty5w+vXr7l58ya//fYba9asITAwUPpC3b59e8aMGcPQoUP5+eefycrKYtasWaioqEjzevKjrq5O3759mTdvHv/++y/Dhg3D09NTmkM0ZswYpkyZQq1atWjQoAHBwcHExsayadMmABYsWICxsTEODg4oKSmxfft2qlatmmewV6VKFTQ0NAgPD6dGjRqoq6vnuzS4l5cXnTt35sqVK3z//fdy5yZPnkznzp0xNTXlu+++Q0lJibi4OC5fvswvv/yi0DOwsrJiw4YNHDhwAHNzczZu3EhMTIzUS5ef1NRURo0axeDBgzl//jxLliyReoMUrTc1NZXQ0FCaNGlCWFgYu3btUijvq1ev6N+/P5MmTSIlJYUpU6bg6+uLkpISOjo6+Pn5MXLkSLKysmjZsiVPnjwhKioKXV1d+vbtS82aNZHJZOzbt4+OHTuioaFBxYoVqVSpEr/++ivGxsakpqYyfvx4ha9HUWZmZvTt25d+/fqxePFi7O3tuXXrFvfu3cPT05OhQ4eyevVqevXqxdixYzEwMCApKYnQ0FDWrFmjcCCaQ01NLVdPWk6gKAiCIAhlQjkaNlcSvqyrFYrNwsKC8+fP06ZNG0aPHk3dunVp3749ERERrFixQi7t5MmTMTY2xtLSkj59+vDkyRMiIiIYN26clKZ27dr83//9HxcvXsTR0ZFWrVrx999/Ex4eXuiwJUtLS7p27UrHjh355ptvqF+/PsuX/2940rBhwxg1ahSjR4+mXr16hIeHs3fvXqysrIDshSTmzJlD48aNadKkCSkpKfzxxx95bvaqoqLC4sWLWbVqFdWqVcPd3T3fdn399dcYGBiQmJhI79695c65uLiwb98+Dh48SJMmTfjqq69YuHCh3EISPj4+0vLjeRk8eDBdu3alR48eNGvWjAcPHsj1LuXH29ubFy9e0LRpU4YOHcrw4cMZNGhQoflydOnShZEjR+Lr60uDBg04efIk/v7+CuVt27YtVlZWtG7dmh49etClSxe5zV2nT5+Ov78/gYGB2Nra4urqSlhYmBT8Va9eXVoIw8jISAqyQkNDOXfuHHXr1mXkyJHMnTtX4espihUrVvDdd9/x008/Ubt2bQYOHMizZ88ApJ7LzMxMvvnmG+rVq8eIESPQ19cXGwcLgiAIn6cvbNU72duSmqkvCKVg6tSp7N69W25OzOfCycmJNm3ayAUSH8rZ2ZkGDRqwaNGiEitTKD2XL18WG86KDWfLfR6x4WzZfC6llaestqu08pRmu0pq1deCaHQofGsQRbzYP7JEyvnYRKAklCufa6D05MkT7OzsuHr1ar6bnxZHWQiUUlJSMDc358KFCzRo0OCTteNTMDMzY8SIEYwYMQLIXiRj165d0ly9wly+XEo7rQuCIAjlXqkESh0L3uheUS/+GF4i5XxsYnyIIJQBenp6/PXXXyUWJPn4+Cj8Zfx9W7ZsQVlZmaFDh5ZIWwRBEARB+Ex8YUPvxGIOQrkyderUEh2a9rmLjIwscp61a9cyduxYVq1axfz58xVevlz4OMraMJJ387RfnKhQ+kPDsjcuVq9SS+E6Xt5LLna7ylqestqu0spTVttVWnnKartKK09ZbVdp5SntdgklS/QoCcIX4OnTp3h5eaGlpYWxsTELFy7E2dlZGhKW4+bNm5w8eZLx48djbW3Nzp07Cy1bJpOxYsUKOnTogIaGBhYWFgXuSZWZmUn//v0xNzdHQ0MDGxsbgoLku/IjIyNp2rQpWlpa6Ovr06JFC2lJ8qlTp9KgQQPWrVuHqakp2tra/PTTT2RmZjJnzhyqVq1KlSpVmDFjhlyZCxYsoF69emhpaWFiYsJPP/0k7eWUn8ePHzN48GCMjIxQV1enbt267Nu3Tzp/4sQJWrVqhYaGBiYmJgwbNkxa7EEQBEEQPjtf2Iaz5aelgiAU26hRo4iKimLv3r0cOnSI48ePc/78+VzpgoOD6dSpE3p6enz//fesXbtWofL9/f3p1q0bcXFxeHl50bNnT7kl49+VlZVFjRo12L59O/Hx8UyePJn//Oc/bNu2DYA3b97g4eGBk5MTFy9e5NSpUwwaNEhuz63k5GT2799PeHg4W7ZsYe3atXTq1Im//vqLY8eOMXv2bCZNmiS3h5SSkhKLFy/mypUrrF+/niNHjjB27Nh8rykrK4sOHToQFRXFb7/9Rnx8PLNmzZKW/U5OTsbV1ZVu3bpx8eJFtm7dyokTJ/D19VXongmCIAhCufOFBUpi6J0gfOaePn3K+vXr2bx5M23btgWyA6KcDXtzZGVlERISwpIlSwDo2bMno0eP5ubNm4Xu1dS9e3cGDBgAZC/5fejQIZYsWSK3bHuOChUqEBAQIL03Nzfn1KlTbNu2DU9PT/7991+ePHlC586dqVUre6iWra1trrauW7cOHR0d6tSpQ5s2bUhMTJSWebexsWH27NkcPXqUZs2aAcj1npmZmfHLL78wZMiQPNsIcPjwYaKjo0lISMDa2hrIXiY/R2BgIF5eXlK5VlZWLF68GCcnJ1asWCGGLAqCIAifn3I0v6gklJ+QThCEYrlx4wavX7+madOm0jE9PT1sbGzk0h06dIhnz57RsWNHACpXrkz79u1Zt25doXU4Ojrmep9fjxJkb2DcqFEjDA0N0dbW5tdffyU1NRUAAwMDfHx8cHFxwc3NjaCgINLS0uTym5mZoaOjI703MjKiTp06cvsXGRkZce/ePen94cOHadu2LdWrV0dHR4c+ffrw4MEDnj9/nmcbY2NjqVGjhhQkvS8uLo6QkBC0tbWll4uLC1lZWdy8eTPfa89PRkYG//77r9zr1atXRS5HEARBEISSIQIlQRCA7EUcHj58iIaGBioqKqioqPDHH3+wfv16srKySqye0NBQ/Pz86N+/PwcPHiQ2NpYffvhBLigIDg7m1KlTNG/enK1bt2Jtbc3p06el8xUqVJArUyaT5Xksp90pKSl07tyZ+vXrs2PHDs6dO8eyZcsA8g1GNDQ0CryO9PR0Bg8eTGxsrPSKi4vj+vXrUk9YUQQGBqKnpyf3WrNmTZHLEQRBEISPRgy9EwThc2JhYUGFChWIiYnB1NQUyN636dq1a7Ru3RqABw8esGfPHkJDQ7Gz+99mpZmZmbRs2ZKDBw/i6uqabx2nT5/G29tb7r2Dg0OeaaOiomjevDk//fSTdCw5OTlXOgcHBxwcHJgwYQKOjo5s3ryZr776qmgX//+dO3eOrKws5s+fL/U65cyJyk/9+vX566+/uHbtWp69Sg0bNiQ+Ph5LS8titel9EyZMYNSoUXLHkpKSSqRsQRAEQSgRX9jQOxEoCcJnTkdHh759+zJmzBgMDAyoUqUKU6ZMQUlJSVogYePGjVSqVAlPT0+5RRMAOnbsyNq1awsMlLZv307jxo1p2bIlmzZtIjo6Ot+FIKysrNiwYQMHDhzA3NycjRs3EhMTI82DunnzJr/++itdunShWrVqJCYmcv36dblArKgsLS15/fo1S5Yswc3NjaioKFauXFlgHicnJ1q3bk23bt1YsGABlpaWXL16FZlMhqurK+PGjeOrr77C19eXAQMGoKWlRXx8PIcOHWLp0qVFbqOamhpqampyx1RVVYtcjiAIgiAIJaP89H0JglBsCxYswNHRkc6dO9OuXTtatGiBra2ttODAunXr+Pbbb3MFSQDdunVj7969/PPPP/mWHxAQQGhoKPXr12fDhg1s2bKFOnXq5Jl28ODBdO3alR49etCsWTMePHgg17ukqanJ1atX6datG9bW1gwaNIihQ4cyePDgYl+/vb09CxYsYPbs2dStW5dNmzYRGBhYaL4dO3bQpEkTevXqRZ06dRg7diyZmZlAdo/TsWPHuHbtGq1atcLBwYHJkyfnWiRDEARBED4bYuidIAjlXUhIiNx7HR0dNm3aJL1/9uwZAQEBDBo0CICLFy/mW5anpyeenp4F1letWjUOHjyY5zkzMzPevn0rvVdTUyM4OJjg4GC5dDmBi5GREbt27cq3rrw2HX7/eiH3ZrsjR45k5MiRcsf69OmTbz2QvbBEQYtZNGnSJN/rhuy5Ue969z4IgiAIQrnzhQ29k70V/+cWhM/ehQsXuHr1Kk2bNuXJkydMmzaNyMhIkpKSqFy58geVLZPJ2LVrFx4eHvmmMTMzY8SIEbk2uP3c+fj48PjxY3bv3g2As7MzDRo0YNGiRQrlv3xZ7LQuCIIgKKZu3bofvQ6Nrortr1iYFzv7l0g5H1v56fsSBEEhPj4+eQYt8+bNw97ennbt2vHs2TOOHz8uFyQlJSXRr18/TE1NUVNTo3r16rRt25ZNmzbx5s2bUrwCQRAEQRDKIplMViKv8kIMvROEL4CDgwPnzp3L93x0dDTt2rXDzs6OZcuWUbt2bQDOnj3LsmXLqFu3Lvb29nnmFZ3SH5eFjV3hif6/G4lXALCsrfiviklXLxc7T6ZeTYXSKz+5BUCHFblXN8zP/h9rFbtdZS1PWW1XaeUpq+0qrTxltV2llae022VkVlvhPHdTrgJQo5ZtISn/56/khCK1rbSv/2MrT0FOSRA9SoLwmXv69CleXl5oaWlhbGzMwoULcXZ2lobBvX37Fh8fH6ytrYmKisLNzQ0rKyusrKzo1asXJ06coH79+vmW7+zsjK+vL76+vujp6VG5cmX8/f0LDKAWLFhAvXr10NLSwsTEhJ9++on09HTp/K1bt3Bzc6NixYpoaWlhZ2fHH3/8AWTPPZLJZBw4cAAHBwc0NDT4+uuvuXfvHvv378fW1hZdXV169+4tt5lseHg4LVu2RF9fn0qVKtG5c+c8lyV/V1ZWFnPmzMHS0hI1NTVMTU2ZMWOGdP727dt4enqir6+PgYEB7u7uueYlCYIgCIJQPolASRA+c6NGjSIqKoq9e/dy6NAhjh8/zvnz56XzsbGxJCQk4OfnJ+0x9L7CfkFav349KioqREdHExQUxIIFCwrcLFVJSYnFixdz5coV1q9fz5EjRxg7dqx0fujQoWRkZPDnn39y6dIlZs+ejba2tlwZU6dOZenSpZw8eVIKWBYtWsTmzZsJCwvj4MGDLFmyREr/7NkzRo0axdmzZ4mIiEBJSYlvv/22wM10J0yYwKxZs/D39yc+Pp7NmzdjZGQEwOvXr3FxcUFHR4fjx48TFRWFtrY2rq6u+W5iKwiCIAjlmqyEXuWEGHonCJ+xp0+fsn79ejZv3kzbtm0BCA4OllvC+tq1awDY2NhIx+7du4eFhYX0fs6cOXJLeL/PxMSEhQsXIpPJsLGx4dKlSyxcuJCBAwfmmf7dRR3MzMz45ZdfGDJkCMuXLwcgNTWVbt26Ua9ePQC5tuT45ZdfaNGiBQD9+/dnwoQJJCcnS2m/++47jh49yrhx44DsZc7ftW7dOgwNDYmPj89zAuzTp08JCgpi6dKl9O3bF4BatWrRsmVLALZu3UpWVhZr1qyRAsng4GD09fWJjIzkm2++yfd+CYIgCEJ5JIbeCYLw2bhx4wavX7+madOm0jE9PT25oCgvlSpVIjY2ltjYWPT19QvtIfnqq6/k/ng6Ojpy/fp1ac+h9x0+fJi2bdtSvXp1dHR06NOnDw8ePJCGyg0bNkwKhKZMmZLn8uXvDgc0MjJCU1NTLqAyMjLi3r170vvr16/Tq1cvLCws0NXVxczMDMgOyvKSkJBARkaGFGC+Ly4ujqSkJHR0dNDW1kZbWxsDAwNevnxZ6JC+vGRkZPDvv//KvUTPlCAIglCWfGmLOYhASRC+cFZWVgAkJiZKx5SVlbG0tMTS0hIVlZLteE5JSaFz587Ur1+fHTt2cO7cOZYtWwYgBQYDBgzgxo0b9OnTh0uXLtG4cWO5YXQAFSpUkP4tk8nk3ucce3dYnZubGw8fPmT16tWcOXOGM2fOyNX5Pg0NjQKvIz09nUaNGkkBZc7r2rVr9O7dW8G78T+BgYHo6enJvQoavigIgiAIwsclAiVB+IxZWFhQoUIFYmJipGNPnjyRhttB9op4tWvXZt68eQXO1ylITtCR4/Tp01hZWaGsrJwr7blz58jKymL+/Pl89dVXWFtb8/fff+dKZ2JiwpAhQ9i5cyejR49m9erVxWobwIMHD0hMTGTSpEm0bdsWW1tbHj16VGAeKysrNDQ0iIiIyPN8w4YNuX79OlWqVJGCypyXnp5ekds4YcIEnjx5IvcaMGBAkcsRBEEQhI9F9CgJgvDZ0NHRoW/fvowZM4ajR49y5coV+vfvj5KSkvSHSiaTERwcTGJiIi1atGDv3r1cv36d+Ph4Vq5cyf379/MMeN6VmprKqFGjSExMZMuWLSxZsoThw4fnmdbS0pLXr1+zZMkSbty4wcaNG1m5cqVcmhEjRnDgwAFu3rzJ+fPnOXr0KLa2ii/f+r6KFStSqVIlfv31V5KSkjhy5AijRo0qMI+6ujrjxo1j7NixbNiwgeTkZE6fPs3atdmb7Xl5eVG5cmXc3d05fvw4N2/eJDIykmHDhvHXX38VuY1qamro6urKvVRVVYt1vYIgCILwMYhASRCEz8qCBQtwdHSkc+fOtGvXjhYtWmBra4u6urqU5quvvuLcuXPY2NgwdOhQ6tSpQ/PmzdmyZQsLFy7kxx9/LLAOb29vXrx4QdOmTRk6dCjDhw9n0KBBeaa1t7dnwYIFzJ49m7p167Jp0yYCAwPl0mRmZjJ06FBsbW1xdXXF2tpaWuihOJSUlAgNDeXcuXPUrVuXkSNHMnfu3ELz+fv7M3r0aCZPnoytrS09evSQ5j1pamry559/YmpqSteuXbG1taV///68fPkSXV3dYrdVEARBEISyQax6JwifmZCQELn3Ojo6bNq0SXr/7NkzAgICcgUy1tbWufIqqkKFCixatIgVK1bkef79vYVGjhzJyJEj5Y716dNH+vf785He5ezsnGuPJh8fH3x8fOSOTZ06lalTp0rv27VrR3x8vFyawjbLVVJSYuLEiUycODHP81WrVmX9+vX55n//fkZGRhZYnyAIgiCUaeWnM6hEyN4W9k1BEIRy7cKFC1y9epWmTZvy5MkTpk2bRmRkJElJSVSuXPmDy3d2dqZBgwYsWrTowxubj8jISNq0acOjR4/Q19cnJCSEESNG8Pjx4w8qd+rUqaxYsYJ79+6xa9cuPDw8SqS9JeXy5dLZaV0QBEEo//La6qKk6Xv9ViLlPN70fYmU87GJoXeC8AWYN28e9vb2tGvXjmfPnnH8+PEiBUk+Pj7IZDKGDBmS69z169cJCgrK1aNT1iUkJBAQEMCqVatIS0ujQ4cOH60uHx+fMheECYIgCIJQMDH0ThA+cw4ODpw7d+6DyzExMSE0NJSFCxdKS2e/fPmS58+fY2pq+sHll7acvY7c3d3L9MRSy9qK/0KYdPVymczzIXW0mHlB4TxR/3Eodj1l9fpLK09NyzoK57mVFF+kesrD9VvY2Cmc50bilSLVk1NHLRvF25WcWPbv2ef0/D+n6//YyvL/Lz8G0aMkCIJCGjZsiImJCTt37pSO7dy5E1NTUxwcHArNHxUVhbOzM5qamlSsWBEXFxdpie6srCwCAwMxNzdHQ0MDe3t7fv/99w9q76VLl/j666/R0NCgUqVKDBo0iPT0dCB7yJ2bmxuA3AqAedm7dy9WVlaoq6vTpk0b1q9fj0wmk4b9TZ06lQYNGsjlWbRokbSh7dSpU1m/fj179uyRVvsRc5UEQRCE8kiseicIgpCPfv36ERwcLL1ft24dP/zwQ6H5YmNjadu2LXXq1OHUqVOcOHECNzc3MjMzgezNVjds2MDKlSu5cuUKI0eO5Pvvv+fYsWPFauezZ89wcXGhYsWKxMTEsH37dg4fPoyvry8Afn5+0nWkpaWRlpaWZzk3b97ku+++w8PDg7i4OAYPHpzvwg758fPzw9PTE1dXV6mu5s2bF+u6BEEQBEEoPWLonSAICvv++++ZMGECt27dArJ7iUJDQwvtIZkzZw6NGzeWW+Lbzi57qEtGRgYzZ87k8OHDODo6Atkb5Z44cYJVq1bh5ORU5HZu3ryZly9fsmHDBrS0tABYunQpbm5uzJ49GyMjI/T19YHslevys2rVKmxsbKSlxG1sbLh8+TIzZsxQuC3a2tpoaGiQkZFRYF2CIAiCUNaVp96gkiACJUEQFGZoaEinTp0ICQnh7du3dOrUSaFFIWJjY+nevXue55KSknj+/Dnt27eXO/7q1SuFhvTlJSEhAXt7eylIAmjRogVZWVkkJiZiZGSkUDmJiYk0adJE7ljTpk2L1abCZGRkkJGRIXfs1atXH6UuQRAEQSiWLytOEoGSIAhF069fP2kI27JlyxTKk7P4Q15y5g2FhYVRvXp1uXNqamrFbGXpUVJSyrUf0+vXr4tcTmBgIAEBAXLHfvzxRxYsLv5Gu4IgCIJQkr60HiUxR0kQhCJxdXXl1atXvH79GhcXF4Xy1K9fn4iIiDzP1alTBzU1NVJTU7G0tJR7mZiYFKuNtra2xMXF8ezZM+lYVFQUSkpK2NjYKFyOjY0NZ8+elTsWExMj997Q0JA7d+7IBUuxsbFyaVRVVaX5WPmZMGECT548kXsNGDBA4bYKgiAIglCyRKAkCEKRKCsrk5CQQHx8PMrKygrlmTBhAjExMfz0009cvHiRq1evsmLFCv755x90dHTw8/Nj5MiRrF+/nuTkZM6fP8+SJUtYv359sdro5eWFuro6ffv25fLlyxw9epSff/6ZPn36KDzsDmDw4MFcvXqVcePGce3aNbZt20ZISAjwv1/VnJ2duX//PnPmzCE5OZlly5axf/9+uXLMzMy4ePEiiYmJ/PPPP3n2OKmpqaGrqyv3UlVVLdb1C4IgCMLHIFa9EwRBKETOF3lFWVtbc/DgQeLi4mjatCmOjo7s2bMHFZXs0b/Tp0/H39+fwMBAbG1tcXV1JSwsDHNz82K1T1NTkwMHDvDw4UOaNGnCd999R9u2bVm6dGmRyjE3N+f3339n586d1K9fnxUrVkir3uUMC7S1tWX58uUsW7YMe3t7oqOj8fPzkytn4MCB2NjY0LhxYwwNDYmKiirWdQmCIAjCp/SlBUpijpIgCIXK6UXJz+7duwstw8nJKd8AQSaTMXz4cIYPH57neWdnZ7mhbT4+Pvj4+BRYX7169Thy5Ei+5z08PHLNLcpLly5d6NKli/R+xowZ1KhRA3V1denYkCFDGDJkiFy+//znP9K/DQ0NOXjwYKF1CYIgCIKQt2XLljF37lzu3LmDvb09S5YsKXCBpUWLFrFixQpSU1OpXLky3333HYGBgXL//y6M7K0i3xQEQSiy58+f06dPHw4dOsTTp0959OiRtCR1fkJCQhgxYoTcZqa7d++W5rz4+Pjw+PFjhQITRbxfX0lydnamQYMGLFq0qNhlvH/9n8Ly5ctp0qQJlSpVIioqip9//hlfX19++eWXQvPKZDJ27dqFh4cHKSkpmJubc+HChVwb1Obn8uXS2WldEARBKP/q1q370euo0n9biZRzb61nkdJv3boVb29vVq5cSbNmzVi0aBHbt28nMTGRKlWq5Eq/efNm+vXrx7p162jevDnXrl3Dx8eHnj17smDBAoXrFT1KglCIwrqIp0yZwtSpU3MdX79+PcePH+fkyZNUrlwZPT29D25LUFCQQr0gQsm5fv06v/zyCw8fPsTU1JTRo0czYcKET90sQRAEQSh1n2rY3IIFCxg4cKC0yf3KlSsJCwtj3bp1jB8/Plf6kydP0qJFC3r37g1kzxXu1asXZ86cKVK9IlAShEKkpaVJ/966dSuTJ08mMTFROqatrZ1nvuTkZGxtbUv0F56SCLZK2qtXr8r1ogNv374lMzNTmi/1voULF7Jw4cJSbtX/WNZW/POTdDW7B6qmZR2F89xKii92PYrmKWr6D83TZNJJhfPE/NL8o7ettK+/rOUpq+0qrTxltV2llaestutD8yj6d7Y0/sa+m6e8yGvvQDU1tTy3BXn16hXnzp2T+5FSSUmJdu3acerUqTzLb968Ob/99hvR0dE0bdqUGzdu8Mcff9CnT58itVMs5iAIhahatar00tPTQyaTyR3LK1BydnZm/vz5/Pnnn8hkMpydnQF49OgR3t7eVKxYEU1NTTp06MD169cVbouPjw8eHh7S+6ysLObMmYOlpSVqamqYmpoyY8YMACIjI5HJZHLD6mJjY5HJZKSkpORZfnJyMu7u7hgZGaGtrU2TJk04fPiwXBozMzOmT5+Ot7c3urq6DBo0KN/2ZmVlMXbsWAwMDKhatWqunrfHjx8zYMAADA0N0dXV5euvvyYuLq7Q6w8ICJDyDBkyRG5j1qysLAIDAzE3N0dDQwN7e3t+//136XzOfdm/fz+NGjVCTU2NEydO5FnfX3/9Ra9evTAwMEBLS4vGjRvL/Rq1Z88eGjZsiLq6OhYWFgQEBPDmzZt82y8IgiAI5VlJLeYQGBiInp6e3CswMDDPOv/55x8yMzNzrVprZGTEnTt38szTu3dvpk2bRsuWLalQoQK1atXC2dlZbv6wIkSgJAgfwc6dOxk4cCCOjo6kpaWxc+dOIPuL/tmzZ9m7dy+nTp3i7du3dOzYsVgblEL2stuzZs3C39+f+Ph4Nm/eXKTlr9+Xnp5Ox44diYiI4MKFC7i6uuLm5kZqaqpcunnz5mFvb8+FCxfw9/fPt7z169ejpaXFmTNnmDNnDtOmTePQoUPS+e7du3Pv3j3279/PuXPnaNiwIW3btuXhw4f5lhkREUFCQgKRkZFs2bKFnTt3ym3UGhgYyIYNG1i5ciVXrlxh5MiRfP/99xw7dkyunPHjxzNr1iwSEhKoX79+nvfCycmJ//73v+zdu5e4uDjGjh1LVlYWAMePH8fb25vhw4cTHx/PqlWrCAkJkQJVQRAEQfjclFSglNfegSU5rD0yMpKZM2eyfPlyzp8/z86dOwkLC2P69OlFKkcMvROEj8DAwABNTU1UVVWpWrUqkD3XZe/evURFRdG8efZwn02bNmFiYsLu3bvp3r17kep4+vQpQUFBLF26lL59+wJQq1YtWrZsWex229vbY29vL72fPn06u3btYu/evfj6+krHv/76a0aPHl1oefXr12fKlCkAWFlZsXTpUiIiImjfvj0nTpwgOjqae/fuSV3t8+bNY/fu3fz+++/59lSpqqqybt06NDU1sbOzY9q0aYwZM4bp06fz+vVrZs6cyeHDh3F0dATAwsKCEydOsGrVKpycnKRypk2bRvv27fNt++bNm7l//z4xMTEYGBgAYGlpKZ0PCAhg/Pjx0r23sLBg+vTpjB07VrpmQRAEQRByy2+YXV4qV66MsrIyd+/elTt+9+5d6TvW+/z9/enTp4+0cXu9evV49uwZgwYNYuLEiSgpKdZXJAIlQSglCQkJqKio0KxZM+lYpUqVsLGxISEhoVjlZWRk0LZt2xJrY3p6OlOnTiUsLIy0tDTevHnDixcvcvUoNW7cWKHy3u+pMTY25t69ewDExcWRnp5OpUqV5NK8ePGC5OTkfMu0t7dHU1NTeu/o6Eh6ejq3b98mPT2d58+f5wqAXr16hYODQ5GuITY2FgcHBylIel9cXBxRUVFyPUiZmZm8fPmS58+fy7VREXmN1353SKEgCIIgfGqfYjEHVVVVGjVqREREhDT9ICsri4iICLkfcd/1/PnzXMGQsrIyQJEWxRKBkiCUUxoaGgWez/kD8e4fhMKG+Pn5+XHo0CHmzZuHpaUlGhoafPfdd7m+sGtpaSnUxgoVKsi9l8lk0tC19PR0jI2NiYyMzJWvsGXU85Oeng5AWFgY1atXlzv3/i9XhV1DYfc3PT2dgIAAunbtmutcUfZoyBEYGCg3hBDgxx9/ZMHi5UUuSxAEQRA+ik+0V+yoUaPo27cvjRs3pmnTpixatIhnz55Jq+B5e3tTvXp1aZ6Tm5sbCxYswMHBgWbNmpGUlIS/vz9ubm5SwKQIESgJQimxtbXlzZs3nDlzRhp69+DBAxITE6lTR/FVynJYWVmhoaFBRESE1LX8LkNDQyB71b6KFSsCFLofUVRUFD4+Pnz77bdAdjCQ38IPH6phw4bcuXMHFRUVzMzMFM4XFxfHixcvpEDm9OnTaGtrY2JigoGBAWpqaqSmpsoNsyuO+vXrs2bNGh4+fJhnr1LDhg1JTEyUG473ISZMmMCoUaPkjiUlJZVI2YIgCIJQEj7V8uA9evTg/v37TJ48mTt37tCgQQPCw8OledmpqalyPUiTJk1CJpMxadIk/vvf/2JoaIibm1uR5xGLQEkQSomVlRXu7u4MHDiQVatWoaOjw/jx46levTru7u5FLk9dXZ1x48YxduxYVFVVadGiBffv3+fKlSv0798fS0tLTExMmDp1KjNmzODatWvMnz+/0Dbu3LkTNzc3ZDIZ/v7+Ug9QSWvXrh2Ojo54eHgwZ84crK2t+fvvvwkLC+Pbb7/Nd2jcq1ev6N+/P5MmTSIlJYUpU6bg6+uLkpISOjo6+Pn5MXLkSLKysmjZsiVPnjwhKioKXV1daT6RInr16sXMmTPx8PAgMDAQY2NjLly4QLVq1XB0dGTy5Ml07twZU1NTvvvuO5SUlIiLi+Py5csKbUb7vrzGa5fnZdcFQRAEoST5+vrmO9Tu/dEpKioqTJky5YPnDItV7wShFAUHB9OoUSM6d+6Mo6Mjb9++5Y8//sg1RE1R/v7+jB49msmTJ2Nra0uPHj2kOUAVKlRgy5YtXL16lfr16zN79uxCv8AvWLCAihUr0rx5c9zc3HBxcaFhw4bFalthZDIZf/zxB61bt+aHH37A2tqanj17cuvWrQJX7mvbti1WVla0bt2aHj160KVLF7llx6dPn46/vz+BgYHY2tri6upKWFgY5ubmRWqfqqoqBw8epEqVKnTs2JF69eoxa9YsqcvexcWFffv2cfDgQZo0acJXX33FwoULqVmzZrHuhyAIgiCUdSW16l15IXtblBlNgiAIn5CPjw+PHz9m9+7dn7oppeLy5fK1gaAgCILw6ZTkBvf5MRm6p0TKub2s6CNpPoUy0aMkk8nK7BefvDbt/FKFhIQoNMm+rD7PorbrYz77snqPSktKSgoymUyaM1Wce/3+5ruCIAiCIAglqVTnKE2dOpXdu3fnmlD+7mTzkhAZGUmbNm149OhRsVfPKqoLFy4wc+ZM/vzzT548eYKJiQnOzs6MGTMGa2trUlJS5Ib+aGtrY2pqirOzMyNGjMDKyirPcqOionBycqJu3bqFTsT/2Hr06EHHjh2l96X1PIW8lUTvSkhIiLRiTH5u3rxZpMUWhJJlWVvxXwiTrmb3QJlZ2SmcJ+X6FQCqW9gqnOe/NxKK1LacdhXnWkorT5OxEQrniZnTtkj1lIfr/5h5PqQOc2vFP8s3r10pdj1l9fo/hzxltV0fmqeyqY1C6f9JTSzVdn105WfUXIkoEz1KVatWVXjTqbJo3759fPXVV2RkZLBp0yYSEhL47bff0NPTw9/fXy7t4cOHSUtLIy4ujpkzZ5KQkIC9vT0REbn/J/348WO8vb1LdJ+cD6GhoUGVKlUKTVfen+eXpEePHqSlpUkvR0dHBg4cKHfMxMTkUzdTEhIS8kX3xAmCIAjCp/SlzVEqUqAUHh5Oy5Yt0dfXp1KlSnTu3DnXxpB//fUXvXr1wsDAAC0tLRo3bsyZM2cICQkhICCAuLg46SaFhIQA8sOQmjdvzrhx4+TKvH//PhUqVODPP/8EYOPGjTRu3BgdHR2qVq1K7969pQnsKSkptGnTBoCKFSsik8nw8fEBsjenCgwMxNzcHA0NDezt7fn999/l6vrjjz+wtrZGQ0ODNm3aFLo08vPnz/nhhx/o2LEje/fupV27dpibm9OsWTPmzZvHqlWr5NJXqlSJqlWrYmFhgbu7O4cPH6ZZs2b079+fzMxMubRDhgyhd+/eODo6FtiGHGZmZkyfPp1evXqhpaVF9erVWbZsmVya1NRU3N3d0dbWRldXF09PT7mdjuPi4mjTpg06Ojro6urSqFEjzp49C8gPvSvJ55mRkYGfnx/Vq1dHS0uLZs2a5bm3TkFiYmJo3749lStXRk9PDycnJ86fP59v+pyhX6GhoTRv3hx1dXXq1q3LsWPHcqU9d+4cjRs3RlNTk+bNm5OYmCidS05Oxt3dHSMjI7S1tWnSpAmHDx9WqM1paWl06NABDQ0NLCwscn0Wb9++jaenJ/r6+hgYGODu7i59HqdOncr69evZs2ePdP9z7tm4ceOwtrZGU1MTCwsL/P39890/SUNDg6pVq0ovVVVVNDU15Y7lt9/AlStX6Ny5M7q6uujo6NCqVSu5vwdr1qzB1tYWdXV1ateuzfLlH2c/oHnz5mFsbEylSpUYOnSo3LXmNcRRX19f+qzmfA62bdtGq1at0NDQoEmTJly7do2YmBgaN26MtrY2HTp04P79+1IZinzeZDIZa9as4dtvv0VTUxMrKyv27t37Ue6BIAiCIAglr0iB0rNnzxg1ahRnz54lIiICJSUlvv32W7kNJJ2cnPjvf//L3r17iYuLY+zYsWRlZdGjRw9Gjx6NnZ2d9Et1jx49ctXh5eVFaGio3CaZW7dupVq1arRq1QrI3jRz+vTpxMXFsXv3blJSUqRgyMTEhB07dgCQmJhIWloaQUFBQPaGjhs2bGDlypVcuXKFkSNH8v3330tfjm/fvk3Xrl1xc3MjNjaWAQMGMH78+ALvyYEDB/jnn38YO3ZsnucLG/qnpKTE8OHDuXXrFufOnZOOBwcHc+PGjSIvazh37lzs7e25cOEC48ePZ/jw4Rw6dAjIDhTd3d15+PAhx44d49ChQ9y4cUPuOXh5eVGjRg1iYmI4d+4c48ePz3NFtpJ8nr6+vpw6dYrQ0FAuXrxI9+7dcXV15fr16wpf99OnT+nbty8nTpzg9OnTWFlZ0bFjR54+fVpgvjFjxjB69GguXLiAo6Mjbm5uPHjwQC7NxIkTmT9/PmfPnkVFRYV+/fpJ59LT0+nYsSMRERFcuHABV1dX3NzcSE1NLbTN/v7+dOvWjbi4OLy8vOjZsycJCdlDml6/fo2Liws6OjocP36cqKgotLW1cXV15dWrV/j5+eHp6Ymrq6t0/3P2ZtLR0SEkJIT4+HiCgoJYvXo1CxcuVPheKuK///0vrVu3Rk1NjSNHjnDu3Dn69evHmzdvANi0aROTJ09mxowZJCQkMHPmTPz9/Vm/fn2JtuPo0aMkJydz9OhR1q9fT0hIiBQEFcWUKVOYNGkS58+fR0VFhd69ezN27FiCgoI4fvw4SUlJTJ48WUqv6OctICAAT09PLl68SMeOHfHy8uLhw4cfetmCIAiC8El8aT1KRZqj1K1bN7n369atw9DQkPj4eOrWrcvmzZu5f/8+MTEx0gaN727GqK2tjYqKClWrVs23Dk9PT0aMGMGJEyekL9KbN2+mV69e0o1994uqhYUFixcvpkmTJqSnp6OtrS3VXaVKFSlQycjIYObMmRw+fFjqobGwsODEiROsWrUKJycnVqxYQa1ataS9ZmxsbLh06RKzZ8/Ot705X+Zr165d+A3MR07elJQUmjZtyvXr1xk/fjzHjx9HRaVo08hatGghBXfW1tZERUWxcOFC2rdvT0REBJcuXeLmzZvScKoNGzZgZ2dHTEwMTZo0ITU1lTFjxkhtym/ulIaGRok8z9TUVIKDg0lNTaVatWoA+Pn5ER4eTnBwMDNnzlTour/++mu597/++iv6+vocO3aMzp0755vP19dX+lyvWLGC8PBw1q5dKxf4zpgxQ9q8dPz48XTq1ImXL1+irq6Ovb099vb2Utrp06eza9cu9u7dm+9a/zm6d+8ubRQ7ffp0Dh06xJIlS1i+fDlbt24lKyuLNWvWSJ/74OBg9PX1iYyM5JtvvkFDQ4OMjIxc93/SpEnSv83MzPDz8yM0NDTfYL44li1bhp6eHqGhoVIgbW1tLZ2fMmUK8+fPp2vXrgCYm5sTHx/PqlWrirSXUWEqVqzI0qVLUVZWpnbt2nTq1ImIiAgGDhxYpHL8/PxwcXEBYPjw4fTq1YuIiAhatGgBQP/+/eUCMEU/bz4+PvTq1QuAmTNnsnjxYqKjo3F1dc3VhoyMDDIyMuSOvXr1qkjXIQiCIAgfU3kKckpCkXqUrl+/Tq9evbCwsEBXV1ea4J3z63lsbCwODg557mKvKENDQ7755hs2bdoEZE8kP3XqFF5eXlKac+fO4ebmhqmpKTo6OtKX2IJ+xU9KSuL58+e0b98ebW1t6bVhwwZpuFBCQgLNmjWTy1fYsLeSWF09pwyZTEZmZia9e/cmICBA7ovnuzZt2iR3DcePH8+3vY6OjlIvRUJCAiYmJnJzTurUqYO+vr6UZtSoUQwYMIB27doxa9asXEMri6qw53np0iUyMzOxtraWu6Zjx44Vqe67d+8ycOBArKys0NPTQ1dXl/T09EJ7dt69XyoqKjRu3Fi6Fznq168v/dvY2BhAGuqZnp6On58ftra26Ovro62tTUJCglTvzJkz5a7r3fYU9Kzi4uJISkpCR0dHymtgYMDLly8LvS9bt26lRYsWVK1aFW1tbSZNmqRQD1dRxMbG0qpVqzx7G589e0ZycjL9+/eXu/Zffvnlgz9P77Ozs5MbGmhsbCw9m6J49xnn7OFUr149uWPvlqvo5+3dcrW0tNDV1c23fYGBgejp6cm91qxZU+RrEQRBEAShZBSpu8LNzY2aNWuyevVqqlWrRlZWFnXr1pV+9dTQ0CiRRnl5eTFs2DCWLFnC5s2bqVevnvSl5dmzZ7i4uODi4sKmTZswNDQkNTUVFxeXAn99TU9PByAsLIzq1avLnfuQhQdygpmrV68qPJfofTlfjs3NzXn69Clnz57lwoULUo9EVlYWb9++RUVFhYMHD9KlSxe5gO796/kQU6dOpXfv3oSFhbF//36mTJlCaGgo3377bbHLLOh5pqeno6yszLlz53LNhdHW1la4jr59+/LgwQOCgoKoWbMmampqODo6lsgv8u8GAzm/pOQMN/Xz8+PQoUPMmzcPS0tLNDQ0+O6776R6hwwZgqenp5Q/p9esMOnp6TRq1EgKMN9laGiYb76cIDQgIAAXFxep1yenl7SkFPTfes5/a6tXr871w0N+852K6/1ATSaTSc8m5/37P2bkNV8rr2f8/rF3y1X081ZY+941YcIERo0aJXcsKSkpz7SCIAiC8Cl8aT1KCgdKDx48IDExkdWrV0tDqE6cOCGXpn79+qxZs4aHDx/m2aukqqqaa8GCvLi7uzNo0CDCw8PZvHkz3t7e0rmrV6/y4MEDZs2aJfWM5Cw28G49gFxdderUQU1NjdTUVKkH6n22tra5JlufPn26wLZ+8803VK5cmTlz5rBr165c5x8/flzgPKWsrCwWL16Mubk5Dg4OyGQyLl26JJdm+fLlHDlyhN9//x1zc3O0tLTQ0dHJs7z323v69GlsbW2l67t9+za3b9+W7l18fDyPHz+mTp06Uh5ra2usra0ZOXIkvXr1Ijg4OM9AqSSep4ODA5mZmdy7d0/6XBVHVFQUy5cvl5Yvv337Nv/880+h+U6fPk3r1q0BePPmDefOnSt0yNz79fr4+Ej3Jz09XW4BEAMDg3x7WE+fPi13L06fPo2DgwMADRs2ZOvWrVSpUgVdXd088+d1/0+ePEnNmjWZOHGidOzWrVsKX4+i6tevz/r163n9+nWuYMDIyIhq1apx48YNuZ7gT8HQ0JC0tDTp/fXr13n+/PkHl1vcz1tB1NTUcv1ok/O3TBAEQRDKhC8rTlJ86F3FihWpVKkSv/76K0lJSRw5ciTXr5+9evWiatWqeHh4EBUVxY0bN9ixYwenTp0CsudL3Lx5k9jYWP75559c4/FzaGlp4eHhgb+/PwkJCdIYfwBTU1NUVVVZsmQJN27cYO/evUyfPl0uf82aNZHJZOzbt4/79++Tnp6Ojo4Ofn5+jBw5kvXr15OcnMz58+dZsmSJNMF8yJAhXL9+nTFjxpCYmMjmzZsLnRiupaXFmjVrCAsLo0uXLhw+fJiUlBTOnj3L2LFjGTJkiFz6Bw8ecOfOHant7dq1Izo6mrVr16KsrIySkhJ169aVe1WpUkValU1LS6vA9kRFRTFnzhyuXbvGsmXL2L59O8OHDwegXbt21KtXDy8vL86fP090dDTe3t44OTnRuHFjXrx4ga+vL5GRkdy6dYuoqChiYmKkQOt9JfE8ra2t8fLywtvbm507d3Lz5k2io6MJDAwkLCyswGt9l5WVFRs3biQhIYEzZ87g5eWlUA/nsmXL2LVrF1evXmXo0KE8evRIbg6cIvXu3LmT2NhY4uLi6N27d749Bu/bvn0769at49q1a0yZMoXo6GgpSPPy8qJy5cq4u7tz/Phxbt68SWRkJMOGDeOvv/4Csu//xYsXSUxM5J9//uH169dYWVmRmppKaGgoycnJLF68OM8A/kP5+vry77//0rNnT86ePcv169fZuHGjtCJgQEAAgYGBLF68mGvXrnHp0iWCg4NZsGBBibelIF9//TVLly7lwoULnD17liFDhuQ5XLCoivt5EwRBEITy7EtbzEHhQElJSYnQ0FDOnTtH3bp1GTlyJHPnzpVLo6qqysGDB6lSpQodO3akXr16zJo1Sxpu061bN1xdXWnTpg2GhoZs2bIl3/q8vLyIi4ujVatWmJqaSscNDQ0JCQlh+/bt1KlTh1mzZjFv3jy5vNWrVycgIIDx48djZGQkffmcPn06/v7+BAYGYmtri6urK2FhYdJGsKampuzYsYPdu3djb2/PypUrFVpMwN3dnZMnT1KhQgV69+5N7dq16dWrF0+ePOGXX36RS9uuXTuMjY2pV68e48ePx9bWlosXL0pLmn+o0aNHc/bsWRwcHPjll19YsGCBNEldJpOxZ88eKlasSOvWrWnXrh0WFhZs3boVyB4W9eDBA7y9vbG2tsbT05MOHToQEBCQZ10l8Twhe5ECb29vRo8ejY2NDR4eHsTExMile3f58bysXbuWR48e0bBhQ/r06cOwYcMU2vNp1qxZzJo1C3t7e06cOMHevXupXLlyoflyLFiwgIoVK9K8eXPc3NxwcXGhYcOGCuUNCAggNDSU+vXrs2HDBrZs2SL17GlqavLnn39iampK165dsbW1pX///rx8+VLqYRo4cCA2NjY0btwYQ0NDoqKi6NKlCyNHjsTX15cGDRpw8uTJXHt5lYRKlSpx5MgRaaXLRo0asXr1aikIGTBgAGvWrCE4OJh69erh5ORESEiI3KbLhSnsmSti/vz5mJiY0KpVK3r37o2fnx+ampofVCYU//MmCIIgCEL5IXtbEqsRCGWCmZkZI0aMYMSIEZ+6KSXq5s2bWFtbEx8fn+8qfEWVkpKCubk5Fy5coEGDBiVSplByPsYzL48uXy6lndYFQRCEcq9u3bofvY5ao/eXSDnJ8zuUSDkfW5FWvROET+GPP/5g0KBBn+UXZjMzMxYtWlSqdeZsshobG1ukfKXVVmdnZ/r161fgM1f0GpydnT/pDwfv1/8pnrcgCIIglBSZrGRe5UXRNukRhE9g6NChn7oJHywkJIQRI0bw+PFjueMxMTGFzjv7Etnb2xcYUJiYmJCWliYNk4yMjKRNmzY8evRIbvGUnTt3lsicpE/JsrbivxAmXb1cJvOU1XZ9aJ6WgbEKpT8xoQEARjUV32/v7q2rxW5XWctT2u2qbpH3vNq8/PdGwkdvW1l9Lu/m0TFW/IfIp2nXi1RPebj+z+n5CyVLBEqfkXdXWxMKZmZmViJ7YH2ogpb6FvL26tUrVFVVC9zoOMeH7OkmCIIgCIK88rQQQ0kQQ++EMi0rK4s5c+ZgaWmJmpoapqamzJgxQzp/6dIlvv76azQ0NKhUqRKDBg2S9vEB8PHxwcPDg3nz5mFsbEylSpUYOnSotJfOf/7zn1x7/UB2j8a0adOk92vWrMHW1hZ1dXVq167N8uXLpXM5w8B27txJmzZt0NTUxN7eXlrtMTIykh9++IEnT55Iq71MnToVyD0UKzU1FXd3d7S1tdHV1cXT05O7d+9K56dOnUqDBg3YuHEjZmZm6Onp0bNnT54+fSqlCQ8Pp2XLlujr61OpUiU6d+5c5I1e7927h5ubGxoaGpibm+e5n9Pjx48ZMGAAhoaG6Orq8vXXXxMXF1ektj579gxvb2+0tbUxNjbOc78nMzMzpk+fjre3N7q6ugwaNEhu6F1KSoq0GErFihWRyWT4+PgAuYe+ZWRkMG7cOExMTFBTU8PS0pK1a9fmex8KS3/58mU6dOiAtrY2RkZG9OnT54OXCRcEQRCEsupLG3onAiWhTJswYQKzZs3C39+f+Ph4Nm/ejJGREfC/zYcrVqxITEwM27dv5/Dhw7n2QTp69CjJyckcPXqU9evXExISIq2m5uXlRXR0tFwgceXKFS5evEjv3r0B2LRpE5MnT2bGjBkkJCQwc+ZM/P39pWXlc0ycOBE/Pz9iY2OxtramV69evHnzhubNm7No0SJ0dXVJS0sjLS0NPz+/XNealZWFu7s7Dx8+5NixYxw6dIgbN27Qo0cPuXTJycns3r2bffv2sW/fPo4dO8asWbOk88+ePWPUqFGcPXuWiIgIlJSU+PbbbxVethyyA8zbt29z9OhRfv/9d5YvX869e/fk0nTv3p179+6xf/9+zp07R8OGDWnbti0PHz5UuK1jxozh2LFj7Nmzh4MHDxIZGcn58+dztWfevHnY29tz4cKFXKv4mZiYsGPHDgASExNJS0sjKCgoz+vy9vZmy5YtLF68mISEBFatWlXgxsYFpX/8+DFff/01Dg4OnD17lvDwcO7evSu3wbAgCIIgCOWXGHonlFlPnz4lKCiIpUuX0rdvXwBq1apFy5YtAdi8eTMvX75kw4YN0jyfpUuX4ubmxuzZs6WAqmLFiixduhRlZWVq165Np06diIiIYODAgdjZ2WFvb8/mzZulL+CbNm2iWbNmWFpaAjBlyhTmz59P165dATA3Nyc+Pp5Vq1ZJ7QLw8/OjU6dOQPbS33Z2diQlJVG7dm309PSQyWQFDheLiIjg0qVL3Lx5U9oQeMOGDdjZ2RETE0OTJk2A7IAqJCRE2nS4T58+RERESD1t3bp1kyt33bp1GBoaEh8fr9CKONeuXWP//v1ER0dLda5du1ZuP60TJ04QHR3NvXv3pE1S582bx+7du/n9998ZNGhQoW1NT09n7dq1/Pbbb7Rt2xaA9evXU6NGjVxt+vrrrxk9erT0/t1hpsrKytIQuypVquS7wfO1a9fYtm0bhw4dol27dgBYWFgUeB8KSr906VIcHBzkthBYt24dJiYmXLt2DWtr63zLzktGRkauvchevXpVpDIEQRAE4WMSQ+8EoYxISEggIyND+hKd13l7e3u5xRBatGhBVlaWtPEpgJ2dnbSXF4CxsbFc74iXlxebN28G4O3bt2zZsgUvLy8gu3cmOTmZ/v37o62tLb1++eWXXMPZ6tevL1cHkKsXprDrNTExkYIkgDp16qCvr09CQoJ0zMzMTAo88rqe69ev06tXLywsLNDV1cXMzAzIHtanaDtUVFRo1KiRdKx27dpyAUhcXBzp6elUqlRJ7r7cvHlT7r4U1Nbk5GRevXolN/TRwMAAGxubXG1q3LixQm0vSGxsLMrKyjg5OZVI+ri4OI4ePSp3/bVrZ0/WL+pQR4DAwED09PTkXmvWrClyOYIgCILwsXxpQ+9Ej5JQZmloaJRIOe+veiaTyeSGofXq1Ytx48Zx/vx5Xrx4we3bt6XhbjnznVavXp1rLtO7wdf79eT84lKU4W6KKux63NzcqFmzJqtXr6ZatWpkZWVRt27dEu2dSE9Px9jYmMjIyFzn3g2oCmurokpiZcCifp4KS5+eni71Xr4vJ1AuigkTJjBq1Ci5Y0lJSUUuRxAEQRCEkiECJaHMsrKyQkNDg4iICAYMGJDrvK2tLSEhITx79kz6Ih0VFYWSklKevRL5qVGjBk5OTmzatIkXL17Qvn17qlSpAoCRkRHVqlXjxo0bUi9TcaiqqpKZmVlgGltbW27fvs3t27elXqX4+HgeP35MnTp1FKrnwYMHJCYmsnr1alq1agVkD5Mritq1a/PmzRvOnTsnDb1LTEyUW9q8YcOG3LlzBxUVFanHqqhq1apFhQoVOHPmDKampgA8evSIa9euKdzrk0NVVRWgwHtcr149srKyOHbsmDSUriCFpW/YsCE7duzAzMwMFZUP/1OqpqYmDWPMkXNdgiAIglAWKCmVo+6gEiCG3glllrq6OuPGjWPs2LFs2LCB5ORkTp8+La065uXlhbq6On379uXy5cscPXqUn3/+mT59+kjzkxTl5eVFaGgo27dvzxUQBQQEEBgYyOLFi7l27RqXLl0iODiYBQsWKFy+mZkZ6enpRERE8M8///D8+fNcadq1a0e9evXw8vLi/PnzREdH4+3tjZOTk8JDzypWrEilSpX49ddfSUpK4siRI7l6KQpjY2ODq6srgwcP5syZM5w7d44BAwbI9bC0a9cOR0dHPDw8OHjwICkpKZw8eZKJEydy9uxZherR1tamf//+jBkzhiNHjnD58mV8fHxQUir6n6WaNWsik8nYt28f9+/fl1v5MIeZmRl9+/alX79+7N69m5s3bxIZGcm2bdvyLLOw9EOHDuXhw4f06tWLmJgYkpOTOXDgAD/88EOhQbEgCIIglEdf2tA7ESgJZZq/vz+jR49m8uTJ2Nra0qNHD2mOi6amJgcOHODhw4c0adKE7777jrZt27J06dIi1/Pdd9/x4MEDnj9/joeHh9y5AQMGsGbNGoKDg6lXrx5OTk6EhIRgbm6ucPnNmzdnyJAh9OjRA0NDQ+bMmZMrjUwmY8+ePVSsWJHWrVvTrl07LCws2Lp1q8L1KCkpERoayrlz56hbty4jR45k7ty5CufPERwcTLVq1XBycqJr164MGjRI6mXLaesff/xB69at+eGHH7C2tqZnz57cunWrSEHq3LlzadWqFW5ubrRr146WLVvKzY1SVPXq1QkICGD8+PEYGRnlWvkwx4oVK/juu+/46aefqF27NgMHDuTZs2f5lltQ+mrVqhEVFUVmZibffPMN9erVY8SIEejr6xcr2BMEQRCEsi5nm5MPfZUXsrdlYddNQRAEIZfLl8VO64IgCIJiFFnZ9oPrmHSoRMq5/Ev7EinnYxM/ewpCCXh/Y9OPJWcD3cLIZDJ2795dImV9LO/XX9R7+O6ms4IgCIIgfHxf2tA7sZiDIHyG0tLSqFixIpAdUJibm3PhwgUaNGggpQkKCkJ0KJd9lrUV/4Uw6erlMpmnrLbrQ/NY2NgplP5G4hUAmoxR/JfYmLnti92uspanrLartPKU1XaVVp6y2q7SylPa7frYytOwuZIgAiVB+Iy8evUKVVXVAje2zaGnp1cKLRIEQRAEQSifxNA7QSiiZ8+e4e3tjba2NsbGxsyfPz9XmoyMDPz8/KhevTpaWlo0a9ZMbs+hkJAQ9PX1OXDgALa2tmhra+Pq6kpaWpqUJjMzk1GjRqGvr0+lSpUYO3Zsrh4gZ2dnfH19GTFiBJUrV8bFxQWQH3qXs+iEg4MDMpkMZ2dnIPfQt6ysLObMmYOlpSVqamqYmpoyY8aMfO9DYelv376Np6cn+vr6GBgY4O7uTkpKiiK3uEhu3LhBmzZt0NTUxN7enlOnTknnpk6dKteLBrBo0SK5Jc1z7sPMmTMxMjJCX1+fadOm8ebNG8aMGYOBgQE1atQgODhYrpxx48ZhbW2NpqYmFhYW+Pv78/r161x1b9y4ETMzM/T09OjZsydPnz4t8XsgCIIgCKXhS1vMQQRKglBEY8aM4dixY+zZs4eDBw8SGRnJ+fPn5dL4+vpy6tQpQkNDuXjxIt27d8fV1ZXr169LaZ4/f868efPYuHEjf/75J6mpqfj5+Unn58+fT0hICOvWrePEiRM8fPiQXbt25WrP+vXrUVVVJSoqipUrV+Y6Hx0dDcDhw4dJS0tj586deV7XhAkTmDVrFv7+/sTHx7N58+YCV7ArKP3r169xcXFBR0eH48ePExUVJQWDJbnxLcDEiRPx8/MjNjYWa2trevXqxZs3b4pUxpEjR/j777/5888/WbBgAVOmTKFz585UrFiRM2fOMGTIEAYPHsxff/0l5dHR0SEkJIT4+HiCgoJYvXo1CxculCs3OTmZ3bt3s2/fPvbt28exY8eYNWtWiVy3IAiCIJQ2MUdJEIR8paens3btWn777Tfatm0LZAcqNWrUkNKkpqYSHBxMamoq1apVA8DPz4/w8HCCg4OZOXMmkB1MrFy5klq1agHZwdW0adOkchYtWsSECRPo2rUrACtXruTAgQO52mRlZZXncuM5DA0NAahUqVK+Q/KePn1KUFAQS5cupW/fvkD2hrAtW7YsVvqtW7eSlZXFmjVrpF+OgoOD0dfXJzIykm+++Sbf9haVn58fnTp1ArL3vLKzsyMpKYnatWsrXIaBgQGLFy+WNiueM2cOz58/5z//+Q/wv6DwxIkT9OzZE4BJkyZJ+c3MzPDz8yM0NJSxY8dKx7OysggJCUFHRweAPn36EBERkWdPXUZGBhkZGXLHSjqoFARBEARBcSJQEoQiSE5O5tWrVzRr1kw6ZmBggI2NjfT+0qVLZGZmYm1tLZc3IyODSpUqSe81NTWlIAnA2NhY2iPqyZMnpKWlydWjoqJC48aNcw2/K86+Q+9LSEggIyNDCv4+NH1cXBxJSUlSgJDj5cuXJCcnf3B731W/fn3p38bGxgDcu3evSIGSnZ2d3N5HRkZGcsusKisrU6lSJen5QHYwuHjxYpKTk0lPT+fNmzfo6urKlWtmZiZ3D959xu8LDAwkICBA7tiPP/7IgsXLFb4OQRAEQfiYytOwuZIgAiVBKGHp6ekoKytz7tw5lJWV5c5pa2tL/65QoYLcOZlMVqxV6LS0tIrX0HdoaGiUaPr09HQaNWrEpk2bcp3L6eEqKe/ex5w/4FlZWUD2Brzv39N35xHlVUZOOXkdyyn31KlTeHl5ERAQgIuLC3p6eoSGhuaar1ZQGe+bMGECo0aNkjuWlJSUZ1pBEARB+BS+sDhJzFEShKKoVasWFSpU4MyZM9KxR48ece3aNem9g4MDmZmZ3Lt3D0tLS7mXIqvRQfaKdMbGxnL1vHnzhnPnzhW5zaqqqkD24hD5sbKyQkNDg4iICIXKLCx9w4YNuX79OlWqVMl1D0pztT1DQ0Pu3LkjFyyVxL5LJ0+epGbNmkycOJHGjRtjZWXFrVu3PqhMNTU1dHV15V45z04QBEEQhNInAiVBKAJtbW369+/PmDFjOHLkCJcvX8bHx0du2Ja1tTVeXl54e3uzc+dObt68SXR0NIGBgYSFhSlc1/Dhw5k1axa7d+/m6tWr/PTTTzx+/LjIba5SpQoaGhqEh4dz9+5dnjx5kiuNuro648aNY+zYsWzYsIHk5GROnz7N2rVr8yyzsPReXl5UrlwZd3d3jh8/zs2bN4mMjGTYsGFyCyJ8bM7Ozty/f585c+aQnJzMsmXL2L9//weXa2VlRWpqKqGhoSQnJ7N48eI8F9oQBEEQhM+JWPVOEIQCzZ07l1atWuHm5ka7du1o2bJlrnlCwcHBeHt7M3r0aGxsbPDw8CAmJgZTU1OF6xk9ejR9+vShb9++ODo6oqOjw7ffflvk9qqoqLB48WJWrVpFtWrVcHd3zzOdv78/o0ePZvLkydja2tKjR49859MUll5TU5M///wTU1NTunbtiq2tLf379+fly5e55vHkZ+rUqXLLeBeHra0ty5cvZ9myZdjb2xMdHS23smBxdenShZEjR+Lr60uDBg04efIk/v7+H1yuIAiCIJRlX9qqd7K3xZkUIQiC8JH17dsXmUxGSEjIp27KJ3P5cunstC4IgiCUf+8uQvSxNJkRWSLlxEx0LpFyPjbRoyQICspr89LieH+j1+LI2bA2R3Ha9u6mtB/D+9fp7OzMiBEjFMr79u1bIiMjmT59utzxO3fu0L59e7S0tOSuXxAEQRAEoaSJVe8E4SNJSUnB3NycCxculEiAVRA/Pz9+/vnnj1pHaZLJZHkujrBw4ULS0tKIjY0t8UUhIiMjadOmDY8ePSpTQZhlbcV/IUy6erlM5imr7SqtPB9SR5Offlc4T8zy74pdT1m9/s8hT1ltV2nlKavtKq08H1KHSa06Cue5nRyvcNoPUZ6GzZUEESgJwmdAW1tbbunxz1VycjKNGjXCysqqRMvNa8nw4nr79i2ZmZmoqIg/r4IgCMLnpTwtxFASxNA74bOTlZVFYGAg5ubmaGhoYG9vz++//+9X2cjISGQyGRERETRu3BhNTU2aN29OYmKiXDmzZs3CyMgIHR0daSGC9+uZNm0aNWrUQE1NjQYNGhAeHi6dNzc3B7KXC5fJZDg7O8vlnzdvHsbGxlSqVImhQ4fKfVnPyMjAz8+P6tWro6WlRbNmzYiMjMz3mt8fehcTE0P79u2pXLkyenp6ODk5cf78eUVvoXR9c+bMwdLSEjU1NUxNTZkxY4Z0/vbt23h6eqKvr4+BgQHu7u6kpKQUqY73rVixglq1aqGqqoqNjQ0bN26UzpmZmbFjxw42bNiATCbDx8cnzzIUuXaZTMaKFSvo0qULWlpaDBw4kDZt2gBQsWJFufIV/Tzt37+fRo0aoaamxm+//YaSkhJnz56Vq3fRokXUrFkz372UBEEQBEEoO0SgJHx2AgMD2bBhAytXruTKlSuMHDmS77//nmPHjsmlmzhxIvPnz+fs2bOoqKjQr18/6dy2bduYOnUqM2fO5OzZsxgbG7N8+XK5/EFBQcyfP5958+Zx8eJFXFxc6NKlC9evXwcgOjoagMOHD5OWlsbOnTulvEePHiU5OZmjR4+yfv16QkJC5BYt8PX15dSpU4SGhnLx4kW6d++Oq6urVHZhnj59St++fTlx4gSnT5/GysqKjh078vTpU4Xv44QJE5g1axb+/v7Ex8ezefNmjIyMgOweGBcXF3R0dDh+/DhRUVFoa2vj6urKq1evFK7jXbt27WL48OGMHj2ay5cvM3jwYH744QeOHj0KZAdArq6ueHp6kpaWRlBQ0Add+9SpU/n222+5dOkSAQEB7NixA4DExES58hX9PI0fP55Zs2aRkJBAly5daNeuHcHBwXJpgoODcy0nLwiCIAjlxZe26p0YGyJ8VjIyMpg5cyaHDx/G0dERAAsLC06cOMGqVatwcnKS0s6YMUN6P378eDp16sTLly9RV1dn0aJF9O/fn/79+wPwyy+/cPjwYblepXnz5jFu3Dh69uwJwOzZszl69CiLFi1i2bJlGBoaAlCpUqVcG81WrFiRpUuXoqysTO3atenUqRMREREMHDiQ1NRUgoODSU1NpVq1akD2HKTw8HCCg4OZOXNmoffh66+/lnv/66+/oq+vz7Fjx+jcuXOh+Z8+fUpQUBBLly6lb9++QPZmuy1btgRg69atZGVlsWbNGqkbPjg4GH19fSIjI/nmm28KreN98+bNw8fHh59++gmAUaNGcfr0aebNm0ebNm0wNDRETU0NDQ2NAjfuVfTae/fuzQ8//CC9v3nzJpC971TOHKWifJ6mTZtG+/btpfcDBgxgyJAhLFiwADU1Nc6fP8+lS5fYs2dPnu3OyMggIyND7lhxg05BEARB+BjE0DtBKMeSkpJ4/vw57du3l+btaGtrS5uivqt+/frSv42NjQGkfYASEhJo1qyZXPqcL8oA//77L3///TctWrSQS9OiRQsSEhIKbaednR3Kyspy9efUfenSJTIzM7G2tpa7hmPHjuW6hvzcvXuXgQMHYmVlhZ6eHrq6uqSnp5OamqpQ/oSEBDIyMmjbtm2e5+Pi4khKSkJHR0dqn4GBAS9fvlS4jXnVWdz7+S5Fr71x48aFllWUz9P75Xl4eKCsrCxtRBsSEkKbNm3y3RsqMDAQPT09udeaNWuKcOWCIAiCIJQk0aMkfFbS09MBCAsLo3r16nLn1NTU5N5XqFBB+nfOLySlNXfk3bpz6s+pOz09HWVlZc6dOycXTAEKL9jQt29fHjx4QFBQEDVr1kRNTQ1HR0eFeyg0NDQKPJ+enk6jRo3YtGlTrnM5PWmfiqLXrqWlVWhZRfk8vV+eqqoq3t7eBAcH07VrVzZv3pzvcEHIHuo4atQouWNJSUmFtlEQBEEQSssX1qEkAiXh81KnTh3U1NRITU2VGxZVVLa2tpw5cwZvb2/p2OnTp6V/6+rqUq1aNaKiouTqiYqKomnTpkD2F2WAzMzMItXt4OBAZmYm9+7do1WrVsVqf1RUFMuXL6djx45A9sIL//zzj8L5rays0NDQICIiggEDBuQ637BhQ7Zu3UqVKlXQ1dUtVhvfZ2trS1RUlDTUD7Kvo04dxZdHzclTnGvP63l96OdpwIAB1K1bl+XLl/PmzRu6du2ab1o1NbVcwVdOmwRBEAShLPjSht6JQEn4rOjo6ODn58fIkSPJysqiZcuWPHnyhKioKHR1deW+hBdk+PDh+Pj40LhxY1q0aMGmTZu4cuUKFhYWUpoxY8YwZcoUatWqRYMGDQgODiY2NlbqZalSpQoaGhqEh4dTo0YN1NXVFdr7x9raGi8vL7y9vZk/fz4ODg7cv3+fiIgI6tevT6dOnQotw8rKio0bN9K4cWP+/fdfxowZU2gv0bvU1dUZN24cY8eORVVVlRYtWnD//n2uXLlC//798fLyYu7cubi7u0sr/926dYudO3cyduxYatSooXBdOcaMGYOnpycODg60a9eO//u//2Pnzp0cPny4SOUU99pr1qyJTCZj3759dOzYEQ0NjQ/+PNna2vLVV18xbtw4+vXrV6RnIAiCIAjCpyXmKAmfnenTp+Pv709gYCC2tra4uroSFhYmLdetiB49euDv78/YsWNp1KgRt27d4scff5RLM2zYMEaNGsXo0aOpV68e4eHh7N27V9rjR0VFhcWLF7Nq1SqqVauGu7u7wvUHBwfj7e3N6NGjsbGxwcPDg5iYGExNTRXKv3btWh49ekTDhg3p06cPw4YNo0qVKgrXD+Dv78/o0aOZPHkytra29OjRQ5pHpampyZ9//ompqSldu3bF1tZWWkK9uD1MHh4eBAUFMW/ePOzs7Fi1ahXBwcG5llUvTHGvvXr16gQEBDB+/HiMjIzw9fUFPvzz1L9/f169eiW3qqIgCIIglEdf2qp3srdv37791I0QBEH4XE2fPp3t27dz8eLFIue9fPnyR2iRIAiC8DmqW7fuR6+j1fwTJVLO8dEtS6Scj030KAm5NistLh8fHzw8PD6ojJCQEGlpZihe22QyGbt37/6gdhTk/et0dnZmxIgRH1TmnTt3aN++PVpaWnLXX1C9n0pKSgoymYzY2NgSLztn89bHjx+XeNmlLT09ncuXL7N06VJ+/vlnIHvT3EWLFn3ahgmCIAhCMclkshJ5lRdijpJQZCkpKZibm3PhwoUSCbAK4ufnJ33J/JwtXLiQtLQ0YmNjFZrH9DlwdnamQYMGcoFD8+bNSUtL+yzuga+vL1u2bMHDw+ODht1Z1lb8F8Kkq5fLZJ6y2q7SylPa7WrSZ6XCeWI2DvnobSurz6W08pTVdpVWnrLartLKU9rtEkqWCJSEMi1n35rPXXJyMo0aNZLmN32pVFVVC9xMtjwJCQkhJCTkUzdDEARBEEpMOeoMKhFi6F05kpWVRWBgIObm5mhoaGBvb8/vv/8unc8ZthQREUHjxo3R1NSkefPmJCYmypUza9YsjIyM0NHRkSbgv19PzkpmampqNGjQgPDwcOl8ziR2BwcHZDJZrsn28+bNw9jYmEqVKjF06FBev34tncvIyMDPz4/q1aujpaVFs2bNiIyMzPea3x96FxMTQ/v27alcuTJ6eno4OTlx/vx5RW+hdH1z5szB0tISNTU1TE1NmTFjhnT+9u3beHp6oq+vj4GBAe7u7qSkpBSpjvetWLGCWrVqoaqqio2NDRs3bpTOmZmZsWPHDjZs2IBMJsPHx6fQ8jZs2EClSpXIyMiQO+7h4UGfPn2A/927devWYWpqira2Nj/99BOZmZnMmTOHqlWrUqVKFblrh+xu9RUrVtChQwc0NDSwsLCQ+5zluHHjBm3atEFTUxN7e3tOnTolnXvw4AG9evWievXqaGpqUq9ePbZs2SKd9/Hx4dixYwQFBUnd8CkpKXkOvYuKisLZ2RlNTU0qVqyIi4sLjx49ytWef//9Fw0NDfbv3y93fNeuXejo6PD8+XOg8OcbGRlJ06ZNpWGQLVq04NatW0D2Rrtt2rRBR0cHXV1dGjVqxNmzZ6W8J06coFWrVmhoaGBiYsKwYcN49uxZns9QEARBEMqbL23onQiUypHAwEA2bNjAypUruXLlCiNHjuT777/n2LFjcukmTpzI/PnzOXv2LCoqKnLDfrZt28bUqVOZOXMmZ8+exdjYmOXLl8vlDwoKYv78+cybN4+LFy/i4uJCly5duH79OgDR0dEAHD58mLS0NHbu3CnlPXr0KMnJyRw9epT169fn+lXd19eXU6dOERoaysWLF+nevTuurq5S2YV5+vQpffv25cSJE5w+fRorKys6duzI06dPFb6PEyZMYNasWfj7+xMfH8/mzZsxMjIC4PXr17i4uKCjo8Px48eJiopCW1sbV1dXhTdrfd+uXbsYPnw4o0eP5vLlywwePJgffviBo0ePAtnBn6urK56enqSlpRW4KWmO7t27k5mZyd69e6Vj9+7dIywsTO55Jycns3//fsLDw9myZQtr166lU6dO/PXXXxw7dozZs2czadIkzpw5I1e+v78/3bp1Iy4uDi8vL3r27ElCQoJcmokTJ+Ln50dsbCzW1tb06tWLN2/eAPDy5UsaNWpEWFgYly9fZtCgQfTp00f67AQFBeHo6MjAgQNJS0sjLS0NExOTXNcZGxtL27ZtqVOnDqdOneLEiRO4ubnluTeVrq4unTt3ZvPmzXLHN23ahIeHB5qamoU+3zdv3uDh4YGTkxMXL17k1KlTDBo0SPqj7uXlRY0aNYiJieHcuXOMHz9e2jw4OTkZV1dXunXrxsWLF9m6dSsnTpyQVs8TBEEQBKF8EUPvyomMjAxmzpzJ4cOHcXR0BMDCwoITJ06watUquc0wZ8yYIb0fP348nTp14uXLl6irq7No0SL69+9P//79Afjll184fPiwXK/SvHnzGDduHD179gRg9uzZHD16lEWLFrFs2TIMDQ0BqFSpUq5hUhUrVmTp0qUoKytTu3ZtOnXqREREBAMHDiQ1NZXg4GBSU1OpVq0akD0HKTw8nODgYGbOnFnoffj666/l3v/666/o6+tz7NgxOnfuXGj+p0+fEhQUxNKlS6U9cGrVqkXLltmrr2zdupWsrCzWrFkjfTkODg5GX1+fyMhIvvnmm0LreN+8efPw8fHhp59+AmDUqFGcPn2aefPm0aZNGwwNDVFTU0NDQ0PhYWcaGhr07t2b4OBgunfvDsBvv/2GqampXA9fVlYW69atQ0dHhzp16tCmTRsSExP5448/UFJSwsbGRnq+zZo1k/J1795d2mh2+vTpHDp0iCVLlsgF1X5+ftKeTgEBAdjZ2ZGUlETt2rWpXr06fn5+Utqff/6ZAwcOsG3bNpo2bYqenh6qqqpoamoWeM1z5syhcePGcvXa2dnlm97Ly4s+ffrw/PlzNDU1+ffffwkLC2PXrl1A4c+3cePGPHnyhM6dO1OrVi0gey+kHKmpqYwZM4batWsDyA2VDAwMxMvLS1rYw8rKisWLF+Pk5MSKFStQV1fPt92Q/d/4+z2ExQ3OBUEQBOFjKEedQSVC9CiVE0lJSTx//pz27dtL83a0tbXZsGEDycnJcmnr168v/dvY2BhA2v8mISFB7gsxIAVekD186e+//6ZFixZyaVq0aJGrRyEvdnZ2KCsry9WfU/elS5fIzMzE2tpa7hqOHTuW6xryc/fuXQYOHIiVlRV6enro6uqSnp5OamqqQvkTEhLIyMigbdu2eZ6Pi4sjKSkJHR0dqX0GBga8fPlS4TbmVWdx72dBBg4cyMGDB/nvf/8LZM+J8fHxkevSNjMzQ0dHR3pvZGREnTp1UFJSkjuW84xyvPuZyHn/fnsL+pxlZmYyffp06tWrh4GBAdra2hw4cEDh55Qjp0dJUR07dqRChQpST9uOHTvQ1dWlXbt2QOHP18DAAB8fH1xcXHBzcyMoKIi0tDSp/FGjRjFgwADatWvHrFmz5D4TcXFxhISEyH22XVxcyMrK4ubNm4W2PTAwED09PbnXmjVrFL52QRAEQfjYvrShd6JHqZxIT08HICwsjOrVq8udU1NTk3ufMxQIkD6MWVlZH7mFuevOqT+n7vT0dJSVlTl37pxcMAUovGBD3759efDgAUFBQdSsWRM1NTUcHR0V/uVdQ0OjwPPp6ek0atSITZs25TqX05NWVjg4OGBvb8+GDRv45ptvuHLlCmFhYXJp8noeBT2joijoczZ37lyCgoJYtGgR9erVQ0tLixEjRhS5h6Sw5/U+VVVVvvvuOzZv3kzPnj3ZvHkzPXr0QEUl+0+dIs83ODiYYcOGER4eztatW5k0aRKHDh3iq6++YurUqfTu3ZuwsDD279/PlClTCA0N5dtvvyU9PZ3BgwczbNiwXGUrslHwhAkTGDVqlNyxpKSkIl2/IAiCIAglR/QolRN16tRBTU2N1NRULC0t5V55ze3Ij62tba75KKdPn5b+raurS7Vq1YiKipJLExUVRZ06dYDsL6NAnvNECuLg4EBmZib37t3LdQ2KDjmLiopi2LBhdOzYETs7O9TU1Pjnn38UboOVlRUaGhpERETkeb5hw4Zcv36dKlWq5GpjcZestrW1LfB+fogBAwYQEhJCcHAw7dq1K9JnoSDvfiZy3r87BK0wUVFRuLu78/3332Nvb4+FhQXXrl2TS6OqqlroZ6h+/fr5Pqv8eHl5ER4ezpUrVzhy5AheXl7SOUWfr4ODAxMmTODkyZPUrVtXbt6TtbU1I0eO5ODBg3Tt2pXg4GCp7Pj4+FzlWlpaSv/NFERNTQ1dXV25lyL5BEEQBKG0yGQl8yovRKBUTujo6ODn58fIkSNZv349ycnJnD9/niVLlrB+/XqFyxk+fDjr1q0jODiYa9euMWXKFK5cuSKXZsyYMcyePZutW7eSmJjI+PHjiY2NZfjw4QBUqVIFDQ0NwsPDuXv3Lk+ePFGobmtra7y8vPD29mbnzp3cvHmT6OhoAgMDc/WE5MfKyoqNGzeSkJDAmTNn8PLyKlKvg7q6OuPGjWPs2LHSsMXTp0+zdu1aIPtLduXKlXF3d+f48ePcvHmTyMhIhg0bxl9//aVwPe8aM2YMISEhrFixguvXr7NgwQJ27twpN4enuHr37s1ff/3F6tWrP2ivnvdt376ddevWSZ+R6OjoIi1KYGVlxaFDhzh58iQJCQkMHjyYu3fvyqUxMzPjzJkzpKSk8M8//+TZqzVhwgRiYmL46aefuHjxIlevXmXFihUFBsetW7ematWqeHl5YW5uLjfUtLDne/PmTSZMmMCpU6e4desWBw8e5Pr169ja2vLixQt8fX2JjIzk1q1bREVFERMTIwWQ48aN4+TJk/j6+hIbG8v169fZs2ePWMxBEARB+GwoyWQl8iovRKBUjkyfPh1/f38CAwOxtbXF1dWVsLAwabluRfTo0QN/f3/Gjh1Lo0aNuHXrFj/++KNcmmHDhjFq1ChGjx5NvXr1CA8PZ+/evdLEdRUVFRYvXsyqVauoVq0a7u7uCtcfHByMt7c3o0ePxsbGBg8PD2JiYhQamgSwdu1aHj16RMOGDenTpw/Dhg2jSpUqCtcP2Su6jR49msmTJ2Nra0uPHj2kuTWampr8+eefmJqa0rVrV2xtbaUl1HV1dYtUTw4PDw+CgoKYN28ednZ2rFq1iuDg4FzLqheHnp4e3bp1Q1tbGw8Pjw8uL0dAQAChoaHUr1+fDRs2sGXLliL1gE2aNImGDRvi4uKCs7MzVatWzdU+Pz8/lJWVqVOnDoaGhnnOX7K2tubgwYPExcXRtGlTHB0d2bNnjzSULi8ymYxevXpJK/a9q7Dnq6mpydWrV+nWrRvW1tYMGjSIoUOHMnjwYJSVlXnw4AHe3t5YW1vj6elJhw4dCAgIALJ7v44dO8a1a9do1aoVDg4OTJ48WVq4RBAEQRDKuy+tR0n29u3bt5+6EYIgFF/btm2xs7Nj8eLFJVKeTCZj165dJRp4CcVz+bLYaV0QBEFQTN26dT96Hd8sO114IgUcHPpViZTzsYnFHAShnHr06BGRkZFERkbm2gtLEARBEAShpJWnFetKggiUBKGccnBw4NGjR8yePRsbG5tP3ZwSM3XqVHbv3k1sbOynbopCfHx8ePz4Mbt37/4o5VvWVvwXwqSrl8tkng+pQ7uqpcJ50u8kFbuesnr9pZWnyY/bFM4Ts8KzSPWUh+s3qaX40OLbyfFFqienjlo2ircrObHs37PP6fmXxvWbW+e/B+D7bl67Uux2fWxKnzBOWrZsGXPnzuXOnTvY29uzZMkSmjZtmm/6x48fM3HiRHbu3MnDhw+pWbMmixYtomPHjgrXKQIlQSinUlJSPkq5n8to3FevXolV4wRBEAThM7B161ZGjRrFypUradasGYsWLcLFxYXExMQ856q/evWK9u3bU6VKFX7//XeqV6/OrVu30NfXL1K9YjEHQRBKVFZWFoGBgZibm6OhoYG9vT2///47AJGRkchkMiIiImjcuDGampo0b96cxMREIHvT3ICAAOLi4qRN6UJCQoDsX4YGDBiAoaEhurq6fP3118TFxUn1Tp06lQYNGrBmzRrMzc1RV1cHIDU1FXd3d7S1tdHV1cXT0zPXCnz/93//R5MmTVBXV6dy5cp8++23AEybNi3PMd8NGjTA39+fqVOnsn79evbs2SO1NzIyEoDbt2/j6emJvr4+BgYGuLu7f7TgVhAEQRBKw6facHbBggUMHDiQH374gTp16rBy5Uo0NTVZt25dnunXrVvHw4cP2b17Ny1atMDMzAwnJyfs7e2LVK8IlARBKFGBgYFs2LCBlStXcuXKFUaOHMn333/PsWPHpDQTJ05k/vz5nD17FhUVFWlp8x49ejB69Gjs7OxIS0sjLS2NHj16ANC9e3fu3bvH/v37OXfuHA0bNqRt27Y8fPhQKjcpKYkdO3awc+dOYmNjycrKwt3dnYcPH3Ls2DEOHTrEjRs3pDIhexPnb7/9lo4dO3LhwgUiIiKkrvx+/fqRkJBATEyMlP7ChQtcvHiRH374AT8/Pzw9PXF1dZXa27x5c16/fo2Liws6OjocP36cqKgotLW1cXV1LfKmu4IgCIJQVpTUqncZGRn8+++/cq+MjIw863z16hXnzp2jXbt20jElJSXatWvHqVOn8syzd+9eHB0dGTp0KEZGRtStW5eZM2cWeQ9QMfROEIQSk5GRwcyZMzl8+DCO/4+9e4/r8f4fP/54Fx10cigJUekgESHHIYepbUxzauaDKOfQcuyzoZzCnNkwtsrmNMxhc9bkQ2PlUKJEKdnWZuawxVYpvz/8ur7eOqhUiud9t+t26/26XofndWX06nVq3x4AKysrTp06xfr16xk1ahQA8+fPp0uXLgDMmDGDd955h3///RddXV309fWpUqWK2iHEp06dIjIyklu3bqGtrQ3AkiVL2LNnDzt37lTqzczMZNOmTZiYmABw9OhRYmNjSU5OVg7j3bRpEw4ODkRFReHs7Mz8+fN5//33lW2+AeU3TvXr18fV1ZXg4GCcnZ2BJ1vcd+nSBSsrKwB0dXXJyMhQi/frr78mJyeHjRs3Kr85Cw4Opnr16oSHh9OzZ898392z/0hIp0oIIcSrKCgoSO3fXYDZs2cTEBCQJ+/t27fJzs7G1NRULd3U1JQrV67kW//169eVQ+cPHDhAYmIi48aNIysri9mzZxc5ThlREkKUmsTERB4+fMibb76Jvr6+cuUe7pvL0dFR+drMzAxAOcsqPzExMaSnp1OrVi21epOTk9XqbdiwodJJAoiPj8fc3FzpJAE0adKE6tWrEx8fD0B0dDTdu3cvsO2RI0eydetW/v33XzIzM9myZctzD/eNiYkhMTERAwMDJdaaNWvy77//qsX7tKCgIIyMjNSujRs3FtqOEEIIUZ5UpfSfv78/9+/fV7v8/f1LLc6cnBxq167N559/TqtWrfDw8OCjjz5i3bp1xapHRpSEEKUmPT0deDKdrV69emr3tLW1lU5C1apVlfTcEZecnJxC6zUzM1PW/zzt6YWZenp6xY5ZV1e30Pu9e/dGW1ub3bt3o6WlRVZWFv379y+0THp6Oq1atWLz5s157j3dkXuav78/fn5+ammJiYnPiV4IIYQoP6W16522trYyQ+R5jI2N0dTUzLO++Pfff1ebzfE0MzMzqlatiqamppJmb2/Pb7/9VqzNnqSjJIQoNU2aNEFbW5vU1FRlat3TChpNeZqWllaeOcQtW7bkt99+o0qVKlhYWBQ5Hnt7e27evMnNmzeVUaW4uDju3btHkyZPtgN2dHQkLCyM4cOH51tHlSpVGDZsGMHBwWhpafH++++rda4Kinf79u3Url0bQ0PDIsWa3z8asmufEEKI152WlhatWrUiLCwMd3d34MkvV8PCwvDx8cm3TMeOHdmyZQs5OTloaDyZQHf16lXMzMyK9W+rTL0TQpQaAwMDpkyZwocffkhoaChJSUmcP3+e1atXExoaWqQ6LCwsSE5OJjo6mtu3b5ORkUGPHj1o37497u7uHDlyhJSUFH788Uc++ugjzp49W2BdPXr0oFmzZgwePJjz588TGRnJ0KFD6dKlC61btwaezIneunUrs2fPJj4+ntjYWBYtWqRWj7e3Nz/88AOHDh3KM+3OwsKCixcvkpCQwO3bt8nKymLw4MEYGxvTp08fTp48SXJyMuHh4UycOJGff/65mG9VCCGEqBhe1q53fn5+bNiwgdDQUOLj4xk7diwPHjxQfsk5dOhQtal7Y8eO5c6dO0yaNImrV6+yf/9+FixYwPjx44vVrnSUhBClau7cucycOZOgoCDs7e1xc3Nj//79WFpaFql8v379cHNzo2vXrpiYmLB161ZUKhUHDhygc+fODB8+HFtbW95//31u3LiRZ3Hn01QqFXv37qVGjRp07tyZHj16YGVlxfbt25U8Li4u7Nixg3379tGiRQu6detGZGSkWj02NjZ06NCBxo0b07ZtW7V7I0eOxM7OjtatW2NiYkJERATVqlXjf//7Hw0aNKBv377Y29vj5eXFv//+W+QRJiGEEKKiKa1d74rLw8ODJUuWMGvWLFq0aEF0dDSHDh1SfgZITU0lLS1NyW9ubs7hw4eJiorC0dGRiRMnMmnSJGbMmFG85338qpwuKYR46cLDw+natSt3794t9qFuxREQEMCePXuIjo4uszae9vjxY2xsbBg3blyedUSFsbCwwNfXF19fX+BJx2337t3K1IHnuXSpfE5aF0IIUfnld+5faev7xblSqedbr1alUk9ZkxElISqA3MNSRdFMmTKFsLCwcmnrjz/+YM2aNfz2228FrmMSQgghxKtHNnMQ4hVSnJ1cKqPHjx+TnZ2tbLldHmrXro2xsTGff/45NWrUKJc2n2bduOi/IUy8cqlClqmocZVXmYoa14uWcR5StG12o74aU65xlaRMI7uil0lKKNn3vyzbeLqdilamosZVXmXK+/tf1koyba4ykxElIV5QTk4OQUFBWFpaoqurS/Pmzdm5c6dyPzw8HJVKRVhYGK1bt6ZatWp06NCBhIQEAEJCQggMDCQmJkZZ5BgSEgLAvXv38Pb2xsTEBENDQ7p160ZMTIxSd+5I1MaNG7G0tERHRwd4Mle3T58+6OvrY2hoyMCBA/Nsq7l3715atmyJjo4OVlZWBAYG8ujRI+W+SqVi48aNvPfee1SrVg0bGxv27dunVseBAwewtbVFV1eXrl27kpKSkuf97Nq1CwcHB7S1tbGwsGDp0qVq9zMyMpg+fTrm5uZoa2tjbW3NF198ofbuDh48SKtWrdDW1ubUqVN5RuA8PT1xd3dnyZIlmJmZUatWLcaPH09WVpZaO1OmTKFevXro6enRtm3bfLcbf9q9e/cYNWoUGhoajBgxgqZNm/L9998r90+dOkWnTp3Q1dXF3NyciRMn8uDBg0LrFEIIISqrl7WZw8siHSUhXlBQUBCbNm1i3bp1XL58mQ8//JD//Oc/nDhxQi3fRx99xNKlSzl79ixVqlRRdk/z8PBg8uTJODg4kJaWRlpaGh4eHgAMGDCAW7ducfDgQc6dO0fLli3p3r07d+7cUepNTExk165dfPvtt0RHR5OTk0OfPn24c+cOJ06c4OjRo1y/fl2pE+DkyZMMHTqUSZMmERcXx/r16wkJCWH+/PlqMQcGBjJw4EAuXrzI22+/zeDBg5W2b968Sd++fenduzfR0dF4e3vnWSR57tw5Bg4cyPvvv09sbCwBAQHMnDlT6QjCk51qtm7dyqpVq4iPj2f9+vV5RotmzJjBwoULiY+PVzus9mnHjx8nKSmJ48ePExoaSkhIiFo7Pj4+nD59mm3btnHx4kUGDBiAm5sb165dy7e+nJwc3nrrLSIiIvj666+Ji4tj4cKFypkMSUlJuLm50a9fPy5evMj27ds5depUgVuVCiGEEKJykal3QryAjIwMFixYwLFjx2jfvj0AVlZWnDp1ivXr16udJTR//nzl84wZM3jnnXf4999/0dXVRV9fnypVqqgdnHbq1CkiIyO5deuWcr7OkiVL2LNnDzt37mTUqFHAk+l2mzZtUg4yPXr0KLGxsSQnJytnB23atAkHBweioqJwdnYmMDCQGTNmMGzYMCXmuXPnMm3aNGbPnq3E4OnpyaBBgwBYsGABq1atIjIyEjc3N9auXUujRo2UESI7O7s8W2svW7aM7t27M3PmTABsbW2Ji4vjk08+wdPTk6tXr/LNN99w9OhRevToocTyrDlz5vDmm28W+r2oUaMGa9asQVNTk8aNG/POO+8QFhbGyJEjSU1NJTg4mNTUVOrWrQs8Wed06NAhgoODWbBgQZ76jh07RmRkJPHx8dja2uaJLSgoiMGDBysbNdjY2LBq1Sq6dOnC2rVrldE9IYQQ4lVRiQaDSoV0lIR4AYmJiTx8+DDPD/GZmZk4OTmppT09EmJmZgbArVu3aNCgQb51x8TEkJ6eTq1atdTS//nnH7WDWxs2bKh0kgDi4+MxNzdXOknw5CDY6tWrEx8fj7OzMzExMURERKiNIGVnZ/Pvv//y8OFDqlWrlidmPT09DA0NuXXrltLOs1tl53YWn46lT58+amkdO3ZkxYoVZGdnEx0djaamZr6H0z4t98yjwjg4OKidwG1mZkZsbCwAsbGxZGdnKx2eXBkZGXneb67o6Gjq16+fp0yumJgYLl68yObNm5W0x48fk5OTQ3JyMvb29s+N+dlYMjIy1NIyMzOLVYcQQghRljRes56SdJSEeAHp6ekA7N+/n3r16qndyx0FylW1alXl69z5uTk5OYXWbWZmlu86mqe33tbT0ytu2KSnpxMYGEjfvn3z3Ht6JOTpmOFJ3IXFXFy6urpFyleUZyws1vT0dDQ1NTl37pxaZwoocFOI58WWnp7O6NGjmThxYp57BXV+CxMUFERgYKBa2tixY1m26rNi1yWEEEKIFycdJSFeQJMmTdDW1iY1NfW5oyKF0dLSIjs7Wy2tZcuW/Pbbb1SpUgULC4si12Vvb8/Nmze5efOmMqoUFxfHvXv3aNKkiVJ3QkIC1tbWJY7Z3t4+z+YOZ86cyZMnIiJCLS0iIgJbW1s0NTVp1qwZOTk5nDhxQpl6VxacnJzIzs7m1q1bdOrUqUhlHB0d+fnnn7l69Wq+o0otW7YkLi7uhd7h0/z9/fOc0ZSYmFgqdQshhBCl4fUaT5KOkhAvxMDAgClTpvDhhx+Sk5PDG2+8wf3794mIiMDQ0FBZA/Q8FhYWJCcnK9O9DAwM6NGjB+3bt8fd3Z3Fixdja2vLr7/+yv79+3nvvfcKnI7Wo0cPmjVrxuDBg1mxYgWPHj1i3LhxdOnSRSkza9YsevXqRYMGDejfvz8aGhrExMRw6dIl5s2bV6SYx4wZw9KlS5k6dSre3t6cO3dObfMEgMmTJ+Ps7MzcuXPx8PDg9OnTrFmzhs8++0x57mHDhjFixAhWrVpF8+bNuXHjBrdu3WLgwIFFiqMobG1tGTx4MEOHDmXp0qU4OTnxxx9/EBYWhqOjI++8806eMl26dKFz587069ePZcuWYW1tzZUrV1CpVLi5uTF9+nTatWuHj48P3t7e6OnpERcXx9GjR1mzZk2xY9TW1s4zCvkqb/UuhBCi8qlMO9aVBtn1TogXNHfuXGbOnElQUBD29va4ubmxf/9+LC0ti1xHv379cHNzo2vXrpiYmLB161ZUKhUHDhygc+fODB8+HFtbW95//31u3LiBqalpgXWpVCr27t1LjRo16Ny5Mz169MDKyort27creVxdXfn+++85cuQIzs7OtGvXjuXLl9OwYcMix9ygQQN27drFnj17aN68OevWrcuzKULLli355ptv2LZtG02bNmXWrFnMmTMHT09PJc/atWvp378/48aNo3HjxowcObJMttgODg5m6NChTJ48GTs7O9zd3YmKiip0mtyuXbtwdnZm0KBBNGnShGnTpikjf46Ojpw4cYKrV6/SqVMnnJycmDVrlrJZhBBCCCEqN9Xjx48fv+wghBBC5HXp0qUKd3hiScpU1LjKq0xFjetFy8iBsxXzwNGKVqaixlVeZcrz+9+0adHzl9Tgr6JLpZ7NQ1qUSj1lTTpKQohy9/jxY0aPHs3OnTu5e/cuRkZGeHp6smLFCuDJlDxfX19l6+3SpFKp2L17N+7u7vneT0lJwdLSkgsXLqgdavsyXLpUPietCyGEqPzKo6P0n69jnp+pCL7+T/NSqaesyRolIUS5O3ToECEhIYSHh2NlZYWGhkaRd8CrbAICAtizZw/R0dEvOxQhhBDihbxmS5SkoySEKH9JSUmYmZnRoUOHUqszKysrzxbhr4KKNo2kJGUqalzlVaaixlVeZZSpel6hRW4j6othZR5XeZWpqHGVV5nc/FZ2DkVu43rC5TKPq7zKlHdconTJZg5CiHLl6enJhAkTSE1NRaVSYWFhgYuLS55pdn///TeDBg1CT0+PevXq8emnn6rdV6lUrF27lnfffRc9PT3l8Ny1a9fSqFEjtLS0sLOz46uvvsoTQ1paGm+99Ra6urpYWVmxc+fOAuPNzs7Gy8sLS0tLdHV1sbOzY+XKlWp5wsPDadOmDXp6elSvXp2OHTty48YNQkJCCAwMJCYmBpVKhUqlyrMzoBBCCFFZ5P5b9qJXZSEdJSFEuVq5ciVz5syhfv36pKWlERUVlW++Tz75hObNm3PhwgVmzJjBpEmTOHr0qFqegIAA3nvvPWJjYxkxYgS7d+9m0qRJTJ48mUuXLjF69GiGDx/O8ePH1crNnDmTfv36ERMTw+DBg3n//feJj4/PN46cnBzq16/Pjh07iIuLY9asWfz3v//lm2++AeDRo0e4u7vTpUsXLl68yOnTpxk1ahQqlQoPDw8mT56Mg4MDaWlppKWl4eHhUQpvUQghhCh/GqrSuSoLmXonhChXRkZGGBgYoKmpSZ06dQrM17FjR2bMmAE8OQcpIiKC5cuX8+abbyp5PvjgA4YPH658HjRoEJ6enowbNw4APz8/zpw5w5IlS+jatauSb8CAAXh7ewNPtnc/evQoq1evVs53elrVqlUJDAxUPltaWnL69Gm++eYbBg4cyF9//cX9+/fp1asXjRo1Ap4ctJtLX1+fKlWqFPqsQgghhKh4ZERJCFEhtW/fPs/nZ0d9nj10Nz4+no4dO6qldezYMU+5otT9tE8//ZRWrVphYmKCvr4+n3/+OampqQDUrFkTT09PXF1d6d27NytXriQtLa1oD/mUjIwM/vrrL7UrMzOz2PUIIYQQZUWm3gkhRCWhp6dX5m1s27aNKVOm4OXlxZEjR4iOjmb48OFqnZjg4GBOnz5Nhw4d2L59O7a2tpw5c6ZY7QQFBWFkZKR2bdy4sbQfRwghhCgxVSldlYV0lIQQFdKzHY0zZ86oTWnLj729PREREWppERERNGnSpMR1R0RE0KFDB8aNG4eTkxPW1tYkJSXlyefk5IS/vz8//vgjTZs2ZcuWLQBoaWmRnZ1daNwA/v7+3L9/X+3KnR4ohBBCiPIna5SEEBVSREQEixcvxt3dnaNHj7Jjxw72799faJmpU6cycOBAnJyc6NGjB9999x3ffvstx44dU8u3Y8cOWrduzRtvvMHmzZuJjIzkiy++yLdOGxsbNm3axOHDh7G0tOSrr74iKioKS0tLAJKTk/n888959913qVu3LgkJCVy7do2hQ4cCTw7PTU5OJjo6mvr162NgYIC2tnaedrS1tfOka2lpFfl9CSGEEGVNoxJNmysNMqIkhKiQJk+ezNmzZ3FycmLevHksW7YMV1fXQsu4u7uzcuVKlixZgoODA+vXryc4OBgXFxe1fIGBgWzbtg1HR0c2bdrE1q1b84w65Ro9ejR9+/bFw8ODtm3b8ueffyqbRQBUq1aNK1eu0K9fP2xtbRk1ahTjx49n9OjRAPTr1w83Nze6du2KiYkJW7dufbEXI4QQQrwkKlXpXJWFjCgJIcqdr6+v2rlJ4eHhavdTUlKeW8fjx4/zTR87dixjx459brmnOztPs7CwUKtbW1ub4OBggoOD1fIFBQUBYGpqyu7duwtsT1tbu9BzmoQQQghRMakeF/TThhBCvCAXFxdatGjBihUripQ/JCQEX19f7t27V6ZxlReVSsXu3btxd3cnJSUFS0tLLly4QIsWLYpU/tIlOWldCCFE0TRt2rTM2xi143Kp1PP5AIdSqaesydQ7IUSFFRAQUORORUHCw8Ofu03psyNaQgghhMhLpt4JIcQrpEOHDmrnGk2aNIm//vpLbSpdzZo1X0ZoRWLduOi/IUy88mQEysq26L+pu371yW8H6zcqfEfBp/2cFF+s2HLjKsmzlFeZRnZFL5OUULx2KsPzl2WZF2nDefKhIpeJWupW4nYq6vO/CmUqalwvWqaof2cU9++LF42rrMlmDkKIUvX3338zePBg9PT0MDMzY/ny5bi4uKit0fnqq69o3bo1BgYG1KlThw8++IBbt24p93NHRQ4fPoyTkxO6urp069aNW7ducfDgQezt7TE0NOSDDz7g4cOHSjkXFxcmTJiAr68vNWrUwNTUlA0bNvDgwQOGDx+OgYEB1tbWHDx4UCmTnZ2Nl5cXlpaW6OrqYmdnx8qVK5/7nA8ePGDo0KHo6+tjZmbG0qVL8+TJyMhgypQp1KtXDz09Pdq2bVvgaE5ISAiBgYHExMQoIz8hISEALFu2jGbNmqGnp4e5uTnjxo0jPT0933q0tLSoU6eOcunq6qKtra2WVtDucj///DODBg2iZs2a6Onp0bp1a3766Sfl/t69e2nZsiU6OjpYWVkRGBjIo0ePnvuuhBBCCFHxSUdJiDLm5+dHREQE+/bt4+jRo5w8eZLz58+r5cnKymLu3LnExMSwZ88eUlJS8PT0zFNXQEAAa9as4ccff+TmzZsMHDiQFStWsGXLFvbv38+RI0dYvXq1WpnQ0FCMjY2JjIxkwoQJjB07lgEDBtChQwfOnz9Pz549GTJkiNLBysnJoX79+uzYsYO4uDhmzZrFf//7X7755ptCn3Pq1KmcOHGCvXv3cuTIEcLDw/M8p4+PD6dPn2bbtm1cvHiRAQMG4ObmxrVr1/LU5+HhweTJk3FwcCAtLY20tDQ8PDwA0NDQYNWqVVy+fJnQ0FB++OEHpk2b9tzvRXGkp6fTpUsXfvnlF/bt20dMTAzTpk0jJycHgJMnTzJ06FAmTZpEXFwc69evJyQkhPnz55dqHEIIIURFIVPvhBCl5u+//yY0NJQtW7bQvXt3AIKDg6lbt65avhEjRihfW1lZsWrVKpydnUlPT0dfX1+5N2/ePDp27AiAl5cX/v7+JCUlYWVlBUD//v05fvw406dPV8o0b96cjz/+GHhyqOnChQsxNjZm5MiRAMyaNYu1a9dy8eJF2rVrR9WqVQkMDFTKW1pacvr0ab755hsGDhyY73Omp6fzxRdf8PXXXyvPGRoaSv369ZU8qampBAcHk5qaqjz/lClTOHToEMHBwSxYsECtTl1dXfT19alSpQp16tRRu/f0aJyFhQXz5s1jzJgxfPbZZ/nGVxJbtmzhjz/+ICoqSpmaZ21trdwPDAxkxowZDBs2DHjyfZs7dy7Tpk1j9uzZpRaHEEIIUVGoKlMvpxRIR0mIMnT9+nWysrJo06aNkmZkZISdnZ1avnPnzhEQEEBMTAx3795VRi1SU1PVzvdxdHRUvjY1NaVatWpKJyk3LTIyUq3up8toampSq1YtmjVrplYGUJvq9+mnn/Lll1+SmprKP//8Q2ZmprKpwsmTJ3nrrbeUvOvXr6dp06ZkZmbStm1bJb1mzZpqzxkbG0t2dja2trZq8WVkZFCrVq08764wx44dIygoiCtXrvDXX3/x6NEj/v33Xx4+fEi1atWKVVdBoqOjcXJyKnD9UkxMDBEREWojSNnZ2SWOIyMjg4yMDLW0zMzM4gcuhBBCiFIhHSUhXrIHDx7g6uqKq6srmzdvxsTEhNTUVFxdXfP8oFy1alXla5VKpfY5Ny23k5VfmfzK5f52KLfctm3bmDJlCkuXLqV9+/YYGBjwySefKGtzWrduTXR0tFLe1NSU69evP/c509PT0dTU5Ny5c2hqaqrde3rU7HlSUlLo1asXY8eOZf78+dSsWZNTp07h5eVFZmZmqXWUdHV1C72fnp5OYGAgffv2zXNPR0en2O0FBQWpjeTBkzOhlq0qvVEyIYQQ4kW8bmt2pKMkRBmysrKiatWqREVF0aBBAwDu37/P1atX6dy5MwBXrlzhzz//ZOHChZibmwNw9uzZlxZzREQEHTp0UDuQNSkpSflaV1dXbQoaQKNGjahatSo//fST8px3797l6tWrdOnSBQAnJyeys7O5desWnTp1KlIsWlpaZGdnq6WdO3eOnJwcli5diobGk7+yn7d+qiQcHR3ZuHEjd+7cyXdUqWXLliQkJOR5FyXl7++Pn5+fWlpiYmKp1C2EEEKUhtdt6t3r1jEUolwZGBgwbNgwpk6dyvHjx7l8+TJeXl5oaGgof9k0aNAALS0tVq9ezfXr19m3bx9z5859aTHb2Nhw9uxZDh8+zNWrV5k5cyZRUVGFltHX18fLy4upU6fyww8/cOnSJTw9PZWODICtrS2DBw9m6NChfPvttyQnJxMZGUlQUBD79+/Pt14LCwuSk5OJjo7m9u3bZGRkYG1tTVZWlvK+vvrqK9atW1eq7wBg0KBB1KlTB3d3dyIiIrh+/Tq7du3i9OnTwJO1XZs2bSIwMJDLly8THx/Ptm3blPVgxaWtrY2hoaHaVdBufEIIIYQoe9JREqKMLVu2jPbt29OrVy969OhBx44dsbe3V6ZnmZiYEBISwo4dO2jSpAkLFy5kyZIlLy3e0aNH07dvXzw8PGjbti1//vmn2uhSQT755BM6depE79696dGjB2+88QatWrVSyxMcHMzQoUOZPHkydnZ2uLu7q422Patfv364ubnRtWtXTExM2Lp1K82bN2fZsmUsWrSIpk2bsnnzZoKCgkrl2Z+mpaXFkSNHqF27Nm+//TbNmjVj4cKFyrRBV1dXvv/+e44cOYKzszPt2rVj+fLlNGzYsNRjEUIIISoCDVXpXJWFTL0ToowZGBiwefNm5fODBw8IDAxk1KhRStqgQYMYNGiQWrnHjx8rX7u4uKh9BvD09MyzhXhAQAABAQHK5/zOKEpJScmT9nTd2traBAcHqx3ICjy3M6Kvr89XX33FV199paRNnTpVLU/ujnrPrsXJ9ewzaWtrs3Pnzjz5PvzwQz788EO1tCFDhhQaX67cs5iKomHDhvm2nyt3bVlBnn6vFhYWeb6HQgghRGVSmTo5pUH1WP7lFqJMXbhwgStXrtCmTRvu37/PnDlzCA8PJzExEWNj45cdXqVlYWGBr6+vslW4SqVi9+7duLu7F6l8QEAAe/bsUduYojSlpKRgaWnJhQsXaNGiBeHh4XTt2pW7d+9SvXr1ItVx6VL5nLQuhBCi8mvatGmZt+G370qp1LPs3calUk9ZkxElIcrBkiVLSEhIQEtLi1atWnHy5EnpJJWytLQ0atSo8bLDEEIIIV5Zr9tmDtJREqKMOTk5ce7cuZcdxivv2UNpXxXWjYv+G8LEK5cqZJmKGteLlmlo0+Q5OZ+4cS2uXOOqaGXKOy7nyYeKXCZqqRsAVrYORS5z/erlYsWWG5eVXTHaSCheG0+3U6I/y9ZF+7MMcCOxeH+eK+qfy/IqU95xlbXXbeqdbOYghKhw/v77bwYPHoyenh5mZmYsX74cFxcXZZpdflQqFXv27FE+T58+HVtbW+VQ3pkzZ5KVlVWsOC5fvkyvXr0wNDTEwMCATp06qW2VvnHjRmVjjsaNG/PZZ3LmkRBCiFeXSlU6V2UhI0pCiArHz8+PiIgI9u3bh6mpKbNmzeL8+fO0aNGiyHUYGBgQEhJC3bp1iY2NZeTIkRgYGDBt2rQilf/ll1/o3LkzLi4u/PDDDxgaGhIREcGjR48A2Lx5M7NmzWLNmjU4OTlx4cIFRo4ciZ6eHsOGDSvJYwshhBCiApGOkhCiQvn7778JDQ1ly5YtdO/eHXiyrXjdunWLVc/T5xlZWFgwZcoUtm3bVuSO0qeffoqRkRHbtm2jatWqwJOzoHLNnj2bpUuX0rdvXwAsLS2Ji4tj/fr10lESQgjxStKoTMNBpUA6SkKICuX69etkZWXRpk0bJc3IyAg7O7ti1bN9+3ZWrVpFUlIS6enpPHr0CENDwyKXj46OplOnTkon6WkPHjwgKSkJLy8vRo4cqaQ/evQIIyOjYsWZKyMjg4yMDLW0zMzMEtUlhBBClIXXbc3O6/a8QojXwOnTpxk8eDBvv/0233//PRcuXOCjjz4qVsdDV1e3wHvp6ekAbNiwgejoaOW6dOkSZ86cKVHMQUFBGBkZqV0bN24sUV1CCCGEeHEyoiSEqFCsrKyoWrUqUVFRNGjQAID79+9z9epVOnfuXKQ6fvzxRxo2bMhHH32kpN24caNYcTg6OhIaGkpWVlaeUSVTU1Pq1q3L9evXGTx4cLHqLYi/vz9+fn5qaYmJiaVStxBCCFEaXrOZd9JREkJULAYGBgwbNoypU6dSs2ZNateuzezZs9HQ0Cjy+Q02Njakpqaybds2nJ2d2b9/P7t37y5WHD4+PqxevZr3338ff39/jIyMOHPmDG3atMHOzo7AwEAmTpyIkZERbm5uZGRkcPbsWe7evZunw1MU2traaGtrq6VpaWkVux4hhBCirLxua5Rk6p0QosJZtmwZ7du3p1evXvTo0YOOHTsq23AXxbvvvsuHH36Ij48PLVq04Mcff2TmzJnFiqFWrVr88MMPpKen06VLF1q1asWGDRuU0SVvb282btxIcHAwzZo1o0uXLoSEhGBpaVns5xVCCCFExSMjSkKICsfAwIDNmzcrnx88eEBgYCCjRo1S0lJSUtTKPH78WO3z4sWLWbx4sVra0+cwBQQEEBAQUGgcjo6OHD58uMD7H3zwAR988EG+9ywsLNRicnFxyROjEEIIUZm8ZgNKqB7Lv9ziFeHi4kKLFi1YsWLFyw4lj4CAAPbs2UN0dHSp1RkeHk7Xrl25e/cu1atXL7V6K4ILFy5w5coV2rRpw/3795kzZw7h4eEkJiZibGz8ssMrkme/556enty7d0/tUNznuXSpfE5aF0IIUfk1bdq0zNsIOHKtdOrpaVMq9ZQ1mXonXhnffvstc+fOLXL+lJQUVCpVqXZeAFQqVZ4fhqdMmUJYWFiptlORBQQEFOtw2Pz4+flha2tLjx49ePDgASdPnqw0nSQhhBBCVH4y9U68MmrWrPmyQyiQvr4++vr6LzuMQmVnZ6NSqdDQePm/P3FycmL06NGlPgpXGVk3LvpvCBOvXKqQZV6kDSs7hyKXuZ5wucTtVNTnL68yZfmeK8Pzt597rshlTs9sVax2ctuo38i+yG38nBQPgLF50c+Pu30zoVhxPR3b6/7nvzyev6FNkyK3ceNaXInjKmuymYMQlZSLi4vaGhQLCwsWLFjAiBEjMDAwoEGDBnz++efK/dxF905OTqhUKlxcXJR7GzduVDYPaNy4MZ999plyLzMzEx8fH8zMzNDR0aFhw4YEBQUpbQK89957qFQq5fOzIyyenp64u7uzZMkSzMzMqFWrFuPHjycrK0vJ89VXX9G6dWsMDAyoU6cOH3zwAbdu3SrWO7l37x6jR4/G1NQUHR0dmjZtyvfffw9ASEgI1atXZ9++fTRp0gRtbW1OnTpF1apV+e2339Tq8fX1pVOnTmrl9uzZg42NDTo6Ori6unLz5k3lfmBgIDExMahUKlQqFSEhIfnGFx4eTps2bdDT06N69ep07NiRGzduFFrHvXv38Pb2xsTEBENDQ7p160ZMTIxSZ+67/vLLL2nQoAH6+vqMGzeO7OxsFi9eTJ06dahduzbz589/7vv78ssvcXBwQFtbGzMzM3x8fNTebWFxCCGEEK8alap0rspCRpTEK23p0qXMnTuX//73v+zcuZOxY8fSpUsX7OzsiIyMpE2bNhw7dgwHBwdlK+bNmzcza9Ys1qxZg5OTExcuXGDkyJHo6ekxbNgwVq1axb59+/jmm29o0KABN2/eVDoJUVFR1K5dm+DgYNzc3NDU1CwwtuPHj2NmZsbx48dJTEzEw8ODFi1aMHLkSACysrKYO3cudnZ23Lp1Cz8/Pzw9PTlw4ECRnj0nJ4e33nqLv//+m6+//ppGjRoRFxenFtPDhw9ZtGgRGzdupFatWpibm2NlZcVXX33F1KlTlTg2b96stjHCw4cPmT9/Pps2bUJLS4tx48bx/vvvExERgYeHB5cuXeLQoUMcO3YMACMjozzxPXr0CHd3d0aOHMnWrVvJzMwkMjISlUpVaB0DBgxAV1eXgwcPYmRkxPr16+nevTtXr15VRhWTkpI4ePAghw4dIikpif79+3P9+nVsbW05ceIEP/74IyNGjKBHjx60bds23/e3du1a/Pz8WLhwIW+99Rb3798nIiJCuV+UOIQQQohXiUYl6uSUBukoiVfa22+/zbhx4wCYPn06y5cv5/jx49jZ2WFiYgI82Qa6Tp06SpnZs2ezdOlS+vbtCzwZeYqLi2P9+vUMGzaM1NRUbGxseOONN1CpVDRs2FApm1tn9erV1erMT40aNVizZg2ampo0btyYd955h7CwMKWjNGLECCWvlZUVq1atwtnZmfT09CJN4zt27BiRkZHEx8dja2ur1PO0rKwsPvvsM5o3b66keXl5ERwcrHSUvvvuO/79918GDhyoVm7NmjVKJyM0NBR7e3ul86mvr0+VKlUKfQd//fUX9+/fp1evXjRq1AgAe/v/m5qSXx2nTp0iMjKSW7duKWcOLVmyhD179rBz505lV7ycnBy+/PJLDAwMaNKkCV27diUhIYEDBw6goaGBnZ0dixYt4vjx4wV2lObNm8fkyZOZNGmSkubs7FysOIQQQghRecnUO/FKc3R0VL5WqVTUqVOn0OlrDx48ICkpCS8vL2Vdkb6+PvPmzSMpKQl4Mm0uOjoaOzs7Jk6cyJEjR0oUm4ODg9rojpmZmVps586do3fv3jRo0AADAwO6dOkCQGpqapHqj46Opn79+konKT9aWlpq7wiePF9iYiJnzpwBnkylGzhwIHp6ekqeKlWqKJ0GgMaNG1O9enXi4+OLFBs8WVPm6emJq6srvXv3ZuXKlaSlpRVaJiYmhvT0dGrVqqX2/UlOTla+P/BkCqSBgYHy2dTUlCZNmqitvzI1NS3wz8KtW7f49ddf6d69+wvFURwZGRn89ddfaldmZmaJ6hJCCCHKgqqU/qssZERJvNJyDwfNpVKpyMnJKTB/eno6ABs2bMgz0pDbqWnZsiXJyckcPHiQY8eOMXDgQHr06MHOnTtLLbYHDx7g6uqKq6srmzdvxsTEhNTUVFxdXYv8w7Ourm6R8qiemSxcu3ZtevfuTXBwMJaWlhw8eJDw8PCiPVQxBQcHM3HiRA4dOsT27dv5+OOPOXr0KO3atcs3f3p6OmZmZvnG8/QW6fm92+L8WXjeuytqHMURFBREYGCgWtrYsWNZtuqzAkoIIYQQ5Uum3gnxmshdk5Sdna2kmZqaUrduXa5fv87gwYMLLGtoaIiHhwceHh70798fNzc37ty5Q82aNalatapanSVx5coV/vzzTxYuXIi5uTkAZ8+eLVYdjo6O/Pzzz1y9erXQUaX8eHt7M2jQIOrXr0+jRo3o2LGj2v1Hjx5x9uxZ2rRpA0BCQgL37t1Tps5paWkV+R04OTnh5OSEv78/7du3Z8uWLbRr1y7fOlq2bMlvv/1GlSpVlI0yyoKBgQEWFhaEhYXRtWvXPPfLIg5/f3/8/PzU0hITE0ulbiGEEEIUn3SUxGurdu3a6OrqcujQIerXr4+Ojg5GRkYEBgYyceJEjIyMcHNzIyMjg7Nnz3L37l38/PxYtmwZZmZmODk5oaGhwY4dO6hTp44ykpD7A3bHjh3R1tamRo0axY6tQYMGaGlpsXr1asaMGcOlS5eKdUYUQJcuXejcuTP9+vVj2bJlWFtbc+XKFVQqFW5uboWWdXV1xdDQkHnz5jFnzpw896tWrcqECRNYtWoVVapUwcfHh3bt2ikdJwsLC5KTk5XpfwYGBspanlzJycl8/vnnvPvuu9StW5eEhASuXbvG0KFDC6yjR48etG/fHnd3dxYvXoytrS2//vor+/fv57333qN169bFekeFCQgIYMyYMdSuXVvZFCMiIoIJEyaUSRza2tp53lFuZ14IIYSoCF63ESVZoyReW1WqVGHVqlWsX7+eunXr0qdPH+DJaMrGjRsJDg6mWbNmdOnShZCQEGU7cQMDAxYvXkzr1q1xdnYmJSVF2SQAnuy0d/ToUczNzXFycipRbCYmJoSEhLBjxw6aNGnCwoULWbJkSbHr2bVrF87OzgwaNIgmTZowbdq0Io30aGho4OnpSXZ2ttJxeVq1atWYPn06H3zwAR07dkRfX5/t27cr9/v164ebmxtdu3bFxMSErVu35lvHlStX6NevH7a2towaNYrx48czevToAutQqVQcOHCAzp07M3z4cGxtbXn//fe5ceMGpqamxX4/hRk2bBgrVqzgs88+w8HBgV69enHt2pMTycszDiGEEKKiyD2y40WvykL1+PHjxy87CCFExePl5cUff/zBvn371NJDQkLw9fXl3r17Lyew18ilS5cq3OGJJSlTUQ9CfdHYXqUDN+XAWTlwtqzKVIbv/6ty4GzTpkXPX1KfhF8vlXqmulg9P1MFIB0lISogFxcXWrRowYoVK8q97fv37xMbG8ubb77Jvn37ePPNN9Xuu7u78913373wOqynhYeH07VrV+7evVvizRAK8vjxY0aPHs3OnTu5e/cuFy5cUDv8tyypVCp2796Nu7s7KSkpWFpaFqv9S5fK56R1IYQQlV95dJSWniidjtLkLpWjoyRT74SogL799ttirUlKSUlBpVIRHR39wm336dOHnj17MmbMGHr27MmePXvU7ru5ualtFV5eVCpVnliK4tChQ4SEhPD999+TlpZG06ZNS1yXEEII8TpTqUrnqixkMwchKqCaNWu+tLaf3vI6vxGtMWPGMGbMmPIL6AUlJSVhZmZGhw4dXnYoJVLRppGUpExFjau8ylTUuMqrTEWN60XLOA9ZV6T8UV+NKde4KlqZihpXeZUp77hE6ZIRJSEqIBcXF3x9fZXPFhYWLFiwgBEjRmBgYECDBg34/PPPlfu5G004OTmhUqlwcXFR7m3cuBF7e3t0dHRo3Lgxn332f+fyZGZm4uPjg5mZGTo6OjRs2JCgoCClTYD33nsPlUqlfA4ICFCbOubp6Ym7uztLlizBzMyMWrVqMX78eLKyspQ8X331Fa1bt8bAwIA6derwwQcfFHrw77MKiiW37af5+voqz+/p6cmECRNITU1VyhVUV35+/vlnBg0aRM2aNdHT06N169b89NNPyv29e/fSsmVLdHR0sLKyIjAwkEePHhX5uYQQQojKREOlKpWrspCOkhCVxNKlS2ndujUXLlxg3LhxjB07loSEJ4t3IyMjATh27BhpaWl8++23AGzevJlZs2Yxf/584uPjWbBgATNnziQ0NBSAVatWsW/fPr755hsSEhLYvHmz0nGIiooCnhwKm5aWpnzOz/Hjx0lKSuL48eOEhoYSEhJCSEiIcj8rK4u5c+cSExPDnj17SElJwdPTs8jPXpxYnrZy5UrmzJlD/fr1lXJFrSs9PZ0uXbrwyy+/sG/fPmJiYpg2bZpySO3JkycZOnQokyZNIi4ujvXr1xMSEsL8+fOL/FxCCCFEZaKhKp2rJD799FMsLCzQ0dGhbdu2ys8+z7Nt2zZUKlWeX6wWhUy9E6KSePvttxk3bhwA06dPZ/ny5Rw/fhw7OztMTEwAqFWrFnXq1FHKzJ49m6VLl9K3b1/gychT7g/1w4YNIzU1FRsbG9544w1UKhUNGzZUyubWWb16dbU681OjRg3WrFmDpqYmjRs35p133iEsLIyRI0cCMGLECCWvlZUVq1atwtnZmfT0dPT19Z/77MWJ5WlGRkYYGBigqamZp9zz6tqyZQt//PEHUVFRylRIa2tr5X5gYCAzZsxg2LBhynPNnTuXadOmMXv27CLHKIQQQlQWL2swaPv27fj5+bFu3Tratm3LihUrcHV1JSEhgdq1axdYLiUlhSlTptCpU6cStSsjSkJUEo6OjsrXKpWKOnXqFDp97cGDByQlJeHl5YW+vr5yzZs3j6SkJODJ1LTo6Gjs7OyYOHEiR44cKVFsDg4OaGpqKp/NzMzUYjt37hy9e/emQYMGGBgY0KVLFwBSU1NL1F55iI6OxsnJqcD1YjExMcyZM0ft3Y4cOZK0tDQePnxY7PYyMjL466+/1K7MzMwXfQwhhBCi0lu2bBkjR45k+PDhNGnShHXr1lGtWjW+/PLLAstkZ2czePBgAgMDsbIq2S570lESopKoWrWq2meVSqVMA8tPeno6ABs2bCA6Olq5Ll26xJkzZwBo2bIlycnJzJ07l3/++YeBAwfSv3//Uo3twYMHuLq6YmhoyObNm4mKimL37t0AL9wR0NDQ4NkTDp5eG/UidHV1C72fnp5OYGCg2ruNjY3l2rVr6OjoFLu9oKAgjIyM1K6NGzeWNHwhhBCi1GmgKpUrv18OZmRk5NtmZmYm586do0ePHv8Xh4YGPXr04PTp0wXGOmfOHGrXro2Xl1eJn1em3gnxCtDS0gJQO9vI1NSUunXrcv36dQYPHlxgWUNDQzw8PPDw8KB///64ublx584datasSdWqVV/4vKQrV67w559/snDhQszNzQE4e/ZssevJLxYTE5M8Zw1FR0fn6bgVpa5nOTo6snHjRuVdPKtly5YkJCSoTcd7Ef7+/vj5+amlJSYmlkrdQgghRGkoral3QUFBBAYGqqXNnj2bgICAPHlv375NdnY2pqamaummpqZcuXIl3/pPnTrFF1988cLHpkhHSYhXQO3atdHV1eXQoUPUr18fHR0djIyMCAwMZOLEiRgZGeHm5kZGRgZnz57l7t27+Pn5sWzZMszMzHByckJDQ4MdO3ZQp04d5dBXCwsLwsLC6NixI9ra2tSoUaPYsTVo0AAtLS1Wr17NmDFjuHTpUrHOiMqVXyzdunXjk08+YdOmTbRv356vv/6aS5cu4eTkVOy6njVo0CAWLFiAu7s7QUFBmJmZceHCBerWrUv79u2ZNWsWvXr1okGDBvTv3x8NDQ1iYmK4dOkS8+bNK/bzaWtro62trZaW2wEWQgghXiX5/XLw2X8DS+rvv/9myJAhbNiwAWNj4xeqS6beCfEKqFKlCqtWrWL9+vXUrVuXPn36AODt7c3GjRsJDg6mWbNmdOnShZCQEGU7cQMDAxYvXkzr1q1xdnYmJSWFAwcOoKHx5K+GpUuXcvToUczNzZ/b+SiIiYkJISEh7NixgyZNmrBw4UKWLFlS7Hryi8XV1ZWZM2cybdo0nJ2d+fvvvxk6dGiJ6nqWlpYWR44coXbt2rz99ts0a9aMhQsXKmuxXF1d+f777zly5AjOzs60a9eO5cuXq22IIYQQQrxKSmvXO21tbQwNDdWugjpKxsbGaGpq8vvvv6ul//777/luypSUlERKSgq9e/emSpUqVKlShU2bNrFv3z6qVKmirNMuChlREqICevrQV3iya8uznh1O9vb2xtvbO0++Dz74gA8++CDfdkaOHKnsTJef3r1707t3b7W0gIAAtaHxp7cBz/XsQbWDBg1i0KBBamlPry1ycXHJs9aoKLHAk93nnh2+f5qvr6/amVSF1fWshg0bsnPnzgLvu7q64urqWuD9p5/JwsLiuc8ohBBCVGQv4wwkLS0tWrVqRVhYmLLFd05ODmFhYfj4+OTJ37hxY2JjY9XSPv74Y/7++29WrlypLAMoCtVj+ZdbiFLn4uJCixYt8nQYKoKAgAD27NnzwvN2y4Onpyf37t1jz549BeapqO86JCQEX19f7t27B5TsvT+7/koIIYQoSNOmTcu8jc/P3CiVeka1K97si+3btzNs2DDWr19PmzZtWLFiBd988w1XrlzB1NSUoUOHUq9ePYKCgvItX5SfJ/IjU++EKAPffvttsdbhpKSkoFKpSr3zolKp8vylMGXKFMLCwkq1ncokJCREWYMlhBBCiKJTqUrnKi4PDw+WLFnCrFmzaNGiBdHR0Rw6dEjZ4CE1NZW0tLRSflqZeidEmSjo7J2KIPfMH1E5WDcu+m8IE69cqpBlXqQNKzuHIpe5nnC5xO1U1OcvrzKN7IpeJimhYj9/SZ6lnpV9kcv8cj2+WLHlxuU89WiR24j65M1itfF0OxWtTEWNq7zK5OZvaNOkyG3cuBZX4rjK2suYepfLx8cn36l2kHfJwrPyWyZQFDKiJEQZcHFxUVsXY2FhwYIFCxgxYgQGBgY0aNCAzz//XLmfu7mCk5MTKpUKFxcX5d7GjRuxt7dHR0eHxo0b89lnnyn3MjMz8fHxwczMDB0dHRo2bKgMO1tYWADw3nvvoVKplM8BAQG0aNFCqcPT0xN3d3eWLFmCmZkZtWrVYvz48WrnEWVkZDBlyhTq1auHnp4ebdu2fe5fSleuXOGNN95AR0eHJk2acOzYsTwjXLGxsXTr1g1dXV1q1arFqFGjlPOfnhYYGIiJiQmGhoaMGTOm0POXCos1PDyc4cOHc//+fVQqFSqVKt+tSHN99913ODs7o6Ojg7GxMe+9994LvRMhhBBCVB4yoiREOVm6dClz587lv//9Lzt37mTs2LF06dIFOzs7IiMjadOmDceOHcPBwUHZFnrz5s3MmjWLNWvW4OTkxIULFxg5ciR6enoMGzaMVatWsW/fPr755hsaNGjAzZs3uXnzJgBRUVHUrl2b4OBg3NzclN3a8nP8+HHMzMw4fvw4iYmJeHh40KJFC2WjBx8fH+Li4ti2bRt169Zl9+7duLm5ERsbi42NTZ76srOzcXd3p0GDBvz000/8/fffTJ48WS1P7kG07du3Jyoqilu3buHt7Y2Pj4/ab37CwsLQ0dEhPDyclJQUhg8fTq1atZg/f36+z1JYrB06dGDFihXMmjWLhIQEgAJH1/bv3897773HRx99xKZNm8jMzOTAgQNFaie/dyKEEEJUdi9xQOmlkI6SEOXk7bffZty4cQBMnz6d5cuXc/z4cezs7DAxMQGgVq1aaltdzp49m6VLl9K3b1/gychTXFwc69evZ9iwYaSmpmJjY8Mbb7yBSqVS25o6t87q1avnu33m02rUqMGaNWvQ1NSkcePGvPPOO4SFhTFy5EhSU1MJDg4mNTWVunXrAk/WOR06dIjg4GAWLFiQp76jR4+SlJREeHi40vb8+fN58803lTxbtmzh33//ZdOmTejp6QGwZs0aevfuzaJFi5R5x1paWnz55ZdUq1YNBwcH5syZw9SpU5k7d66yjXmuosRqZGSESqV67juZP38+77//vtqOes2bNy9yO8WVkZGR51TywkbOhBBCiPL2uk1Fk46SEOXE0dFR+Tr3B/Vbt24VmP/BgwckJSXh5eWltoX3o0ePMDIyAp5Mm3vzzTexs7PDzc2NXr160bNnz2LH5uDgoDbiZGZmpmytGRsbS3Z2Nra2tmplMjIyqFWrVr71JSQkYG5urtYZadOmjVqe+Ph4mjdvrnSSADp27EhOTg4JCQlKR6l58+ZUq1ZNydO+fXvS09O5efNmnjOLShJrQaKjowvcOr0028mV3ynlY8eOZdmqzwooIYQQQpQv1Ws2pCQdJSHKSdWqVdU+q1QqcnJyCsyfu1Znw4YNtG3bVu1ebqemZcuWJCcnc/DgQY4dO8bAgQPp0aNHoWf/FDe29PR0NDU1OXfuXJ7pexVtU4jSjFVXV7dc2smV3ynliYmJJapLCCGEEC9OOkpCVAC5a5Kys7OVNFNTU+rWrcv169cZPHhwgWUNDQ3x8PDAw8OD/v374+bmxp07d6hZsyZVq1ZVq7MknJycyM7O5tatW3Tq1KlIZezs7Lh58ya///67MjIUFRWllsfe3p6QkBAePHigjCpFRESgoaGBnZ2dki8mJoZ//vlH6bicOXMGfX39fA+MK0qsWlpaRXonjo6OhIWFMXz48BK1U1za2tp5TiXP/XMhhBBCVASv13jS6zfVUIgKqXbt2ujq6nLo0CF+//137t+/DzzZ7S0oKIhVq1Zx9epVYmNjCQ4OZtmyZQAsW7aMrVu3cuXKFa5evcqOHTuoU6eOck6QhYUFYWFh/Pbbb9y9e7dEsdna2jJ48GCGDh3Kt99+S3JyMpGRkQQFBbF///58y7z55ps0atSIYcOGcfHiRSIiIvj444+B/xu2Hzx4MDo6OgwbNoxLly5x/PhxJkyYwJAhQ5TOFTxZp+Pl5UVcXBwHDhxg9uzZ+Pj45FmfVNRYLSwsSE9PJywsjNu3b/Pw4cN8n2H27Nls3bqV2bNnEx8fT2xsLIsWLSrxOxFCCCEqOw2VqlSuykI6SkJUAFWqVGHVqlWsX7+eunXr0qdPHwC8vb3ZuHEjwcHBNGvWjC5duhASEqJsJ25gYMDixYtp3bo1zs7OpKSkcODAAaUTsXTpUo4ePYq5uTlOTk4lji84OJihQ4cyefJk7OzscHd3JyoqigYNGuSbX1NTkz179pCeno6zszPe3t589NFHAOjo6ABQrVo1Dh8+zJ07d3B2dqZ///50796dNWvWqNXVvXt3bGxs6Ny5Mx4eHrz77ruFbun9vFg7dOjAmDFj8PDwwMTEhMWLF+dbj4uLCzt27GDfvn20aNGCbt26ERkZWeJ3IoQQQojKRfX48ePHLzsIIcSrLyIigjfeeIPExEQaNWr0ssOpFC5dKp8DBIUQQlR+TZsW/YDaktp87udSqWdwq/qlUk9ZkxElIUSZ2L17N0ePHiUlJYVjx44xatQoOnbs+Fp1kgo63FcIIYSojFSq0rkqC9nMQQhRJv7++2+mT59OamoqxsbG9OjRg6VLl77ssIAnHZg9e/YQHR39skN5LuvGRf8NYeKVSxWyTEWNq7zKVNS4yqtMRY2rvMq8SBvOkw8VuUzUUrcSt1NRn/9VKFPecYnSJR0lIUSZGDp0KEOHDn3ZYQghhBCilLxu5yjJ1DshxEvl4uLChAkT8PX1pUaNGpiamrJhwwYePHjA8OHDMTAwwNramoMHDyplsrOz8fLywtLSEl1dXezs7Fi5cqVaveHh4bRp0wY9PT2qV69Ox44duXHjBiEhIQQGBhITE4NKpUKlUhESElJgfF9++SUODg5oa2tjZmaGj4+Pcu/evXt4e3tjYmKCoaEh3bp1IyYmptTfkRBCCFERaJTSVVlUpliFEK+o0NBQjI2NiYyMZMKECYwdO5YBAwbQoUMHzp8/T8+ePRkyZIiylXdOTg7169dnx44dxMXFMWvWLP773//yzTffAPDo0SPc3d3p0qULFy9e5PTp04waNQqVSoWHhweTJ0/GwcGBtLQ00tLS8PDwyDeutWvXMn78eEaNGkVsbCz79u3D2tpauT9gwABu3brFwYMHOXfuHC1btqR79+7cuXOn7F+aEEIIIcqUTL0TQrx0zZs3V85Z8vf3Z+HChRgbGzNy5EgAZs2axdq1a7l48SLt2rWjatWqBAYGKuUtLS05ffo033zzDQMHDuSvv/7i/v379OrVS9k8wt7eXsmvr69PlSpVqFOnTqFxzZs3j8mTJzNp0iQlzdnZGYBTp04RGRnJrVu3lINilyxZwp49e9i5cyejRo0q1jvIyMggIyNDLS0zM7NYdQghhBBlSabeCSFEOXN0dFS+1tTUpFatWjRr1kxJyz2A9tatW0rap59+SqtWrTAxMUFfX5/PP/+c1NRUAGrWrImnpyeurq707t2blStXkpaWVqyYbt26xa+//kr37t3zvR8TE0N6ejq1atVCX19fuZKTk0lKSipWWwBBQUEYGRmpXRs3bix2PUIIIURZUZXSVVnIiJIQ4qWrWrWq2meVSqWWlvsbrJycHAC2bdvGlClTWLp0Ke3bt8fAwIBPPvmEn376SSkTHBzMxIkTOXToENu3b+fjjz/m6NGjtGvXrkgx6erqFno/PT0dMzMzwsPD89yrXr16kdp4mr+/P35+fmppiYmJxa5HCCGEKCuv24iSdJSEEJVOREQEHTp0YNy4cUpafqM4Tk5OODk54e/vT/v27dmyZQvt2rVDS0uL7OzsQtswMDDAwsKCsLAwunbtmud+y5Yt+e2336hSpQoWFhYv/Eza2trKFL5cWlpaL1yvEEIIIUpGpt4JISodGxsbzp49y+HDh7l69SozZ84kKipKuZ+cnIy/vz+nT5/mxo0bHDlyhGvXrinrlCwsLEhOTiY6Oprbt2/nWRuUKyAggKVLl7Jq1SquXbvG+fPnWb16NQA9evSgffv2uLu7c+TIEVJSUvjxxx/56KOPOHv2bNm/BCGEEKKcya53QghRwY0ePZq+ffvi4eFB27Zt+fPPP9VGl6pVq8aVK1fo168ftra2jBo1ivHjxzN69GgA+vXrh5ubG127dsXExIStW7fm286wYcNYsWIFn332GQ4ODvTq1Ytr164BT6YfHDhwgM6dOzN8+HBsbW15//33uXHjhrKmSgghhHiV5B6r8aJXZaF6/Pjx45cdhBBCiLwuXZKT1oUQQhRN06ZNy7yN3Rd/K5V63nMsfNfZikJGlIQQogyEh4ejUqm4d+8eACEhISXa5EEIIYSoKGTXOyGEeIWEh4erbcago6ODlZUVkyZNKvZZRy9DPSv752f6/365Hg+AdeOi/1Yx8cqlMi9THm1U5DIVNa7yKlNR4yqvMuUdl/NHEUUuEzW/Y5nHVlG/L+VVprzjKmuVaNZcqZCOkhCiUsjMzHyhXeASEhIwNDTkn3/+4bvvvmPs2LE0atSowHOShBBCCPF6k6l3QrwmXFxcmDBhAr6+vtSoUQNTU1M2bNjAgwcPGD58OAYGBlhbW3Pw4EG1cpcuXeKtt95CX18fU1NThgwZwu3bt1+43hMnTtCmTRu0tbUxMzNjxowZPHr0SK1eHx8ffH19MTY2xtXVlREjRtCrVy+1erKysqhduzZffPFFoc9fu3Zt6tSpg6WlJRMnTsTS0pLz588XWiYiIgIXFxeqVatGjRo1cHV15e7du8CTM52CgoKwtLREV1eX5s2bs3PnzkLrE0IIISozDVSlclUW0lES4jUSGhqKsbExkZGRTJgwgbFjxzJgwAA6dOjA+fPn6dmzJ0OGDOHhw4cA3Lt3j27duuHk5MTZs2c5dOgQv//+OwMHDnyhen/55RfefvttnJ2diYmJYe3atXzxxRfMmzcvT71aWlpERESwbt06vL29OXToEGlpaUqe77//nocPH+Lh4VGkd/D48WMOHTpEamoqbdu2LTBfdHQ03bt3p0mTJpw+fZpTp07Ru3dv5fyloKAgNm3axLp167h8+TIffvgh//nPfzhx4kSR4hBCCCEqG5WqdK7KQqbeCfEaad68OR9//DEA/v7+LFy4EGNjY0aOHAnArFmzWLt2LRcvXqRdu3asWbMGJycnFixYoNTx5ZdfYm5uztWrV7G1tS1RvZ999hnm5uasWbMGlUpF48aN+fXXX5k+fTqzZs1CQ+PJ73BsbGxYvHix2jPY2dnx1VdfMW3aNACCg4MZMGAA+vr6hT57/fr1AcjIyCAnJ4c5c+bQuXPnAvMvXryY1q1b89lnnylpDg4OSh0LFizg2LFjtG/fHgArKytOnTrF+vXr6dKlS6Gx5CcjIyPPeU6ZmZnFrkcIIYQQpUNGlIR4jTg6Oipfa2pqUqtWLZo1a6ak5Z7/c+vWLQBiYmI4fvw4+vr6ytW4cWMAkpKSSlxvfHw87du3VztLoWPHjqSnp/Pzzz8raa1atcrzDN7e3gQHBwPw+++/c/DgQUaMGPHcZz958iTR0dFER0ezceNGFixYwNq1awvMnzuilJ/ExEQePnzIm2++qfZuNm3apPZeiiMoKAgjIyO1a+PGjSWqSwghhCgLqlL6r7KQESUhXiNVq1ZV+6xSqdTScjsuOTk5AKSnp9O7d28WLVqUpy4zM7MS11tUenp6edKGDh3KjBkzOH36ND/++COWlpZ06tTpuXVZWloq23M7ODjw008/MX/+fMaOHZtvfl1d3QLrSk9PB2D//v3Uq1dP7Z62tvZzY8mPv78/fn5+ammJiYklqksIIYQoC5Vp2lxpkI6SEKJALVu2ZNeuXVhYWFClSun9dWFvb8+uXbt4/Pix0omKiIjAwMBAmSJXkFq1auHu7k5wcDCnT59m+PDhJYpBU1OTf/75p8D7jo6OhIWFERgYmOdekyZN0NbWJjU1tUTT7PKjra2dp5P1Irv8CSGEEKWtMm3EUBpk6p0QokDjx4/nzp07DBo0iKioKJKSkjh8+DDDhw9XNjUoiXHjxnHz5k0mTJjAlStX2Lt3L7Nnz8bPz09Zn1QYb29vQkNDiY+PZ9iwYUVq89atW/z222/cuHGDHTt28NVXX9GnT58C8/v7+xMVFcW4ceO4ePEiV65cYe3atdy+fRsDAwOmTJnChx9+SGhoKElJSZw/f57Vq1cTGhpa5PcghBBCiIpLRpSEEAWqW7cuERERTJ8+nZ49e5KRkUHDhg1xc3MrUoemIPXq1ePAgQNMnTqV5s2bU7NmTby8vJQNIZ6nR48emJmZ4eDgQN26dYtUxs7ODoAqVapgbm7O6NGjCQgIKDC/ra0tR44c4b///S9t2rRBV1eXtm3bMmjQIADmzp2LiYkJQUFBXL9+nerVq9OyZUv++9//FikeIYQQorJ53abeqR4/fvz4ZQchhBDFkZ6eTr169QgODqZv374vO5wyc+lS+Zy0LoQQovJr2rRpmbdxJP6PUqmnp71JqdRT1mRESQhRaeTk5HD79m2WLl1K9erVeffdd192SEIIIYR4RUlHSQhRaaSmpmJpaUn9+vUJCQkp1Q0mSsrT05N79+6xZ8+eMqnfunHRf0OYeOVShSxTUeN60TLV69kUKf+9X66Va1wVrUx5x9XQpkmRy9y4FlfmsVXU78vTZTrOv1DkMhEfORWrncrw/K/S97+sVaatvUvDy/8pQwghisjCwgKZLSyEEEK8HBqvVz9Jdr0TQpQPFxcXJkyYgK+vLzVq1MDU1JQNGzbw4MEDhg8fjoGBAdbW1hw8eFApc+LECdq0aYO2tjZmZmbMmDGDR48eqdU5ceJEpk2bRs2aNalTp06eDRpSU1Pp06cP+vr6GBoaMnDgQH7//Xe1PN999x3Ozs7o6OhgbGzMe++9B8CcOXPynfPdokULZs6cSUBAAKGhoezduxeVSoVKpSI8PByAmzdvMnDgQKpXr07NmjXp06cPKSkppfMyhRBCCFHmpKMkhCg3oaGhGBsbExkZyYQJExg7diwDBgygQ4cOnD9/np49ezJkyBAePnzIL7/8wttvv42zszMxMTGsXbuWL774gnnz5uWpU09Pj59++onFixczZ84cjh49CjxZ09SnTx/u3LnDiRMnOHr0KNevX8fDw0Mpv3//ft577z3efvttLly4QFhYGG3atAFgxIgRxMfHExUVpeS/cOECFy9eZPjw4UyZMoWBAwfi5uZGWloaaWlpdOjQgaysLFxdXTEwMODkyZNERESgr6+Pm5sbmZmZ5fCmhRBCiNKnKqX/KguZeieEKDfNmzdXtgD39/dn4cKFGBsbM3LkSABmzZrF2rVruXjxIt999x3m5uasWbMGlUpF48aN+fXXX5k+fTqzZs1Stid3dHRk9uzZANjY2LBmzRrCwsJ48803CQsLIzY2luTkZMzNzQHYtGkTDg4OREVF4ezszPz583n//ffVDpZt3rw5APXr18fV1ZXg4GCcnZ0BCA4OpkuXLlhZWQGgq6tLRkYGderUUcp//fXX5OTksHHjRuVA3eDgYKpXr054eDg9e/bM824yMjLIyMhQS5NOlRBCiIrkddseXEaUhBDlxtHRUflaU1OTWrVq0axZMyXN1NQUeHI4bHx8PO3bt1c6GgAdO3YkPT2dn3/+Od86AczMzLh16xYA8fHxmJubK50kgCZNmlC9enXi4+MBiI6Opnv37gXGPHLkSLZu3cq///5LZmYmW7ZsYcSIEYU+Z0xMDImJiRgYGKCvr4++vj41a9bk33//JSkpKd8yQUFBGBkZqV0bN24stB0hhBBClB0ZURJClJuqVauqfVapVGppuZ2inJycF6qzOOV1dXULvd+7d2+0tbXZvXs3WlpaZGVl0b9//0LLpKen06pVKzZv3pznnolJ/mdH+Pv74+fnp5aWmJj4nOiFEEKI8lOZps2VBukoCSEqJHt7e3bt2sXjx4+VDlRERAQGBgbUr1+/yHXcvHmTmzdvKqNKcXFx3Lt3jyZNnmwh7OjoSFhYGMOHD8+3jipVqjBs2DCCg4PR0tLi/fffV+tcaWlpkZ2drVamZcuWbN++ndq1a2NoaFikWLW1tdHW1lZL09LSKlJZIYQQojzIrndCCFEBjBs3jps3bzJhwgSuXLnC3r17mT17Nn5+fsr6pOfp0aMHzZo1Y/DgwZw/f57IyEiGDh1Kly5daN26NQCzZ89m69atzJ49m/j4eGJjY1m0aJFaPd7e3vzwww8cOnQoz7Q7CwsLLl68SEJCArdv3yYrK4vBgwdjbGxMnz59OHnyJMnJyYSHhzNx4kS1aYNCCCFEZfK6beYgHSUhRIVUr149Dhw4QGRkJM2bN2fMmDF4eXkpm0EUhUqlYu/evdSoUYPOnTvTo0cPrKys2L59u5LHxcWFHTt2sG/fPlq0aEG3bt2IjIxUq8fGxoYOHTrQuHFj2rZtq3Zv5MiR2NnZ0bp1a0xMTIiIiKBatWr873//o0GDBvTt2xd7e3u8vLz4999/izzCJIQQQoiXS/VYTm8UQohCPX78GBsbG8aNG5dnHVFZunSpfE5aF0IIUfnld+5faTt17W6p1POGTY1SqaesyYiSEKLCCwgIoEWLFkXOn5KSgkqlIjo6usA84eHhqFQq7t27V2hdf/zxB2vWrOG3334rcB1TQSwsLFixYoXyWaVSsWfPnmLVIYQQQlQUqlK6KgvZzEEI8coxNzcnLS0NY2PjF66rdu3aGBsb8/nnn1OjRvn/Bsy6cdF/Q5h45VKFLPMibVjZORS5zPWEyyVup0Sx2RYttutXyzeuilamosZVXmUqalxPl2lkV/QySQlPyjgPWVek/FFfjSlxXK9CmfKOS5Qu6SgJIV45mpqaagfAvgiZnSyEEEI8ofGanTgrU++EEEXm4uLChAkT8PX1pUaNGpiamrJhwwYePHjA8OHDMTAwwNramoMHDwJPOhnW1tYsWbJErZ7o6GhUKpVyTtC9e/fw9vbGxMQEQ0NDunXrRkxMTIFx5OTkMGfOHOrXr4+2tjYtWrTg0KFDyv38pt4dOHAAW1tbdHV16dq1KykpKc993nv37jF69GhMTU3R0dGhadOmfP/998r9U6dO0alTJ3R1dTE3N2fixIk8ePCgKK9SCCGEqHRet6l30lESQhRLaGgoxsbGREZGMmHCBMaOHcuAAQPo0KED58+fp2fPngwZMoSHDx+iUqkYMWIEwcHBanUEBwfTuXNnrK2tARgwYAC3bt3i4MGDnDt3jpYtW9K9e3fu3LmTbwwrV65k6dKlLFmyhIsXL+Lq6sq7777LtWvX8s1/8+ZN+vbtS+/evYmOjsbb25sZM2YU+pw5OTm89dZbRERE8PXXXxMXF8fChQvR1NQEICkpCTc3N/r168fFixfZvn07p06dwsfHp7ivVAghhBAVkHSUhBDF0rx5cz7++GNsbGzw9/dHR0cHY2NjRo4ciY2NDbNmzeLPP//k4sWLAHh6epKQkKBsuZ2VlcWWLVuU84hOnTpFZGQkO3bsoHXr1tjY2LBkyRKqV6/Ozp07841hyZIlTJ8+nffffx87OzsWLVpEixYt1DZOeNratWtp1KgRS5cuxc7OjsGDB+Pp6Vnocx47dozIyEi+/fZb3nzzTaysrOjVqxdvvfUWAEFBQQwePBhfX19l+/BVq1axadMm/v3332K/14yMDP766y+1KzMzs9j1CCGEEGXmNRtSko6SEKJYHB0dla81NTWpVasWzZo1U9JMTU0BuHXrFgB169blnXfe4csvvwTgu+++IyMjgwEDBgAQExNDeno6tWrVQl9fX7mSk5NJSkrK0/5ff/3Fr7/+SseOHdXSO3bsSHx8fL4xx8fH5zn/qH379oU+Z3R0NPXr18fW1jbf+zExMYSEhKjF7OrqSk5ODsnJyYXWnZ+goCCMjIzUro0bNxa7HiGEEKKsvG4HzspmDkKIYqlataraZ5VKpZam+v8LPXNycpQ0b29vhgwZwvLlywkODsbDw4Nq1aoBkJ6ejpmZGeHh4Xnaql69euk/QBHp6uoWej89PZ3Ro0czceLEPPcaNGhQ7Pb8/f3znNGUu4ZLCCGEEOVPOkpCiDL39ttvo6enx9q1azl06BD/+9//lHstW7bkt99+o0qVKlhYWDy3LkNDQ+rWrUtERARdunRR0iMiImjTpk2+Zezt7dm3b59a2pkzZwptx9HRkZ9//pmrV6/mO6rUsmVL4uLilHVWL0pbWxttbW21NC0trVKpWwghhCgNr9mmdzL1TghR9jQ1NfH09MTf3x8bGxu1aW89evSgffv2uLu7c+TIEVJSUvjxxx/56KOPOHv2bL71TZ06lUWLFrF9+3YSEhKYMWMG0dHRTJo0Kd/8Y8aM4dq1a0ydOpWEhAS2bNlCSEhIoTF36dKFzp07069fP44ePUpycjIHDx5UdtebPn06P/74Iz4+PkRHR3Pt2jX27t0rmzkIIYR4Zb1mS5SkoySEKB9eXl5kZmYyfPhwtXSVSsWBAwfo3Lkzw4cPx9bWlvfff58bN24o652eNXHiRPz8/Jg8eTLNmjXj0KFD7Nu3Dxsbm3zzN2jQgF27drFnzx6aN2/OunXrWLBgwXNj3rVrF87OzgwaNIgmTZowbdo0srOzgScjTidOnODq1at06tQJJycnZs2aRd26dYv5ZoQQQohK4jXrKakey2mKQohycPLkSbp3787NmzcL7AAJdZcuyUnrQgghiqZp06Zl3kZU8v1SqcfZ0qhU6ilrMqIkhODzzz/H3NwcDQ0NVqxYQUBAAC1atFDue3p64u7uXqK6MzIy+PnnnwkICGDAgAF5OkkuLi74+voWWoeFhUWBW39XVOHh4ahUKu7duwdASEjIS92cQgghhHhRsuudEOK18tdff+Hj48OyZcvo168fRkZG5OTkMGHChFKpf+vWrXh5edGiRQs2bdpUKnW+iPDwcLp27crdu3crRcfFunHRf0OYeOVShSxTUeMqrzIVNa7yKpOb38LGochtpFy7XOZxlVeZihpXeZXJze88bEOR24gKHVnmcZVXmfKOq6y9bps5SEdJiNdcamoqWVlZvPPOO5iZmSnp+vr6L1RvZmYmWlpaeHp6PvdwVyGEEEKIikam3glRQbi4uDBhwgR8fX2pUaMGpqambNiwgQcPHjB8+HAMDAywtrbm4MGDADx+/Bhra2uWLFmiVk90dDQqlUo5gyc1NZU+ffqgr6+PoaEhAwcO5PfffweeTAfLPSzWysoKlUpFSkpKnql3uQIDAzExMcHQ0JAxY8aQmZmpFr+Pjw++vr4YGxvj6uoKwIkTJ2jTpg3a2tqYmZkxY8YMHj16pFbvo0eP8PHxwcjICGNjY2bOnElhyyeXLVtGs2bN0NPTw9zcnHHjxpGenq7cv3HjBr1796ZGjRro6enh4ODAgQMHSElJoWvXrgDUqFEDlUpVaCcuIiICFxcXqlWrRo0aNXB1deXu3bvAk3OigoKCsLS0RFdXl+bNm7Nz584C6xJCCCEqu9dsLwfpKAlRkYSGhmJsbExkZCQTJkxg7NixDBgwgA4dOnD+/Hl69uzJkCFDePjwISqVihEjRhAcHKxWR3BwMJ07d8ba2pqcnBz69OnDnTt3OHHiBEePHuX69et4eHgA4OHhwbFjxwCIjIwkLS0Nc3PzfGMLCwsjPj6e8PBwtm7dyrfffktgYGCe+LW0tIiIiGDdunX88ssvvP322zg7OxMTE8PatWv54osvmDdvXp5yVapUITIykpUrV7Js2TI2btxY4HvS0NBg1apVXL58mdDQUH744QemTZum3B8/fjwZGRn873//IzY2lkWLFqGvr4+5uTm7du0CICEhgbS0NFauXJlvG9HR0XTv3p0mTZpw+vRpTp06Re/evZVd74KCgti0aRPr1q3j8uXLfPjhh/znP//hxIkTBcYthBBCVGqvWU9Jpt4JUYE0b96cjz/+GAB/f38WLlyIsbExI0c+ma89a9Ys1q5dy8WLF2nXrh2enp7MmjWLyMhI2rRpQ1ZWFlu2bFFGmcLCwoiNjSU5OVnpAG3atAkHBweioqJwdnamVq1aAJiYmFCnTp0CY9PS0uLLL7+kWrVqODg4MGfOHKZOncrcuXPR0HjyOxcbGxsWL16slPnoo48wNzdnzZo1qFQqGjduzK+//sr06dOZNWuWUs7c3Jzly5ejUqmws7MjNjaW5cuXK8/9rKc3f7CwsGDevHmMGTOGzz77DHgyitavXz+10bJcNWvWBKB27dqFrlFavHgxrVu3VuoEcHB4ssYiIyODBQsWcOzYMeVMKCsrK06dOsX69evVDsItqoyMDDIyMtTSnh6xE0IIIUT5khElISoQR0dH5WtNTU1q1aql/LAPKDvG3bp1C4C6devyzjvv8OWXXwLw3XffkZGRwYABAwCIj4/H3NxcbZSoSZMmVK9enfj4+GLF1rx5c6pVq6Z8bt++Penp6dy8eVNJa9WqlVqZ+Ph42rdvj+qp1Z8dO3YkPT2dn3/+WUlr166dWp727dtz7do1ZfTmWceOHaN79+7Uq1cPAwMDhgwZwp9//snDhw+BJ+cszZs3j44dOzJ79mwuXrxYrGeF/xtRyk9iYiIPHz7kzTffRF9fX7k2bdpEUlJSsduCJyNURkZGaldho2pCCCFEeXuZu959+umnWFhYoKOjQ9u2bYmMjCww74YNG+jUqRM1atSgRo0a9OjRo9D8BZGOkhAVSNWqVdU+q1QqtbTczkROTo6S5u3tzbZt2/jnn38IDg7Gw8NDrUNTnvT09Mq8jZSUFHr16oWjoyO7du3i3LlzfPrpp8D/jcB4e3tz/fp1hgwZQmxsLK1bt2b16tXFakdXV7fAe7nrofbv3090dLRyxcXFlXidkr+/P/fv31e7vL29S1SXEEIIURZUqtK5imv79u34+fkxe/Zszp8/T/PmzXF1dVV+cfys8PBwBg0axPHjxzl9+jTm5ub07NmTX375pVjtSkdJiEru7bffRk9Pj7Vr13Lo0CFGjBih3LO3t+fmzZtqoz5xcXHcu3ePJk2aFKudmJgY/vnnH+XzmTNnlHU/BbG3t+f06dNqGzNERERgYGBA/fr1lbSffvpJrdyZM2ewsbFBU1MzT53nzp0jJyeHpUuX0q5dO2xtbfn111/z5DM3N2fMmDF8++23TJ48mQ0bnmxNq6WlBVDgaFUuR0dHwsLC8r3XpEkTtLW1SU1NxdraWu0q7H0URltbG0NDQ7UrN1YhhBDidbZs2TJGjhzJ8OHDadKkCevWraNatWrKjJpnbd68mXHjxtGiRQsaN27Mxo0bycnJKfDf9YJIR0mISk5TUxNPT0/8/f2xsbFR1swA9OjRg2bNmjF48GDOnz9PZGQkQ4cOpUuXLrRu3bpY7WRmZuLl5UVcXBwHDhxg9uzZ+Pj4KOuM8jNu3Dhu3rzJhAkTuHLlCnv37mX27Nn4+fmplUtNTcXPz4+EhAS2bt3K6tWrmTRpUr51Wltbk5WVxerVq7l+/TpfffUV69atU8vj6+vL4cOHSU5O5vz58xw/fhx7e3sAGjZsiEql4vvvv+ePP/5Q2y3vaf7+/kRFRTFu3DguXrzIlStXWLt2Lbdv38bAwIApU6bw4YcfEhoaSlJSEufPn2f16tWEhoYW670KIYQQlUVp7eWQkZHBX3/9pXY9u043V2ZmJufOnaNHjx5KmoaGBj169OD06dNFivvhw4dkZWUp65SLSjpKQrwCvLy8yMzMZPjw4WrpKpWKvXv3UqNGDTp37kyPHj2wsrJi+/btxW6je/fu2NjY0LlzZzw8PHj33XcJCAgotEy9evU4cOAAkZGRNG/enDFjxuDl5aVsWJFr6NCh/PPPP7Rp04bx48czadIkRo0alW+dzZs3Z9myZSxatIimTZuyefNmgoKC1PJkZ2czfvx47O3tcXNzw9bWVtmUoV69egQGBjJjxgxMTU3x8fHJtx1bW1uOHDlCTEwMbdq0oX379uzdu5cqVZ7sgTN37lxmzpxJUFCQ0s7+/fuxtLQsyusUQgghKp9S6inlty732X/Lc92+fZvs7GxlnXYuU1NTfvvttyKFPX36dOrWravW2SrS4z4u7LASIUSlcPLkSbp3787Nmzfz/EUiKq9Ll8rnpHUhhBCVX9OmTcu8jYs385+FUVx2tavmGUHS1tZGW1s7T95ff/2VevXq8eOPP6rNmpk2bRonTpzIM33/WQsXLmTx4sWEh4erbZpVFLI9uBCVWEZGBn/88QcBAQEMGDBAOklF4Onpyb1799izZ8/LDkUIIYR4LRXUKcqPsbExmpqa/P7772rpv//+e6HHmgAsWbKEhQsXcuzYsWJ3kkA6SkJUalu3bsXLy4sWLVqwadOmlx1OpbBy5UpKcyDdwsICX19ftbOdSpN146L/hjDxyqUKWaaixlVeZSpqXOVVpqLGVV5lKmpc5VXmRdpwHrLuOTn/T9RXY0rcTkV9/pKUKWsl2bHuRWlpadGqVSvCwsJwd3cHUDZmKGj6PDw5D3H+/PkcPny42Ouyc0lHSYhKzNPTE09Pz5cdRqWQnZ2NSqXCyMjoZYcihBBCVEovoZ8EgJ+fH8OGDaN169a0adOGFStW8ODBA2Vt9tChQ6lXr56yzmnRokXMmjWLLVu2YGFhoaxlyj33sKhkMwchRIXk4uKCj48PPj4+GBkZYWxszMyZM5XRoIyMDKZMmUK9evXQ09Ojbdu2hIeHK+VDQkKoXr06+/btU9vO29PTU/mNFDz5rdTixYuxtrZGW1ubBg0aMH/+fAC6deuW57dVf/zxB1paWoSFheHi4sKNGzf48MMPUalUaofmnjp1ik6dOqGrq4u5uTkTJ07kwYMHZffChBBCiFeUh4cHS5YsYdasWbRo0YLo6GgOHTqkLDlITU0lLS1Nyb927VoyMzPp378/ZmZmyrVkyZJitSsdJSFEhRUaGkqVKlWIjIxk5cqVLFu2jI0bNwLg4+PD6dOn2bZtGxcvXmTAgAG4ublx7do1pfzDhw9ZtGgRGzdu5PLly9SuXTtPG/7+/ixcuJCZM2cSFxfHli1blL94vb292bJli9qC06+//pp69erRrVs3vv32W+rXr8+cOXNIS0tT/pJOSkrCzc2Nfv36cfHiRbZv386pU6cKnSIghBBCVHiltT94Cfj4+HDjxg0yMjL46aefaNu2rXIvPDyckJAQ5XNKSgqPHz/Ocz1vt95nydQ7IUSFZW5uzvLly1GpVNjZ2REbG8vy5ctxdXUlODiY1NRU6tatC8CUKVM4dOgQwcHBLFiwAICsrCw+++wzmjdvnm/9f//9NytXrmTNmjUMGzYMgEaNGvHGG28A0LdvX3x8fNi7dy8DBw4EnoxUeXp6olKpqFmzJpqamhgYGKgtKA0KCmLw4MHKuiUbGxtWrVpFly5dWLt2LTo6OnliycjIyLMDUGZm5gu8PSGEEKJ0qV7a5LuXQ0aUhBAVVrt27dSms7Vv355r164RGxtLdnY2tra2ynxjfX19Tpw4QVJSkpJfS0ur0F1u4uPjycjIoHv37vne19HRYciQIcrJ3+fPn+fSpUvPXRcWExNDSEiIWmyurq7k5OSQnJycb5n8zpTIHT0TQgghRPmTESUhRKWTnp6OpqYm586dQ1NTU+3e04s0dXV11Tpaz9LV1X1uW97e3rRo0YKff/6Z4OBgunXrRsOGDZ8b3+jRo5k4cWKeew0aNMi3jL+/P35+fmppiYmJz41PCCGEKC8vY9e7l0k6SkKICuvZQ+TOnDmDjY0NTk5OZGdnc+vWLTp16lTi+m1sbNDV1SUsLAxvb+988zRr1ozWrVuzYcMGtmzZwpo1a9Tua2lpkZ2drZbWsmVL4uLisLa2LnIs+Z0poaWlVeTyQgghRFl7zfpJMvVOCFFxpaam4ufnR0JCAlu3bmX16tVMmjQJW1tbBg8ezNChQ/n2229JTk4mMjKSoKAg9u/fX+T6dXR0mD59OtOmTWPTpk0kJSVx5swZvvjiC7V83t7eLFy4kMePH/Pee++p3bOwsOB///sfv/zyC7dv3wZg+vTp/Pjjj/j4+BAdHc21a9fYu3evbOYghBBCVCIyoiSEqLCGDh3KP//8Q5s2bdDU1GTSpEmMGjUKgODgYObNm8fkyZP55ZdfMDY2pl27dvTq1atYbcycOZMqVaowa9Ysfv31V8zMzBgzZoxankGDBuHr68ugQYPybMQwZ84cRo8eTaNGjcjIyODx48c4Ojpy4sQJPvroIzp16sTjx49p1KgRHh4eL/ZChBBCiJfpNRtSUj0uzSPqhRAiHxYWFvj6+iq7wBWFi4sLLVq0YMWKFWUWV1GlpKTQqFEjoqKiaNmyZZHLeXp6cu/ePfbs2QMU/5kuXSqfk9aFEEJUfk2bNi3zNq6kPSyVehqbVSuVesqajCgJIUQBsrKy+PPPP/n4449p165dsTpJQgghxKtGNnMQQggBQEREBF27dsXW1padO3e+lBisGxf9N4SJVy5VyDK5+a1sHYrcxvWrl8s8rvIqU1HjKq8yFTWu8ipTUeMqrzLlHZez38Eil4la9laZx1bezy9Kl2zmIIR4IS4uLvj4+ODj44ORkRHGxsbMnDmTwmb1Llu2jGbNmqGnp4e5uTnjxo0jPT1duX/jxg0MDAwIDQ1FT08PBwcHDhw4ADw5fVulUnH48GGcnJzQ1dWlW7du3Lp1i4MHD2Jvb4+hoSEffPABDx/+3xSBQ4cO8cYbb1C9enVq1apFr1691M5cyk/nzp1ZtGgR2dnZtG7dmgYNGjB//nzl/s2bNxk4cCDVq1enZs2a9OnTh5SUlBK+SSGEEKJiU5XSVVlIR0kI8cJCQ0OpUqUKkZGRrFy5kmXLlhV6WKqGhgarVq3i8uXLhIaG8sMPPzBt2jTl/vjx48nIyOB///sfsbGxLFq0SO18JICAgADWrFnDjz/+qHRYVqxYwZYtW9i/fz9Hjhxh9erVSv4HDx7g5+fH2bNnCQsLQ0NDg/fee4+cnJwC4/T392fhwoXMnDmTuLg4tmzZgqmpKfBkWp6rqysGBgacPHmSiIgI9PX1cXNzIzMzs6SvUgghhKi4XrOekky9E0K8MHNzc5YvX45KpcLOzo7Y2FiWL1/OyJEj883/9KYOFhYWzJs3jzFjxvDZZ58BT7YF79evH82aNQPAysoqTx3z5s2jY8eOAHh5eeHv709SUpKSt3///hw/fpzp06cD0K9fP7XyX375JSYmJsTFxeW7APbvv/9m5cqVrFmzhmHDhgHQqFEj3njjDQC2b99OTk4OGzduVA61DQ4Opnr16oSHh9OzZ8+ivTwhhBBCVEgyoiSEeGHt2rVTOgsA7du359q1a3kOYs117NgxunfvTr169TAwMGDIkCH8+eefylS5iRMnKh2h2bNnc/HixTx1ODo6Kl+bmppSrVo1tQ6Vqakpt27dUj5fu3aNQYMGYWVlhaGhIRYWFsCTTll+4uPjycjIoHv37vnej4mJITExEQMDA/T19dHX16dmzZr8+++/z53Sl5+MjAz++usvtUtGpoQQQlQkqlL6r7KQjpIQolylpKTQq1cvHB0d2bVrF+fOnePTTz8FUDoG3t7eXL9+nSFDhhAbG0vr1q3VptEBVK1aVflapVKpfc5Ne3paXe/evblz5w4bNmzgp59+4qefflJr81m6urqFPkd6ejqtWrUiOjpa7bp69SoffPBBEd/G/wkKCsLIyEjtKmz6ohBCCFHeVKrSuSoL6SgJIV5Ybqcj15kzZ7CxsUFTUzNP3nPnzpGTk8PSpUtp164dtra2/Prrr3nymZubM2bMGL799lsmT57Mhg0bShzfn3/+SUJCAh9//DHdu3fH3t6eu3fvFlrGxsYGXV1dwsLC8r3fsmVLrl27Ru3atbG2tla7jIyMih2jv78/9+/fV7u8vb2LXY8QQgghSod0lIQQLyw1NRU/Pz8SEhLYunUrq1evZtKkSfnmtba2Jisri9WrV3P9+nW++uor1q1bp5bH19eXw4cPk5yczPnz5zl+/Dj29vYljq9GjRrUqlWLzz//nMTERH744Qf8/PwKLaOjo8P06dOZNm0amzZtIikpiTNnzvDFF18AMHjwYIyNjenTpw8nT54kOTmZ8PBwJk6cyM8//1zsGLW1tTE0NFS7tLS0SvS8QgghRFl4zfZykM0chBAvbujQofzzzz+0adMGTU1NJk2axKhRo/LN27x5c5YtW8aiRYvw9/enc+fOBAUFMXToUCVPdnY248eP5+eff8bQ0BA3NzeWL19e4vg0NDTYtm0bEydOpGnTptjZ2bFq1SpcXFwKLTdz5kyqVKnCrFmz+PXXXzEzM2PMmDEAVKtWjf/9739Mnz6dvn378vfff1OvXj26d++OoaFhiWMVQgghKqzK1MspBdJREkK8sKpVq7JixQrWrl2b7/1nzxb68MMP+fDDD9XShgwZonz97Hqkp7m4uOQ5o8nT0xNPT0+1tICAAAICApTPPXr0IC4uTi1PYWc9wZMO1kcffcRHH32U7/06deoQGhpaYPmQkBC1z+Hh4YW2J4QQQoiKQ/X4eT8pCFHBWFhY4Ovrq7bFtHgiPDycrl27cvfuXapXr55vnpCQEHx9fbl3716R601JScHS0pILFy7QokULtXsuLi60aNGCFStWlDjup6lUKnbv3o27u3uBeYr6DEWpqyw93X5h77Agly7JSetCCCGKJr+jLkrb9T/+LZV6rEx0SqWesiZrlISogMLDw1GpVMXqzAB06NCBtLS0Em0mUJl4eHhw9epV5XNAQEC+nY+0tDTeeuutcoxMCCGEeHW9brveydQ7IV4hWlpa1KlTp1zbLO/pZFlZWejq6j53+26g3N9FWbBuXPTfECZeuVQhy1TUuMqrTEWNq7zKVNS4yqtMRY2rvMpU1LieLuPsd7DIZaKWvVWsdsr7WcpaJerjlAoZURIViouLCz4+Pvj4+GBkZISxsTEzZ84sdC3JsmXLaNasGXp6epibmzNu3DjS09OV+zdu3KB3797UqFEDPT09HBwcOHDgAPB/IzeHDx/GyckJXV1dunXrxq1btzh48CD29vYYGhrywQcfKIehAhw6dIg33niD6tWrU6tWLXr16pXnkNGff/6ZQYMGUbNmTfT09GjdujU//fQTKSkpaGhocPbsWbX8K1asoGHDhly/fp2uXbsCT3ZrU6lUyvqbjIwMJk6cSO3atdHR0eGNN94gKipKqSO/kaiQkBAaNGhAtWrVeO+99/jzzz+f+32IjIzEyckJHR0dWrduzYULF/LkuXTpEm+99Rb6+vqYmpoyZMgQbt++rdx3cXFh4sSJTJs2jZo1a1KnTh21NUPw5BDYzp07o6OjQ5MmTTh69Kja/ZSUFFQqFdu3b6dLly7o6OiwefNmQkJClKmFISEhBAYGEhMTg0qlQqVSKWuDVCoVe/bsee73pCDPy793715atmyJjo4OVlZWBAYG8ujRo+e+XyGEEEJUfNJREhVOaGgoVapUITIykpUrV7Js2bJCD97U0NBg1apVXL58mdDQUH744QemTZum3B8/fjwZGRn873//IzY2lkWLFqGvr69WR0BAAGvWrOHHH3/k5s2bDBw4kBUrVrBlyxb279/PkSNH1DYYePDgAX5+fpw9e5awsDA0NDR47733lANO09PT6dKlC7/88gv79u0jJiaGadOmkZOTg4WFBT169CA4OFgthuDgYDw9PWnYsCG7du0CICEhgbS0NFauXAnAtGnT2LVrF6GhoZw/fx5ra2tcXV25c+dOvu/mp59+wsvLCx8fH6Kjo+natSvz5s0r9P2np6fTq1cvmjRpwrlz5wgICGDKlClqee7du0e3bt1wcnLi7NmzHDp0iN9//52BAweq5QsNDUVPT4+ffvqJxYsXM2fOHKUzlJOTQ9++fdHS0uKnn35i3bp1TJ8+Pd+YZsyYwaRJk4iPj8fV1VXtnoeHB5MnT8bBwYG0tDTS0tLw8PDI97kK+p4U9B4Ky3/y5EmGDh3KpEmTiIuLY/369YSEhDB//vxC368QQghRab1m+4PL1DtR4Zibm7N8+XJUKhV2dnbExsayfPlyRo4cmW/+pzd1sLCwYN68eYwZM4bPPvsMeHLGT79+/WjWrBkAVlZWeeqYN28eHTt2BMDLywt/f3+SkpKUvP379+f48ePKD/L9+vVTK//ll19iYmJCXFwcTZs2ZcuWLfzxxx9ERUVRs2ZN4Mn5Qbm8vb0ZM2YMy5YtQ1tbm/PnzxMbG8vevXvR1NRUytSuXVsZOXnw4AFr164lJCREWXezYcMGjh49yhdffMHUqVPzPNfKlStxc3NTOo62trb8+OOPHDp0qKDXz5YtW8jJyeGLL75AR0cHBwcHfv75Z8aOHavkWbNmDU5OTixYsEDtHZibm3P16lVsbW0BcHR0ZPbs2cCTA1zXrFlDWFgYb775JseOHePKlSscPnyYunXrArBgwYJ81xT5+vrSt2/ffOPV1dVFX1+fKlWqFDrV7nnfk+LmDwwMZMaMGQwbNgx48udq7ty5TJs2TXlmIYQQ4lWiqky9nFIgI0qiwmnXrh2qp1b6tW/fnmvXrpGdnZ1v/mPHjtG9e3fq1auHgYEBQ4YM4c8//1Smyk2cOFHpCM2ePZuLFy/mqcPR0VH52tTUlGrVqql1qExNTbl165by+dq1awwaNAgrKysMDQ2xsLAAnnTKAKKjo3FyclJ+wH6Wu7s7mpqa7N69G3gyfaxr165KPflJSkoiKytL6dDBk22527RpQ3x8fL5l4uPjadu2rVpa+/btC2wjt4yjoyM6Ov+3I82zZWJiYjh+/Dj6+vrK1bhxYyXOXE+/VwAzMzPlPcbHx2Nubq50kgqLrXXr1oXGXBTP+54UN39MTAxz5sxRewcjR44kLS1NbZpmUWVkZPDXX3+pXZmZmcWuRwghhBClQzpKolJLSUmhV69eODo6smvXLs6dO8enn34KoPyQ6e3tzfXr1xkyZAixsbG0bt06zzk9VatWVb5WqVRqn3PTnp6i1bt3b+7cucOGDRv46aeflHUruW0+b6MBLS0thg4dSnBwMJmZmWzZsoURI0aU8C2Uv/T0dHr37k10dLTalbvmKNfz3mNR6enpvXDMRdn8oTj509PTCQwMVHv+2NhYrl27ptbJLKqgoCCMjIzUrsKmnAohhBDl7XXb9U46SqLCeXZx/ZkzZ7CxsUFTUzNP3nPnzpGTk8PSpUtp164dtra2/Prrr3nymZubM2bMGL799lsmT57Mhg0bShzfn3/+SUJCAh9//DHdu3fH3t6eu3fvquVxdHQkOjq6wLVD8KQDd+zYMT777DMePXqkNrVMS0sLQG0UrVGjRmhpaREREaGkZWVlERUVRZMmTfJtw97ePt/3WRh7e3suXrzIv//+31kJz5Zp2bIlly9fxsLCAmtra7WrqJ0ae3t7bt68SVpaWpFjK4iWllaBI465ivI9KU7+li1bkpCQkOf5ra2t0dAo/l+t/v7+3L9/X+3y9vYudj1CCCFEWXnNlihJR0lUPKmpqfj5+ZGQkMDWrVtZvXo1kyZNyjevtbU1WVlZ4KoQQwABAABJREFUrF69muvXr/PVV1+xbt06tTy+vr4cPnyY5ORkzp8/z/Hjx7G3ty9xfDVq1KBWrVp8/vnnJCYm8sMPP+Dn56eWZ9CgQdSpUwd3d3ciIiK4fv06u3bt4vTp00oee3t72rVrx/Tp0xk0aJDaCEbDhg1RqVR8//33/PHHH6Snp6Onp8fYsWOZOnUqhw4dIi4ujpEjR/Lw4UO8vLzyjXXixIkcOnSIJUuWcO3aNdasWVPo+iSADz74AJVKxciRI4mLi+PAgQMsWbJELc/48eO5c+cOgwYNIioqiqSkJA4fPszw4cOf22HJ1aNHD2xtbRk2bBgxMTGcPHmSjz76qEhln2VhYUFycjLR0dHcvn2bjIyMPHmK8j0pTv5Zs2axadMmAgMDuXz5MvHx8Wzbto2PP/64RM+gra2NoaGh2pXbYRZCCCFE+ZOOkqhwhg4dyj///EObNm0YP348kyZNYtSoUfnmbd68OcuWLWPRokU0bdqUzZs3ExQUpJYnOzub8ePHY29vj5ubG7a2tspGDyWhoaHBtm3bOHfuHE2bNuXDDz/kk08+UcujpaXFkSNHqF27Nm+//TbNmjVj4cKFeUbFvLy8yMzMzDPtrl69espmAaampvj4+ACwcOFC+vXrx5AhQ2jZsiWJiYkcPnyYGjVq5Btru3bt2LBhAytXrqR58+YcOXLkuT/I6+vr89133xEbG4uTkxMfffQRixYtUstTt25dIiIiyM7OpmfPnjRr1gxfX1+qV69e5NEUDQ0Ndu/erXyvvb29S7xjXL9+/XBzc6Nr166YmJiwdevWPHmK+j0pan5XV1e+//57jhw5grOzM+3atWP58uU0bNiwRM8ghBBCVHSv29Q71ePCDqgRopy5uLjQokULVqxY8bJDKRdz585lx44d+W4wIcSlS5cq9CGNFfXAxYpWpqLGVV5lKmpc5VWmosZVXmUqalxPl3lVDpxt2rTo+Uvq57uls8lQ/RqVY8aEdJREhfK6dJTS09NJSUmhe/fuzJs3r8CtzyuilJQULC0tuXDhAi1atHjZ4VRY4eHhdO3albt371K9enVCQkLw9fVVOwz4eS5dKp+T1oUQQlR+0lEqfTL1ToiXwMfHh1atWuHi4lKpdrsrKU9PT9zd3V9K2wEBAahUqkIvIYQQQjzf6zb1Tg6cFRVKeHj4yw6hXISEhBASElJq9WVmZr4WC/9L8pxTpkxhzJgxymdnZ2dGjRpVaUbxSjJdw8rWochlrl+9XOJ2KuLUEwDLYjx/8iv4/BWtTEWNq7zKVNS4yqtMRY3rRcu8ERRdpPyn/FuUa1xlrRL1cUqFjCgJUQm5uLjg4+ODr68vxsbGuLq6Ak+mar311lvo6+tjamrKkCFDuH37tlLu77//ZvDgwejp6WFmZsby5ctxcXHB19dXyaNSqdizZ49ae7lTx/KTnZ2Nl5cXlpaW6OrqYmdnx8qVK5X7AQEBhIaGsnfvXmUEJ7dDHBsbS7du3dDV1aVWrVqMGjWK9PR0pWzuSNT8+fOpW7cudnZ2zJkzJ9/pBS1atGDmzJl50vX19alTp45yaWpqYmBgoJZWkIiICFxcXKhWrRo1atTA1dVV2Qo+JyeHoKAg5bmbN2/Ozp07C6xLCCGEqOxetxEl6SgJUUmFhoYq5yqtW7eOe/fu0a1bN5ycnDh79iyHDh3i999/Z+DAgUoZPz8/IiIi2LdvH0ePHuXkyZOcP3/+heLIycmhfv367Nixg7i4OGbNmsV///tfvvnmG+DJiM7AgQNxc3MjLS2NtLQ0OnTowIMHD3B1daVGjRpERUWxY8cOjh07puzwlyssLIyEhASOHj3K999/z4gRI4iPjycqKkrJc+HCBS5evMjw4cNf6FmeFh0dTffu3WnSpAmnT5/m1KlT9O7dW9n+PCgoiE2bNrFu3TouX77Mhx9+yH/+8x9OnDhRajEIIYQQ4uWRqXdCVFI2NjYsXrxY+Txv3jycnJxYsGCBkvbll19ibm7O1atXMTMzIzQ0lC1bttC9e3cAgoODqVu37gvFUbVqVQIDA5XPlpaWnD59mm+++YaBAweir6+Prq4uGRkZaqM3oaGh/Pvvv2zatEk5pHbNmjX07t2bRYsWYWpqCoCenh4bN25Um3Ln6upKcHAwzs7OynN06dIFKyurF3qWpy1evJjWrVurbSXv4PBkSldGRgYLFizg2LFjtG/fHgArKytOnTrF+vXr6dKlS6nFIYQQQlQUqtds8p10lISopFq1aqX2OSYmhuPHj6Ovr58nb1JSEv/88w9ZWVm0adNGSTcyMsLOzu6FY/n000/58ssvSU1N5Z9//iEzM/O5O+LFx8fTvHlzpZME0LFjR3JyckhISFA6Ss2aNcuzLmnkyJGMGDGCZcuWoaGhwZYtW1i+fPkLP8fToqOjGTBgQL73EhMTefjwIW+++aZaemZmJk5OTiVqLyMjI89BuZmZpbO7kBBCCFEqXq9+knSUhKisnu5gwJMtx3NHY55lZmZGYmJikepVqVQ8e2pAVlZWgfm3bdvGlClTWLp0Ke3bt8fAwIBPPvmEn376qUjtPc+zzwnQu3dvtLW12b17N1paWmRlZdG/f/9SaS+Xrq5ugfdy11Ht37+fevXqqd3T1tYuUXtBQUFqI3MAY8eOZdmqkh+OLIQQQoiSk46SEK+Ili1bsmvXLiwsLKhSJe//2lZWVlStWpWoqCgaNGgAwP3797l69SqdO3dW8pmYmJCWlqZ8vnbtGg8fPiyw3YiICDp06MC4ceOUtKSkJLU8WlpaytqeXPb29oSEhPDgwQOlMxQREYGGhsZzR7mqVKnCsGHDCA4ORktLi/fff7/Qjk1JODo6EhYWlqfzAtCkSRO0tbVJTU0ttWl2/v7++Pn5qaUVtXMrhBBClIfXbEBJNnMQ4lUxfvx47ty5w6BBg4iKiiIpKYnDhw8zfPhwsrOzMTAwYNiwYUydOpXjx49z+fJlvLy80NDQUDtLqFu3bqxZs4YLFy5w9uxZxowZQ9WqVQts18bGhrNnz3L48GGuXr3KzJkz1TZaALCwsODixYskJCRw+/ZtsrKyGDx4MDo6OgwbNoxLly5x/PhxJkyYwJAhQ5Rpd4Xx9vbmhx9+4NChQ2VyFpW/vz9RUVGMGzeOixcvcuXKFdauXcvt27cxMDBgypQpfPjhh4SGhpKUlMT58+dZvXo1oaGhJWpPW1sbQ0NDtet12PJdCCFE5SG73gkhKqW6desSERFBdnY2PXv2pFmzZvj6+lK9enU0NJ78r75s2TLat29Pr1696NGjBx07dsTe3h4dHR2lnqVLl2Jubk6nTp344IMPmDJlCtWqVSuw3dGjR9O3b188PDxo27Ytf/75p9roEjxZU2RnZ0fr1q0xMTEhIiKCatWqcfjwYe7cuYOzszP9+/ene/furFmzpkjPa2NjQ4cOHWjcuDFt27YtwRsrnK2tLUeOHCEmJoY2bdrQvn179u7dq4zWzZ07l5kzZxIUFIS9vT1ubm7s378fS0vLUo9FCCGEEOVPpt4JUQkVdDCvjY0N3377bYHlDAwM2Lx5s/L5wYMHBAYGMmrUKCWtbt26HD58WK3cvXv3lK8tLCzU1jBpa2sTHBxMcHCwWpmgoCDlaxMTE44cOZInnmbNmvHDDz8UGG9hh/I+fvyYX3/9NU+n7HlSUlKKnLdLly5ERETke0+lUjFp0iQmTZqU730XFxe19+Tp6Ymnp2dxQhVCCCEqlNdt1zvV42dXbQshKjSVSsXu3btxd3cvdtkLFy5w5coV2rRpw/3795kzZw7h4eEkJiZibGxc+sHypFPXtWtX7t69qxxc6+vrq9b5+vzzz5k7dy6//PILy5YtUzsANz9Tp05l69at3Lt3j5s3b1KjRo0yif1FBQQEsGfPHqKjo4EnnaV79+7lOdC3IJculc9J60IIISq//A5jL21/pD8qlXpM9CvHWI1MvRPiOVxcXJ77g3t5SktL46233gKejI6oVCrlB/GiWLJkCc2bN6dHjx48ePCAkydPllknKT8eHh5cvXpV+fzXX3/h4+PD9OnT+eWXX9RGtwqyZMkS/vnnHz7//PMK20kSQgghROVWObpzQlRwjx8/Jjs7O9/d5krb04e2FpeTkxPnzp0rxWiKT1dXV22HutTUVLKysnjnnXcwMzMrUh2v00C4deOi/4Yw8cqlClmmosZVXmUqalzlVaaixvV0mYbWTYpc5kZiXLHayW3D0tahyG0kX71crDaebqeilamocZVXmdz8zlPyTj8vSNSSniWOq6y9XhPvZERJiEJ5enpy4sQJVq5ciUqlQqVSkZKSQnh4OCqVioMHD9KqVSu0tbU5deoUSUlJ9OnTB1NTU/T19XF2dubYsWNqdVpYWLBgwQJGjBiBgYEBDRo04PPPP1fuZ2Zm4uPjg5mZGTo6OjRs2FBtvY9KpVKmbuVuHODk5IRKpcLFxSXf58jOzsbLywtLS0t0dXWxs7Nj5cqVeZ7V3d2dBQsWYGpqSvXq1fl/7J13VBTJ2sZrDAhIEgTJGZEkkoMISA4GFBVFxSxmMYAoKmYx54CKYs4JFTHnHBDMiglEEEVQyczM8/0xp2unGUDdu7vXvV//7tlzZbqru7q7pqeeetOsWbMIn88n0dHRRFlZmWhra7NikRiL1p49e4irqyuRlpYmlpaW5NKlS3Xe0+TkZKKkpET/bWVlRQgRpS/n8Xhk1qxZREVFRaL4akhICOnbty8hROTSJl7Qlun74sWLiYaGBlFRUSEjR45k1X/Ky8sjwcHBREZGhhgYGJBdu3YRfX19snz58jr7SgghmzdvJhYWFqRJkyZEQ0ODjBo1im4rLi4mgwcPJqqqqkRBQYF4eXmRjIyMeo/HwcHBwcHxb4XLesfBwUFZsWIFcXFxIUOGDCF5eXkkLy+P6Ojo0O2xsbEkISGBPH36lLRu3ZqUlJSQoKAgcu7cOZKenk4CAgJIx44dSXZ2Nuu4S5YsIfb29iQ9PZ2MGDGCDB8+nDx//pwQQsjKlStJSkoK2bdvH3n+/DnZuXMn0dfXr7V/t2/fJoQQcvbsWZKXl1dnIgehUEi0tbXJ/v37yZMnT8j06dPJlClTyL59+1j7nT9/nnz48IFcvnyZLF26lMTHx5MOHTqQZs2akVu3bpFhw4aRyMhI8v79e1a76OhoMmHCBJKenk5cXFxIx44dSWFh4Q/vb1hYGBWSt2/fJnl5eWTChAlEIBCQlJQUul9BQQE5ceJEvWnAL1y4QF69ekUuXLhAtm7dSpKTk1nJICIiIsiHDx/IxYsXycGDB8mGDRtIQUFBvf1bt24dGTlyJBk6dCh5+PAhSUlJIcbGxnR79+7dSUFBATl58iS5d+8esbW1Jd7e3uTLly8/vHYODg4ODo5/G7y/6H//FjjXOw6OelBUVCRSUlJEVla2Vpe3WbNmEV9fX/q3srIysba2pn/Pnj2bHD58mKSkpLAsEUFBQTRb26RJk8iyZcvIhQsXiKmpKcnOziYmJibEzc2N8Hg8oqenV2f/VFVVCSGEqKio1OuS17hxY1bhVAMDA3Ljxg2yb98+0qNHD1b/V65cSYu+Lly4kJSVlZEpU6YQQkS1hRISEsjVq1dJz549abtRo0aR0NBQQohIXKSlpZGkpCQSExNTZ58IEbnhqaio0GthriE8PJxs2bKFdO/enRBCyI4dO4iurm6dFjNCCGnWrBlZvXo1adiwIWnVqhUJDg4m586dI0OGDCHPnj0jZ8+eJXfu3CH29vaEEEI2bdpETExM6u3fnDlzyIQJE1iZ7RwcHAghhFy9epXcvn2bFBQUkCZNmhBCRLFTR44cIQcOHPipWCsODg4ODg6O3xdOKHFw/Acwk26GkpISMmPGDHLixAmSl5dH+Hw+KS8vl7AotW7dmv6bx+MRdXV1at3o378/8fX1JaampiQgIIB06NCB+Pn5/cd9XbNmDdm8eTPJzs4m5eXlpKqqiuW+RgghFhYWtOYSIYS0aNGClUWnYcOGREVFRcIS4+LiQv/dqFEjYm9vT54+ffqn+zpkyBDi4OBAcnNziZaWFklOTib9+/dnFcatiYWFBWnYsCH9W0NDgzx8+JAQQsjz589Jo0aNiK2tLd1ubGxcbyKIgoIC8uHDB+Lt7V3r9oyMDFJSUkKFHkN5eTl59erVT12nOJWVlRLuhlVVVb98HA4ODg4Ojr+Lf5Pb3F8BJ5Q4OP4DmjZtyvp74sSJ5MyZM2Tx4sXE2NiYyMjIkG7duklMeBs3bsz6m8fjEaFQSAghxNbWlrx584acPHmSnD17lvTo0YP4+PiQAwcO/Ol+7tmzh0ycOJEsWbKEuLi4EHl5ebJo0SJy69atH/arvr7+XdjY2BBra2uybds24ufnRx4/fkxOnDhRb5u/up/iCSdqo6SkhGhoaNRa04qJwfoV5s+fz7L6EULI8OHDydKVa3/5WBwcHBwcHBz/OZxQ4uD4AVJSUkQgEPzUvteuXSP9+/cnXbp0IYSIJtO/UuCUQUFBgYSFhZGwsDDSrVs3EhAQQL58+UKUlZUl+kYI+WH/rl27RlxdXVnFWf+M1aMubt68Sdzd3QkhhPD5fHLv3j2Wq+GfYfDgwWT58uUkNzeX+Pj4sGLDfhVTU1PC5/NJeno6sbOzI4QQkpWVRYqKiupsIy8vT/T19cm5c+dI+/btJbbb2tqS/Px80qhRozpjyH6FyZMnk/Hjx7M+y8rK+o+Py8HBwcHBwfHn4JI5cHD8AH19fXLr1i3y9u1b8vnz53qtFCYmJuTQoUPkwYMHJCMjg4SHh/+yVWPp0qVk9+7d5NmzZ+TFixdk//79RF1dvVYrhZqaGpGRkSFpaWnk48eP5OvXr3X26+7du+TUqVPkxYsXZNq0aeTOnTu/1K/6WLNmDTl8+DB59uwZGTlyJCkqKqo38cLPEB4eTt6/f082btz4Hx+rVatWxMfHhwwdOpTcvn2bpKenk6FDhxIZGZl63flmzJhBlixZQlauXElevnxJ7t+/T1atWkUIIcTHx4e4uLiQkJAQcvr0afL27Vty/fp1EhcXR+7evfvLfWzSpAlRUFBg/ccIYQ4ODg4Ojt8BLusdBwcHi4kTJ5KGDRsSc3NzoqqqKhFvJM7SpUtJs2bNiKurK+nYsSPx9/dnxcX8DPLy8mThwoXE3t6eODg4kLdv35LU1FRW7BBDo0aNyMqVK0liYiLR1NQknTt3rvWYkZGRpGvXriQsLIw4OTmRwsJClnXpPyUhIYEkJCQQa2trcvXqVZKSkvIfF7FVVFQkoaGhRE5OjoSEhPzHfdy2bRtp0aIFcXd3J126dCFDhgwh8vLyRFpaus42/fr1I8uXLydr164lFhYWpEOHDuTly5eEEJFrX2pqKnF3dycDBgwgLVu2JD179iTv3r0jLVq0+I/7y8HBwcHB8bvx/y3rHQ//nyo3cnBw/KW8ffuWGBgYkPT0dInEEH8F3t7exMLCgqxcufIvP/b79++Jjo4OOXv2bJ0JG/7bPHr06Lcrnvhn2vyu/fqn2vyu/fqn2vyu/RJvwxWc/f/9/P9XCs6KJ1/6u/ha/tfEKCvK/DtsNZxQ4uD4zeDxeOTw4cN/iRXlr8bT05O0adOGFmn9s0JJX1+fREVFkaioqFq3FxUVkYsXL5Ju3bqRJ0+eEFNTU4l9+vfvT4qLi2nx3Zp9q8n58+dJSUkJsbKyInl5eSQyMpI8evSIFBQU0DTrfzU1r/NXn+2jR/9MpXUODg4Ojn8//4RQ+lbx1wglBel/h1DikjlwcPxm5OXl1Zu2+t9EcnIyiYqKIsXFxb/UzsbGhhQVFZEFCxbUKpJq49ChQxKZ78Sprq4mU6ZMIa9fvyby8vK0hlJ9bTg4ODg4ODj+4N/jNPfXwAklDo7fjPoKx/5u6Ovrk7/DKP1nMgXWzAhYE39/f+Lv70//vnjxYq3Z7H43fjc3kj/T5nft1z/V5j85h5ah2U+3yX399E+f53e9/v+FNr9rv/6pNr9rv/6pNv/JORyG7vrpNnc2hP/0vhw/z7/D7sXB8S9gw4YNRFNTUyLLXefOnVlZ244ePUpsbW2JtLQ0MTQ0JDNnziR8Pp9u5/F41J3s7du3hMfjkUOHDpH27dsTWVlZYm1tTW7cuFFvX4qLi8ngwYOJqqoqUVBQIF5eXiQjI4NunzFjBmnTpg3Zvn070dfXJ4qKiqRnz57k+/fvdJ/S0lISERFB5OTkiIaGBlmyZInEeYqKikhERARp1qwZkZWVJYGBgTTZwcWLF8mAAQPI169fCY/HIzwej8yYMYO2LSsrIwMHDiTy8vJEV1eXbNiwgXXsnJwc0qNHD6KkpESUlZVJ586d6xVQnp6eLFe+7du3E3t7eyIvL0/U1dVJeHi4RKHcH1FcXEwiIyNJixYtiLS0NLG0tCTHjx+n269evUratWtHZGRkiI6ODhkzZgwpLS39pXNwcHBwcHD8a+D9Rf/9S+CEEgfHX0T37t1JYWEhuXDhAv3sy5cvJC0tjfTu3ZsQQsiVK1dIREQEGTt2LHny5AlJTEwkycnJZO7cufUeOy4ujkycOJE8ePCAtGzZkvTq1YslrmrrS0FBATl58iS5d+8esbW1Jd7e3uTLly90n1evXpEjR46Q48ePk+PHj5NLly6RhIQEuj06OppcunSJHD16lJw+fZpcvHiR3L9/n3We/v37k7t375KUlBRy48YNAoAEBQWR6upq4urqSpYvX04UFBRIXl4eycvLIxMnTqRtlyxZQuzt7Ul6ejoZMWIEGT58OHn+/DkhROQm5+/vT+Tl5cmVK1fItWvXiJycHAkICJAo3lsX1dXVZPbs2SQjI4McOXKEvH37lvTv3/+n2hJCiFAoJIGBgeTatWtkx44d5MmTJyQhIYE0bNiQ3r+AgAASGhpKMjMzyd69e8nVq1f/4/pRHBwcHBwcvyv/37Leca53HBx/Ec2aNSOBgYFk165dNIvagQMHSPPmzamL18yZM0lsbCzp168fIYQQQ0NDMnv2bBITE0Pi4+PrPPbEiRNJcHAwPYaFhQXJysoirVq1ktj36tWr5Pbt26SgoIA0adKEEELI4sWLyZEjR8iBAwfI0KFDCSEiIZCcnEzk5eUJIYT07duXnDt3jsydO5eUlJSQpKQksmPHDnotW7duJdra2vQ8L1++JCkpKbSYLSGE7Ny5k+jo6JAjR46Q7t27E0VFRcLj8Wp1JwwKCqIpyidNmkSWLVtGLly4QExNTcnevXuJUCgkmzZtonWOtmzZQpSUlMjFixeJn5/fD5+HuBXP0NCQrFy5kjg4OJCSkhIiJyf3w/Znz54lt2/fJk+fPiUtW7akx2GYP38+6d27N7VimZiYkJUrVxIPDw+ybt26etOOc3BwcHBw/Bv5N9VA+ivghBIHx19I7969yZAhQ8jatWtJkyZNyM6dO0nPnj1pDaSMjAxy7do1lgVJIBCQiooKUlZWRmRlZWs9buvWrem/NTQ0CCGEFBQU1CqUMjIySElJCVFRUWF9Xl5eTl69ekX/1tfXpyKJOS7jmvbq1StSVVVFnJyc6HZlZWVWYoWnT5+SRo0asfZRUVEhpqam5OnTp/XcJclrYsQUc/6MjAySlZXF6h8hhFRUVLCuoT7u3btHZsyYQTIyMkhRURF1iczOzibm5j9OBfzgwQOira1NRVJNMjIySGZmJtm5cyf9DAARCoXkzZs3xMzs52NLCCGksrKSVFZWsj77WesZBwcHBwcHx18PJ5Q4OP5COnbsSACQEydOEAcHB3LlyhWybNkyur2kpITMnDmTdO3aVaJtfRYI8cxsjIWlZiyU+Dk0NDTIxYsXJbYpKSnVekzmuHUd8++gvvOXlJQQOzs7lghh+JlU3qWlpTR5w86dO2mhYH9//58WHzIyMvVuLykpIZGRkWTMmDES23R1dX/qHOLMnz+fzJw5k/XZ8OHDydKVa3/5WBwcHBwcHH8H/88MSpxQ4uD4K5GWliZdu3YlO3fuJFlZWcTU1JTY2trS7ba2tuT58+fE2Nj4b+uDra0tyc/PJ40aNSL6+vp/6hhGRkakcePG5NatW3TSX1RURF68eEE8PDwIIYSYmZkRPp9Pbt26RV3vCgsLyfPnz6nFRkpKiggEgj91DXv37iVqampEQUHhl9s/e/aMFBYWkoSEBKKjo0MIIeTu3bu/dIzWrVuT9+/fkxcvXtRqVbK1tSVPnjz5y57l5MmTyfjx41mfZWVl/SXH5uDg4ODg+Ev4f6aUuGQOHBx/Mb179yYnTpwgmzdvpkkcGKZPn062bdtGZs6cSR4/fkyePn1K9uzZQ6ZOnfqXnd/Hx4e4uLiQkJAQcvr0afL27Vty/fp1EhcX99NiQU5OjgwaNIhER0eT8+fPk0ePHpH+/ftTF0JCRDE5nTt3JkOGDCFXr14lGRkZpE+fPkRLS4t07tyZECJy7yspKSHnzp0jnz9/JmVlZT91/t69e5PmzZuTzp07kytXrpA3b96QixcvkjFjxpD379//sL2uri6RkpIiq1atIq9fvyYpKSlk9uzZP3VuBg8PD+Lu7k5CQ0PJmTNnyJs3b8jJkydJWloaIUQUV3X9+nUyatQo8uDBA/Ly5Uty9OjRP53MoUmTJkRBQYH1n5SU1J86FgcHBwcHx/8aa9asIfr6+kRaWpo4OTmR27dv17v//v37SatWrYi0tDSxsrIiqampv3xOTihxcPzFeHl5EWVlZfL8+XMSHs6ua+Dv70+OHz9OTp8+TRwcHIizszNZtmwZ0dPT+8vOz+PxSGpqKnF3dycDBgwgLVu2JD179iTv3r0jLVq0+OnjLFq0iLRr14507NiR+Pj4EDc3N2JnZ8faZ8uWLcTOzo506NCBuLi4EAAkNTWVutW5urqSYcOGkbCwMKKqqkoWLlz4U+eWlZUlly9fJrq6uqRr167EzMyMDBo0iFRUVPyUhUlVVZUkJyeT/fv3E3Nzc5KQkEAWL17809fOcPDgQeLg4EB69epFzM3NSUxMDLWQtW7dmly6dIm8ePGCtGvXjtjY2JDp06cTTU3NXz4PBwcHBwfHv4H/Vta7vXv3kvHjx5P4+Hhy//59Ym1tTfz9/ess+3H9+nXSq1cvMmjQIJKenk5CQkJISEgIefTo0a9dL/6OapEcHBwcHP8xjx49+u2KJ/6ZNr9rv/6pNlzB2d/zufxTbX7Xfv1TbX7Xfv1Tbf7JgrOWlj9/jj9LRd2VSX4J6V8M/nFyciIODg5k9erVhBBRnLaOjg4ZPXo0iY2Nldg/LCyMlJaWsmofOjs7kzZt2pD169f/9Hk5ocTBwcHxm/KrK18cHBwcHP9/+TcJJZ5AMtNrkyZNaFkTcaqqqoisrCw5cOAACQkJoZ/369ePFBcXk6NHj0q00dXVJePHj2cVoo+PjydHjhwhGRkZP99RcHBwcHD8q6ioqEB8fDwqKir+lv3/19r8rv36p9r8rv36p9r8rv36p9r8rv36p9r8rv36J9v8jsTHx4MQwvovPj6+1n1zc3NBCMH169dZn0dHR8PR0bHWNo0bN8auXbtYn61ZswZqamq/1E9OKHFwcHD8y/j69SsIIfj69evfsv//WpvftV//VJvftV//VJvftV//VJvftV//VJvftV//ZJvfkYqKCnz9+pX1X13i778plLj04BwcHBwcHBwcHBwc/xh1udnVRvPmzUnDhg3Jx48fWZ9//PiRqKur19pGXV39l/avCy7rHQcHBwcHBwcHBwfHb4mUlBSxs7Mj586do58JhUJy7tw54uLiUmsbFxcX1v6EEHLmzJk6968LzqLEwcHBwcHBwcHBwfHbMn78eNKvXz9ib29PHB0dyfLly0lpaSkZMGAAIYSQiIgIoqWlRebPn08IIWTs2LHEw8ODLFmyhAQHB5M9e/aQu3fvkg0bNvzSeTmhxMHBwfEvo0mTJiQ+Pv6n3RZ+df//tTa/a7/+qTa/a7/+qTa/a7/+qTa/a7/+qTa/a7/+yTb/C4SFhZFPnz6R6dOnk/z8fNKmTRuSlpZG60NmZ2eTBg3+cJRzdXUlu3btIlOnTiVTpkwhJiYm5MiRI7+cGZBLD87BwcHBwcHBwcHBwVEDLkaJg4ODg4ODg4ODg4OjBpxQ4uDg4ODg4ODg4ODgqAEnlDg4ODg4ODj+lXDRAxwcHH8nnFDi4ODg+A3IyMj4b3ehVl69evXLk9HXr1//Tb1h8/bt23/kPP+fefjwISkvL/9vd6NWABAej/dL4/PZs2d/Y4/+PF++fPlvd+Ffx/nz53+5zffv3/+GnrA5ffr0L7fJyckhAoHgb+gNx38KJ5Q4ODg4/sscOnSI9OnTh2zcuPGn2yxbtoy8efPml84zf/58cuHChZ/ef+zYscTV1ZXcu3fvpyejMTExZMyYMeT+/fu/1LdfZcaMGcTU1PRvF5jXr18nHz58+FvPQYioJkh9f9dkzZo1JD09/W/rDwBy+vRpYm1tTfbu3UsqKir+tnMRQsj06dN/6T4PGzaMWFlZEaFQ+NNiac6cOaRv377k2rVrP32emzdv/vJCwcqVK3/4/MTZuXMn6dmz5y+LuN27d//S/n+GadOmkczMzF9qc/jw4b+pN3+wcOFCMnLkSLJly5afbjN48GDi5eVFCgsLf7pNdHT0L4mrNWvWkJEjR5LExMSfbrN161ZiaWlJrl279kvjhuMfAhwcHBwc/1Xev3+PkJAQeHh4YNOmTT/c//nz5+DxeAgPD0d2dvZPnePNmzdo1qwZOnfujGvXrv1Um4qKClhaWsLa2hp37tyBUCj8YZukpCQ4OjoiIiICd+/e/anzpKenQyAQAACWLVuGe/fu/bBNSUkJfHx8oK+vjwcPHvxwf+b44tR3PUKhEJcvX4asrCxmz56N/Pz8H57jr2Djxo0oLi6ud5979+6hcePGGDRoEB4+fPi39mf48OFo2rQpkpOTUVZWVu++4ve4uroaAFBeXv7Dc+Tl5UFaWhrt27f/6ft89epVGBoaon379uDz+QDqf54AsGfPHgQGBiIwMBBXr1794Tnu3r0LHo+H+fPn/9TYB4C0tDRoa2sjIiKi1jEnDnPMtWvXws3NDT169MCzZ89+6jzHjh0Dj8fDtGnTfmr/P8OXL1/A4/Hg6emJJ0+e/FSbgwcPgsfjYcGCBX9bvwDg3bt3CA0NhYeHBzZv3vxTbdLT06GlpYXAwEB8/vz5h/s/fPgQurq6cHBwQElJyU+dIzMzEwMHDkTbtm2xfv36n2oDAA4ODjAxMcHly5d/OG44/lk4ocTBwcHxX+LQoUPIzMwEIJoshoaGws3NrV6xxExWb968CVlZWfTq1euHYunr168AgAcPHsDc3BwdO3asVyzt3bsXWVlZAIDKykqYm5vDysqqXrF04MAB+u/du3fD3t4effv2/aFYyszMRJs2bRAXF4cxY8aAx+Ph+fPnde6/bds2OpkuLS2Ft7c3dHV16xVL4hOPixcv4siRI8jJyam3XwxTp06Fvr4+5s6di7y8vB/uz0zaGYHwK5OenJwcmJiYYMWKFQDqn/ifOHECenp6GDhw4E+LpdqOV9tnhw4dwuXLl+nfI0eORJMmTX5KLL19+xb3798HIJo0z58/v942FRUVAICXL1/CwMAAnp6e9YolcYFz+/Zt6Ovrw8PDo16xlJycTP999OhRBAQEwN/f/6fE0sqVKyElJYUFCxb8lFgqLi7GunXrYGdnhz59+tT7/G/dusXqo6enJ0JDQ39KLOXn52P58uVQVlbG1KlTf7j/r1JUVAQA+PDhA7S0tODu7o7Hjx//sN379++RkJAAJSUlJCQk/OX9Wrx4MR3v79+/R5cuXdCuXbt6xdKlS5dQWloKAHj06BE0NDQQEBCAT58+1Xuu6upqnD9/Hg4ODrCzs6tXLM2aNYu+H54+fYoBAwbAxcWlXrF0/vx5lgB1cXGBgYEBJ5Z+MzihxMHBwfFfIDMzE9bW1ujSpQv9sfzw4UO9YmnMmDFYu3YtFT43btyAtLR0vWJp4sSJGDduHAoKCgCIxFKrVq3qFEuHDh1Cw4YNMWvWLLx9+xbAj8XSpk2bYGBggLlz59LPflYslZWVYebMmWjRogXk5OTovoxFQpzLly+Dx+Nh0qRJdJLzs2IJAKKjo6GgoABtbW3IyMhg48aN+PLli8R+e/bswa5du+jf06dPh7a29g/FEnNfHj9+jODgYHTq1AlTpkz5qdVrQCSyevbsieDg4B+eAxCJJR0dnZ8SS+ITr48fP9YqFIVCIXJzc6GkpISuXbvixo0bdNvPiKXS0lL07t0brVq1wsKFC8Hj8bBjx446+9S9e3esWLGCTkBfvnwJPT29OsVScnIyeDwe9uzZQz/7kVg6ePAgVFRUEB0dTT/7kVjatGkTbt26RY+zevVqaiWpSyxFREQgLS0NAPDt2zesXbsWNjY2dYqlc+fOQVVVFYsWLaKfbd68+YdiacSIEXQMFhQUYNmyZVBSUvopsVRb32vrW2RkJGbPnk3P8+HDB2hoaNQrlqKioqglNC8vD/Pnz4eCgsJPiaW6REHNz8+dOwdzc3OEhYXR+/MjsbRhwwY6DplxKy6Wavtudu3aFatXrwbwh1iys7OrUyxdvXoVpqamCAwMpO/ZJ0+e1CmWhEIh7t+/jyZNmmDChAl48eIF3caJpd8PTihxcHBw/JfYvHkzvLy80K1bNzoBqU8s+fr6wsLCAlu3bv1psTR06FDY29tjxowZPy2WFixYAF1dXcycOfOnxNL79+8xZswYuLi4YM6cOfTz+sSSQCCgx9i9ezdUVFRgYWGBqVOnUmsMM/EVZ9euXWjQoAFiYmJ+KJbE+3j16lXY2dnh8uXL+Pz5M2JjY6GkpIRly5axxNLHjx9ha2sLX19fHD58mH7+I7HETGrev38PRUVFDBgwAN26dYOrqyvatWuHjx8/1rp/TZ49ewYVFRVs27ZNYhtzPeL35dixY9DV1cWAAQOodbKudoBo5dve3h76+vqwt7fHgQMH8O3bN9b+165dQ8uWLdGjR486xVJdLnU3b96EnZ0dGjRogJkzZ0r0V5yhQ4eiSZMm2LRpE52AZmVlUeFT232eOHEipKWlf1os5efnY/78+bC0tMSECRNoG3GxdOXKFfp5dXU1VFVVYWlpifv37/+UWMrNzUVwcDBUVVVx8eJFAD8WSy9fvsS4ceNgbm6OJUuW0M/rE0sfPnyAoaEhWrZsScfTz4ol8fNnZ2fj9evXqKqqqnXfQYMGwcDAAMuXL/8psZSdnQ11dXW0bt2avpd+ViyJ9+vEiRPYunUr1q9fX+f42rJlCzw9PVluij8SSyNHjoSsrCy2b9/+Q7FUUVGBqKgoNGzYEFu2bAHwY7EkEAiwZ88etGvXDv7+/vTZ1CeWAJHLpa6uLmJiYjix9BvDCSUODg6OfxjxH7/k5GR4eHjUK5bE9+/ZsyfMzc2RnJxcr1gSn8zFxMTA1tYW8fHx9Yol8fMkJCRAW1v7h2KJaZOXl4fRo0fDycnpp8USIJpkVlRU4Pnz55gxYwYcHR0RHR1NXbLE7xlzTTt37gSPx/spsQQAy5cvx+TJkzFx4kTW51OnToWSkhKWL1/OEkvp6enw9fVFQEAADh48SD//kVj68OEDDh8+jEmTJtE+p6amwt3dHc7OznQCVdMqlJ2dTe/j9+/f0a9fPwwePJj1TMSfzefPn1FcXEzv0bFjx6Cjo1OvWAJALXcHDhzAly9fYG1tDXNzc7x8+ZJ1nwHRmDIyMkKPHj1w/fp1ur0uscS0+/jxI+zt7WFhYQFHR0fcuXOHbmeuu+bYbNy4MTZu3PjTYmnChAmQkpL6oVhi+vTp0yfMmzcP5ubm9Yolpl+lpaUwNzdHmzZtcO/evZ8SS8+ePUNERARUVFRw4cIFAD8WS2/evEF0dDRMTU2xePFi+jkjBkJDQ/H06VNWmxcvXsDFxQXGxsY/LZbE+zpjxgxYW1vDwMAALVu2xJYtW6hQEN9v4sSJ0NfXx7Jly35KLD1+/Bht2rSBlZXVL4slQGTtNTIygouLC1xdXaGiooL09HS6Xfzebd68Ge7u7j8US+ICfcSIEZCWlv4psVRSUoL4+HjweLwfiiXx7+fu3bvh5ub2Q7Ekfi3r16+HpqYmJ5Z+YzihxMHBwfFfQNy1LCkpCe7u7rWKJU9PT6xevZr1o9+jR486xZJ4ggfxNhMnTqxTLHXq1Im6IIn3a+7cubWKJQsLC7Rp00ZCYH348AGjRo2Co6OjhFhycHBAv379WBaKI0eOQF5eHmfPngUgiu+YMmUKnJycEBsbS/s/YcIEZGZmsq5n+/bttYolHx8fGBgY0Ak6c794PB58fX1prALDtGnT0Lx5c8yZMwffvn2jk8UHDx7Ay8urXrEk7h729etXdOjQAUpKShg9ejT9XCAQ4OTJk2jXrh3c3Nzw4cMHuu3q1ato0KAB3Nzc0LNnT3qPL168CCkpKSr4xCewCQkJ8PDwgJ2dHdzc3OhEMTU1Fbq6urW64QmFQhQUFMDV1RX79+8HAJw5cwby8vISkzfxe3z16lUYGRmhe/fuEpYlOTk5JCYmory8nPbv9evXKCgoQG5uLq5fv45OnTrBzs6OJZYAkRgUP090dHSdYkncDU/8PowbN65WsWRgYAAvLy8Jy9LHjx8xb948mJmZSYglJsHD2bNn6fgvLS2FqanpD8WSeJ+ePXuGvn37QllZGefPnwfwh1iytbWtVSy9evUK0dHRaNmyZa1iKSwsDI8ePWK1efHiBZydnWFkZETvTUFBAZYvX16vZWnOnDlQU1PDsWPHUFlZCQ8PDxgYGLDEmPhzGT9+fJ1iycPDQyLBw6NHj9C6des6xVJdCR6SkpKgqqpKk7js2bMHPB4PKSkpAEDvs3jfNm7ciHbt2kmIpa5du8LT0xOrVq0CAJbVbNiwYbWKJS0tLQQFBbGsvt+/f8e0adPqFEv29vb4/v07ALZY2rVrF1xdXSXE0sCBA+Hm5kath+Lv2TVr1tQpllq2bIlz585xYum/CCeUODg4OP5BxN2nKisr6ec7duxAu3btWGIpLy8PPj4+CAwMlMiE1q1bN5iZmbHE0s2bN9G0aVP4+flJuHoBIsFhY2MjIZbMzc3Rtm1bZGZmoqKigmUpmDt3LrS0tCTEkoqKCvr27Uv3YyYkeXl5GDNmDBwcHFhiac+ePdDT08OsWbPoZ3fu3EHPnj1hbGyMM2fOABAJjri4ODg4OMDf3x9+fn5QU1NDdXU1SkpKUFlZSc/FxKyIi6WSkhJYW1uja9eurMnF2LFj0ahRI+zcuVPCWjVmzBj4+/uzLGSAKOtZXWLJwMAAcXFx9D5XVVVR60Hr1q1ZEyGhUIhTp07BxsYG9vb2qKqqwogRIzBgwAA8evQIW7ZsQfv27aGpqYk+ffrg+PHjCAsLQ2RkJKuvcXFxUFVVxc6dO3Ht2jUYGxvDxMSE9iE1NRUGBgbo0qULTcbBkJubC2NjY5SVleHUqVOQk5PDunXr6D1bt24dCgsLqYhhBMuVK1dqFUv9+vWDuro6Dfo/cuQIjIyMsHXrVvp8zp07h06dOsHe3h63b98GAMybNw8LFiyQiEEbN25crWLJ0NAQFhYWKCwslJgsjhkzplaxJC0tjZEjR9LPmO/Zly9fMH/+fLRq1Yollo4dOwYHBweMGzeOdfzS0lKYmJjUKpaaNGmC6dOnS4ilp0+fonfv3hJiad26dXBwcEBgYKCENert27eYOHEiTExMWGJp69ataNOmDfr27SvhJvfy5Us4OjpKiKUVK1agefPmLLEuFApRXFwMT09PGjOWmpoKBQUFOgZqiwkERN8bPT09CbGkra0NMzMzvHnzhnU9jx8/hqWlZa1iSVlZGXFxcRLXHxcXh+nTpwMA9u/fD3l5eSQmJgIQLZ6IZ1AUt/xs27ZNIltgbm4u3N3dMWLECPpsxMfNkCFDahVLhBCMHz+e1a+ysjLExcXVKpYcHBygq6uL8vJyVFRU0PePUCjEwYMH4eLiwhJLT58+RUhICIYMGQKhUCjxPBmxFB0dzUpmY25uDmtr6x8mUeH4++CEEgcHB8c/BDNBSEtLQ8+ePeHu7o6BAwfSFd3t27dTN7wnT55AIBAgPz8fOTk5SE9Px4MHD3Dz5k16vJ49e0qIpUuXLqF9+/YQCAS4evUqLl26RIPMASA2Nha2traYPn06Pn78CIFAgLt37yI8PBzLli1Dp06d4OPjgwEDBtA2Nd3wBAIBqqurwefzsXbtWgwfPhze3t7YtWsXysrK8OXLF+qGxyR4EAqFOHPmjES8Snp6Onr37g19fX0qlr59+4b169cjIiICERERqKqqwpIlS9ChQwe0b98effv2pROmHTt20AQPzKSkoqIClZWVErEE/fv3h5ycHPbu3Vurax8gmkyXlpbStnVZliZMmAALCwvWxK2yshJbt26FlZUVunbtyrJeCYVCpKam4saNG8jJyYGdnR110WLYsWMHtZTIysrC0NAQhYWFAERxII6OjvRZHjt2DEpKSli7di2r//v374evry/9e+/evdSK5erqipCQEMjLy2Pjxo30vFlZWXBzc0N8fDw6deoEDw8PeHl50ex14m544uOPmTgfPXoUTZs2xfLly/Hq1SvWNV2+fBkhISFo3rw5unbtCh6Ph/T0dNy9exdXrlxhZderKZYEAgGePXuG0NBQrFu3DkOHDkWfPn2wdOlSVhtxsSQQCPDkyRPw+XwsX74cgwYNgp2dHZKSkvDu3TuUlpbW6obHuDgVFRWhrKyMjqWSkhIYGxtLiKUFCxZAWVkZnz9/xvv37/Ho0SO6LTc3F+Hh4RJiaeHChRgwYAAuXryIJUuWYNCgQbh69Sq+f/+OT58+YeLEiRJueNu3b6cLFAUFBXj37h2dZL979w4ODg4ssfTp0yfMmTOHCn9m7BUUFMDY2BifPn3CuXPnWEL5+/fvWLFiBbUEXr58mfXOGD9+vIRYevfuHTp16gQ+n4/CwkJ8+PCBfrefP38OCwsLCbE0ZcoU+Pj4SAil8PBwjBo1CmlpaZCXl6djms/nY+nSpZgzZw7mz58PHx8fmJiYoFevXnRsJicnw93dnSZ4EAgE+PTpEwQCARITE9G/f3/07duXxssBopT34mJJIBDg9evX4PP5ePz4MS5duoTs7Gz6jpgyZQpLLFVWVuLkyZMYOHAg5syZg8DAQGhqamLkyJE0Rm3v3r1wc3NDQEAAXZR68+YNBAIBzp49i379+iE0NBSDBg2iQj4xMZGKJXHL0ps3b8Dx34MTShwcHBz/IMykcvz48di/fz90dXVhY2NDJ5jJycnw9vaGr68vXSWNi4uDpaUlTExMoK2tzVotZ2KWtm7dSlf3AZEgMjY2hrW1NZ2kMhPmmJgY2NnZYcaMGXTiExsbixYtWmDx4sXYt28fGjVqBH9/fzpZWLBgAfT09DBhwgTaJiYmBpqampg4cSKmT58OHo9HJ5+MZcnFxQWxsbG0X1u2bKHWBQZxsXTp0iUAbBeg2NhYqKqqYv369di2bRu0tLRgZWVFhcjOnTvRoEEDDBs2DMXFxVi0aBE6deoEU1NTLFq0iBWD069fP8jLy2Pfvn3UcsZM3I4dOwZPT084ODjA0tISR48eBSDKUMiIpcOHD9O+PXz4ECkpKTh9+jR9VhUVFbSWVE2xBIgsKiEhIejduzddJa4pHjMyMjBz5kzo6OhQK0dmZiaaN2+OqqoqnDx5UsIitGTJEpSWltJkCnv37sW4cePQqFEjOrZWr14NLS0thISE0HOVlZUhODgY1tbWkJGRwZw5c3Dw4EEEBQVBSkqKulfduHEDrVq1gr+/P31+QqEQRUVFcHV1xezZswGIJpFFRUXYsWMH7t+/D4FAgBcvXmD+/PkYMGAAnjx5gtjYWFhaWkJPTw8ODg7w9fWl/YmOjoaUlBQ2bdpEXZtiYmKgpqaGqVOnYuLEiWjRogXCwsJom4kTJ0JWVpYVyD9p0iS0aNECc+fOxezZs6GoqIh+/fqhsrISBQUFNMHD4MGDWc8/ICAA1tbWCAgIoBNjcTc85poAkaieOnUq7OzsoKioCD8/P8ycOROVlZV49eoV+vbti+bNm1NBXFZWhgMHDkBJSQk9e/ZE586doa2tjWHDhqGyshKvX79GdHQ0LCwsMHv2bJagiI+Ph4eHBxQUFNC7d28sX74cgMh1z9nZGcbGxlQs3b59m7bdsmULnWj7+fnB29sbcnJySEpKosd+9+4d3NzcEBISglatWqFVq1bQ19dHUFAQHb8TJkyAgYEBVqxYwcqYOGPGDHh5eUFJSQn9+/fHhg0bAIjczaytrVkJHo4fP05dfAcNGkRdBHfu3AlHR0dIS0tjzZo19NjFxcUIDg6Gm5sb1NXVsX79ety5cwcKCgrw8vKiVhwmAYaPjw/evXtHx4y6ujqmTJmCOXPmoEGDBujTpw899ogRIyAnJ4f169fTdxwzLlVVVWnCiKKiIlRVVWH69Olo0KABTTXP5/MRFxeHFi1aYMOGDTh37hzU1dXh4eFBF6CYBA/29vb03Xz48GH6/l+xYgUMDAxgbm5OryUxMRF6enoYMWKEhFWY478DJ5Q4ODg4/iE+f/4MFxcXmhK4vLwcWlpaGD16NGtStH79egQHB9OaJCoqKrh27RpKS0sRExMDHo/HqsHSs2dPqKioIDU1FYCoaKuqqiqNDVm2bBl4PB5r9T4mJgY6OjrYtGkTHj16BAsLC7r6nZqayopfYZg8eTJCQkIgFApx4cIF6Ovr03Pcv39fIh30x48f0bdvX+pu8urVK7i5ucHGxkYi6cCNGzdgbGwMQ0NDnDp1in7+9OlTWFtbUwGVkpICRUVFOqFi7ltiYiJcXV0xefJkqKurY+7cuVi3bh3k5OQQGRnJilkaOHAgeDwezp07Rz87ceIEZGRksGDBAty5cwd9+/ZFo0aNqAXlwYMH8PPzg7OzM44dO4bMzEwYGxtTNyMbGxtqESsvL0dSUhJcXV0REBBAJ5vMCrmMjAwsLS3pBE382TOuQuXl5Vi8eDHat2+Pb9++obq6GkFBQRgzZgzk5ORYFqEnT57Az88P586dw5MnT9C/f39oampCSUmJtTLNxJAZGRkhICAAgwcPhpubGywsLODn54f58+eDz+cjOzsbhoaGGDp0KKt/Fy9ehI2NDd6/f896xmZmZtizZw8+fPiAqVOnwsPDA02aNIG1tTUVG8z1L168GCoqKrhx4wYqKysxc+ZMiWcRHR1NY1SuXr0KExMT6vZ38OBBNG3alE7IxZ+ph4cHgD9iqxhBd+fOHfB4PGzfvp3u/+XLF0yePBm9e/eGUCjEsWPHIC0tjcWLF+PYsWMYOXIkeDweff5MggfxAsdz586FqqoqUlNTUVRUBH9/f2hrayMjIwOAyLISEREBHo+He/fu4dmzZzA0NKTZLCsrK9GgQQPqdgaILIfDhw+Hg4MDCgsLIRQKER8fDxUVFRw/fhx3795FQEAA1NXVqYvWy5cv4eLiAjk5OZw7dw42NjZYt24doqKiwOPx6BhITk6mz56hpKQEQUFBMDY2hoqKCr1nixYtAo/HoxYSQGRZkpaWxt69ewGI4vtUVFSQkpKCy5cvw9vbG1paWnSCzyR4UFNTw/v376Gvr4+OHTsiPDwcCgoK9D7m5+cjKCgIrVq1wu7du/Ht2zc8efIEgYGBsLCwgKWlJX0nXLt2DTIyMhIZQVetWoURI0ZAIBDg+vXrMDY2pqLs8OHDkJWVpZYqhp49e6J9+/YAgCVLlkBVVZW+ZyIjIyErK0uvv7S0lC4GnThxAs+ePYOlpSUdtzdv3kSTJk1YYl0oFGLLli0YNmwYtXTZ29vTOKXc3Fzo6OggMjKS1a8lS5bA3Ny8Vvdpjn8eTihxcHBw/EMUFhbCzs4OHz9+RHZ2NjQ1NTFkyBC6PS0tjU5Ki4uLwefzERYWhq1btwIQ1ThSUlKiAkbctWzatGnUMjF48GDqnrRv3z4oKSmxrA8MTJKICxcuwMjICIDI4sWstAKimCHxVNXiq+/e3t4ARPFHcnJydCLy9etXGpj9+fNnugLPuJ916tQJDg4OdELJEBwcDAMDA4SGhtLPrly5Ai0tLQAikVTTkrJx40YqOA4fPgxjY2M6ub137x54PB6UlZURFhZG3XUAUWA7E/tQWVmJrl270gkrU/iVEQoMN2/eRKdOnXDlyhVoa2vTLHq3b9+GiooKlJSUaAB6eXk5DeJn7gXz+caNG9GoUSNMmzYNNRHPDhcTEwN5eXlcv34dlZWVGDRoEKSlpTF8+HC6f2lpKYKCghAQEEDv84oVK9C4cWO0bt2aVQ8KEFn6Dh06hM6dO2PgwIGYMWMG8vPzYWBggPT0dHz+/BlaWlqsa9+8eTN1H6otbXO3bt2grKwMZWVldO3aFWvXrsX379/h7u6OYcOG0f2qq6vRt29fas04evQoFBQUqOgRT1O+atUqVFdXY//+/WjTpg0A0fgXF/Dfv3/HsWPHaBvmvl24cAEuLi4ARIlExMfmt2/f6IJBUVERhEIhysvL0bVrV5qZLTc3F/r6+nQCy3yvvn//Dnt7e7x69QqfP3+Gh4cHdu/eDQA4e/YsmjZtSgUs0+bZs2eYNWsW+Hw+7t69CwcHB/q5jo4OzW4IgFrv3r17RyfJ79+/R9u2bekiyLlz5yArK0vvobi725AhQ/D27VuMHDkS6urqUFRUZCVcKCoqwqRJk2BqagonJyf06tULLi4uaN26Nfr3749169aBz+fj4MGDUFRUpPdZ/LmsWLECfD4f7969g7OzMxUwNfvFjMWMjAz07duXCvAWLVqgYcOG9J3GkJ2dDV9fX5ibm0NOTg6Ojo5o164d7t+/DwsLC/D5fBw5coT1/f/27RsrPo15/vv27YONjQ0A0TtB/H327ds3HDlyhLbh8/koLS1FSEgI3Sc1NRVycnJ0XJaXl6OqqgpVVVXYuHEjqqur8fz5czouDxw4IPFeOnToECvRCSByoTMxMcG3b99oIV9xkSTu2ivuHcDx34UTShwcHBx/E8yPJBNT8O3bN5iammLhwoUwNjbG0KFDWfEGfn5+OHHiBG3/7ds3aGtr4+jRo7hw4QLrx7iqqgpTp05lxRIAoh9pS0tLJCUl4fr166w21dXVmDhxIg4dOgTgjyD3d+/ewcPDAzNnzmQFUgMiERAQEMBK7S0UCrFv3z66AqyoqMharT148CBCQ0Op5WHp0qXo3bs33Z6Wlobg4GA4OjrSidz379/Rp08fHD16FEKhkPbt/fv3CAoKwvz582mmNYY7d+6gW7duNFX5qVOnaLar48ePQ0lJCbt27cL58+fB4/EwePBgVs0c5p58//4dlpaWuHbtGr5+/QpNTU2WUFi/fj11ayotLUV8fDwGDhxItzs7O8Pd3R09e/aEgoICTp8+Ta1COTk5uHfvHlJTU/HkyROalGPlypVo0KABq0hvzbTZ8vLykJOTo4Ly06dPaN++PWxsbNC3b19Mnz4d7dq1g5WVFR1HKSkp2LJlC86dO4dBgwbBxcWF5WYlfh5x0dOlSxdMnToVOjo6GDZsGD3e58+f0bVrV2zbto2KuE+fPiE/P581mdu6dSv27NmDsrIyKkAjIiIwbtw48Pl8CIVCVFdXw97eHsnJyUhLS2MJmOrqaixYsEBC2J05cwZdu3bF9u3bWRNeQCROhg4dyorhEAgESElJgZGREfbt28eyPjLjomfPnqw2X79+hYmJCdLS0vDp0ycJoZicnMyySAKi76aTkxNyc3Nx7Ngx1veMsSjWtJoePXoUFhYW+PDhAwwMDDBkyBAqKC5duoTIyEjqOsZQUFAAc3Nz5OTkSAgF5jxMPCPDhg0b0LRpU1haWkpYUYqKinDq1Cn0798fI0aMQEJCAsrKyui+Nd8zfD4f8fHx2LlzJ+s4OTk5MDU1RX5+PhUj4v3asmULy+UVEL1LmNTkXbt2lfguFhYW4vHjx9i1axeuXbtGYzSNjY0xfvx4KCoq0nMAooUQd3d3VvZNoVCIGzduoEOHDtSiLD5mLly4gD59+rAsrdXV1fD19cX58+dx/PhxifdsYmIiTp48Sf8GRKJWXV0d06dPZ8UKAsCtW7fg7+9PF2yY70NFRQVcXV2xZs0a6OnpITIykvX+79SpEz1PXYWNOf55OKHEwcHB8Tcg7q40d+5cvH79GgAwe/Zs6mMvzuTJk2FtbY2cnBxkZ2dTd62YmBgEBgZCVlaW5W6Vn58Pf39/KhyePn1KJ+GLFy+GnZ0dpKSkWK4gnz9/hp+fHxISErBx40YkJSUhJycHhYWFCA4OhpSUFGJiYuj+5eXlCAwMpBnk9uzZQ1fQGVcjHo+H+fPns9p06NCBujRdvXqVuguKHzstLQ0dO3ZE8+bNMXLkSDg6OsLFxQUCgQBr167Fhg0b8P79e3z//h3t27cHj8djuSiVlJQgMDAQISEhdJJYUFCADx8+oLCwEK6urtRCUF5eDkNDQ/B4PMyZM4c+GyYGBgB69+6NiIgI6OjoYPjw4XQC8/37dwQHB2PFihU0i9bDhw9pMdoOHTogICAAFRUVuHbtGpo0aQJCCF0dZlbw9fT00LZtW/j5+dFJ+po1a9CoUSPW/QNEhSjV1NQwbNgwKpIYUfP161csWLAAXl5eCA0NxcSJE1FdXQ2hUIj79+9DRUWFugMxq/kuLi40tkIoFGLFihXYvXs3Zs+eTQVwbGwsjbMRn6TFxsbCzMyMJhQ4evQo3N3doampidDQUKxcuRI1+fz5M6ZMmQIlJSU8efIEb968oVaJCRMmwM/Pj5VxDRAJ4uDgYKxbtw7bt2/HuXPnUFlZiXfv3qFFixbg8XhYsWIFa5z5+/vTcZacnEwFoVAoREBAAHg8HnVzFR+bPXr0oEKWGTuDBg3C9OnToauri8jISGqp+fz5MyIiIpCUlAQ+n0+Td5SWlqJ169YIDAxkWXkBkSucl5cXDhw4gDt37tDJr0AggIODA3g8HsuSDIi+5+7u7jRWhYlfy8vLg5WVFUaNGoVmzZqxRF9mZiY6dOjAclU9cuQIkpOTcevWLZpQRTz5hbigevnyJa0fNnv2bLRv3x4yMjIst8ZPnz4hMDAQy5YtAwBqvc3JyYGFhQWio6Ml+pWeno5OnTpRV15AlBCGsSI9e/aM1nBjxJJ4v9asWYPp06fj3bt3EAgEmDRpEuTl5Vn3rKKiAsHBwejQoQMEAgF27tyJtLQ0FBcXIysrC2ZmZjSNO0NZWRkCAgLomGFEKZ/PR8eOHWFjY4NmzZqxnuW7d+/g4+ODjRs3YvXq1YiNjaULBLGxsZCSkmJlGKyoqECHDh0QHBwMgUCAy5cvIykpCVlZWaiurkZERATk5OTQqVMn1vOfNGkSbG1tkZubC47fC04ocXBwcPxNHDx4EHJycpg+fTqdkD569AhhYWEwMzPD3LlzsXHjRkRGRlKf/fj4ePTo0YNOrvbu3QttbW0EBATQ+kgfP35EYGAg2rZtCz6fj6lTp8Lf35+KGMb1yNXVlRZtZCwzzs7OGD9+PNTU1LB582Zq9bl79y5MTU3h5+eH+Ph4rF+/Hu3bt4elpSWqqqowceJE6OnpYfny5TSZw/bt2+Ho6AgfHx+cPXsWu3btQkBAAKysrFBdXY3o6GiYmZlh9OjRcHFxQYMGDViuJpmZmZg6dSr8/PwwePBgVFVVITo6GmpqakhMTKTJJz58+AB9fX24ublhypQpWLlyJe0bM9kTT7f77t07mJub02QMBQUFGDlyJE6cOEFXd9PS0hAVFUVFxbp166Cvrw8XFxeJRBItW7akQlecR48ewcHBgcZ1vHr1isb+nDp1CitXroSamhqdDDIxHszEtqqqCmvWrAGPx2O5Io0bNw7Dhg2DUChEVlYWkpOTYWNjg06dOkms7DMwfQ4LC4OrqysV2k+ePEG/fv3g4OCA8ePHIzg4GMrKypCVlcWMGTNojZ7y8nJ06dIFrVu3xrBhw7BkyRL069cPioqKdAwdP34csrKyWLBgAc6ePYvIyEioq6uz0sCnpaXB398fRkZGuH//PqZPnw5/f38av3Xt2jU0b94cLi4u1OKQl5eHoKAguLq6YsKECdDQ0MCKFSuoaLh+/TqkpaXRr18/7Ny5E0ePHoWPjw8dZ8zYnDdvHh3PJ0+ehKurK9q0aYPjx49j06ZN8Pf3h7m5Oaqrq5GWloYJEyZQt8h58+bRWlviAjo2NhYmJiZ48+YN5s6dC39/f5ql8tSpU1BTU0NgYCCAP6yTgYGB8PLywr59+6ClpYVRo0bhxYsXEAqFOHToENq0aYPg4GDk5ubShQR5eXlqgUpISMCQIUPopHnVqlUS4ooR8L6+vtRi9/LlSygrK2Pfvn10PEZGRsLJyQkrVqygYmTu3LkYNWoUAgICqBvahQsX0KpVK7Rr144+75ycHAQGBsLZ2Rl8Ph8LFy7E6NGjqRsmc8/EhUJJSQmCg4Ph7+8vkZ7f0NCQuhRmZmaiVatW6NKlC0124e7uDg8PD7Ro0QJJSUl0QSE9PR2hoaEwNjamiWO8vLzouyk6Ohrq6upITEykxz99+jQaN26MAQMGICkpCUeOHIGXlxcdMzNmzICbmxuNY3r9+jWMjIxgZ2eH6upqlJWVobCwEIGBgXBzc8OECROgqamJVatW0eQomZmZNLthfHw84uLi4OPjAwsLC1RVVVGXvBkzZtCSD8+ePYONjQ3at2+PRYsW4cCBAxg2bBgUFRUlCmVz/B5wQomDg4PjbyAzMxMaGhoSCREAUeKD+Ph46OrqwtHRESEhIXj48CGmTJmC5s2b49ChQ6xipqtXr4apqSmsrKzQtm1bODk5wdbWFlVVVTSg+uTJk3QCA4gElru7OzQ0NGBhYQEbGxs4Ojpi69at0NTUZCWDYCwI169fx/Dhw2FkZAR/f38MHDgQ1dXV2LhxI1q0aMFKDc2wY8cOdOzYEU2bNoWLiwt69OiBqqoqnDlzBgoKCjQepLi4GFu2bIGMjAwrxgb4Y/V89+7d0NDQYMX0MAIgJycHAwcOhJ2dHfz8/BAZGYkpU6ZAX18fbdq0Qf/+/anV5eHDh9DQ0MC4ceOwb98+BAUFwd3dnV7ngQMHIC0tjXnz5tHJaXl5OUaNGgVra2sEBwdjypQpCAsLQ7NmzZCSkoIVK1Zg1apV+PLlC8taKB7wvnHjRgQEBOD9+/eoqKhAeHg4tWgw7lnMan1ZWRm+f/8OgUCAgwcPUgEnFArRv39/WFhYYO7cuXB1dUXHjh0xbNgwmlJePO6LgXFVPHXqFOzt7VmJO168eIHJkyejXbt28PLygq6uLjZu3ChxjNLSUkydOhW+vr6wtrZGREQEFVJv3ryBk5MTtRwUFxdDU1MTDg4OMDQ0pC6EZWVl2Lx5M169eoWpU6dCTU0Nhw4dYgWmnz59Gs2bN4ednR3MzMzg6uoKOzs7akm7c+cOFb5MH8+ePQtbW1vo6urCxcUF3bt3R1VVFbZs2QJVVVXWeGbanT17Fl26dEGLFi3Qtm1bWo+ISQgRFxfHiuEZOXIklJWVMWTIEERHRyMiIgJKSkpIT0/HpEmToK6ujuTkZOq29e3bNyxduhQNGjSAr68vOnbsCHd3d7Ru3Rrnz5+nrqLiNXBKS0uxc+dOtGnTBvLy8jAzM4OjoyMVJzExMdDQ0MCaNWuoFa+qqopaZfv3748+ffqwFjHE79PIkSPRunVrKjLfvXuH4cOHw87ODgMHDkRwcDCaNm2K5s2b49ixY3Q/QBTPY2lpiVatWsHMzAwODg5wcHCg59fU1MTKlSupJaa8vJwmvRg2bBgGDx4s0S/m+3v79m3Y29vj+PHj9HwPHz6EtbU1bGxsYG5uDm1tbWhra+P69euoSXp6OhYtWgRzc3OEhIRgzJgxqK6uxoYNG6Curo67d++yvkOAyA3Vz88PqqqqtDhtVVUVzVZ34MABuvgEiGKTFBUVYWVlhTZt2qBt27awsbHBgQMHoKmpyfpOMTx9+hQLFiyAlZUVOnXqhKioKFRXV+PevXtQU1NDUlKSxPcsIyMD/fr1g4mJCaytrREUFCThpsnx+8AJJQ4ODo6/gd27d8PW1pYVx1GzqGNpaSl1Abp//z6tws4g/gN76dIlrF+/HpMnT8a2bdvA5/Px7NkzWFlZseKaxN2mnjx5giNHjmDJkiU4evQo+Hw+pkyZgg4dOtBVaEAyPXVpaSlre//+/emqcc24K4asrCyUlZXR7du2bYOhoSGrXlF5eTlWrFgBHo+HyZMnS1znrFmzEBQUhKqqKtqnmr76lZWVqKysxKFDh6Cnp4fdu3dj2rRpcHJygpOTE7WkbNmyBVpaWjAzM4O7uzvt74sXL2BiYsJy+2IoKyvDhg0b0K1bN3h7e2PkyJG0MKezszMaN25Ms95VV1ejtLQU3bp1Q7NmzRAYGIhGjRrR+C8A6Nq1K44ePUqDw8VjxTZt2kRX/gGRux2Tle3bt280hmvx4sV0pXnv3r1wdXWl6ZYBkQATD7avqKiAjY0NKxUy87wqKipw+vRpmJqaslIP17zHhw4dkshEV1FRgalTp+LVq1fIzc1Fy5YtMWLECOTm5sLf3x+KioqYMmUK3f/p06do1aoVa2wCf4y1hw8fYteuXZg9ezYOHjwIPp+P4cOH09ggZj/x70BJSQny8/Px+fNn2ueRI0dSSwuzb83vWXZ2NqqqqiAUCvHixQsYGBiwYt3EWbhwIXr37g0XFxeMGjUKjx8/xs2bN2FoaIizZ89K7F9RUYGbN29i4MCBiIqKwuLFi1FdXY34+Hj07NmT1S9mDDJ9v3TpEt6+fUvd+c6dOwdtbe1aJ+SAyILbu3dvWheIuc7q6mp67CtXrsDOzo7ljvf+/XvMmTMHAQEB8Pf3h5mZGU6cOMFKssL8OzMzE0eOHEFCQgKOHDkCPp+PU6dOQVNTk1pfarJu3Tp069YNYWFhmDZtGu1XzSKpgYGBNMscw8uXL7Fu3TosWbIEc+fOhYeHByt2rua7SbxINyDKTsfEC9b2PquoqEB+fj6Ki4shFArpuGSSrtQkPz8fCxcuxLx587B9+3bw+XwkJCTAy8uL9T2p2a+aNdu2bNnCSgtes41QKERJSQm+fv1aa4IUjt8HTihxcHBw/A0kJibCxMSExgCI/8hevHiR5colFApx/fp1aGlpsaqyM1RXV9f6Y5qZmYkWLVrUOoGpqqpiTaCZiVBoaCiCg4MlPmcqzounfmb6FhwcjEGDBkmco7y8nBWHIN7mzp07kJeXl0g2kZmZiWbNmoHH4yEqKoq1rVevXnB1daV/MxMLPp+PixcvUlc8QOTWyMSs8Pl8anGwt7enYikrKws5OTmsa7xx4wYMDAyopYTpb83+M/8lJCQgOjoaQqEQxcXF8PDwgKOjI3Xre/bsGYYPH44xY8bg7NmzmDt3LrUiRkREQF9fH4qKiqy4j/z8fHh7e9P+MzVfxN0a+Xw+SxBVVVUhKCgIoaGhtL937tyBgYEB1NTUsGjRIurid/r0aVa6d/Fr3LRpE5o3b16r4L1z5w7u3buH6upqhIaGokWLFjRdMvDHJDUuLg6hoaF0bE+ePBktW7ZEu3btqOXo3r17UFdXp9YX8XtcUVEhUV+qqqoKDg4OiIiIkOhzZWUlMjIyJCbJQqEQYWFh6Ny5M2pSXl5O3f3EuXXrFlq2bInnz5+zhEJNqqqq6PaDBw/CwMCANellttUl6Pv27cuKQxTf/vDhQ4nzAaLFBVtbW1RWVtL9mfPUJQL379/PqmsEAJ6entQdkIHP50MgECAjIwMtWrSQSE4BiO6z+Jhj2LhxI5ydnVFdXV3nddd8Nhs2bMCoUaPw7t07uk9GRgZMTU3pYkLNY8TFxcHFxUXiGqurq3Hw4EFWoguhUIiqqio4Ozuz3k3i/bl9+7bE9Vy+fBmqqqrUksR8zwFIFKFmmDFjBuzt7VkumYBojOzbt49+D8T7MH36dJibm9PPxEXSnTt3JAozc/y+NCAcHBwcHH85rVq1IllZWeT48eOEEEJ4PB7ddujQIZKSkkKEQiHdVlZWRj5+/EiqqqoIIYRUV1fT/a9cuUJOnz7N+owQQqqqqkhZWRkpLS2lfzPcuHGD7N27l1RWVhJCCGnQQPS679q1Kzl79ixJSUlhff7p0yeSmJhInj17xjoHj8cj+vr65Pz58+Tz58+sbRMmTCDLli0jN27ckGijq6tLvL29SWJiIrly5QrdpqSkREJCQsimTZvIzp07SWpqKt3Wq1cvkpWVRZKSkgghhDRs2JAQQsjHjx/JsmXLyMOHD8m6devIrFmzyJo1a0hRURHdz9PTkyxatIgAIO3btyelpaXEyMiIaGtrkwYNGhChUEgaNWpEPn36REpKSkizZs3ofWaezc2bN8nZs2cJj8cjRUVF5NOnT6RJkybEzs6O8Hg8oqioSFJSUkjTpk3JrFmzSGpqKpGVlSWbN28mnz9/JqmpqWT+/Pmkbdu2hBBCVq1aRdTU1Iiqqirp3r07+fr1KykoKCADBgwgZWVlZOTIkWTVqlVky5Yt5NSpU2Ts2LFEXV2d9klBQYFUVlaSxMRE0qVLF5KdnU12795NeDweefz4MbG3tydPnz4lI0eOJJcuXSIdOnQg0dHR5OXLl0RVVZU8f/6cEEKIUCik1xgYGEgaNGhAoqKiCCGENG7cmBBCCACydetWcvHiRUIIIXv37iUeHh6ka9eu5PLly4QQQqSkpAghhDx+/JgIBAJ6D0tLS8ngwYNJSkoKUVNTI4QQ0qRJE/L582fWeBIKhQQAuX79Ojlz5gxrvDZu3Jh07dqV3L17l44Xps9v374l8+bNIy9evJAYZ8bGxuThw4fk8ePHBADd9vXrV7Jy5Upy/vx5VpsPHz6Q169fExUVFdKgQQPC5/Ppee7fv0/u379PAJDGjRvT74asrCzh8/nk9evXrGMBINu2bSOZmZn0GBAtQBM9PT1SWFhI3rx5Q++/UCgk3759I8uWLaP3WRyhUEjevXtHCgoKCI/HIwAIj8cjAoGAHD9+nOTm5tI+EULIw4cPyYwZM0irVq3IjBkzyIkTJwghhCQkJJAPHz7Qdw8A0rBhQ9r2y5cv5NOnT4QQQvh8Pr1vt27dIsePHycVFRWsflVXV5NXr16R4uJi0qBBA3o8gUBATpw4QQoKCkijRo1YbZ4/f04yMjKIpaUliY6OJseOHSMWFhZES0uL3Lp1ixDyx7uHuXdOTk7k5s2b5MiRI6xjlZaWkh07dpCrV6+ynn3jxo1J586dycmTJ+k7iDlWdnY2WbVqlcQzU1NTIw0aNKB9YJ4LIYScOHGCnDp1SuK5mJubk8ePH5O0tDS6LyGEVFRUkOTkZPouFe+br68vefnyJdmyZQsh5I93WWVlJdmxYwe5efMm61gcvzH/HX3GwcHB8b9PTEwMLUKYk5ODDx8+ICoqCioqKqz0tIBo1TQgIAA2NjYsv/ny8nJ4eHggLi6u1nP07dsXzZs3Z6XiZTKCiQdZM+Tm5qJfv34wMDDAnj17UFxcjBcvXiA4OBgODg4S7iGAKB6lVatWcHFxQVZWFj59+gQ/Pz/IysrCzc1NYtWb4eTJk2jfvj3at2+PlStX4syZM/Dx8UGHDh3w9u1b6OrqYvXq1XT/d+/eoV+/fnB2dsbKlStRWlqKjIwMdOzYEQ4ODoiLi4OCggLc3NxgaGgIY2NjVowFn8/H+fPnoa2tzapPI87379+hra1N3aLEGTt2LOLi4nDnzh2YmJhAT08PPB4PY8eOlTiGn58fzMzMcPDgQVy/fh2ysrKQlZWlgf7M6vSNGzegp6cHAwMDtGzZEi4uLrCzs6OuYMOHD6fZALOysrBjxw44ODigT58+2Lt3L0pLSzFkyBD06tWLrrTHxcXB1NSUVUPm06dPOH78OLUm8Hg8aGpqssYSIFppX7JkCYyMjDB8+HB8+/YNjx49QlxcHJSVlWn/AdGY7NGjB1RUVFjuYAkJCbC1tcWECRMwdOhQNGvWjLVCLhQKUVZWhvDwcLi4uNAYrg8fPqC6uhpeXl4YM2aMxP2/cuUK2rZti7CwMOr2l5OTg06dOsHNzU3C3Ynpo6WlJWxsbHD16lXk5eXRJAS1tfny5QvatGmD8PBwanFlxvnQoUMxffp0CYvG06dPoaOjg1GjRrGsN8y1iLuRMhQUFEBdXR0dO3akiRyqq6sxdepUGBsbS6QBB0TWLjMzM8THx7Oyn5WXl8Pd3Z2VwU+8JtiqVasQGhoKJSUlDBw4ECtXroS7uzsWLlzIuj6G/v37w9DQkBXXVVlZCV9f31qfy9WrV9GqVSvMmzePFWtWVlYGd3d3VjbC3bt3s9z+Nm3ahD59+kBeXh5RUVHo1q0bZGRk6ozJiYqKgrS0NBITE3H//n1kZmbC398ftra2tT5/pnyBj48Ptajm5uaiY8eOcHV1lWjz8eNHeHp6okuXLqxYKD6fD19fX1bdL3GGDh2Kpk2bIjExEbdv38bp06fh5+dXZ7+Ki4sxevRo6Ovr02yleXl5mDZtGlRVVSVSp3P8vnBCiYODg+MXqCkGAEl/dYaSkhLMnDkTUlJS0NXVhaamJhQUFGjdj5qcPHkS3t7e0NfXx9atW7Fy5UqYm5tDSUmJJQjEefz4MYKCgiAjI4PZs2dj2rRp8PHxgaWlpcSEjyEjIwPjx49H48aNoaWlRSfwNQOwgT8mWU+ePIGNjQ00NDSgqakJaWlptGrVClVVVUhJSWHdF/GJ2fnz5zFq1CgauN62bVtUVVUhNzcXDg4OrPTlgMgtaeLEibSAacuWLeHq6ors7GxERETg9u3bqKysRHp6OmxsbGBpaSkRB3Dv3r1anwnTxwMHDkBZWRmhoaF4+vQpbt68iUmTJkFRURE3b96Et7c3Ro8ejRMnTtAsfuvXr2dd49evX2kNl8TERMjIyEBeXh79+vWTOG9lZSUSExOxYsUKHDhwgFVXqEuXLjA2NsbatWvh5uaGwMBAREZGwtPTEwEBAQDAiv2aOnUqVFVVcfbsWRrsL37PP336hKdPn2LUqFHQ09Oj9V3E+15QUIBNmzZBS0sLzZs3h7GxMYyNjVmTb/HjhoaGQkVFhbrhPXv2DOPGjYO2tjY0NDRqTfIBiFwAQ0JC0LJlS3h7e6N58+ZwdnaGlZWVhKsWw7FjxxAcHIzmzZvD0NAQ5ubmNHFJzetgnnFRURGcnJxgZGQEFRUV6oLJnKNmm2XLltGEEO/evcOdO3cwefJkKCsr0+xkNcXF7t270bRpU0RERGDjxo1ISUmBp6cnrK2tJeL1mH49efIE2traNGFBUFAQlJWVa73PDHFxcTAzM8Pw4cNx6tQpnDlzBn5+fmjTpg39Pk+dOhVGRkas+ljFxcW4efMmdHV14evrCx6PB3l5eZaLKcONGzdokeC5c+dixowZrIxwtTFu3DhYWFggKioKV65cwcWLF6mAYdow2QeXLFkiIfTu3r2L7t27w9PTk6bpr/lsANFYnz17NpSUlKCqqgpzc3O0a9eu1ncTw4kTJ9C9e3fIyMjAxMQEampqaNasWa1jBhC531lZWcHb2xuTJ0/G2rVr4e7uTq9f/NmLt504cSIMDAwgLS0NQgitXyYUCmvt19OnTzF58mRISUnByMgIFhYW0NbWrvf5c/x+cEKJg4OD4ydhfjTfvXuHvXv3YsWKFTR2qC6xBIjiNUaMGAEejychDGpy//59DB48GLq6ujAwMAAhBAcOHKj3HIWFhZg2bRqcnZ3Rvn17DBo0iE5exCdxNYORMzIycPjwYZw7d441ea+v2OHu3buxbt066OjowNfXF5MmTQKPx6s1tkmcgoICuho9cuRImJiYQEtLizXZZygpKcH79+9x5MgRXL9+HRs3boSsrCzatGnDsng8fvy4VrEkfo219aWsrAxnzpyBsbExNDU1YWBgACsrK6SlpSE2NhZ9+/ZFYWEhAFFiBSZ2at26dbSoJSAaDzExMejSpQsePHiAS5cuQUlJCeHh4RJ9qTlZZ/r77ds3GmA/f/58mvFv9+7daNu2Leu63r17Bzs7O+zfv7/ee80wePBgODg4SJyfaVNcXIwDBw7gxo0bNP7r7t272L17Nw4dOsSKo+vatSuUlZWpdWj16tUSac1r68+dO3cwffp0NG/eHMrKylBTU6NiRFwsibd5/fo1Ll++jCVLluDQoUP0OdbMaiZ+XUyWu61bt+L48ePg8/koLy9nTfzF41c2bdoEFxcXNG7cGCYmJjAzM8P9+/clVvrFz3XkyBEEBgZCWVkZ9vb26NChA06ePImTJ09KCAym3ZcvX7B69WpMmDABCxcuZFmS65qQL1myhIodW1tb+Pr60u8xcy8vXbrEsm4JhULk5eXB2NgYenp6iIqKgpGREa0jVPP5v3z5EjNnzoS5uTm8vb1phsuPHz+yrkW83ezZs6nQsbGxgZeXF+3XunXroKamhps3b9LrEv+eCIVClJeX4+PHjxg6dCi0tLRqjYdiePLkCW7cuIFbt25BIBDg7du3tE5cbfcvPz8fZ8+eRa9evdCoUSOaGKWu53Lnzh2MHTsWxsbGcHd3R3h4ONLT0yUS2dQ8z7Nnz5CamoqAgAAoKCjg6tWr9b4zKyoq8ODBA6xfvx6HDh2q1ZLI8XvDCSUODg6On4CZMGRkZMDAwAC2trZQUlJCq1atJLI71WTHjh1o0KBBrVmzGGr+0CYmJqJBgwY0IL+ulV7x/jGZl/Ly8lBcXExdi2oTWOKZrgDR5LHmREScmlnInjx5AmlpaTRt2pQmoKi5sl7btR06dAjNmzdHs2bN6lxZrdnfz58/w8fHBw0bNmQlF2D6YW9vD1VVVXz//p2e6/Hjx7S+UV0wGcsyMjLw4cMHTJkyBZqamjAxMWHt9+XLF/Tq1Yu6GTH34MGDB7C3t6cuPEKhECdPnoSSkhIrKcGwYcOooFi4cCE6deoEc3NzjB49mrqsid97xg2zZ8+erHuXkZEBWVlZ1vkYxBMA3L59GydOnMD8+fNhZGRUa+C4UCjE3LlzERkZSQXs4cOHISUlBRsbG0hJScHFxYVVsDM0NBRqamqYPHkyeDweHZu1TRJrflZSUoLjx4/Dz88Prq6uNC13XZZI8c/v3buH27dvs4Lta8tAlpWVReuP7du3D87OzhLfzZqZ3mbPno3Y2Fh8/PgRUVFRCA8Pl8hgJn6u9+/fw8nJCREREdi/fz94PB5N7FET8XGcmpqK6OhojBgxgi5M1KTm9/HZs2d4//49PX9OTg5cXFywa9euOq/p1atXaNu2LfT19TFixAi0bNmyVgsxw65du6g4j4mJwcCBAyWsfeLty8rKsHXrVrx9+5YKoKqqKvTr148mZ6krEYVAIEBOTg4tOFufyBa/F9OnT0dAQADOnj1ba0IP5v+3bdsGHo+H1NRUAD9+HwkEAlRWVqKsrAz79++HkZERtmzZQsdZXeMREFlu+/btC1lZWZpM52e+Bxz/PjihxMHBwfEDxCfGMjIyiIuLQ35+Pl6+fAltbW1WmueabNmyha4MM9RnfRIKhUhKSgKPx4OWlhb9rD6hJC5i5s+fDycnJ1hbW8PLy4uuOtf8oRf/e/HixQgICEDr1q0RGxsrkcWpNpKTk6GoqAgVFRVWFr36+jlv3jwEBgbCzs7up+qGnD9/nlqcvnz5AldXV7Rs2RLPnj1j7ZeRkYH+/fvTcx88eBB6enqYO3cuLVpZE4FAQO8BMzHKy8vDpEmToKqqitjYWNYk58uXLwgJCYGjoyPevXuH+fPno1evXggPD2dNyAQCAU6ePIlmzZrBzs4OLi4uMDIyQnV1NaZMmQJ1dXUsW7YMJ0+eRMOGDdG5c2da/+r79+/Ytm0bgoKCaq1F8+bNG5ibm2PDhg2sjICAyAK1Zs0aHDx4EKqqqvDx8YGcnBykpKQwb968Wu/B9u3bwePxMGHCBDx9+hQuLi5ITExERUUFXrx4gbFjx8LW1pbGxggEAlhaWoIQAhsbG1rr60eTQXErnLhYYqwrtbmzMkRHR0NHRweNGzdG165dWWmdmWPGx8fj0qVL6NevH3g8HmJjY9GwYUMkJyfXekymXVlZGaZNm4ZGjRrB19cXTZs2RUZGRr3XUlxcjLVr10JPTw9NmjSh56hv3G/YsAGKioqIiIiAgYEBHB0d67Qs1XUvBQIBnj17BhkZGYlMkgA7PfXt27dhaWkJCwsLmJiY4MmTJ7Xe47KyMoSEhKBRo0bo3bt3vdfP9Cs2NhaDBg1iiQ2BQICAgACa2l2c8vJyurgxc+ZMWFpaQl9fH02aNEFsbGydmeYYxGtxideJqwnznvXz82PFUdV3P5ltu3btwoIFC9CwYUOYmppi9+7d1FOgvrH9s2KJ498NJ5Q4ODg4foKXL19CWloaU6dOZX3etm1bxMXFoV+/fti1axfLtWLDhg1o2LAhIiMj4ebmhm7dutEV7rrEEtMmPj4erq6usLe3p5OgH1mVpkyZAjU1NWzfvh2pqamwsbGBgYFBrav3DJMnT4aGhgbmzJmDPXv2QEpKCoMHD5ZIU17Tnebu3bt4+fIlrl69CnV1dfj7+9N9a+snn8/HihUrICsrC3Nz83onIkKhEBkZGeDxeJg4cSIVe1++fIGjoyNMTU0lxBLD6dOn0bRpU6xbt65e1x6G3NxcODo64saNGwBELoLjx4+Hs7MzZs6cydq3sLCQFgZdunQpeDweDAwMahVjT548wdChQxEbG4vq6mo8fPgQZmZmuHDhAgBR4L6UlBTLFTMnJwcjRoxAjx49WDVyxEVRhw4dYGFhQQPXAZH1oUOHDggICICamhpNRc4IByaoXxzmvh84cAA8Hg+jRo1CSEgIKwV7dnY2Ro4cCXd3d+Tl5SExMRGNGjVC37594e/vj27dutWa/rvmOWrCFAKtTSyJt7l69SosLS1x6dIlnDp1Ch4eHvD29sbu3bvpPgsXLgSPx6Nugh4eHrWmnq+L0tJS2NvbU4HFUNt3henbrVu3ICsrC3V1dVaij9q+04mJiWjYsCFNif39+3coKyvTuL660n7XZs3Izc2FjY0NlixZIhF/deDAAcyfPx/Tp09HcHAwbG1tQQhBgwYNaDry2q6pqqoK2traaNy4Mb2v9b1n7t+/T7eLuykOHjwYxsbGEoss79+/R9++fTFo0CBoaGhgz5492LNnDwghMDY2xtGjRyXqSzE8efIEpqam1EJUF+vXr4eUlBRGjBgBAwMDjBkz5qeTJTBJTJKSkrB27Vo4OzvDyMgIu3btqtWyVJP8/HxOLP2PwwklDg4Ojh8gEAgwefJkqKqqYtmyZfTz+fPno0GDBujVqxecnJwgJSWFqKgolJSUIDExETwej7oCbdq0CQ4ODujWrVudcU1MG6ZI57lz52BnZ8eqDVTXJIbZl5lAp6SkQFFREcbGxlBVVa1VLB07dgwtW7akrlxXr15F48aNISUlheDg4FpX/LOzs/Hlyxfq1ldZWYnTp0+jRYsWLLFUW7B+eXk5kpKS0LhxY1Zx0rrYtGkTmjVrhpiYGJZYcnZ2hoWFBasgKuNKNWTIEFqAlKG2+ByGO3fuoH379jA3N6e1ZfLz8zFu3Dg4Ojpizpw5da74Jycng8fjYcqUKaxYoppujYAogL5NmzYARBYv8QK03759o+Pky5cv9BzLly9HeHg4/Pz8sHDhQlRXV6OyshJOTk6wtLTEoEGDMHPmTLi5ucHS0hKbNm2Cl5cX+Hw+srKyYGBgwLoX4oJOvH7Mvn37wOPxwOPxqGBkyMzMBI/Ho7FozNjcvHkzPDw80L1791rFkvj1P3v2DC9fvmS5AB49elRCLNUc2w8ePGBlYcvKykJQUBC8vLywe/dulJSUwMvLC7NnzwYgSoZiZGQEZ2dnNG/eHCkpKXQc1vUMv337hpEjR2Lo0KFQUFDA8uXL6baa8U1CoRBFRUV4+/Ytrl+/jnXr1sHKyoqVKU3cupuSkgIejydRz8nGxgZdunSBs7Mz+vTpQwV9bdkjhUIh67vUt29f6OnpIS0tjV5HeXk5OnbsCBsbG8jLy+PKlSt4+fIlBg8ejFatWsHIyIgKYHFxBojEv4+PD9q3bw8FBQWaCa82USX+2d69e9GmTRscPnwYgCihhqGhIdzd3fHmzRsUFhaioKAAAQEBaNOmDRwdHel92L59O+Tl5WFpaQllZWUcPXoUoaGhtLAyw507d6ChoVGr6KmqqkJRURH27t0LHo9H+5GcnAwtLS2MHTv2h2IpOzsbhoaG2LlzJ+vzgIAA6Ojo1GpZev36NZ4/f04XTACRZalPnz4ssVSflZTj3wUnlDg4ODh+gtzcXIwdOxZOTk5Yt24dFixYAFVVVZw8eZL+iDLZ3d68eYNdu3bhyJEjtH1FRQWSkpLqFUuXLl1itWHSXf+MWLpx4wZmzZoFAEhLS4OqqirWrFmDly9fQkdHB8bGxiy3GqFQiNTUVKxZswYAqLvYzp078eDBA0hLS2PAgAGsrFnx8fGwtraGkZERzM3NqRuUUCjE6dOnoampiaCgINYk4e7duzh+/DgePXpExcSaNWvQsGFDlsWGuYc14wo2b94MeXl5xMTE0IQRRUVFUFZWhpGRkUQh3sDAQOoCVHOy8uzZs1onMDdv3qTZ2cTF0sSJE2Fubo74+HgAokx34m49gCg1M4/Hw+zZs1lxRuJWAECUAUtfXx8zZ86EoqIiFUmASKB6eXmxJooxMTFo3rw5RowYgWHDhkFaWhqdO3fG+/fvUVlZicmTJyMoKAg+Pj6IjIxEdXU1Vq9ejf79+6OsrAza2toYOnQo7UdqaioWL15cp5WNmdQPGjSIlbGssLCQ3gPxtM+AyN2pNrEkLkSmT5+ONm3aQF1dHZ6enqzrPnr0KPz9/dGuXTua4AEAFixYgMDAQLi4uEgkxsjKykJwcDB8fX2RlJSEsWPHQktLC4sXL4aioiKNFwoNDaWTcPExVVccHuOGJycnxxJLAOj35tixY/Dz86NisqioCEuXLoWVlRVGjBjBui8nT56kro0zZsyg27p27QpNTU2sXr0aw4YNg46ODjw8PKj1Qnx8Ll26FCEhIXBzc8OkSZPoswsMDIS6ujp69uyJ8ePHo23btrC0tMTw4cMxcOBAVhKThw8fwtzcHFZWVsjPz2e5nJ09exbPnj1DdXU1SkpK0KNHDygoKEjE9mVnZ7Oe6aNHj3D58mV07NgRPj4+9D3w6NEjmJubQ0tLi8Zx2tjY0GQGfD4f586dY1k927RpAwsLC7Rt21aiCPGDBw/QsGFDalESF3nnz5/H4cOHsWrVKhr7yfRx69atPyWW8vLyYGBgQJOjiL9LjI2NYWNjg927d9Nnc+TIEZiZmcHExIS65zLvYkYsKSoqUqsxx/8GnFDi4ODg+Eny8vIwatQomJqaomHDhtSiwbjTnThxAoaGhhJuYcyPe2VlZZ1iqS6rh0AgkBBLAoGgVrGUl5cHPp+PgIAA6kZUXl4Ob29vNG3alGXxAUSTxuzsbBQVFaFt27Y0luXTp08wMTGhrm+AKOOViooK9u3bhx07dmDYsGFo2LAhFVqMZYkQgvHjxwMAJk2aBFNTU+jr66Nt27bw8fGhVoX169ejUaNG1BoAiGKY5s2bR61VDJs3b0bDhg0xadIk6tq4Y8cOOrkW379Hjx5wdHSUuI+fPn3CtGnTkJGRgezsbInsU9evX0eXLl3QsmVLmmQiNzcXY8aMwbVr1zBnzhy0bdsWGhoa6N+/PxVUALBy5UrweDzMnTuX5XqUkpICBQUFei5G8Ii7a1VUVKBjx44ICQmhY+DOnTvQ0dFhJa64f/8+dHR0EBYWxroucWvDmTNnwOPxICsri4kTJ7Imt8OGDUOPHj3ovWJi7IqKiugxdu/eDR6Ph379+uHChQvIysrC5MmToaioyMpOKD5W6xJLgEhYq6qq4tSpU8jIyECfPn3QsGFDLF68mLY/duwYbG1tERkZCUBkRZOTk8O4ceNgaWkJNTU1CeHy6tUrODk5YfTo0cjLy4O9vT0aNGjAEiSASCw1b94cR48epWmn3d3dUV1djVWrVmHkyJHw8fHB3r178eHDB5SXlyM+Ph6KiopYvHgxqqqqEBwcjGHDhuHQoUOQl5fH9OnTWaKuqKgIy5cvh6WlJQIDAxEdHQ0ej4dnz56hsrISW7duRePGjREfH4/w8HBYWloiKyuLtp85cyaUlJRYxwREsUDNmzdHdHQ0YmJi0KxZM7Rv3x5Pnz7F9u3boaGhgZ49eyIoKAjjxo1DdXU1+vfvj9atW6Mm8+fPB4/Hg7KyMj5//kyPb2RkhN27d1MBlp+fj+7du6NZs2a4evUqysvLERYWhnHjxtFjRUVFoVmzZigrK8OVK1cQEhICDw8PHD9+nI6Nbdu2ITExEbt27aKiLScnB0KhEF26dMG4ceOopaxTp05QVFSkqfBXr16NixcvUutpjx494OrqyqrjVV1dDW9vb4wdO5Y1FsX/vW3bNpZYqqusg7W1NXr06EE/Y74LHTt2hL6+PqysrPDgwQOkpqZCXl4ea9euRU5ODjZu3Agej4fRo0fT9/jnz5/RuXNnaGpq/jDBD8e/B04ocXBwcPwC+fn5GDNmDFq3bs2a8AGgFqfakiGIT2yTkpLg6OiIsLCwn/pBZcSSvb09HB0d8f37dwCile5Hjx6xAqLfv38PfX19HDx4EIDICtKtWzfcvHkTAoEAWVlZKC4uZgV/v3nzBmZmZnTl9suXLxg3bhwyMjLA5/Px7ds3tG3bllUcFhAJGx6PR+voVFZW4vbt2+Dz+Vi1ahXU1NSoK+DEiRMhLS1NA9Grq6uxfv16Vsr0uLg48Hg8rFixQkIsjRo1CoqKihg9ejTLqnPp0iX06dOH9uHhw4do1qwZ+vTpw2ofGxsLMzMzvHr1Cl26dEHr1q0lYosuX74Ma2trtG7dmmYCq6ysxNSpU6Guro5169bh2rVraNGiBYKDg6m7HPBHumzxBALp6elwdnamK9YXLlxAUFAQzMzMkJCQgAULFsDHxwcWFhasmi+3b9+GlpYWXQ1nRPGNGzfQqFEjuoKfkZGBo0eP4v79+/R+zZw5E02aNKExFrm5uYiNjYWKigq1Dh46dAhWVlZo0aIFbG1tERERQccsI5Z4PB66desGT09PlpsRQ02xZGtrix49elAXz5s3b8LZ2ZmKvbS0NMjLy6Njx45o2rQpy4X1ypUrEAgEuHDhAubMmUPHSHZ2NgYNGgRXV1esWrWKdf73799DIBDgwYMHUFZWhrW1NczMzCT6GhYWhmbNmsHFxQWKioq4ffs2YmJioKqqirlz52LYsGEwNDREv379UFVVhby8POpSa2pqCnNzczx//hz6+vp0/DPf5QcPHqCkpAQCgQC7du2Cv78/2rdvz7IMVldXY8uWLVBSUoK0tDS9z8yE/NixYzAzM2OJp0ePHkFfX5/lsvf27Vu0atUKfn5+AP6wRIun4z5x4gQsLS2xcuVKlqV63759NCsdn8/HrFmz0KJFC1y8eFHi/fP161eEhYWBx+OhTZs2MDExoWOTWThgsh0CImtoSEgIPD096TsHEH2X7t69ixcvXtC+FBcXw9bWFkuXLgUgGkO9e/emGfQAoFWrVtDX16fuwGfPnkXHjh3RsmVLJCQkYOHChfD29q6z5pP44sC2bdugra2NqKgoWlbg6dOnyMvLo4Lx3LlzkJOTYxXnTk1NRY8ePXD37l1YWFigc+fO6NmzJxISEgD84bIXEBAAGRkZDB06lL5PCwsLWRZZjn8/nFDi4ODg+EUYy5KTkxP98Zw9ezbk5OTqzZolLpa2bNkCfX19ieQQdcFMJHV1dTFo0CBER0dDX18fUlJS6NOnD8stysvLC8bGxti8eTPc3d3h4uICPp+PuLg4GBgY0IKWjFDIzs6GkpIShgwZgoMHDyIgIAAuLi60vx8+fIC6ujq2bdsGALTIIiDy5+/Xrx/L3ae6uhrh4eE0tfSxY8cgJydH3W1KS0upC9Thw4dZE545c+agQYMGWLZsGUssTZ8+Ha6urvDz86OTTD6fjxMnTqBly5YYOHAgtQTt3bsXzZs3h42NDUJDQxESEsJKR75nzx74+/vTeApxGKuHgYEBiouLcerUKZibm9MV7Rs3bqBJkybQ0tKCo6MjTp8+TWOSDhw4IDF569atG61lBIhEwZQpU6Crq0szhTFtBg0ahKSkJLx69QqNGzemcRd8Pp/WBTI3N0diYiL279+P5s2bQ0NDA6amphgxYgS+fPmCr1+/YvTo0eDxeDAxMYGNjQ2rmOy5c+fQpEkTLFmyBOfPn0dCQgKcnZ3h6upKXSNPnDgBHo+HadOm1ZsQg5ncjhkzBubm5rCwsKDj+dOnT5g1axbKy8tx9uxZqKurIzExEZ8+fYK7uzt4PB51aQREgldLS4vW4mF49eoVBg0aBBcXF2q9ZCgoKEBZWRnu3r2L+/fvo1OnTjA1NZWIdUlKSsKqVavw/PlzXLhwAcbGxtQieP78eTRq1Ag7duxgtUlPT8eePXvA5/Px4MEDWFpaIjs7G58+fcLy5cvh6emJpk2bonPnzjRZAgC6iCFORUUFdu7ciSZNmiAuLo5+XlVVhYCAAHTu3FkiDbympiY9LjPemYQyTI2ga9eugcfjYdWqVRAKhfjy5QsGDhwIDw8PzJ07F6WlpcjNzUWHDh0wYcIEAKAWOOa7/OHDB9y4cQPR0dEsMbpv3z4kJSXRsZmcnAxZWVlYWVkhKyuLJZSvXr2KLl26wNvbG/v27UN0dDTU1NSgrKwMLy8v1uJBUFAQ9PX1MW3aNFoDjc/nY9OmTTQhB5NQgRkH9+/fx+TJk6mbYp8+fah4+5FY2r59Oxo2bIjly5cjNjYWxsbG0NDQwIABA6gYS05ORtOmTeHm5gYvLy/Iy8vD0NAQADB+/Hh4eHhg3bp1ePPmDQoKCmBlZYXBgwcDABISEsDj8TBgwAAJN2CO/w04ocTBwcHxJ2DEUrt27eDo6AhpaWncvXv3h+2YH/GKigpaGPNnYKq/37t3D2fPnoW5uTnOnz+PgwcPwsXFBQEBAXRF9+HDh/D390ebNm3QoUMHVFVVISUlBfr6+khJScHkyZPh6+sLd3d3mt0uNTUVSkpKsLCwQLt27SQyUYWGhsLNzY2uiDMTlPDwcFbNIIZu3brh8OHDOHnyJCtxQXV1NTZt2oT9+/dDKBTi7NmzOHHiBMuVbebMmeDxeFi2bBm1qoSGhmL37t3UBezAgQM0LmTv3r2ws7ND3759qdXk7du3GD58OCIiIjB+/HgJy9vRo0fh5eUFDw8P6honEAgQFxeHRYsWUVeoe/fu0b6fOnUKysrK2L59Oz5//gxFRUUEBgayVtKLi4tZ58nJyYGenp6ENa6kpIQ1oTt//jyNeQOA0aNHw8DAgBV/8f37d5ibm2PFihUIDAzE5s2b8f79eyxYsACurq7o1asXFTtXr17Ftm3bkJaWxioGHBUVhX79+rH6cvr0aTg5OWHYsGH0uR4+fJhah+pDPMV6amoqXr58Sa+fmTgy1gxmTA0ZMgTOzs4ICgqiMU1v3rzBlClToKioiOjoaNY5Xr9+jaFDh8LIyIgWX3748CFat27NEjiXL19G586dqVhatmwZKzsgIEpP7uTkBEAkmBl3KkAkci5evCgRK5OXlwcpKSkEBARAT08PISEhmDVrFk6cOIEWLVogOTn5h5nOqqqqkJycjMaNG1OxFBQUhJYtW7KsiYBo4UJWVhaJiYkA/lh8qKqqgq2tLcsaN3fuXEhJSVGR8/HjR4wePRqtWrWCjIwMTExMYGlpSZ9rQUEBHB0dsWjRIhw5cgS9e/eGs7MzbGxsYGJiUuvCDRMrGRAQgKZNm1LXYvFEGdeuXYO7uzt69uwJGxsb3Lt3DydOnMCIESPQqlUr2j+BQIBOnTrB0dERsrKyWLZsGbU2i7ssOzg4wNDQkJVc5Nu3b/Qeffr0qd7sfOKxWCdPnkRKSgq0tbVx8uRJLFy4EMHBwWjbti1NvvDw4UOEh4cjPDwcvXv3RlVVFV68eIEOHTqgf//++Pr1K4RCIdauXQsPDw/k5eUBEBXatbOzg7a2NmdJ+h+FE0ocHBwcf5K8vDz0798fxsbGEi4/9U2caoqjH4kl8R99QFQnRTz9cWZmJnx8fODr64tjx47RNh8+fKDt9u7dy6qnc/ToUfj6+sLNzY3GluTl5bHcYMQrzh86dAhubm4YMGAAnUjy+Xx4eHjQmCRxIiIioKurC0VFRWzcuBGAKGYpJiYG3t7eWL58OaKioqChoQFFRUU4OTlh+vTptP3cuXOhqqoKU1NTmJqawszMDB07doS8vDx1c2NWxQHRpJcRS7t27UJlZSW9jocPH6Jbt24IDg7G3LlzaZuUlBR4e3vDwsICSUlJSEhIgKamJkvwlpeXIz8/H6WlpfD19cWMGTOoBcnR0RGNGzemMUdr166FiYkJpk+fTrOMVVZWYsCAAQgPD6eioObzTE5OxpgxY2gyDkBkVYiIiICioiLmzp2LlStXwt/fH8bGxujbty+6deuGwsJCun9iYiJcXFwQFhbGqjfDnOfFixeoqqrC4MGD0bZtW4nnNXXqVDg5OUkUW2WobYwmJSUhMzOT3uft27dDSkoKJ0+epJPY0tJStG7dmmavKykpQWhoKPbu3UuPIz6Jnzp1KgwNDVmxa4DImpKQkED7kZ6ejh49esDJyYlaWACRxa5z584wNDSEhoYGevfuzUpOsHv3bri6uiItLQ0KCgosAXvkyBFERkYiNzeXijxGxGRmZiIyMhLz589HTk4OvWYfHx+sX7+eHuPTp0+13j/mOpOTkyEjIwMZGRmYmprS4+fl5dHFEEDkhqqtrU3dNpniqFZWVqzzAX9YYRkxUlpaivz8fGzduhXHjh2jxxS3XNrY2KBRo0aIiYnB+fPnIRAI0K1bN8TExNSZGv3WrVuws7ODgYEBHWPiiwIPHjzAzZs30b9/f9a4i4qKgqmpKdasWUPfHU+fPsWMGTOgrKwMRUVFak0SdwV0cHCAiYkJrl27xhJFGzZsoHFTP6pJB4i+52PHjmXFup07dw5dunSBq6srzp8/jx07drDq4d2+fRuqqqqQkZHBtWvX6PFGjx4NFxcXul9MTAxWrVrFWZP+h+GEEgcHB8efRCAQoKCgAPn5+bh16xZu3rzJsozU1YbhwoULSE1NZaW5ro/FixcjJCQE7u7uGDRoEGvbw4cP4evri4CAANYq++rVqzFp0iR06dJFoi5QSkoKfH19aUYyhtqSS/D5fKxevRpOTk7Q0dFB9+7dYWdnB3Nzc1RXV+PBgwd48eIFFV3fv3+Hs7MzDA0NUVhYiKysLHTu3BlKSkrQ19fHvXv34OTkhLt37yIzMxMxMTGws7Njia5jx45h5MiRNDX29+/fYWpqCikpKSxZsgQAO5nBnj17YGVlBUIIunbtCkBkjVBTU0NISAgGDBgAGRkZ9OjRg1rGLl++TONHrKysWBN4cYqKimBra0vdBysqKjBkyBDcuHGDTta+fPmC8ePHw8fHB0pKSkhISMCTJ0/w4sULNGzYkBXTxPD69Wv4+PigadOmNHEGw4IFC6CjowN9fX1ahys2NhZ6enowMDBgZXMTCoVITEyEh4cHAgICWCLq8OHDMDMzw61bt7Bq1SrY29vj+vXrrEnm4cOHYWhoSAXe5cuXcfbsWdbYFB8TFy9eRMOGDTF27FhWfI2npyd0dXVx5swZ2r+ZM2dCS0sLkZGRcHV1ha2tLR1Pw4cPR7t27bBv3z7k5+ejuLgYU6dORatWrTBnzhzW9TEw/WYKDdvZ2bFE89WrV+Hp6QljY2M4OjoiPDycFUdnamoqEU9WXl6OoKAghIeH4+TJk+jTpw/atWuHmTNnUle+munCJ0+eDHV1dZqghBH/Ne+VOIxFtWPHjqz707ZtWzg7O2PTpk0oKipCfn4+IiMjoaioiHHjxmHevHnw8fGBlpYWpkyZgokTJ+L06dNUqDBiiRF+4ue/c+cObt68SVN/AyJLac0EEp6enizXwEOHDmH16tVYuXIljfG5f/8+XF1dYW5uTmMFKysrMWfOHHh5eSEwMBAdO3ZkHZcRS0pKSqxkE4mJiWjcuDH09PSwYsUK1rNgcHZ2hry8PKtAdXx8PJo1a1ZrBsOePXti06ZN9O/MzEw4OjpCSUmJugIznD9/Hl27doWjoyNat26Ndu3aITU1FVlZWZg9ezaUlJRgaWmJadOmUQGclpaGhg0bIiQkhCaiEM8MyvG/ByeUODg4OP4E4hO3uLg4GBoawsTEBPLy8liwYEGtdYTE20yePBna2tqwsrKClJQUxowZw8osBrAnO4sWLULTpk0xbNgwGBsbo0WLFnTSzvDw4UNYW1vT1VammGK7du2gr6+P5s2bS5zj4MGD0NHRQdOmTVkuWeKTaPH6Lvfu3cPUqVMRGRmJ+Ph4VFdXY+LEidDR0YGqqioMDAwwbdo0AKJVWX19fejp6cHExAS2trZQVVWFh4cHIiIiWCmVP3/+jPj4eNja2tJ4ips3b0JBQYG6uRQWFsLY2Bj6+vrQ1dWl8UXigmHPnj1QU1NDo0aNMG7cOBw/fpweDxClK1dUVERoaCgKCwsRGxsLKysrvHnzhq7q12YN/PLlCywtLdGhQwcsXboUvr6+sLW1pfdGvA9fv37FokWL0K5dO+jp6WHy5Mlwc3NDUFAQS8AwpKWlwdfXF8rKyiyhffPmTbx58wbfvn1Dfn4+hEIhSktLMXfuXOjq6mLYsGEsC5BQKMSKFSsQEBBA6059/vwZHTp0wMqVK+nfFhYW8PX1xeXLl+m1jh07Fq6urvj27RumTJkCY2NjGBgY0Pgv8XMwbN++HTo6OhgzZgxr0u3j4wNNTU2ajODVq1eYMWMGvLy8aNKEmJgYtGjRAtOnT8eECROgpKSEYcOGgc/nIycnB9OmTYO5uTkmTZpEj3v79m2JFOUPHjzAgAED0KZNG+zZs4f28caNG8jJycGRI0fg4OCA8PBwVoIAfX19+Pj44PTp09i9ezf8/PxgaWmJAwcOQEZGBjExMZg0aRL8/f3h6urKei579+6lab6Z2C9AlCpeVlaWWkfqQlwIrF27FsrKyli9ejU6dOgAW1tbjB07FkVFRfj27RvWrFkDS0tL+Pj4wMzMDMrKyggLC4OxsTFat26NwYMHUyvMvHnzICUlxSowPHXqVJiamkJPTw/Gxsb0u8nw7ds3PHr0CAEBAawECdHR0dDQ0EC3bt3Qpk0b2NjYICkpCYAoNoqp3ZWXl4clS5ZARUUFUVFRCAgIAI/HowkbGF68eIGOHTuiR48eEAqFqKqqwufPn3Ht2jXMmDEDpqamLCEjHvMYGRlJ4/QAkVWybdu2mDlzJms8fvz4EatWrZIoMbB79244OjrCyspKwvJ/4cIFeHh4oFOnTggNDYWnpycOHz6MZ8+eIS8vD5MmTYKtrS2mTp1KheH+/fsREBCAPn36sAQcx/8mnFDi4ODg+A+YPXs2WrRogcuXL6OiogITJkygBTprE0uAKF2vhoYG9b9fuHAheDweIiIiJIQMIHInmjVrFo1XefHiBfr06QM3Nzc6eWF49eoVBAIBPn78iHHjxtEJ3vXr1+Hp6QkjIyN6DkZonD59Gtu3b4empiYr3khcLDETkppC4uTJk9DW1sa5c+eQlpaGVatWoUmTJtTVqrq6GomJiVizZg0OHTqEV69eITIyEpqamvDx8WH1vbCwEDNmzICDgwOthcQICyaW6suXLygoKICHhwd0dHRqFUtnz57F+vXr0bhxY+jo6LDSGwN/iKWwsDCMGTOGWtMSEhJYK9s1r/3Ro0ewsbGBs7Mz/P39JWJLagqsV69eYf/+/bCwsACPx4Ovry/d58uXL6wU5bdu3YKfnx/s7Ozo5Jux7KWnp8PCwgKpqakQCoUoKyvDjBkz4OzsjKioKJa7ElMUFRClCw8KCoK/vz8r3ig3NxdWVlawtbWFpaUlOnbsCEVFRaSnp2PevHlQU1PD9evXUVFRQePFevbsSduLW1aYmjVjxoxhncPHxwcaGhosixQzni5cuABDQ0OaWfD27dvg8Xiswp/5+fkYO3YsevbsSQWiv78/nJyc6PeAIT09Ha1bt4aZmRm2bNnCOhcgWgxwcHBAr1696DmvXLkCR0dH6OnpwdHRET179sTdu3dhZmZGY4M+ffqE5s2bw9DQkMbdMP2NioqiMTXMM83Ly4O3tze1dv6o6OitW7cwevRoVu20+fPnw9HREWPGjKHWvdLSUpw5cwY6Ojq4efMmvf/Lly9H27ZtMXbsWPrZlClT4ObmBqFQiNmzZ0NNTQ2XLl1CQUEBxo0bBx6Px4oB2759O9zc3FjjeceOHdDW1qbvjs2bN0NKSooVi3fr1i2YmpoiICAAa9eupRkzP3z4gPj4eMjLy0ukdWdcFrds2QIDAwOaKOTly5eYPHkyTE1NWZlEZ82axUq2wjzTqqoqjBw5Eu7u7nRbze/emjVrMHnyZPr33r170b59e4SEhLCSfQiFQty7dw8CgYC6bXp6erKeyaRJk2BjY4Np06axXA5rCjKO/004ocTBwcHxC4j/ID9//hwdOnSgcUFHjhyBkpISBg0ahMaNG2Py5MkoKytjTZhycnLQs2dP6g9/8OBBNGvWDNHR0ZCRkUFERAR15QFE7iEaGhrQ0NBgrV4/efIEffv2Rdu2bWl6bYadO3eCx+PBysqK5RZy+/ZteHt7w9jYGJMnTwaPx6MrrF+/fsW2bdvqFUvM9TPXc/jwYQwYMIDlrgOIXPoaNmwokdKZuXdMogVtbW0sWrSItU9hYSHGjx/PinP4+PEjeDwerQ0FiESep6cn9PT06GRq4cKFGD16NG13/PhxKCgoIDg4mGYjY7bdu3cPhBDY29vD1dUVTk5OkJWVpZaYmoinOGYCu+uqZ1Vz0vb161ccPXqUHmPGjBlo27Yt1NTU0LFjR+zevRuASEB06tQJDg4OdFL+9u1bnDlzBp07d4aNjQ1Onz4NQBTLER8fDycnJ4wfP77W2KLHjx+jSZMm4PF4dCLL9O3z58/YsWMHxo0bh7lz5+LZs2d49eoVOnXqRGviHD9+HIqKihg7diyaNWuG3r17swQzQ3JyMhVL4pYlX19faGtrSxR9PXHiBJ3k7tq1C3JycjShwtevX3Hz5k0UFxfjzZs3tDDy27dvcfnyZZpdjbkPDIMHD4ampiZ8fX1RXFzMCvwHRMk/7O3tqSBiePPmDYqLiyEUCpGeno7evXujsrISb9++hZGREYYOHYoTJ07AwMAAjo6ONB03cz0102uPGDEC5ubmEs+iJmlpaTAxMYGmpqaElczd3R0WFhYsK/OOHTugr6/PioEqKSmhVth9+/ZRgSwUCqmViDn28ePHoaSkhH79+qFx48as79KZM2dYcYmzZs2ihX737dsHBQUFmtDk+/fv9P3EpJKXkZFhCYv8/HxaWHnlypWssfLgwQMcOXIE9vb2sLOzo2IpKysLU6ZMgaGhIQYMGIDAwEDo6uqCz+dj165daNu2Le7fv0+tOrm5uVBWVqaWUvFnXV1djbFjx8LQ0JAVl7lz5054eXkhJCSElZ2U+V4ymUWZdOc1xZKjoyPGjx9fbxwax/8enFDi4ODg+BMUFBSgvLwcGzZsQGlpKa5cuQJtbW0aIzB06FDweDyMGDGCTqqYCf3+/fvx9etX3Lp1C3p6evTHfvbs2SCEoFOnTtTd7MWLFxg/fjzk5eUlAtyfPn1Kk0kwYg0A3r17hx49eqBx48Y0qxPDnTt34O/vDxkZGQQFBUFFRYUllnbs2FGrWBozZgy18gAiodauXTsoKSmxapAwk45hw4ahU6dOKC8vr9UylZOTg8jISLi4uLCyeDH9YCY+58+fx/3797F582Y0adKEVVT0zZs38Pb2hrS0NDp37oxGjRpJuNYcPXoUUlJSiIqKYmXpYu7FqVOn4ODggCZNmqBv374SViJxxK9j6dKlmD59er3ps2u2AURpztXU1LB37168ffsW5ubmaN26NZ18njt3Dp07d6ZxGxoaGsjKysLVq1cRFhYGKysrlliaNWsWTE1NWRNfcV68eIFmzZrBx8eHZhCsjY8fP0IoFCIpKQmFhYW4du0atLW16QQ5KioKhBBatHj37t0si0FdYsna2hqdO3cGILLI8fl87Nu3DxYWFlSIiaf9PnjwIHr06AF1dXXs378f27dvB4/Ho6nSz58/j44dO8LHx4e69h09ehTjxo3D0qVLUVBQgHnz5qFdu3bw9fXF4MGD6XM/fPiwhBueOEKhkArl3r170+xnAODv749mzZrB3d0dZWVlEAqF1Epx/fp1GvP2/ft3mJiYSCwA1MaECROgoqKCyMhIGm+TmZkJV1dX6OjoQEtLi7qwHTt2DCYmJnSCz4zP9+/fgxACGRkZrF+/no7H4uJirFixAt+/f6ep19etWweBQIA+ffqAx+Nh8ODBtRZsnTRpEqZMmYIbN26wMlby+Xxs3ryZFuOtrq7G2rVrIScnx7LeACKxxLzPmEWhcePGwdfXF2/evMHFixfh4OCANm3a0D6/ffsWq1evRvv27dGzZ09UVVVh4cKFmD9/PoKDg2FiYgI/Pz/s3LkTxcXFmDJlCgYNGkSFLiASQ8+fP0deXh6mTZsGU1NT1ntz586dEklsvn37xkrrfvPmTXTq1ElCLI0cORIeHh6sZCkc//twQomDg4PjJzh8+DAuXLgAQFQ8lXEtY1aUx48fj969e9O/4+Li0Lp1a5ibm0MgEGD8+PHo2rUrhEIhDcCeMWMGOnfuTH+kFyxYgO7du8Pb2xv79++nAdQ5OTmYMGECjIyMJETFgwcPMHv2bPD5fFy6dIlOhrOzsxEUFIQWLVrQCQHDtWvXMHbsWLx//x5dunSBkpJSvWLp69evmDRpEiwtLVkxI8ePH4eHh4eEixUgcgFq27ZtrVmpmEnNu3fvqFiq6aYDiESDgoICzfyVlJSEBg0asMRSeXk55syZg+jo6DrTWR8+fLhWsVRZWYn379/D0tKSJhoYP348dfery3UqOjoampqaWLx48U+nBGYm4Q4ODjh69CgAUcIEWVlZmhWQ2S81NRXjx49HZGQkdeMCRO6TNcXS169fkZCQQBMqvHz5EpcvX8br16/pyvfDhw8hLy+PTp06UUGWmppKrThjxozBsGHD6PkBYNq0aejVqxe1VDFjs0uXLsjMzISNjQ2rHg/wh1gaO3Ysnjx5grS0NEREREAgEGD06NHw9vZGeXk5ysvL4ebmBh6PRxcJAJE7U4cOHRAeHo6oqCg0bdoUDRo0kIjFO3fuHEJCQtC6dWt4enpCQUEBcnJyyM7OxurVq6GgoIDZs2djzJgxMDU1RcuWLallZv/+/dR18smTJ9SVU5yvX7/C2tqa9q2iogIDBw7EqlWrkJ+fD0AUjzR8+HD06dMHzZo1Q9euXbFq1SqUlpZi6NChtM4OUL8L3rhx49CmTRvMnTuXCoazZ8+ic+fOMDAwoO5vHz9+hJaWFrp3706LpQKiZCBWVlbo3LkzWrZsifXr11PRxrxnoqKiMGDAAPpumjJlCvz9/eHj40P7lpWVhdzcXFRVVdH6TDwej4ocgUCAkpIS+Pn5ITg4GGfOnEFFRQUqKyuxcuVKNGjQgBUbBYhE3ObNm1FdXY2cnBy0b98eFy9epOOsNrHEWGiFQiHWrFkDFRUVmrXw2LFjmDRpEuTk5BAeHg5bW1uoqanR7VlZWTAyMqIW9tevXyMuLk5CLG3cuBGjR4+GQCDA8ePH0b59e9jY2MDBwYEWc75x4wa1LDHfV+Y5cPz/ghNKHBwcHD/g69evCA8Ph7S0NMLCwiAjI0P93JkaJz4+PujVqxcAURaojh07onPnzuDxeOjcuTOaNm1K2zDpocPDw+Hr64vS0lLa5ujRo4iNjYWmpibWr19PRdTr168RHR2Nli1bUlEh7tISGxuLVq1aYe/evbRNdnY2/Pz8ahVLDNnZ2QgJCalVLGlpaaF///4ARPEa8+fPh7m5OSsz3cmTJ+Hr6wtPT08aO1JUVARPT0+EhYXVmSZdXCwNHz4cRkZG2Lt3L524ffjwATExMZg/fz6rnbhYEhdh9dVUAURukU2bNsXQoUPrjB1jUmRPmDCBiqWa/T969CjU1dVZRVHrur6aIjE/Px+tW7cGn89HSkoKa7W+tLQU27ZtQ0FBAa5cuYKWLVvCy8uLVUcG+EMs2djYYNSoUdiwYQMVM/v27YOqqio0NDSgp6cHf39/6maWmZkJeXl5dO3aFTdv3sSIESNgYGCAwMBAyMrKsoLShUIhunbtinbt2gEQLQaEhIRg3bp1mDhxIkL/j72zDssq696/D4oYlKACgkhIdyMIiiIdgh2o2DI2AnY7Y3d3i93d3e04YneMga3k5/cH19nf5wg6OvHG733u65pr5OTe++xznnXvtda96tXDz88PPT09bGxsZCpjCxcuxNTUlISEBAYOHIijoyNubm7o6uqKOZiXl8e6devw8PAgICCAgwcPsmzZMsLCwoSK4sWLF1EoFKirq7Nq1apCtY3OnDnDwIEDsbW1pXLlyjg5OTFixAg6deokvE9QYKz7+/vLwuGWL19O27ZtWbNmDS4uLtjY2NCuXTtBeqV3MSIigj179pCWloaVlZXYP2XKFMzMzMQc2LlzJ/3790dXV5fGjRsTGhqKQqGQhbQBLF68mOTkZPr37y/IPxQQVQ8PD4YPHy4jS9HR0Xh6eoo5cObMGbS0tIiKimLBggXs27eP0NBQPDw8yM3NpV27dlStWpUZM2YID1VWVpZ4F6VnGRcXJ1PGTE1NxdbWFn19fQIDA5kxYwbz5s1DQ0ODZcuWcefOHS5dukRoaCgVK1bEyMiIRYsWCSL+6dMnJk6ciEKhYPTo0Zw9e1YWajlq1Ch8fHwICwuTkby8vDwOHDiAt7c3np6eMhW7AwcO0LVrV1lelIRLly4xZswYatasiUKhID4+XnzzfvrpJ6ysrIRgxv379+nXrx92dnay0gBQEAJapkwZhg8fzoULF4iMjERfX1+M9+HDh6lXrx5ubm5s3bq1UDtU+N+AiiipoIIKKnwHnjx5gqWlJcWLFxeGoXKdISlEKDw8HCcnJ6EgZW9vj5qamkhSVjaed+/ejUKhwNPTExsbGxwdHRk6dCgVK1bk5MmThYzDx48f06tXL+zs7GQrpIMHD8bAwIC9e/cWOufZs2dCVvhrMrYvX74kOjq6EFlatmwZampq4l5SWJO9vb1MSW7Tpk0EBQWhoaGBt7c3jRo1wsvLS6xo/xFZmjZtGm3bthVjc+nSJaG6JnkTlEUkpDC81NTUPyRIyli5ciVqamr8+uuv7NixgxkzZrB582ZZuN6AAQPw8fGhV69eIsdKuf2TJk2iTp06gDy34UsoCzWsXbuWW7du8e7dOywtLUV9JOV6OFevXiUoKIidO3dy+fJl3N3dUSgUInRS2fA8duwYERER6OrqYmVlxZIlS7hw4QL29vZMnTqVW7dusXTpUmJiYrC0tBT5Tp06dUKhUNC0aVNu3ryJi4sLCoWCQYMGiWtLfdqxYwdly5bF09MTFxcXHB0dmTt3Lrq6upw9e5ZXr17x5MkTQkJCqFatmixPbvr06cTGxpKbm0t4eLgwZpUhFVyuXbs25cuXx8fHR4RbQQHZPnXqFKmpqWhoaLBgwYJCczs/P5/379+TkZFBx44dCQgIoFKlSqLIrPRcMjIyqFKliiClUDDHKlWqRP/+/Zk0aRIGBgbUrFlThA2uWrWKwMBADAwMsLKyEmN48uRJ2rVrV6SM/KNHj+jfvz8NGjRAoVCQkJAgCgv36tVL5KRJBr7ygkPnzp3x9vYmNTVVEN+dO3cSFRWFp6en8CxdvnwZPz8/qlatip2dHSEhIbK6Zm3btqVq1arMnDlT5CzNnz+f4sWLExkZibu7u0zdbvny5RgaGrJhwwYWLlxISkoKGhoadOzYkUmTJlGqVCmMjIxwdXXF0tJSLBIoz0dpnMePH4+amhrFihVj27Zt4h47d+6kfPny6OvrC1EW6Z3Ky8vj4MGDmJmZkZiYKI53dHTE0NCQQ4cOAf+3EJKXl8e0adO4e/cuWVlZDB48GAcHB/G+Xb16FQ8PD5kwiKSiWK5cOVEc+NOnT0RFRYnabc+fP8fS0lJ4ViXs27ePZs2aFSmyo8L/BlRESQUVVFDhG5B+0B8/fkxUVBTh4eHo6+uLUDNl2dr09HRatmxJcnIyOTk5fP78WVR7V1NTE/LFyiIABw4cICUlhSFDhvDq1StCQkJESNTDhw/Zv38/zZo1Y9KkSTx48IBnz57Rvn17mjRpQn5+Pvfv38fFxUUYbs+ePeP06dMMGjRIGK/Pnz/Hzc1N1DdZsmQJ/fv3JzU1VayUvnnzppBn6dWrV+zcuVNG7p4+fcovv/yCra2tzNCrXr065ubmuLu7y3JOvua9kXDnzh3s7OyIjY3l4MGD4l5JSUmoqamRmJgok9Q+deoU586dY8aMGejr6/9wYvWzZ8/o1asXhoaGODs7Y2pqiqOjo0w9cODAgdjY2KCvry+MTQmDBw/G1NS0UC5TTk4Ou3fv5t27d5w8eRJzc3N27NhBr1690NXVFYbWzJkz0dfXFyv8kopdZGQk/v7+Itzy8uXLeHh44ODgIFbapTlz7949Tp06xcOHD2nSpAmurq6MHDmSZs2ayQqAnjlzhqioKDG2+vr6+Pj4cO3aNTE3GzduLFN6U27Tnj17+Omnn+jXrx85OTn069cPf39/8vLyZDkyPj4+VK1alQULFojtubm5fPjwgZEjR9K3b1/c3d2FIfwlHj58yNu3b8W7ptwHKJAu19DQYPHixYIUTJ06lQsXLoj73b9/n6SkJDQ0NGQ5c1CQgyJ5nCRcv36dvn37ir+fPn2KsbEx/v7+Iozx2bNn/PrrryLcbsuWLdjY2Mikz6X5qkyac3NzGTlyJAYGBty7d4+9e/diYGAgCpd++vSJ9PR0SpUqRf/+/UUfWrVqVcgoP3LkCBEREXh6eooQs7dv33Lv3j1u3bolxkx5waB169aCLL19+5asrCwWL15Mo0aN6NGjh5i7e/bsoW3btjIp7zdv3jBt2jS0tLTYsmULt27d4sCBA5w4cYKoqCiGDRtGTk4Od+/eZevWrcTHx5OUlCRCfocPH46enh4GBgZs27ZNPMvDhw+jo6MjC+eUICk7SmP4+PFjunTpgo6ODh06dJAd5+/vLwvpXbZsGaampoLwZGVlERkZSUxMjOwed+7cYdasWeK8rKwsvL29OXfuHC9fvsTIyEiWg5meni7yRL8U7FDhfwsqoqSCCiqoUASK8hLk5eXx5MkTmjZtip6eXqG8HGWjXQrJk9C9e3fU1NQKrUQrq6y9evUKU1NTUlJS2LhxIw0aNMDf3x8fHx9sbGzEyv+DBw+EgfTw4UM8PDyERG+LFi3w9PTE0dERc3NzkVT+9OlT8vLySElJwdDQkKSkJGJiYrCwsBCqdY8fPyY+Pp7y5cvLQsvOnDnD7t27xWr7hw8f+OWXX7Czs6Nnz57k5OQwYMAA1NTUcHR0JDQ0tFDI2Lewe/du/P39qV+/Pjt27BDbu3XrhomJCVOmTOHVq1fcvXsXBwcHmjRpwsWLF4ssOPlHSE9Pp0KFChw+fJjc3FzOnz9Pz549MTY2loUjde/enbZt25Kfny9WtaHAWLa2tmbatGkyIYc3b94QGBjIokWLuHDhAh06dKBChQqUK1eO+/fvi+Pu3btHjx490NHRoVmzZrRt25agoCAqV66Mra0tI0eOFLLQly9fxsnJCVdXVxFa1LdvX9q3b8/bt2/FNePi4ihZsiRWVlay7QCzZ8+mSpUq3L17l+3bt+Po6EitWrXE/hs3btClSxdsbGxkZAkQ7ZDm2uDBg/H09BRhTZLBvW/fPsqUKUOtWrWEgt/8+fPZv38/OTk5ZGdnM3nyZFxcXGQ1mcaPH4+Pj4+43pfS88oEvVu3bpQtW5a+ffvSoUMHihcvXshD+vDhQ3766SccHR1lamc5OTk4OTnx888/c+DAAYYPH05MTEwh74FElmrUqMHly5f5EllZWSQlJaGlpUX79u2Fwa/cZuV/e3h4MHDgQFasWIG9vX2hRYPZs2ejq6srwiOlwrNFqSFGR0fj5eUlExcAmDt3LklJSQwdOlQWzte6dWssLS2ZNWuWmBNfqm9aWlqipaUlK+wLBYqIsbGxdO7cWfTpw4cPhIeH06pVK6ZPn050dDR16tQhNDSUwMBA6tWrx9u3b/n8+TP5+fnExcVhYmLCli1bBFnav38/mpqatGzZUozdl99Z6Zv5+++/07NnT5ydnYVH++TJkzg4OAhStmHDBpydnVFXV8fHx0cs+ly+fBkzM7OvFo+W5lVISAgJCQmYm5vTqVMn8XwyMzOJjIws9D6o8L8JFVFSQQUVVPgCyj/eCxYsYODAgXTs2JGDBw/y+fNnHj9+TEJCAvr6+iKpPi4ujv79+wMFXoPOnTvTsGFDFi5cKIzcXr16UaJECRYvXszLly+Ji4uTGY5QYGCWL1+ecuXK0adPH/bt2wdAYmKikOyVIBllDRo0wNXVFTU1NZKTk9m9e7fwUkgrrVBg5FepUoWTJ08CBWE3pUqVYsmSJeKY58+fi7oqUFAY18LCAgcHB4yMjGjdujXXr18nMzOTX375BRsbG3r16sXnz58ZM2YMCoUCBwcHfH19CymLfRmCJ9UJgoLwverVq1OvXj2R8A0F6nkWFhZMnTqVzMxM5s6di4+PD61atZLVQ/leDBw4UPRNwu3bt2nTpg2RkZG8fPlSVhfpzJkzhcLTmjRpgru7O4MHD+bq1aucOnWK8PBwPD09haH3888/o1AoMDc3F3LbEh4/fszq1asJDg4mISGBpk2bUrp0aaZOnSpWsSVIZMnT05OkpCR0dHSEEa9MzBMTE9HW1mbixIkyAnnx4kVMTEw4d+4cOTk5bNu2DVtbW1E7CgrU6Lp27Yq9vb3wBoaHh5Oamipry6VLlyhevLhMTAMKwvTi4+OpVasWwcHBJCcnY2BgwOTJk0VOytu3b5kyZQqurq40a9aMp0+f4ubmhrq6Og0bNhTXKmqOSBgwYACBgYH4+flx/vx50tPT+eWXXxg6dKhQg3v8+DGdOnXC2NiYmJgYUlNTqVevHlZWVmzduhWFQkGtWrUoXbo0lStXZuvWrYWKlpYqVYrw8PAivaESWXJxcWHMmDHCw6UcSibNn8DAQIYOHcru3bspXbq0eO+kYy9evIiBgQEHDhxg8ODBQg3x9u3bRaohVq1aldKlS4u8nX79+gmRDl9fX1H0VUKbNm2wtrZm3LhxMgKtfH9LS0vc3d1lpQfy8vJo06YN4eHhsr7PmzcPPz8/ypcvz5AhQ8RiSN++fWXPcOXKlcybNw+FQiHGXRrLffv2oa2tTWJiomyhYdmyZQwaNIh+/fqJ78aLFy/o3r073t7ejBgxgsuXL6NQKFiwYAFdu3YVXttixYoRFxdHiRIlaN26NSNHjiQhIUF8j6V7v337Vha+uXTpUipXroyHh4esn3379sXa2lpWw0mF/12oiJIKKqigwleQkpJCxYoV6datG2FhYVhbW4sf34yMDNq0aYNCoRDx+9nZ2aSmplKhQgWGDh0q8gUSEhLIzc3lzZs39O/fn2LFiuHo6IidnR2HDx9m8+bNnD17VhCq69evy2op5efnU6dOHXr16gUUFNi8fPmyrBbI8ePHCxGHgIAAhg4dKv6ePn26KPK6evVqtLS0ZPVRJC/Sq1evyMvLE7kbkkele/fuaGlpcfDgQQDatWtHuXLl0NXVZfLkyXz+/FkUz3V1dZXl6Sgbo1/WNNq4cSM9e/bEwcGB4sWLExoaKvPWRUVFUb58ecaOHcvr169ZuHAhHh4eJCYmFkmWvuaVgAIvhqOjowinkrBs2TI0NTVlY3rlyhWRE6GhoSEjnV26dMHLywuFQoGLiwvVq1cnOztbhF6dOHGCLVu20KlTJ2xtbcVqv3Lb8vLyyMrKonHjxvTo0UPWVuV///rrr+jq6qKuri7ad+rUKRITE0U+DhQQZjs7O8aOHcvz58/JzMwkOTmZKlWqCLWurKwsQZZq1Kgh62uvXr3Q1tbG2toaW1vbIgtqLliwAHV1dVJSUjhz5gy3bt0iMjKSESNGcPXqVYoVKybCN6W+Koc7zZ8/X9QP8vLyEvkr9erVK/L5fTkWL1684N27dyQnJ2NoaIi/vz/u7u6oqamJkNXHjx/TuXNnypcvj5ubGwsXLuT27dt07txZ5IU9fPgQNzc36tSpU6iA7dOnT4XwxLJly+jTpw/Dhg0TtaiysrJo3749Xl5ejB07VpYjJGHixIkUK1aM9evX8+LFC8LDw2nWrJksH+7x48fY2dmxfPnyP1RDhILvkZGREU2bNmXdunVERUWJ5//ixQvmz59P6dKlZcqUDRo0oGHDhl/NE7x48SIuLi60aNGC8+fPk5eXx9u3b/Hz8yMsLIz09HTh2YICT9SXSo9hYWG0a9cOKCBvenp6zJ07V8i0V6hQQUaW9u/fj0KhEJ4siVgHBQXh6+srRCGgwLPUrVs3qlWrRlpaGnPmzKFEiRJoaWkJARLJK3/o0CESExPx8/MTkulSTtSGDRsIDQ3FxcWFKVOm8OjRIz5+/EhycjLW1tbEx8czaNAgmjVrJgs/VkEFFVFSQQUVVCgCmzdvxszMTCRxb9q0iRIlSog8IyiIXd+wYQNTp04lJyeH/fv3U7VqVbFyvGnTJkqVKsXChQvFOVIo1+rVq0lNTcXa2hoDAwOqV69OixYtZPk4b9++5eDBg0RGRuLo6ChC3Ozs7KhSpQpVq1aV5RdI52RkZBAaGoqzs7Ms/G/OnDm0bt2a7du3yxTXoEBwoE+fPrx69UoYVY0bNxYhTOvWrUNHR0ec8+nTJ+7cuYOtrS0WFhZi9VWZLE2aNEnWbyggW9I1pQKPxYsXZ8aMGezfv59ly5ZhZWVF3bp12bdvHx8/fqRNmzbo6upSqVIlIX38NbKkXFBWOeRNwo4dOzA1NWXatGmy/KNTp05hYWFBgwYNeP78OZ07d8bQ0JB3796RlZXFjBkzKF68uIwsvXz5kkOHDglCBXDr1i2ZhPCZM2do06YNtra2MgWvGTNmiBAiPz8/UYfmS4NW6kOvXr2wtLQECpQGXVxccHZ2plWrVrIwyYYNG1K2bFnMzc1p0KABbm5unD17lk+fPskUx3bt2oWNjY2MLD169IijR48yd+5cYfQXJZaxZs0aKlasiImJCcbGxri5ufHp0ydu3ryJlpYWP/30E1DgqVu7di01a9akS5cuwqh/8uQJ+/btIzc3l/z8/O8iS8p/b9q0iQoVKnDu3Dmys7PJz89n+PDhlChRQoRPPnjwgCZNmtCzZ09Onz5NeHg4Li4usrpid+7cwc3Njdq1axcKo5XG3MDAgJCQEPz9/WWexaysLNq1a4evry+DBg2S5VX17t2bsmXLYmFhgbq6OgsWLGDGjBkEBQURGhrKwoUL2b17NyEhIXh6enL//v3vUkOEgvfQx8eH+Ph4fHx8ZM/048ePTJo0CRsbG5mhr+whLQrnzp3D3t4eAwMDoqKiiI+Px8DAAHNzc+zs7HBxcSEgIEDWx9evX7Nv3z7Cw8PFt+nhw4dYWFjIPNQAkZGRGBgYsHXrVhFmefbsWeHhrFixImfPnhXtmzRpEsWLF2fmzJmEhoYyZMgQWrVqRbt27Rg1ahQKhQI1NTXxXVUugv3u3Tv27dtHiRIlKF++PF26dOH06dNoa2uTnJxMmzZtMDAwoE2bNty+fZt3796xdOlS4Q1t167dV8sMqPC/CRVRUkEFFVQoAnPnzhXqZunp6Whra4sV63fv3nHmzJlC3opVq1aJMI6iPDY7d+4Uq/QjR47EyMhI1Gbq1q0bpUuXJjo6WpClgwcPUrt2bcLDw8nOzmbIkCFUqFCBffv2cf/+fVHUVllCe86cOfj5+REcHEx2djZr164VoVrnzp1DTU0NhUIhI28fP34kNDSU9u3bC6MjOzubmjVrcuDAAY4dO4ampqZYjc/OzmbixIns3r2bhw8fYmdnh6enJ3fu3BF1oooiS1Cg7qWjoyM8OqmpqbKcGSggM+bm5oSGhnLw4EHu379P586dcXd3l9VqkciSchje+vXruXv3LtWrV6d27dqFhAGgoKCmvr4+P//8M0eOHOHWrVuEhIRgZWUlcoL09fW5du2aOEeZLH0Zeiahb9++mJmZUbVqVaKjo4Xxdv78edq2bYuFhQUjRowgIiICa2trcnJyyMnJITAwkPr164vrSAbjo0ePGDp0KHfu3OHUqVPY2NgQFBSEmpoae/fuZd26dXh6epKQkCAjS+3ataNYsWJMnz6dp0+fMnz4cCIjI6lQoQLJyckil2PHjh3Y29vLwvCUUVQNLAkPHz7k+PHjHDp0SPQzNTWV0qVL4+fnx6JFiwgJCSE4OJgGDRrg4eEhK+Cq7G3Kyclhz549f0iWJMybNw9vb2+ysrJkbUxNTaV8+fI8fPgQKAijy8vL4+bNm6Iw8Zdy8/fu3cPb2xsPDw/hKYUC5bWKFSuK8LL3798zb9481NXVGTVqFFAwJxo2bEibNm1EftWdO3eoXr06x44d4+XLl4wePZoSJUowbdo0FixYQJs2bdDQ0BB1e7Kzs3n9+jUWFhbfVENUzt1bs2YNjo6OqKuri9BfCWfOnEFHR0eE7Er4Vi0nKAjxNDc3JyAggPj4eAwNDTl58iTZ2dlMmjQJhUKBt7e3CJc7cuQIISEhxMfHi2d69+5dTExM2L59uxgfKFhUsbGxwcXFhVWrVsk8lQsXLhREW/lZDh8+XISSZmVlkZmZSV5eHnv27OHKlSuMGzeuyBpbymRLR0eHihUrMmzYMNl3Y/Xq1djZ2ZGYmCh7x79nnFT434OKKKmgggoqKEH6sZ44cSKNGjXi8OHDaGpqypTcli9fTt++fYV3Q/pxlcJhNm7ciKampiBWq1evZtOmTXTp0oUHDx5w8+ZNAgMDRWL2jh070NTUJDExEUdHR+Li4ti8eTPv378X4TAXLlygdu3aQm1ry5Yt6Orq0rBhQ9TU1ITxlp+fz5YtW8jNzSUtLY3KlSszZswYYeAsXryYkiVLMmzYMI4cOcKRI0eoU6cOLi4usmKPUFCTxMDAgNKlS8tWiV++fEnNmjWFN0siSx4eHsIDIuUsqampFSJLjRs3Fobf4MGD8ff3F0ng0ljOmzeP0qVLExwczN69e3nw4AGdOnXCx8fnq2RpwIABVKlShVGjRjFlyhRq1qwp84goG0GDBg3Cw8ODUqVK4eTkhLe3N9nZ2TRs2BCFQkH9+vVlQhtQYPjNnDmTkiVLkpKSIrveihUrMDIyYtmyZUyfPh0rKyvc3d1FHtGVK1dIS0vDycmJyMhIsrOzycrKIi8vj+3btxdJwNLS0nB3dxfehKSkJBQKBT4+PuKYpUuXysiS9OyaN2/O3bt36devHxUqVGDJkiVs2LABBwcHvLy8ePLkCdnZ2ULgwdHRkT+LK1euiJy9DRs24OTkhJmZmSyPZfz48dSpU0cYz69fv+bTp0+CyEpkSV9fX0aWivJozZo1izJlyog5LV3z3LlzGBsbC4+uhLy8PB48eEB0dDR+fn4sX75ctv/OnTvUqFFDFiq6ePFiXFxcCpHFCRMmoK+vL8K+pGcIBeFv169fp3fv3rLzxo8fT/HixZkwYQLv37/n6dOn7NixA4VCweHDh8nJyREqjspqiJ8+fSIiIoKQkJBC7di0aRNOTk7ExMTIvGRPnz6latWqbN68uYgnVRjz5s0TSovnz58XYcTS927Lli1oa2vTv39/rK2tqVatGm/fviUvL4+rV6/KVB8B3N3diYuLE9eX1D/Dw8MpVaoUkZGRAEJZcPny5WhoaIjcPIlEHTlyBGNjYxH2O3r0aLp16ybu9/nzZ0aMGCEjS/n5+WRnZ4ux+vnnnylevDiGhoaFBCtWr16Nra0t7du3l82Xr5FzFf53oSJKKqigwv80vrZqnpGRQZkyZVAoFDL1pE+fPomY/C9/VJ89e4a+vj4KhULUWtqzZ49Iam7WrJk4Z82aNTx8+JBjx45RqVIlobDUpk0bihUrRokSJZg5c6bIf3j69Cljx47l48eP7N+/n0qVKjFjxgyysrKoW7cuCoVClnwvGXRnzpwROUFS++fMmSMKR7q7uxMREUF2djanT5/mxIkTIpznxo0bBAUFYW1tzbt378jLy+PZs2eEhYVRrVo12dg9evQIGxubQmRp3LhxsjHMz8+XKeKtXLmS4sWLy1bMocAzJJEKyUNw9+5dOnbsiLe3dyGy5OPjQ8OGDalfvz7e3t6MHDmSiIgIHj169NWcpbt373L8+HGOHz9OVlYWOTk5jBgxgqFDh+Lp6Un79u2FESkZaFlZWYwZM4bq1auL665du5YlS5bIagldv35dFFt98eKF8DisXbuWBg0a4OfnR7t27YRHcdy4cZQoUYKoqCjatm1L06ZN0dHRESFUHz9+pFatWrRt2xZ7e3saN24s7rVs2TI8PT1FzpLU1t9++w0XFxdxjyNHjoiaRMrYsGEDTZs2/aYHSRlfFvo9d+4cycnJgjx8+vRJFn6Yk5NDWFiYkAffunUrNWvWxNvbGx8fH5FHAgjPkrI4ABTMBylU8cmTJ3h7e9O0aVOZoMW1a9eoWrXqV4sB3759m8jISIKCgmR1dqQ2KmPLli2ULl1aKOtJz/rMmTMYGBgUUnXs06cPXl5e6Ojo4OzsXMhTMWHCBEqUKEHv3r358OED79+/JyoqigEDBgAFIZvKaojt2rWjZs2aODo6kp2dzeHDh9m+fbssRHDt2rV4eHjg5+fHjBkzWLt2LVFRUTg4OHzXszxw4ADFixenW7duYmzPnTtH1apViY2NZfXq1ZiamgqvuCRQUqVKFfFdun79Og8fPhR/b9q0iapVq5KUlCTuk5ubS+3atWnUqBF5eXl07twZPz8/Pnz4wLNnzwgMDCQ+Pl685/369aNkyZKYm5tz+PBhPnz4wJgxY9DS0pJ947KysgRZmjNnjqzPGRkZDBo0CC0tLcqUKUN8fHwhcYa1a9diYGBAly5d/rCMgQr/u1ARJRVUUOF/El/Wx1mzZg1jxowhPT1dGHzz5s1DS0uL5ORkzp8/z5o1a2S5PwsXLiQtLY3Ro0eLGin79+9HX1+fpk2bsmnTJjZs2IC9vT3FihVjyJAhsiK1UOA1aNmypfihHjVqFKGhodja2uLo6MiiRYsE0ZGMkY4dO9KuXTuxGt+jRw8CAwOpUaOG8Mo0adJEeCiKylFISUlh3Lhx3L59m/z8fHr27EmVKlUoWbIkkZGRgths2rQJT09PypUrh4eHB56ennh6erJ69WpGjhzJpEmThCH+6NGjQp6lT58+sXz5crFSfOHCBXbu3Mnx48dFe9q2bYu2tjZbt24Vim29e/emf//+PHjwgA8fPohwxMePH5OUlCQjS0OHDqVbt264uLhw9uxZOnbsiJeXF6NGjSpSwlkajy/DbJT/njZtGm5ubrRv315m9EqFP6Xr3b9/n7Jly6JQKJgwYYLsejdu3MDJyQkvLy+ePn3Kpk2b0NDQoHfv3nTo0IG4uDhKlSolVPGOHDlCfHw8sbGxtG3bVsixS5Ce/7x587CxsaFJkyZiX926ddHX16dDhw58+vSJ/Px8cX8omN9f5r6sWrWKFy9efFVEoigoj+Nvv/0mCMaXdaWgIF9u7dq1IscuOztbeFsHDx7M5s2bCQkJwdTUVCaosG/fPooVK0aLFi2AgvA4hUJBu3btRI2hOXPmEBAQQFhYGKdOneLQoUNERkbi5+f3zfApiSzVqVOH+fPny45V7tvdu3epWbMmrVq1kuWs3L9/H1tbWxlhkbyJkydPpnv37pQpU4ZevXqJtkr3GDFiBH5+fuI+gwYNwtTUVLz7Dx8+FGqILVq0YMCAAeTk5JCSkoKZmRmGhoZCpU3ywKxbtw4HBwfU1dUJCwujd+/e4ll8D1lasmQJlStXpmvXrmKenzp1iho1ajBo0CBiY2PF92f+/Pm0bNmS9u3bk5ubS+/evbGzs0NXV5euXbuKd2P69OmYmpri5eUl3sXy5cvj5eWFp6cnenp6QiwDChY6goKCRKjvwoUL0dPTQ0NDQ3xHnj9/zvTp09HT0xOiNlAw737++WchkAMF+aUmJiYkJydz5swZZs6ciZGREX369ClUOHbDhg3Cu6WCCkVBRZRUUEGF/zkkJyfTqVMnkSeTnJyMrq4uTk5OIqlZyuOYN28ehoaGaGpqoqWlRVBQENnZ2fTq1QsdHR0CAwOF+pkUard3717s7OwwNzfHy8uL+vXrM2vWLNTU1Bg8eLDMOGvVqhXe3t7C4IyLi2Py5MkANGrUCHt7exYtWiSM5I8fP+Lj4yOKI378+JG4uDiZUMC7d+8wNzend+/eYptknH369InDhw/j5OREREQEW7duFe09cOAAu3btIjo6murVq7N48WKggFROmTKFCRMmsGLFCpKTk6lcuTJRUVHExcVRrlw54aV4+PAhDg4OeHt7F1rBXbFiBeXLl8fQ0BA7OzvatGkj9rVv3x51dXVcXFzw8PAQMsg1atTA29sbExMTJkyYQGZmJk+fPhVheN27d8fLy4uwsDBWrVoFFHgHvpcsQYFXa+jQoUycOFHmjZg+fTqenp60bNmSnTt3EhISIgtRk6538OBBPDw8ZIUwpX03btygYsWKJCQkUKdOHZkYxJMnT+jVqxdlypQRIUZfhjIVhXfv3jF//nxsbW1p0qQJb968oXbt2tjZ2fHLL7+Ie1++fBkTExNGjhxJuXLlmDp1qrjG8ePHiYmJEUVMvwc7duwQ6mZdunQhPDxc5q38EhkZGTRr1oz4+HhycnK4ffs2Pj4+TJw4ESgQXDA3N8fExAQdHR0RVpqfn8/BgwfJyMhgwIABDB48mMqVK1OiRAkaN27M77//Tn5+PitWrKB27doUL14cR0dHatSo8V0kQcojio6OFuF706ZNo2fPnvTt21fMl0WLFuHn50dkZCTr1q3jwIEDhIaG4u3tLZ7TgQMHSEpKYtGiReL606ZNw8TEhLS0NJlhfvXqVeGtlRY0HBwchJBHUZg5cyZ6enqcOHGCmzdvcuLECby8vLCxsRFjv3XrVkxNTRk3blyRBWiLgvK7sGTJEoyNjenatasgMJ8+faJTp06Ym5sDBcQ6NjZWFO1ds2YNlStXZtOmTYwZM4Zq1aoRFRUlpL3PnTtHkyZNaNKkCW3btiU7O5vw8HAUCgWNGzcu5I1fvXo1MTExlChRAicnJ3x9falevTpVqlQRIZEvXrxg6tSphchSVlYW/fr1w8nJCWtra4oXL16ohtKUKVMwNjamT58+shBLFVT4I6iIkgoqqPA/h+TkZNzd3enduzc7d+6kRo0anDhxgtzcXK5evUrXrl0pXry4SJR++fIlffr0wcfHh0aNGgkyIcW2Z2ZmMnr0aIoXLy4Mpnfv3nH//n1h1AGCLEnV7aEgx8TDwwMXFxe8vLyws7MTleDz8/Np2LChIEuSATdhwgTU1NRo0qQJnp6euLq6Fsov6tChA6GhobKwJihQm0pISGDnzp3Url2bBg0a0K1bN2EAQcGqe5MmTfD392fevHmy81evXo2xsbHIi5g7dy4lSpSQGYqPHj1CT0+P1q1bi/a8fPmS4OBgFi1aREZGBlOmTMHJyUkmYrB+/XomTZrEzz//zI4dO9DT06NHjx5cuHBBhPApq5p17twZR0dHWrVqRUREBKGhocK79S2ypGykpaamYmBgQN26dXFxcaFWrVqyPs+ZM4fAwEAsLCyEBDgUyGSnpqbSvXt3Vq1axcGDB7GxsSEsLIzRo0fTvHlzWVHg58+fY2pqKkiC8lhFRkaSkpJCbm5uIaL1Nbx//5758+fj4OBAZGQkL168oFGjRgQFBTFz5kxxfrdu3VAoFKKoMBSQ66ioKKKior47eT0rK4uxY8diZ2cnQsy+DC8rCk+ePBH3+PXXXxkyZAgfPnzg0aNHWFlZ0bZtW968eUP16tWxsLAQQgBQkJdSrlw5Dh06xLFjx1i1ahWlSpWiQYMGstC+CxcucPfu3e8imRLu3r0rvBXDhw9HS0uLhg0boquri7u7u5BhX716NQ0aNEBNTQ03NzexUAIFz9XS0hJNTc1Cz3Xq1KmYmJjQt29fbt26xbp16zAyMsLf359169YJj9CgQYOIiIgQ77wkMQ8FcyApKUmQU+UxdXBwIDY2VmyTVASl876FL2XboYAUSmRJ+mZcvHiRSpUqYWxsjIODAw4ODkLds0uXLrKCrLt27aJ27dpERkaKd1BCdnY2b9++ZeDAgfTo0YPq1avTqVMnWR0lCRkZGTx8+FCIcEhkSQrLk8iSvr5+oTpfkoCMRO4AmZjL1KlTqVKlisgVVUGF74GKKKmgggr/M1A2IIYOHYqvry8tW7YUOToSnj9/Ttu2bfH29pbVDJk/fz61a9cWq8rKUt5QUBCzYsWKMnLyZdibRJaGDBkC/F9oWo8ePUhJSRFGnrIRU79+fUGWPn36xPv375kyZQqxsbF06tSpyFX0lStXYm5uTkpKiggd+v3334mJiSEoKIi8vDzOnj1LUFAQmpqahQrfSmSpZs2aspCyESNGiMK3a9euRUtLSxhMb9++lRVDldpz/PhxGjZsSKNGjcSYffr0iaVLl+Lg4CBL/paQmppKgwYNRL+Cg4MJDg6WeTDu3r1L+/btOXr0KNu2bSMsLOy7yRL8n+EkEd7Zs2ejrq6Oh4eH8A5CQeL5r7/+Kp6lVPelR48e1K9fH2tra7p27cqhQ4cwMjLCxcUFdXV1IZMtoWHDhjRt2rTQvGnSpAkRERGFxuCP8P79e6ZOnYq3tzcPHz7kxIkT1KxZEx8fH5Ev9eTJE+rVq4eGhgZDhgwhLS2N4OBgHBwcigyX+xZycnKoU6cOCoVCiA7A94V4KcunQ4FQSN26dYWntGXLlhQvXhxTU1PxnOLi4ujSpYvsOocPH0ZDQ4OEhIQiQ6a+py9fHtO+fXsxZ96/fy9qnClLbN+8eVMY8PB/ZOzixYtYW1tTp04dEbIr3WP69OlC+h4K3peUlBR0dXWJiIhg/PjxnD17FnV1ddLT02Xfp7Vr15Kbm0vjxo3x8/MT26Wxnjp1Kq6urrIcLeX939N3Sapbwvz58wVZkp7TlStXGDRoEGPHjiUnJ4fLly9TtWpVNDU1GTlypOz83bt3ExwcTGxsrKgJVRSGDx+Or6+vjCzl5eVx+fLlQuIrt2/fxs/PrxBZmj59OgqFgqlTp4o+bdiwgSFDhuDn54erq6u4tnI/J06ciK2trRBIUUGFP4KKKKmgggr/U1A2FAYPHkylSpUwMDDg8ePHwP8Z0WvWrMHQ0JCbN2/KzpkzZw6enp6UKVNGECJlQmBoaCjCmSZPnkz79u1p0aIFa9euFSp5M2fOFGF4yveEgpXdnj17Mn78eFHgEgrIkp2dHUuWLOHTp09cvHhRrErn5+cXuYo+c+ZMXFxcsLKyEp4nZ2dnUXsmLy+PK1euUKtWLZycnFi3bp3s/Fu3bhEaGkpSUpJo47hx4+jRowfr168vVItp1apVDBw4UJb/9fnzZ0aNGkWVKlVEHSAJHz9+ZOnSpbi6uopCuBKaNGkiVPVcXV0JCQnh7du3QEHelLJss4RNmzYVSZakML3+/fsLo+nTp08kJyczduxYoMCbpaury6BBg4iMjMTKyqqQNw0KkvzNzc0FuVq1ahUaGhpCSe3w4cOYm5tjaWmJlpYWHTt2FOdOmDABR0dHJk2aJOYCIGrEFFXg9Y/w4cMHXr9+TY8ePYiJicHHxwcdHR2qVq0qyNLr168ZNGgQ1apVIzo6mh49eoj58j3eFyh4b16/fs3QoUNJSUnB1dVV1rcv2y7Nl9u3b5ORkSHmKhR4p0JCQmReri5durB//36ePn0q1Mv8/f1p27atuJ6Uy9OvXz8UCgVt27YtRDq/px8STp8+zYEDB2jXrp0Q7ZD64ujoiIODA6dPny5EPr4kWhcuXMDNzY127drJampBQb0sSRBCwrFjxxg/fjxGRkbUqVOHMmXKEBISQmZmJvn5+YwYMYJKlSpx/fp11q1bh729faG5mJ6ejpOT0w8Z/MrfmbFjxxIVFUX9+vUZNGiQaPOXZEk6R9kLlZ6eLmTlpTpzEvbs2YOLiwspKSlAQb7QuHHjSE9PF1667Oxshg8fjr+/P61btyYjI4Pg4GCio6PZtGkTCxYsYMuWLaJvDx48KESWfv/9d9asWVMkMTx06BAeHh64urrKFlaksEApD1IFFb4HKqKkggoq/M9B2ZAZM2YMJiYmJCUlyWLXpboiUoKy8jlLly7F3t6e8PBwmYF1+/ZtTE1N2b17N4MGDUJTU5MOHTqI0LqGDRuKH//Zs2dTsmRJkpOTxY9979690dLSIjg4GA8PD/T09Bg6dKi4foMGDXB0dKRDhw6ULl2an376SYT2fS3/5vjx4yxbtozU1FTmzJkjM5Clcy5evEhQUBDh4eFiJVi6xuPHj9m1axf37t0jPz+fVatWoampScmSJWUk6d27d4SGhtKjR49C4/37778zYcIEdHV1ZcY1FJCl2bNnU61aNVmCd79+/ahevTpeXl6Eh4fLiEX79u3p0aMHnz9/5vnz58J4goJV7dDQ0EJkqVGjRqLejYR79+7x8OFDMjIysLKyEsRs+/btaGtrY2FhwerVq2XtnTdvHoGBgUDhWlmSIuGePXsIDg5m8uTJKBQK0tLSxPldu3YVYVODBw+mdevWaGlpCU/cn8HixYspV64cZ8+e5eXLl0KZ0MvLi4ULF4o+fxnq9CPeB2V8+PCB8ePH4+DgQKdOnWT7zp49K667evVqLCws0NfXJzQ0VFbzpmnTppiYmLB48WLat29P+fLluX37tuxaM2fORFNTU4TAKtfIadSoESVLlhSqcd8D5Wffs2dPKlSoQIUKFVAoFMyYMUNGGrOzs3FxcaFixYrfVYD03LlzuLu7065dOyHCkZaWhrm5Ofr6+jRr1kzUGZPw6dMnJk6cSIMGDVBXV+f8+fOcOXOGpk2bCnGLx48f06RJE+rUqcPkyZPJzc3l4cOHhIeHExsb+91y1srHjRw5Ek1NTdLS0sQCjJubmyys1NTUlBYtWohv4uvXr2WkdPXq1bi5udGqVSuZ5y0/P5/Tp0+Tl5dHamoqlStXxtfXF39/fwIDA0W/srOzGTt2LJ6enhgZGeHr60tycjKampo4Ozujrq5OnTp1WLFiBVAgoiGFZ0rfIiggZklJScTExDBx4kSRF3n06FE8PT1xdnbm6tWr9OvXD3Nzc5GXqoIK3wsVUVJBBRX+5/ClB+aXX37B2dmZhg0bcvToUY4ePUpYWBienp4yY1H5nOXLl+Pv74+3tzebN29m06ZNRERE4OLiwo0bN4iKipIVsJwzZw41atQgMTFReEEmT54sZKZPnjxJRESEUM97/PgxEydOpESJEqJGEkDt2rWxtLREoVAQHh5O165dBflSNoa+RpxAbiBLx50/f56goCAiIiLYtGmT2N+7d2/MzMyYO3eu8Mb07dtX5AudO3eOixcvEhISIjO27t69S0ZGhpAdlqTCHRwc6Nq1q6wtnz594tSpUyQmJgrD6Pjx4/j4+GBsbCxySaAgJ8rQ0JD9+/czbNgwfHx8MDc3x8/PT3jgduzYQVhYGGFhYRw4cEDk/uTl5clqNUnjsHjxYjw8PIQhuHnzZmJiYhg3blyhsVu0aBHNmjVj27ZthTxq69ato0+fPsyfPx9LS0sSExOpUqUKCoVCiG9AgUhEYmIirq6u1K9fX6y0/1kMGTJEyLVLz/PJkydUq1YNCwsL5s2bV8ig/t48FihIhG/bti1NmjQR9Xk+fPjAhAkTcHZ2pnXr1rx48YI6deqIsMw7d+5gbW3NzJkzWbduHa1atcLDw0OEa2VmZorCu+7u7pw7d65QG+7fv0+rVq2wtrYWuUtv374lKiqKdevWMWPGDMqVK1eIgPxRf/bt24e3tzfbt2/nzJkzVK9eHU9PTzZt2iR7N7Kzs0lISPhu2fRz584J8ZbZs2djaWnJypUrWbFiBZUqVaJGjRqFvEtSu+Li4vDw8MDHxwcnJyeZCMSNGzdo06YNZmZm6OjoCNn5Hw2dhAIvWtOmTWXe6hMnTuDk5CQL8Zs+fTqxsbHk5eUxcuRIAgMDcXZ2pnbt2oIIrlixolDBZwkTJ07E1NRUeHFGjRpFyZIlsbe3FyqPubm53Lhxg0OHDnH+/HkcHR05dOiQCPGrV68eNWvWFIs3t27dws7Ojvj4eKDAC6yhoUGjRo1o0qQJ5cqVIyYmRhTbPXHiBH5+flSsWBELC4sfEi5RQQUJKqKkggoq/E9B2fty6NAhEToyYsQIKlSogJaWFtHR0UKpCZAZoHv27GH9+vVAgdFsa2tL2bJlCQ8Pp0+fPkycOJFKlSrh6uoqy1XKzs4Wq/DKanD5+fksWrSIiIgIqlevLlv1f//+PcOHD8fe3l62qn3s2DHKly9PVFQUtWvXpnv37kWSpS/xyy+/FKqho3zO+fPnCQ4OxsvLiyNHjjB69GgqVqzIsWPHCoWrJCUlYWJigqamJt7e3gQFBYnQqLVr12JlZYWzszP6+vokJSVx+fJl3r17x5gxY3B0dKRHjx4ydTYdHR26du3K4cOHRZumTp2Kp6cn7u7u9OrVi1atWqGpqcnKlSsZPHgwBgYGpKen8/TpU6ytrXF2dhYG5vbt26lZsyYeHh7iGY8dO5aEhATi4+NlnsClS5diZWXFxo0beffuHdHR0fTt27fIpPfffvuNkiVLolAoZGP58eNHQkNDqVevHrq6ukydOpXs7GweP37MrFmzKF26NB06dJCN4YcPH/5S/RapfaNHj8bd3V3k+0jzdv/+/ZQtWxYHBwdR3Ph7oGx49+7dm3LlytGwYUPCw8NRU1OjV69evHjxgvfv3zN9+nQsLCwwNjbG09OT7Oxszp07R0pKCp07dxbXunfvHj169MDV1VWEO0IBGSoqqV/CuXPnaN++vVC2Mzc3x97entzcXNasWYONjc0PhVKtXbuWVq1aidAwKCBfUl2njRs3FkmMvtf7dvLkSVHPSvJQQgFxNTY2JjAwUCb7Lp0n5ZoFBARQqlQpUYdNQmZmJvfu3WPhwoXs2LFDtOd7QyehIFzP3d0dS0tLWT5Vbm4uu3fvxtbWtlBuUf/+/TEwMGD+/PlcvHgRIyMjvLy8hJjG8uXLqVSpEqGhocIjnJmZSePGjcUiwubNm9HW1iY1NZWwsLBC8uo///wziYmJNGvWTDb3rly5QlBQkKzG18OHD8nNzeXJkyc4OzvLilmfO3eOgIAAYmNjhZf5w4cPHD16VJZrqoIKPwIVUVJBBRX+pyD9EK9btw41NTVZBftx48ZRsWJFZs+eLZPZVT6nZMmSsnCsZcuW4eDgwNChQ8nPz+fVq1fY29ujUChYvXq1jLi8ffuW0qVLs3DhQlmbJGNTU1OzULHMw4cPo6ury4kTJ8jLyxOkrUePHowYMYJhw4bh4eFB9+7dRWK3dE9lo2PRokVUqlRJhBJ+CemcU6dO0aVLFz5+/CgU3JShbDBevXqVo0ePyoQO9uzZg5aWlpCilpKulyxZAsCrV68YP348lSpVIi0tjTdv3lCzZk2Zl0lCXl4e27dvp3379tSoUYPOnTuzZ88enjx5go+Pj8ip2rt3r0xUAv6vOGbTpk3Jy8tj6NCh6Ovr07ZtW6HaJpGHjIwMQkNDMTY2xtTUVORxKY+LMlavXk3p0qVJTU1l//797Nu3jzp16uDs7MyhQ4cwMzOTecE+fvwoxkE5L+fvwrVr1yhZsmQhmekdO3YQGxtLv379fsjrIOH+/ft07txZNielMD8p5O2XX34hLi6OHTt2kJWVxZs3b2jcuDHly5cnJCREdr27d+/SvXt3PD09ZTLpRUF53KWQxvHjxzN37lxBDrp160bNmjW/myh9/PiR8PBwSpcuTWhoqGzf27dvCQoKws/Pj5UrV/7QeH3pfevYsSOOjo4kJyfLjnv69CkmJibUqFGjkAetV69emJmZcfjwYWrWrEnNmjVlnt2i5uH3erok3Lhxg8jISEqUKMGwYcNk+168eIGJiYlMQv7evXu4u7sL79OuXbvQ1tZm5syZ4pjHjx+jrq6OkZGRLA/t119/5datW1y+fBkzMzNR8mD69Omoqamhr68vlDOHDRuGQqHAxsZGhMZJ/V2/fj0KhYKePXvKFOyePn1K1apVxbdYGotz586hpaXFnDlzfmhsVFDha1ARJRVUUOH/S3zL0NmzZw8KhUL84Es/snl5ecyZM6fIAq379+9HoVAIY1z5+hs3biQvL0/k/bx58wYrKytcXFxk4R5Pnz7FxsZGeKSUsXr1amxsbGjYsKEsQfrBgweYmJgIsQAJ48ePx8PDg6ysLMaPH4+np6eMLCm378iRI/To0UOs8H7N66S8/fnz51SoUEF4TZSv9/HjRx4+fCiT2JVC21JSUmjVqhVQEH5lZWUlCzuD/6vLdOvWLZ48eYKVlZVMSKKoMDHl+9+6dQtra2tyc3PZvn27LATu/fv3zJo1i+fPnxMTE0OlSpU4deoUSUlJIqwRoF27dpQtW1bUn7px4wbbtm1j8eLFf7han5uby/LlyzE2NsbY2BgPDw+io6PJzs7m5s2blCpVijVr1sjOuXPnDoaGhigUiiLzuP4MlMdp5cqVaGho0K1bN06cOEFGRgYREREyz8kfGf/K11u2bBklSpTAwsJC5n2AgjBSdXV1Lly4wJIlS4TnVCLyZ86coVmzZlSsWLGQB/PevXu0bduWwMBAXr58yYkTJ9iyZQsXL14spOBWVLugIBcwKSkJHR2dQm1TRlH9ffHiBa1atcLS0pKpU6fKyMbbt29xdHQsJMf9LXyZ+6OhoUGzZs3Q1dXFysqKHTt2yI5/9OgRxYsXJykpCShYfBk9ejRBQUEif+fMmTPUrFmT8PBw2ULO9+YjfQsPHjwQoh/Kz6Z+/fpUrlxZpvZ46dIlqlSpAhTUalJ+z96+fSuOvX79OhYWFgQFBRXy3EydOpXatWsLb+fKlSupW7cuEydOlI39tGnTUCgUjBw5UuZllRZBnJycmDRpkiBL9+/fx9jYWBC7rKwscb3w8HAhAqKCCn8VKqKkggoq/H8HZQNp7dq1DBs2jNmzZwvScuLEiUJJ+sqqXUuXLqVbt24MHDhQFJ598uRJIYJTlBqWZFxnZmZibm6OlZUVgwcPZvny5URHR4uwoaLaumjRIlGrZdmyZWzduhU3NzcUCgVmZmYsX75c5hEKCgoSOR+S3HnPnj1lq7KXL1+mVKlSFC9enJ9//lmc+z1GV1RUFDExMUJIQWr3sWPHCA8Px9fXV5aHBdCiRQumTZtGdnY2lSpVokOHDuJe6enpwvCT+n3jxg3MzMyEd0d5bK5cuUJ6err4W2pHfn4+Hh4eNGrUCG1tbZlIwPXr16levTrbtm3j8+fPREREUK5cOezs7Dhz5oysre3bt6ds2bKF1P6+bMfX8OzZM65fv87du3dlggmNGzcmMjJShBFCgWHZokULGbH4K5DuJ0kiv337lo0bN2JkZISJiQkmJia4u7t/0zP2LVy8eJHY2Fg0NDREnomUo/b69WuqVKki8smggIzHxsYKlbGLFy/SpEkTAgIChDdRasf9+/d5+vQpvXv3xtzcXMhxx8bGFvKofol3794xb9486tat+83cLuX36vLly1y5ckWEvGVmZtK0aVP8/PyYMWNGoUWAP+N9O336NImJieJ9ePbsGW5ubgQHBwsClJaWRtu2bXn69Cm5ubl069YNPT09rKyssLS0pEKFCsLLcurUKWrVqkVUVFShb9VfxZ07d4iMjMTa2prExETGjh2LsbExCoVC9o3LysrCz8+PTp06oaWlJXvPfv31V3x9fUUI3fXr1zE1NSUoKEgmmDBp0iSMjY05c+YM2dnZxMTEMGDAAC5cuMCpU6dk79moUaNQU1Ojf//+HD58mIyMDJEr2rZtW/z8/Bg3bpyoOTV06FDU1dUL1W0KDg7+IZEPFVT4FlRESQUVVPj/CsoGYUpKCsbGxgQHB1OjRg18fHxkMfhFGUSpqakYGxvToEEDGjVqROXKlWXSvN9jRCmTJTs7OxQKBS1atCAlJaXIvJcvFfUsLCwoUaIEUVFRuLq6YmxsjKWlJQEBAURFRZGQkMC9e/cYMWKELO9l+PDhWFhYyOL2oSB8xcDAgJCQkELqaspJ419i8uTJuLu7079/f7Ei/P79e6KiovD398fa2pro6GgOHTokzhkyZAjGxsYYGRnRtWtXWcJ5s2bNSE5OLpSXExAQgJeXlzCAJEycOJFGjRrx4sULxo8fT5cuXUTS+Pjx4zE0NBS1lqDAyI2MjCQkJESM78ePH2nRogUKhUKEMinPkY4dO6JQKAoRvj+CdI3du3eTmppKUlKSyNE4cOAANWrUIDQ0lKVLl/Lrr7+SkpKCnZ3dV70mf3SforatXr0adXV1WT7L06dPOXv2LIcOHfpTeSyzZ88WXqjTp08TFBRExYoVhSJdXl4ez549w8TERGbAL1++HFtbWxo0aCDESs6ePUvTpk3x9/dn2bJlsvtMmzYNQ0NDQSZTU1PR0tJi9+7df9jGd+/eCan4oqA8Zv3798fOzg47OzsRMpidnc2rV69o3Lgx/v7+zJo165uCJ38EKffH3t5eiJdAwbslkaXt27fTrVs3fH19SUlJ4cSJEwQEBHDmzBnevHnDrVu3aNKkCTo6OmKOnz59Gicnp0IhfH8H7t69S2xsLGpqaoSFhTF27FiSkpIoXbo0GzZsIDc3l8+fP9O9e3d0dXVp06aNOPfTp09EREQQGRlJXl6eeG+LIksnT54kNDSU8uXLY2tri729PcnJyRgbG1OmTBmCg4NlxXKlorEKhYIOHToQFhZGdnY2d+/epW7dunh6ejJp0iSysrL4+PEjrVu3pnjx4owaNYrZs2eTnJyMtra2LAdRBRX+ClRESQUVVPj/ElOmTKFKlSpiNXzy5Mmoq6tjaWnJ0qVLxXFf1kgyMzMTq9oLFy6kePHilCpViokTJwIFycFFqcZ9Cck4ffv2LSYmJlSpUoXmzZt/1VBWbsfKlStxcXGha9eu7Nu3j65du4risqdPnyYwMJD4+HhcXV1RKBQifCwvL48FCxYUaeSlp6dTqVIlfvrpJ+HRmDx5MpqamrLcgi/Rt29fPD09sba2JjY2Fjc3NxwdHcnOzubGjRs4OjpSt25doTT16NEjwsLCMDQ0FLWpsrKy6NOnD5UqVSqyGO+1a9ewsLDAx8eHAwcOcPDgQSZPnoyGhgYbN24kNTWVChUqsGzZMmGw379/n/bt22NhYUFcXBxJSUkEBATg5ORUSA0sKyuLqKgoDAwMRP0jZYwaNeqHyISE7du3o66uTnR0NFWqVKFChQqsXLkSKBAKadmyJaVKlcLS0pJKlSoVqez2LSjPiffv38tCEK9fv46enh7Tpk0r8ngJP2LwZ2Vl0alTJ2rVqiW2SWRJX1+fKVOmMG/ePGrXri1CH1etWsWQIUPIy8tj4cKFeHt7ExcXJyNLCQkJODg4sHLlSvG+tGjRgkGDBgEFXjHl3JdPnz79MKEsCiNHjqR8+fKCyP/000+oq6uL0NaXL1/StGlTrK2tf0js4ktIuT9aWlqFFinu3buHvb09Li4uHDlyhEGDBlGjRg3i4uIIDw+X5d18/PiRmJgYXFxchGcuIyPjh3ORvhf3798nMjKSunXrsmzZMiE7bmhoKDzpN2/eJCIiAjc3NxITE+nfvz81atQQ79nYsWMZPny4eF4SWapZs6bYdvLkSRYtWsSkSZPYt28fjo6ObN++nePHj+Pp6Um1atVkioNSPt+UKVPIz89nxYoVhIWFERQURLly5TAwMGDy5MlkZ2eLOm3W1ta4uLgQEBAgkytXQYW/ChVRUkEFFf6/w4cPH2jTpg0TJkwACgqR6ujo0L9/f+rVq0eVKlUKhVt9/vyZtLQ0oVS1efNmdHR0GDVqFD169KBEiRK0a9eOqKgoFi9eLAvV+5qXKScnh4ULF2JhYYGuri7m5uYi/EsyzL8m4z1v3jxRl2Xnzp389NNP+Pr6CmPy6NGj9OnTB1NTU5mYAhSs7g8fPpzhw4dz9epVcY+lS5dibGxM586dGTp0KKVKlZKFtilD+Xp79uxhwIABdOrUSZZD8OTJE6ZMmYK2tjaRkZGCYG7ZsoVq1apRvnx5wsPDqV27NgYGBoIoFEUub926ha+vL2ZmZhgZGeHo6Mjq1avZtWsXZmZmIiRJGffu3WP58uXUqVOHhIQE+vXrR05ODqtWrWL06NEsXbpU5LDk5+cLI1AiS1+243vIknROZmYmXbt2lYUjJSQkYGRkJPOe3L9/n8uXLwuVsO+F8viPHz+e2NhYAgICGDp0qCC2X0oy/x3IyMgoJDhy9uxZQkJCKFasGA0aNKBixYrUqFGDSZMmoaamJgrbZmVlsWDBgkJk6eTJk7Rr104m412/fn22bt3KwYMH0dTUFPM6JyeHWbNmsX79+j8VAichNzeX+Ph44W1bs2YN5cqVE3k1Uhjhs2fPGDhw4F8mI/fv3yc6OprAwEBZPuHQoUOJiIigZcuW5OXl8f79e/r164eVlZXI/4H/m3vr1q3D3NycW7duFerPP4Fbt24RGRmJqakplpaWhIWFoa+vj5aWliCP169fZ9y4cVSrVo369evLChZ3796dsmXLMnHiRF68eCGONzU1pUaNGoUK4l6+fJnevXuLvzMzMwkMDMTX11dGln755RfU1NREbbn58+dz//59MjMziYuLw83NjcmTJwui+ezZMz5+/PhNT6MKKvwZqIiSCiqo8P8l7t+/z82bN4W3QvIILV++HHV1dTQ1NcWqqYSnT59y48YN7ty5g42NjSBNu3fvpnjx4hQrVgw7OzvMzMxo1KgRffv25ePHj4Wq10tYtmwZpUqVYvXq1bx48QIdHR1q167NkCFDWLBggTDWvkaWlixZgoWFBV26dOHu3bt07twZDw8PmeywVPtHOk/yvjRo0ABra2uCgoJYsGCBjCzp6+tTrFixQmIWX+JbhuqqVavQ1tame/fuREdHU7ZsWYKCgkQO1YMHDxg5ciSdO3dm4sSJHD58WBQO/RYuX77M1atXRaHLWbNm4ezsLJOQ/rJdyuPXu3dvypYti5+fH3p6evj4+Ijxys/PJzIyEhMTkyKJ1/fi5MmTmJiY4O3tXahPCQkJGBoasnz58m/KXn8vevfuTfny5Zk4cSL9+vXD09OTqKgoIX/8TxjQ3bp1o1GjRmRmZoptJ0+eJC4uDjMzM65cuYKurq4IeVKGMllq0KCBGANlzwlA586d0dbWpkyZMjIP74sXLwgKCmLMmDF/uv35+fm8fv0aExMTDh06xOHDh2VCBJ8/fyYlJUUmmgJ/fSxv375NZGQkQUFBLF++nHnz5rFp0yZBKm7fvk1ubi7v379n6NChGBkZ0aFDB0EooaB+WOXKlb8pUvF3Y/z48RQvXpyAgADu3bvH7du3admypQjDk/C18MRBgwahq6vL+PHjZWTJwsICR0dHXr58yahRo4iJicHGxkbU2pKQmZlJjRo18Pf3Z9WqVeI+48aNo1ixYlSoUEHmYXz37h0xMTEYGBgwZcoUERasggr/BFRESQUVVPivhrIXoCiPwPz58/Hz8xMrjVu2bKFu3brMnDlTGC1fYuPGjbi5uYkf/RMnTtC8eXPi4uJo3749Hz9+FNd1dXWlf//+hXJ/bt26hYeHB5MnTxbtevPmDSEhISgUCpydnVm+fPkfkqUVK1aIcLMnT57QuXNnvL29hTCDVEwVChSmTE1NhdcqPT0dhUKBr68vc+bMIT8/n1mzZqFQKChdujQLFiz4U0UrHz16hKWlpYywSQpZNWvWFJ4l6ZoXL17E3NycpKSkQsZpUX1WHo9Jkybh4OAgDG5lUrp69WpZONvFixfx9vYW4ZY3btyge/fuuLm5yYzkatWqER0d/d39LQq1a9cWyolfGtiJiYloaGiwatWqv6RUtnLlSmxtbQX53Lp1KxoaGtjY2FCrVi2hMPajBr7yWP/yyy/06dNHJhKybt06ypUrVyiE6fTp0wQHB2NpaUmZMmUoU6YMUVFRhcQpsrKyhCc1ISGB/Px8Dh8+zLFjx0QOz/v370WIZmZmJm/evOHJkyeEhYXh6+v7Q6GQX5u73bp1IyAggNKlSwuvFxR4H2rWrCkWCv4ONTkJt2/fJioqCh0dHWxsbETb1qxZQ+XKlYX4wfv37xkwYAAeHh40btyYjIwMkc9TrVq1v+RN+1GMHTuWatWqySTtP3/+TMOGDdHT0yuk3Hf16lXx3ZIwYMAAtLS0GDduHC9evCA/P5+rV68SHx/P5MmTKVOmDL169cLGxgYTE5NCIhqvX7/G3t6edu3ayWrdtWnTBhMTE5FLKXmzHz9+TLly5bC2tpZJmqugwt8NFVFSQQUV/iuRkZEhM6YmTJhAmzZtaNGiBTdu3BAEYOHChRgaGrJ79252795NWFgYqamp5OfnM2rUKKKjowkPD2fv3r2CTG3fvh0NDQ1WrlzJy5cviYiIoHXr1rx48QJjY2OZitf48eNRKBSULVuWHj16iJC+06dPy/JScnNzmTBhAqampty5c4d69erh6urKkiVLChkd8HXj78mTJ3Tp0oWKFSuSmJgorv3hwwcGDBggciTWrl2Lrq4uv/zyC7Vq1cLKyopmzZqhoaHBkiVLaNu2LdWqVWPq1KliHL/XOHvx4gVWVlYimV86/+LFi5QuXZq6deuyc+dOoEBhy8DAgNTU1D/lYbl48SIKhUKm2AcFq8qxsbGCAP3888/Ur1+fuLg42Xjevn2bFi1aEBkZKbZnZWX9LYZo7dq1MTIyYu/evYXISseOHYW4w5/Fli1b6N69O1AQPirlJEm1jCIiIr4pxvFH2Lp1K4sXL8bCwgIvLy9iYmK4cuUK+fn5dOjQgaioKGGYSobr5s2b8fHxwdnZmUePHqGvr09oaGghspSXl8fatWu5ffu2SN7X1NSkVq1aIvztxIkTuLm5CVVCLy8vvL29ZYWe/wjKz/HOnTvcvHlT/L1y5UpsbGyoU6eO8I69evWK8PBwAgIC/rFwtrVr11K6dGlatGgBFISIHjlyhLi4ONzd3YVK27t37xg8eDB6enqUK1eOuLg4Wrdu/acWL/4Kxo4dS7ly5cR7LP1/48aNQljh8OHD5Ofns3nzZhQKBStWrCjkJUxLS6N06dJMnjxZiDkcOHCAnj17smXLFqBgsahBgwYEBATI6tVBQT6n9Eyk7b///jvly5endevWsnv99ttvhISEkJiYKLzPKqjwT0BFlFRQQYX/OvTq1QsdHR2OHz8OFBjJWlpatGvXDjMzM6pUqcL69evJzs4mIyOD2NhYSpcuTfHixTExMSE7O5vJkyejo6PDgAEDhFjB+PHjefXqFe/fv6d9+/aoq6tjYWGBs7OzMLIHDx4sq9Hh6upKfHw8S5cuFcUsU1NTSU9PR11dXUhaQ4EEubJwQnh4OObm5jLj7ntw+vRpDAwMKFOmjCBiOTk5XL16ladPn5KRkYGNjY3I0Tpy5AhlypShWLFiQkHr5cuXNGvWjGrVqjFt2jRZLak/wvPnzzEzMxPkJScnh5ycHO7evUvNmjVFodePHz8yefJk6tSp89Wcrm3btn2VQEnHTZ48mRIlStCrVy/27t3L4cOHCQkJwdnZWRh1M2fORKFQULFixUKKVzt37kShUBSSk/6evkoG28mTJ5kwYQJjx46V1UiqWbMmJiYmRZKlH8HXvBpPnz7lzZs3+Pn5ifF+9+4dDg4OVKxYUdTj+R4o93fw4MEoFArevXvHw4cP2bFjBwEBAbi6ulKrVi0SEhKoXr26yCvKyclh/fr1eHl5kZaWJsby1q1b6OnpERERwbVr18jLy2PIkCEMHz4cKAglc3Z25sSJE+zdu5cOHTrg6uoqQmEB5s6dy9y5c1m/fv2fUuqDAiPd3NwcfX19mjVrJt6zMWPG4ObmhqWlJcHBwXh5eclk0/8JsnThwgUUCgVLly6lU6dOODg4kJeXx+HDh2nQoAEuLi6CLH348IFhw4Zhbm7OuHHjZIWu/258ra937tzBw8OD1q1by97F48eP07lzZ8aNGydrT0JCAjo6OqSnp8vI0oMHD9DR0UGhULBy5Up27tyJg4MDJiYmMo/ls2fPaNCgAdWrV2fu3LkyD9Lhw4cZNmwY8+fP58qVK0BB4eSyZcvSqlUrfv31Vx48eMCAAQOIi4v7W8JbVVDhW1ARJRVUUOG/El5eXtjY2HD48GFatmwpKyYaExODubm5qAly/fp11q9fj7u7O05OTixfvpy2bduK+iZQoIjl6OjIuHHj+PTpE2/fvuXQoUOsW7dOZrzt379fyBp7e3sTEBAgVk9///13jhw5Qk5ODjt27EBNTa3I8CvJSFu7di21atUS6nA/gqNHj1K/fn0MDQ1FqJ103fT0dNzc3ISxuHnzZkJDQ2nfvn2hWk9FkaVvhSJJ+6ZNm4aamppQ3Nu5cyc1a9akVatWLFq0SCSj9+vXDw8Pj0Krz/B/3rhp06YVGQIpIS8vj1WrVmFsbEylSpWwt7eXkS+p3StXrkShUNC9e3cZIb106RI2NjbfrLvzLaxduxZ9fX2ioqKoV68eZcqUIS0tTeyvVasW5ubm7Nix408Z3soE5unTp4VUCK9cuYKRkREHDhwACgzbRo0asXbt2j/ldbh69So///yz8PopY+vWrSLPS6FQCGK9YcMGof74ZVHRGzduYGBggJubGxEREWhqanL69GlWr15NQkKCbKzu3r1Ljx49cHFx+Woe0o+O4caNG7G0tGTlypWsWLGCSpUq4e/vL+bgkSNHGD16NH379mXOnDl/mox9D5TfD3V19UJFcYsiS2/fvmXmzJlFFrr+OyCFGELRY5uTk8OkSZOoXr069erV49q1a5w/f57w8HCRT7RmzRqZSEmrVq0oW7Ys6enpYhEpIyODPn36CC/148eP6dq1K3p6enTr1k12z99//53GjRtjY2MjZPvXr19PmTJl8PDwwMrKCg8PDyHbv3v3bgwNDTE1NcXU1JSKFSt+NYxXBRX+TqiIkgoqqPBfBWXjxs3NjSpVquDm5iaKSUqIiYkRhUyVjfDY2Fjs7e2pWrWq8EhJ6Ny5M46OjrKk5I0bN8rqfAB06tQJhUIhk8AtKtHZ09MTJyenIj1G79+/JzIykvbt2/+QYaTcjsuXLxMXF4ehoaHMaJg/fz729vZs3bqVFy9eEB0dzcCBA2XXkK7z+vVrQZamT59Obm4uY8aMkdWbKgqZmZn07NkThULBgAEDSEtLo0GDBujp6YmcKiiQaDY2NhbiA4DwUAwYMIAmTZqgrq7O1KlTv0mWoIBE/Pbbb/z222/k5eVx9OhRdu3axcuXL8X4z5s3D4VCQWJiIps3b+bMmTOEh4fj5ub2p0jFb7/9hrGxsciDuHr1KqVKleKnn36SPQtXV1ccHBz+UmJ5nz59cHJywsjIiAEDBoi59fDhQ7y9vWnevDn79u0jNDSUqKgo0Z8f6dfWrVtRKBQYGhqK+Z+fn1/IgP7111/p378/1apV49ixY3h5eTF58mSgIH/lxYsXrF69WigINmzYEBcXFzp37sylS5d4/Pgx0dHR6Onp0aRJE9m1JbLk6en5pwqDftnfo0ePyvLlnjx5grGxMX5+fl8Nf/ynwu4kSPWA1NTUCilLSmTJ3d29UP7P392uvXv3olAo6NixY5H3kL49WVlZzJs3j+rVq6Ompoa5uTkeHh5kZ2dz4cIF7OzsqFOnDtu3bxfnJiYmoqury5AhQ1i7di1RUVGyumY5OTn8/vvv9OjRAw8PD+FllPDs2TMGDBhAbm4uv//+O6mpqSKX7ODBgzRt2hRzc3OxQPDixQv27NnD9u3bVeF2KvzLoCJKKqigwn8dlMO4atWqhUKhkHl+JMTFxVG6dGkOHDggO6d58+aoqakxZsyYQkVOpfyf5cuXc/r0aaysrIiPjy+U7G5iYiJEC5TJ28aNG4US2sGDBzE2NsbNzY1jx47J6gbVqVMHJyenImXCfwSXLl0iPj5eRpbu3LkjpLaNjY1xdXUV/S9KNOL169c0b96c6tWrM3r0aOrVq0epUqX+UKXuzZs3zJ49Gzs7O1xcXHBzc2P79u1ERUWJekJ5eXnY2NjIPG9QULPKyMiIU6dOMWjQIIoXL/5NsvTl+PTq1QsjIyNKlSpFYGAgCxcuFH2cP3++yK1ITEykSZMmP5yHJWHv3r34+/sDBQa+iYkJnTp1Evslb560/89ixYoVVKlShblz5zJ69GhKly5N06ZNefDgAVDgoXB3d6dy5crUqFHju/NYvtx/8+ZNkpKSKFmypPAQfO0aly9fpmLFiqSnp+Pq6sqMGTP49OkT/fv3x9/fH0NDQ0qUKMGGDRvYsGEDnz59Ijc3V7Tt/PnzNG3aFBMTE5ncOBTk7bRu3ZpWrVr90NxXPnbKlCl06tQJR0dHevXqJTvu6dOnmJiYUKNGjX9JXR2pXXl5eWRlZbF582auXLkiZK6/7P/hw4epXbs2LVu2lJ3/dyMzM5MFCxZgaGgoCxkuquC11IZjx45x4cIFcnNz6dOnDy1btsTR0RENDQ0CAgKEBwgKQh7t7OwwNzenRo0a7N69m6VLl3LgwAHhKZc8S97e3owYMaJQG8+dO4ebmxu+vr4yyfuzZ8/SpEkTzM3NRZ02FVT4V0NFlFRQQYX/CnzLIPT09KRq1aoyMiKdk5aWVuQqbXx8PPb29ixbtqyQ8tz48eMZMGAASUlJWFpaoq6uTkxMjCy8z9fXl7p168rup0ysJONs27Zt2NjYULp0aRwdHXF2dsbV1ZWAgIA/nScxZswYGjZsKP6WyJKBgQGnTp0CCoz2jRs3snLlym+GGimTpYiICDp06EB+fj5t27ZFS0ur0Iq3BOU2v3z5kvfv3/P8+XNu3rxJUFAQwcHBQtji0qVL2NnZYWpqSlhYGA0aNKBs2bKyejN/RJaUDclz587h4eHBsWPHuHz5MnXr1sXPz48pU6aIMZXC8IYNGya8g39mtX7//v34+flx/PhxTE1Nad++vbjOyZMnadu27Z8SbfhyPm/btk0IU0CB0EGpUqVo2LChaP/Lly+5evWqOPePQseU77Fx40YOHTpEfn4+t2/fFsp80vP9mqHu7+/PsGHDaNGiBS4uLmhqahIbG8uUKVN4+vQpYWFhMrIzZ84catWqJZ7hhQsXaNq0KdWrV5eJoEABmfmRcDPlY0aOHImGhgbNmjVDV1cXKyurQnP12bNnFC9e/IfyuP4MlMf5S6GQvLw8BgwYUCRZunjx4j8q2KC8CLNkyRLKly9PSkqK2P9H78O0adPQ1tbm+PHjPHz4kMOHD+Pu7k5YWJgQZ8jPz+fOnTvcvXuXlJQULCwssLS0xM/Pj5iYGPFuPH78mG7duuHn5ycLxYQCL2ft2rUpW7as+H5JOHfuHAkJCWhra/8lSX8VVPizUBElFVRQ4T8eysbE+vXrGTduHBs2bJCFm7m6umJtbc2xY8dkycFQUI8oNTWVKVOmsHv3brE9JiYGR0dHGVmCAgU9LS0t9u3bx/Xr11m+fDn29vY0aNBA/Fhv3LiR8uXLc+jQIaDA0JeIVYkSJYiOjhbehrdv3zJ06FA6d+5Mr169SE9P/0t5EuvXr0dDQ4N27dqJbcqeJWXvl4RvGUXS+L5//15muCYmJn6TLL1//17kWVy8eJGQkBCysrI4evQocXFx1KhRg82bN4vrDRo0iI4dO5KWlibOU35OAwYMKJIsfWl4Xr9+XRA6kOdaTZ06VZClOXPmiNDALwtffi8uX76Ms7MzWlpaQmVQQo8ePYiIiJAJdnwPlPs8d+5c+vTpg6+vLyNHjpQdd/LkSUqXLk2TJk0Keav+yMBWvkdKSgqmpqbMnTtXhPPdunWLNm3aUK5cOfF88/LyxHlXr14lJSWFUqVKcfToUTIzM1m/fj3z58+XhRfGxcXJwufmz5+Pm5sb9evXF8/w7Nmzgiwp10z63r58idOnT5OYmCjyV549e4abmxvBwcGyvEMoULn7J8PslNs+evRoQkJC8PT0pH379ty4cUOM58CBAylRogSLFi365jX+Lig//8mTJ9O2bVsqVqyIQqGgS5cuYt+3xqZNmzbEx8fLth0/fhxzc3P8/f1ldejGjBmDsbGx+B727dsXDQ0N/P39RVj048ePadmypZAAV8a+ffvw9/fHycmpUC7hqVOnaNeunZCWV0GFfyVUREkFFVT4j4byD2pqaira2tq4urpiZmaGg4MDc+bMEfvd3d2xs7Nj//794ry0tDS0tbWpWbMmbm5u6OnpyYpk1q1bFxcXF+bMmSMMwPj4eNq0aSNrx/r16zEyMiI6Oprz58/z5MkTWrRoQU5OjiBWBw8eFMTKzs6O+vXri5o+ReFH5Y+VsX37djQ1NWWyuZcvX6Z+/fooFIpCcs3w7VV75fsoK+B9iywNGjRIiDGULFmSvn37in3KZEnyLH2pdrd06VJWrVolI0VfI0sAw4cPp3r16jg6OhIWFibbJ5Gl6tWrM3LkSEFAFy1ahEKhYPjw4d80SKWxuXjxIjt27CA9PV2EZUp5TwMHDuTs2bNcu3aN5ORkypUrV6h+1h9B+RkMHToUdXV1oqKiUCgU+Pj4iHBOCadOnUKhUDBo0KAfuo+EKVOmYGBgwPHjx4XUt4QbN27Qrl079PX1ZYVFpZo/kgfU1ta2kPDD8+fPad68OeXKleO3336jW7dujB49mpycHBYuXIi3tzdxcXEystS8eXNsbGy+Sry/B+np6bi7u2Nvby8znO/evSvIklSrSBn/dE5S3759KV++PIMHD2bEiBGYmpri4+MjQsYkNUCFQsG2bdv+sXZ8+Y4PHjyYcuXKsXbtWtavX0+3bt3Q09OjQ4cO4pgvx0b6+6effhLvmXIe29y5cylTpgx169Zl3759PHr0iNDQUOEh3rZtG1paWiQlJeHl5UVAQIDwLD1//py8vDzOnz/P1q1bmTt3rlCuO3z4MOHh4Xh7excquFuUGIwKKvwroCJKKqigwn8slL0tx44do1q1aiL87fz58/To0YNKlSqxePFicVzlypVp3LgxULAiHxYWJsjKw4cPGTNmDMWLFxfyxHv27MHMzIyEhASgwKBp1qyZSEBXNiKGDh1K2bJladKkCXfu3BHti4uL+yqxiomJKSQa8Wdw+PDhQtu2bdtG2bJlRe5BXl4e586do2/fvixfvpx+/foxatQoscoLXydLytu/PKZVq1aCLO3Zs0dWmDI2NhYNDQ0x5sqQyFJwcDCrVq0S29PS0jA0NMTX15cyZcrQpEkTWf8GDhxIyZIl+fnnn4Wnb86cOWhrazNs2DACAwMxMDCgf//+svtlZmYSHh5Ohw4dZM9t2bJlhcQ+isLq1aupWLEiNjY2lC9fHjMzMyFqMXbsWOzs7NDU1MTNzQ0nJ6e/lPty5swZmjdvLubzmTNnsLCwoHHjxoU8glevXv1hz6P0DOvXry8LtwL5nL5//z7x8fGEhoYCBe+Mrq4u06ZNAwoIuUQSJaxZs4YmTZqIYsZSUr/kCcjKymLBggWFyNKJEycYPHjwXyItN27cIDIyEi0tLVEzTMK9e/fw8vLCxcVFljv2T+P69etUrVpVhKNBQf6et7e3rNh1dnY28+bN+0fU9gDhLVRuQ61atWTj9PLlS6ZPn46mpiY9e/YECr4bRS0irF27Vkh9K2PJkiVERkbi6ekpvKz79+/n7t27nD59GhMTE1Erq3fv3igUCqysrIQK4Zo1azAwMKBWrVqYmJjg4+PDvHnzgAL1zIiICPz8/P4luWUqqPBHUBElFVRQ4T8OX8apz5gxgxYtWhAfHy8zMm7fvk3btm0JCwtjxYoVYntubi6LFi0iKiqKwMBA3r17J/a9ffuWQYMG4eDgwOXLl2nfvj1OTk4yL9OkSZNQV1eX5SQBTJ06FXd3dwwNDUlNTQUKyNy3iJWmpibNmzf/S1K2586dK2SsSkhPT0ehUMiM4dTUVCpXrkx4eDh169YVdaUkfEmEpL/37t1LUlIS9erVY8aMGbJV3BYtWlC2bFk0NDRkXo/AwEDMzc3R1NQUoTjK1z969CghISH4+/vz7Nkzxo4di4mJiXjGM2bMQKFQEBsbKyN03bp1IyAggPz8fLZt28aIESNEH968eUPPnj3x9fUt5Gl59+7dd+fwKOPs2bPo6emxaNEiHj16xNu3b4mPj8fU1FT06/r16xw7dowrV64UMkp/BEuWLMHf3x8vLy+ePXsmth85cgQLCwsaNWpUpKH/I/3Jy8vj8+fPODs7C7Ux5bn5+fNnMSefPHkiq0dVr149oIB4mJqaynJ8MjMzuX//PrNnz+bSpUtoamqioaEhS/CH/yNLPj4+1K9fX/YOftmWH8X9+/eJjo4mMDBQlucGiPyrfzL358trX7t2jUqVKok5Lb03L168QFdXV6gFKuPvJkudOnUq5GX99OkTNjY2dO3aVbZdWlBQKBQ0b95cbF+5ciXjx4+nd+/eItSzf//+lCxZkvnz53Pz5k1evnxJdHQ0s2fPFgVppXpHAMOGDaN+/fpiDGbOnElkZCRDhgwhNzeX06dPU6FCBaFul5GRgUKhYNy4ceIakoBK7dq1ycrK+seELlRQ4XugIkoqqKDCfxQGDRqEp6enTJ46NTUVhUJB5cqVC0ltp6eno6GhgampqVjFhIKY+SpVqqCtrV2IpOzfv59y5cpx5swZHj16RLdu3fDx8ZEpMjVu3Bg9PT127drFo0eP+PDhA5GRkdSuXZtKlSqhpqYmJK+/RayCg4NxcXERxOp7fvSVDTHJ4Jg2bRoaGhoMHjxYduzNmzcxNjZGoVAwYsQIZsyYgampqSAzUp5OmTJlZPkhX7Zj/fr16Orq0rhxY9LS0ihevDjJycncuXNHHNOmTRuKFSvG3r17efDgAR8/fhTXadOmDZqammJVPS8vj65du/L8+XN+++03zpw5w/Pnz2nXrp1Ial+zZg26urr07dsXIyMjgoODOXDggLhmfn4+J0+epEqVKujq6spU+F68eEFycjK+vr4MGTLkm2NYFL7s/7Jly3B2dubVq1eyc+vWrUvVqlX/1tCtAwcO4Ovri7a2tszTBgWeUysrK+rUqVOocO6fQYsWLbCxsRFERfIeXLt2jc6dO4sQzZycHPLy8pgwYQLNmzfn1q1bmJiYiNpbALt27WLw4MFkZWWRlZUl6rNZ9WQAAIg1SURBVCdpa2sTFRXFtWvXZPfOyspi4cKFmJqa0qdPH+DvU3e7ffs2kZGRBAUFFSJLEv7pcDtJGv3ly5fo6+vL5K+zs7PJzc3F39+/kCz2P4EHDx6I3DxlUtqnTx9CQkIKeSn79OlDnTp1qFevHnl5eSKPLTo6mtDQUEqWLMm6det49+4dw4YNo0yZMlSuXBlTU1Ps7e35/Pkz58+fp2rVqrL8uZSUFGxsbMQCQFxcnGwRatGiRdSpUwcoIJgWFhYyNT5JuGTfvn0yz7UKKvy7oCJKKqigwn8UTp8+TXBwMOHh4TIvyPjx49HV1SUtLU1WQ+PSpUtUqVKFuLg4/Pz8RL0bKFi5t7KyomnTprIE4bt372JhYSFyGZ48eULnzp3x8fHh559/BgqMvMTERMqWLUvVqlWxtLTE2tqae/fuUb9+fUqVKkW/fv3ENYsiVjExMaSnpzNt2jRKlCghqyX0NSgb6TNmzGDo0KE8f/6c/Px8Zs2aRfHixWVk6enTp/z0008cPnyYd+/e0aVLFzEGmzdvRltbmxEjRtCmTRtKly4tG1MJ58+fx8zMjFmzZgEFK9G6urpixVka79zcXJKSkrhy5QqVK1cmJCREZiRJZGn79u3s2bOHoKAgatSoIXK/Pnz4wN69e3n58iXnz5/H3NxchEDOnz8fDQ0NatWqJYjtjRs3yMrKYsyYMRgZGRWqx/Py5UuhtCWF7nwvJIN99+7d5OXlMX/+fAwMDMR+qc2PHz9GT0/vT+fVfI2wnTp1iurVqxMeHl7o2vv376dBgwY/5BX5koBI5x47dgx3d3dCQkJ48+YNubm5vH79mpo1a+Lt7U1eXh7r1q0jMTGR3Nxc0tPTMTc3x8DAQJbHAtChQwdatWrF+/fvOXHihCAiT58+RV9fn9DQUDIyMgq1Zc+ePf8Iabl9+zZRUVEEBwczd+7cv/3638Lp06dRKBTCCzp+/HhMTExkyoV5eXm4urrKajz901i0aBFaWlpCVn7//v04OjrSunVrsZDz7t076tatKxaWVqxYgZGRkQh127dvHwqFQvatOHHiBJs3b2bdunVC5j85ORlXV1dBbgC2bNmCv78/ZmZmuLq6YmtrK1PfGzlyJI0aNSI/P78QEV+/fr0sv1AFFf4ToCJKKqigwn8MlBPqa9WqRVhYGGvXrhX7hwwZgrGxMe3atWPPnj2cOXOG0NBQPDw8uHHjBm3atMHX11cW6jJz5kxcXV0JDg5m9erV7Nixg4iICJycnGTGm0SWvL29ZSugW7ZsYcmSJSxYsEAc36ZNGypWrIinp+cfEqucnBwOHjyIlZXVDymvpaSkYGBgwJw5c4RXJzs7m1mzZqGurk6rVq2YMmUKYWFhBAcHi7CfGzduiP+srKxEfsL69etFbSFltar8/Hx27Nghwvru379PlSpV6NmzJ7t27aJEiRJ07dpVJGNfunSJkydPcv78ebS0tGjcuLGMuLZv3x6FQkF0dDQKhYLly5ezdOlSQRIlgYRx48ZRu3ZtXr9+LZ5TbGwszZo1Iy8vj7Vr1xIYGEh2djavXr1i3Lhx2NnZ0blzZ9k4PX/+nClTpvwpQ/zAgQMoFAo2btzIs2fPqFSpkqxGUn5+vsg/+TN5ZsqEIT09nalTp7J582ZBwg4dOkRAQADR0dGFxBIkfIsstWzZkqCgoCLvJyEnJ4c1a9bg6+uLvr4+3t7eODs7o6mpSeXKlZk0aRIKhUIm3d2qVSsUCoUo5vvq1SvS0tKoUKECV69epW/fvnh5ebFw4UKRiH/r1i309PSIjIzkypUr5OfnExUVxZQpU8R1/ymy5OvrK1Ny+1fg/fv3REVFiffm1q1bpKWlUa5cOVq0aEHfvn2pVasWDg4O/1LDPyMjg2rVqmFhYSHI0qZNm/Dy8sLR0VHkcDk6Oop2jRo1ShSkTU9PR0tLSxC+zMxM0tPTBSHs1asXISEhJCQkoKenJ6t7JGHr1q388ssvDB48WNxDevZnz55FR0eHUqVK0a1bN9l5nTt3pn79+iKnSwUV/hOgIkoqqKDCfxQkY+/ChQtFkqXhw4dTunRpSpYsScOGDWnRooVQ87p+/XqRZGnOnDlUqVJF1ENKTk4W53yNLEkESBnXrl2jbdu26OnpsXfv3u8mVlKxRYkUfKvfUJBEbWxsXKRxnpeXx9atWzE0NERHR4fq1avTuXNnzM3NZSu7q1atwtfXV9zzwIEDNG/enIULF5KTkyO73++//87FixfJyckhNjaWxMREPn/+TE5ODo6OjhQrVoyOHTty+/ZtKlasKEQUTp48SalSpWRkqWnTpjRo0IDBgwezd+9erly5grOzMzVr1uTJkyeiD71798bX15ebN2/y+fNnYmJiRN4CFBh3JUuWFHLsL1++ZOzYsTg6On7VKP4RQ/zGjRvMmDFDeLQkEmpra0v79u359OkTjx49YvDgwZiZmfHo0aPvvvaXSEtLo3z58lhaWuLo6EjTpk3Fczl06BCBgYHExsbKwk2/B1u2bKFixYo0aNBAbCtKlCM/P5+nT58yefJkRo4cyaxZs8jNzcXMzIxSpUqJ+SsZtTk5OURGRmJoaIiJiQkBAQGYmppy7tw5+vXrR/ny5dm7d68gSdJ9pFA8yRC3t7eXFXr+p/D48eN/aU6ShEGDBmFqaiq+JU+ePGHVqlX4+fkRFRVF69at/3SttL/Srjt37uDn54epqakgSxcvXmTNmjV06dJFeG2WLFnCmzdvSEtLIy4ujl27dqGlpSULYR47diyWlpaULl2ahg0boqWlxfz582nevHkhZbqvtUe5758+fWLw4MEYGRmJ+9y/f58+ffqgp6f3XaIrKqjwr4SKKKmgggr/dnztB/bcuXNFkqXx48ejr6/P6NGjhQErGXkZGRlFkqVFixbh7OxM9+7dxY9xUUbckydP6NKlC35+fjK563fv3rFlyxaio6NFGN+PEKsva4NImD17dqFtw4YNIzg4uFD9IOX/T58+HT8/P2xtbdHT0xO5JpLRunr1akqWLMnu3bt58+YN0dHRdOzYUeyXwvmUxyAzMxMvLy+Ry/T582e6dOnCunXrOH78OOPGjeOnn36SjbcyWbpw4QKdOnVCR0dHhELl5eWxbNkyatWqRXBwMI8fPwYKRB60tbWxs7PD3NwcR0dHUaxTamPLli2JiIgQpELyLLm4uAiVwj+DGzdu4OjoSMWKFWXk7MWLF8ydO5fKlSujp6eHra0txsbGPyzEoVyLKjMzk5iYGC5dusSbN2+YPXs2vr6+REdHi34dPnwYOzs7kcf2vcjPz2fPnj2UL19eCDBI27+FnJwc3r17h6amJkZGRjg5ORWaP1AQujl79my2bNnCgwcPuHLlCvb29qJ+0cuXL7l06RKjR48WdbHu3r3LiBEjGDVqlIx4/SvwT5IlKFAffPnypex+Dg4OIv9Kwpfj/0/0X7mve/bsYeXKlWzfvl14rR88eFCILCm3a/To0RgYGPDrr79y+PBhPDw8KFGihAjbHTVqFHfu3CE6OpouXbpgbGyMhoYG8+fPJzc3V1Z37kchyeuXKlUKc3NzXF1dsbKy4ty5c3/6miqo8E9BRZRUUEGFfyuUf/AvX77MwYMHefLkiQjROnv2bCGyJFW7r1y5Mh07dmTu3LmcOXNGrHBfu3ZNkCXl0B9Jta5Tp05fJS5QQIASEhIKFUbMzs6WFduUjv1eYvUlpk6dKkLNlJGamkpgYGCh7bm5uaxbt06QwxYtWqBQKKhdu3YhY+jBgwc0b94cdXV1qlatiqOjoyBFGzduxNfXlxo1atC9e3eh4Hb37l3KlStHkyZNGDRoEP369cPCwoLbt28TGhqKubm58Obk5eWJ6508eRItLS3q1q3LyZMn6dOnD1paWoIE5ufnk56eTmBgILVr1xZheCdOnGD8+PFMmDCBnJwcPnz4IDMqFyxYgJOTE7dv3xbbMjMzGTx4MAkJCX/aML579y69evVCX19fhBwpj/GbN29IT09n9+7dP5xQrtym+/fvc/36derUqSPyOnJycli8eDG+vr7ExMQIsnThwoU/5XX4s2QJ4PXr12RlZeHu7o6Dg4MgS1Ifvqy7dO/ePSwtLVm2bBnnzp2jXbt22NnZYW9vj0KhEMWcle/9/0u+ybp16zAyMsLf35/169cL7+igQYOIiIgQ36vc3NxvSu3/3ejVqxcVK1bEycmJEiVKEBISIhRA79+/T/Xq1bGwsJCFx54+fZoWLVqwfft2oEBFsnPnzjg4ODB8+HB27NiBtbU1YWFhuLm58f79e3x8fKhZsyb6+vocOHCgyP4V1devvaMfP37k8uXLzJ49m927d39X/qYKKvw7oCJKKqigwr8Nyj+sffr0wdbWFm1tbapXr06/fv149eoVUECWateuTUREhCyXIjAwEIVCgba2Nv7+/jRv3lysqEpkyd/fn19++UWcM2/ePMzNzenRo0chQ1AZL1++LOTF+Rp+hFgpIzMzUxiSympvK1asQKFQsHnzZtnxr169Ij4+nmXLlvH582dmzpzJyJEjqV27NvHx8UIlTWrvgwcP2LVrF8uXLxdG+KlTpyhVqhSDBg2iTZs2BAQE4OfnJzw9M2bMoFixYpQsWRIdHR2xyjty5EgqV66Mm5ubqIeSn58v2n/06FFKlCjB+fPnefjwIb179/4qWQoODiYpKUm2Ej9//ny0tbWZPn26TB7e3d29UI2md+/eibH6HrJUlDH35MkT+vbti6GhYSG1sr8Dffv2pVKlSri4uFClShVZ3oVElvz9/fH395cV1v0jsqQcTqd8vT8iS9K/z58/z7Jlyzh27Ji474sXL3B3d5d5lkaOHEm7du1kHr6XL1/StGlT7OzsKFmyJD/99BPr16/n48eP+Pv7M2zYsD81Vv+J+FpdoZSUFHR1dYmIiGD8+PGcPXsWdXV10tPT/+VtXLRoEQYGBpw4cYLPnz9z+fJl6tWrR1BQkJBrv3XrFnZ2dmJeSAV7ra2tZWFuz549IykpCXt7ezQ0NETx3rVr1/L582cxL+vXr1+ILEFB+KM0T65fv8758+e/ucigkvxW4b8FKqKkggoq/NsxfPhwDA0N2b17Nzk5OTRp0gQjIyM6deokQl3OnTuHs7MzPXv2JCcnh5EjR4pjrl+/Tvfu3SlVqhTh4eFi9T4jI4P4+Hjat28vW9letGiRzEvxLXyv1+JHiFVKSoooggsFymvW1tb07t1bJrddpkwZFi9ezMWLF7ly5QqhoaG4u7vz5s0bWejL8uXLCQwMJD4+XibRLIVDSTh79iwLFiyQhQlu376dwMBAvL29BVlas2YNEREReHt7CyU8KPCA2dvb07lzZxlZkgincg7Ww4cPSUtLQ1NTU3aNlStXEhgYSLly5WRiGDdv3qR37954e3tjbW1N586duXLlCqtWrSIyMlIocimP7fcYW9IxBw4c4JdffqF58+bs3r2bV69e8ebNG/r164etra1MGv7PeKqUz9m0aRNGRkasWLGCgQMHYmFhgZeXl4yE5eTkMHPmTJnq14/c4/79+0JdUbrenj170NfXl5El5XPWr19P6dKlsbOzQ6FQ0K1bN+HtfPnyJV5eXujp6REeHk6pUqU4d+4c27dvZ8aMGSxfvpx79+7x+fNnDh48KJu/OTk5+Pj4MHPmzB8ctf9MKI/ZnTt3Csm0Hzt2jPHjx2NkZESdOnUoU6YMoaGhZGZm/qME4EuSnJycTEREhGzblStXqFGjhqw+0qNHjwTRkQr2KuemSfj48SPPnz9n7969ZGRkcOPGDRQKBS1bthRe7Ly8POrXr0+FChXYtWsXL168oH79+qLg9tq1a9HT08PCwgJNTU0WLVr0L8lTU0GFfwoqoqSCCir8W3H16lX8/PyE92T37t2ULVuW2NhYbGxs6NKli/AsZWRkkJeXx+3btwkMDBTytTt27EBTU5PWrVvj5OREVFSU8Czdu3fvTxUg/bP4I6P3/Pnz+Pn54eXlJYz/33//nR49euDn50e/fv2E0ZOamoqOjg7ly5fHwcFB1GQJCgrC0tKSevXqCe/L0qVLqVWrFpGRkezatYuQkBC8vLzEtR49eoS/vz9aWloMHTpU1t7t27cTEBBAtWrVhNz36dOnad26Nd7e3rL6S+PGjcPNzY2uXbty+/Ztmcfht99+4/jx47x8+ZLc3Fzev39PamoqWlpaMrK0YMECEhMT6datG97e3owcOVLsu3btGhs2bBACEBYWFmhra/8lI3zt2rXo6OjQvHlzGjduTKVKlUhMTOTjx488ePCAfv364eDgIEQq/goWLFjAnDlzhGpYbm4uu3fvxtXVlWrVqsm8mMreoz+aN8r7hw0bhrOzMzY2NtjZ2ck8A3v27KFChQpCXlw5FDM0NJRZs2bx8eNHli1bhrW1Na1btxbzEKB379707duXX3/9lZSUFMzMzKhevTphYWEYGBiwZ88ecezHjx/JyMggIiICNze3/2/C7CSkpaVhbm6Ovr4+zZs3586dOzIi9OnTJyZOnEiDBg1QV1cX4/hPe0skT03v3r2pWbOmeM7SHFmzZg3q6uqyGmjwf/PtwYMHREdHU61aNZYtWyb2Kz8/idxs3boVDQ0N2rVrJ8hSfn4+TZo0QU1NDQcHB2xtbcnOzub+/fvY2Ngwa9YsTp48yaBBg1BTU2PChAmy4tUqqPDfBBVRUkEFFf6tyM7OZuXKlbx69YrDhw9jYGAgjOrIyEj09fVp1KiRzFuRm5vLhg0bePjwIcePH6dSpUrCkJbkqT09PWUqcP90ovePYMeOHcTGxuLp6SkKQb548YJevXrh5eXFgAEDhLF17tw5jh49yrFjx+jXrx8GBgbMnDmTixcvoqenR2BgoCjuuHLlSsLCwqhcuTI1atSQreRmZWUxc+ZMnJ2d8fDwkHmk8vPz2blzJ05OTgQHB3Pu3DkSExMJCgpCXV0dW1tbFixYII4fO3YsXl5etG3bVniW+vbti729PQYGBnh7e5OUlMTz5895/vw5ffr0QVtbWzxXqW/Pnj0TioDK5A0K8ib27NlDhw4d0NbWxtLSUkiU/wgkeW9JXCInJ4cSJUrISNGTJ0/o3r07Xl5esjnzo3j+/DmWlpYoFAoGDRoktufk5LB7927c3Nzw9/f/S0Zj//79MTAwYNWqVVy5cgVvb2/MzMxEfhAUhE8qFAqRM3fo0CF69epF/fr1Zf1bvXo1tra2tG7dWiZYkZuby5IlSzA0NBTKi1OmTEGhUIj8l7y8PGbOnElkZCQBAQH/qLrbvwMbN27E0tKSlStXsmLFCipVqkSNGjW4cuWK7DhpLsfFxVG3bt1/hCyuWbNGCGj06tWLFi1aALBt2zYUCoVsIQNg586duLu7i+9CUfiyYK+yAMn8+fOZMmWKCBfdtWsXxYsXl5Glly9fsmrVKlasWEFubi579uxhypQpheT7x44di0KhUJElFf5roSJKKqigwr8d0g9ox44d6dixozA2kpOT8fHxITk5WfZDrow+ffqQkJAgVurHjBlDaGgovXv3/o8iRwkJCSQlJYm/d+zYQXR0dJFkydvbW+ZZgoJcAxcXF7Zt2wbAkSNHKFOmDHPmzJHd5/fff+fatWvCYFU23LKysli6dCkuLi7ExcXJcmMkUYCjR4+Kwr7Hjx9n9+7dBAUFUa1aNZlC3M8//4yTkxO//vorY8aMoWLFisLb0LRpU8qXLy/Csx4/fkxaWpqoWSTdDwrIUrdu3fDx8ZHlCilj69ateHp6ir5/a8X+y30XLlzA09MTKPBWmZiY0LZtW7H/8uXLQIHH7UfqXH0NFy5coEaNGtjY2MgU0iRjslKlSrRv3/5PXfvYsWP4+PiIQsmbNm1CV1cXV1dXdHR02LNnD7NnzyYiIoL9+/eLOTBhwgQUCgUVKlQoJCyyZs0anJycaNCgARcvXhTvTO/evYXC4bp169DU1BT5Zu/eveP58+c8ePCAdevWFTnX/tvw5bfi6NGjskKxT548wdjYmMDAQJkHTzpv6tSp1KlT52//5nz69InmzZujUCho1KgRZcuWlXkABwwYQMmSJZk+fTpXrlzh0aNHorbaH3m2pIK9tWvXFgsJKSkpVKpUiblz58oEILZv307x4sVp3749SUlJNG7cWLYQ07lzZxQKBa6uroXKIIwdOxYNDQ1+/vlnFVlS4b8OKqKkggoq/Megfv36xMbGCsOrQYMGLFmy5JuJ+23btsXDw0P8AMfHx4vaOF8751+N9+/fM3z4cPT09GTKeF8jSykpKVSrVo2uXbuKY69evYq9vT1QsNqtqakpwrvevn3L8uXLheEijde+ffvo168fSUlJLFu2jNzcXPLy8liyZAleXl6FyBLAkiVLsLW1lW0/f/48YWFh2NnZCY8CFJC3Dx8+EBERIdqyfft2WV5SVlaWkPOeMWOGzJguiiwp5woph6lFR0dTt27dIse3qGf8+PFjsrKy2L9/P9bW1ty5cwdzc3MhUAAFxnCbNm2EV+xH8OU9pb9zc3O5fPkyzs7OuLi4CCVGKCASp0+f/tNelwsXLgjjfffu3VSsWJFp06bx8eNHnJ2dsbCwYP78+aI/jx49EuO9YMECypcvT/fu3QuFZC1ZsgQfHx8eP34sPI19+vRh4MCBbNq0STbX8vPzWbp0qajFI+G/2ZOkTCimTJlCp06dcHR0pFevXrLjnj59iomJCTVr1ixUaLVXr16YmZnJnvff1a7c3FxMTU0pUaKEWKyQ3vWsrCxGjRqFlpYWRkZGWFtb4+npKfb/0fdPuWDvtGnTMDQ05OTJk7JjpDy47du3U7JkScLCwoSYg6T2BzB48GDU1NQKebgA8f1TXjxQQYX/BqiIkgoqqPAfgfz8fEaMGIGXlxfBwcFUq1YNOzs7YYB97Qd/xYoVeHl54eDggKenJ7a2tsKA+09SVnr16hWTJk2iXLly9O7dW2wviiw9f/6c9u3by1T0Xr58ibW1NV26dEFHR0eWs3P+/HkCAwM5evSo2LZ27VrKlClDeHg4derUQU1NjRYtWnDr1i3y8vJYuHAhfn5+1K5dW6bMt2XLFkxNTUUCu3T/o0ePUqZMGWxsbITRDAUGW61atbh8+TI7d+5EU1NTtO3z58+EhYVhYWEhjldWylO+vkSWfH19ZSqF0nNv06YNzZo1+2pi+J07d+jWrZvou5+fnxD1CAgIQKFQ0Lp1a9k5aWlpBAQE/LAnSXkuzp8/n+7du9OmTRvZ+F+5cgUnJydcXV1lincS/ohYfG2+S32qW7cuPXr0AAqM5ejoaMqXL09wcDBQkGNWo0YN5s2bJ86dMmUKxsbG9O7dW+Sibd++nVu3bvH27VvS0tKE13Pq1Kno6+tTtmxZ2fN+/fo1ISEhMsL/3wzlb8TIkSPR0NCgWbNm6OrqYmVlxY4dO2THP3v2jOLFi8u8w0+fPqVdu3acOXPmH2mjpDYYGhpK6dKlhUhLfn6+aP/ly5fZv38/O3fu/GEPn1Swt0WLFmJxJiMjgyVLlhAYGIiPj4/4Nq1du5aAgADy8vLYtWsXkZGRspDY7t27o6GhwapVq4rshwoq/LdBRZRUUEGF/xh8/PhRyBIrh+B9y6jMysoiPT2dtLQ00tLSvuucfxdevXrFxIkTKVeunEwaWyJLXl5enDhxAijI0fn8+bPMGJJyfSSFKSggI5GRkURGRgrjWqp3o2zgHjhwgEqVKtGqVSugYNymTZtGcHCwqMEEcObMGcqXL8+YMWNkhtaNGzfw9fWlSZMmhVacg4ODcXJyQkdHR2aYP3z4kCpVqmBrawsUGKKTJk0qNC7KZKlHjx5YWFiwaNEioIAw/Prrr+jp6X21IGVeXh6zZs3CysqK0NBQFAqFTEZ+y5YteHl5ERQUxK1bt9i/f78Qmbh06VKR1/wepKWlYWJiQuPGjUlISEBNTY3ly5eL/VeuXMHV1RUjI6NvysQX1R8JR44c4dixY9y8eVNse/HiBXZ2doKQZmVl0bBhQy5duiTG8tatW9SsWZM6deqwePFice7kyZMxNjamX79+XL16FScnJ6ysrGjVqhXa2tqy8WjZsiUaGhrs2rWLGzdukJGRQWhoKB4eHv/VYXZF4fTp0yQmJopcoGfPngmJbGUBCyh4j7/8vvyVAqzfwuzZs4mKiiIrK4tPnz7RsmVLGVmSoBwmB98vM6+M5ORk3NzcGDJkCNWrVyc6OppOnToRFRWFqalpIcJ/+fJlFAoFcXFxsvnZrVs3NDQ0WLNmzQ/2VgUV/vOgIkoqqKDCfwS+toL+LYPsz5zzr0RReVW///47EydORFdXV0aWpk+fTkxMjPDm/PLLL8THx+Pv78/UqVO5c+cOT58+pX79+lhYWNClSxf69u2LpaUlVapUkYXa3L59GwsLC5EjJBlN+/fvR01NTeSVZGdnc/nyZTZt2sTOnTvFuI0dOxY1NTXGjx8vFLbmzJlDXFwcd+7c4dKlS9y9e1cki1+5cgU7Ozvc3d2BAvKWmZlJeHg4NjY2+Pn54ePjQ5kyZWSkTBnSGD1+/JiJEycWMvS+ZzW6Q4cOKBQKatasKdv++fNn1qxZQ7Vq1dDS0sLOzo5q1arJcj1+FPPnz6dy5cpipX379u0oFApKlixZyNuXkJDw3cRdea4kJydjbGyMpqYmtWrVYvr06WJf3bp1MTY25ueff8bPzw83N7dC3tc7d+6IhH1lsjR16lRKlSrFkCFDyMnJoVy5cpQpU0YoT0rzIDs7m5iYGExMTNDS0sLHx4fq1av/fyfcINUWsre358aNG2L73bt3BVmS8sKU8U/3Py8vj6lTp+Lp6Sm8ns+ePaNVq1aULVuWnTt38v79e+rXry9EFL7Hi6783VQOsT106BBt27bF3NycUaNGifDC5cuXExoaWiTZv3LlClpaWkRHR8vIUs+ePVEoFGzYsOHPdV4FFf5DoCJKKqigwn89/pNC7CR8WYvl2rVrwsD8+PEjEyZMQEdHhz59+jB06FAUCgWDBw8mNTWVn3/+GR0dHQYMGEB8fDweHh4EBQVx/fp1njx5woQJE3B2dqZu3bqYm5uL5HLJwL127RqlSpUSRkp2drZoj4+Pj1Bku3jxIoaGhpiamlK5cmUCAwNFrteoUaPQ1tamQoUKWFtbo66uzqpVq0hNTRWSyU2aNGHXrl1AgTGlq6srZMz9/PxwdXUlOzsbLy8vNDQ0SEhI+GbuxJfbcnNziyyw+iVyc3PJzc1lyJAhtGzZEg8PD5nXTRlnz57lwYMHfykM6P3794waNUoIaWzatEkU1+3Xrx8aGhoyj5ZyO78GZSlvgOPHj+Ps7MyJEyfYu3cvHTp0wN3dXUipZ2ZmUr9+fQICAqhXr95Xx1VZ3UyZLM2aNYvffvuNx48fY2RkhI2NjazgrHJbjh07xpYtWzhz5sy/VGr/XwWptpCWllYhj+e9e/fw8vLCxcXlHwutk1DUHH/+/DkVK1Zk4MCBsm3SooCLiwvW1tbfXatI+R6jRo0iNjaW8PBwDh48KOan8ruRn59PWFgY9evXJz8/nytXrrBhwwY2btwoQu4uXbqEtrY2MTExMrLUp0+fQjWoVFDhvw0qoqSCCir87fiap+dbicVf2/fftmqtHCoH0K9fP2xsbDAwMMDExISJEyfy+++/k52dzYQJEyhXrhx9+/YlPDwcIyMjdu7cSUJCAlu3bhXX2LJlCzExMURGRoqV5S/zsA4ePMi6deuEAEKHDh2oUqVKoTC5atWqMW7cOHJycujQoQMDBgzg4cOHbN68GTc3N2xtbUUY0Zw5czAzM8POzo65c+dy+PBhqlSpwp49e5g+fTpxcXH4+PiIPI779+8L4jdnzhw+fvzIw4cPcXBwoEOHDvj5+dGzZ09hiP1VoY2iDMuPHz8yadIknJ2dC+Uk3b59+0+FSBV1nytXrnDnzh1u376NnZ2dEBA5duwYCoUChULBunXrvuv6XyqBrV69moSEBNLS0sS2u3fv0qNHD1xdXRk3bpzYLtUYg6+TF4ks1alTR1bPSlks4PPnz7i7u+Pg4CDIkgTlhH34zxBI+btx//59oqOjCQwMlIVPQsH4JSYm/tv6PW3aNHx9fQvJ42/ZsoXFixd/d06ScvvHjRuHtrY2/fv3x93dHSsrKyZMmEBmZiZQEPq7bds2goODcXZ2Jjs7mzVr1mBqaoqbmxs1atRAT09PhCVevXoVbW1t4uLiCs0fFVT4b4aKKKmgggp/K5R/jE+dOsX27ds5efKkCPEoSpwhLy9P/L13715WrFjBmjVrhIKUtO9rSmP/KXj48KHs79GjR1O+fHnWr1/PqVOnSElJwdbWlt69e/P69Wvevn0rpJtnzpxJnTp10NPTw8zMjEOHDsmutXr1aiwsLDh+/LgoLqmsclenTh1sbW35f+3deUCN2f8H8PdtkVASIWVf0mInsmRPJCV71uwyaIjsy2AsY9/3soeQbNmbwTDGMvZt7GRfKu3d+/790e8+366YxaDi8/qH7r3P7Tz33uq8n3PO54SGhlKtVvPq1ats3bo1ra2tuX79eu7evZvDhw9nnjx5ePjwYbq7u7Nz58461btOnz6tbGSqDRQ7d+6kq6srPT096efnx+nTpyuP//XXX9m+fXtWq1ZNKfv9vlEhrdGjRyvl3rVh6WNHA7XHHThwgAMGDODAgQOVzXejoqI4b948VqxYkT4+PkxMTOTYsWPp7OycrnTxP/0+ZGrhkHnz5uncf/jwYVaqVIm3b98mmTrVzs/Pj2vXrv1Hoy49evTg4MGDSaa+dpGRkXR3d6e5uTk7dOig81htWKpSpQrHjBnzwXa+z507d1irVi22aNGCUVFRDAkJ4bRp07hv3z7lvXjx4gUrV67M8uXL89KlS4yNjWW7du2UwJYZR24/pXf3Fnqfz33hZtKkSWzXrh03bdqk3Hbu3DkWKVJECd7va8O/adeVK1fYs2dPnbVX/fr1Y7ly5Thz5kxGRUXx2rVr9PX1ZefOnZmcnMzffvuNZmZmyrTS48ePU6VScdSoUcr3vnz5MlUqFTt06PCPR7iEyOwkKAkhPouAgADa2tqyaNGibNCgAZ2cnHSufmulnc4ydOhQli5dmuXLl2f9+vVZqFAhZY1MWocPH/6sbf8Y9vb2bN68OcnUTsvbt2/ZoEED/vjjjzqPmzlzJq2trbl9+3aSqWsONm7cqHSq27dvT5VKxVmzZqUbaShSpAgnTZqks2nokSNHeObMGcbGxtLFxYVVq1ZlWFgYydTNVgcOHMjcuXPT1taWlSpV4tmzZ7lv3z6WLFmSOXLkUBaBa0fCTp8+zSpVqtDa2lr5/gcOHGCTJk2YN29enY1aydSw1KFDBzo5Oel0LsPDw7l48WLu3Lkz3b4v1atXp7+//38OS7t27aKxsbFSYEBfX1/pYEZFRXHJkiUsVaoUixQp8t6yx38nbei7dOkSK1WqxKpVq+qUPw4LC6NKpWJ4eDhv3rzJ5s2bs23btsr9fxWWkpOTGRoaqnQqtf+eO3eO3t7etLa2ZlBQkM4x9+7dY/fu3dmtW7d/9bppNBrevXuX9+/f5/Dhw2liYsLKlSsrFdy0gfnly5esVq0azczMlND8LXV6tXsLNWrUSNlb6HN698LC7t272bhxY5YvX56VK1fmli1bmJCQwEmTJtHOzu5fB/13bdq0iYUKFWLJkiWVwjFavr6+LF++POfOncuEhAS+fPlSad/KlSvZrl07kqmBvXDhwjqV/x4/fkySvHr1Kq9du/af2ihEZiJBSQjxyc2bN48WFhZKMYExY8ZQpVJx7969Oo9bvHgxK1asyGvXrnHp0qW0sLBQRgUWLVpElUqlBAqt4OBgFi5c+L2LqzPKjBkzaG9vr3ytXfRcrVo1JSilDT0tW7aks7OzznMkJSUpnWp3d3fmzZuXYWFhym2vX7+mra0tZ82axWLFinHGjBkMDw+nSqXirl27SFIJZ1WqVGFYWJjSybl79y6fP3+uBNW4uDju3r2bRYoUSdcOjUbD/fv3097enj///DODgoIYExPD/fv3s1atWrSxseGxY8d0jjlx4gSbNGmibOTq7+/PggULsnz58ixSpAgdHBx0quGNHTuWTk5O7Nmz50fvOxMVFcVZs2YpU8lev37NgIAAGhoacv369cp5Xr16lRs2bEi3d9C/4e/vz1atWrFmzZo0NzenjY2Nzua7PXr0oEqlYokSJVihQoV/FCzeDTnLly9ngwYNlJHXP/74g97e3qxdu3a69U5Pnjz54AbM75N2tOHMmTNs0qQJT5w4QTJ1pLJs2bLs3r27TqCdPXu2zr5XX9OapL+Tdm+hzyltSFq6dCnXrFmjVLe7ceMGu3btSicnJxYvXpzdunVj6dKleeDAgXTH/lsdOnRgtmzZ+NNPP6WbVjlgwADmy5dPZ780jUbDn376iW5ubrx58yYLFy7M3r17K23Yu3cvAwIC3nshTIisToKSEOKT0Wg0TExMZNeuXZVF0Tt37mSuXLmUhe+xsbFKaDh+/DiLFi3K9evX08/PT9lsdPv27crieJKMiYlR/qBfvHiR9erV44IFC7706X3Q0qVLWbhwYb5+/Zpjx45VrrR27NiRNjY2yuO0HeiRI0fSw8ND5zne7fC6urrSxMSEPXv25KxZs9iiRQva2dnx8ePHnDNnDk1MTJg9e3Zu3bqV5P/KE2vDUtWqVRkaGqq8bs+ePeOVK1d4+vRppR3h4eEsVaoUGzdurHzfiIgI5s2blxcvXqSfnx/z5cunjOrt3buXLi4ubNasmRKCtS5dukS1Ws3g4GBaWFjw2LFjTElJ4blz5zh48GBaWVnpjMQMHjxYZ5+of+P8+fM0MjJihQoVlEpt2tc3ICCABgYGOh29/yIwMJBmZmY8c+YMX716xcePH9PFxYVOTk46oz2HDx/mkSNHPmq9CJlaRa9SpUps3bq1EpbOnDmjhKX3beL5d51lbaENrYULF7J9+/Zs27atTpjThqUePXq8t2BBVlsn+Clo9xb6EoYOHcr8+fNzyZIljIyM1Lnv2rVrXLRoEW1tbalSqejl5fWPn/ev2u/l5UV7e3tu2LAh3bq9mTNnMiUlhSdOnFA2ON6zZw8dHR1ZoEABpVCK9mf3u+++Y9euXRkTE/OP2yZEViFBSQjxn7zvj7G7uzuDgoK4a9cu5sqVS9nPJyUlRblyqu1ILlq0iGPGjGGHDh04bty4dMeo1WouWrSIs2bNUjp3wcHBSjncjKbRaHjq1Cm6ubmxdOnSzJkzp7KZ5507d1i2bFnWqVNHCYhqtZp169bVqcqm7XBs2rSJQ4YMUW5v1aqVsk/J9OnTldfs0KFDVKlUNDIy4uzZs5XHawPo27dv6eLiwpIlS3LXrl28cOECy5QpQ0dHR+bOnZvt2rVTRup27dpFGxsburq6kkzdk6dp06bMly8fTUxMePHiRZ3z3blzJ5s0acKmTZsqoxJpjRkzhk2aNNG57fbt2+zRowfd3Nx0rjr/k4p27/PkyRP6+PhQpVIpASJtNbaRI0dSpVIpIfK/GDVqFGvXrq2zju7hw4esXr06S5YsqROW0hZH+Cs///yzUh1s0KBBynsbFBRER0dHtmzZUicsderUiTY2Nuk2P/0r/v7+7NmzZ7oqZ0ZGRixZsmS6BfchISF0cHCgl5dXuqIB37LPHZbWrVtHS0tLnjlzRuf2dz9DkZGRXLduHcuUKZNuX6f3Sdvu48ePMzQ0lJcuXdL5+WvRogXLlSv33rCUnJzMrl27sm7duspt7dq1o6GhIbds2cI3b97w+fPnHD58OC0sLJTKm0J8bSQoCSE+ieDgYB47dowajYZ9+/ZlxYoVaWZmprP3y+PHj9mkSRPOmzePGo2Gq1evVqYVzZgxg5UrV6aJiQkXLlyoHPPixQs2bdqUkydPztSLyd3d3WlgYMCaNWvy0aNHJFNHOCIiIujg4EBLS0vWqlWLVapUoZ2dHZOSknQq5IWEhNDY2DhdsYDatWuzTZs2ytcpKSmMjIzk3r17OWfOHJqamuqsg9KGsdjYWLZu3ZpHjx5loUKFOGTIEKrVah45coSGhoYcPnw4ydRgtGfPHhYqVIj169cnmRoOVCoVCxYsqKw3SPva79y5k82aNWO1atXSBalZs2bRwcGBT5480bl9/fr1zJUrlxIitf7Je/q+x7x69YqdOnVijhw5ePz4cZ3HJSUlccKECbxy5crfPvfffc8ffviBVatWVTqS2rB++PBh5siRgw0bNmRwcPA/fs6oqCjmyJGDLi4u9PHxoZmZGc+fP08y9b0IDAxMF5ZOnjzJ8ePH/6uRnYcPHyptTbuJ7MqVK5k/f376+/uney/Wrl1Lb2/vTFck5Ws2evRoenp6Mjk5Od10ynffh8ePH7NChQp/O5qe9udl+PDhtLa2ZunSpVmoUCEOHjxYp4CLp6cnK1asyBUrVigVM7WuXr3KnDlz6qzV0haNMTc3p7OzM4sWLfrBjaCF+BpIUBJC/CcajYbPnj1j/vz5OWnSJJKpVz9LlixJGxsb3rlzhzExMXz8+DGbNm1KJycnpqSk8NWrV3R0dGT//v1Jpk4Nq169OgsXLswjR47w9evXvHXrFps2bcpq1aqlK4edWSQnJ/PNmzds06YNZ8yYwSZNmrBJkyZKwFCr1YyJieHUqVP5ww8/cPr06YyNjWVcXJxyTtevX2fp0qV1QmXaqVvaDnJkZKQSwsjU12zKlCk0NTXltGnTlHU4q1evVtZ6rVq1StmANTk5mc7OznRxcVGmyURFRVGtVnPnzp2MiIggST548IBnzpyhm5sbrayslOlYaTvqu3fv5sCBA9N15sLDw1mkSBEuXLhQKTVMplZArFChgs6Gnv+E9v0+ceIElyxZwh9++EFpZ0JCAr29vZkzZ850YelTuXDhAvX19Tl+/Hid28PDw9mqVSs2aNCAjRo1StfJ/CvR0dHMlSsXjYyMlMIbWtqwVL16dbZu3TrddKZ/Ow0uODiYlSpV0hn5mjdvHq2srDh8+PB0YUlLwtLnpf2cenp6slGjRsrtaUdGf/31V2U7AC1XV1dlau/ffdanTJnCQoUKKT8vgwYNYu7cudmtWzedcFO7dm126tRJ51htO/z8/NiqVSudCx8RERFcvnw5Dxw48MENpIX4WkhQEkJ8EgsXLqSVlZVytfLChQu0tLSkvb09ixUrpoymaK9yp6SkcNu2bTQ2NlaKAzx9+pTly5eng4MDc+fOTScnJzo5Oekckxm8uwA6reDgYDZs2DBdWNKaPn06vby8WKZMGS5atIg3b95kXFyczkJ6rbTHhYSEsHjx4ixVqhQrV67MS5cukUytUjZlyhTmyJGDFhYWbNy4MQ0NDZXpU4sXL2bXrl1JklWqVKGLiwujo6NJkkePHuWiRYuU1zc6OlqpXkWmdtobN26s875u376dEyZMYExMzAevfAcEBDBv3rz88ccfeezYMd66dYsuLi6sW7fuR3XAQ0JCmDt3brZv3541a9ZklSpV2LdvX5KpYbFTp040MzNTOoSfWmBgIA0NDTl06FCePn2at27dopubGydPnswrV65QpVIpi+w/JG0H+ObNmyxQoABNTU3ZvHnzdFXCEhMTGRQUxCJFinDEiBEkPz4A3rx5k02aNGGjRo10NpydN28era2tOXLkSN66deujnlv8cx96/zZu3EgLC4t0a+oePnxILy8vHjlyRLlt3759tLa2TjeKq5X2Z+vRo0f08PBQCpuEhYUxd+7c7Ny5M62trdmpUyed3zlqtZoRERFcu3atzvNs3bqVefPm5dGjR//tKQvxVZCgJIT4V95dpK4NL9evX6ezs7POtJDXr19z/fr1nD17NsPCwpTHatfSREVF0dPTk/7+/kr4iI6O5tGjR7l69WqlIMD7vm9GWbNmDceNG5eudHfaELdp0yY2bNiQTZs2VQKLWq3miBEjaGFhwRkzZnDy5MksXrw4u3TpojMVJm2HSvv/S5cu0dLSktOmTVOCWMGCBZVg8ObNG86YMYMmJibMnTs3x44dqzzH5s2bmSNHDpYtW5YeHh46ozwjR45k27Zt+fLlS/7www+sX78+8+bNyx49eihrf5KTk+ni4sL8+fOzffv2zJ49O/Pnz69Uq0vb3rQdrHHjxrFKlSrMnj07y5UrR0dHRyWQ/ZuwdOXKFRYpUkTZv+XKlSs0NjZWpg5qz9/d3Z1WVlZ/GWL/i5CQEObPn5/W1ta0srJipUqVGB8fz7t377J06dLK9Ln3SXu+J0+eVD4rT548Yd68edmkSRNev349XWf64MGDn+TiQNr9gdKGpfnz51NfX19ZDyg+j7Tv/4MHD3QqMN66dYvt27enk5MTV61axcTERF67do3u7u50dHTUef9fvHjxwRGctJ+dkydP8sWLFzx48CBfvXrFU6dO0dramvPnzydJDhkyhObm5mzZsqWytigxMZGDBg1SCkb89NNPyvP16tWLNWvWlGIN4pskQUkI8Y9s2bJFJ6wEBwcr07u0BgwYwGLFiikd4nnz5ulMSVq8eDH37t2rc9uUKVNoZWWVbopJWpllJGnp0qXvLXOulbazsnnzZrq4uLBatWq8f/8+t27dylKlSimv2cmTJ5WS0u3bt9cJS2mdPHmS27dv58iRI3Vud3d3Z4ECBfjzzz/rdLw9PDzYuHFjnXUFffr0oYGBgTJyFx8fzxUrVtDMzIzh4eEcO3Yszc3NuXjxYs6aNYtubm6sXLmyTqEIb29vVq9enUWKFGG1atU4bdo0ZWQq7Xmnfa/u3r3LEydO8MSJEzojKv/Gvn37WKlSJZKpHf6iRYuyd+/eyv3aq+KvXr3SmZb4OTx8+JAnTpzgL7/8opzP8OHDWbZsWZ2RuLTSdpJHjhzJatWqMSgoSAmat27dorm5Od3c3Hjp0iVqNBo2b95c6dSSn+bznzYspS03vmXLlkzz8/U1Svv+T5gwgQ4ODixWrBjt7OyUfYzOnz/P/v3709TUlPnz52eZMmVYo0YNnZH0vxpRTPs9Bg8ezKJFi/LRo0fKGrcRI0awdevWyu/dCRMm0MnJib6+vukuWly5coX9+vVj2bJlWbZsWa5atYpz585lixYtZFRJfJMkKAkh/tbEiRPZqVMn5Y/qjRs36OzsTD09PQYEBCgV1KKjo+no6MgJEyZwxYoV7Nixo9IJe/bsGT08PKhSqdi1a1edq9j16tWjj4/PFz+vf2PNmjU0NDTk7t27//JxaTs0QUFByjqeQ4cOKVdpw8LCaGZmxtWrV3PLli3Mli0bO3XqpKyz0UpOTmbVqlWVq7zvdmjd3d1pbW3N8PBwZZPbJUuWsESJEixfvrwyeqDdCNXAwID16tVjo0aNmDdvXgYHB/PevXusUqUKt23bpjzvn3/+yaFDh7Jq1ao8cuQIf/jhB4aHh/PJkydMSkpi3759WbVqVU6bNk3pjH1oZCmtj5l2t3//fjZr1ox37tyhtbU1e/furbwOx48f59ChQzNkncSlS5fYuXNn5s2b973TJt81atQo5suXj4cOHUo3GqedilehQgU6ODgoxT4+tbSbqWpH6LQkLH1eY8eOpaWlJYODgxkZGckqVarQ1taWO3bsIJk6nffGjRsMDg5mRETER42kv3z5kr169Uq3x9x3331HFxcXPnz4kGRqafBNmzZ9cOpsfHw8nz9/zh49etDFxYVWVlZUqVQcOHDgR5+/EFmVBCUhxN9KW3jgzJkzyh/YDRs2KGWoPT09efjwYfbo0YOdO3dmdHS08sf+4MGDytXMffv2sU+fPixQoACdnZ25evVqjh07lq1bt+a9e/cy5gT/RmBgIFUqlc5+Q3/VsXzffc+ePeOzZ8/48uVL1qpVi9OnTyeZ2kkpU6YM8+fPz4kTJ773uKZNm7JQoULK2oS0ocTZ2Zk2Njb8/fffaWpqyn79+rFjx44sXLgwy5cvz9WrVyuPdXV1ZfHixTl37lz+9ttvJFNHoQoVKqSzgSqZOtJRpkwZDh06lNWqVaOrq6uyXkIblrQjS+8LS5/KnTt3mCNHjvd21AYOHEgXF5cvvtFlcnIyz549yyFDhihrxf7KpUuXaGdnx59//plkaof2woULnD59uvKa3r17l5MnT+a0adM+6yavX2ozVfE/v/32Gx0dHZV1bOHh4cydOzcdHBxoZmbGHTt2KD9Daf1deE0bcFasWEFjY2NlA++0Vq5cyZIlS7JGjRp0cHBg2bJl/3FxnPPnz3PBggUsVarUB0e9hfiaSVASQvyltNPkdu3axeLFi3POnDnKGp2HDx/y5MmTdHR0ZJMmTVikSBECUEZejh8/zuLFi3PgwIGMjY0lmTrydO/ePbZq1Yqurq5KRzjtlKDMYtmyZdTT02PPnj1ZqFAhnc76+zoy2tdLo9Hw4cOH6TaQvHPnDkuVKqWMwj169Ijdu3fn+vXrleeLiopidHS0MrXt9evXyhVo7f43afcgunHjBps0aaKzN9PTp0/p5ubGSpUqce3atUxKSuKsWbNYtWpVduzYUekoRUZG0tHRkQEBAUxMTNTpOLm7u7Nnz57cs2cPmzVrxiZNmigd++Tk5C8WlkJDQ5kzZ04GBATwxo0bvHjxIv39/WlmZvbBhe1fwj8d9bl37x5LlizJ9evX8+zZs+zVqxdtbW1pZ2enUwgi7Wv3OdfkfcnNVAV5+fJlZQTv0KFDzJ8/v7KZdsWKFWlvb8/g4OB/9Z6n/awkJSXx0qVLbNSoEY2MjJQ9mdI+X1BQEMePH88RI0Yot/9VEHv35/jdNZlCfCskKAkh/pHLly8zISGBnTp1Yq1atThnzhydEJWSksLQ0FD269eP5cqVY3JyMo8fP06NRsOxY8eyVq1a9PPz01lsn5KSwvPnz3PMmDGsXbt2pinYoDV79myqVCru2bOHJLlkyRLmy5fvvWFpypQpOseOGjWKJUqUYJkyZdi6dWudwgwODg4cPHgwQ0JC2KxZMzZu3FjpuG7fvp1ubm4sU6YMO3TooKxV0ZZTt7W1VQpEpO3M1KtXj/7+/jptevz4MUuVKsXy5ctz8eLFTEhI4PLly1mnTh126NBBeb2XLFlClUrFhQsXKoHn7du3rFq1qlLyfc+ePXR1dc2QsJSSksLAwECamprS2tqatra2rFChQqbcv+V9AeTly5f09vamra0ts2XLxv79+3P79u2Mi4tjrVq13juS+CVIWPr0PvSaPn78mBqNhi1btuT3339PjUbDxMREenh4MHfu3MqGz//E4cOHlWIrvXv35oABA6hWq3n58mU6OjrSxsaGL1++JPnhMP9vf9dmtm0ZhPhSJCgJId5ry5YtSsfbz8+PtWrVIknGxMSwS5curFGjBufNm6fzh3jr1q309vamRqOhn58fS5Ysyfj4eMbFxXHcuHGsXr06v//++3S7wKeVmcJSRESETtneN2/ecOnSpenC0vnz56lSqejp6UkyteqdpaUl16xZw3nz5rF48eJ0cnJSpojNnTuX9vb2LFWqFJ2dnZXXMCwsjNmzZ+dPP/3EsLAw9u/fnyqVSinC8OLFCzo5ObFgwYL8888/SaZ2YBISEtiiRQu2a9eOZGpnTRuW/P39aWpqyvr16/P+/fsMDw/ngAEDmD17dnbv3l353lOmTKG+vj49PT3ZuXNn1q1bl/b29jpXksPCwt4blvr168fq1atz9OjRf/ne/lcPHjzg0aNHee7cOT5//vyzfZ+PlbaTvHfvXi5evJgbNmzgvXv3mJCQwJ9//pm//vqr8pjk5GRWr1493XohkTWlff9/+eUXnj59WrmoQab+/qhcuTJnzZqlPL5Tp068e/fuPwqtGo2G0dHRbNy4MevWrUt3d3eamprqbCh85coVVq5cmXZ2dsrvm8z0O1WIrEaCkhAiHbVarazLqVWrFk1MTHT+GKcNS/Pnz1c6x4cOHaK+vj4rVqxIU1NTnZLJacPS4MGDlWPSzpXPrFct07YrKioqXVjSaDQ8ePAgLS0t2bp1a65du1Zng8+rV6+ybNmyrFatmrKQ/86dO7x3757SQXrz5g1btWrFadOmkSSfP39OKysrfvfddzptefHiBRs0aKAEJa1ffvmFenp6/PHHH3VuHzVqFCdPnsxz587x+++/Z6VKlejj48NKlSoxf/787NChgxKWQkJCOGDAAHp5eXHIkCFMTk7mixcvdDYlPXDggLKpbtqw1L59e/bo0SPTvodf0tChQ1msWDHWrl2brq6uLFCgAA8ePKjcHxcXx+vXr7NZs2asVKmSdGS/MkOHDmX+/Plpbm7OBg0a6PwuaNasGYsVK8YxY8awVq1adHBwUC5q/NMRvpcvX9LGxoYqlYpTp05Nd/+VK1dYpUoVlitXji9evPg0JyXEN0qCkhBC0aZNG53NJ+vWrUuVSqWz9kXbqY6JiWHXrl2ZJ08e9unTR+nsubm5UaVS0cPDQzlG23mOi4vj+PHjWbNmTfbo0UNn6l5Wog1LFhYW9PPzU24/cuQIra2tqVKpOG/ePJ1jrl27RltbW9aoUSNd50WtVjM2Npbly5fnnj17GBkZSSsrK/bq1Ut5zKZNm5QCDB/qUC1btoz6+vrs1q0bf/rpJ/7444/Mli0bf//9dx48eJAWFhZKZT21Ws2ZM2eyQoUK9Pb2Vt7XtO/JxIkT6ejoyOLFi7NmzZrKFMTw8HC6urrS1dVV2cspJSVFade3HJbWrl3LggUL8sSJEyRT9ypSqVTKyKRareaSJUvo5ubGOnXqZLrNlMW/l/bzfv78eVaqVIlnzpzh7t276evry7JlyypTaNVqNVu0aMGGDRuyVatWH7W32OvXr9msWTM6OzuzcePGyjS8tG25evUqra2t2bFjx09xikJ8syQoCSFIpq5J6datm85Uqx9//JHjxo1jtmzZGBAQoNyufUxMTAxLlizJbt26KX+gAwMDuWTJEpqYmLBLly7KuhVtkIqLi2NAQAC7d++epTvU2rCkUqk4Z84ckqnneOTIEZYsWZKNGjVSHqs9z+vXrzNPnjw6+wBdv36dT58+ZXJyMtu1a8eJEyeyePHi7NWrl3Lc06dP6ePjw9WrV/9th+rQoUOsU6cOK1asyMqVK3PLli0kyY0bN9LS0lJnylp0dDRHjx5NY2Nj9urVSyckjR8/ngUKFGBwcDCfPHnCMmXKsHz58sro0t69e+nm5sYqVaooi8fJb2/dy7sllocPH87+/fuTJLdt28ZcuXIpC/djYmL4/PlzPnjwgNu2bct0mymLfy/t512tVvPUqVM6vw9v3LhBPz8/2tjYcOHChcpj027e+rHv/+PHj9msWTPWr19fJyyRqb+j79+/LwFciP9IgpIQIp358+frTJtbtWoVDQ0NdcKSWq3mhQsXlJGE6dOnc/v27UoH4dChQ8yVKxe7dOmiU8BBu8fHh/bwyCrUajVfv37N0NBQJiYm6nR2jhw5QgsLi/eOqt27d0/pvNy6dYs2Njb85ZdfSJIzZ86kSqVigwYNdALriBEjWLp0ad65c+cftS0mJoaJiYl88eKFMqXx119/ZdmyZblv3z6dx967d49WVlY0NTXl6NGjSaZ2wKpXr67srXTo0CGamJhw6dKlOsdu27aNgwcPzrLv4X+V9ry1U0lHjBjBsWPHMiwsjLly5VL2C9NoNFy3bh2nTp2q81mRjuzXYdKkSWzQoAGbNm3KFi1a6NynDUt2dnbK1Fqt/3qxSLuRcOPGjRkYGMiUlBTWrVtXZ4Nq+YwJ8fEkKAkhdP5YJyYm0s7OjkWKFOGVK1dIpl7xDAwMpJGREf38/Hj37l02a9aMLVq0UDqLzs7ONDU15Z49e5SRicOHD9PU1JTt2rXjsWPH6Obmxho1auiUts6K0rZ76tSpbNWqFatVq8Zly5bx6tWrJP8XlrQFHt6l7bzUqVNHZ/Rp1KhRNDQ05IABA+jn50cfHx+ampr+o01NSd3Ou0ajUTrlT58+ZZUqVdi8eXOdvX9u3LhBT09PBgcHK8fevn2bZcqUYUpKCvfu3avT4X/79i2XLl2qc0X83e/7Ldi7d68yTTUgIIC+vr4kyQULFjBv3rzMmTOnzqbKb968oYuLi04HVmRdaT/vM2fOZN68eenn50dXV1eqVCqlYIPWzZs36ePjw/bt23/y33u3b9+ml5cXbW1tWaJECTo4OGTZac1CZDYSlIT4xqX9g6+tkhQdHc169eqxZMmSvHz5MsnUsBQcHMzs2bPTxsaGFStWZFJSEh89eqQc7+XlxXz58nH37t3KH+oTJ04wX758dHBwoKOjozInP6uGpLSv14QJE5gnTx4OHTqUHTp0YKlSpejl5aWsTzly5AgtLS1Zp06ddM+jHTH6+eefWaVKFe7atUu5b/78+WzTpg2dnZ05YMAA5T34N3766Se2bduWrVq1UtYlXbt2jVZWVnRxceFPP/3E/fv3s2HDhmzZsqUyQpaSkkKNRsMqVaqwXbt2NDU1VaaOkanBqnbt2sp6pW9RXFwcy5Urx9KlS7Nbt27pKo917dqVRkZG3L9/P2/evMnr16+zSZMmrFKlikyz+8qcOnWKixYtUn4eIiMjOW7cOJqYmChTcrUePHjw2dbxRUZGcufOnVyxYsVn3bBYiG+NBCUhvmFpO/2zZs3iiBEjlNGGN2/e0NnZmSVKlNAZgbh79y4PHz5MtVrNqVOn0sfHRwkGJNmyZUvmzZuXu3btUsLAq1eveP78eeX7fQ1/wB88eMA+ffroVDMLDQ2li4sLvb29+fTpU6rVaoaHh7N58+bKub87fe7p06esXr26MiKhpd389Z9Om3k3wFlYWLBnz56sX78+9fT0lDUMN2/eZLt27Vi2bFmWLl2adevWVTaj/e677/jHH3+QTP08FCxYkG3atFGeNy4ujm5ubnRxcZHpPCTz5MnDHDlycOfOnST/97lOSkpiixYtaG1tTRMTE1avXp21a9eWwg1fmVOnTlGlUtHY2JihoaHK7U+ePOGECROYO3fudEVdyC8z+iqfMSE+DQlKQggOHTqU+fLl44YNG/jgwQPl9ujoaNaqVUtnZOndY0JCQnj//n2d+1q0aKGMLKVdn0RmzSlaS5Ys4cOHD5WvN2/eTJVKRUtLS6VEtlZISAjNzc2VCnVprxxfvnyZ9vb2rF+/Pn/77Tc+e/aMJLlr1y6amppy//79/7mtDx8+5IQJE3j06FGS/yueYWBgwLVr15JMXU/z5s0b3r59mxqNhsOGDaOFhQXXr1/P27dvkyTv37/P3r17s0SJEmzZsiV9fX3p7OzMcuXKfVSlrq9JSkoKIyMjaWlpSRsbG5YrV47Xr18nqft+//rrr9y1axdPnz79VV0k+Fa9+3lPTk7mokWLmCtXLo4YMULnvidPnnDixIlUqVTcvHnzl2ymEOITkqAkxDdu3bp1tLKySrfn0c2bN5X/16lTh7ly5VI60du2bWORIkV01s28ffuWJ0+eVL728PCgSqXS2WAzKzp37hxVKhX79evHx48fk0ztIHXv3p0qlYrLli1LtwdU6dKl0+1nRKYWSThw4ADr1avHihUrsm7duty3bx/v3LnDLl26cNSoUVSr1R8dQHbs2EGVSsXixYsrQY1MHeEICAigoaGhzga6JLl//34WK1ZM2dQ2rXv37nHDhg1s3Lix0r5vdVrPu2u/yNTAlJCQwMqVK9Pe3l4JS1pfw0UCkSrte7dp0yYeOHCACQkJTExM5Lx586inp8fp06frHPPo0SOuWrXqm/tZEeJrIkFJiG/cTz/9pBQTuHHjBufOnUsbGxuWKlWKQ4YMIZlaCtvX11eZzrF8+XJWqlSJZOq6lylTprBUqVI0Nzdn+/btlecePnx4lp4Cou0Qh4eH09DQkH369GFkZCTJ1PDRrl075smThwcOHFA6Ui9fvmTp0qW5fPly5fiHDx/yyZMnOh3nbdu2sW/fvsyZMyd79uxJW1tbWllZKaNMHyMyMpL9+vWjvr6+MhUo7UjGyJEjqVKpdKYLLlu2jOXLl1c2wk17zIdk5ff0Y6QNwSEhIZw2bRr37dvHly9fkkzdBLhy5cosX748L126xNjYWLZr106pEplV1+OJVGnfv4CAAFpaWnL16tVKqf34+HjOmTOHKpUqXVjSkrAkRNYkQUmIb0jaP/ja/8+bN48ODg709vamvb09O3TowDFjxnD27NnMly8fL168qPMcKSkp3LFjB21tbdmoUSMWL16cnTt35owZMxgaGko9PT1lE1KtrNxJ0IaG8PBw6unp6YSllJQUtmrViiYmJuzfvz9nzpzJ5s2b08HBQTnnrVu30t7enlZWVuzUqRN37Nih8/x79+6lv78/ixQpQpVK9Y9LgH8ozLx584be3t7MkSOHUsRB+14nJSVx8eLFTE5OVm6bO3cu7e3tlaCUtiLhli1bePbs2X/6Un2V0v7MDB8+nCYmJqxcuTL19fXp6+urrOl6+fIlq1WrRjMzM5YvX542NjbKFEXxdZg+fToLFizIkydPpts/iUxd12doaMgxY8ZkVBOFEJ+YBCUhvhFp/7AnJiYqHePo6GhOnjyZnp6eXL58Of/880+SqesrqlWrxnv37pFM7YA/ffpUOX7Dhg3s0aMH161bp6xrunr1KqtVq/ZRVdoyM+1rt3fv3veGpc6dO1OlUrFDhw5csGCBEpIuX77MggULcu7cuZw9ezY9PT3p6OiYbvpbUlISnzx58lEhKTAwkAEBAfzuu++UfY/i4+PZsWNH5syZM11Y0tK28fz581SpVOmmCsbExNDDw0OnxPW3Ju3I2ZkzZ9ikSROlcMmWLVtYtmxZdu/eXWcK6uzZs5UwSmbtiwTifxISEuju7s6JEyeSTC1qs3v3bnp5edHX11eZqjxp0iTWrl1bRhGF+EqoSBJCiK+aRqOBnp4eAGDq1Kk4evQoLl++DE9PT7Rr1w5OTk7KY0kiLi4O7du3R3JyMvbs2YNJkybh0KFDuHjxIpo2bYoWLVqgXbt2yjFqtRoxMTHo0qULoqOjcfjwYeX7ZUVpX6937d27F82bN0evXr0wbtw4WFpaIikpCT169MCBAwcQEhKC2rVr49y5cwgLC0N8fDymTp0KADh79izmzp2LK1euwN/fX3kNU1JSYGBg8K/bOWzYMKxZswYdO3bEgwcPcObMGXh6emLmzJl4/vw5hgwZgpCQEISEhKBZs2YfPM/58+dj8ODB8PPzQ9OmTZEtWzZMnDgRT548wZkzZz6qbVnZgQMH0LhxY+XrRYsW4ejRo9BoNFi3bh0MDQ0BACEhIRgzZgxq1aqFfv36oUqVKjrPo1aroa+v/0XbLj49koiPj0fr1q1RsGBBVKtWDXv37kVCQgL09PQQHx8PCwsLbNy4ERqNBtmyZYNKpQJJqFSqjG6+EOK/yNCYJoT4okaNGsW8efNy6tSpnDhxIitUqMAGDRoo1dDi4uK4cuVKNmnSRNknady4cTQ3N+fy5cu5aNEienh4sHLlysoO84mJiVy1ahUbNWrEypUrZ/mKaGnbvWHDBv70008cP348Hz16pOwNtXv3burp6bFv375KgYeUlBS2bt2aBQsW5Pbt29m8eXPmzZuXnTt31nn+M2fOsEuXLqxRowZXr1790e3cu3evTtGGzZs3M3v27FyzZo3ymFWrVhEAbWxs+Pbt2788582bN9PKyoqFChWivb09Gzdu/E2Ws/b392fPnj11RgSmTZtGIyMjlixZMl3BhpCQEDo4ONDLy4s3btz40s0Vn8GHfnetXLmSNWvWZL58+ThhwgRldHHkyJFs166dzmNlREmIr4MEJSG+EdevX6etrS337t2r3Hbp0iV6e3uzcePGvHr1Kt++fcvx48fz+++/Z3JyMh8+fMiqVavqlLe9e/cuR4wYwapVq/Lw4cOMj4/nokWLOH78+K9qulFAQADz58/PFi1asESJEnR0dOTWrVuVggx79uxhtmzZ2K5dO7548YJk6hQ6FxcXlixZUtlTycrKSqd4AkmePXuWLVu2ZP369RkdHf1R7Vu5ciWdnZ1Jpk4DMzExUabJxcTEKOXBR4wYQUNDQy5YsOAvwxKZWtL4+vXrvHr16jdbzvrhw4dKQEy7iezKlSuZP39++vv78+7duzrHrF27lt7e3ln24oD4n7TvYXh4OIODg3Wmyj548EBnk22SdHV1Za9evb5YG4UQX44EJSG+Effv36eVlRXDwsJI/u+K55UrV5g3b14GBgaSpM4C9KdPn7Jw4cJcunSpznM9ePCAtra2nDp1KkndzvTXMPowf/58Fi5cWClksGfPHqpUKlapUoWbN29mfHw8ydRCDbVr11bOOTk5mcnJycqarcOHD9PV1ZUuLi48dOiQzvc4f/58ug7Xv7F69Wp27NiRe/bsYa5cuXTWEm3fvp3+/v5KVa5x48ZRX1//L8PS+66Af8sd/+DgYFaqVIlBQUHKbfPmzaOVlRWHDx+eLixpfcuvWVb3buGOEiVK0NbWlhUqVGCdOnWUDbTJ1DWbhw8fZtOmTXWKt8hIkhBfl6y7iEAI8UH8/6WHTLMEUbte4vr16wBS16eQhK2tLcqVK4fLly8DgLIehf8/v75w4cK4cuUKEhISlOeztraGvb09rl27BpI6a1iy+pqMt2/f4vnz5xg1ahQqVaqErVu3wtvbG3PnzoWxsTFGjBiBnTt3IjY2Fl5eXvjll1+gr6+Pffv2oVu3bujQoQOmTJmCqKgo1K9fH8OGDYOBgQGmTJmCiIgI5fuUL18ehQoV+uh2Ojo6YsuWLXBzc8P8+fPRt29fAEB8fDyWLFmC169fI0+ePACA8ePHY/To0Rg0aBCCgoIQGxub7vnet5YiK68z+6+qVKmC/PnzY926dVi7di0AYMCAAQgICMC6deuwbNky3L59O91x3/JrltVpfwZmzJiBoKAgbNy4EVeuXEH37t1x7NgxODs7Izo6GgBw6dIlTJ06FcbGxjh79iwMDAygVqtlTZIQX5uMTGlCiE8v7RXtly9fMiUlRbna+dNPP1FfX59btmxRHhMbG8sKFSpw9uzZJFP34omKilJGltavX0+VSsUZM2YolfJiY2Pp6OjI8ePHf6Gz+rJ+//13Pn36lFevXqWNjQ3nzJlDMrUSYLZs2Vi6dGkeOHCAZOoV5NDQUGbLlo29e/emj48PS5cuzRIlSigb8IaHh9PDw4PVqlXjL7/88snauWXLFhobG3PYsGE8cuQIDx8+zEaNGrF8+fLvvcI9ZsyYvx1ZEv9z+/Zturm5sX79+jprv+bPn099ff1vuiLg12LlypW8evWq8vW9e/fo7e2tVJDctWsXTU1NOXr0aJYpU4ZOTk7KdNkrV658s1NUhfhWSFAS4iv1ww8/sFq1aqxRowa9vLyUogMBAQFUqVT08fHhgAED2LBhQ2XqyJgxY1i2bFna2dnRycmJp06dIkkuWbKE+vr6dHNzY9u2bVmvXj3a29t/9Z2D4OBgVq1alffv3yeZ2mnq3r07v//+e2W63atXr1i1alVOmjRJOS4xMZENGzZkiRIllECyc+dOtmvXTim3/imkpKRww4YNtLKyopWVFStXrkx3d3cmJSVxz549XLNmDbds2aITiiQs/Ttpw5K26AmZGlK/hmmm37KIiAjq6+tz0KBBSnlvMvW9jYyM5O+//84iRYoogfjHH3+kSqVisWLFGBsbqzxeplsK8fWSoCTEVyLtyMGiRYtoamrKuXPncvTo0XRycmLBggWV/V5Wr15NLy8vNmvWjH369GFSUhLXrFnDPHnyMDAwkEuXLqW7uztz5crFkJAQkqnrdIYMGcL27dtz2LBhX1Xhhg9ZsGABS5QowePHj/PJkyd0d3fnuHHjlPtTUlL47NkzlipViqGhoST/t8YrLi6OJUqU4LBhw5THp+1cfUrPnj3j9evXee/ePWo0Gg4fPpwFCxZkjRo1mCNHDnbo0EEp7kCSY8eOZbZs2Th16lRlvZX4sNu3b7N58+Zs1KgRlyxZonOfhKWsbe3atSxcuDAHDhzIa9eu6dw3c+ZMenh4MCYmhmRqFcmuXbuyd+/e8r4L8Y2QoCTEV+bw4cPs37+/TqWmV69e0cPDg4UKFVKmjaRdmBwaGspRo0Zx5cqVOs/Vu3dv5sqVi7dv3yb54U1Lv1bR0dG0s7OjpaUlra2tWbFiRaVEeNrQU7ZsWfbt21f5OikpiRqNhp6enuzdu/dnb2faK9ozZsygtbW1Mhq4ePFiqlQqenh46Ez7GzRoEOvUqSOLz/+h27dvs0aNGhwwYEBGN0V8Amk/92vXrqWVlRUHDhyoU+K9X79+LF68OMnUn3dPT09OnjxZuV/CkhBfPwlKQnxFDh48yHLlyjFfvnzcvXs3yf91oh8+fEhbW1tl/yNtyDlz5gzLli3L7NmzK0FJGwZIslq1auzfvz/Jb6tjoD3X6Ohobtq0iZs3b1Zes/DwcA4ePFgJI/Pnz2f58uU5a9Ysnefw8vLigAEDqNFoPksgGThwoFLZjiSfP3/OXr16KZXaQkJCaGZmxpEjR9LS0pKNGjViRESE8nhtmyQs/TORkZEyzeoroP28p/19tnr1aiUsaffKOn/+PAsVKkQrKyva29t/E9ONhRC6pDyPEF+RSpUqwdXVFWq1GmvXrgVJ6OnpgSTy5csHMzMzvHr1CsD/qtuVKVMGAwYMgKWlJVavXq3sLJ+SkgKNRgNra2skJSUByPoV7f4NfX19qNVqmJiYoG3btmjTpg0MDAwQEhKCli1bIk+ePEqFK09PTzRo0AArV66Ej48PVq5cib59++LAgQPo168fVCrVJ6+GdejQIcTExMDMzEy5LUeOHGjfvj3c3d3xxx9/YOjQoRg/fjwmT56MyZMn4+jRo/jhhx9w9uxZ5Rj+f3VD8fcsLS2hp6cHjUaT0U0RH0mj0Sif9+TkZOX2Ll26YOLEidi6dSsWLlyI27dvo3z58ti/fz969uwJHx8f/PHHH0p1OyHEt8Hg7x8ihMgK1Go1zM3NMXr0aBgaGmLHjh0YPnw4pk2bBpVKBQMDAyQmJsLQ0FDnmFy5cqFbt27Ili0bpk+fjvbt22Pz5s1KkHr06BGsra0z6rQy1LvB8MaNGxg2bBhmzpyJfv36KbdbW1vD398f9vb2WLhwIS5cuIA8efLg6NGjsLW1/Sxta9iwIerWrQsDAwOsX78e9erVg5WVFZycnGBsbIygoCCUKFEC3bp1AwAkJSXB1dUVuXLlQsWKFQG8vyS4+HtSAjxr0l44AoCZM2ciIiIC2bNnh729PcaOHQsfHx8AwJgxYwAAgwYNgr29Pezt7ZXn0G6zIIT4NqjINButCCGyLO3IQEpKCpKTkzFhwgQEBwfD2toa5cuXx7Nnz3DhwgVcuXIl3V5JUVFRyJ07N5YtW4bJkyfD2NgYdnZ2yJ49O06fPq1zTFak0Wg+2Ln9q/vedfDgQfTv3x/79+9H0aJFP3h8bGws9PT0YGxs/N8a/h4dO3aEo6MjBg0aBAC4fPkyvL29YW5ujo0bN6JgwYLQaDQYNWoUIiIisG7dOlhbW6Nt27bw9PRUOoP/5ryFyOrSjpxOmzYNkyZNQv/+/XHr1i1cvnwZ2bNnx2+//QZDQ0MEBQVh3LhxqF+/Pn744QcUKVIkg1svhMgo8ldSiCwq7fQfbScgNDQU3bp1g0qlwogRI9CxY0f8+eefOH/+PDw8PHDjxg3o6+sjJSVFOWb79u3w8vLC8+fP0blzZ4wePRoGBga4du0afHx8cOPGDRgYGCAlJSUDz/bjpQ0EQUFBGD9+PHx9fXHkyBHExcUp9/2T6TRv375FfHz8e587IiICv//+OwAgZ86cnyUkvXr1Crlz58a4ceMQGBgIALCzs8Pw4cOhp6eHzp074/Hjx9DT04O7uzuuXLmCFi1awM7ODrdv30anTp0A6F5ZF+JboA1Jp0+fxoULF7B582ZMnToVW7ZsQWBgIFJSUlCvXj0AQLdu3TBy5Ei8efPmmx1NF0Kkkr+UQmQhgYGBaNmyJdRqtc5aCZVKhc2bN6Njx45wdnZG9uzZkTt3bgQEBKBWrVp48OABJkyYgPDwcKXDoFKpsGnTJnTt2hXt2rWDhYUFjI2N0bFjR/Tv3x+5c+fG2rVrle+dVadpaQPBsGHDEBAQgDdv3uDOnTvw9fXFpEmTlICknU6zdu1aPHz48L3PVaFCBbx48QLLli3TeW4A2LFjB3bt2qWz7uFT006t9PX1xaBBg7B8+XKoVCq0b98evXv3RlJSEjp37oxHjx6hZs2ayvqKAQMG4Ny5czA0NERKSkqWfS+F+C82bdqEPn364LffftMJQFWrVsWsWbPw6tUrhIWFAQD69OmD0NBQWZMmxLcuY2pICCH+DbVazdjYWFpbW1OlUtHV1VWnctOTJ09YqFAhzp07V+eYlStX0szMjPb29jQzM6Oenh7PnDlDkoyKiqK1tTXnzJmjHKN9zrdv33Lx4sWsVq0aPT09s3xVtJ07d7JYsWLKuYeFhdHAwICbN2/WedylS5eoUqm4YMGCDz7XypUraWhoyKFDh/LixYu8cuUKhw0bRjMzM169evWznUPa9+Dhw4ccPnw4TUxMuGzZMuX+4OBgOjs7s1GjRnz48GG65/iWqhYK8a6bN2/Szc2NBgYGnDhxos59L168oLW19V/+7Ashvj0SlITIArQliTt06MAZM2awXLlyrF+/vs5eSGnLRJPkqVOnWKhQIe7cuZOvX79mv379aGZmxq1btyrPp91TKS1thzw2NpazZs1i3bp1+ejRo891ap/Fu8Fu+fLlbNy4MUkyODiYpqamXLRoEcnUUPj7778rIWL+/Pls2LAhX79+/d7nVqvV3Lx5M/PkyUNra2uWKlWKNjY2PHv27Gc7n/eVpH748CEDAgKYK1cuLl26VLl906ZNbNCgAStUqMAXL158tjYJkRU9ePCALVq0YPXq1RkYGKjcHhsbSwcHB+X3ghBCkGTWXZ0txDdEO8UrT548iImJwcqVK9GyZUt4eHhg586dGD9+PDp37ox8+fIpx0RGRsLa2ho1a9aEmZkZpkyZguPHj2PLli2YMmUK2rdvj1atWsHExETne6lUKpBEjhw50LdvX/j4+OiUoM4KtFPLYmNjkTNnTrx9+xbm5uY4duwYevbsiWnTpilV68LCwnDp0iWUKFEC5ubmcHZ2hrm5+QfPWU9PD23atEGtWrVw7949qFQqFC9eHAUKFPgs55J2HdSNGzfw6tUr2NjYoGDBghgzZgxIwt/fHwDQu3dvtG3bFnFxcTh9+jTy5MnzWdokRFZlbW2NuXPn4rvvvsOUKVPwyy+/wN7eHkePHkVSUhJ69eqV0U0UQmQiUvVOiCxA21meOXMm7t+/j7lz5+LatWto0qQJnjx5gtq1a2Pfvn3Q19dXQsLmzZvRvn17HDhwAKVLl4afnx/Onj2LHj16IC4uDvPmzcOwYcMwbty49+6l877bspKpU6ciOjoaP/74I27cuIHKlSsjLi4OwcHBaNu2LQAgISEBXl5esLa2xtKlSzPda5D2+48aNQqhoaF4+fIlihYtiqpVq2LChAkAgFmzZmHhwoWYOXMmevbsqfMcUs5YiPTu3buHQYMGYefOnWjSpAkaNmyIIUOGAJCfGSHE/8iIkhCZ0LsddO3/a9eujXHjxgEAihcvDkNDQxgYGCA5OVkJSdpj27Rpgz179sDV1RXOzs64cOECTp06heLFiwMALCwsMG7cOPTu3RuWlpbp2pCVQxKQWnlu1qxZ6Ny5M2xtbbFw4UIMGjQIp06dQpkyZfD69WtMmzYNjx8/RlhYGFQqVbqS2Rn9Gmi//4wZM7BixQps2LABDRs2RMeOHbF582Z06tQJTk5OGDBgAIDUEaX8+fOjRYsWynNIh0+I9IoWLYr58+dDrVbDwMBA53egVIQUQmjJbwMhMiGVSoWEhAS8evVK+VorOjpaGUWysrLCtm3bEBkZiQoVKiAuLg6vX79WjgkKCsL169fRt29f1KxZE8WLF0dCQgIAwMrKCvb29jAyMvryJ/iJvW9gvEmTJrCzs8PPP/8MAGjatCnmzp2LDRs2wM3NDYMHD4ahoSFOnz4NAwMDpZJgZkIScXFxOHLkCCZMmICGDRsiPDwcYWFhmDx5MpycnJCUlIT8+fNj4MCBWLRoEZo1a5bRzRYiSyhcuDDmzp2L5ORkrFq1CqtWrQKQ8RdIhBCZh0y9EyKTOXLkCA4ePIht27bBwMAAtWvXRseOHVG7dm0AgIuLC06ePIlKlSph+/btMDc3x7x587Bo0SKoVCoYGBigVq1a8Pb2hrOzMwBgzZo1GD16NP78809ky5YNycnJ8PLygpGREbZs2fLVdAwSEhKQPXt25euBAwciLCwMN27cQLZs2QAAr1+/xsOHD2FqaooiRYoom/Rm1g11k5OT4erqirlz5yIyMhKtWrXCjBkz0KdPHyQmJmLNmjWwtbVVPh8AMvX5CJHZ3L17F507d4a5uTnWrl0LU1PTjG6SECKTkKAkRCYSFBSEH374AfXr10eOHDmQI0cOLFy4EEWKFMHQoUPh4+OD/v3749mzZ1iwYAEKFCiQ7pjs2bNj8eLFKFKkCPz9/dG9e3c8fPgQbdu2xdOnT1GvXj1cv34dcXFxyk707045ywr69u2LoUOHomTJkgCApUuX4ty5c+jbty8qVqwIAIiLi0ONGjXQpk0bjBkz5r3nmZnO/UNtady4MZ4+fYr79+9j1qxZ6N69OwDg0aNH6Ny5Mzp37gwfH58v3Vwhvhr37t2Dnp4eChcunNFNEUJkIhKUhMgkli1bhoEDByIwMBDu7u7IlSsXAODWrVto2bIl4uPjsXz5ctSrVw8xMTEwMTH522OSkpIwa9YsNGvWDL/++ivWr1+PFy9eoFSpUpgwYQIMDAyy5OhDVFQU2rZti127dsHQ0BAAMG7cOJw+fRoHDx7EoEGDUKdOHbi7u2PIkCG4desWNm/erIwqZUZpF5BfvHgRpqamMDY2Rv78+XH58mW0adMGxsbGOHPmDBITExEfH4+OHTsiJiYGR44ckbVIQgghxCcmQUmITGDdunXo0qULQkJC4OXlpXSak5OTYWhoiNu3b6N27dqoXLkydu3a9dHHALqjFlmxutO7oy4rV65EnTp1UKZMGQDAhg0bsHbtWly7dg2NGzdGjRo10LNnTwQGBqJr164Z1ewPmjRpEmrXro169eoBAAICArBlyxZER0fDxcUFPj4+aNy4MTZu3AhfX19YWVnBzMxMWb906tQpGBoaZsn3UgghhMjMstZlZCG+QikpKVi6dCmsra1hYWGhdHhJKh3gEiVKYOrUqejTpw8uXbqEsmXL/qtjLl68iHLlygHQreiU1TrW717XSUxMhJ+fH8qWLYugoCDY2dnB29sb9erVw927dzFo0CD8+eefAICff/450wWl06dPIzQ0FCdOnECuXLmQkJCATZs2YeXKlbhx4wYOHDigTBns0KEDateujcWLF8PY2BiWlpbw8fGBvr5+lhwVFEIIITI7GVESIhN4/vw5WrVqBbVajZEjR6Jp06bQ09PTKRN+4MABNGvWDL/99hsqV678UcdkdXfu3FHKmwcHB6NZs2ZISkqCo6MjLC0tsWTJEjg4OCjnn5KSgoMHD+LMmTMICAjIlGFi165dWLhwIbJnz45ixYrByspK2UD2xIkTmDdvHm7duoXRo0frlP3WkpEkIYQQ4vPIHCuYhfgGnT9/Hjt27EBERAQsLCywfft2qFQqTJkyBeHh4dBoNFCpVFCr1QBSFxtXqlQJ165d+1fH1KlTRyl4kJWdPn0aDRo0QGhoKIYOHYo+ffrgxYsXyJcvH06dOoUHDx6gX79+uHz5snKMgYEBXF1dMWrUKGU9VmaRnJwMAGjevDmGDBmC+Ph4rF27FlFRUcpjnJycMHDgQJQqVQpTp07Fpk2b0j2PhCQhhBDi85CgJEQGWL9+Pbp164ZVq1Zh//790Gg0yJs3L3bs2AEA+PHHH7F3716kpKRAX18f0dHRmD9/Pu7cuYNNmzb942O2bdsGe3t75M6dOyNP95PIkSMH3N3d0atXL6xYsQIXL15EiRIlkJCQgHz58uHs2bO4f/9+urCUVmYZUXr58qVShGL16tWoUaMGhgwZgrJly2LLli04fvy48lhtWDI1NcXBgwczqslCCCHEt4dCiC9q9erVNDY25saNG/n69Wvl9uTkZJLkixcvWKtWLdasWZP79u1jSkoKK1asSJVKxXXr1vH169fUaDR/e4y7uzsrVaqkPEZ7TFbStm1b+vr6Kl9PmzaNKpWKxYoVY0hIiHJ7QkICSfL58+csVqwYS5cuzdu3b3/x9v4TERERzJs3L+/evUs/Pz/my5eP9+/fJ0nu3buXLi4ubNasGX/99Ved4y5dukS1Wp0RTRZCCCG+SbJGSYgv6PLly2jXrh38/PzQs2dP5Xb+/7oi7XqTly9fwsPDA/r6+nj8+DHu3buHefPmoU+fPjqFGz50zOvXr5GYmIhLly5l2YpoycnJOH78OGrVqqWMvvz555/4888/sXfvXuzbtw+jR49Gp06dAPxvrc6LFy/Qt29fbNq0KVOec1JSEjw9PfH7778jMTERv/76KxwcHJT7d+3ahQULFkBPTw9jx45FjRo1dI7PTPs+CSGEEF8z+WsrxBf06NEjxMXFwdnZWaeCm7b4gLYDnDdvXmzfvh2vXr2CRqOBlZUV6tevj+TkZKXz/1fHGBgYKCFJOxUvqzE0NES9evVgaGiIBQsWwNnZGaVKlYKrqyt8fHzQoEEDTJo0CevXrweQulZnzpw50NPTQ0hICPT19ZW1WplJtmzZULlyZbx8+RI5c+ZUQqD289C8eXN89913UKlUGDhwIC5duqRzvIQkIYQQ4suQv7hCfEFnzpxBTEwMypQpA5VKla7ctUqlwtWrV3HkyBFYWFjgxIkT6N69O2JiYlCiRAkYGhr+o2NOnz6thKTMsi7n39BoNDr/L1iwIO7fvw83NzcAQMWKFdGnTx80bNgQY8aMwejRo+Hm5oYFCxborMfKLAHx3fesb9++OH36NKpUqYKGDRvizJkzOkU4mjdvjgEDBsDJyQl2dnYZ0WQhhBDimydBSYgvqFSpUoiNjcX+/fsB/G9UKK01a9Zg48aNSElJQa5cuVC6dGnExsbi8OHD//gYPT09aDSaLBuStKMm165dQ0pKClq2bIkFCxbg5s2bcHV1BQBUqFAB/fv3R9euXbF3714YGRnh6tWr0NfX1wlaGU1biRAAYmJi8PTpU1hbW6Ny5crYtm0b7Ozs4OHhgfPnzyvBbtq0aahduzbmzp2rvJdCCCGE+LIkKAnxBVWpUgXZsmXDsmXLcP/+feV27YhDdHQ0bt68iXLlyikh52OOAbLmFK20IWns2LHo0aMHjh49Cn19fTRu3BgzZszArVu3lLBkZ2eHUaNG4dixY9i6dasyipZZzp2k0paJEyfCw8MD9vb26NmzJ9avX49s2bJhz549sLe3h4uLCxYtWoQGDRpgzZo1MDY2Vp4ns5yPEEII8S2RYg5CfGHBwcHo1q0bWrVqBX9/f1SqVAkAEBkZiZ49eyI6OhoRERE6oedjjsnKRo4cicDAQCxZsgS1atVCvnz5AKRuIBseHg4/Pz/Y2Nhg9+7dOsdllkIHTLPpLwCMGzcOCxYswOTJkxEfH49Dhw7h8ePH6Ny5M/z8/AAAHTt2xO3bt5W1ZoaGhpnmfIQQQohvkQQlIb4wtVqNwMBA+Pr6okCBAnBwcIBGo0FUVBQ0Gg2OHz+erlLdxxyTVZ07dw6tWrXCihUr0KBBA8TGxuLZs2f4/fffYWNjgwoVKmDPnj1o3749evfujRkzZmR0k3Vo3wPtv/fv34eXlxdGjRqFli1bAgBu3bqFpUuX4siRI/jpp59Qr149AMDTp0+RP39+qFSqLLu+TAghhPhayKVKIb4wfX199OzZE6dOnULLli2h0WhQuHBhdO7cGSdOnHhvpbqPOSarSk5OhrGxMfLmzYtff/0Vo0aNQrNmzeDn56dMxXNxccGePXswbdq0jG6ujqFDh8LNzU3nvciePTseP36MN2/eKI8rWbIk+vbti+joaFy8eFG5vUCBAkqRDwlJQgghRMaSESUhMpmPGRXKqiNJ75ta9uLFC1SsWBH58uXDtWvX4OPjgyZNmqB06dJo2bIlxo4dq+ydBGSec09OTsaCBQuwYcMG2NjYICgoCAYGBnj8+DE8PT1Rv359/PDDDzA0NFSm5bVo0QIFChTA8uXLM7j1QgghhHiXXLIUIgO9u5YF+PuS1h9zTGaUNiSdP38eQOreSXZ2djh//jx2796NQoUKwdnZGdmyZQMA5MmTJ93eSJnl3A0NDeHr6wsTExOsWbMGXbp0wZo1a2BpaYnu3bujX79+KFKkCLp27YqcOXMiNjYWT548QfXq1TO66UIIIYR4DxlREkJ8cWnD3vDhw7Fp0yakpKTg1atX6Nu3L4YMGYJChQoBAOLi4hATE4Nu3brh2bNnOHXqVKYJR1ppQ9++ffuwe/duLF++HN7e3liyZAkMDQ0xdepUjB49Gu7u7jAxMcGDBw/w/Plz/PHHHzLNTgghhMiEJCgJITLMnDlzMHnyZISEhMDMzAxXr15F//794enpiUmTJqFgwYKYMWMGNm/eDCMjIxw5ciRTF60YPHgwIiIiULFiRfzxxx949OgRGjZsiNWrV8PQ0BBbt27Fzz//jMjISBQrVgxTp06FgYGBFG4QQgghMiEJSkKIDNO2bVtYW1tj1qxZym2HDh1C8+bNMWXKFPj5+eHRo0fYsWMH+vTpA319/UwbKg4dOoQOHTogNDQUNWvWhEajwZw5c7BmzRrY29sjKCgIhoaGSE5OhqGhoXJcZj0fIYQQ4lsnVe+EEF+cRqNBUlISHj58qGycm5KSgpSUFDRs2BD+/v5YtWoVoqOjYWVlBV9fX6XkdmYNFc+fP4eBgQHKlCkDIHWT2F69esHd3R3bt29H//79kZSUpBOSpLqdEEIIkXlJUBJCfHYajUbnaz09PWTLlg3NmjVDUFCQsk5Hu24pV65cyJs3L0xMTHSOyyzT7dIOxGv/X6xYMeTOnRtnz55V7jMxMUGvXr1gbm6OTZs2YeLEiTrP825RDiGEEEJkHhKUhBCfVdpCB+fOncPRo0fx8OFDpKSkwNfXF3Xq1EGXLl1w5swZ6OvrIy4uDkeOHIGlpWWmDBIajUanXdoqfCVKlEDOnDkxf/58XL58Wbk/MTERjo6OWLZsGSZMmPDF2yuEEEKIjyNrlIQQX4S/vz82bdqEV69eoXTp0ihXrhxWrFiBO3fuYOTIkdi5cyccHByQnJwMPT09nDlzBoaGhu8th54ZzJgxA7///jvUajUGDx6MmjVr4vr162jYsCHs7e3RuHFjVKhQAdOnT4eJiQlCQkKgp6eXaQtRCCGEEEKXBCUhxGeRdiQpNDQUw4YNw5IlS5A/f35ERERg9erVyJMnD3bu3AkjIyNs374d9+7dg6mpKbp06ZLpqsGlPZ8ffvgBCxYsgIeHB27duoWff/4Za9asQceOHfHnn39i9OjROH/+PDQaDSwtLXHgwAEYGhq+d4NdIYQQQmROEpSEEJ9VWFgYjhw5ghw5cmDy5MkAUgs37N+/H6NGjYK7uzvGjx+fLkBk1pGXR48eYeXKlWjQoAFq166N+Ph4TJgwATNnzkRgYCA6deqEhIQEJCYm4tWrVyhWrBhUKlWmCn1CCCGE+HvyV1sI8VmQRExMDPz8/HD37l14eXkp9xkYGKBZs2YIDQ3F8ePH33t8ZgxJYWFh8PT0RLFixeDq6goAMDY2Voo0dO/eHQYGBmjfvj2yZ8+O3LlzA0gdjZKQJIQQQmQtMgdECPHZmJqa4tixY6hTpw7OnDmDHTt2KMUPAKBatWp4/fo13rx5k3GN/BeqVauGvn374v79+3j8+DGA1BBkaGiISZMmYejQofD29sahQ4d0jpPpdkIIIUTWI1PvhBCfBUll36PIyEh4eHjA2NgYffr0gaenJ96+fYt27dohd+7cCA0NzXQFGz60nigqKgq+vr4IDQ3FgQMHULNmTaXgRHJyMlauXImePXvKCJIQQgiRxUlQEkJ8Eu+uKdKGh+vXr8PGxgYPHz6El5cXLl++jJIlS6JUqVKIiorCnj17YGRklKmq26UNSUFBQbh27RpiY2PRoEEDtGzZEgkJCejZsydCQ0Oxf/9+nbCkJWuShBBCiKxN5oMIIf6Ta9euAUhdU6SdVqcNDSEhIahRowbOnTsHa2trhIaGolKlSoiPj4enpyf2798PIyMjJCUlZZqQBPxvqtywYcMwfPhwJCcn4+nTp/D398eQIUOQPXt2zJ49G15eXmjatCkiIiLStV9CkhBCCJG1SVASQny0TZs2wc7ODsOGDQPwv7CkUqkQFhYGb29vTJ48GZUqVYJarUahQoWwadMm5MqVC2vWrMHRo0ehVquRLVu2DD6T9MLDwxESEoKwsDDMnDkTbdq0QWRkJCpWrAgAsLCwwPz581GrVi1MmjQpYxsrhBBCiE9OgpIQ4qPdu3cPtra2+OWXX+Dv7w8gNSy9ffsWFy5cwJIlS+Dr66vcrlarYWVlhbCwMLx9+xb+/v44duxYRp7CB0VGRqJw4cJwdHRESEgIevTogdmzZ6Nz5854+/Ytjh07hty5cyM4OBj79+/P6OYKIYQQ4hOToCSE+Gg5cuSAubk5WrZsid27dythKVeuXOjZsye6d++u83htWCpcuDA2bdoEExMTFCtWLANa/vcMDAxQuHBh7N27Fz4+Ppg+fTr69u0LADh48CDCwsLw4sULmJqaQk9PDxqNJoNbLIQQQohPSYKSEOKjVahQATY2NvDz80OnTp2wf/9+DB48GE5OTvj99991SoFracNS0aJFcfDgQRQtWjQDWv73HB0dsWXLFri5uWH+/PlKSIqPj8eSJUvw6tUr5M2bV3m8lAAXQgghvi6y2lgI8dGKFSuGkydPIjo6WhlNmjJlCoyMjNCwYUMlFL27eaz268wcLsqWLYv169ejS5cuuHr1KiIiIkASU6ZMwdOnT7Fr1y6oVKpMVa1PCCGEEJ+OlAcXQnwUtVqNqKgoODs7IyIiAvny5YOdnR0SEhJgZGQET09PTJkyJaOb+Z+o1Wps3rwZQ4cOBQAULFgQhQoVwtatW2FoaPjeECiEEEKIr4MEJSHE33r9+jXevHmDZ8+ewcTEBHZ2dsp9PXv2hKurKyZNmoQ8efJg8eLF2LlzJ6ZPn47x48ejf//+GdjyT+P58+d48+YNjIyMULhwYahUKtknSQghhPjKyV95IcRf2rFjB1atWoVTp07h1atXIAlfX18MHDgQJUqUgFqtRtu2bdG4cWOsXbsW+fPnh7m5OQoWLAhvb++Mbv4nYWFhAQsLC+VrjUYjIUkIIYT4ysmIkhDig1asWIFRo0ZhwIABcHR0hImJCfbv349p06ahQYMGWLFiBYyNjTFjxgz4+vrC0tIy3XPI9DQhhBBCZEUSlIQQ77VixQr07dsXmzdvhpeXl859O3fuRPv27dGqVSusWbMmg1oohBBCCPH5SFASQqSzZ88eNG/eHOvXr0eHDh0AIF11t2XLlqFv377YtWsXmjVrllFNFUIIIYT4LDJvbV4hRIbJly8fjI2NsX//fkRFRQFAuhLYrq6uKFCgAO7evZsBLRRCCCGE+LwkKAkhdCQlJcHR0RGHDh3Cjh070Lt3b0RHRyv3awehCxcuDLVajZSUlIxqqhBCCCHEZyNBSQgBADh48CDGjh2LPn364N69e6hRowb27NmDAwcOoFevXkpY0o4s/frrryhZsiScnJwystlCCCGEEJ+FBCUhBFatWoVevXohOTkZjRs3RtGiRQEgXVh68+YNACAlJQVTp06FlZUVqlSpkoEtF0IIIYT4PKSYgxDfuK1bt6Jbt25YtWoVWrdunW4tEgCcPHkSzZo1g6urK5YsWYIOHTrg7t27OH/+PAwMDKDRaKCnJ9ddhBBCCPH1kKAkxDcsOjoa7dq1Q+XKlTF58uS/fOzJkyfRvHlzvHr1Cra2tvjjjz9gaGiIlJQU2XxVCCGEEF8duQQsxDcsOjoaZ86c+eD0OY1GAwCIjY1FjRo1EBoaitatW0tIEkIIIcRXT4KSEN+whIQEJCcnK9Pm3h1g1tPTw7NnzzBgwABERkaidu3a2Lx5s4QkIYQQQnz1JCgJ8Q3LnTs3AGDfvn0A0u+VBACnTp1CYmKi8lgtCUlCCCGE+JpJUBLiG0USFhYWCAgIwNKlS7Fw4UIA/5tuBwCJiYkICgqCqakpcuTIkVFNFUIIIYT44uSSsBDfiHcr02lHj9q0aYMLFy5gwIABePnyJdq0aYPChQvj9OnTmDp1Kp48eYLg4GCoVCqQfO+okxBCCCHE10aq3gnxlevcuTMGDBgAR0fHD5bxvnr1KlasWIG5c+cid+7ciI+PR5kyZWBpaYmwsDAYGhpCrVZDX18/A85ACCGEEOLLk6AkxFfszZs38PLywvnz53Ho0CFUrFjxL/c8unLlCi5cuID4+HhUqFABFStWhJ6enhRuEEIIIcQ3R4KSEF8xknj27Bn69++PAwcO4Oeff/5gWPpQgJLNZIUQQgjxLZKgJMRXKu0o0MWLF/Hdd9/h9u3b2Lt3LxwcHCQACSGEEEL8BeklCfGV0oak0aNHY+DAgQCAR48eoV69evjjjz+gp6enU+FOCCGEEEL8j4woCfEVW7FiBb7//nvs378fxYsXx61btzB58mScOHECR44c+ds1S0IIIYQQ3yrpHQnxFbt16xaaNGkCJycnFCxYELVq1cLChQtRoUIFNG3aFFeuXIGenh7keokQQgghhC4JSkJ8xfT09PD7778rX5NE8eLF4e3tjadPn8LBwQHXr1+XvZGEEEIIId4hQUmIr8CH1hp5eXkhd+7cmDBhAmJiYpRAVKxYMfj4+GDixIkoWbLkl2yqEEIIIUSWIBujCJHFpV1jFBwcjBs3boAknJ2dUb9+fXh4eGD//v2IiorC999/j5SUFMyfPx+WlpYYNWoUAMg+SUIIIYQQ75BiDkJ8JYYNG4a1a9fCzc0Njx8/xpUrV+Dn5wdfX19MmjQJe/fuxenTp1GqVCkYGxvj9OnTMDQ0BEmZeieEEEII8Q4JSkJ8BcLCwjBgwABs3rwZ1atXx7p169CrVy8sW7YMnTt3hkajQVJSEg4dOgQTExPUqlUL+vr6MpIkhBBCCPEB0kMSIgvSjgJp/719+zbs7e1RvXp1hISEwNfXF7Nnz0bnzp0RHR2N69evo1q1anBzc1OeQ61WS0gSQgghhPgAKeYgRBaknSp37949AEC2bNlQrFgx7Nu3Dz4+Ppg+fTr69u0LANi/fz92796N169f6zyHvr7+l220EEIIIUQWIlPvhMhCQkJCYGxsDDc3N/j7++PRo0fYuHEjjh07BmdnZwBAYGAgunbtCgCIi4tDy5YtUbJkSSxatCgjmy6EEEIIkaXIvBshsojExEQcOnQIS5cuhZeXF8LDw3H8+HEAQO3atbF48WJ89913ePXqFU6dOgWSGDt2LJ4+fYrdu3cDgBRuEEIIIYT4h2RESYgsxsbGBrdu3cLcuXPRv39/pSBDbGwsli9fjokTJ8LQ0BBWVlawsLDAzp07YWhoCLVaLdPthBBCCCH+IQlKQmQhsbGx6Nq1K1QqFXbs2IFt27ahefPm0P4Yq1Qq3LlzBzExMTAyMkLp0qWhp6cn1e2EEEIIIf4lCUpCZGJpN5NNKy4uDkOHDsXy5cuVsKT1559/olSpUn/7HEIIIYQQ4sPkErMQmVTagBMREYGkpCSo1Wo0bdoUOXLkwOTJk6FSqdC6dWts2LABjRs3ho+PD/Lly4clS5YozyMhSQghhBDi35OgJEQmRFIJOCNHjsTGjRthbGyMJ0+eoG3btpgxYwbMzMwwefJkZMuWDa1bt0a5cuWQmJiIixcvZnDrhRBCCCGyPpl6J0QmNnXqVMyZMwehoaGoUaMGpk2bhhEjRsDb2xuLFi2CqakpAODgwYN48eIF2rRpA319fVmTJIQQQgjxH0lQEiKTunv3LgICAtChQwd4enpix44d6NatG3r16oXly5ejefPmmDt3LszNzXWOk+p2QgghhBD/nVxyFiITSk5OhqWlJdzc3FCvXj2cPHkSAwcOxKRJk9C/f38YGRlh8uTJePPmDTZu3IhcuXIpx0pIEkIIIYT472SVtxCZzJQpUzB16lQYGRmhXbt2MDMzw759+1C1alV06dIFAGBmZoa2bduCJHLkyJHBLRZCCCGE+PpIUBIik9HT08PChQtx9+5dGBkZQaPR4PLly3j9+jVMTEwQHx+PX375BU2bNsWuXbugp6cHjUaT0c0WQgghhPiqSFASIpNp0aIFypQpg8OHDwNIDU6+vr44duwYqlatiipVquDOnTvo2LGjcoyUABdCCCGE+LSkmIMQmUBiYiKMjIyUr3v16oWjR4/i6tWrUKlUAIDjx49jy5YtyJcvH4YPHw4DAwMp3CCEEEII8ZlIUBLiCxs4cCAGDx6MYsWKAQCWL1+Oixcvon///rCxsQEAREVFoUaNGvDx8cGwYcNAUglMWlICXAghhBDi85H5OkJ8Qc+ePcPFixdhbW2t3Hbz5k1cvXoVlSpVwtixY7Fv3z7kzp0bDRs2xOnTp5GSkgKVSoV3r2lISBJCCCGE+HxkREmIL0Sj0eisJVq9ejXq1auHokWLAkgdWdq8eTNu3ryJli1bws7ODn369EFwcDDatm2bUc0WQgghhPgmSVAS4gsgCY1Go6wnio2NhZmZGWrUqIGVK1eiTJkyAIAHDx7g5s2b8PPzg4WFBY4cOYKePXti2bJlGdl8IYQQQohvjgQlIb6A+/fvo0iRIgCAkJAQNG/eHM+fP0eNGjVga2uL+fPnw9bWVnl8fHw8Dh48iNOnT2PMmDEyzU4IIYQQ4guToCTEZ3bq1Cm0b98eixcvxsGDB7FixQqcPXsWxYsXx8OHD1G1alXY29tj4cKFKFu27HufQwo3CCGEEEJ8WRKUhPjMzp8/j8WLF2Pbtm1ISUnB+fPnUbhwYaUkuDYsOTg4YOHChUrlOyGEEEIIkXGk6p0Qn4n2GkSFChVQrFgxvHjxAmZmZrhw4QIAwMjICElJSbC2tsbp06dx9epVtGnTBvfv38/IZgshhBBCCEhQEuKz0Gg0yr5Hz58/R82aNXHw4EG4urrC398fISEhAABDQ0Oo1WpYW1vjt99+Q/HixWFlZZWRTRdCCCGEEABk0YMQn1jaMuATJ07E/fv30bNnTzg7O8Pc3BxJSUkYM2YM9PT04OXlBX19fSxYsABdu3bFjh07AABqtVqpkCeEEEIIIb48WaMkxGcyYsQIrFq1CrNmzUKDBg1gaWkJIHXN0sKFC3Ho0CH06NEDx48fx59//omrV6/q7LMkhBBCCCEyjowoCfEZnDx5Eps2bUJISAjq1KkDIHXNkkqlQoUKFfD9998jb968CA4ORvHixXHp0iXo6eml25RWCCGEEEJkDBlREuIz2LdvH/r374/jx48jf/78UKlUSlBSq9XQ09ODSqVCTEwMcuXKBZVKJSXAhRBCCCEyEbl0LcRnEBcXh3v37iExMVEJR9riDhEREThx4gTUajVMTEygUqmg0WgkJAkhhBBCZCISlIT4DzQazXtvr1mzJhwdHTFw4EA8ePBAKcyQkJCAH3/8ERERETrFGmS6nRBCCCFE5iJT74T4SGnXEx08eBBv376Fvr4+3N3dAQCBgYEICgpCSkoKRowYgTdv3mDdunV48uQJTp8+LSNIQgghhBCZmAQlIT6Cdr0RkFrdbu3atcifPz+uXbuGNm3aYPLkybC2tsbu3bsRGBiI/fv3o0yZMihcuDA2b96s7J8kJcCFEEIIITInCUpC/AfTp0/HnDlzEBoaCkdHRyxYsAADBw6Eh4cH5s6diyJFigAA7t27B3NzcyncIIQQQgiRRcjCCCE+UmRkJK5cuYLZs2fD0dER27Ztw9ixYzF69GhERETg+++/x9WrVwEARYsWlcINQgghhBBZiPTWhPhI5ubm8PDwQP369XH69GkMGTIE48ePx8CBA2FmZgZ/f39ERUUhKCgI1tbWynFSuEEIIYQQIvOTHpsQHyl79uxo3rw5zMzMcPDgQdjb26Nr164AgGzZsqFTp04wNDREoUKFMrilQgghhBDi35KgJMR/oJ1Cd+PGDURFRUGlUiEhIQH79u2Dm5sb9u7dCz09vQ+WERdCCCGEEJmTFHMQ4hM4efIknJ2dYWNjg8TERGTPnh1nz56VtUhCCCGEEFmUBCUhPpGzZ89i27ZtMDU1xeDBg2FgYCDV7YQQQgghsigJSkJ8JhKShBBCCCGyLglKQgghhBBCCPEOKeYghBBCCCGEEO+QoCSEEEIIIYQQ75CgJIQQQgghhBDvkKAkhBBCCCGEEO+QoCSEEEIIIYQQ75CgJIQQQgghhBDvkKAkhBBCCCGEEO+QoCSEEEIIIYQQ75CgJIQQQgghhBDvkKAkhBBCCCGEEO+QoCSEEEIIIYQQ7/g/Qi6Lygy/JkMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1174,19 +1154,19 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_369269/805283967.py:42: FutureWarning: \n", + "/tmp/ipykernel_109448/805283967.py:42: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", " sb.barplot(x='model', y='f1_score_mean', data=df, capsize=0.2, palette='viridis', ax=ax)\n", - "/tmp/ipykernel_369269/805283967.py:53: FutureWarning: \n", + "/tmp/ipykernel_109448/805283967.py:53: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", @@ -1195,7 +1175,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1205,7 +1185,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 6c1ac10823..4b50d623bb 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -104,7 +104,7 @@ extra: default: latest alias: true docker_url: nvcr.io/nvidia/clara/bionemo-framework - docker_tag: main--nightly + docker_tag: nightly github_url: https://github.com/NVIDIA/bionemo-framework copyright: | diff --git a/requirements-cve.txt b/requirements-cve.txt index 2794921a1a..357f0d6a81 100644 --- a/requirements-cve.txt +++ b/requirements-cve.txt @@ -9,4 +9,4 @@ pillow>=10.3.0 tornado>=6.4.2 wandb>=0.19.1 # Addresses CVE GHSA-v778-237x-gjrc lightning<=2.4 -pytorch_lightning<=2.4 \ No newline at end of file +pytorch_lightning<=2.4 diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py index 602c56a134..09526572ef 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py @@ -79,7 +79,7 @@ def __getitem__(self, index: int) -> BertSample: sequence = self.sequences[index] tokenized_sequence = self._tokenize(sequence) - label = tokenized_sequence if len(self.labels) == 0 else self.labels[index] + label = tokenized_sequence if len(self.labels) == 0 else torch.Tensor([self.labels[index]]) # Overall mask for a token being masked in some capacity - either mask token, random token, or left as-is loss_mask = ~torch.isin(tokenized_sequence, Tensor(self.tokenizer.all_special_ids)) @@ -108,7 +108,7 @@ def load_data(self, csv_path: str | os.PathLike) -> Tuple[Sequence, Sequence]: df = pd.read_csv(csv_path) sequences = df["sequences"].tolist() - if "label" in df.columns: + if "labels" in df.columns: labels = df["labels"].tolist() else: labels = [] @@ -147,7 +147,7 @@ def __init__( max_seq_length: int = 1024, micro_batch_size: int = 4, global_batch_size: int = 8, - num_workers: int = 10, + num_workers: int = 2, persistent_workers: bool = True, pin_memory: bool = True, rampup_batch_size: list[int] | None = None, diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py index 70501dce50..bdfaa4fe6b 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py @@ -18,7 +18,6 @@ from pathlib import Path from typing import Dict, Sequence, Type, get_args -import torch from nemo import lightning as nl from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype @@ -27,9 +26,9 @@ from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule, InMemoryCSVDataset from bionemo.esm2.model.finetune.finetune_regressor import ESM2FineTuneSeqConfig from bionemo.esm2.model.finetune.finetune_token_classifier import ESM2FineTuneTokenConfig -from bionemo.llm.lightning import batch_collator from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.biobert.model import BioBertConfig +from bionemo.llm.utils.callbacks import IntervalT, PredictionWriter from bionemo.llm.utils.datamodule_utils import infer_global_batch_size @@ -58,6 +57,7 @@ def infer_model( pipeline_model_parallel_size: int = 1, devices: int = 1, num_nodes: int = 1, + prediction_interval: IntervalT = "epoch", config_class: Type[BioBertConfig] = ESM2Config, ) -> None: """Runs inference on a BioNeMo ESM2 model using PyTorch Lightning. @@ -77,13 +77,11 @@ def infer_model( pipeline_model_parallel_size (int, optional): Pipeline model parallel size for distributed inference. Defaults to 1. devices (int, optional): Number of devices to use for inference. Defaults to 1. num_nodes (int, optional): Number of nodes to use for distributed inference. Defaults to 1. + prediction_interval (IntervalT, optional): Intervals to write predict method output into disck for DDP inference. Defaults to epoch. config_class (Type[BioBertConfig]): The config class for configuring the model using checkpoint provided """ - if os.path.isdir(results_path): - results_path = results_path / "esm2_inference_results.pt" - else: - _, extension = os.path.splitext(results_path) - results_path = results_path if extension == ".pt" else results_path / ".pt" + # create the directory to save the inference results + os.makedirs(results_path, exist_ok=True) # Setup the strategy and trainer global_batch_size = infer_global_batch_size( @@ -101,12 +99,14 @@ def infer_model( find_unused_parameters=True, ) + prediction_writer = PredictionWriter(output_dir=results_path, write_interval=prediction_interval) + trainer = nl.Trainer( accelerator="gpu", devices=devices, strategy=strategy, num_nodes=num_nodes, - callbacks=[], # TODO: @farhadr Add PredictionWriter for DDP + callbacks=[prediction_writer], plugins=nl.MegatronMixedPrecision(precision=precision), ) @@ -135,11 +135,9 @@ def infer_model( tokenizer = get_tokenizer() module = biobert_lightning_module(config=config, tokenizer=tokenizer) - predictions = trainer.predict(module, datamodule=datamodule, return_predictions=True) - results_dict = batch_collator(predictions) - non_none_keys = [key for key, val in results_dict.items() if val is not None] - print(f"Writing output {str(non_none_keys)} into {results_path}") - torch.save(results_dict, results_path) + # datamodule is responsible for transforming dataloaders by adding MegatronDataSampler. Alternatively, to + # directly use dataloader in predict method, the data sampler should be included in MegatronStrategy + trainer.predict(module, datamodule=datamodule) # return_predictions=False failing due to a lightning bug def infer_esm2_entrypoint(): @@ -181,7 +179,7 @@ def get_parser(): required=True, help="Path to the CSV file containing sequences and label columns", ) - parser.add_argument("--results-path", type=Path, required=True, help="Path to the results file.") + parser.add_argument("--results-path", type=Path, required=True, help="Path to the results directory.") parser.add_argument( "--precision", @@ -226,6 +224,14 @@ def get_parser(): default=1, help="Tensor model parallel size. Default is 1.", ) + parser.add_argument( + "--prediction-interval", + type=str, + required=False, + choices=get_args(IntervalT), + default="epoch", + help="Intervals to write DDP predictions into disk", + ) parser.add_argument( "--include-hiddens", action="store_true", diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py index c10ce0754e..aac0ed617d 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py @@ -13,7 +13,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -from pathlib import Path +import glob +from typing import get_args import pandas as pd import pytest @@ -26,9 +27,21 @@ from bionemo.esm2.data.tokenizer import get_tokenizer from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule, InMemoryCSVDataset from bionemo.esm2.scripts.infer_esm2 import infer_model +from bionemo.llm.data import collate +from bionemo.llm.lightning import batch_collator +from bionemo.llm.utils.callbacks import IntervalT esm2_650m_checkpoint_path = load("esm2/650m:2.0") +esm2_3b_checkpoint_path = load("esm2/3b:2.0", source="ngc") + + +# Function to check GPU memory +def check_gpu_memory(threshold_gb): + if torch.cuda.is_available(): + gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3) # Memory in GB + return gpu_memory < threshold_gb + return False @pytest.fixture @@ -71,6 +84,17 @@ def data_module(dataset): return ESM2FineTuneDataModule(predict_dataset=dataset) +@pytest.fixture +def padded_tokenized_sequences(dummy_protein_sequences): + tokenizer = get_tokenizer() + tokenized_sequences = [ + tokenizer.encode(seq, add_special_tokens=True, return_tensors="pt") for seq in dummy_protein_sequences + ] + batch = [{"text": tensor.flatten()} for tensor in tokenized_sequences] + collated_batch = collate.bert_padding_collate_fn(batch, padding_value=tokenizer.pad_token_id, min_length=1024) + return collated_batch["text"] + + def test_in_memory_csv_dataset(dataset): assert len(dataset) > 0 sample = dataset[0] @@ -114,38 +138,43 @@ def test_esm2_fine_tune_data_module_val_dataloader(data_module): data_module.val_dataloader() -def test_in_memory_csv_dataset_tokenizer(): - tokenizer = get_tokenizer() - sequence = "sequence" - tokenized_sequence = tokenizer.encode(sequence, add_special_tokens=True, return_tensors="pt") - assert isinstance(tokenized_sequence, torch.Tensor) - - @pytest.mark.parametrize("precision", ["fp32", "bf16-mixed"]) -def test_infer_runs(tmpdir, dummy_protein_csv, dummy_protein_sequences, precision): +@pytest.mark.parametrize("prediction_interval", get_args(IntervalT)) +@pytest.mark.skipif(check_gpu_memory(30), reason="Skipping test due to insufficient GPU memory") +def test_infer_runs( + tmpdir, + dummy_protein_csv, + dummy_protein_sequences, + precision, + prediction_interval, + padded_tokenized_sequences, +): data_path = dummy_protein_csv - result_dir = Path(tmpdir.mkdir("results")) - results_path = result_dir / "esm2_infer_results.pt" - - max_dataset_seq_len = max(len(seq) for seq in dummy_protein_sequences) + result_dir = tmpdir / "results" + min_seq_len = 1024 # Minimum length of the output batch; tensors will be padded to this length. infer_model( data_path=data_path, checkpoint_path=esm2_650m_checkpoint_path, - results_path=results_path, - min_seq_length=max_dataset_seq_len, + results_path=result_dir, + min_seq_length=min_seq_len, + prediction_interval=prediction_interval, include_hiddens=True, precision=precision, include_embeddings=True, include_input_ids=True, include_logits=True, micro_batch_size=3, # dataset length (10) is not multiple of 3; this validates partial batch inference - # config_class=SUPPORTED_CONFIGS[config_class_name], config_class=ESM2Config, ) - assert results_path.exists(), "Could not find test results pt file." - - results = torch.load(results_path) + assert result_dir.exists(), "Could not find test results directory." + + if prediction_interval == "epoch": + results = torch.load(f"{result_dir}/predictions__rank_0.pt") + elif prediction_interval == "batch": + results = batch_collator( + [torch.load(f, map_location="cpu") for f in glob.glob(f"{result_dir}/predictions__rank_0__batch_*.pt")] + ) assert isinstance(results, dict) keys_included = ["token_logits", "hidden_states", "embeddings", "binary_logits", "input_ids"] assert all(key in results for key in keys_included) @@ -153,8 +182,15 @@ def test_infer_runs(tmpdir, dummy_protein_csv, dummy_protein_sequences, precisio assert results["embeddings"].shape[0] == len(dummy_protein_sequences) assert results["embeddings"].dtype == get_autocast_dtype(precision) # hidden_states are [batch, sequence, hidden_dim] - assert results["hidden_states"].shape[:-1] == (len(dummy_protein_sequences), max_dataset_seq_len) + assert results["hidden_states"].shape[:-1] == (len(dummy_protein_sequences), min_seq_len) # input_ids are [batch, sequence] - assert results["input_ids"].shape == (len(dummy_protein_sequences), max_dataset_seq_len) + assert results["input_ids"].shape == (len(dummy_protein_sequences), min_seq_len) # token_logits are [sequence, batch, num_tokens] - assert results["token_logits"].shape[:-1] == (max_dataset_seq_len, len(dummy_protein_sequences)) + assert results["token_logits"].shape[:-1] == (min_seq_len, len(dummy_protein_sequences)) + + # test 1:1 mapping between input sequence and results + # this does not apply to "batch" prediction_interval mode since the order of batches may not be consistent + # due distributed processing. To address this, we optionally include input_ids in the predictions, allowing + # for accurate mapping post-inference. + if prediction_interval == "epoch": + assert torch.equal(padded_tokenized_sequences, results["input_ids"]) diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index 7e64db3596..ab211a7a63 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -10,7 +10,9 @@ authors = [{ name = "BioNeMo Team", email = "bionemofeedback@nvidia.com" }] requires-python = ">=3.10" license = { file = "LICENSE" } dynamic = ["version"] -dependencies = [] +dependencies = [ + "bionemo-noodles" +] # [project.scripts] # bionemo-evo2-train = "" diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index eea72ba178..381a3d532c 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -17,8 +17,6 @@ """Module containing data preprocessing and splitting functions for Evo2 in BioNeMo. It can also be utilized as a script to dump pre-processed data to JSON. - -TODO(@cye): Add commentary and config interface. """ import argparse @@ -33,13 +31,14 @@ import pandas as pd import torch import yaml -from Bio import Seq, SeqIO from megatron.core.datasets.indexed_dataset import IndexedDatasetBuilder from nemo.utils import logging from bionemo.evo2.data.resources.phyla_kingdom_map import PHYLA_TO_KINGDOM from bionemo.evo2.data.tokenizer import Evo2Tokenizer from bionemo.evo2.utils.config import Evo2PreprocessingConfig +from bionemo.noodles import back_transcribe_sequence, complement_sequence, reverse_sequence, transcribe_sequence +from bionemo.noodles.nvfaidx import NvFaidx @contextmanager @@ -71,22 +70,22 @@ def __init__(self, params: Evo2PreprocessingConfig | None = None): ) @staticmethod - def _subsequence_generator(sequence: Seq.Seq, subsequence_length: int | None = None, offset: int | None = None): + def _subsequence_generator(sequence: str, subsequence_length: int | None = None, offset: int | None = None): subsequence_length = subsequence_length if isinstance(subsequence_length, int) else len(sequence) step_size = offset if isinstance(offset, int) else subsequence_length for i in range(0, len(sequence), step_size): yield sequence[i : i + subsequence_length] @staticmethod - def _random_reverse_complement(seq: Seq.Seq, prob: float = 0.5): + def _random_reverse_complement(seq: str, prob: float = 0.5): if random.random() < prob: - return seq.reverse_complement() + return complement_sequence(reverse_sequence(seq)) else: return seq @staticmethod - def _reverse_complement_expansion(seq: Seq.Seq): - return [seq, seq.reverse_complement()] + def _reverse_complement_expansion(seq: str): + return [seq, complement_sequence(reverse_sequence(seq))] @staticmethod def _train_val_test_split(train_weight: float, val_weight: float, test_weight: float): @@ -141,20 +140,19 @@ def _load_evo_taxonomy(fname): return id_to_taxonomy @staticmethod - def _yield_sequences_from_files(fnames: list, semaphore: Semaphore, gzip_data: bool = False): + def _yield_sequences_from_files(fnames: list, semaphore: Semaphore): """Iterator over sequences within multiple input documents. Arguments for multiprocessing tasks. Utilized to limit the amount of sequences streamed into memory. - TODO(@cye): Just do the fasta parsing ourselves if there's no weird formats. """ def yielder(fname, semaphore): - # Open file. - with gzip.open(fname, "rt") if gzip_data else open(fname, "r") as f: - for record in SeqIO.parse(f, "fasta"): - semaphore.acquire() - # Yield filename and record within fasta. - yield str(fname), record + # Read FASTA. + index = NvFaidx(fname) + for seqid, sequence in index.items(): + semaphore.acquire() + # Yield filename and sequence within fasta. + yield str(fname), seqid, sequence for fname in fnames: semaphore.acquire() @@ -167,7 +165,7 @@ def configure(self, params: Evo2PreprocessingConfig | None = None): self._load_evo_taxonomy(self.params.taxonomy_path) if self.params.taxonomy_path is not None else None ) - def preprocess_data(self, filepath: str, record) -> list[dict]: + def preprocess_data(self, filepath: str, seqid: str, seq: str) -> list[dict]: """Preprocess Evo2 fasta datapaths.""" # Retrieve EVO taxonomy metadata if id_to_taxonomy is provided. lineage_string = ( @@ -186,7 +184,6 @@ def preprocess_data(self, filepath: str, record) -> list[dict]: with preprocessing_context_manager( self.params.seed + hash(filepath) if self.params.seed is not None else None ): - seq = record.seq # Randomly reverse complement the sequence. seq = self._random_reverse_complement(seq, prob=0.5) if self.params.random_reverse_complement else seq seqs_to_parse = self._reverse_complement_expansion(seq) if self.params.embed_reverse_complement else [seq] @@ -194,9 +191,9 @@ def preprocess_data(self, filepath: str, record) -> list[dict]: if self.params.force_uppercase: seq = seq.upper() if self.params.transcribe == "transcribe": - seq = seq.transcribe() + seq = transcribe_sequence(seq) elif self.params.transcribe == "back_transcribe": - seq = seq.back_transcribe() + seq = back_transcribe_sequence(seq) if self.params.drop_empty_sequences and len(seq) == 0: continue if self.params.nnn_filter and "NNN" in seq.upper(): @@ -216,7 +213,7 @@ def preprocess_data(self, filepath: str, record) -> list[dict]: "text": taxonomy_token + str(subseq) if taxonomy_token is not None else str(subseq), } if self.params.include_sequence_id: - preproc_data_record["id"] = f"{record.id}_{i}" + preproc_data_record["id"] = f"{seqid}_{i}" # Tokenize the sequence. preproc_data_record["tokens"] = self.tokenizer.tokenize( preproc_data_record["text"], @@ -245,7 +242,7 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): preproc_tasks = pool.imap( evo2_preprocessor.preprocess_data_task, Evo2Preprocessor._yield_sequences_from_files( - preproc_config.datapaths, semaphore, preproc_config.gzip_data + preproc_config.datapaths, semaphore ), chunksize=25, ) @@ -253,7 +250,7 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): preproc_tasks = ( evo2_preprocessor.preprocess_data_task(x) for x in Evo2Preprocessor._yield_sequences_from_files( - preproc_config.datapaths, semaphore, preproc_config.gzip_data + preproc_config.datapaths, semaphore ) ) @@ -294,15 +291,13 @@ def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): for sequence in self.preprocess_generator(preproc_config): if sequence["split"] == "train": train_builder.add_item(torch.Tensor(sequence["tokens"])) + train_builder.end_document() elif sequence["split"] == "val": val_builder.add_item(torch.Tensor(sequence["tokens"])) + val_builder.end_document() elif sequence["split"] == "test": test_builder.add_item(torch.Tensor(sequence["tokens"])) - # IMPORTANT TODO(@cye): Split documents by filename instead of all datasets - # into one document, to check that BlendedDataset weighting make sense. - train_builder.end_document() - val_builder.end_document() - test_builder.end_document() + test_builder.end_document() # Write preprocessed index sdata to disk. IDX = ".idx" diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index b0c3eb95be..51064c4cb9 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -41,7 +41,6 @@ class Evo2PreprocessingConfig(BaseModel): # Evo Taxonomy taxonomy_path: None | Path = None # Raw Preprocessing Transforms - gzip_data: bool = False embed_reverse_complement: bool = False random_reverse_complement: bool = False subsequence_length: None | int = None diff --git a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml index 2e9768b116..4b12b273b9 100644 --- a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml +++ b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml @@ -1,6 +1,6 @@ -- datapaths: ["/workspace/bionemo2/sub-packages/bionemo-evo2/tests/data/mmseqs_results_rep_seq.fasta"] - output_dir: "/workspace/bionemo2/sub-packages/bionemo-evo2/tests/data" - output_prefix: promoters_ab_test +- datapaths: ["/workspace/bionemo2/data/mmseqs_results_rep_seq_distinct.fasta"] + output_dir: "/workspace/bionemo2/data" + output_prefix: promoters_ab_test_noodles_uint8_distinct # Datasplit train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training valid_split: 0.0 @@ -8,7 +8,6 @@ # Evo Taxonomy taxonomy_path: null # Raw Preprocessing Transforms - gzip_data: false embed_reverse_complement: true random_reverse_complement: false subsequence_length: null @@ -36,3 +35,4 @@ nnn_filter: true # RNG seed: 42 + diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py index 3a72d11e9e..ae7b0aaa7b 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py @@ -13,10 +13,10 @@ # See the License for the specific language governing permissions and # limitations under the License. import argparse +import os from pathlib import Path from typing import Dict, Type, get_args -import torch from nemo import lightning as nl from nemo.utils import logging @@ -25,9 +25,9 @@ from bionemo.geneformer.api import FineTuneSeqLenBioBertConfig, GeneformerConfig from bionemo.geneformer.data.singlecell.datamodule import SingleCellDataModule from bionemo.geneformer.data.singlecell.preprocess import GeneformerPreprocess -from bionemo.llm.lightning import batch_collator from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.biobert.model import BioBertConfig +from bionemo.llm.utils.callbacks import IntervalT, PredictionWriter from bionemo.llm.utils.datamodule_utils import infer_global_batch_size @@ -38,6 +38,7 @@ def infer_model( include_hiddens: bool = False, include_embeddings: bool = False, include_logits: bool = False, + include_input_ids: bool = False, seq_length: int = 2048, micro_batch_size: int = 64, precision: PrecisionTypes = "bf16-mixed", @@ -46,9 +47,13 @@ def infer_model( devices: int = 1, num_nodes: int = 1, num_dataset_workers: int = 0, + prediction_interval: IntervalT = "epoch", config_class: Type[BioBertConfig] = GeneformerConfig, ) -> None: """Inference function (requires DDP and only training data that fits in memory).""" + # create the directory to save the inference results + os.makedirs(results_path, exist_ok=True) + # This is just used to get the tokenizer :( train_data_path: Path = ( load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" / "train" @@ -86,16 +91,19 @@ def infer_model( ckpt_include_optimizer=True, progress_interval=1, ) + + prediction_writer = PredictionWriter(output_dir=results_path, write_interval=prediction_interval) + trainer = nl.Trainer( devices=devices, accelerator="gpu", strategy=strategy, num_nodes=num_nodes, - callbacks=[], + callbacks=[prediction_writer], plugins=nl.MegatronMixedPrecision(precision=precision), ) # Configure the data module and model - data = SingleCellDataModule( + datamodule = SingleCellDataModule( seq_length=seq_length, tokenizer=tokenizer, train_dataset_path=None, @@ -113,7 +121,7 @@ def infer_model( pin_memory=False, num_workers=num_dataset_workers, ) - geneformer_config = config_class( + config = config_class( seq_length=seq_length, params_dtype=get_autocast_dtype(precision), pipeline_dtype=get_autocast_dtype(precision), @@ -122,20 +130,15 @@ def infer_model( initial_ckpt_path=str(checkpoint_path) if checkpoint_path is not None else None, include_embeddings=include_embeddings, include_hiddens=include_hiddens, + include_input_ids=include_input_ids, skip_logits=not include_logits, initial_ckpt_skip_keys_with_these_prefixes=[], # load everything from the checkpoint. ) # The lightning class owns a copy of the actual model, and a loss function, both of which are configured - # and lazily returned by the `geneformer_config` object defined above. - model = biobert_lightning_module( - geneformer_config, - tokenizer=tokenizer, - ) + # and lazily returned by the `config` object defined above. + module = biobert_lightning_module(config=config, tokenizer=tokenizer) - results_dict = batch_collator(trainer.predict(model, datamodule=data, return_predictions=True)) - non_none_keys = [key for key, val in results_dict.items() if val is not None] - print(f"Writing output {str(non_none_keys)} into {results_path}") - torch.save(results_dict, results_path) + trainer.predict(module, datamodule=datamodule) # return_predictions=False failing due to a lightning bug def geneformer_infer_entrypoint(): @@ -147,11 +150,12 @@ def geneformer_infer_entrypoint(): infer_model( data_path=args.data_dir, checkpoint_path=args.checkpoint_path, - results_path=args.result_path, + results_path=args.results_path, include_hiddens=args.include_hiddens, micro_batch_size=args.micro_batch_size, include_embeddings=not args.no_embeddings, include_logits=args.include_logits, + include_input_ids=args.include_input_ids, seq_length=args.seq_length, precision=args.precision, devices=args.num_gpus, @@ -193,10 +197,13 @@ def get_parser(): parser.add_argument( "--include-logits", action="store_true", default=False, help="Include per-token logits in output." ) - parser.add_argument( - "--result-path", type=Path, required=False, default=Path("./results.pt"), help="Path to the result file." + "--include-input-ids", + action="store_true", + default=False, + help="Include input_ids in output of inference", ) + parser.add_argument("--results-path", type=Path, required=True, help="Path to the results directory.") parser.add_argument( "--num-gpus", type=int, @@ -211,6 +218,14 @@ def get_parser(): default=1, help="Number of nodes to use for training. Default is 1.", ) + parser.add_argument( + "--prediction-interval", + type=str, + required=False, + choices=get_args(IntervalT), + default="epoch", + help="Intervals to write DDP predictions into disk", + ) parser.add_argument( "--num-dataset-workers", type=int, diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py index 3252df2ced..d679eeb023 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py @@ -14,6 +14,7 @@ # limitations under the License. import math +import re import tarfile from copy import deepcopy from pathlib import Path @@ -260,6 +261,9 @@ def __getitem__(self, idx): return {"text": self.input_ids[idx], "attention_mask": self.mask[idx]} +@pytest.mark.xfail( + re.search(r"h[1-9]00", torch.cuda.get_device_name().lower()) is not None, reason="Known issue on H100 GPUs" +) def test_geneformer_nemo1_v_nemo2_inference_golden_values( geneformer_config: GeneformerConfig, cells: List[List[str]], seed: int = 42 ): diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py b/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py index 0b150255ed..e1b018cf63 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py @@ -49,6 +49,10 @@ def padding_collate_fn( """ global _warned_once keys: set[str] | None = None + + if len(batch) == 0: # empty batches passed through in DDP inference + return {} + for entry in batch: # First check that we have sane batches where keys align with each other. if keys is None: diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py index 5219d830f9..baf5e72bde 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py @@ -177,8 +177,7 @@ def forward(self, batch: DataT, forward_out: DataT) -> Tuple[Tensor, DataT]: Returns: A tuple containing the loss tensor (dummy in this case) and the forward output (unmodified). """ - dtype, device = get_dtype_device(forward_out) - return torch.zeros(1, device=device, dtype=dtype), forward_out + return torch.zeros((1, 1)), forward_out def reduce(self, forward_out: List[DataT]) -> DataT: """Collates list of model's outputs into a single output.""" @@ -313,6 +312,8 @@ def validation_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: def predict_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: """Alias for forward_step.""" + if len(batch) == 0: + return return self.forward_step(batch) def training_loss_reduction(self) -> MegatronLossType: diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py new file mode 100644 index 0000000000..9f835dff2e --- /dev/null +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py @@ -0,0 +1,100 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import logging +import os +from typing import Any, Literal, Sequence + +import lightning.pytorch as pl +import torch +from lightning.pytorch.callbacks import BasePredictionWriter + +from bionemo.llm.lightning import batch_collator + + +IntervalT = Literal["epoch", "batch"] + + +class PredictionWriter(BasePredictionWriter, pl.Callback): + """A callback that writes predictions to disk at specified intervals during training.""" + + def __init__(self, output_dir: str | os.PathLike, write_interval: IntervalT): + """Initializes the callback. + + Args: + output_dir: The directory where predictions will be written. + write_interval: The interval at which predictions will be written. (batch, epoch) + + """ + super().__init__(write_interval) + self.output_dir = str(output_dir) + + def write_on_batch_end( + self, + trainer: pl.Trainer, + pl_module: pl.LightningModule, + prediction: Any, + batch_indices: Sequence[int], + batch: Any, + batch_idx: int, + dataloader_idx: int, + ) -> None: + """Writes predictions to disk at the end of each batch. + + Args: + trainer: The Trainer instance. + pl_module: The LightningModule instance. + prediction: The prediction made by the model. + batch_indices: The indices of the batch. + batch: The batch data. + batch_idx: The index of the batch. + dataloader_idx: The index of the dataloader. + """ + # this will create N (num processes) files in `output_dir` each containing + # the predictions of it's respective rank + result_path = os.path.join(self.output_dir, f"predictions__rank_{trainer.global_rank}__batch_{batch_idx}.pt") + + # batch_indices is not captured due to a lightning bug when return_predictions = False + # we use input IDs in the prediction to map the result to input + torch.save(prediction, result_path) + logging.info(f"Inference predictions are stored in {result_path}\n{prediction.keys()}") + + def write_on_epoch_end( + self, + trainer: pl.Trainer, + pl_module: pl.LightningModule, + predictions: Any, + batch_indices: Sequence[int], + ) -> None: + """Writes predictions to disk at the end of each epoch. + + Args: + trainer: The Trainer instance. + pl_module: The LightningModule instance. + predictions: The predictions made by the model. + batch_indices: The indices of the batch. + """ + # this will create N (num processes) files in `output_dir` each containing + # the predictions of it's respective rank + result_path = os.path.join(self.output_dir, f"predictions__rank_{trainer.global_rank}.pt") + + # collate multiple batches / ignore empty ones + prediction = batch_collator([item for item in predictions if item is not None]) + + # batch_indices is not captured due to a lightning bug when return_predictions = False + # we use input IDs in the prediction to map the result to input + torch.save(prediction, result_path) + logging.info(f"Inference predictions are stored in {result_path}\n{prediction.keys()}") diff --git a/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_callbacks.py b/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_callbacks.py new file mode 100644 index 0000000000..e29af872d0 --- /dev/null +++ b/sub-packages/bionemo-llm/tests/bionemo/llm/utils/test_callbacks.py @@ -0,0 +1,110 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import os +from unittest.mock import MagicMock, patch + +import pytest +import pytorch_lightning as pl +import torch + +from bionemo.llm.lightning import batch_collator +from bionemo.llm.utils.callbacks import PredictionWriter + + +# Fixture for temporary directory +@pytest.fixture +def temp_dir(tmp_path): + return str(tmp_path) + + +@pytest.fixture +def mock_trainer(): + trainer = MagicMock(spec=pl.Trainer) + trainer.global_rank = 0 + return trainer + + +@pytest.fixture +def mock_module(): + return MagicMock(spec=pl.LightningModule) + + +@pytest.fixture +def sample_predictions(): + return [{"temp": torch.tensor([1, 2, 3])}, {"temp": torch.tensor([4, 5, 6])}, None] + + +@pytest.fixture +def collated_prediction(sample_predictions): + return batch_collator([item for item in sample_predictions if item is not None]) + + +@pytest.mark.parametrize("write_interval", ["batch", "epoch"]) +def test_prediction_writer_init(temp_dir, write_interval): + writer = PredictionWriter(output_dir=temp_dir, write_interval=write_interval) + assert writer.output_dir == temp_dir + if write_interval == "batch": + assert writer.interval.on_batch + if write_interval == "epoch": + assert writer.interval.on_epoch + + +@patch("torch.save") +def test_write_on_batch_end(mock_torch_save, temp_dir, mock_trainer, mock_module, collated_prediction): + writer = PredictionWriter(output_dir=temp_dir, write_interval="batch") + + batch_idx = 1 + writer.write_on_batch_end( + trainer=mock_trainer, + pl_module=mock_module, + prediction=collated_prediction, + batch_indices=[], + batch=None, + batch_idx=batch_idx, + dataloader_idx=0, + ) + + expected_path = os.path.join(temp_dir, f"predictions__rank_{mock_trainer.global_rank}__batch_{batch_idx}.pt") + mock_torch_save.assert_called_once_with(collated_prediction, expected_path) + + +@patch("torch.save") +def test_write_on_epoch_end( + mock_torch_save, temp_dir, mock_trainer, mock_module, sample_predictions, collated_prediction +): + writer = PredictionWriter(output_dir=temp_dir, write_interval="epoch") + + writer.write_on_epoch_end( + trainer=mock_trainer, + pl_module=mock_module, + predictions=sample_predictions, + batch_indices=[], + ) + + expected_path = os.path.join(temp_dir, f"predictions__rank_{mock_trainer.global_rank}.pt") + + mock_torch_save.assert_called_once() # Ensure it's called exactly once + + # Extract the actual call arguments + actual_args, actual_kwargs = mock_torch_save.call_args + prediction = actual_args[0] + assert actual_args[1] == expected_path, "Paths do not match" + + # Compare tensors manually + assert isinstance(prediction, dict) + for key in prediction: + assert torch.equal(prediction[key], collated_prediction[key]), "Tensors do not match" diff --git a/sub-packages/bionemo-noodles/rust/src/lib.rs b/sub-packages/bionemo-noodles/rust/src/lib.rs index 04199345ea..28cd38fe76 100644 --- a/sub-packages/bionemo-noodles/rust/src/lib.rs +++ b/sub-packages/bionemo-noodles/rust/src/lib.rs @@ -128,8 +128,8 @@ impl PyIndexedMmapFastaReader { } #[staticmethod] - fn create_faidx(fasta_filename: &str) -> PyResult { - match IndexedMmapFastaReader::create_faidx(fasta_filename) { + fn create_faidx(fasta_filename: &str, force: bool) -> PyResult { + match IndexedMmapFastaReader::create_faidx(fasta_filename, force) { Ok(fai_filename) => Ok(fai_filename), Err(e) => { let py_err = match e.kind() { @@ -180,6 +180,10 @@ impl PyIndexedMmapFastaReader { fn noodles_fasta_wrapper(_: Python, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; + m.add_function(wrap_pyfunction!(complement_sequence, m)?)?; + m.add_function(wrap_pyfunction!(reverse_sequence, m)?)?; + m.add_function(wrap_pyfunction!(transcribe_sequence, m)?)?; + m.add_function(wrap_pyfunction!(back_transcribe_sequence, m)?)?; Ok(()) } @@ -220,7 +224,7 @@ impl IndexedMmapFastaReader { Ok(IndexedMmapFastaReader { mmap_reader, index }) } - fn create_faidx(fasta_filename: &str) -> std::io::Result { + fn create_faidx(fasta_filename: &str, force: bool) -> std::io::Result { let fasta_path = Path::new(fasta_filename); let index: fai::Index = fasta::io::index(fasta_path).map_err(|e| { std::io::Error::new( @@ -235,7 +239,7 @@ impl IndexedMmapFastaReader { let fai_filename = fasta_filename.to_string() + ".fai"; let fai_path = Path::new(&fai_filename); // Convert back to a Path - if fai_path.exists() { + if fai_path.exists() && !force { return Err(std::io::Error::new( std::io::ErrorKind::AlreadyExists, format!("Fai file {} already exists", fai_path.display()), @@ -260,10 +264,11 @@ impl IndexedMmapFastaReader { } fn new(fasta_path: &str, ignore_existing_fai: bool) -> std::io::Result { - if !ignore_existing_fai { + let fasta_fai_str = fasta_path.to_string() + ".fai"; + let fasta_fai_path = Path::new(&fasta_fai_str); + if !ignore_existing_fai && fasta_fai_path.exists() { // load the .fai files if they exist - let fasta_fai_path = fasta_path.to_string() + ".fai"; - Self::from_fasta_and_faidx(fasta_path, &fasta_fai_path as &str) + Self::from_fasta_and_faidx(fasta_path, &fasta_fai_str) } else { Self::from_fasta(fasta_path) } @@ -353,6 +358,35 @@ fn read_sequence_mmap(index: &fai::Index, reader: &Mmap, region_str: &str) -> io return Ok(result); } +#[pyfunction] +fn reverse_sequence(s: &str) -> String { + return s.chars().rev().collect(); +} + +#[pyfunction] +fn complement_sequence(s: &str) -> String { + // Produces a complement of the input DNA sequence + s.chars() + .map(|c| match c { + 'A' => 'T', + 'T' => 'A', + 'C' => 'G', + 'G' => 'C', + _ => c, // Keeps unknown characters unchanged + }) + .collect() +} + +#[pyfunction] +fn transcribe_sequence(s: &str) -> String { + s.replace("T", "U") +} + +#[pyfunction] +fn back_transcribe_sequence(s: &str) -> String { + s.replace("U", "T") +} + /// Compute the number of bytes from start to the end of the line, half interval. /// this means the returned position will the byte offset of a newline. fn bases_remaining_in_first_line_read( @@ -615,17 +649,38 @@ fn test_mmap_reads() { // Note these are the same tests we use in python, but having them here can prevent us from building a wheel with broken code. assert_eq!(reader.read_sequence_mmap("chr1:1-1").unwrap(), "A"); assert_eq!(reader.read_sequence_mmap("chr1:1-2").unwrap(), "AC"); - assert_eq!(reader.read_sequence_mmap("chr1:1-100000").unwrap(), "ACTGACTGACTG"); + assert_eq!( + reader.read_sequence_mmap("chr1:1-100000").unwrap(), + "ACTGACTGACTG" + ); assert_eq!(reader.read_sequence_mmap("chr2:1-2").unwrap(), "GG"); - assert_eq!(reader.read_sequence_mmap("chr2:1-1000000").unwrap(), "GGTCAAGGTCAA"); + assert_eq!( + reader.read_sequence_mmap("chr2:1-1000000").unwrap(), + "GGTCAAGGTCAA" + ); //Recall to get python based assert_eq!(readering we add 1 to both start and end, so 1-13 is a 12 character string(full sequence) - assert_eq!(reader.read_sequence_mmap("chr2:1-11").unwrap(), "GGTCAAGGTCA"); - assert_eq!(reader.read_sequence_mmap("chr2:1-12").unwrap(), "GGTCAAGGTCAA"); - assert_eq!(reader.read_sequence_mmap("chr2:1-13").unwrap(), "GGTCAAGGTCAA"); + assert_eq!( + reader.read_sequence_mmap("chr2:1-11").unwrap(), + "GGTCAAGGTCA" + ); + assert_eq!( + reader.read_sequence_mmap("chr2:1-12").unwrap(), + "GGTCAAGGTCAA" + ); + assert_eq!( + reader.read_sequence_mmap("chr2:1-13").unwrap(), + "GGTCAAGGTCAA" + ); assert_eq!(reader.read_sequence_mmap("chr3:1-2").unwrap(), "AG"); - assert_eq!(reader.read_sequence_mmap("chr3:1-13").unwrap(), "AGTCAAGGTCCAC"); - assert_eq!(reader.read_sequence_mmap("chr3:1-14").unwrap(), "AGTCAAGGTCCACG"); // adds first character from next line + assert_eq!( + reader.read_sequence_mmap("chr3:1-13").unwrap(), + "AGTCAAGGTCCAC" + ); + assert_eq!( + reader.read_sequence_mmap("chr3:1-14").unwrap(), + "AGTCAAGGTCCACG" + ); // adds first character from next line assert_eq!( reader.read_sequence_mmap("chr3:1-83").unwrap(), "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCA" @@ -648,15 +703,58 @@ fn test_mmap_reads() { // Handles end of multi line but non-full sequence entry // Full sequence - assert_eq!(reader.read_sequence_mmap("chr4:1-16").unwrap(), "CCCCCCCCCCCCACGT"); - assert_eq!(reader.read_sequence_mmap("chr4:1-17").unwrap(), "CCCCCCCCCCCCACGT"); + assert_eq!( + reader.read_sequence_mmap("chr4:1-16").unwrap(), + "CCCCCCCCCCCCACGT" + ); + assert_eq!( + reader.read_sequence_mmap("chr4:1-17").unwrap(), + "CCCCCCCCCCCCACGT" + ); assert_eq!( reader.read_sequence_mmap("chr4:1-1000000").unwrap(), "CCCCCCCCCCCCACGT" ); - assert_eq!(reader.read_sequence_mmap("chr4:1-17").unwrap(), "CCCCCCCCCCCCACGT"); + assert_eq!( + reader.read_sequence_mmap("chr4:1-17").unwrap(), + "CCCCCCCCCCCCACGT" + ); - assert_eq!(reader.read_sequence_mmap("chr4:3-16").unwrap(), "CCCCCCCCCCACGT"); + assert_eq!( + reader.read_sequence_mmap("chr4:3-16").unwrap(), + "CCCCCCCCCCACGT" + ); assert_eq!(reader.read_sequence_mmap("chr4:17-17").unwrap(), ""); } + +#[test] +fn test_reverse_sequence() { + assert_eq!(reverse_sequence("ACGTACGTACGT"), "TGCATGCATGCA"); +} + +#[test] +fn test_complement_sequence() { + // test simple complement + assert_eq!(complement_sequence("ACGTACGTACGT"), "TGCATGCATGCA"); + // test identity + assert_eq!( + complement_sequence(&complement_sequence("ACGTACGTACGT")), + "ACGTACGTACGT" + ); +} + +#[test] +fn test_transcribe_sequence() { + assert_eq!(transcribe_sequence("ACGTACGTACGT"), "ACGUACGUACGU"); + // test identity + assert_eq!( + back_transcribe_sequence(&transcribe_sequence("ACGTACGTACGT")), + "ACGTACGTACGT" + ); +} + +#[test] +fn test_back_transcribe_sequence() { + assert_eq!(back_transcribe_sequence("ACGUACGUACGU"), "ACGTACGTACGT"); +} diff --git a/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py b/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py index 82cb0023a7..53d2ead084 100644 --- a/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py +++ b/sub-packages/bionemo-noodles/src/bionemo/noodles/__init__.py @@ -13,7 +13,21 @@ # See the License for the specific language governing permissions and # limitations under the License. -from bionemo.noodles_fasta_wrapper import PyFaidxRecord, PyIndexedMmapFastaReader +from bionemo.noodles_fasta_wrapper import ( + PyFaidxRecord, + PyIndexedMmapFastaReader, + back_transcribe_sequence, + complement_sequence, + reverse_sequence, + transcribe_sequence, +) -__all__ = ("PyFaidxRecord", "PyIndexedMmapFastaReader") +__all__ = ( + "PyFaidxRecord", + "PyIndexedMmapFastaReader", + "reverse_sequence", + "complement_sequence", + "transcribe_sequence", + "back_transcribe_sequence", +) diff --git a/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py b/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py index 938b1793fc..cd44ab1d49 100644 --- a/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py +++ b/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py @@ -33,7 +33,16 @@ class SequenceAccessor: """ def __init__(self, reader: PyIndexedMmapFastaReader, seqid: str, length: int) -> None: - """Construct a SequenceAccessor object. + """Construct a SequenceAccessor object. Ultimately this is used as a convenience object with NvFaidx. + + When querying the following are true: + - Negative indexing is supported, but it does not wrap. so query[-10000] for a sequence of length 1 will fail. + - out of bounds indexing is truncated: query[1:999999999] will return a string from position 1 to the terminus. + - reversed slices return the empty string: query[999:1] is the empty string. + - empty slice returns the full string: query[:] is the full string of the sequence. + - beginning of slice is beyond the range of the contig, the empty string is returned. + + Additionally there are convenience methods that you may find useful in the class definition. Args: reader (PyIndexedMmapFastaReader): The indexed reader object that provides access to the underlying FASTA file. @@ -84,10 +93,39 @@ def __getitem__(self, key: int | slice) -> str: # noqa: D105 else: raise TypeError("Index must be an integer or a slice.") + def __len__(self) -> int: # noqa: D105 + return self.length + + def sequence_id(self) -> str: + """Returns the sequenceid of this SequenceAccessor.""" + return self.seqid + + def sequence(self) -> str: + """Returns the sequence associated with this SequenceAccessor as a string.""" + return self[:] + class NvFaidx: """NvFaidx is a rest + pyo3 replacement for PyFaidx that provides a dictionary-like interface to reference genomes. + This class is a collection of SequenceAccessors, organized by sequence-id in a dictionary like manner. SequenceAcecessors + are similar dict-like interfaces over actual sequence entries in the underlying index. Furthermore, utilities are provided + for parsing faidx files, building faidx files, and storing faidx files to disk. + + **IMPORTANT** by default all fasta files build an in-memory faidx object. This is due easy mistakes that may occur + if a faidx file is constructed while using multi-processing (such as a default constructor that creates these files on the fly). + However, methods exist to create these methods manually where a user has more control over multiprocessing. + + Examples: + >>> index = NvFaidx(fasta_file, faidx_path=None, ignore_existing_fai=True) + >>> index['chr1'] # Returns a SequenceAccessor for chr1 + >>> index['chr1'][0:10] # Returns the first 10 bases of chr1. + >>> faidx_filename = NvFaidx.create_faidx(fasta_file) # Creates a faidx to disk. + >>> index = NvFaidx(fasta_File, faidx_filename, ignore_existing_fai = True) # Uses a faidx from disk. + + + Motivation and more details: + NvFaidx is built using Noodles as a backend for Fai objects, and memory maps for backing the underlying fasta. Using a backend of Memmaps provide the following benefits: - The kernel implements this mechanism by using page faults @@ -105,6 +143,8 @@ class NvFaidx: where all workers block until it is complete (not implemented above) 2) Index object instantion must be fast. 3) Read-only use of the index object must be both thread safe and process safe with python. + + See Also: bionemo.noodles.nvfaidx.SequenceAccessor """ def __init__(self, fasta_path: str | Path, faidx_path: Optional[str | Path] = None, ignore_existing_fai=True): @@ -126,13 +166,17 @@ def __init__(self, fasta_path: str | Path, faidx_path: Optional[str | Path] = No elif not isinstance(faidx_path, str) and faidx_path is not None: raise TypeError(f"faidx_path must be a `str`, `pathlib.Path`, or None. got: {type(faidx_path)}") - if ignore_existing_fai: - self.reader = PyIndexedMmapFastaReader(fasta_path, ignore_existing_fai=ignore_existing_fai) - elif faidx_path is not None: - self.reader = PyIndexedMmapFastaReader.from_fasta_and_faidx(fasta_path, faidx_path) - else: - # Builds a FAIDX object in memory by default. - self.reader = PyIndexedMmapFastaReader(fasta_path) + match (fasta_path, faidx_path, ignore_existing_fai): + case (_, _, True): + self.reader = PyIndexedMmapFastaReader(fasta_path, ignore_existing_fai=ignore_existing_fai) + case (_, faidx_path, _) if faidx_path is not None: + self.reader = PyIndexedMmapFastaReader.from_fasta_and_faidx(fasta_path, faidx_path) + # In this case, faidx path is None and ignore_existing is False, and it covers all other cases. + case (_, None, False): + # But the logic here doesnt make sense, ignore_existing is false, but it should only use if it if it exists. + self.reader = PyIndexedMmapFastaReader(fasta_path, False) + case _: + raise ValueError("unreachable condition.") self.records: Dict[str, PyFaidxRecord] = {record.name: record for record in self.reader.records()} @@ -153,13 +197,26 @@ def __len__(self) -> int: # noqa: D105 def keys(self) -> set[str]: # noqa: D102 return set(self.records.keys()) + # These provide dict like iteration functionality + def __iter__(self): # noqa: D105 + return iter(self.keys()) + + def items(self): # noqa: D102 + for key in self.keys(): + yield key, self[key][:] + + def values(self): # noqa: D102 + for key in self.keys(): + yield self[key][:] + @staticmethod - def create_faidx(fasta_filename: str | Path) -> str: + def create_faidx(fasta_filename: str | Path, force: bool = False) -> str: """Create a FAI index for a FASTA file, the result is saved in the same location as `fasta_filename`, with a .fai extension. Args: fasta_filename (str): Path to the FASTA file to be indexed. + force (bool): Delete existing faidx file and create a new index file. """ if isinstance(fasta_filename, Path): fasta_filename = str(fasta_filename) - return PyIndexedMmapFastaReader.create_faidx(fasta_filename) + return PyIndexedMmapFastaReader.create_faidx(fasta_filename, force) diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py index bba6414642..c273370efd 100644 --- a/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py @@ -32,9 +32,9 @@ def sample_fasta(): return str(pathlib.Path(__file__).parent.parent.parent / "bionemo/noodles/data/sample.fasta") -def test_create_faidx(): +def test_create_faidx_rustbind(): filename = create_test_fasta(num_seqs=2, seq_length=200) - faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename) + faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename, force=False) assert os.path.exists(faidx_filename) assert faidx_filename == filename + ".fai" @@ -48,7 +48,7 @@ def test_create_faidx(): def test_from_fasta_and_faidx_no_such_faidx(): filename = create_test_fasta(num_seqs=2, seq_length=200) - faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename) + faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename, force=False) os.remove(faidx_filename) # And this should fail. with pytest.raises(FileNotFoundError): @@ -58,7 +58,7 @@ def test_from_fasta_and_faidx_no_such_faidx(): def test_from_fasta_and_faidx(): # Smoke test, this should all work filename = create_test_fasta(num_seqs=2, seq_length=200) - faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename) + faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename, force=False) index = PyIndexedMmapFastaReader.from_fasta_and_faidx(filename, faidx_filename) index2 = PyIndexedMmapFastaReader(filename, ignore_existing_fai=True) # Test against constructor for equivalence. @@ -129,6 +129,67 @@ def test_memmap_index(sample_fasta): assert index.read_sequence_mmap("chr4:17-17") == "" +def test_len(sample_fasta): + index = NvFaidx(sample_fasta) + assert len(index) == 5 + + +def test_contains(sample_fasta): + index = NvFaidx(sample_fasta) + for i in range(1, 6): + assert f"chr{i}" in index + + +def test_create_faidx_nvfaidx(sample_fasta): + test_fasta_fn = create_test_fasta() + + faidx_fn = NvFaidx(test_fasta_fn, None, ignore_existing_fai=False) + + faidx_fn = NvFaidx.create_faidx(test_fasta_fn, force=False) + _ = NvFaidx(sample_fasta, faidx_path=faidx_fn, ignore_existing_fai=False) + assert os.path.exists(faidx_fn) + + faidx_fn = NvFaidx.create_faidx(test_fasta_fn, force=True) + _ = NvFaidx(sample_fasta, faidx_path=faidx_fn, ignore_existing_fai=False) + assert os.path.exists(faidx_fn) + + with pytest.raises(FileExistsError): + faidx_fn = NvFaidx.create_faidx(test_fasta_fn, force=False) + + _ = NvFaidx(sample_fasta, faidx_path=faidx_fn, ignore_existing_fai=False) + + +def test_iter_all_id_seqs(sample_fasta): + expected = { + "chr1": "ACTGACTGACTG", + "chr2": "GGTCAAGGTCAA", + "chr3": "AGTCAAGGTCCACGTCAAGGTCCCGGTCAAGGTCCGTGTCAAGGTCCTAGTCAAGGTCAACGTCAAGGTCACGGTCAAGGTCAG", + "chr4": "CCCCCCCCCCCCACGT", + "chr5": "A", + } + fasta_path = sample_fasta + index = NvFaidx(fasta_path) + for seq_id in index: + full_seq = index[seq_id][:] + assert full_seq == expected[seq_id], seq_id + + for seq_id in index.keys(): + full_seq = index[seq_id][:] + assert full_seq == expected[seq_id], seq_id + + # Same test different syntax + for seq_id in index.keys(): + assert index[seq_id].sequence() == expected[seq_id], seq_id + + for_next_test = [] + for seq_id, full_seq in index.items(): + assert full_seq == expected[seq_id], seq_id + for_next_test.append(full_seq) + + for full_seq, seq_via_items in zip(index.values(), for_next_test): + assert full_seq == seq_via_items + + def test_getitem_bounds(sample_fasta): # NOTE make this the correct path, check this file in since we are checking exactness of queries. index = NvFaidx(sample_fasta) @@ -140,10 +201,21 @@ def test_getitem_bounds(sample_fasta): assert index["chr1"][1:10000] == "CTGACTGACTG" # Slice up to the last element assert index["chr1"][0:-1] == "ACTGACTGACT" + # Get the full sequence + assert index["chr1"][:] == "ACTGACTGACTG" # equivalent to above assert index["chr1"][:-1] == "ACTGACTGACT" # -1 should get the last element assert index["chr1"][-1:] == "G" + # non slices return empty string + assert index["chr1"][100:1] == "" + # Negative integer indexing is allowed. + assert index["chr1"][-1] == "G" + assert index["chr1"][-1 * len(index["chr1"])] == "A" + + with pytest.raises(IndexError): + # Negative indexing is not allowed to wrap + index["chr1"][-1000000] # Invalid contig should throw an exception with pytest.raises(KeyError): @@ -191,6 +263,8 @@ def _test_faidx_generic(faidx_obj): # Should see this is out of bounds and return empty or throw an error assert index["chr4"][17:17] == "" + assert index["chr4"][17:] == "" + def test_nvfaidx_python_interface(sample_fasta): nvfaidx_index = NvFaidx(sample_fasta) @@ -297,10 +371,9 @@ def test_file_errors(): # But if we create an index in memory, should work! _ = PyIndexedMmapFastaReader(test_fa, ignore_existing_fai=True) - # test failure due to lack of fai - with pytest.raises(FileNotFoundError): - new_test_fasta = create_test_fasta(num_seqs=1, seq_length=200) - _ = PyIndexedMmapFastaReader(new_test_fasta, ignore_existing_fai=False) + # Should work because 'ignore' implies it only occurs with the fai exists. + new_test_fasta = create_test_fasta(num_seqs=1, seq_length=200) + _ = PyIndexedMmapFastaReader(new_test_fasta, ignore_existing_fai=False) ## Benchmarks diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_sequence_ops.py b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_sequence_ops.py new file mode 100644 index 0000000000..06a494b4fd --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_sequence_ops.py @@ -0,0 +1,159 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import os +import pathlib +import random +import tempfile +import time +from collections import defaultdict + +import pytest + +from bionemo.noodles import back_transcribe_sequence, complement_sequence, reverse_sequence, transcribe_sequence +from bionemo.noodles.nvfaidx import NvFaidx + + +@pytest.fixture +def sample_fasta(): + return str(pathlib.Path(__file__).parent.parent.parent / "bionemo/noodles/data/sample.fasta") + + +def test_reverse_sequence(): + assert reverse_sequence("ACGTACGTACGT") == "TGCATGCATGCA" + + +def test_reverse_sequence_equivalence(sample_fasta): + idx = NvFaidx(sample_fasta) + + # compare to results generated from biopython: + assert reverse_sequence(idx["chr1"].sequence()) == "GTCAGTCAGTCA" + assert complement_sequence(idx["chr1"].sequence()) == "TGACTGACTGAC" + assert transcribe_sequence(idx["chr1"].sequence()) == "ACUGACUGACUG" + assert back_transcribe_sequence(idx["chr1"].sequence()) == "ACTGACTGACTG" + + +@pytest.mark.skip("Requires Biopython") +def test_benchmark_vs_biopython(): + """Must install biopython to actually run this. Timings below. + reverse 0.0005855560302734375 1.9788742065429688e-05 29.59036144578313 + transcribe 0.0012478828430175781 4.1961669921875e-05 29.738636363636363 + back_transcribe 9.417533874511719e-05 8.821487426757812e-06 10.675675675675675 + complement 0.0005459785461425781 8.416175842285156e-05 6.4872521246458925 + """ + from Bio import SeqIO + + test_fasta = create_test_fasta(num_seqs=100, seq_length=10000) + fasta_biop = SeqIO.parse(test_fasta, "fasta") + # Time transcribe + results = defaultdict(lambda: 0.0) + for record in fasta_biop: + start = time.time() + record.seq[::-1] + end = time.time() + results["reverse"] += end - start + + start = time.time() + record.seq.transcribe() + end = time.time() + results["transcribe"] += end - start + + start = time.time() + record.seq.back_transcribe() + end = time.time() + results["back_transcribe"] += end - start + + start = time.time() + record.seq.complement() + end = time.time() + results["complement"] += end - start + + biop_results = results + + idx = NvFaidx(test_fasta) + results = defaultdict(lambda: 0.0) + for seq in idx.values(): + start = time.time() + reverse_sequence(seq) + end = time.time() + results["reverse"] = end - start + + start = time.time() + transcribe_sequence(seq) + end = time.time() + results["transcribe"] = end - start + + start = time.time() + back_transcribe_sequence(seq) + end = time.time() + results["back_transcribe"] = end - start + + start = time.time() + complement_sequence(seq) + end = time.time() + results["complement"] = end - start + + noodles_results = results + print("func", "biopython-time", "noodles-time", "noodles-speedup") + for key in results: + biop, noodles = biop_results[key], noodles_results[key] + print(key, biop, noodles, biop / noodles) + assert biop / noodles > 1 + assert False # So they print out + + +def test_complement_sequence(): + assert complement_sequence("ACGTACGTACGT") == "TGCATGCATGCA" + assert complement_sequence(complement_sequence("ACGTACGTACGT")) == "ACGTACGTACGT" + + +def test_transcribe_sequence(): + assert transcribe_sequence("ACGTACGTACGT") == "ACGUACGUACGU" + assert back_transcribe_sequence(transcribe_sequence("ACGTACGTACGT")) == "ACGTACGTACGT" + + +def test_back_transcribe_sequence(): + assert back_transcribe_sequence("ACGUACGUACGU") == "ACGTACGTACGT" + assert transcribe_sequence(back_transcribe_sequence("ACGUACGUACGU")) == "ACGUACGUACGU" + + +def create_test_fasta(num_seqs=2, seq_length=1000): + """ + Creates a FASTA file with random sequences. + + Args: + num_seqs (int): Number of sequences to include in the FASTA file. + seq_length (int): Length of each sequence. + + Returns: + str: File path to the generated FASTA file. + """ + temp_dir = tempfile.mkdtemp() + fasta_path = os.path.join(temp_dir, "test.fasta") + + with open(fasta_path, "w") as fasta_file: + for i in range(1, num_seqs + 1): + # Write the header + fasta_file.write(f">contig{i}\n") + + # Generate a random sequence of the specified length + sequence = "".join(random.choices("ACGT", k=seq_length)) + + # Split the sequence into lines of 60 characters for FASTA formatting + for j in range(0, len(sequence), 80): + fasta_file.write(sequence[j : j + 80] + "\n") + + return fasta_path diff --git a/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py b/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py index 65faa129f5..e7fd99438d 100644 --- a/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py +++ b/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py @@ -28,6 +28,20 @@ __all__: Sequence[str] = ("RowFeatureIndex",) +def are_dicts_equal(dict1: dict[str, np.ndarray], dict2: dict[str, np.ndarray]) -> bool: + """Compare two dictionaries with string keys and numpy.ndarray values. + + Args: + dict1 (dict[str, np.ndarray]): The first dictionary to compare. + dict2 (dict[str, np.ndarray]): The second dictionary to compare. + + Returns: + bool: True if the dictionaries have the same keys and all corresponding + numpy arrays are equal; False otherwise. + """ + return dict1.keys() == dict2.keys() and all(np.array_equal(dict1[k], dict2[k]) for k in dict1) + + class RowFeatureIndex: """Maintains a mapping between a row and its features. @@ -100,10 +114,16 @@ def append_features( if isinstance(features, pd.DataFrame): raise TypeError("Expected a dictionary, but received a Pandas DataFrame.") csum = max(self._cumulative_sum_index[-1], 0) - self._cumulative_sum_index = np.append(self._cumulative_sum_index, csum + n_obs) - self._feature_arr.append(features) - self._num_genes_per_row.append(num_genes) - self._labels.append(label) + + # If the new feature array is identical to the last one, it is not appended. Instead, the last array accounts + # for the additional n_obs also. + if len(self._feature_arr) > 0 and are_dicts_equal(self._feature_arr[-1], features): + self._cumulative_sum_index[-1] = csum + n_obs + else: + self._cumulative_sum_index = np.append(self._cumulative_sum_index, csum + n_obs) + self._feature_arr.append(features) + self._num_genes_per_row.append(num_genes) + self._labels.append(label) def lookup(self, row: int, select_features: Optional[list[str]] = None) -> Tuple[list[np.ndarray], str]: """Find the features at a given row. diff --git a/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py b/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py index e1fd5a0e7e..c18ca2ef5f 100644 --- a/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py +++ b/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py @@ -20,7 +20,32 @@ import pandas as pd import pytest -from bionemo.scdl.index.row_feature_index import RowFeatureIndex +from bionemo.scdl.index.row_feature_index import RowFeatureIndex, are_dicts_equal + + +def test_equal_dicts(): + dict1 = {"a": np.array([1, 2, 3]), "b": np.array([4, 5, 6])} + dict2 = {"a": np.array([1, 2, 3]), "b": np.array([4, 5, 6])} + assert are_dicts_equal(dict1, dict2) is True + + +def test_unequal_values(): + dict1 = {"a": np.array([1, 2, 3]), "b": np.array([4, 5, 6])} + dict3 = {"a": np.array([1, 2, 3]), "b": np.array([7, 8, 9])} + + assert are_dicts_equal(dict1, dict3) is False + + +def test_unequal_keys(): + dict1 = {"a": np.array([1, 2, 3]), "b": np.array([4, 5, 6])} + dict4 = {"a": np.array([1, 2, 3]), "c": np.array([4, 5, 6])} + assert are_dicts_equal(dict1, dict4) is False + + +def test_different_lengths(): + dict1 = {"a": np.array([1, 2, 3]), "b": np.array([4, 5, 6])} + smaller_dict = {"a": np.array([1, 2, 3])} + assert are_dicts_equal(dict1, smaller_dict) is False @pytest.fixture @@ -37,6 +62,20 @@ def create_first_RowFeatureIndex() -> RowFeatureIndex: return index +@pytest.fixture +def create_same_features_first_RowFeatureIndex() -> RowFeatureIndex: + """ + Instantiate a RowFeatureIndex. + + Returns: + A RowFeatureIndex with known values. + """ + one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} + index = RowFeatureIndex() + index.append_features(6, one_feats, len(one_feats["feature_name"])) + return index + + @pytest.fixture def create_second_RowFeatureIndex() -> RowFeatureIndex: """ @@ -86,14 +125,17 @@ def test_feature_index_internals_on_single_index(create_first_RowFeatureIndex): assert len(vals) == 1 -def test_feature_index_internals_on_append(create_first_RowFeatureIndex): +def test_feature_index_internals_on_append_different_features( + create_first_RowFeatureIndex, create_second_RowFeatureIndex +): one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} two_feats = { "feature_name": np.array(["FF", "GG", "HH", "II", "ZZ"]), "gene_name": np.array(["RET", "NTRK", "PPARG", "TSHR", "EGFR"]), "spare": np.array([None, None, None, None, None]), } - create_first_RowFeatureIndex.append_features(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") + create_first_RowFeatureIndex.concat(create_second_RowFeatureIndex) + # append(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") assert len(create_first_RowFeatureIndex) == 2 assert create_first_RowFeatureIndex.number_vars_at_row(1) == 3 assert create_first_RowFeatureIndex.number_vars_at_row(13) == 5 @@ -113,6 +155,28 @@ def test_feature_index_internals_on_append(create_first_RowFeatureIndex): assert label == "MY_DATAFRAME" +def test_feature_index_internals_on_append_same_features(create_first_RowFeatureIndex): + one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} + create_first_RowFeatureIndex.concat(create_first_RowFeatureIndex) + # append(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") + assert len(create_first_RowFeatureIndex) == 1 + assert create_first_RowFeatureIndex.number_vars_at_row(1) == 3 + assert create_first_RowFeatureIndex.number_vars_at_row(13) == 3 + assert create_first_RowFeatureIndex.number_vars_at_row(19) == 3 + assert create_first_RowFeatureIndex.number_vars_at_row(2) == 3 + assert sum(create_first_RowFeatureIndex.number_of_values()) == 2 * (12 * 3) + assert create_first_RowFeatureIndex.number_of_values()[0] == 2 * (12 * 3) + assert create_first_RowFeatureIndex.number_of_rows() == 24 + feats, label = create_first_RowFeatureIndex.lookup(row=3, select_features=None) + assert np.all(feats[0] == one_feats["feature_name"]) + assert np.all(feats[1] == one_feats["feature_int"]) + assert label is None + feats, label = create_first_RowFeatureIndex.lookup(row=15, select_features=None) + assert np.all(feats[0] == one_feats["feature_name"]) + assert np.all(feats[1] == one_feats["feature_int"]) + assert label is None + + def test_concat_length( create_first_RowFeatureIndex, create_second_RowFeatureIndex, From 5511fe7e9f8cc9d38a51319404e712ac6edc89ef Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Thu, 2 Jan 2025 17:41:28 -0800 Subject: [PATCH 013/140] [cye/lineage-str] Clean up interface for taxonomic lineage tokens in Hyena. --- sub-packages/bionemo-evo2/README.md | 2 +- .../bionemo-evo2/src/bionemo/evo2/README.md | 2 +- .../src/bionemo/evo2/data/README.md | 36 +- .../src/bionemo/evo2/data/preprocess.py | 430 +++++++++--------- .../bionemo/evo2/data/resources/__init__.py | 14 - .../evo2/data/resources/phyla_kingdom_map.py | 71 --- .../src/bionemo/evo2/data/tokenizer.py | 16 +- .../src/bionemo/evo2/utils/config.py | 34 +- .../src/bionemo/evo2/utils/torch2nemo.py | 289 ------------ sub-packages/bionemo-evo2/tests/README.md | 2 +- .../tests/config/test_preproc_config.yaml | 28 +- 11 files changed, 305 insertions(+), 619 deletions(-) delete mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py delete mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py delete mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 39916f40d4..9a2fe90c54 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -1 +1 @@ -Library containing data preprocessing, training, and inference tooling for Evo2. +Library containing data preprocessing, training, and inference tooling for StripedHyena2. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md index 982a6ec28d..34f2831bed 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md @@ -1 +1 @@ -Source code for BioNeMo Evo2. +Source code for BioNeMo StripedHyena2. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md index 0a64e3596a..4a1a59b4c7 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md @@ -23,44 +23,54 @@ $ ls -lah Next we acquired the `fasta` file that was used to generate this and placed it into the tests/data folder of this sub-package. ```yaml -- datapaths: ["sub-packages/bionemo-evo2/tests/data/mmseqs_results_rep_seq.fasta"] - output_dir: "sub-packages/bionemo-evo2/tests/data" - output_prefix: promoters_ab_test +- datapaths: ["/workspace/bionemo2/data/mmseqs_results_rep_seq_distinct.fasta"] + output_dir: "/workspace/bionemo2/data" + output_prefix: promoters_ab_test_noodles_uint8_distinct # Datasplit - train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training, will verify this manually + train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training valid_split: 0.0 test_split: 0.0 - # Evo Taxonomy - taxonomy_path: null + # Overwrite existing binaries. Otherwise, skip already preprocessed datasets. + overwrite: True # Raw Preprocessing Transforms - gzip_data: false embed_reverse_complement: true - random_reverse_complement: false - subsequence_length: null + random_reverse_complement: 0.5 + random_lineage_dropout: 0.1 include_sequence_id: false transcribe: "back_transcribe" force_uppercase: true + indexed_dataset_dtype: "uint8" # Tokenizer tokenizer_type: "Byte-Level" - # None of the following tokenization params matters for this byte-level dataset for META/optimal Evo2 specifically. vocab_file: null vocab_size: null merges_file: null + # Either a named pretrained tokenizer model, or a path to a SentencePiece tokenizer. pretrained_tokenizer_model: null special_tokens: null fast_hf_tokenizer: true - append_eod: true # except this, this matters + append_eod: true enforce_sample_length: null - indexed_dataset_dtype: "uint8" ftfy: false # Compute workers: 1 - preproc_concurrency: 10000 + preproc_concurrency: 100000 + chunksize: 25 # Filters drop_empty_sequences: true nnn_filter: true # RNG seed: 42 + # StipedHyena2 Taxonomic Lineage Tags + taxonomy_data: + FP002272: + kingdom: KINGDOM + phylum: PHYLUM + clazz: CLASS + order: ORDER + family: FAMILY + genus: GENUS + species: SPECIES ``` Finally we generated our own bin/idx file for in this case everything going into the training set. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index 381a3d532c..b503330157 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -22,10 +22,13 @@ import argparse import gzip import multiprocessing as mp +import os import random +import time from contextlib import contextmanager from pathlib import Path from threading import Semaphore +from typing import Optional import numpy as np import pandas as pd @@ -34,113 +37,187 @@ from megatron.core.datasets.indexed_dataset import IndexedDatasetBuilder from nemo.utils import logging -from bionemo.evo2.data.resources.phyla_kingdom_map import PHYLA_TO_KINGDOM -from bionemo.evo2.data.tokenizer import Evo2Tokenizer -from bionemo.evo2.utils.config import Evo2PreprocessingConfig +from bionemo.evo2.data.tokenizer import StripedHyena2Tokenizer +from bionemo.evo2.utils.config import StipedHyena2PreprocessingConfig, StripedHyena2TaxonomyLineage from bionemo.noodles import back_transcribe_sequence, complement_sequence, reverse_sequence, transcribe_sequence from bionemo.noodles.nvfaidx import NvFaidx -@contextmanager -def preprocessing_context_manager(seed: int | None = None): - """Context manager for Evo2 preprocessing RNG.""" - # Track current state. - current_state = random.getstate() - try: - # Set random seed. - random.seed(seed) - yield seed - finally: - # Restore random state. - random.setstate(current_state) - - -class Evo2Preprocessor: +class StipedHyena2Preprocessor: """Data preprocessing class for Evo2.""" - VBAR = "|" PROMPT_SPACER_LENGTH = 131_072 + BIN = ".bin" + IDX = ".idx" + TRAIN = "train" + VAL = "val" + TEST = "test" + + def __init__(self, params: StipedHyena2PreprocessingConfig | None = None): + """Initialize StipedHyena2Preprocessor.""" + self.tokenizer: StripedHyena2Tokenizer = StripedHyena2Tokenizer(params) - def __init__(self, params: Evo2PreprocessingConfig | None = None): - """Initialize Evo2Preprocessor.""" - self.params: Evo2PreprocessingConfig = params if params is not None else Evo2PreprocessingConfig() - self.tokenizer: Evo2Tokenizer = Evo2Tokenizer(self.params) - self.id_to_taxonomy: dict | None = ( - self._load_evo_taxonomy(self.params.taxonomy_path) if self.params.taxonomy_path is not None else None + @staticmethod + @contextmanager + def preprocessing_context_manager(seed: int | None = None): + """Context manager for Evo2 preprocessing RNG.""" + # Track current state. + current_state = random.getstate() + try: + # Set random seed. + random.seed(seed) + yield seed + finally: + # Restore random state. + random.setstate(current_state) + + @staticmethod + def _get_output_filename(config: StipedHyena2PreprocessingConfig, ext: str = None, split: str = None, temp: bool = False) -> Path: + # Get output directory. Defaults to CWD. + output_dir = config.output_dir + if output_dir is None: + output_dir = Path.cwd() + # Pickup output file prefix. + config_prefix = "{}_{}".format( + config.output_prefix, config.tokenizer_type.lower().replace(" ", "") ) + output_filepath = Path(output_dir) / (config_prefix + (f"_{split}" if split is not None else "") + (ext if ext is not None else "") + (".tmp" if temp else "")) + return output_filepath @staticmethod def _subsequence_generator(sequence: str, subsequence_length: int | None = None, offset: int | None = None): - subsequence_length = subsequence_length if isinstance(subsequence_length, int) else len(sequence) - step_size = offset if isinstance(offset, int) else subsequence_length + subsequence_length = subsequence_length if subsequence_length is not None else len(sequence) + step_size = offset if offset is not None else subsequence_length for i in range(0, len(sequence), step_size): yield sequence[i : i + subsequence_length] @staticmethod - def _random_reverse_complement(seq: str, prob: float = 0.5): - if random.random() < prob: - return complement_sequence(reverse_sequence(seq)) - else: - return seq + def _random_reverse_complement(seq: str, prob: float = 0.0, seed: int = None): + with StipedHyena2Preprocessor.preprocessing_context_manager( + seed if seed is not None else None + ): + if random.random() < prob: + return complement_sequence(reverse_sequence(seq)) + else: + return seq @staticmethod def _reverse_complement_expansion(seq: str): return [seq, complement_sequence(reverse_sequence(seq))] @staticmethod - def _train_val_test_split(train_weight: float, val_weight: float, test_weight: float): - # Generate random number. - roll = random.random() - # Rectify and normalize split ratios. - total_weight = abs(train_weight) + abs(val_weight) + abs(test_weight) - if total_weight <= 0: - raise ValueError("Train-validation-test split proportions cannot be zero.") - train_split = abs(train_weight) / total_weight - test_split = abs(test_weight) / total_weight - split = "train" - if roll > train_split: - if roll < 1 - test_split: - split = "val" - else: - split = "test" - return split + def _train_val_test_split(train_weight: float, val_weight: float, test_weight: float, seed: int = None): + with StipedHyena2Preprocessor.preprocessing_context_manager( + seed if seed is not None else None + ): + # Generate random number. + roll = random.random() + # Rectify and normalize split ratios. + total_weight = abs(train_weight) + abs(val_weight) + abs(test_weight) + if total_weight <= 0: + raise ValueError("Train-validation-test split proportions cannot be zero.") + train_split = abs(train_weight) / total_weight + test_split = abs(test_weight) / total_weight + split = "train" + if roll > train_split: + if roll < 1 - test_split: + split = "val" + else: + split = "test" + return split @staticmethod - def _get_evo_seq_id(filename: str): - """TODO(@cye) Consider deprecating the Taxonomy resources from Arc in favor of an explicit SeqID -> Taxonomy mapping via config.""" - try: - return ".".join(filename.split("/")[-1].split(".")[:-1]) - except Exception: - return None + def _construct_taxonomy_token(lineage: StripedHyena2TaxonomyLineage, dropout: float = 0.0, seed: int = None) -> Optional[str]: + """Construct a special Taxonomy token for natural language prompting of DNA generation models.""" + # If dropout > 0, randomly drop out segments of the lineage for training on incomplete lineages. + with StipedHyena2Preprocessor.preprocessing_context_manager( + seed if seed is not None else None + ): + return "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( + lineage.kingdom if random.random() >= dropout else None, + lineage.phylum if random.random() >= dropout else None, + lineage.clazz if random.random() >= dropout else None, + lineage.order if random.random() >= dropout else None, + lineage.family if random.random() >= dropout else None, + lineage.genus if random.random() >= dropout else None, + lineage.species if random.random() >= dropout else None, + ) if lineage is not None else None + + def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, config: StipedHyena2PreprocessingConfig): + """Preprocess Evo2 fasta datapaths.""" - @staticmethod - def _get_evo_phyla_from_lineage_string(lineage_str: str): - """TODO(@cye) Consider deprecating the Taxonomy resources from Arc in favor of an explicit SeqID -> Taxonomy mapping via config.""" - try: - return lineage_str.split(";")[1].split("_")[-1] - except Exception: - return None + # Timing. + start = time.time() + # Retrieve taxonomy lineage string if SeqID has associated taxonomy data. + # Note: Better implemented as a suffix tree substring dictionary, but convenient + # for identifying a large amount of sequences with identical lineages. + # Slow for extremely large dictionaries of (SeqID Substr, Taxonomy) pairs. + lineage = None + for id, tax in config.taxonomy_data.items(): + # Taxonomy ID is a substring of Seq ID. + if id in seqid: + lineage = tax + break - @staticmethod - def _load_evo_taxonomy(fname): - """TODO(@cye) Consider deprecating the Taxonomy resources from Arc in favor of an explicit SeqID -> Taxonomy mapping via config.""" - df = pd.read_csv(fname, sep="\t") - id_to_taxonomy = {} - for _, row in df.iterrows(): - lineage_string = ( - f'd__{row["kingdom"]};' - f'p__{row["phylum"]};' - f'c__{row["class"]};' - f'o__{row["order"]};' - f'f__{row["family"]};' - f'g__{row["genus"]};' - f's__{row["species"]}' - ) - id_to_taxonomy[row["genome_id"]] = lineage_string - return id_to_taxonomy + # Preprocess data. + preproc_data = [] + with self.preprocessing_context_manager( + config.seed + hash(filepath) + seq_idx if config.seed is not None else None + ): + # Randomly reverse complement the sequence. + seq = self._random_reverse_complement(seq, prob=config.random_reverse_complement) + seqs_to_parse = self._reverse_complement_expansion(seq) if config.embed_reverse_complement else [seq] + for seq in seqs_to_parse: + # Sequence Modifiers + if config.force_uppercase: + seq = seq.upper() + if config.transcribe == "transcribe": + seq = transcribe_sequence(seq) + elif config.transcribe == "back_transcribe": + seq = back_transcribe_sequence(seq) + if config.drop_empty_sequences and len(seq) == 0: + continue + if config.nnn_filter and "NNN" in seq.upper(): + continue + + # Construct taxonomy token with random dropout on the lineage categories per sequence. + taxonomy_token = self._construct_taxonomy_token(lineage, dropout=config.random_lineage_dropout) + + # Inject taxonomy lineage tokens every PROMPT_SPACER_LENGTH tokens in the sequence. + # If the taxonomy lineage token is not provided, then just take the original sequence. + target_length = ( + self.PROMPT_SPACER_LENGTH - len(taxonomy_token) + if taxonomy_token is not None + else None + ) + taxonomy_injected_sequence = [ + taxonomy_token + str(subseq) if taxonomy_token is not None else str(subseq) + for subseq in self._subsequence_generator(seq, target_length, target_length) + ] + + # Wrap and tokenize. + preproc_data_record = { + "text": "".join(taxonomy_injected_sequence), + } + if config.include_sequence_id: + preproc_data_record["id"] = f"{seqid}" + preproc_data_record["tokens"] = self.tokenizer.tokenize( + preproc_data_record["text"], + use_ftfy=config.ftfy, + enforce_sample_length=config.enforce_sample_length, + append_eod=config.append_eod, + drop_empty_sequences=config.drop_empty_sequences, + ) + preproc_data.append(preproc_data_record) + end = time.time() + return preproc_data, end - start + def preprocess_data_task(self, file_sequence_config): + """Wrapper function to unpack args for preprocess_data.""" + return self.preprocess_data(*file_sequence_config) + @staticmethod - def _yield_sequences_from_files(fnames: list, semaphore: Semaphore): + def _yield_sequences_from_files(config: StipedHyena2PreprocessingConfig, semaphore: Semaphore): """Iterator over sequences within multiple input documents. Arguments for multiprocessing tasks. Utilized to limit the amount of sequences streamed into memory. @@ -149,146 +226,77 @@ def _yield_sequences_from_files(fnames: list, semaphore: Semaphore): def yielder(fname, semaphore): # Read FASTA. index = NvFaidx(fname) - for seqid, sequence in index.items(): + for i, (seqid, sequence) in enumerate(index.items()): semaphore.acquire() # Yield filename and sequence within fasta. - yield str(fname), seqid, sequence + yield str(fname), seqid, sequence, i, config - for fname in fnames: + for fname in config.datapaths: semaphore.acquire() yield from yielder(fname, semaphore) - def configure(self, params: Evo2PreprocessingConfig | None = None): - """Configure a new Evo2PreprocessingConfig for Evo2Preprocessor.""" - self.params = params if params is not None else Evo2PreprocessingConfig() - self.id_to_taxonomy = ( - self._load_evo_taxonomy(self.params.taxonomy_path) if self.params.taxonomy_path is not None else None - ) - - def preprocess_data(self, filepath: str, seqid: str, seq: str) -> list[dict]: - """Preprocess Evo2 fasta datapaths.""" - # Retrieve EVO taxonomy metadata if id_to_taxonomy is provided. - lineage_string = ( - self.id_to_taxonomy.get(self._get_evo_seq_id(str(filepath)), None) - if isinstance(self.id_to_taxonomy, dict) - else None - ) - phyla = self._get_evo_phyla_from_lineage_string(lineage_string) if lineage_string is not None else None - kingdom = PHYLA_TO_KINGDOM.get(phyla, None) if phyla is not None else None - if isinstance(self.id_to_taxonomy, dict) and (lineage_string is None or kingdom is None): - logging.info(f"No taxonomy lineage metadata detected for {filepath}. Skipping datafile...") - return [] - - # Preprocess data. - preproc_data = [] - with preprocessing_context_manager( - self.params.seed + hash(filepath) if self.params.seed is not None else None - ): - # Randomly reverse complement the sequence. - seq = self._random_reverse_complement(seq, prob=0.5) if self.params.random_reverse_complement else seq - seqs_to_parse = self._reverse_complement_expansion(seq) if self.params.embed_reverse_complement else [seq] - for seq in seqs_to_parse: - if self.params.force_uppercase: - seq = seq.upper() - if self.params.transcribe == "transcribe": - seq = transcribe_sequence(seq) - elif self.params.transcribe == "back_transcribe": - seq = back_transcribe_sequence(seq) - if self.params.drop_empty_sequences and len(seq) == 0: - continue - if self.params.nnn_filter and "NNN" in seq.upper(): - continue - taxonomy_token = ( - self.VBAR + lineage_string.upper() + self.VBAR if isinstance(lineage_string, str) else None - ) - target_length = ( - # Full sequence length minus bandwidth for the special Taxonomy token. - self.PROMPT_SPACER_LENGTH - len(taxonomy_token) - if isinstance(taxonomy_token, str) - # Chunk into subsequences. If None, then default to sequence length. - else self.params.subsequence_length - ) - for i, subseq in enumerate(self._subsequence_generator(seq, target_length, target_length)): - preproc_data_record = { - "text": taxonomy_token + str(subseq) if taxonomy_token is not None else str(subseq), - } - if self.params.include_sequence_id: - preproc_data_record["id"] = f"{seqid}_{i}" - # Tokenize the sequence. - preproc_data_record["tokens"] = self.tokenizer.tokenize( - preproc_data_record["text"], - use_ftfy=self.params.ftfy, - enforce_sample_length=self.params.enforce_sample_length, - append_eod=self.params.append_eod, - drop_empty_sequences=self.params.drop_empty_sequences, - ) - preproc_data.append(preproc_data_record) - return preproc_data - - def preprocess_data_task(self, file_record): - """Wrapper function to unpack args for preprocess_data.""" - return self.preprocess_data(*file_record) - - def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): + def preprocess_generator(self, preproc_config: StipedHyena2PreprocessingConfig): """Main function to preprocess data for Evo2.""" - # Configure preprocessor. - self.configure(preproc_config) - # Instantiate multiprocessing pool. + # Instantiate multiprocessing pool. Use semaphore to limit the amount of sequences to read into memory. semaphore = Semaphore(preproc_config.preproc_concurrency + preproc_config.workers) if preproc_config.workers > 1: pool = mp.Pool(preproc_config.workers) # Ordered imap for downstream seeded splitting. preproc_tasks = pool.imap( - evo2_preprocessor.preprocess_data_task, - Evo2Preprocessor._yield_sequences_from_files( - preproc_config.datapaths, semaphore + self.preprocess_data_task, + self._yield_sequences_from_files( + preproc_config, semaphore ), - chunksize=25, + chunksize=preproc_config.chunksize, ) else: preproc_tasks = ( - evo2_preprocessor.preprocess_data_task(x) - for x in Evo2Preprocessor._yield_sequences_from_files( - preproc_config.datapaths, semaphore + self.preprocess_data_task(x) + for x in self._yield_sequences_from_files( + preproc_config, semaphore ) ) # Preprocess data and split results into train, test, and split. - with preprocessing_context_manager(preproc_config.seed if preproc_config.seed is not None else None): - for result in preproc_tasks: + with self.preprocessing_context_manager(preproc_config.seed if preproc_config.seed is not None else None): + for result, elapsed_time in preproc_tasks: # Release semaphore for the task associated with the result. semaphore.release() - # Randomly assign all sequences from this document to train, val, or test. - split = Evo2Preprocessor._train_val_test_split(preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split) + # Randomly assign all sequences to train, validation, or test. + split = self._train_val_test_split(preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split) for sequence in result: sequence["split"] = split - yield sequence + yield sequence, elapsed_time - def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): + def preprocess_offline(self, preproc_config: StipedHyena2PreprocessingConfig): """Offline data preprocessing script for Evo2.""" - # Process output directory. - output_dir = preproc_config.output_dir - if output_dir is None: - output_dir = Path.cwd() - # Build train, validation, and test datasplits. - BIN = ".bin" - TRAIN_SUFFIX = "_train" - VAL_SUFFIX = "_val" - TEST_SUFFIX = "_test" - config_prefix = "{}_{}".format( - preproc_config.output_prefix, preproc_config.tokenizer_type.lower().replace(" ", "") - ) - train_bin_path = Path(output_dir) / (config_prefix + TRAIN_SUFFIX + BIN) - val_bin_path = Path(output_dir) / (config_prefix + VAL_SUFFIX + BIN) - test_bin_path = Path(output_dir) / (config_prefix + TEST_SUFFIX + BIN) + + # Validate if binaries have already been produced for the given config and overwrite is set to False. + if any(self._get_output_filename(preproc_config, ext, split).is_file() for ext, split in zip([self.BIN, self.IDX], [self.TRAIN, self.VAL, self.TEST])): + if not preproc_config.overwrite: + # Skip this dataset! + logging.info(f"Skipped overwriting (overwrite: False) existing preprocessed data: {preproc_config.output_prefix}") + return + else: + logging.info(f"Overwriting (overwrite: True) existing preprocessed data: {preproc_config.output_prefix}") + + # Instantiate indexed data builders. dataset_dtype = getattr(np, preproc_config.indexed_dataset_dtype) - train_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(train_bin_path), dtype=dataset_dtype) - val_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(val_bin_path), dtype=dataset_dtype) - test_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(test_bin_path), dtype=dataset_dtype) + temp_train_bin = self._get_output_filename(preproc_config, self.BIN, self.TRAIN, temp=True) + temp_val_bin = self._get_output_filename(preproc_config, self.BIN, self.VAL, temp=True) + temp_test_bin = self._get_output_filename(preproc_config, self.BIN, self.TEST, temp=True) + train_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(temp_train_bin), dtype=dataset_dtype) + val_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(temp_val_bin), dtype=dataset_dtype) + test_builder: IndexedDatasetBuilder = IndexedDatasetBuilder(bin_path=str(temp_test_bin), dtype=dataset_dtype) + logging.info(f"Created temporary binary datasets: {temp_train_bin} {temp_val_bin} {temp_test_bin}") # Preprocess data and split results into train, validation, or test. - for sequence in self.preprocess_generator(preproc_config): + avg_preproc_time = 0.0 + avg_index_time = 0.0 + count = 0 + for sequence, elapsed_time in self.preprocess_generator(preproc_config): + index_start_time = time.time() if sequence["split"] == "train": train_builder.add_item(torch.Tensor(sequence["tokens"])) train_builder.end_document() @@ -298,15 +306,24 @@ def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): elif sequence["split"] == "test": test_builder.add_item(torch.Tensor(sequence["tokens"])) test_builder.end_document() - - # Write preprocessed index sdata to disk. - IDX = ".idx" - train_idx_path = Path(output_dir) / (config_prefix + TRAIN_SUFFIX + IDX) - val_idx_path = Path(output_dir) / (config_prefix + VAL_SUFFIX + IDX) - test_idx_path = Path(output_dir) / (config_prefix + TEST_SUFFIX + IDX) - train_builder.finalize(idx_path=str(train_idx_path)) - val_builder.finalize(idx_path=str(val_idx_path)) - test_builder.finalize(idx_path=str(test_idx_path)) + index_end_time = time.time() + # Update average preprocessing and indexing time. + avg_preproc_time = (avg_preproc_time * count + elapsed_time) / (count + 1) + avg_index_time = (avg_index_time * count + index_end_time - index_start_time) / (count + 1) + count += 1 + + # Report timing. + logging.info(f"Average preprocessing time per sequence: {avg_preproc_time}") + logging.info(f"Average indexing time per sequence: {avg_index_time}") + logging.info(f"Number of sequences processed: {count}") + + # Write preprocessed index data to disk. Rename temporary binaries to denote preprocessing completion. + train_builder.finalize(idx_path=str(self._get_output_filename(preproc_config, self.IDX, self.TRAIN))) + val_builder.finalize(idx_path=str(self._get_output_filename(preproc_config, self.IDX, self.VAL))) + test_builder.finalize(idx_path=str(self._get_output_filename(preproc_config, self.IDX, self.TEST))) + os.rename(temp_train_bin, self._get_output_filename(preproc_config, self.BIN, self.TRAIN)) + os.rename(temp_val_bin, self._get_output_filename(preproc_config, self.BIN, self.VAL)) + os.rename(temp_test_bin, self._get_output_filename(preproc_config, self.BIN, self.TEST)) def parse_args(): @@ -321,11 +338,14 @@ def parse_args(): args = parse_args() # Read config YAML. with open(args.config, "r") as yaml_fs: - evo2_preproc_config_batch = yaml.safe_load(yaml_fs) - # Instantiate Evo2Preprocessor. - evo2_preprocessor = Evo2Preprocessor() - for config in evo2_preproc_config_batch: - # Convert into Evo2PreprocessingConfig. - evo2_preproc_config = Evo2PreprocessingConfig(**config) + hyena2_preproc_config_batch = yaml.safe_load(yaml_fs) + for config in hyena2_preproc_config_batch: + start = time.time() + # Convert into StipedHyena2PreprocessingConfig. + hyena2_preproc_config = StipedHyena2PreprocessingConfig(**config) + # Instantiate StipedHyena2Preprocessor. + hyena2_preprocessor = StipedHyena2Preprocessor(hyena2_preproc_config) # Preprocess data specified in config. - evo2_preprocessor.preprocess_offline(evo2_preproc_config) + hyena2_preprocessor.preprocess_offline(hyena2_preproc_config) + end = time.time() + logging.info(f"Finished preprocessing {hyena2_preproc_config.output_prefix} ({hyena2_preproc_config.datapaths}) in {end - start:.3f} seconds with {hyena2_preproc_config.workers} workers.") diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py deleted file mode 100644 index 25e6abfbc5..0000000000 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/__init__.py +++ /dev/null @@ -1,14 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py deleted file mode 100644 index 3839a9c236..0000000000 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/resources/phyla_kingdom_map.py +++ /dev/null @@ -1,71 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -PHYLA_TO_KINGDOM = { - "Acanthocephala": "animalia", - "Annelida": "animalia", - "Apicomplexa": "protista", - "Arthropoda": "animalia", - "Ascomycota": "fungi", - "Bacillariophyta": "chromista", - "Basidiomycota": "fungi", - "Blastocladiomycota": "fungi", - "Brachiopoda": "animalia", - "Bryozoa": "animalia", - "Cercozoa": "protista", - "Chlorophyta": "plantae", - "Chordata": "animalia", - "Chytridiomycota": "fungi", - "Ciliophora": "protista", - "Cnidaria": "animalia", - "Cryptomycota": "fungi", - "Ctenophora": "animalia", - "Dicyemida": "animalia", - "Discosea": "protista", - "Echinodermata": "animalia", - "Endomyxa": "protista", - "Euglenozoa": "protista", - "Evosea": "protista", - "Foraminifera": "protista", - "Fornicata": "protista", - "Haptophyta": "protista", - "Hemichordata": "animalia", - "Heterolobosea": "protista", - "Microsporidia": "fungi", - "Mollusca": "animalia", - "Mucoromycota": "fungi", - "Nematoda": "animalia", - "Nematomorpha": "animalia", - "Nemertea": "animalia", - "Onychophora": "animalia", - "Oomycota": "chromista", - "Orthonectida": "animalia", - "Parabasalia": "protista", - "Perkinsozoa": "protista", - "Phoronida": "animalia", - "Placozoa": "animalia", - "Platyhelminthes": "animalia", - "Porifera": "animalia", - "Preaxostyla": "protista", - "Priapulida": "animalia", - "Rhodophyta": "plantae", - "Rotifera": "animalia", - "Sanchytriomycota": "fungi", - "Streptophyta": "plantae", - "Tardigrada": "animalia", - "Xenacoelomorpha": "animalia", - "Zoopagomycota": "fungi", -} diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py index d6dc73e597..f5fa96f8da 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py @@ -18,16 +18,16 @@ from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer -from bionemo.evo2.utils.config import Evo2PreprocessingConfig +from bionemo.evo2.utils.config import StipedHyena2PreprocessingConfig -class Evo2Tokenizer: - """Tokenizer for Evo2.""" +class StripedHyena2Tokenizer: + """Tokenizer for StripedHyena2.""" - def __init__(self, params: Evo2PreprocessingConfig | None = None): - """Initialize the Evo2Tokenizer.""" - # Pass all NeMo2/Megatron-compliant parameters associated with config.Evo2PreprocessingConfig. - self.params: Evo2PreprocessingConfig = params if params is not None else Evo2PreprocessingConfig() + def __init__(self, params: StipedHyena2PreprocessingConfig | None = None): + """Initialize the StripedHyena2Tokenizer.""" + # Pass all NeMo2/Megatron-compliant parameters associated with config.StipedHyena2PreprocessingConfig. + self.params: StipedHyena2PreprocessingConfig = params if params is not None else StipedHyena2PreprocessingConfig() self.tokenizer: TokenizerSpec = get_nmt_tokenizer( library=self.params.tokenizer_type.lower(), vocab_file=str(self.params.vocab_file) if self.params.vocab_file is not None else None, @@ -46,7 +46,7 @@ def tokenize( append_eod: bool = False, drop_empty_sequences: bool = False, ): - """Tokenize the input text data for Evo2.""" + """Tokenize the input text data for StripedHyena2.""" if isinstance(text, str): text = [text] # Tokenize a document or batch of strings. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index 51064c4cb9..c283446883 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -20,16 +20,26 @@ from pydantic import BaseModel -class Evo2BlendedDatasetConfig(BaseModel): +class StipedHyena2BlendedDatasetConfig(BaseModel): """Pydantic model class that specifies indexed datasets, dataset weights, and datasplits assignments for training.""" dataset_prefix: None | str = None dataset_weight: None | float = None dataset_split: Literal["train", "validation", "test"] -class Evo2PreprocessingConfig(BaseModel): - """Class specifying the configuration schema for Evo2 data preprocessing.""" +class StripedHyena2TaxonomyLineage(BaseModel): + """Pydantic model class that defines the source lineage of a DNA sequence.""" + kingdom: None | str = None + phylum: None | str = None + clazz: None | str = None + order: None | str = None + family: None | str = None + genus: None | str = None + species: None | str = None + +class StipedHyena2PreprocessingConfig(BaseModel): + """Pydantic model class specifying the configuration schema for a preprocessed IndexedDataset (.bin, .idx).""" # Paths datapaths: list[Path] = [] output_dir: None | Path = None @@ -38,15 +48,16 @@ class Evo2PreprocessingConfig(BaseModel): train_split: float = 0.7 valid_split: float = 0.2 test_split: float = 0.1 - # Evo Taxonomy - taxonomy_path: None | Path = None + # Overwrite existing binaries. Otherwise, skip already preprocessed datasets. + overwrite: bool = False # Raw Preprocessing Transforms embed_reverse_complement: bool = False - random_reverse_complement: bool = False - subsequence_length: None | int = None + random_reverse_complement: float = 0.0 + random_lineage_dropout: float = 0.0 include_sequence_id: bool = False transcribe: None | Literal["transcribe", "back_transcribe"] = None force_uppercase: bool = False + indexed_dataset_dtype: str = "uint8" # Tokenizer tokenizer_type: Literal[ "Byte-Level", @@ -66,12 +77,17 @@ class Evo2PreprocessingConfig(BaseModel): append_eod: bool = False enforce_sample_length: None | int = None ftfy: bool = False - indexed_dataset_dtype: str = "uint8" # Compute + # NOTE: If preprocessing short individual sequences (< 1000 bp), do NOT use multiprocessing + # (workers > 1) because sequence-level parallel IPC will dominate the preprocessing time! workers: int = 1 - preproc_concurrency: int = 10000 + preproc_concurrency: int = 100000 + chunksize: int = 1 # Filters drop_empty_sequences: bool = False nnn_filter: bool = False # RNG seed: None | int = None + # StipedHyena2 Taxonomic Lineage Tags + # SeqID Sub-String Indexing: "ABC" will have taxonomy data from "A". + taxonomy_data: dict[str, StripedHyena2TaxonomyLineage] = {} \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py deleted file mode 100644 index 2e573f66ee..0000000000 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/torch2nemo.py +++ /dev/null @@ -1,289 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import argparse -from dataclasses import dataclass - -import torch -from nemo.collections.llm.gpt.model.hyena import HyenaConfig, PyTorchHyenaImporter - - -""" -python torch2nemo.py --model-ckpt pretrained_model/global_step199400 --output-nemo-ckpt nemo_pretrained_model/evo2_nemo_pretrained.nemo -""" - - -@dataclass -class Hyena40bPretrainedConfig(HyenaConfig): - """Fixes SDHSDH instead of SHDSDH in the original 40b, probably a typo there?""" - - hybrid_override_pattern: str = "SDH*SDHSDH*SDHSDH*SDHSDH*SDHSDH*SDH*SDHSDH*SDHSDH*" - num_layers: int = 50 - seq_length: int = 8192 - hidden_size: int = 8192 - num_groups_hyena: int = 8192 - num_groups_hyena_medium: int = 512 - num_groups_hyena_short: int = 512 - make_vocab_size_divisible_by: int = 8 - tokenizer_library: str = "byte-level" - mapping_type: str = "base" - ffn_hidden_size: int = 21888 - gated_linear_unit: bool = True - num_attention_heads: int = 64 - use_cpu_initialization: bool = False - hidden_dropout: float = 0.0 - attention_dropout: float = 0.0 - params_dtype: torch.dtype = torch.bfloat16 - normalization: str = "RMSNorm" - add_qkv_bias: bool = False - add_bias_linear: bool = False - layernorm_epsilon: float = 1e-6 - # fp8: str = 'hybrid' - # fp8_amax_history_len: int = 16 - # fp8_amax_compute_algo: str = "max" - recompute_granularity: str = "full" - recompute_method: str = "uniform" - recompute_num_layers: int = 2 - hyena_init_method: str = "small_init" - hyena_output_layer_init_method: str = "wang_init" - hyena_filter_no_wd: bool = True - - -def parse_args(): - """Parse args.""" - parser = argparse.ArgumentParser(description="PyTorch to NeMo converter") - parser.add_argument("--model-ckpt", type=str, required=True, help="Path to the PyTorch model checkpoint.") - parser.add_argument("--output-nemo-ckpt", type=str, required=True, help="Path to the NeMo model checkpoint.") - return parser.parse_args() - - -if __name__ == "__main__": - # print(torch.load("pretrained_model/global_step199400/mp_rank_00_model_states.pt").keys()) - args = parse_args() - pretrained_config: HyenaConfig = Hyena40bPretrainedConfig() - importer = PyTorchHyenaImporter(args.model_ckpt, model_config=pretrained_config) - importer.apply(args.output_nemo_ckpt) - - -""" -{ - # Logging - 'use_wandb': true, - "print_mem_alloc_stats": false, - "log_memory_stats": true, - "log_memory_alloc_counts": false, - # MP / PP config - 'pipe_parallel_size': 0, - 'model_parallel_size': 2, - 'sequence_parallel': true, - - # Zero config - # Leaf Modules - # Modules to mark as leaf modules, only for Zero-stage 3 - # Must be list of strings that can be be used as such getattr(module, leaf_module) - # where module is one of savanna.model.block or savanna.model.operators.hyena.hyena. - - # This controls the granularity of zero-3 parameter partitioning. I.e., if ParallelSequenceMixer is - # set as a leaf module, then the entire ParallelSequenceMixer will be gathered / partitioned as a single unit. - # ParallelSequenceMixer is the equivalent of an AttentionBlock: input projections, self attention, and output projections. - # ParallelBlockPipe is the equivalent of a TransformerBlock: AttentionBlock + FFN - # backbone modules: ParallelBlockPipe - # block modules: 'ParallelSequenceMixer', 'ParallelGLU', 'ParallelLinear', 'FlexLinear', 'ParallelMLP', - # hyena_modules: 'ParallelCausalDepthwiseConv1d', 'ParallelComplexModalFilter', 'ParallelHyenaOperator', 'ParallelImplicitFreeformFilter', 'ParallelShortHyenaOperator', - #NOTE: If a module is specified as a leaf module, all its nested modules will be - 'zero_use_leaf_modules': false, - 'zero_leaf_modules': ["ParallelSequenceMixer", "ParallelGLU"], - - 'zero_use_mics': false, - 'zero_optimization': - { - 'stage': 3, - 'prefetch_bucket_size': 500000000, - 'max_live_parameters': 1000000000, - 'allgather_partitions': True, - 'allgather_bucket_size': 500000000, - 'overlap_comm': True, - 'reduce_scatter': True, - 'reduce_bucket_size': 500000000, - 'contiguous_gradients': True, - 'cpu_offload': false, - 'param_persistence_threshold': 0, - # "mics_shard_size": 8, - # "mics_hierarchical_params_gather": false, - }, - - # Batch sizing - 'train_micro_batch_size_per_gpu': 8, - 'gradient_accumulation_steps': 1, - - # Activation checkpointing - 'checkpoint-activations': true, - 'checkpoint-num-layers': 1, - - # Training - 'train-iters': 40, - 'lr-decay-iters': 40, - - 'make_vocab_size_divisible_by': 8, - 'num_layers': 50, - 'hidden_size': 8192, - 'num_attention_heads': 64, - 'num_groups_hyena': 8192, - 'num_groups_hyena_medium': 512, - 'num_groups_hyena_short': 512, - 'num_groups_hyena_mlp': 512, - 'operator-config': - [ - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['hyena_short_conv'], 1], - [['hyena_medium_conv'], 1], - [['hyena'], 1], - [['flash_v2'], 1], - ], - - # These kernels will be also autotuned and activated - 'use_cgcg': false, - 'use_cgcg_short': false, - 'use_cgcg_mlp': false, - - # Tune to target sequence length e.g., 8192 - 'seq_length': 8192, - 'max_position_embeddings': 8192, - - 'hyena_medium_conv_len': 128, # default is null - 'log_attn_norms': false, - 'pos_emb': 'rotary', - 'rotary_emb_base': 1000000, - 'rotary_pct': 1, - 'prenorm': true, - 'postnorm': false, - 'pre_mlp_norm': true, - 'outer_mlp_norm': false, - 'no_weight_tying': false, - 'gpt_j_residual': false, - 'normalize_hyena_filters': false, - 'short-conv-L': 3, - 'hyena_filter_fast_decay': 0.3, - 'hyena_filter_slow_decay': 1.2, - 'hyena_filter_w': 14, - 'hyena_filter_cls': 'implicit_modal', - 'hyena_medium_filter_cls': 'explicit_single_decay', - 'explicit_filter_decay_preset': 'weak', - 'hyena_filter_order': 16, - 'hyena_filter_wd': 0., - 'use_fast_heads': false, - 'use_slow_heads': false, - 'use-hyena-filter': true, - 'output_layer_parallelism': 'column', - 'bias_dropout_fusion': false, - 'norm': 'rmsnorm', - 'rms_norm_epsilon': 1.0e-6, - 'identity_mlp': false, - 'activation': 'gelu', - 'mlp_type': 'llama', - 'scaled-upper-triang-masked-softmax-fusion': true, - 'bias-gelu-fusion': false, - 'init_method': 'small_init', - 'output_layer_init_method': 'wang_init', - 'optimizer': - { - 'type': 'Adam', - 'params': { 'lr': 0.0003, 'betas': [0.9, 0.95], 'eps': 1.0e-8 }, - }, - 'min_lr': 0.00003, - - 'data-impl': 'mmap', - - 'partition-activations': false, - 'synchronize-each-layer': false, - 'gradient_clipping': 1.0, - 'weight-decay': 0.1, - 'hidden-dropout': 0.0, - 'attention-dropout': 0.0, - 'precision': 'bfloat16', - 'bf16': { 'enabled': true }, - 'distributed-backend': 'nccl', - 'lr-decay-style': 'cosine', - 'warmup': 0.005, - 'checkpoint-factor': 2500, - 'extra_save_iters': [100], - 'eval-interval': 200, - 'eval-iters': 20, - 'log-interval': 5, - 'steps_per_print': 5, - 'keep-last-n-checkpoints': 100, - 'wall_clock_breakdown': false, - - 'tokenizer_type': CharLevelTokenizer, - 'use_fp8_input_projections': true, - 'use_fp8_output_projections': true, - 'use_fp8_mlp_projections': true, - 'use_fp8_norm': true, - 'checkpoint_strict_load': false, - 'make_gated_mlp_multiple_of': 128, - 'materialize_attn_mask': false, # default false, to save memory - 'fast_conv_proj': true, - 'hyena_short_conv_len': 7, - 'to_upper': "normalized_weighted", - 'mask_loss_control_tags': true, - 'lowercase_loss_reweighting': 0.1, -} -""" diff --git a/sub-packages/bionemo-evo2/tests/README.md b/sub-packages/bionemo-evo2/tests/README.md index f3e523b303..177ebe7f20 100644 --- a/sub-packages/bionemo-evo2/tests/README.md +++ b/sub-packages/bionemo-evo2/tests/README.md @@ -1 +1 @@ -Tests for BioNeMo Evo2. +Tests for BioNeMo StripedHyena2. diff --git a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml index 4b12b273b9..9d624854b1 100644 --- a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml +++ b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml @@ -5,15 +5,16 @@ train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training valid_split: 0.0 test_split: 0.0 - # Evo Taxonomy - taxonomy_path: null + # Overwrite existing binaries. Otherwise, skip already preprocessed datasets. + overwrite: True # Raw Preprocessing Transforms embed_reverse_complement: true - random_reverse_complement: false - subsequence_length: null + random_reverse_complement: 0.0 + random_lineage_dropout: 0.1 include_sequence_id: false transcribe: "back_transcribe" force_uppercase: true + indexed_dataset_dtype: "uint8" # Tokenizer tokenizer_type: "Byte-Level" vocab_file: null @@ -26,13 +27,26 @@ append_eod: true enforce_sample_length: null ftfy: false - indexed_dataset_dtype: "uint8" # Compute workers: 1 - preproc_concurrency: 10000 + preproc_concurrency: 100000 + chunksize: 25 # Filters drop_empty_sequences: true nnn_filter: true # RNG seed: 42 - + # StipedHyena2 Taxonomic Lineage Tags + taxonomy_data: + FP002272: + kingdom: KINGDOM + phylum: PHYLUM + clazz: CLASS + order: ORDER + family: FAMILY + genus: GENUS + species: SPECIES + FP000491: + kingdom: king + order: ord + family: fam From 92d0352b39763c72168a3767d3157c487631c1a9 Mon Sep 17 00:00:00 2001 From: John St John Date: Fri, 3 Jan 2025 11:04:57 -0800 Subject: [PATCH 014/140] Changes made on 256 node branch --- sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index ebf6c1f1e7..107b5a7d18 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -102,6 +102,9 @@ def parse_args(): parser.add_argument( "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." ) + parser.add_argument( + "--limit-val-batches", type=int, default=20, help="Number of validation steps", + ) parser.add_argument( "--ckpt-dir", type=str, @@ -381,7 +384,7 @@ def main(): logger=loggers, callbacks=callbacks, log_every_n_steps=1, - limit_val_batches=10, + limit_val_batches=args.limit_val_batches, num_sanity_val_steps=0, use_distributed_sampler=False, plugins=nl.MegatronMixedPrecision( From 923cbdf9644a935901cbb205fa9fab7d94e5fddc Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Fri, 3 Jan 2025 11:07:14 -0800 Subject: [PATCH 015/140] Cye/hyena flops --- 3rdparty/NeMo | 2 +- sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 191593a527..3a6825e7cd 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 191593a5274c989856a277531c1cc5195f5f1653 +Subproject commit 3a6825e7cda32fb8dfc1e371f72dfc258e3025dd diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 107b5a7d18..26ea544f14 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -15,7 +15,7 @@ import argparse from collections import defaultdict -from dataclasses import dataclass +from dataclasses import dataclass, asdict import nvidia_resiliency_ext.ptl_resiliency as res_module import torch @@ -32,6 +32,7 @@ from nemo.lightning import NeMoLogger from nemo.lightning.pytorch import callbacks as nl_callbacks from nemo.lightning.pytorch.callbacks import ModelCheckpoint +from nemo.lightning.pytorch.callbacks.flops_callback import FLOPsMeasurementCallback from nemo.lightning.pytorch.callbacks.megatron_comm_overlap import MegatronCommOverlapCallback from nemo.lightning.pytorch.optim import CosineAnnealingScheduler from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule @@ -285,11 +286,17 @@ def main(): save_optim_on_train_end=True, save_context_on_train_end=True, ) + flop_meas_callback = FLOPsMeasurementCallback( + asdict(hyena_config), + data, + "hyena", + ) callbacks = [ checkpoint_callback, RichModelSummary(max_depth=4), LearningRateMonitor(), TimingCallback(), + flop_meas_callback, ] if args.enable_preemption: callbacks.append(nl_callbacks.PreemptionCallback()) From 6460ea3b99d38f5df1ca1bb1927b2222be9f3510 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Fri, 3 Jan 2025 11:54:35 -0800 Subject: [PATCH 016/140] Fix broken import of blended training config. --- sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 26ea544f14..6bf3738399 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -39,7 +39,7 @@ from nemo.lightning.pytorch.strategies.utils import RestoreConfig from nemo.utils.exp_manager import TimingCallback -from bionemo.evo2.utils.config import Evo2BlendedDatasetConfig +from bionemo.evo2.utils.config import StipedHyena2BlendedDatasetConfig from bionemo.llm.utils.datamodule_utils import infer_global_batch_size From 7e72f4842f62dbaa9dacb2929e4aedb50abb8726 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Fri, 3 Jan 2025 12:24:06 -0800 Subject: [PATCH 017/140] Cye/import fix --- .../src/bionemo/evo2/run/train.py | 20 ++++++------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 6bf3738399..849c530193 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -112,7 +112,6 @@ def parse_args(): default=None, help="Directory to restore an initial checkpoint from. Use this for supervised fine-tuning.", ) - parser.add_argument("--defer-embedding-wgrad-compute", action="store_true", default=False) parser.add_argument( "--restore-optimizer-from-ckpt", action="store_true", @@ -137,12 +136,6 @@ def parse_args(): action="store_true", default=False, ) - parser.add_argument( - "--wgrad-deferral-limit", - type=int, - default=22, - help="Unused unless you also do --defer-embedding-wgrad-compute.", - ) return parser.parse_args() @@ -215,12 +208,12 @@ def parse_dataset_config(dataset_config_path: str): dataset_config_batch = yaml.safe_load(config_file) for dataset_config in dataset_config_batch: # Validate. - config_model = Evo2BlendedDatasetConfig(**dataset_config) + config_model = StipedHyena2BlendedDatasetConfig(**dataset_config) # Integrate the weights for renormalization. weight_sums[config_model.dataset_split] += abs(config_model.dataset_weight) for dataset_config in dataset_config_batch: # Validate. - config_model = Evo2BlendedDatasetConfig(**dataset_config) + config_model = StipedHyena2BlendedDatasetConfig(**dataset_config) # Add indexed dataset to split and associate with blended training weight. blended_dataset_config[config_model.dataset_split].extend( [config_model.dataset_weight / weight_sums[config_model.dataset_split], config_model.dataset_prefix] @@ -266,11 +259,11 @@ def main(): ) if args.model_size == "7b": - hyena_config = llm.Hyena7bConfig(wgrad_deferral_limit=args.wgrad_deferral_limit, defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute) + hyena_config = llm.Hyena7bConfig() elif args.model_size == "40b": - hyena_config = llm.Hyena40bConfig(wgrad_deferral_limit=args.wgrad_deferral_limit, defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute) + hyena_config = llm.Hyena40bConfig() elif args.model_size == "test": - hyena_config = llm.HyenaTestConfig(wgrad_deferral_limit=args.wgrad_deferral_limit, defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute) + hyena_config = llm.HyenaTestConfig() else: raise ValueError(f"Invalid model size: {args.model_size}") @@ -319,8 +312,7 @@ def main(): MegatronCommOverlapCallback( tp_comm_overlap=True, tp_comm_overlap_cfg=userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, - defer_embedding_wgrad_compute=args.defer_embedding_wgrad_compute, - wgrad_deferral_limit=args.wgrad_deferral_limit, + wgrad_deferral_limit=22, # default from NeMo overlap_param_gather_with_optimizer_step=False, # Currently disabled due to an issue with checkpointing. align_param_gather=args.align_param_gather, ) From 45923c630b3191f1469436e0b1c1f031068332ed Mon Sep 17 00:00:00 2001 From: John St John Date: Mon, 6 Jan 2025 08:51:18 -0800 Subject: [PATCH 018/140] Add improved nsys profiling support --- .../src/bionemo/evo2/run/train.py | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 849c530193..df5822960d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -136,6 +136,39 @@ def parse_args(): action="store_true", default=False, ) + + # NSYS profiling/tooling arguments + parser.add_argument( + "--nsys-profiling", + action="store_true", + default=False, + help="Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling output you must run the whole program with `nsys`. For example: " + " `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true --capture-range=cudaProfilerApi --capture-range-end=stop [regular python command here]`", + ) + # start, end, rank + parser.add_argument( + "--nsys-start-step", + type=int, + required=False, + default=0, + help="Start nsys profiling after this step.", + ) + parser.add_argument( + "--nsys-end-step", + type=int, + required=False, + help="End nsys profiling after this step.", + ) + # rank as list of integers + parser.add_argument( + "--nsys-ranks", + type=int, + nargs="+", + required=False, + default=[0], + help="Enable nsys profiling for these ranks.", + ) + return parser.parse_args() @@ -324,6 +357,16 @@ def main(): gc_interval_train=args.gc_interval, gc_interval_val=args.gc_interval ) ) + if args.nsys_profiling: + if args.nsys_end_step is None: + nsys_end_step = args.max_steps + else: + nsys_end_step = args.nsys_end_step + callbacks.append( + nl_callbacks.NsysCallback( + start_step=args.nsys_start_step, end_step=nsys_end_step, ranks=args.nsys_ranks, gen_shape=True + ) + ) loggers = [] wandb_logger = WandbLogger( From c805984b9315fac242c9b17ec8d27ff91a2f5e7a Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Mon, 6 Jan 2025 17:41:44 -0800 Subject: [PATCH 019/140] [cye/hyena-doc-update] Add data preprocessing documentation, fix tech debt in tokenizer and config, remove unused args in infer.py. --- 3rdparty/NeMo | 2 +- sub-packages/bionemo-evo2/README.md | 2 +- sub-packages/bionemo-evo2/pyproject.toml | 13 +- .../bionemo-evo2/src/bionemo/evo2/README.md | 2 +- .../src/bionemo/evo2/data/README.md | 156 +++++++++++++----- .../src/bionemo/evo2/data/preprocess.py | 69 ++++---- .../src/bionemo/evo2/data/tokenizer.py | 26 +-- .../src/bionemo/evo2/run/infer.py | 37 ++--- .../src/bionemo/evo2/run/train.py | 24 +-- .../src/bionemo/evo2/utils/config.py | 30 ++-- sub-packages/bionemo-evo2/tests/README.md | 2 +- .../tests/config/test_preproc_config.yaml | 12 +- 12 files changed, 225 insertions(+), 150 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 3a6825e7cd..d2b45c3ab5 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 3a6825e7cda32fb8dfc1e371f72dfc258e3025dd +Subproject commit d2b45c3ab53a2a1a1d87bce4ad77ee0d5d7bcc5d diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 9a2fe90c54..39916f40d4 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -1 +1 @@ -Library containing data preprocessing, training, and inference tooling for StripedHyena2. +Library containing data preprocessing, training, and inference tooling for Evo2. diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index ab211a7a63..0be5739b09 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -14,15 +14,10 @@ dependencies = [ "bionemo-noodles" ] -# [project.scripts] -# bionemo-evo2-train = "" -# bionemo-evo2-recipe = "" -# infer_evo2 = "" -# train_evo2 = "" - -# Make sure that the tokenizer files are included along with the python files during installation. -[tool.setuptools.package-data] -"bionemo.evo2" = [] +[project.scripts] +infer_evo2 = "bionemo.evo2.run.infer:main" +train_evo2 = "bionemo.evo2.run.train:main" +preprocess_evo2 = "bionemo.evo2.data.preprocess:main" [tool.setuptools.packages.find] where = ["src"] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md index 34f2831bed..982a6ec28d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md @@ -1 +1 @@ -Source code for BioNeMo StripedHyena2. +Source code for BioNeMo Evo2. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md index 4a1a59b4c7..48f7bc3e09 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md @@ -1,14 +1,112 @@ -# Data package -## Preprocess -### Equivalence with arc implementation -To test equivalence with the reference implementation we first downloaded processed megatrion IndexedDataset -files from Arc institute for their promotors dataset: +# Evo2 Data Preparation +## Data Preprocessing -```bash -$ mkdir tmp_goldstandard -$ cd tmp_goldstandard -$ scp login-eos:/lustre/fsw/healthcareeng_bionemo/arc_evo2/data/promoters/pretraining_data_promoters/data_promoters_*_text_CharLevelTokenizer_document.* ./ +To streamline the process of preparing and building datasets for training Evo2 on DNA sequences, we provide a configurable preprocessing script (`preprocess.py`) that can preprocess and tokenize a collection of `.fasta` files and convert them into Megatron-compatible `IndexedDataset`. + +```python +preprocess_evo2 -c +``` +or if you are running the script outside of the BioNeMo container or you haven't pip-installed `bionemo-evo2`, then you can run the script directly: +```python +python sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py -c +``` + +Configuration YAML parameters for the script can be found in `utils/config.py`: +```python +class Evo2PreprocessingConfig(BaseModel): + """Pydantic model class specifying the configuration schema for a preprocessed IndexedDataset (.bin, .idx).""" + # Collection of FASTA files to preprocess and wrap into a single IndexedDataset. + datapaths: list[Path] = [] + # Output directory for the preprocessed dataset .bin/.idx. + output_dir: None | Path = None + # Output file prefix for identifying your datasets. + output_prefix: None | str = None + # Random Sequence-Level Datasplit + train_split: float = 0.7 + valid_split: float = 0.2 + test_split: float = 0.1 + # Overwrite existing binaries. Otherwise, skip already preprocessed datasets. + overwrite: bool = False + # Raw Preprocessing Transforms + # For every sequence, include a reverse-complemented copy of that sequence in the dataset. Doubles the size of the dataset. + embed_reverse_complement: bool = False + # For every sequence, randomly reverse complement the sequence with the specified probability instead of using the original sequence. + random_reverse_complement: float = 0.0 + # For sequences associated with taxonomic lineages specified in `taxonomy_data`, randomly drop out nodes of the lineage with the specified probability. For instance: |d__KINGDOM;p__None;c__CLASS;o__None;f__None;g__None;s__None| + random_lineage_dropout: float = 0.0 + # Transcribe (DNA -> RNA) or Back-Transcribe (RNA -> DNA) the sequence before tokenization. + transcribe: None | Literal["transcribe", "back_transcribe"] = None + # Force upper-case alphabetical characters in the `.fasta` sequences. + force_uppercase: bool = False + # Data type of the IndexedDataset. When using the byte-level tokenizer, uint8 is more than sufficient with a vocabulary size of 255 for ASCII. + indexed_dataset_dtype: str = "uint8" + # Tokenization Transforms + # Append end-of-document token to the end of each sequence. + append_eod: bool = False + # Enforce the length of the sequence, by padding shorter sequences and raising exceptions when the length is exceeded. + enforce_sample_length: None | int = None + # Run ftfy on the sequence characters prior to tokenization to fix encoding issues. + ftfy: bool = False + # Tokenizer + tokenizer_type: Literal[ + "Byte-Level", + "HuggingFace", + "SentencePiece", + "Regex", + "Megatron", + "Tiktoken", + ] = "Byte-Level" # Recommended for DNA / RNA sequences. All other tokenizers have not been tested, and only supported here for experimentation! + # For more information on the behavior of the following parameters, refer to NeMo: + # https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/nlp/modules/common/tokenizer_utils.py + vocab_file: None | Path = None + vocab_size: None | int = 512 + merges_file: None | Path = None + tokenizer_model_name: None | str = None + pretrained_tokenizer_model: None | str = None + special_tokens: None | dict[str, str] = {} + fast_hf_tokenizer: bool = False + # Compute Configuration + # NOTE: If preprocessing a large amount of short individual sequences (< 1000 bp), do NOT use + # multiprocessing (workers > 1) because sequence-level parallel IPC will dominate the preprocessing time! + workers: int = 1 + # Number of sequences to load into memory at any given time during preprocessing. + # Prevents OOM while doing sequence-parallel. + preproc_concurrency: int = 100000 + chunksize: int = 1 + # Data Filters + drop_empty_sequences: bool = False + # If `NNN` is detected in the sequence, drop it from the preprocessed dataset. + nnn_filter: bool = False + # RNG + seed: None | int = None + # Evo2 Taxonomic Lineage Tags + # SeqID Sub-String Indexing: "ABC" will have taxonomy data from "A". + taxonomy_data: dict[str, Evo2TaxonomyLineage] = {} + # Periodicity of injecting phylogenetic lineage tags in the sequence prior to tokenization. + prompt_spacer_length: int = 131072 +``` + +Furthermore, the `taxonomy_data` field contains a map from sequence ID substrings to phylogenetic lineage data of the form: +```python +class Evo2TaxonomyLineage(BaseModel): + """Pydantic model class that defines the source lineage of a DNA sequence.""" + kingdom: None | str = None + phylum: None | str = None + clazz: None | str = None + order: None | str = None + family: None | str = None + genus: None | str = None + species: None | str = None ``` +which gets converted into a lineage string prior to tokenization as a prefix to the sequence: +``` +# (Example) Escherichia coli +|d__Bacteria;p__Pseudomonadota;c__Gammaproteobacteria;o__Enterobacterales;f__Enterobacteriaceae;g__Escherichia;s__Escherichia coli|ATCGTACGTACATCTCTA... +``` +In the Evo2 model, this special "token" is masked out in the loss function, so the model will learn to not generate tokens of this form. + +### Testing +To test equivalence with the reference implementation we first downloaded source-of-truth preprocessed Megatron `IndexedDataset` containing promoters data: ```bash $ ls -lah @@ -20,73 +118,55 @@ $ ls -lah -rwxr-xr-x 1 bionemo bionemo 20K Dec 4 00:56 data_promoters_valid_text_CharLevelTokenizer_document.idx ``` -Next we acquired the `fasta` file that was used to generate this and placed it into the tests/data folder of this sub-package. +Next we acquired the `.fasta` file that was used to generate this, and configured our scripts to preprocess the sequence data into equivalent Megatron `IndexedDataset`. ```yaml +# mmseqs_promotors_config.yaml - datapaths: ["/workspace/bionemo2/data/mmseqs_results_rep_seq_distinct.fasta"] output_dir: "/workspace/bionemo2/data" - output_prefix: promoters_ab_test_noodles_uint8_distinct - # Datasplit - train_split: 1.0 # because they do manual splits of first 1000 for validation, 2nd 1000 for test, and leftover for training + output_prefix: promoters_uint8_distinct + train_split: 1.0 # We're just going to dump everything into a single file and compare against the union of the 3 splits in the SoT. valid_split: 0.0 test_split: 0.0 - # Overwrite existing binaries. Otherwise, skip already preprocessed datasets. overwrite: True - # Raw Preprocessing Transforms embed_reverse_complement: true - random_reverse_complement: 0.5 - random_lineage_dropout: 0.1 + random_reverse_complement: 0.0 + random_lineage_dropout: 0.0 include_sequence_id: false transcribe: "back_transcribe" force_uppercase: true indexed_dataset_dtype: "uint8" - # Tokenizer tokenizer_type: "Byte-Level" vocab_file: null vocab_size: null merges_file: null - # Either a named pretrained tokenizer model, or a path to a SentencePiece tokenizer. pretrained_tokenizer_model: null special_tokens: null fast_hf_tokenizer: true append_eod: true enforce_sample_length: null ftfy: false - # Compute workers: 1 preproc_concurrency: 100000 chunksize: 25 - # Filters drop_empty_sequences: true nnn_filter: true - # RNG - seed: 42 - # StipedHyena2 Taxonomic Lineage Tags - taxonomy_data: - FP002272: - kingdom: KINGDOM - phylum: PHYLUM - clazz: CLASS - order: ORDER - family: FAMILY - genus: GENUS - species: SPECIES + seed: null # Not relevant because we are not using random reverse complement or lineage dropout. ``` -Finally we generated our own bin/idx file for in this case everything going into the training set. +To run the preprocessing script, we ran the following command: ```bash -$ python sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py -c sub-packages/bionemo-evo2/tests/config/mmseqs_promotors_config.yaml +$ python preprocess.py -c mmseqs_promotors_config.yaml ``` -Next to check equivalence, we were not attempting to replicate the exact ordering of the datset, we just wanted to verify -that we get the same elements out of our processed dataset as the original. +To check equivalence of the two preprocessed datasets, we verify that we get the same elements out of our processed dataset as the original, but do not enforce ordering of the data. (`bionemo-noodles` does not sequentially read the `.fasta` file.) ```python >>> from megatron.core.datasets.indexed_dataset import IndexedDataset >>> ds_train_ref = IndexedDataset("./data_promoters_train_text_CharLevelTokenizer_document") >>> ds_val_ref = IndexedDataset("./data_promoters_valid_text_CharLevelTokenizer_document") >>> ds_test_ref = IndexedDataset("./data_promoters_test_text_CharLevelTokenizer_document") ->>> ds_train_ours = IndexedDataset("../sub-packages/bionemo-evo2/tests/data/promoters_ab_test_byte-level_train") +>>> ds_train_ours = IndexedDataset("./promoters_uint8_distinct_byte-level_train") >>> len(ds_train_ours) == len(ds_train_ref) + len(ds_test_ref) + len(ds_val_ref) True >>> # Example of what one of these set elements looks like, it's just a string representation of the token list for an diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index b503330157..6273b18a8a 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -37,30 +37,29 @@ from megatron.core.datasets.indexed_dataset import IndexedDatasetBuilder from nemo.utils import logging -from bionemo.evo2.data.tokenizer import StripedHyena2Tokenizer -from bionemo.evo2.utils.config import StipedHyena2PreprocessingConfig, StripedHyena2TaxonomyLineage +from bionemo.evo2.data.tokenizer import Evo2Tokenizer +from bionemo.evo2.utils.config import Evo2PreprocessingConfig, Evo2TaxonomyLineage from bionemo.noodles import back_transcribe_sequence, complement_sequence, reverse_sequence, transcribe_sequence from bionemo.noodles.nvfaidx import NvFaidx -class StipedHyena2Preprocessor: +class Evo2Preprocessor: """Data preprocessing class for Evo2.""" - PROMPT_SPACER_LENGTH = 131_072 BIN = ".bin" IDX = ".idx" TRAIN = "train" VAL = "val" TEST = "test" - def __init__(self, params: StipedHyena2PreprocessingConfig | None = None): - """Initialize StipedHyena2Preprocessor.""" - self.tokenizer: StripedHyena2Tokenizer = StripedHyena2Tokenizer(params) + def __init__(self, params: Evo2PreprocessingConfig | None = None): + """Initialize Evo2Preprocessor.""" + self.tokenizer: Evo2Tokenizer = Evo2Tokenizer(params) @staticmethod @contextmanager def preprocessing_context_manager(seed: int | None = None): - """Context manager for Evo2 preprocessing RNG.""" + """Context manager for preprocessing RNG.""" # Track current state. current_state = random.getstate() try: @@ -72,7 +71,7 @@ def preprocessing_context_manager(seed: int | None = None): random.setstate(current_state) @staticmethod - def _get_output_filename(config: StipedHyena2PreprocessingConfig, ext: str = None, split: str = None, temp: bool = False) -> Path: + def _get_output_filename(config: Evo2PreprocessingConfig, ext: str = None, split: str = None, temp: bool = False) -> Path: # Get output directory. Defaults to CWD. output_dir = config.output_dir if output_dir is None: @@ -93,7 +92,7 @@ def _subsequence_generator(sequence: str, subsequence_length: int | None = None, @staticmethod def _random_reverse_complement(seq: str, prob: float = 0.0, seed: int = None): - with StipedHyena2Preprocessor.preprocessing_context_manager( + with Evo2Preprocessor.preprocessing_context_manager( seed if seed is not None else None ): if random.random() < prob: @@ -107,7 +106,7 @@ def _reverse_complement_expansion(seq: str): @staticmethod def _train_val_test_split(train_weight: float, val_weight: float, test_weight: float, seed: int = None): - with StipedHyena2Preprocessor.preprocessing_context_manager( + with Evo2Preprocessor.preprocessing_context_manager( seed if seed is not None else None ): # Generate random number. @@ -127,10 +126,10 @@ def _train_val_test_split(train_weight: float, val_weight: float, test_weight: f return split @staticmethod - def _construct_taxonomy_token(lineage: StripedHyena2TaxonomyLineage, dropout: float = 0.0, seed: int = None) -> Optional[str]: + def _construct_taxonomy_token(lineage: Evo2TaxonomyLineage, dropout: float = 0.0, seed: int = None) -> Optional[str]: """Construct a special Taxonomy token for natural language prompting of DNA generation models.""" # If dropout > 0, randomly drop out segments of the lineage for training on incomplete lineages. - with StipedHyena2Preprocessor.preprocessing_context_manager( + with Evo2Preprocessor.preprocessing_context_manager( seed if seed is not None else None ): return "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( @@ -143,8 +142,8 @@ def _construct_taxonomy_token(lineage: StripedHyena2TaxonomyLineage, dropout: fl lineage.species if random.random() >= dropout else None, ) if lineage is not None else None - def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, config: StipedHyena2PreprocessingConfig): - """Preprocess Evo2 fasta datapaths.""" + def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, config: Evo2PreprocessingConfig): + """Preprocess fasta datapaths.""" # Timing. start = time.time() @@ -183,10 +182,10 @@ def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, con # Construct taxonomy token with random dropout on the lineage categories per sequence. taxonomy_token = self._construct_taxonomy_token(lineage, dropout=config.random_lineage_dropout) - # Inject taxonomy lineage tokens every PROMPT_SPACER_LENGTH tokens in the sequence. + # Inject taxonomy lineage tokens every prompt_spacer_length tokens in the sequence. # If the taxonomy lineage token is not provided, then just take the original sequence. target_length = ( - self.PROMPT_SPACER_LENGTH - len(taxonomy_token) + config.prompt_spacer_length - len(taxonomy_token) if taxonomy_token is not None else None ) @@ -199,8 +198,6 @@ def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, con preproc_data_record = { "text": "".join(taxonomy_injected_sequence), } - if config.include_sequence_id: - preproc_data_record["id"] = f"{seqid}" preproc_data_record["tokens"] = self.tokenizer.tokenize( preproc_data_record["text"], use_ftfy=config.ftfy, @@ -217,7 +214,7 @@ def preprocess_data_task(self, file_sequence_config): return self.preprocess_data(*file_sequence_config) @staticmethod - def _yield_sequences_from_files(config: StipedHyena2PreprocessingConfig, semaphore: Semaphore): + def _yield_sequences_from_files(config: Evo2PreprocessingConfig, semaphore: Semaphore): """Iterator over sequences within multiple input documents. Arguments for multiprocessing tasks. Utilized to limit the amount of sequences streamed into memory. @@ -235,7 +232,7 @@ def yielder(fname, semaphore): semaphore.acquire() yield from yielder(fname, semaphore) - def preprocess_generator(self, preproc_config: StipedHyena2PreprocessingConfig): + def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): """Main function to preprocess data for Evo2.""" # Instantiate multiprocessing pool. Use semaphore to limit the amount of sequences to read into memory. @@ -269,7 +266,7 @@ def preprocess_generator(self, preproc_config: StipedHyena2PreprocessingConfig): sequence["split"] = split yield sequence, elapsed_time - def preprocess_offline(self, preproc_config: StipedHyena2PreprocessingConfig): + def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): """Offline data preprocessing script for Evo2.""" # Validate if binaries have already been produced for the given config and overwrite is set to False. @@ -327,25 +324,29 @@ def preprocess_offline(self, preproc_config: StipedHyena2PreprocessingConfig): def parse_args(): - """Parse arguments for Evo2 preprocessing.""" - parser = argparse.ArgumentParser(description="Preprocess datapaths for Evo2.") - parser.add_argument("-c", "--config", type=str, required=True, help="Path to Evo2 data preprocessing config JSON.") + """Parse arguments for preprocessing.""" + parser = argparse.ArgumentParser(description="Preprocess FASTA files for training Evo2.") + parser.add_argument("-c", "--config", type=str, required=True, help="Path to data preprocessing config JSON.") return parser.parse_args() -if __name__ == "__main__": +def main(): # Parse arguments. args = parse_args() # Read config YAML. with open(args.config, "r") as yaml_fs: - hyena2_preproc_config_batch = yaml.safe_load(yaml_fs) - for config in hyena2_preproc_config_batch: + evo2_preproc_config_batch = yaml.safe_load(yaml_fs) + for config in evo2_preproc_config_batch: start = time.time() - # Convert into StipedHyena2PreprocessingConfig. - hyena2_preproc_config = StipedHyena2PreprocessingConfig(**config) - # Instantiate StipedHyena2Preprocessor. - hyena2_preprocessor = StipedHyena2Preprocessor(hyena2_preproc_config) + # Convert into Evo2PreprocessingConfig. + evo2_preproc_config = Evo2PreprocessingConfig(**config) + # Instantiate Evo2Preprocessor. + evo2_preprocessor = Evo2Preprocessor(evo2_preproc_config) # Preprocess data specified in config. - hyena2_preprocessor.preprocess_offline(hyena2_preproc_config) + evo2_preprocessor.preprocess_offline(evo2_preproc_config) end = time.time() - logging.info(f"Finished preprocessing {hyena2_preproc_config.output_prefix} ({hyena2_preproc_config.datapaths}) in {end - start:.3f} seconds with {hyena2_preproc_config.workers} workers.") + logging.info(f"Finished preprocessing {evo2_preproc_config.output_prefix} ({evo2_preproc_config.datapaths}) in {end - start:.3f} seconds with {evo2_preproc_config.workers} workers.") + + +if __name__ == "__main__": + main() diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py index f5fa96f8da..85b4f1dbe1 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py @@ -18,21 +18,21 @@ from nemo.collections.common.tokenizers.tokenizer_spec import TokenizerSpec from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer -from bionemo.evo2.utils.config import StipedHyena2PreprocessingConfig +from bionemo.evo2.utils.config import Evo2PreprocessingConfig -class StripedHyena2Tokenizer: - """Tokenizer for StripedHyena2.""" +class Evo2Tokenizer: + """Tokenizer for Evo2.""" - def __init__(self, params: StipedHyena2PreprocessingConfig | None = None): - """Initialize the StripedHyena2Tokenizer.""" - # Pass all NeMo2/Megatron-compliant parameters associated with config.StipedHyena2PreprocessingConfig. - self.params: StipedHyena2PreprocessingConfig = params if params is not None else StipedHyena2PreprocessingConfig() + def __init__(self, params: Evo2PreprocessingConfig | None = None): + """Initialize the Evo2Tokenizer.""" + # Pass all NeMo2/Megatron-compliant parameters associated with config.Evo2PreprocessingConfig. + self.params: Evo2PreprocessingConfig = params if params is not None else Evo2PreprocessingConfig() self.tokenizer: TokenizerSpec = get_nmt_tokenizer( library=self.params.tokenizer_type.lower(), vocab_file=str(self.params.vocab_file) if self.params.vocab_file is not None else None, merges_file=str(self.params.merges_file) if self.params.merges_file is not None else None, - model_name=self.params.pretrained_tokenizer_model, + model_name=self.params.tokenizer_model_name, tokenizer_model=self.params.pretrained_tokenizer_model, special_tokens=self.params.special_tokens, use_fast=self.params.fast_hf_tokenizer, @@ -46,7 +46,7 @@ def tokenize( append_eod: bool = False, drop_empty_sequences: bool = False, ): - """Tokenize the input text data for StripedHyena2.""" + """Tokenize the input text data for Evo2.""" if isinstance(text, str): text = [text] # Tokenize a document or batch of strings. @@ -58,19 +58,19 @@ def tokenize( text_ids: list = self.tokenizer.text_to_ids(t) if drop_empty_sequences and len(text_ids) == 0: continue - # Append EOD token if appropriate. + # Append EOD token (EOD ID: 0) if appropriate. eod_length = int(append_eod and l == len(text) - 1) token_length = len(text_ids) + eod_length - text_ids += [self.tokenizer.eod] * eod_length + text_ids += [0] * eod_length if enforce_sample_length is not None: - # Pad shorter sequences and except excessive sequences. + # Pad shorter sequences (Pad ID: 1) and except excessive sequences. if token_length > enforce_sample_length: raise ValueError( "Detected input text with a length greater than the maximum " f"possible sample length of {enforce_sample_length}.)" ) else: - text_ids += [self.tokenizer.pad] * (enforce_sample_length - token_length) + text_ids += [1] * (enforce_sample_length - token_length) # Append to document. doc_ids.append(text_ids) return doc_ids diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 3e7ac10d06..2cbb001699 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -20,6 +20,7 @@ import torch from megatron.core.inference.common_inference_params import CommonInferenceParams from nemo.collections.llm import generate +from nemo.utils import logging def parse_args(): @@ -36,28 +37,20 @@ def parse_args(): + "g__Escherichia;" + "s__Escherichia|" ) - ap.add_argument("--prompt", type=str, default=default_prompt, help="Prompt for generation") + ap.add_argument("--prompt", type=str, default=default_prompt, help="Prompt to generate text from Evo2. Defaults to a phylogenetic lineage tag for E coli.") ap.add_argument( - "--ckpt-dir", type=str, required=True, help="Path to checkpoint directory containing pre-trained Hyena model." + "--ckpt-dir", type=str, required=True, help="Path to checkpoint directory containing pre-trained Evo2 model." ) - ap.add_argument("--temperature", type=float, default=1.0, help="Temperature during sampling") - ap.add_argument("--top-k", type=int, default=0, help="Top K during sampling") - ap.add_argument("--top-p", type=float, default=0.0, help="Top P during sampling") - ap.add_argument("--cached-generation", type=bool, default=True, help="Use KV caching during generation") - ap.add_argument("--max-new-tokens", type=int, default=1024, help="Max new tokens during sampling") - ap.add_argument("--repetition-penalty", type=float, default=1.0, help="Repetition penalty during sampling") - ap.add_argument("--penalty-alpha", type=float, default=0.0, help="Penalty alpha during sampling") + ap.add_argument("--temperature", type=float, default=1.0, help="Temperature during sampling for generation.") + ap.add_argument("--top-k", type=int, default=0, help="Top K during sampling for generation.") + ap.add_argument("--top-p", type=float, default=0.0, help="Top P during sampling for generation.") + ap.add_argument("--max-new-tokens", type=int, default=1024, help="Maximum number of tokens to generate.") # compute args: - ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Tensor Parallel Size") - ap.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Pipeline Parallel Size") - ap.add_argument("--context-parallel-size", type=int, default=1, help="Context Parallel Size") + ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1.") + ap.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Order of pipeline parallelism. Defaults to 1.") + ap.add_argument("--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1.") # output args: - ap.add_argument("--sequence-fasta", type=str, default="sequence.fasta", help="Sequence fasta file") - ap.add_argument("--proteins-fasta", type=str, default="proteins.fasta", help="Proteins fasta file") - ap.add_argument("--structure-pdb", type=str, default="structure.pdb", help="Structure PDB file") - # misc args: - ap.add_argument("--devices", type=str, default="cuda:0", help="Device for generation") - ap.add_argument("--seed", type=int, default=12345, help="Random seed") + ap.add_argument("--output-file", type=str, default=None, help="Output file containing the generated text produced by the Evo2 model. If not provided, the output will be logged.") return ap.parse_args() @@ -103,9 +96,13 @@ def main(): ), text_only=True, ) - + if torch.distributed.get_rank() == 0: - print(results) + if args.output_file is None: + logging.info(results) + else: + with open(args.output_file, "w") as f: + f.write(f"{results}\n") if __name__ == "__main__": diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index df5822960d..ddbe7d3dd1 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -39,7 +39,7 @@ from nemo.lightning.pytorch.strategies.utils import RestoreConfig from nemo.utils.exp_manager import TimingCallback -from bionemo.evo2.utils.config import StipedHyena2BlendedDatasetConfig +from bionemo.evo2.utils.config import Evo2BlendedDatasetConfig from bionemo.llm.utils.datamodule_utils import infer_global_batch_size @@ -68,7 +68,7 @@ def parse_args(): parser.add_argument( "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." ) - parser.add_argument("--wandb-project", type=str, default="bionemo_hyena", help="Wandb project name") + parser.add_argument("--wandb-project", type=str, default="bionemo_evo2", help="Wandb project name") parser.add_argument("--wandb-run-id", type=str, default=None, help="Wandb run identifier") parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallelism.") parser.add_argument("--fp8", action="store_true", help="Set to enable FP8") @@ -241,12 +241,12 @@ def parse_dataset_config(dataset_config_path: str): dataset_config_batch = yaml.safe_load(config_file) for dataset_config in dataset_config_batch: # Validate. - config_model = StipedHyena2BlendedDatasetConfig(**dataset_config) + config_model = Evo2BlendedDatasetConfig(**dataset_config) # Integrate the weights for renormalization. weight_sums[config_model.dataset_split] += abs(config_model.dataset_weight) for dataset_config in dataset_config_batch: # Validate. - config_model = StipedHyena2BlendedDatasetConfig(**dataset_config) + config_model = Evo2BlendedDatasetConfig(**dataset_config) # Add indexed dataset to split and associate with blended training weight. blended_dataset_config[config_model.dataset_split].extend( [config_model.dataset_weight / weight_sums[config_model.dataset_split], config_model.dataset_prefix] @@ -292,16 +292,16 @@ def main(): ) if args.model_size == "7b": - hyena_config = llm.Hyena7bConfig() + evo2_config = llm.Hyena7bConfig() elif args.model_size == "40b": - hyena_config = llm.Hyena40bConfig() + evo2_config = llm.Hyena40bConfig() elif args.model_size == "test": - hyena_config = llm.HyenaTestConfig() + evo2_config = llm.HyenaTestConfig() else: raise ValueError(f"Invalid model size: {args.model_size}") - hyena_config.seq_length = args.seq_length - model = llm.GPTModel(hyena_config, tokenizer=data.tokenizer) + evo2_config.seq_length = args.seq_length + model = llm.GPTModel(evo2_config, tokenizer=data.tokenizer) # Setup callbacks. checkpoint_callback = ModelCheckpoint( @@ -313,7 +313,7 @@ def main(): save_context_on_train_end=True, ) flop_meas_callback = FLOPsMeasurementCallback( - asdict(hyena_config), + asdict(evo2_config), data, "hyena", ) @@ -371,14 +371,14 @@ def main(): loggers = [] wandb_logger = WandbLogger( name=( - f"hyena-size-{args.model_size}-TP{args.tensor_parallel_size}-" + f"evo2-size-{args.model_size}-TP{args.tensor_parallel_size}-" f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" f"-GBS{global_batch_size}-MBS{args.micro_batch_size}" f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" f"-NODES{args.num_nodes}-FP8{args.fp8}" ), id=args.wandb_run_id, # set this to use the same curve name for restarts. - project="bionemo_hyena", + project="bionemo_evo2", save_dir=args.experiment_dir, ) loggers.append(wandb_logger) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index c283446883..f5317e0f61 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -20,14 +20,14 @@ from pydantic import BaseModel -class StipedHyena2BlendedDatasetConfig(BaseModel): +class Evo2BlendedDatasetConfig(BaseModel): """Pydantic model class that specifies indexed datasets, dataset weights, and datasplits assignments for training.""" dataset_prefix: None | str = None dataset_weight: None | float = None dataset_split: Literal["train", "validation", "test"] -class StripedHyena2TaxonomyLineage(BaseModel): +class Evo2TaxonomyLineage(BaseModel): """Pydantic model class that defines the source lineage of a DNA sequence.""" kingdom: None | str = None phylum: None | str = None @@ -38,7 +38,7 @@ class StripedHyena2TaxonomyLineage(BaseModel): species: None | str = None -class StipedHyena2PreprocessingConfig(BaseModel): +class Evo2PreprocessingConfig(BaseModel): """Pydantic model class specifying the configuration schema for a preprocessed IndexedDataset (.bin, .idx).""" # Paths datapaths: list[Path] = [] @@ -54,11 +54,14 @@ class StipedHyena2PreprocessingConfig(BaseModel): embed_reverse_complement: bool = False random_reverse_complement: float = 0.0 random_lineage_dropout: float = 0.0 - include_sequence_id: bool = False transcribe: None | Literal["transcribe", "back_transcribe"] = None force_uppercase: bool = False indexed_dataset_dtype: str = "uint8" - # Tokenizer + # Tokenization Transforms + append_eod: bool = False + enforce_sample_length: None | int = None + ftfy: bool = False + # NeMo Tokenizer Configuration tokenizer_type: Literal[ "Byte-Level", "HuggingFace", @@ -70,16 +73,13 @@ class StipedHyena2PreprocessingConfig(BaseModel): vocab_file: None | Path = None vocab_size: None | int = 512 merges_file: None | Path = None - # Either a named pretrained tokenizer model, or a path to a SentencePiece tokenizer. + tokenizer_model_name: None | str = None pretrained_tokenizer_model: None | str = None special_tokens: None | dict[str, str] = {} fast_hf_tokenizer: bool = False - append_eod: bool = False - enforce_sample_length: None | int = None - ftfy: bool = False - # Compute - # NOTE: If preprocessing short individual sequences (< 1000 bp), do NOT use multiprocessing - # (workers > 1) because sequence-level parallel IPC will dominate the preprocessing time! + # Compute Configuration + # NOTE: If preprocessing a large amount of short individual sequences (< 1000 bp), do NOT use + # multiprocessing (workers > 1) because sequence-level parallel IPC will dominate the preprocessing time! workers: int = 1 preproc_concurrency: int = 100000 chunksize: int = 1 @@ -88,6 +88,8 @@ class StipedHyena2PreprocessingConfig(BaseModel): nnn_filter: bool = False # RNG seed: None | int = None - # StipedHyena2 Taxonomic Lineage Tags + # Evo2 Taxonomic Lineage Tags # SeqID Sub-String Indexing: "ABC" will have taxonomy data from "A". - taxonomy_data: dict[str, StripedHyena2TaxonomyLineage] = {} \ No newline at end of file + taxonomy_data: dict[str, Evo2TaxonomyLineage] = {} + # Periodicity of injecting phylogenetic lineage tags in the sequence prior to tokenization. + prompt_spacer_length: int = 131072 \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/tests/README.md b/sub-packages/bionemo-evo2/tests/README.md index 177ebe7f20..f3e523b303 100644 --- a/sub-packages/bionemo-evo2/tests/README.md +++ b/sub-packages/bionemo-evo2/tests/README.md @@ -1 +1 @@ -Tests for BioNeMo StripedHyena2. +Tests for BioNeMo Evo2. diff --git a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml index 9d624854b1..2d81a550c0 100644 --- a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml +++ b/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml @@ -11,22 +11,22 @@ embed_reverse_complement: true random_reverse_complement: 0.0 random_lineage_dropout: 0.1 - include_sequence_id: false transcribe: "back_transcribe" force_uppercase: true indexed_dataset_dtype: "uint8" + # Tokenizer Transforms + append_eod: true + enforce_sample_length: null + ftfy: false # Tokenizer tokenizer_type: "Byte-Level" vocab_file: null vocab_size: null merges_file: null - # Either a named pretrained tokenizer model, or a path to a SentencePiece tokenizer. + tokenizer_model_name: null pretrained_tokenizer_model: null special_tokens: null fast_hf_tokenizer: true - append_eod: true - enforce_sample_length: null - ftfy: false # Compute workers: 1 preproc_concurrency: 100000 @@ -36,7 +36,7 @@ nnn_filter: true # RNG seed: 42 - # StipedHyena2 Taxonomic Lineage Tags + # Evo2 Taxonomic Lineage Tags taxonomy_data: FP002272: kingdom: KINGDOM From f5b15f36aa29a52820672adce42e73077bd39c92 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Wed, 8 Jan 2025 11:09:46 -0800 Subject: [PATCH 020/140] [cye/transcript-readme] Add main documentation snippets for Hyena, and add transcript splicing script for preprocessing. --- sub-packages/bionemo-evo2/README.md | 160 ++++++++- sub-packages/bionemo-evo2/pyproject.toml | 1 + .../bionemo-evo2/src/bionemo/evo2/README.md | 1 - .../src/bionemo/evo2/data/README.md | 30 ++ .../evo2/data/transcript_extraction.py | 306 ++++++++++++++++++ sub-packages/bionemo-evo2/tests/README.md | 1 - 6 files changed, 496 insertions(+), 3 deletions(-) delete mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/README.md create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py delete mode 100644 sub-packages/bionemo-evo2/tests/README.md diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 39916f40d4..9056770151 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -1 +1,159 @@ -Library containing data preprocessing, training, and inference tooling for Evo2. +# bionemo-evo2 + +`bionemo-evo2` is a `pip`-installable package that contains **data preprocessing**, **training**, and **inferencing** code for Evo2, a new `Hyena`-based foundation model for genome generation and understanding. Built upon `Megatron-LM` parallelism and `NeMo2` algorithms, `bionemo-evo2` provides the remaining tools necessary to effectively fine-tune the pre-trained Evo2 model checkpoint on user-provided sequences at scale, and generate state-of-the-art life-like DNA sequences from Evo2 for downstream metagenomic tasks. + +## Installation + +To install this package, execute the following command: +```bash +pip install -e . +``` + +To run unit tests, execute the following command: +```bash +pytest -v . +``` + +## Preprocessing + +To train or fine-tune Evo2 on a custom dataset, we need to preprocess and index sequence data for training from raw FASTA files into tokenized binaries compliant with `NeMo2` / `Megatron-LM`. For more information about how to configure your data for training, refer to [data/README.md](src/bionemo/evo2/data/README.md) and [utils.config.Evo2PreprocessingConfig](src/bionemo/evo2/utils/config.py). + +```bash +preprocess_evo2 -c +``` + +## Training + +Given a preprocessed collection of preprocessed datasets, and optionally a pre-trained NeMo2 checkpoint for Evo2, training can be executed using the following command: + +```bash +$ train_evo2 --help +usage: train_evo2 [-h] -d DATASET_CONFIG [--num-nodes NUM_NODES] [--devices DEVICES] [--seq-length SEQ_LENGTH] [--tensor-parallel-size TENSOR_PARALLEL_SIZE] [--pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE] [--context-parallel-size CONTEXT_PARALLEL_SIZE] [--wandb-project WANDB_PROJECT] [--wandb-run-id WANDB_RUN_ID] + [--sequence-parallel] [--fp8] [--micro-batch-size MICRO_BATCH_SIZE] [--global-batch-size GLOBAL_BATCH_SIZE] [--grad-acc-batches GRAD_ACC_BATCHES] [--max-steps MAX_STEPS] [--val-check-interval VAL_CHECK_INTERVAL] [--grad-reduce-in-fp32] [--no-aligned-megatron-ddp] [--use-megatron-comm-overlap-llama3-8k] [--align-param-gather] [--straggler-detection] [--model-size {7b,40b,test}] [--experiment-dir EXPERIMENT_DIR] [--limit-val-batches LIMIT_VAL_BATCHES] [--ckpt-dir CKPT_DIR] [--restore-optimizer-from-ckpt] [--seed SEED] [--workers WORKERS] [--gc-interval GC_INTERVAL] [--enable-preemption] [--ckpt-async-save] [--nsys-profiling] [--nsys-start-step NSYS_START_STEP] [--nsys-end-step NSYS_END_STEP] [--nsys-ranks NSYS_RANKS [NSYS_RANKS ...]] + +Train a Hyena model using NeMo 2.0. + +options: + -h, --help show this help message and exit + -d DATASET_CONFIG, --dataset-config DATASET_CONFIG + Path to the blended / weighted training dataset configuration YAML. + --num-nodes NUM_NODES + Number of nodes to use for training, defaults to 1. + --devices DEVICES Number of devices to use for training, defaults to 1. + --seq-length SEQ_LENGTH + Training sequence length + --tensor-parallel-size TENSOR_PARALLEL_SIZE + Order of tensor parallelism. Defaults to 1. + --pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE + Order of pipeline parallelism. Defaults to 1. + --context-parallel-size CONTEXT_PARALLEL_SIZE + Order of context parallelism. Defaults to 1. + --wandb-project WANDB_PROJECT + Wandb project name + --wandb-run-id WANDB_RUN_ID + Wandb run identifier + --sequence-parallel Set to enable sequence parallelism. + --fp8 Set to enable FP8 + --micro-batch-size MICRO_BATCH_SIZE + Micro-batch size for data-parallel training. + --global-batch-size GLOBAL_BATCH_SIZE + Global batch size for training. If set to None, infer it from the TP, CP, and PP parameters. + --grad-acc-batches GRAD_ACC_BATCHES + Number of batches to accumulate gradients over. + --max-steps MAX_STEPS + Number of training optimizer update steps. + --val-check-interval VAL_CHECK_INTERVAL + Number of steps between validation measurements and model checkpoints. + --grad-reduce-in-fp32 + Gradient reduce in FP32. + --no-aligned-megatron-ddp + Do not do aligned gradient updates etc. + --use-megatron-comm-overlap-llama3-8k + --align-param-gather + --straggler-detection + --model-size {7b,40b,test} + Model size, choose between 7b, 40b, or test (4 layers, less than 1b). + --experiment-dir EXPERIMENT_DIR + Directory to write model checkpoints and results to. + --limit-val-batches LIMIT_VAL_BATCHES + Number of validation steps + --ckpt-dir CKPT_DIR Directory to restore an initial checkpoint from. Use this for supervised fine-tuning. + --restore-optimizer-from-ckpt + Restore optimizer state from initial checkpoint. Defaults to False. + --seed SEED Set random seed for training. + --workers WORKERS Number of workers to use for data loading. + --gc-interval GC_INTERVAL + Set to a value > 0 if you want to synchronize garbage collection, will do gc every gc-interval steps. + --enable-preemption Enable preemption hooks. If enabled this will save a checkpoint whenver slurm exits. + --ckpt-async-save + --nsys-profiling Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling output you must run the whole program with `nsys`. For example: `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true --capture-range=cudaProfilerApi --capture-range-end=stop [regular python + command here]` + --nsys-start-step NSYS_START_STEP + Start nsys profiling after this step. + --nsys-end-step NSYS_END_STEP + End nsys profiling after this step. + --nsys-ranks NSYS_RANKS [NSYS_RANKS ...] + Enable nsys profiling for these ranks. +``` + +To supply a pre-trained checkpoint, pass the NeMo2 checkpoint directory to `--ckpt-dir`, and the script will dump newly trained checkpoints and logs to `--experiment-dir`. However, if there are existing well-defined checkpoints in the directory specified by `--experiment-dir`, the script will automatically resume training from the most recent checkpoint in the experiment directory instead of starting from the checkpoint specified by `--ckpt-dir`, which streamlines long training sessions. (To disable this behavior, supply a new or clean `--experiment-dir` when restarting from `--ckpt-dir`.) + +Training data and sampling weights can be specified using the `--dataset-config` argument as a YAML file adhering to the following schema: [utils.config.Evo2BlendedDatasetConfig](src/bionemo/evo2/utils/config.py). For more information about dataset sampling and blending during training with Megatron-LM, refer to [megatron/core/datasets/readme.md](https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/datasets/readme.md). For example: + +```yaml +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.18 +- dataset_prefix: /workspace/bionemo2/data/gtdb_imgpr/pretraining_data_gtdb_imgpr/data_gtdb_imgpr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.24 +- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.03 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.0003 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.18 +- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.24 +``` + +## Inference + +Once you have a pre-trained or fine-tuned Evo2 checkpoint, you can also prompt the model to generate DNA sequences using the following command: + +```bash +$ infer_evo2 --help +usage: infer_evo2 [-h] [--prompt PROMPT] --ckpt-dir CKPT_DIR [--temperature TEMPERATURE] [--top-k TOP_K] [--top-p TOP_P] [--max-new-tokens MAX_NEW_TOKENS] [--tensor-parallel-size TENSOR_PARALLEL_SIZE] [--pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE] [--context-parallel-size CONTEXT_PARALLEL_SIZE] [--output-file OUTPUT_FILE] + +options: + -h, --help show this help message and exit + --prompt PROMPT Prompt to generate text from Evo2. Defaults to a phylogenetic lineage tag for E coli. + --ckpt-dir CKPT_DIR Path to checkpoint directory containing pre-trained Evo2 model. + --temperature TEMPERATURE + Temperature during sampling for generation. + --top-k TOP_K Top K during sampling for generation. + --top-p TOP_P Top P during sampling for generation. + --max-new-tokens MAX_NEW_TOKENS + Maximum number of tokens to generate. + --tensor-parallel-size TENSOR_PARALLEL_SIZE + Order of tensor parallelism. Defaults to 1. + --pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE + Order of pipeline parallelism. Defaults to 1. + --context-parallel-size CONTEXT_PARALLEL_SIZE + Order of context parallelism. Defaults to 1. + --output-file OUTPUT_FILE + Output file containing the generated text produced by the Evo2 model. If not provided, the output will be logged. +``` + +As in `train_evo2`, `--ckpt-dir` points to the NeMo2 checkpoint directory for Evo2 that you want to load for inference. `--output-file` can be used to dump the output into a `.txt` file, and if not specified the output will be logged in the terminal. + +``` +[NeMo I 2025-01-06 17:22:22 infer:102] ['CTCTTCTGGTATTTGG'] +``` \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index 0be5739b09..2179dd5d6a 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -18,6 +18,7 @@ dependencies = [ infer_evo2 = "bionemo.evo2.run.infer:main" train_evo2 = "bionemo.evo2.run.train:main" preprocess_evo2 = "bionemo.evo2.data.preprocess:main" +splice_evo2 = "bionemo.evo2.data.transcript_extraction:main" [tool.setuptools.packages.find] where = ["src"] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md deleted file mode 100644 index 982a6ec28d..0000000000 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/README.md +++ /dev/null @@ -1 +0,0 @@ -Source code for BioNeMo Evo2. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md index 48f7bc3e09..340bb94631 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md @@ -189,3 +189,33 @@ True >>> all_our_data == all_ref_data True ``` + +## Sequence Splicing & Stitching + +Evo2 has also been trained on spliced DNA and mRNA sequences, where introns are removed leaving only the concatenated exons of the genome. Moreover, "stitched" variants of spliced transcripts have been introduced into Evo2's training dataset, which include 1024 bp of sequence from the promoter and 32 bp around each exon. + +To perform splicing or "stitched" splicing on sequences in a FASTA file given an associated gene transfer format (GTF) file, execute the following command: +```bash +$ splice_evo2 --help +usage: splice_evo2 [-h] --fasta-path FASTA_PATH --gtf-path GTF_PATH [--output-path OUTPUT_PATH] [--transcript-type {default,stitched}] [--stitched-promoter STITCHED_PROMOTER] [--stitched-intron STITCHED_INTRON] [--stitched-overlap] [--only-longest-transcript] [-v] + +Extract spliced transcripts from a FASTA and GTF. + +options: + -h, --help show this help message and exit + --fasta-path FASTA_PATH + Path to FASTA file to extract transcripts from. + --gtf-path GTF_PATH Path to gene transfer format (GTF) file associated with the FASTA. + --output-path OUTPUT_PATH + Path to output FASTA file. + --transcript-type {default,stitched} + Type of transcript to extract from the GTF and FASTA files for splicing. 'Stitched' transcripts include 1024 bp of sequence from the promoter and 32 bp around each exon. + --stitched-promoter STITCHED_PROMOTER + Number of bp to include in the promoter region when --transcript-type=stitched is used. Defaults to 1024. + --stitched-intron STITCHED_INTRON + Number of bp to include from neighboring introns when --transcript-type=stitched is used. Defaults to 32. + --stitched-overlap Allow overlap of neighboring intron windows when --transcript-type=stitched is used. Defaults to False, i.e. prevents overlap by shortening the intron windows for a contiguous splice. + --only-longest-transcript + Only extract the longest transcript per gene. + -v, --verbose Turn on verbose log messages. +``` \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py new file mode 100644 index 0000000000..873bc4a27d --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py @@ -0,0 +1,306 @@ +import argparse +from collections import defaultdict +import math +import re +import sys +from bionemo.noodles import back_transcribe_sequence, complement_sequence, reverse_sequence, transcribe_sequence +from bionemo.noodles.nvfaidx import NvFaidx +from nemo.utils import logging + +def parse_gtf_attributes(attributes: str): + # Split on all semicolons that are not inside quotes + attributes = re.split(r';(?=(?:[^"]*"[^"]*")*[^"]*$)', attributes) + out = dict() + for a in attributes: + if len(a) == 0: + continue + key = a.split()[0] + value = a.split('"')[1] + out[key] = value + return out + +def extract_transcript_exons(gtf_path: str, only_longest_transcript: bool): + + genes = defaultdict(set) + gene2transcripts = defaultdict(set) + transcripts = dict() + exons = dict() + exon2transcript = dict() + transcript2gene = dict() + transcript2exon = defaultdict(set) + skip_transcripts = set() + + gtf_fields = ['seqname', 'source', 'feature', 'start', 'end', 'score', 'strand', 'frame', 'attribute'] + with open(gtf_path) as infile: + for line in infile: + # skip header lines + if line.startswith("#"): continue + line = line.strip().split("\t") + if len(line) < 9: + continue + + # parse the attributes into a dictionary + line = dict(zip(gtf_fields, line)) + attribs = parse_gtf_attributes(line['attribute']) + + if line['feature'] == 'gene': + contig, start, end, strand = line['seqname'], line['start'], line['end'], line['strand'] + start, end = int(line['start'])-1, int(line['end']) + try: + gene_id = attribs['gene_id'] + except: + continue + genes[gene_id].add((contig, start, end, strand)) + + elif line['feature'] == 'exon': + contig, start, end, strand = line['seqname'], line['start'], line['end'], line['strand'] + start, end = int(line['start'])-1, int(line['end']) + try: + gene_id = attribs['gene_id'] + except: + continue + transcript_id = attribs['transcript_id'] + gene2transcripts[gene_id].add(transcript_id) + + # Skip exons that have already been handled and are likely errors + if transcript_id in skip_transcripts: + continue + exon_number = int(attribs['exon_number']) + + exon_id = (gene_id, transcript_id, exon_number) + if exon_id in exons: + del exons[exon_id] + if transcript_id in transcripts: + del transcripts[transcript_id] + if transcript_id in transcript2exon: + del transcript2exon[transcript_id] + skip_transcripts.add(transcript_id) + continue + + exons[exon_id] = {"seqname":contig, "start":start, "end":end, "strand":strand} + if exon_id in exon2transcript: + raise Exception("Exon Already Exists in exon2transcript") + exon2transcript[exon_id] = transcript_id + transcript2exon[transcript_id].add(exon_id) + + elif line['feature'] == 'transcript': + contig, start, end, strand = line['seqname'], line['start'], line['end'], line['strand'] + start, end = int(line['start'])-1, int(line['end']) + try: + gene_id = attribs['gene_id'] + except: + continue + + gbkey = attribs['gbkey'] + transcript_biotype = attribs['transcript_biotype'] + transcript_id = attribs['transcript_id'] + if transcript_id in skip_transcripts: + continue + + transcripts[transcript_id] = {"seqname":contig, "start":start, "end":end, "strand":strand, "gbkey":gbkey, "transcript_biotype":transcript_biotype} + transcript2gene[transcript_id] = gene_id + gene2transcripts[gene_id].add(transcript_id) + + if only_longest_transcript: + transcript_lengths = defaultdict(int) + for exon in exons: + transcript_lengths[exon[1]] += exons[exon]['end'] - exons[exon]['start'] + + keep_transcripts = dict() + keep_exons = dict() + keep_exon2transcript = dict() + keep_transcript2gene = dict() + keep_transcript2exon = defaultdict(set) + keep_skip_transcripts = set() + + for gene in gene2transcripts: + this_transcripts = gene2transcripts[gene] + this_transcript_lengths = [(transcript, transcript_lengths[transcript]) for transcript in this_transcripts] + longest_transcript = max(this_transcript_lengths, key=lambda x: x[1])[0] + keep_transcripts[longest_transcript] = dict(transcripts[longest_transcript]) + for exon in transcript2exon[longest_transcript]: + keep_exons[exon] = dict(exons[exon]) + keep_exon2transcript[exon] = longest_transcript + keep_transcript2exon[longest_transcript].add(exon) + keep_transcript2gene[longest_transcript] = gene + + transcripts = keep_transcripts + exons = keep_exons + exon2transcript = keep_exon2transcript + transcript2gene = keep_transcript2gene + transcript2exon = keep_transcript2exon + skip_transcripts = keep_skip_transcripts + + return { + 'transcripts': transcripts, + 'exons': exons, + 'exon2transcript': exon2transcript, + 'transcript2gene': transcript2gene, + 'transcript2exon': transcript2exon + } + +def extract_default_transcript_sequences(transcript_info, fasta_records, output_file): + + for transcript_id in transcript_info['transcripts']: + gene_id = transcript_info['transcript2gene'][transcript_id] + this_exons = list(sorted(transcript_info['transcript2exon'][transcript_id], key=lambda x: x[-1])) + + seqname = None + exon_qc_failed = False + if len(this_exons) > 1: + for i in range(1, len(this_exons)): + this_exon = this_exons[i] + prev_exon = this_exons[i-1] + this_coords = transcript_info['exons'][this_exon] + prev_coords = transcript_info['exons'][prev_exon] + if this_coords['strand'] != prev_coords['strand']: + exon_qc_failed = True + if this_coords['strand'] == '+' and this_coords['start'] < prev_coords['start']: + exon_qc_failed = True + if this_coords['strand'] == '-' and this_coords['start'] > prev_coords['start']: + exon_qc_failed = True + if this_coords['seqname'] != prev_coords['seqname']: + exon_qc_failed = True + + if exon_qc_failed: + continue + + transcript_seq = '' + for exon in this_exons: + coords = transcript_info['exons'][exon] + if seqname is None: + seqname = coords['seqname'] + exon_seq = str(fasta_records[coords['seqname']][coords['start']:coords['end']]) + if coords['strand'] == '-': + exon_seq = reverse_sequence(complement_sequence(exon_seq)) + transcript_seq += exon_seq + + print(f'>{seqname}|{gene_id}|{transcript_id}\n{transcript_seq}', file=output_file) + +def extract_stitched_transcript_sequences(transcript_info, fasta_records, output_file, stitch_token='@', promoter_size=1024, intron_window=32, overlap=False): + + for transcript_id in transcript_info['transcripts']: + gene_id = transcript_info['transcript2gene'][transcript_id] + this_exons = list(sorted(transcript_info['transcript2exon'][transcript_id], key=lambda x: x[-1])) + + exon_qc_failed = False + if len(this_exons) > 1: + for i in range(1, len(this_exons)): + this_exon = this_exons[i] + prev_exon = this_exons[i-1] + this_coords = transcript_info['exons'][this_exon] + prev_coords = transcript_info['exons'][prev_exon] + if this_coords['strand'] != prev_coords['strand']: + exon_qc_failed = True + if this_coords['strand'] == '+' and this_coords['start'] < prev_coords['start']: + exon_qc_failed = True + if this_coords['strand'] == '-' and this_coords['start'] > prev_coords['start']: + exon_qc_failed = True + if this_coords['seqname'] != prev_coords['seqname']: + exon_qc_failed = True + + if exon_qc_failed: + continue + + transcript_seq = "" + seqname = None + for i in range(len(this_exons)): + # Previous Exon + prev_exon = this_exons[i-1] if i > 0 else None + prev_coords = transcript_info['exons'].get(prev_exon, None) + # Current Exon + cur_exon = this_exons[i] + cur_coords = transcript_info['exons'].get(cur_exon, None) + exon_number = cur_exon[-1] + if seqname is None: + seqname = cur_coords['seqname'] + # Next Exon + next_exon = this_exons[i+1] if i < len(this_exons)-1 else None + next_coords = transcript_info['exons'].get(next_exon, None) + # Extract the stitched spliced sequence without overlapping intron windows. + intron_window_left = min(intron_window, math.floor(abs(cur_coords['start'] - prev_coords['end']) / 2)) if not overlap and prev_coords is not None else intron_window + intron_window_right = min(intron_window, math.ceil(abs(next_coords['start'] - cur_coords['end']) / 2)) if not overlap and next_coords is not None else intron_window + if cur_coords['strand'] == '+' and exon_number == 1: + exon_start = cur_coords['start'] - promoter_size + exon_end = cur_coords['end'] + intron_window_right + elif cur_coords['strand'] == '-' and exon_number == 1: + exon_start = cur_coords['start'] - intron_window_left + exon_end = cur_coords['end'] + promoter_size + else: + exon_start = cur_coords['start'] - intron_window_left + exon_end = cur_coords['end'] + intron_window_right + exon_seq = str(fasta_records[cur_coords['seqname']][exon_start:exon_end]) + if cur_coords['strand'] == '-': + exon_seq = stitch_token + reverse_sequence(complement_sequence(exon_seq)) + transcript_seq += exon_seq + + if stitch_token and len(stitch_token) > 0: + transcript_seq = transcript_seq[len(stitch_token):] + + print(f'>{seqname}|{gene_id}|{transcript_id}\n{transcript_seq}', file=output_file) + +def run(args): + + with ( + open(args.output_path, "w") if args.output_path is not None else sys.stdout + ) as output_file: + + if args.verbose: + logging.info("Indexing FASTA file...") + + fasta_index = NvFaidx(args.fasta_path) + + if args.transcript_type == 'default': + if args.verbose: + logging.info("Extracting default transcripts...") + if args.only_longest_transcript: + logging.info("Only extracting the longest transcript per gene.") + else: + logging.info("Extracting all transcripts regardless of length.") + + elif args.transcript_type == 'stitched': + if args.verbose: + logging.info("Extracting stitched transcripts...") + if args.only_longest_transcript: + logging.info("Only extracting the longest transcript per gene.") + else: + logging.info("Extracting all transcripts regardless of length.") + + transcript_info = extract_transcript_exons(args.gtf_path, args.only_longest_transcript) + + if args.transcript_type == 'default': + extract_default_transcript_sequences(transcript_info, fasta_index, output_file) + elif args.transcript_type == 'stitched': + extract_stitched_transcript_sequences( + transcript_info, + fasta_index, + output_file, + promoter_size=args.stitched_promoter, + intron_window=args.stitched_intron, + overlap=args.stitched_overlap + ) + +def parse_args(): + """Parse command line arguments for splicing transcripts.""" + ap = argparse.ArgumentParser(description="Extract spliced transcripts from a FASTA and GTF.") + ap.add_argument("--fasta-path", type=str, required=True, help="Path to FASTA file to extract transcripts from.") + ap.add_argument("--gtf-path", type=str, required=True, help="Path to gene transfer format (GTF) file associated with the FASTA.") + ap.add_argument("--output-path", type=str, default=None, help="Path to output FASTA file.") + ap.add_argument("--transcript-type", type=str, default="default", choices=['default','stitched'], + help="Type of transcript to extract from the GTF and FASTA files for splicing. 'Stitched' transcripts include 1024 bp of sequence from the promoter and 32 bp around each exon.") + ap.add_argument("--stitched-promoter", type=int, default=1024, help="Number of bp to include in the promoter region when --transcript-type=stitched is used. Defaults to 1024.") + ap.add_argument("--stitched-intron", type=int, default=32, help="Number of bp to include from neighboring introns when --transcript-type=stitched is used. Defaults to 32.") + ap.add_argument("--stitched-overlap", action='store_true', + help="Allow overlap of neighboring intron windows when --transcript-type=stitched is used. Defaults to False, i.e. prevents overlap by shortening the intron windows for a contiguous splice.") + ap.add_argument("--only-longest-transcript", action='store_true', help="Only extract the longest transcript per gene.") + ap.add_argument("-v", "--verbose", action='store_true', help="Turn on verbose log messages.") + return ap.parse_args() + +def main(): + args = parse_args() + if args.verbose: + logging.info(args) + run(args) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/tests/README.md b/sub-packages/bionemo-evo2/tests/README.md deleted file mode 100644 index f3e523b303..0000000000 --- a/sub-packages/bionemo-evo2/tests/README.md +++ /dev/null @@ -1 +0,0 @@ -Tests for BioNeMo Evo2. From 9ba9e07f52bdde853e45780c3e86e18da3c5ee98 Mon Sep 17 00:00:00 2001 From: John St John Date: Thu, 9 Jan 2025 17:18:17 -0800 Subject: [PATCH 021/140] Bump nemo version to the new context length insensitive code, and update test to use new checkpoint --- 3rdparty/NeMo | 2 +- .../src/bionemo/core/data/resources/evo2.yaml | 8 ++++---- .../bionemo-evo2/tests/bionemo/test_evo2.py | 16 ++++++++-------- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index d2b45c3ab5..96cca681f4 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit d2b45c3ab53a2a1a1d87bce4ad77ee0d5d7bcc5d +Subproject commit 96cca681f47ad452ef3f2bc304518a5ceb25644f diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index 3faa65e196..cde355a43b 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -1,11 +1,11 @@ -- tag: 7b-8k:1.0 +- tag: 7b-8k-zarr:1.0 ngc: null ngc_registry: model - pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_nemo2.tar.gz" - sha256: cc36769cc80c19b7105e8341f51a89230ba704dbe11c982603378fc418425640 # pragma: allowlist secret + pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_fix_shape.tar.gz" + sha256: 31261b3dce731e257f03b5f609306df1334cfc723a445cb3800c757a06263ebb # pragma: allowlist secret owner: John St John description: > - A 7b parameter evo2 model used in testing + A 7b parameter evo2 model used in testing, zarr format - tag: 7b-8k-nofp8-te-goldvalue-testdata:1.0 ngc: null diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py index f0eff07bdf..ed6d6862db 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py @@ -18,15 +18,15 @@ from pathlib import Path from typing import Literal, Set +import pytest import torch -from megatron.core.transformer.enums import AttnBackend from megatron.core.transformer.module import Float16Module from nemo.collections import llm from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning.io.pl import MegatronCheckpointIO -from transformer_engine.pytorch.utils import get_cudnn_version -from transformer_engine.pytorch.utils import get_device_compute_capability +from transformer_engine.pytorch.utils import get_cudnn_version, get_device_compute_capability +from bionemo.core.data.load import load from bionemo.llm.utils.weight_utils import ( MegatronModelType, _key_in_filter, @@ -34,7 +34,7 @@ _munge_sharded_tensor_key_megatron_to_nemo2, ) from bionemo.testing.megatron_parallel_state_utils import distributed_model_parallel_state -from bionemo.core.data.load import load + logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) # Capture all levels in the logger itself @@ -58,8 +58,8 @@ def load_weights_sharded_inplace_nemo2_to_mcore( distributed_checkpoint_dir, sharded_state_dict=sharded_state_dict ) - -def test_golden_values(): +@pytest.mark.parametrize("seq_len", [8_192, 16_384]) +def test_golden_values(seq_len:int): """Step 1: # add local .ssh/*.pub key to eos ~/.ssh/authorized_keys mkdir -p arc_model/checkpoints/ @@ -69,7 +69,7 @@ def test_golden_values(): rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/final_7b_no_fp8_golden_value.pt arc_model/gold_standards/ """ try: - evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k:1.0") / "weights" + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.0") / "weights" gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") except ValueError as e: if e.args[0].endswith("does not have an NGC URL."): @@ -80,7 +80,7 @@ def test_golden_values(): else: raise e with torch.inference_mode(), distributed_model_parallel_state(): - hyena_config = llm.Hyena7bConfig(use_te=True) + hyena_config = llm.Hyena7bConfig(use_te=True, seq_length=seq_len) tokenizer = get_nmt_tokenizer( "byte-level", ) From 854951f24309d56fceadb6d436646e108325e5d5 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Mon, 13 Jan 2025 10:59:02 -0800 Subject: [PATCH 022/140] added flag for tflops callback --- .../src/bionemo/evo2/run/train.py | 28 ++++++++++++++----- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index ddbe7d3dd1..51d818852b 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -136,6 +136,18 @@ def parse_args(): action="store_true", default=False, ) + parser.add_argument( + "--ckpt-format", + type=str, + choices=['torch_dist', 'zarr'], + default='torch_dist', + help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated." + ) + parser.add_argument( + "--tflops-callback", + action="store_true", + help="Enable tflops calculation callback for Hyena / Evo2. Defaults to False." + ) # NSYS profiling/tooling arguments parser.add_argument( @@ -312,20 +324,22 @@ def main(): save_optim_on_train_end=True, save_context_on_train_end=True, ) - flop_meas_callback = FLOPsMeasurementCallback( - asdict(evo2_config), - data, - "hyena", - ) callbacks = [ checkpoint_callback, RichModelSummary(max_depth=4), LearningRateMonitor(), TimingCallback(), - flop_meas_callback, ] if args.enable_preemption: callbacks.append(nl_callbacks.PreemptionCallback()) + if args.tflops_callback: + # Add callback that logs the tera-FLOPS per second per GPU during training. + flop_meas_callback = FLOPsMeasurementCallback( + asdict(evo2_config), + data, + "hyena", + ) + callbacks.append(flop_meas_callback) if args.straggler_detection: callbacks.append( @@ -415,7 +429,7 @@ def main(): ckpt_load_optimizer=True, ckpt_save_optimizer=True, ckpt_async_save=args.ckpt_async_save, - save_ckpt_format="torch_dist", + save_ckpt_format=args.ckpt_format, ) trainer = nl.Trainer( devices=args.devices, From ada349e26f5ed60dbe6f9e546062cbf6aa6c01e1 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Mon, 13 Jan 2025 11:13:16 -0800 Subject: [PATCH 023/140] [cye/evo2-ckpt-utils] Add Evo2 ZeRO-1/3 to NeMo checkpointing utils. --- .../src/bionemo/evo2/run/infer.py | 10 +- .../bionemo/evo2/utils/checkpoint/README.md | 65 +++ .../convert_checkpoint_model_parallel_evo2.py | 270 ++++++++++ .../checkpoint/convert_zero3_to_zero1.py | 114 ++++ .../bionemo/evo2/utils/checkpoint/params.py | 42 ++ .../evo2/utils/checkpoint/torch2nemo.py | 30 ++ .../utils/checkpoint/zero3_conversion_lib.py | 485 ++++++++++++++++++ 7 files changed, 1015 insertions(+), 1 deletion(-) create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 2cbb001699..8fda8579c6 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -51,6 +51,14 @@ def parse_args(): ap.add_argument("--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1.") # output args: ap.add_argument("--output-file", type=str, default=None, help="Output file containing the generated text produced by the Evo2 model. If not provided, the output will be logged.") + # extra: + ap.add_argument( + "--ckpt-format", + type=str, + choices=['torch_dist', 'zarr'], + default='torch_dist', + help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated." + ) return ap.parse_args() @@ -71,7 +79,7 @@ def main(): ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. ckpt_save_optimizer=False, ckpt_async_save=False, - save_ckpt_format="zarr", + save_ckpt_format=args.ckpt_format, ), log_every_n_steps=1, limit_val_batches=10, diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md new file mode 100644 index 0000000000..e4e96a6768 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md @@ -0,0 +1,65 @@ +# Evo2 Checkpoint Conversion Library + +This library contains helper scripts for converting checkpoint formats for Evo2. + +## Converting ZeRO-1 / PyTorch Checkpoints to NeMo2 Checkpoints + +To convert a single PyTorch or ZeRO-1 checkpoints (`.pt`) into NeMo2 format, run the following command: +``` +python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py --model-path --output-dir --model-type --ckpt-format +``` +where `--model-type` can be set to `7b` or `40b` and `--ckpt-format` can be set to `torch_dist` or `zarr`. + +The NeMo2 checkpoint should have the following structure for `torch_dist`: +``` +default--val_loss=2.3738-epoch=0-consumed_samples=800.0-last +├── context +│ ├── io.json +│ └── model.yaml +└── weights + ├── __*_*.distcp + ├── common.pt + └── metadata.json +``` +and the following structure for `zarr`: +``` +interleaved_hyena_7b_fix_shape +├── context +│ ├── io.json +│ └── model.yaml +└── weights + ├── common.pt + ├── metadata.json + └── # Example: module.decoder.layers.0.mixer.dense + └── shard_*_*.pt +``` + +## Converting ZeRO-1 MP{N} to ZeRO-1 MP1 + +To convert sharded (MP>1) ZeRO-1 checkpoints to un-sharded (MP1) checkpoints (or any order of model parallelism) compatible with the `torch2nemo.py` conversion script, you can run the following command: +``` +python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py --source_dir --output_dir --mp_size +``` + +ZeRO-1 checkpoints should have the following structure: +``` +arc_7b_tp8_pretrained_ckpt/global_step199400 +└── mp_rank_*_model_states.pt +``` + +## Converting ZeRO-3 to ZeRO-1 + +To convert ZeRO-3 checkpoints into ZeRO-1 checkpoints, run the following command: +``` +python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py --overwrite --mp_size +``` + +ZeRO-3 checkpoints should have the following structure: +``` +arc_40b_zero3_w32_mp8_test_notfinal_ckpt/global_step1 +├── bf16_zero_pp_rank_*_mp_rank_*_optim_states.pt +├── configs +│ ├── 40b_test_chkpt.yml +│ └── opengenome.yml +└── zero_pp_rank_*_mp_rank_*_model_states.pt +``` \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py new file mode 100644 index 0000000000..48dd6f6c0c --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py @@ -0,0 +1,270 @@ +""" +Usage: python convert_checkpoint_model_parallel_evo2.py \ + --input-checkpoint-dir /path/to/input/checkpoint/global_step1000 \ + --output-checkpoint-dir /path/to/output/checkpoint_mp2/global_step1000 \ + --output-model-parallelism 2 + +Loads the (potentially sharded) parameters in `input_checkpoint_dir` and then re-shards +them according to the desired level of model tensor parallelism. + +Specialized to the Evo 2 architecture, only supports Zero-1 checkpoints, and does not +convert any optimizer state (only the parameters). +""" +import argparse +import os +import re +from collections import OrderedDict +from glob import glob +from pathlib import Path +from typing import List + +import torch +from params import EVO2_PARAMS, Param +from nemo.utils import logging + +DEVICE = "cpu" +DEFAULT_PARAM_PATTERN = r'sequential\.\d+\.(.+)' + +def get_args(): + parser = argparse.ArgumentParser( + description="Convert checkpoint parameters to desired model parallelism.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + parser.add_argument('--source_dir', type=str, required=True, help='Path to the input checkpoint directory containing ZeRo1 checkpoint shards, i.e. mp_rank_*_model_states.pt.') + parser.add_argument('--glob-pattern', type=str, default='mp_rank_*_model_states.pt', required=False, help='Filename pattern to glob for ZeRo1 checkpoint shards.') + parser.add_argument('--output_dir', type=str, required=True, help='Path to the output checkpoint directory to dump the --mp_size converted model checkpoint (ZeRo1).') + parser.add_argument('--mp_size', type=int, required=True, help='Desired output model parallelism to convert to.') + parser.add_argument('--exclude-extra', action='store_true', help='Exclude extra states in the conversion. Default to False, i.e. include extra states.') + parser.add_argument("--verbose", action="store_true", help="Print more information about the conversion.") + args = parser.parse_args() + return args + +def concatenate_tensors_across_shards( + tensor_name: str, + data_shards: List[OrderedDict[str, torch.Tensor]], + partition_dim: int, + hidden_dim: int = None, + verbose: bool = False +) -> torch.tensor: + + # Retrieve tensor shards. + tensors = [ shard['module'][tensor_name] for shard in data_shards ] + + # Check shape of tensors without tensor parallelism, i.e. stored in all shards of the checkpoint. + if partition_dim is None: + for i, tensor in enumerate(tensors): + if not torch.allclose(tensors[0], tensor): + logging.info(f'WARNING: Synchronized params differ for param {tensor_name}: abs max diff = {(tensors[0] - tensor).abs().max()}.') + # Get the distribution of tensors[0] and tensor. + if verbose: + ref_tensor = tensors[0].flatten().to(torch.float32) + ref_min, ref_max = ref_tensor.min(), ref_tensor.max() + + q = torch.tensor([0.25, 0.5, 0.75], device=ref_tensor.device) + ref_quantiles = ref_tensor.quantile(q) + logging.info(f"rank0 tensor: min={ref_min}, max={ref_max} quantiles={ref_quantiles}") + + target_tensor = tensor.flatten().to(torch.float32) + target_min, target_max = target_tensor.min(), target_tensor.max() + target_quantiles = target_tensor.quantile(q) + logging.info(f"rank{i} tensor: min={target_min}, max={target_max} quantiles={target_quantiles}") + + logging.info(f"rank0 tensor distribution:\n {ref_tensor.histc(100, min=ref_min, max=ref_max)}") + logging.info(f"rank{i} distribution:\n {target_tensor.histc(100, min=ref_min, max=ref_max)}") + + logging.info(f"tensor {tensor_name} not partitioned, returning rank0 tensor {tensors[0].shape}") + return tensors[0] + # Check for sharding across the hidden dimension. + elif partition_dim == hidden_dim: + raise ValueError(f"Detected sharding for {tensor_name} across hidden dimension at index {hidden_dim}.") + + # Check that the tensors have a consistent hidden dimension. + expected_dim = None + if hidden_dim is not None: + for tensor in tensors: + if expected_dim is None: + # Store expected hidden dimension for all tensors. + expected_dim = tensor.shape[hidden_dim] + if not tensor.shape[hidden_dim] == expected_dim: + raise ValueError(f'Tensor {tensor_name} has invalid hidden shape {tensor.shape}.') + + # Concatenate shards. + return torch.cat(tensors, dim=partition_dim) + + +def split_tensor_across_shards( + data_shards: List[OrderedDict], + tensor: torch.tensor, + tensor_name: str, + partition_dim: int, +) -> None: + + if partition_dim is None: + # No sharding. Synchronize weights across all shards. + for data_shard in data_shards: + data_shard['module'][tensor_name] = tensor + data_shard['param_shapes'][tensor_name] = tensor.shape + else: + # Split the tensor along the partition dimension across shards. + n_shards = len(data_shards) + if tensor.shape[partition_dim] % n_shards != 0: + raise ValueError(f"Cannot shard {tensor_name} of dimension {tensor.shape[partition_dim]} across {n_shards} evenly.") + for chunk, data_shard in zip( + torch.chunk(tensor, chunks=n_shards, dim=partition_dim), + data_shards, + ): + data_shard['module'][tensor_name] = chunk.clone() + data_shard['param_shapes'][tensor_name] = chunk.shape + + +def format_output_filename(shard: int) -> str: + return f'mp_rank_{str(shard).zfill(2)}_model_states.pt' + + +def check_params(detected, expected, buffers: set[str], param_pattern=DEFAULT_PARAM_PATTERN, verbose=False): + """Check that all model parameters are expected.""" + + # Expected model parameters. + expected = set(expected) if not isinstance(expected, set) else expected + # Detected model parameters. + model_param_names = [] + for k in detected: + match = re.search(param_pattern, k) + if match is not None: + model_param_names.append(match.group(1)) + else: + logging.info(f"Could not match {k}") + detected_param_set = set(model_param_names) + if verbose: + logging.info("Detected Params:\n {detected_params}".format(detected_params='\n '.join(detected_param_set))) + + # Log unexpected model parameters. + missing_params = expected - detected_param_set + extra_params = detected_param_set - expected + extra_params = [param for param in extra_params if param not in buffers] + extra_params = [param for param in extra_params if not param.endswith('._extra_state')] + if len(extra_params) > 0: + logging.info(f"WARNING: detected extra params: {extra_params}") + if len(missing_params) > 0: + logging.info(f"WARNING: missing params: {missing_params}") + if not (extra_params or missing_params): + logging.info("No missing or extra params detected!") + +def convert(input_data_shards, output_data_shards, model_parameter_names: List[str], param_list: List[Param], verbose=False, exclude_extra=False): + """Convert model weights from input model parallelism to output model parallelism.""" + logging.info(f"Converting {len(model_parameter_names)} parameters from {len(input_data_shards)} input shards to {len(output_data_shards)} output shards...") + converted = 0 + skipped = 0 + for model_parameter in model_parameter_names: + if args.verbose: + logging.info(f"Processing {model_parameter}...") + + # Ignore FP8 extra state. + if model_parameter.endswith('._extra_state'): + if 'extra_state' in model_parameter: + logging.info(f'Ignoring {model_parameter} -> contains extra state.') + skipped += 1 + continue + + # Get the partition dimension and hidden dimension of each parameter. + param_info = None + for param in param_list: + if '.'.join(model_parameter.split('.')[2:]) == param.name: + if param_info is None: + param_info = param + else: + raise ValueError(f'Found more than one matching model parallelism parameter for {model_parameter}: {param_info}, {param}') + if param_info is None: + raise ValueError(f'Could not find {model_parameter} among known parameters.') + + # Concatenate shards. + concatenated_tensor = concatenate_tensors_across_shards( + model_parameter, + input_data_shards, + param_info.partition_dim, + param_info.hidden_dim, + verbose=verbose + ) + # Split into shards. + split_tensor_across_shards( + output_data_shards, + concatenated_tensor, + model_parameter, + param_info.partition_dim, + ) + converted += 1 + logging.info(f"Converted {converted} of {len(model_parameter_names)} parameters (skipped {skipped} params).") + num_params = len(output_data_shards[0]['module']) + logging.info(f"Total Params: {num_params}") + if not all(num_params == len(shard['module']) for shard in output_data_shards): + raise ValueError('Shards have different number of parameters, which is not permitted in model parallelism.') + + if not exclude_extra: + logging.info("Adding extra states from rank0 input shard...") + rank0_model = input_data_shards[0]['module'] + for k in rank0_model.keys(): + for i, output_shard in enumerate(output_data_shards): + if k not in output_shard['module']: + if i == 0: + logging.info(f"Adding {k} to output shards.") + output_shard['module'][k] = rank0_model[k] + new_params = len(output_data_shards[0]['module']) - num_params + logging.info(f"Added {new_params} extra states, total params: {num_params + new_params}") + if not all(num_params + new_params == len(shard['module']) for shard in output_data_shards): + raise ValueError('Shards have different number of parameters after adding extra states.') + + for shard_idx, output_data_shard in enumerate(output_data_shards): + output_path = Path(output_data_shard['output_dir']) / format_output_filename(shard_idx) + torch.save( + output_data_shard, + output_path, + ) + logging.info(f"Converted checkpoint saved to: {output_path}") + +def convert_zero1_model_parallel_checkpoint(source_dir: str, output_dir: str, glob_pattern: str = 'mp_rank_*_model_states.pt', model_parallel: int = 8, param_list: List[Param] = EVO2_PARAMS, exclude_extra_params: bool = False, verbose: bool = False): + """Convert sharded ZeRo1 checkpoint to desired model parallelism.""" + + # Argument validation. + if not os.path.exists(source_dir): + raise ValueError(f'Input checkpoint dir ({source_dir}) not found.') + os.makedirs(output_dir, exist_ok=True) + logging.info(f"Converting checkpoint from {source_dir} to {output_dir}") + + # Identify all checkpoint model path files. + parameter_paths = sorted(glob(f'{source_dir}/{glob_pattern}')) + if len(parameter_paths) == 0: + raise ValueError(f"No parameter files found in {source_dir}") + + # Load all shards from the ZeRo1 checkpoint. + input_data_shards = [ torch.load(path, map_location=DEVICE) for path in parameter_paths ] + buffers = {buf for x in input_data_shards for buf in x.get("buffer_names", [])} + + # Initialize output MP shards. + output_data_shards = [ + { + 'module': OrderedDict(), + 'param_shapes': OrderedDict(), + 'dp_world_size': input_data_shards[0]['dp_world_size'], + 'output_dir': output_dir, + } + for _ in range(model_parallel) + ] + model_parameter_names = input_data_shards[0]['module'].keys() + + # Check no missing or extra params + check_params(detected=model_parameter_names, expected=set(param.name for param in param_list), buffers=buffers, verbose=verbose) + # Convert the checkpoint + convert(input_data_shards, output_data_shards, model_parameter_names, param_list, verbose=verbose, exclude_extra=exclude_extra_params) + logging.info("Done!") + +if __name__ == '__main__': + args = get_args() + convert_zero1_model_parallel_checkpoint( + args.source_dir, + args.output_dir, + args.glob_pattern, + args.mp_size, + EVO2_PARAMS, + args.exclude_extra, + args.verbose + ) \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py new file mode 100644 index 0000000000..6106fcef4b --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python + +import argparse +import os +import time +from multiprocessing import Pool + +import zero3_conversion_lib +from zero3_conversion_lib import get_elapsed, process_single_rank + + +def convert_zero_checkpoint_to_fp32_state_dict( + checkpoint_dir, + output_dir, + tag=None, + exclude_frozen_parameters=False, + mp_size=8, + overwrite=False, + num_workers=1, + ranks_to_process=None, +): + ds_checkpoint_dir = os.path.join(checkpoint_dir, tag) if tag is not None else checkpoint_dir + + if not os.path.isdir(ds_checkpoint_dir): + raise FileNotFoundError(f"Directory '{ds_checkpoint_dir}' doesn't exist") + + output_dir = os.path.join(output_dir, tag) if tag is not None else output_dir + if not os.path.exists(output_dir): + os.makedirs(output_dir, exist_ok=True) + + num_workers = min(num_workers, mp_size) + + if ranks_to_process is not None: + ranks_to_process = list(ranks_to_process) + assert len(ranks_to_process) <= mp_size, f"Expected {mp_size} ranks to process, got {len(ranks_to_process)}" + assert all(0 <= r < mp_size for r in ranks_to_process), f"Expected ranks to be in range [0, {mp_size}), got {ranks_to_process}" + else: + ranks_to_process = list(range(mp_size)) + + print(f"Processing ranks: {ranks_to_process}", flush=True) + + start = time.time() + if num_workers > 1: + with Pool(num_workers) as p: + p.starmap( + process_single_rank, + [ + (i, ds_checkpoint_dir, output_dir, overwrite, exclude_frozen_parameters) + for i in ranks_to_process + ], + ) + else: + for i in ranks_to_process: + process_single_rank(i, ds_checkpoint_dir, output_dir, overwrite, exclude_frozen_parameters) + + total_time = get_elapsed(time.time() - start) + print( + f"All done!\n-> Total time: {total_time}\n-> All outputs written to {os.path.abspath(output_dir)}" + ) + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument( + "checkpoint_dir", type=str, help="path to the desired checkpoint folder, e.g., path/checkpoint-12" + ) + parser.add_argument( + "output_dir", + type=str, + help="directory to the pytorch fp32 state_dict output files" "(e.g. path/checkpoint-12-output/)", + ) + parser.add_argument("--overwrite", action="store_true", help="Overwrite existing MP shards") + parser.add_argument( + "-t", + "--tag", + type=str, + default=None, + help="Checkpoint tag used as a unique identifier or sub-directory that contains the checkpoint, e.g. 'global_step1' or 'latest'.", + ) + parser.add_argument("--exclude_frozen_parameters", action="store_true", help="exclude frozen parameters") + parser.add_argument("-d", "--debug", action="store_true", help="enable debug") + parser.add_argument("--mp_size", required=True, type=int, help="Model parallel size of source checkpoint") + parser.add_argument("--rank_start", default=None, type=int, help="Start rank to process") + parser.add_argument("--rank_end", default=None, type=int, help="End rank to process") + parser.add_argument("--num_workers", default=1, type=int, help="Number of workers to use for processing") + args = parser.parse_args() + + if args.rank_start is not None: + if args.rank_end is None: + args.rank_end = args.mp_size - 1 + else: + assert args.rank_end < args.mp_size, "Expected end rank to be less than mp_size" + + assert args.rank_start < args.rank_end, "Expected start rank to be less than end rank" + assert args.rank_start >= 0, "Expected start rank to be greater than 0" + args.ranks_to_process = list(range(args.rank_start, args.rank_end + 1)) + else: + args.ranks_to_process = list(range(args.mp_size)) + + print(f"Args:") + for k, v in args.__dict__.items(): + print(f" {k}: {v}", flush=True) + print("") + zero3_conversion_lib.debug = args.debug + + convert_zero_checkpoint_to_fp32_state_dict( + args.checkpoint_dir, + args.output_dir, + tag=args.tag, + exclude_frozen_parameters=args.exclude_frozen_parameters, + mp_size=args.mp_size, + overwrite=args.overwrite, + num_workers=args.num_workers, + ranks_to_process=args.ranks_to_process, + ) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py new file mode 100644 index 0000000000..055f6e092e --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py @@ -0,0 +1,42 @@ +from dataclasses import dataclass + + +@dataclass +class Param: + name: str # Name of the parameter in the checkpoint. + partition_dim: int # The dimension index that gets sharded. `None` for no sharding. + hidden_dim: int # The hidden dimension index. `None` for no hidden dimension. + +EVO2_PARAMS = [ + # Only layer_00. + Param('word_embeddings.weight', 0, 1), #torch.Size([64, 8192]) + + Param('input_layernorm.weight', None, 0), #torch.Size([8192]) + Param('post_attention_layernorm.weight', None, 0), #torch.Size([8192]) + Param('pre_mlp_layernorm.weight', None, 0), #torch.Size([8192]) + Param('outer_mlp_layernorm.weight', None, 0), #torch.Size([8192]) + + Param('mixer.dense_projection.weight', 0, 1), #torch.Size([3072, 8192]), + Param('mixer.hyena_proj_conv.short_conv_weight', 0, None), #torch.Size([3072, 3]), + + Param('mixer.mixer.conv_bias', 0, None), #torch.Size([1024]), + Param('mixer.mixer.filter.decay', 0, None), #torch.Size([64, 8192]), + Param('mixer.mixer.filter.gamma', 0, None), #torch.Size([1024, 16]), + Param('mixer.mixer.filter.h', 0, None), #torch.Size([64, 8192]), + Param('mixer.mixer.filter.p', 0, None), #torch.Size([1024, 16]), + Param('mixer.mixer.filter.R', 0, None), #torch.Size([1024, 16]), + Param('mixer.mixer.filter.t', None, 0), #torch.Size([1, 1, seqlen]), + + Param('mixer.mixer.short_conv.short_conv_weight', 0, None), #torch.Size([64, 1, 7]), + + Param('mixer.rotary_emb.inv_freq', None, None), #torch.Size([64]) + Param('mixer.dense.weight', 1, 0), #torch.Size([8192, 2048]), + Param('mixer.dense.bias', None, 0), #torch.Size([8192]) + + Param('mlp.w1.weight', 0, 1), #torch.Size([2736, 8192]), + Param('mlp.w2.weight', 0, 1), #torch.Size([2736, 8192]), + Param('mlp.w3.weight', 1, 0), #torch.Size([8192, 2736]), + + # Only last layer. + Param('norm.weight', None, 0), #torch.Size([8192]), +] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py new file mode 100644 index 0000000000..bb767a3c8e --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py @@ -0,0 +1,30 @@ +import argparse + +from nemo.collections import llm +from nemo.collections.llm.gpt.model.hyena import PyTorchHyenaImporter + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("--model-path", type=str, required=True, help="Path to the Evo2 un-sharded (MP1) model checkpoint file.") + parser.add_argument("--output-dir", type=str, required=True, help="Output directory path for the converted model.") + parser.add_argument("--model-type", type=str, choices=["7b", "40b", "test"], default="7b", + help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b).") + return parser.parse_args() + +if __name__ == "__main__": + + # Parse args. + args = parse_args() + + # Hyena Model Config + if args.model_type == "7b": + evo2_config = llm.Hyena7bConfig() + elif args.model_type == "40b": + evo2_config = llm.Hyena40bConfig() + elif args.model_type == "test": + evo2_config = llm.HyenaTestConfig() + else: + raise ValueError(f"Invalid model type: {args.model_type}") + + importer = PyTorchHyenaImporter(args.model_path, model_config=evo2_config) + importer.apply(args.output_dir) \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py new file mode 100644 index 0000000000..fe3ba7d56a --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py @@ -0,0 +1,485 @@ +""" +Helper utility for converting ZeRO3 and ZeRO2 checkpoints to PyTorch. +""" +import glob +import math +import os +import re +import time +from collections import OrderedDict +from dataclasses import dataclass +from typing import Dict, List + +import psutil +import torch +from tqdm import tqdm + +BUFFER_NAMES = 'buffer_names' +DS_VERSION = 'ds_version' +FP32_FLAT_GROUPS = 'fp32_flat_groups' +FROZEN_PARAM_FRAGMENTS = 'frozen_param_fragments' +FROZEN_PARAM_SHAPES = 'frozen_param_shapes' +OPTIMIZER_STATE_DICT = "optimizer_state_dict" +PARAM_SHAPES = 'param_shapes' +PARTITION_COUNT = 'partition_count' +SINGLE_PARTITION_OF_FP32_GROUPS = "single_partition_of_fp32_groups" +ZERO_STAGE = 'zero_stage' +EXTRA_STATE = "._extra_state" + + +@dataclass +class zero_model_state: + buffers: Dict + extra_states: Dict + param_shapes: List + shared_params: List + ds_version: int + frozen_param_shapes: Dict + frozen_param_fragments: Dict + + +debug = 0 +device = torch.device("cpu") + + +def profile_memory_decorator(func): + def profile_memory(): + pid = os.getpid() + process = psutil.Process(pid) + memory_info = process.memory_info() + print_pid(f"{pid}: RSS = {memory_info.rss / 1024 ** 2:.2f} MB") + + def wrapper(*args, **kwargs): + profile_memory() + func(*args, **kwargs) + profile_memory() + + return wrapper + + +def print_pid(msg): + pid = os.getpid() + print(f"{pid=}:{msg}") + + +def atoi(text): + return int(text) if text.isdigit() else text + + +def natural_keys(text): + """ + alist.sort(key=natural_keys) sorts in human order + http://nedbatchelder.com/blog/200712/human_sorting.html + (See Toothy's implementation in the comments) + """ + return [atoi(c) for c in re.split(r"(\d+)", text)] + + +def get_checkpoint_files(checkpoint_dir, glob_pattern): + # XXX: need to test that this simple glob rule works for multi-node setup too + ckpt_files = sorted(glob.glob(os.path.join(checkpoint_dir, glob_pattern)), key=natural_keys) + + if len(ckpt_files) == 0: + raise FileNotFoundError(f"can't find {glob_pattern} files in directory '{checkpoint_dir}'") + + return ckpt_files + + +def get_model_files_by_rank(checkpoint_dir, rank): + return get_checkpoint_files(checkpoint_dir, f"*mp_rank_{rank:02}_model_states.pt") + + +def get_optim_files_by_rank(checkpoint_dir, rank): + return get_checkpoint_files(checkpoint_dir, f"*mp_rank_{rank:02}_optim_states.pt") + + +def create_ds_output_path(rank): + return f"mp_rank_{rank:02}_model_states.pt" + +def create_zero3_model_state_path(dp_rank, mp_rank): + return f"zero_pp_rank_{dp_rank}_mp_rank_{mp_rank:02}_model_states.pt" + +def create_zero3_optim_state_path(dp_rank, mp_rank): + return f"bf16_zero_pp_rank_{dp_rank}_mp_rank_{mp_rank:02}_optim_states.pt" + +def get_model_state_file(checkpoint_dir, zero_stage): + if not os.path.isdir(checkpoint_dir): + raise FileNotFoundError(f"Directory '{checkpoint_dir}' doesn't exist") + + # there should be only one file + if zero_stage <= 2: + file = os.path.join(checkpoint_dir, "mp_rank_00_model_states.pt") + elif zero_stage == 3: + file = os.path.join(checkpoint_dir, "zero_pp_rank_0_mp_rank_00_model_states.pt") + + if not os.path.exists(file): + raise FileNotFoundError(f"can't find model states file at '{file}'") + + return file + + +def parse_model_states(files): + + zero_model_states = [] + for file in files: + state_dict = torch.load(file, map_location=device) + + if BUFFER_NAMES not in state_dict: + raise ValueError(f"{file} is not a model state checkpoint") + buffer_names = state_dict[BUFFER_NAMES] + if debug: + print_pid("Found buffers:", buffer_names) + + # recover just the buffers while restoring them to fp32 if they were saved in fp16 + buffers = {k: v.float() for k, v in state_dict["module"].items() if k in buffer_names} + + extra_states = {k: v for k, v in state_dict["module"].items() if k.endswith(EXTRA_STATE)} + + # collect parameters that are included in param_shapes + param_shapes = state_dict[PARAM_SHAPES] + param_names = [] + for s in param_shapes: + for name in s.keys(): + param_names.append(name) + + # update with frozen parameters + frozen_param_shapes = state_dict.get(FROZEN_PARAM_SHAPES, None) + if frozen_param_shapes is not None: + if debug: + print_pid(f"Found frozen_param_shapes: {frozen_param_shapes}") + param_names += list(frozen_param_shapes.keys()) + + # handle shared params + shared_params = [[k, v] for k, v in state_dict["shared_params"].items()] + + ds_version = state_dict.get(DS_VERSION, None) + + frozen_param_fragments = state_dict.get(FROZEN_PARAM_FRAGMENTS, None) + + z_model_state = zero_model_state( + buffers=buffers, + extra_states=extra_states, + param_shapes=param_shapes, + shared_params=shared_params, + ds_version=ds_version, + frozen_param_shapes=frozen_param_shapes, + frozen_param_fragments=frozen_param_fragments, + ) + zero_model_states.append(z_model_state) + + return zero_model_states + + +def parse_optim_states(files, ds_checkpoint_dir): + total_files = len(files) + state_dicts = [] + for f in files: + state_dict = torch.load(f, map_location=device) + # immediately discard the potentially huge 2 optimizer states as we only care for fp32 master weights + # and also handle the case where it was already removed by another helper script + state_dict["optimizer_state_dict"].pop("optimizer_state_dict", None) + state_dict[OPTIMIZER_STATE_DICT] = { + FP32_FLAT_GROUPS: state_dict[OPTIMIZER_STATE_DICT][FP32_FLAT_GROUPS], + ZERO_STAGE: state_dict[OPTIMIZER_STATE_DICT][ZERO_STAGE], + PARTITION_COUNT: state_dict[OPTIMIZER_STATE_DICT][PARTITION_COUNT], + } + state_dicts.append(state_dict) + + if not ZERO_STAGE in state_dicts[0][OPTIMIZER_STATE_DICT]: + raise ValueError(f"{files[0]} is not a zero checkpoint") + zero_stage = state_dicts[0][OPTIMIZER_STATE_DICT][ZERO_STAGE] + world_size = state_dicts[0][OPTIMIZER_STATE_DICT][PARTITION_COUNT] + + # For ZeRO-2 each param group can have different partition_count as data parallelism for expert + # parameters can be different from data parallelism for non-expert parameters. So we can just + # use the max of the partition_count to get the dp world_size. + + if type(world_size) is list: + world_size = max(world_size) + + if world_size != total_files: + raise ValueError( + f"Expected {world_size} of '*_optim_states.pt' under '{ds_checkpoint_dir}' but found {total_files} files. " + "Possibly due to an overwrite of an old checkpoint, or a checkpoint didn't get saved by one or more processes." + ) + + # the groups are named differently in each stage + if zero_stage <= 2: + fp32_groups_key = SINGLE_PARTITION_OF_FP32_GROUPS + elif zero_stage == 3: + fp32_groups_key = FP32_FLAT_GROUPS + else: + raise ValueError(f"unknown zero stage {zero_stage}") + + if zero_stage <= 2: + fp32_flat_groups = [ + state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key] for i in range(len(state_dicts)) + ] + elif zero_stage == 3: + # if there is more than one param group, there will be multiple flattened tensors - one + # flattened tensor per group - for simplicity merge them into a single tensor + # + # XXX: could make the script more memory efficient for when there are multiple groups - it + # will require matching the sub-lists of param_shapes for each param group flattened tensor + + fp32_flat_groups = [ + torch.cat(state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key], 0) + for i in range(len(state_dicts)) + ] + + return zero_stage, world_size, fp32_flat_groups + + +def _get_fp32_state_dict_from_zero_checkpoint(ds_checkpoint_dir, rank, exclude_frozen_parameters=False): + """ + Returns fp32 state_dict reconstructed from ds checkpoint + + Args: + - ``ds_checkpoint_dir``: path to the deepspeed checkpoint folder (where the optimizer files are) + + """ + + print_pid(f"Processing zero checkpoint '{ds_checkpoint_dir}'") + + # optim_files = get_optim_files(ds_checkpoint_dir) + # zero_stage, world_size, fp32_flat_groups = parse_optim_states(optim_files, ds_checkpoint_dir) + + optim_files = get_optim_files_by_rank(ds_checkpoint_dir, rank=rank) + optim_files_check = get_checkpoint_files(ds_checkpoint_dir, f"bf16*_{rank:02d}_optim_states.pt") + assert set(optim_files) == set(optim_files_check), f"Expected {optim_files_check}, got {optim_files}" + # check ordering as well + for f1, f2 in zip(optim_files, optim_files_check): + assert os.path.basename(f1) == os.path.basename( + f2 + ), f"Found mismatching optim files for rank {rank}: {os.path.basename(f1)} != {os.path.basename(f2)}" + print_pid(f" -> Optim files for rank {rank}: {len(optim_files)}") + + if debug: + print_pid(f"{optim_files=}") + + if os.environ.get("ZERO3_CONVERSION_DEBUG", "0") == "1": + breakpoint() + + zero_stage, world_size, fp32_flat_groups = parse_optim_states(optim_files, ds_checkpoint_dir) + assert len(optim_files) == world_size, f"Expected {world_size} optim files, got {len(optim_files)}" + if debug: + print_pid(f" -> rank{rank} stage: {zero_stage} {world_size=} {len(fp32_flat_groups)=} {fp32_flat_groups.shape=}") + + model_files = get_model_files_by_rank(ds_checkpoint_dir, rank=rank) + model_files_check = get_checkpoint_files(ds_checkpoint_dir, f"zero_*_mp_rank_{rank:02d}_model_states.pt") + assert set(model_files) == set(model_files_check), f"Expected {model_files_check}, got {model_files}" + + for f1, f2 in zip(model_files, model_files_check): + assert os.path.basename(f1) == os.path.basename( + f2 + ), f"Found mismatching optim files for rank {rank}: {os.path.basename(f1)} != {os.path.basename(f2)}" + print_pid(f" -> Model files for rank {rank}: {len(model_files)}") + + assert len(optim_files) == len( + model_files + ), f"Expected same number of optim and model files: {len(optim_files)} != {len(model_files)}" + assert len(optim_files) > 0, f"Expected at least one optim file, got {len(optim_files)}" + + zero_model_states = parse_model_states(model_files) + print_pid(f"Parsing checkpoint created by deepspeed=={zero_model_states[0].ds_version}") + + return _get_fp32_state_dict_from_zero3_checkpoint( + world_size, fp32_flat_groups, zero_model_states, exclude_frozen_parameters + ) + + +def zero3_partitioned_param_info(unpartitioned_numel, world_size): + remainder = unpartitioned_numel % world_size + padding_numel = (world_size - remainder) if remainder else 0 + partitioned_numel = math.ceil(unpartitioned_numel / world_size) + return partitioned_numel, padding_numel + + +def _zero3_merge_frozen_params(state_dict, world_size, zero_model_states): + + if zero_model_states[0].frozen_param_shapes is None or len(zero_model_states[0].frozen_param_shapes) == 0: + return + + if debug: + for i in range(world_size): + num_elem = sum(s.numel() for s in zero_model_states[i].frozen_param_fragments.values()) + print_pid(f"rank {i}: {FROZEN_PARAM_SHAPES}.numel = {num_elem}") + + frozen_param_shapes = zero_model_states[0].frozen_param_shapes + wanted_params = len(frozen_param_shapes) + wanted_numel = sum(s.numel() for s in frozen_param_shapes.values()) + avail_numel = ( + sum([p.numel() for p in zero_model_states[0].frozen_param_fragments.values()]) * world_size + ) + print_pid(f"Frozen params: Have {avail_numel} numels to process.") + print_pid(f"Frozen params: Need {wanted_numel} numels in {wanted_params} params") + + total_params = 0 + total_numel = 0 + for name, shape in zero_model_states[0].frozen_param_shapes.items(): + total_params += partitioned_numel + unpartitioned_numel = shape.numel() + total_numel += unpartitioned_numel + + param_frags = tuple(model_state.frozen_param_fragments[name] for model_state in zero_model_states) + state_dict[name] = torch.cat(param_frags, 0).narrow(0, 0, unpartitioned_numel).view(shape) + + partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info( + unpartitioned_numel, world_size + ) + + if debug: + print_pid( + f"Frozen params: {total_params} {name} full shape: {shape} partition0 numel={partitioned_numel} partitioned_padding_numel={partitioned_padding_numel}" + ) + + print_pid(f"Reconstructed Frozen fp32 state dict with {total_params} params {total_numel} elements") + + +# @profile_memory_decorator +def _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states): + if os.environ.get("ZERO3_CONVERSION_DEBUG", "0") == "1": + breakpoint() + + param_shapes = zero_model_states[0].param_shapes + avail_numel = fp32_flat_groups[0].numel() * world_size + # Reconstruction protocol: For zero3 we need to zip the partitions together at boundary of each + # param, re-consolidating each param, while dealing with padding if any + + # merge list of dicts, preserving order + param_shapes = {k: v for d in param_shapes for k, v in d.items()} + + if debug: + for i in range(world_size): + print_pid(f"{FP32_FLAT_GROUPS}[{i}].shape={fp32_flat_groups[i].shape}") + + wanted_params = len(param_shapes) + wanted_numel = sum(shape.numel() for shape in param_shapes.values()) + # not asserting if there is a mismatch due to possible padding + avail_numel = fp32_flat_groups[0].numel() * world_size + print_pid(f"Trainable params: Have {avail_numel} numels to process.") + print_pid(f"Trainable params: Need {wanted_numel} numels in {wanted_params} params.") + + # params + # XXX: for huge models that can't fit into the host's RAM we will have to recode this to support + # out-of-core computing solution + offset = 0 + total_numel = 0 + total_params = 0 + pid = os.getpid() + for name, shape in tqdm(param_shapes.items(), desc=f"{pid=}: Gathering Sharded Weights"): + + unpartitioned_numel = shape.numel() + total_numel += unpartitioned_numel + total_params += 1 + # NOTE: partitioned_numel includes padding, padding applies if unpartitioned_numel is not divisible by world_size + partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info( + unpartitioned_numel, world_size + ) + + if debug: + print_pid( + f"Trainable params: {total_params} {name} full shape: {shape} partition0 numel={partitioned_numel} partitioned_padding_numel={partitioned_padding_numel}" + ) + + # XXX: memory usage doubles here + state_dict[name] = ( + torch.cat( + tuple(fp32_flat_groups[i].narrow(0, offset, partitioned_numel) for i in range(world_size)), 0 + ) + .narrow(0, 0, unpartitioned_numel) + .view(shape) + ) + offset += partitioned_numel + + offset *= world_size + + # Sanity check + if offset != avail_numel: + raise ValueError(f"consumed {offset} numels out of {avail_numel} - something is wrong") + + print_pid(f"Reconstructed Trainable fp32 state dict with {total_params} params {total_numel} elements") + + +def _get_fp32_state_dict_from_zero3_checkpoint( + world_size, fp32_flat_groups, zero_model_states, exclude_frozen_parameters +): + + state_dict = OrderedDict() + + # buffers + buffers = zero_model_states[0].buffers + state_dict.update(buffers) + if debug: + print_pid(f"added {len(buffers)} buffers") + + # extra state (e.g., fp8) + extra_states = zero_model_states[0].extra_states + state_dict.update(extra_states) + if debug: + print_pid(f"added {len(extra_states)} extra_states") + + if not exclude_frozen_parameters: + _zero3_merge_frozen_params(state_dict, world_size, zero_model_states) + + _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states) + + # recover shared parameters + for pair in zero_model_states[0].shared_params: + if pair[1] in state_dict: + state_dict[pair[0]] = state_dict[pair[1]] + + return state_dict + + +def get_elapsed(t): + minutes = t // 60 + seconds = t % 60 + if minutes > 0: + total_time = f"{minutes:.0f}min{seconds:.0f}s" + else: + total_time = f"{seconds:.1f}s" + return total_time + + +def process_single_rank( + rank: int, + ds_checkpoint_dir: str, + output_dir: str, + overwrite: bool = False, + exclude_frozen_parameters: bool = False, +): + + print_pid(f"Gathering rank {rank} state_dict...") + + start = time.time() + output_path = os.path.join(output_dir, create_ds_output_path(rank)) + if os.path.exists(output_path) and not overwrite: + print_pid(f"Output path {output_path} exists, skipping") + return + + print_pid(f" -> Gathering data parallel partitions for mp rank {rank}...") + + if os.environ.get("ZERO3_CONVERSION_DEBUG", "0") == "1": + breakpoint() + + state_dict = _get_fp32_state_dict_from_zero_checkpoint( + ds_checkpoint_dir=ds_checkpoint_dir, rank=rank, exclude_frozen_parameters=exclude_frozen_parameters + ) + print_pid(f" -> Done processing rank {rank} state_dict, gathered {len(state_dict)} params") + + checkpoint = { + "module": state_dict, + "param_shapes": OrderedDict(), + "dp_world_size": 1, + } + + for param, value in state_dict.items(): + if isinstance(value, torch.Tensor): + checkpoint["param_shapes"][param] = value.shape + + print_pid(f" -> Saving mp rank {rank} checkpoint to {output_path}") + torch.save(checkpoint, f"{output_path}") + + total_time = get_elapsed(time.time() - start) + print_pid(f" -> rank {rank} took {total_time}") From 652dfe0f03a3efa8990ef34194f972a3ea5887f0 Mon Sep 17 00:00:00 2001 From: Jared Wilber Date: Mon, 13 Jan 2025 23:34:07 -0800 Subject: [PATCH 024/140] Add test for evo2 tokenizer. --- .../tests/bionemo/evo2/data/test_tokenizer.py | 237 ++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py new file mode 100644 index 0000000000..8270829701 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py @@ -0,0 +1,237 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest + +from bionemo.evo2.data.tokenizer import Evo2Tokenizer +from bionemo.evo2.utils.config import Evo2PreprocessingConfig + + +@pytest.fixture +def tokenizer() -> Evo2Tokenizer: + return Evo2Tokenizer(Evo2PreprocessingConfig()) + + +def test_tokenizer_handles_long_dna_sequence(tokenizer: Evo2Tokenizer) -> None: + """ + Verifies tokenizer correctly processes a long DNA sequence into expected token IDs. + This sequence excerpt was pulled from mmseqs_results_rep_seq_distinct.fasta. + """ + sequence = "TACACCTATATTTTTTAAGGTATGTAAACATCTACTTTTAGTGATACTAACAAAAATATAGAATAATAATTAGTGTTTTTGTATATTAATGTATGGGTAGGATCACAAATAAATTACGAAACCTTTTCCTATAATATTATAA" + tokens = tokenizer.tokenize(sequence) + expected_tokens = [ + [ + 84, + 65, + 67, + 65, + 67, + 67, + 84, + 65, + 84, + 65, + 84, + 84, + 84, + 84, + 84, + 84, + 65, + 65, + 71, + 71, + 84, + 65, + 84, + 71, + 84, + 65, + 65, + 65, + 67, + 65, + 84, + 67, + 84, + 65, + 67, + 84, + 84, + 84, + 84, + 65, + 71, + 84, + 71, + 65, + 84, + 65, + 67, + 84, + 65, + 65, + 67, + 65, + 65, + 65, + 65, + 65, + 84, + 65, + 84, + 65, + 71, + 65, + 65, + 84, + 65, + 65, + 84, + 65, + 65, + 84, + 84, + 65, + 71, + 84, + 71, + 84, + 84, + 84, + 84, + 84, + 71, + 84, + 65, + 84, + 65, + 84, + 84, + 65, + 65, + 84, + 71, + 84, + 65, + 84, + 71, + 71, + 71, + 84, + 65, + 71, + 71, + 65, + 84, + 67, + 65, + 67, + 65, + 65, + 65, + 84, + 65, + 65, + 65, + 84, + 84, + 65, + 67, + 71, + 65, + 65, + 65, + 67, + 67, + 84, + 84, + 84, + 84, + 67, + 67, + 84, + 65, + 84, + 65, + 65, + 84, + 65, + 84, + 84, + 65, + 84, + 65, + 65, + ] + ] + assert expected_tokens == tokens + + +def test_tokenizer_processes_pipe_delimited_sequence(tokenizer: Evo2Tokenizer) -> None: + """Verifies tokenizer correctly handles pipe-delimited sequences with info tags.""" + tokens = tokenizer.tokenize("|info|ATG|info|ATG|") + expected_tokens = [[124, 105, 110, 102, 111, 124, 65, 84, 71, 124, 105, 110, 102, 111, 124, 65, 84, 71, 124]] + assert expected_tokens == tokens + + +def test_tokenizer_drops_empty_sequences(tokenizer: Evo2Tokenizer) -> None: + """Verifies tokenizer removes empty sequences when drop_empty_sequences is True.""" + tokens = tokenizer.tokenize(["A", "", "T"], drop_empty_sequences=True) + expected_tokens = [[65], [84]] + assert expected_tokens == tokens + + +def test_tokenizer_appends_eod_token(tokenizer: Evo2Tokenizer) -> None: + """Verifies tokenizer correctly appends end-of-document token.""" + tokens = tokenizer.tokenize(["ATCG"], append_eod=True) + expected_tokens = [[65, 84, 67, 71, 0]] + assert expected_tokens == tokens + + +def test_tokenizer_pads_sequence_to_required_length(tokenizer: Evo2Tokenizer) -> None: + """Verifies tokenizer correctly pads sequence to specified length.""" + tokens = tokenizer.tokenize(["ATCG"], enforce_sample_length=10) + expected_tokens = [[65, 84, 67, 71, 1, 1, 1, 1, 1, 1]] + assert expected_tokens == tokens + + +def test_tokenizer_raises_error_for_invalid_length(tokenizer: Evo2Tokenizer) -> None: + """Verifies tokenizer raises ValueError when sequence exceeds enforced length.""" + with pytest.raises(ValueError): + tokenizer.tokenize(["ATCGATCGATCG"], enforce_sample_length=4) + + +def test_tokenizer_fixes_unicode_with_ftfy(tokenizer: Evo2Tokenizer) -> None: + """Verifies tokenizer correctly processes broken unicode characters using ftfy.""" + tokens = tokenizer.tokenize("✠ATCG", use_ftfy=True) + expected_tokens = [[226, 156, 160, 65, 84, 67, 71]] + assert expected_tokens == tokens + + +def test_tokenizer_processes_special_characters(tokenizer: Evo2Tokenizer) -> None: + """ + Evo2_Dataset uses specific ASCII encodings for specific characters: + CONTROL_TAGS: ClassVar[list[int]] = [64, 35] # '@' tag for splice splits/windows, '#' for contig splits + TAG_BOUNDS = 124 # start and end delim: '|' + TAG_CHARS: ClassVar[set[int]] = {95, 59, 32} # chars only found in control tags: _, ;, space + DEFAULT_EOD = 0 + This test verifies tokenizer correctly handles these special characters. + """ + special_chars = "".join(["@", "#", "|", "_", ";", " "]) + tokens = tokenizer.tokenize(special_chars, append_eod=True) + expected_tokens = [[64, 35, 124, 95, 59, 32, 0]] + assert expected_tokens == tokens From 265a0bec1fce2a64fb6e69c8539aeb1050911556 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Tue, 14 Jan 2025 04:06:43 -0800 Subject: [PATCH 025/140] Fix nemo-savanna repo build in CI --- .gitmodules | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitmodules b/.gitmodules index b23b9d161b..1580a2e194 100644 --- a/.gitmodules +++ b/.gitmodules @@ -3,4 +3,4 @@ url = https://github.com/NVIDIA/Megatron-LM.git [submodule "3rdparty/NeMo"] path = 3rdparty/NeMo - url = ssh://git@gitlab-master.nvidia.com:12051/ataghibakhsh/nemo-savanna.git + url = https://gitlab-master.nvidia.com/ataghibakhsh/nemo-savanna.git From fb093778b80c6d14f83d630ce7705dc909c0a799 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Tue, 14 Jan 2025 12:09:11 -0800 Subject: [PATCH 026/140] fixing format issues on evo2-dev --- Dockerfile | 2 +- .../src/bionemo/core/data/resources/evo2.yaml | 2 +- sub-packages/bionemo-evo2/README.md | 2 +- .../src/bionemo/evo2/data/README.md | 2 +- .../src/bionemo/evo2/data/preprocess.py | 225 ++++++++--- .../evo2/data/transcript_extraction.py | 367 ++++++++++++------ .../src/bionemo/evo2/run/infer.py | 30 +- .../src/bionemo/evo2/run/train.py | 38 +- .../bionemo/evo2/utils/checkpoint/README.md | 2 +- .../convert_checkpoint_model_parallel_evo2.py | 308 ++++++++++----- .../checkpoint/convert_zero3_to_zero1.py | 68 +++- .../bionemo/evo2/utils/checkpoint/params.py | 80 ++-- .../evo2/utils/checkpoint/torch2nemo.py | 37 +- .../utils/checkpoint/zero3_conversion_lib.py | 336 +++++++++++++--- .../src/bionemo/evo2/utils/config.py | 5 +- .../bionemo-evo2/tests/bionemo/test_evo2.py | 7 +- .../src/bionemo/llm/utils/datamodule_utils.py | 1 + 17 files changed, 1097 insertions(+), 415 deletions(-) diff --git a/Dockerfile b/Dockerfile index a2900c74cc..1ddee4412a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -60,7 +60,7 @@ ARG NEMU_RUN_TAG=34259bd3e752fef94045a9a019e4aaf62bd11ce2 RUN pip install nemo_run@git+https://github.com/NVIDIA/NeMo-Run.git@${NEMU_RUN_TAG} # Used for straggler detection in large runs. -ARG RESIL_COMMIT="97aad77609d2e25ed38ac5c99f0c13f93c48464e" +ARG RESIL_COMMIT=97aad77609d2e25ed38ac5c99f0c13f93c48464e RUN pip install --no-cache-dir "git+https://github.com/NVIDIA/nvidia-resiliency-ext.git@${RESIL_COMMIT}" RUN mkdir -p /workspace/bionemo2/ diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index cde355a43b..b9a04679ec 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -20,4 +20,4 @@ CCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGG TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT - ATAATTTTAATTTATATAAT \ No newline at end of file + ATAATTTTAATTTATATAAT diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 9056770151..92ee5e5b37 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -156,4 +156,4 @@ As in `train_evo2`, `--ckpt-dir` points to the NeMo2 checkpoint directory for Ev ``` [NeMo I 2025-01-06 17:22:22 infer:102] ['CTCTTCTGGTATTTGG'] -``` \ No newline at end of file +``` diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md index 340bb94631..777190115d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/README.md @@ -218,4 +218,4 @@ options: --only-longest-transcript Only extract the longest transcript per gene. -v, --verbose Turn on verbose log messages. -``` \ No newline at end of file +``` diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index 6273b18a8a..442c2a76c5 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -20,7 +20,6 @@ """ import argparse -import gzip import multiprocessing as mp import os import random @@ -31,7 +30,6 @@ from typing import Optional import numpy as np -import pandas as pd import torch import yaml from megatron.core.datasets.indexed_dataset import IndexedDatasetBuilder @@ -53,13 +51,21 @@ class Evo2Preprocessor: TEST = "test" def __init__(self, params: Evo2PreprocessingConfig | None = None): - """Initialize Evo2Preprocessor.""" + """Initialize Evo2Preprocessor. + + Args: + params (Evo2PreprocessingConfig | None): Configuration parameters for preprocessing. + """ self.tokenizer: Evo2Tokenizer = Evo2Tokenizer(params) @staticmethod @contextmanager - def preprocessing_context_manager(seed: int | None = None): - """Context manager for preprocessing RNG.""" + def preprocessing_context_manager(seed: Optional[int] = None): + """Context manager for setting and restoring the random number generator state. + + Args: + seed (int | None): Seed for the random number generator. Defaults to None. + """ # Track current state. current_state = random.getstate() try: @@ -71,30 +77,64 @@ def preprocessing_context_manager(seed: int | None = None): random.setstate(current_state) @staticmethod - def _get_output_filename(config: Evo2PreprocessingConfig, ext: str = None, split: str = None, temp: bool = False) -> Path: + def _get_output_filename( + config: Evo2PreprocessingConfig, ext: Optional[str] = None, split: Optional[str] = None, temp: bool = False + ) -> Path: + """Generate the output filename for the preprocessed data. + + Args: + config (Evo2PreprocessingConfig): Configuration object containing preprocessing settings. + ext (Optional[str]): File extension for the output file. Defaults to None. + split (Optional[str]): Data split type (e.g., 'train', 'val', 'test'). Defaults to None. + temp (bool): Flag indicating whether the file is temporary. Defaults to False. + + Returns: + Path: The constructed output file path. + """ # Get output directory. Defaults to CWD. output_dir = config.output_dir if output_dir is None: output_dir = Path.cwd() # Pickup output file prefix. - config_prefix = "{}_{}".format( - config.output_prefix, config.tokenizer_type.lower().replace(" ", "") + config_prefix = "{}_{}".format(config.output_prefix, config.tokenizer_type.lower().replace(" ", "")) + output_filepath = Path(output_dir) / ( + config_prefix + + (f"_{split}" if split is not None else "") + + (ext if ext is not None else "") + + (".tmp" if temp else "") ) - output_filepath = Path(output_dir) / (config_prefix + (f"_{split}" if split is not None else "") + (ext if ext is not None else "") + (".tmp" if temp else "")) return output_filepath @staticmethod - def _subsequence_generator(sequence: str, subsequence_length: int | None = None, offset: int | None = None): + def _subsequence_generator(sequence: str, subsequence_length: Optional[int] = None, offset: Optional[int] = None): + """Generate subsequences from a given sequence. + + Args: + sequence (str): The input sequence. + subsequence_length (int | None): Length of each subsequence. Defaults to the length of the sequence. + offset (int | None): Step size for generating subsequences. Defaults to subsequence_length. + + Yields: + str: Subsequences of the input sequence. + """ subsequence_length = subsequence_length if subsequence_length is not None else len(sequence) step_size = offset if offset is not None else subsequence_length for i in range(0, len(sequence), step_size): yield sequence[i : i + subsequence_length] @staticmethod - def _random_reverse_complement(seq: str, prob: float = 0.0, seed: int = None): - with Evo2Preprocessor.preprocessing_context_manager( - seed if seed is not None else None - ): + def _random_reverse_complement(seq: str, prob: float = 0.0, seed: Optional[int] = None): + """Randomly reverse complements a DNA sequence based on a given probability. + + Args: + seq (str): The DNA sequence to potentially reverse complement. + prob (float): The probability of reverse complementing the sequence. Defaults to 0.0. + seed (Optional[int]): The seed for the random number generator. Defaults to None. + + Returns: + str: The original or reverse complemented DNA sequence based on the probability. + """ + with Evo2Preprocessor.preprocessing_context_manager(seed): if random.random() < prob: return complement_sequence(reverse_sequence(seq)) else: @@ -102,13 +142,33 @@ def _random_reverse_complement(seq: str, prob: float = 0.0, seed: int = None): @staticmethod def _reverse_complement_expansion(seq: str): + """Generate a list containing the original and reverse complemented sequence. + + Args: + seq (str): The input DNA sequence. + + Returns: + list[str]: List containing the original and reverse complemented sequence. + """ return [seq, complement_sequence(reverse_sequence(seq))] - + @staticmethod - def _train_val_test_split(train_weight: float, val_weight: float, test_weight: float, seed: int = None): - with Evo2Preprocessor.preprocessing_context_manager( - seed if seed is not None else None - ): + def _train_val_test_split(train_weight: float, val_weight: float, test_weight: float, seed: Optional[int] = None): + """Randomly assign a data point to train, validation, or test split based on provided weights. + + Args: + train_weight (float): The weight for the training split. + val_weight (float): The weight for the validation split. + test_weight (float): The weight for the test split. + seed (Optional[int]): The seed for the random number generator. Defaults to None. + + Returns: + str: The split assignment ('train', 'val', or 'test'). + + Raises: + ValueError: If the sum of the weights is zero or negative. + """ + with Evo2Preprocessor.preprocessing_context_manager(seed if seed is not None else None): # Generate random number. roll = random.random() # Rectify and normalize split ratios. @@ -126,25 +186,48 @@ def _train_val_test_split(train_weight: float, val_weight: float, test_weight: f return split @staticmethod - def _construct_taxonomy_token(lineage: Evo2TaxonomyLineage, dropout: float = 0.0, seed: int = None) -> Optional[str]: - """Construct a special Taxonomy token for natural language prompting of DNA generation models.""" + def _construct_taxonomy_token( + lineage: Evo2TaxonomyLineage, dropout: float = 0.0, seed: Optional[int] = None + ) -> Optional[str]: + """Construct a special Taxonomy token for natural language prompting of DNA generation models. + + Args: + lineage (Evo2TaxonomyLineage): The taxonomy lineage information. + dropout (float): The probability of dropping out segments of the lineage. Defaults to 0.0. + seed (Optional[int]): The seed for the random number generator. Defaults to None. + + Returns: + Optional[str]: The constructed taxonomy token or None if lineage is None. + """ # If dropout > 0, randomly drop out segments of the lineage for training on incomplete lineages. - with Evo2Preprocessor.preprocessing_context_manager( - seed if seed is not None else None - ): - return "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( - lineage.kingdom if random.random() >= dropout else None, - lineage.phylum if random.random() >= dropout else None, - lineage.clazz if random.random() >= dropout else None, - lineage.order if random.random() >= dropout else None, - lineage.family if random.random() >= dropout else None, - lineage.genus if random.random() >= dropout else None, - lineage.species if random.random() >= dropout else None, - ) if lineage is not None else None + with Evo2Preprocessor.preprocessing_context_manager(seed if seed is not None else None): + return ( + "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( + lineage.kingdom if random.random() >= dropout else None, + lineage.phylum if random.random() >= dropout else None, + lineage.clazz if random.random() >= dropout else None, + lineage.order if random.random() >= dropout else None, + lineage.family if random.random() >= dropout else None, + lineage.genus if random.random() >= dropout else None, + lineage.species if random.random() >= dropout else None, + ) + if lineage is not None + else None + ) def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, config: Evo2PreprocessingConfig): - """Preprocess fasta datapaths.""" + """Preprocess fasta datapaths. + + Args: + filepath (str): Path to the .fasta file. + seqid (str): Sequence ID. + seq (str): DNA sequence. + seq_idx (int): Sequence index. + config (Evo2PreprocessingConfig): Configuration object containing preprocessing settings. + Returns: + tuple[list[dict], float]: Preprocessed data and the time taken for preprocessing. + """ # Timing. start = time.time() # Retrieve taxonomy lineage string if SeqID has associated taxonomy data. @@ -181,13 +264,11 @@ def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, con # Construct taxonomy token with random dropout on the lineage categories per sequence. taxonomy_token = self._construct_taxonomy_token(lineage, dropout=config.random_lineage_dropout) - + # Inject taxonomy lineage tokens every prompt_spacer_length tokens in the sequence. # If the taxonomy lineage token is not provided, then just take the original sequence. target_length = ( - config.prompt_spacer_length - len(taxonomy_token) - if taxonomy_token is not None - else None + config.prompt_spacer_length - len(taxonomy_token) if taxonomy_token is not None else None ) taxonomy_injected_sequence = [ taxonomy_token + str(subseq) if taxonomy_token is not None else str(subseq) @@ -210,14 +291,28 @@ def preprocess_data(self, filepath: str, seqid: str, seq: str, seq_idx: int, con return preproc_data, end - start def preprocess_data_task(self, file_sequence_config): - """Wrapper function to unpack args for preprocess_data.""" + """Wrapper function to unpack args for preprocess_data. + + Args: + file_sequence_config (tuple): Tuple containing arguments for preprocess_data. + + Returns: + tuple[list[dict], float]: Preprocessed data and the time taken for preprocessing. + """ return self.preprocess_data(*file_sequence_config) - + @staticmethod def _yield_sequences_from_files(config: Evo2PreprocessingConfig, semaphore: Semaphore): """Iterator over sequences within multiple input documents. Arguments for multiprocessing tasks. Utilized to limit the amount of sequences streamed into memory. + + Args: + config (Evo2PreprocessingConfig): Configuration object containing preprocessing settings. + semaphore (Semaphore): Semaphore to limit the number of sequences in memory. + + Yields: + tuple: Arguments for preprocess_data. """ def yielder(fname, semaphore): @@ -233,8 +328,14 @@ def yielder(fname, semaphore): yield from yielder(fname, semaphore) def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): - """Main function to preprocess data for Evo2.""" + """Main function to preprocess data for Evo2. + Args: + preproc_config (Evo2PreprocessingConfig): Configuration object containing preprocessing settings. + + Yields: + tuple[dict, float]: Preprocessed sequence data and the time taken for preprocessing. + """ # Instantiate multiprocessing pool. Use semaphore to limit the amount of sequences to read into memory. semaphore = Semaphore(preproc_config.preproc_concurrency + preproc_config.workers) if preproc_config.workers > 1: @@ -242,17 +343,12 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): # Ordered imap for downstream seeded splitting. preproc_tasks = pool.imap( self.preprocess_data_task, - self._yield_sequences_from_files( - preproc_config, semaphore - ), + self._yield_sequences_from_files(preproc_config, semaphore), chunksize=preproc_config.chunksize, ) else: preproc_tasks = ( - self.preprocess_data_task(x) - for x in self._yield_sequences_from_files( - preproc_config, semaphore - ) + self.preprocess_data_task(x) for x in self._yield_sequences_from_files(preproc_config, semaphore) ) # Preprocess data and split results into train, test, and split. @@ -261,22 +357,34 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): # Release semaphore for the task associated with the result. semaphore.release() # Randomly assign all sequences to train, validation, or test. - split = self._train_val_test_split(preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split) + split = self._train_val_test_split( + preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split + ) for sequence in result: sequence["split"] = split yield sequence, elapsed_time def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): - """Offline data preprocessing script for Evo2.""" + """Offline data preprocessing script for Evo2. + Args: + preproc_config (Evo2PreprocessingConfig): Configuration object containing preprocessing settings. + """ # Validate if binaries have already been produced for the given config and overwrite is set to False. - if any(self._get_output_filename(preproc_config, ext, split).is_file() for ext, split in zip([self.BIN, self.IDX], [self.TRAIN, self.VAL, self.TEST])): + if any( + self._get_output_filename(preproc_config, ext, split).is_file() + for ext, split in zip([self.BIN, self.IDX], [self.TRAIN, self.VAL, self.TEST]) + ): if not preproc_config.overwrite: # Skip this dataset! - logging.info(f"Skipped overwriting (overwrite: False) existing preprocessed data: {preproc_config.output_prefix}") + logging.info( + f"Skipped overwriting (overwrite: False) existing preprocessed data: {preproc_config.output_prefix}" + ) return else: - logging.info(f"Overwriting (overwrite: True) existing preprocessed data: {preproc_config.output_prefix}") + logging.info( + f"Overwriting (overwrite: True) existing preprocessed data: {preproc_config.output_prefix}" + ) # Instantiate indexed data builders. dataset_dtype = getattr(np, preproc_config.indexed_dataset_dtype) @@ -308,7 +416,7 @@ def preprocess_offline(self, preproc_config: Evo2PreprocessingConfig): avg_preproc_time = (avg_preproc_time * count + elapsed_time) / (count + 1) avg_index_time = (avg_index_time * count + index_end_time - index_start_time) / (count + 1) count += 1 - + # Report timing. logging.info(f"Average preprocessing time per sequence: {avg_preproc_time}") logging.info(f"Average indexing time per sequence: {avg_index_time}") @@ -331,6 +439,11 @@ def parse_args(): def main(): + """Main function to execute the preprocessing script. + + This function parses command-line arguments, reads the configuration file, + and initiates the preprocessing of data as specified in the configuration. + """ # Parse arguments. args = parse_args() # Read config YAML. @@ -345,7 +458,9 @@ def main(): # Preprocess data specified in config. evo2_preprocessor.preprocess_offline(evo2_preproc_config) end = time.time() - logging.info(f"Finished preprocessing {evo2_preproc_config.output_prefix} ({evo2_preproc_config.datapaths}) in {end - start:.3f} seconds with {evo2_preproc_config.workers} workers.") + logging.info( + f"Finished preprocessing {evo2_preproc_config.output_prefix} ({evo2_preproc_config.datapaths}) in {end - start:.3f} seconds with {evo2_preproc_config.workers} workers." + ) if __name__ == "__main__": diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py index 873bc4a27d..d2c897f240 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py @@ -1,16 +1,43 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + import argparse -from collections import defaultdict import math import re import sys -from bionemo.noodles import back_transcribe_sequence, complement_sequence, reverse_sequence, transcribe_sequence -from bionemo.noodles.nvfaidx import NvFaidx +from collections import defaultdict + from nemo.utils import logging +from bionemo.noodles import complement_sequence, reverse_sequence +from bionemo.noodles.nvfaidx import NvFaidx + + def parse_gtf_attributes(attributes: str): + """Parses the attributes field of a GTF file line into a dictionary. + + Args: + attributes (str): The attributes field from a GTF file line. + + Returns: + dict: A dictionary of attribute key-value pairs. + """ # Split on all semicolons that are not inside quotes attributes = re.split(r';(?=(?:[^"]*"[^"]*")*[^"]*$)', attributes) - out = dict() + out = {} for a in attributes: if len(a) == 0: continue @@ -19,53 +46,61 @@ def parse_gtf_attributes(attributes: str): out[key] = value return out + def extract_transcript_exons(gtf_path: str, only_longest_transcript: bool): + """Extracts transcript exons from a GTF file and optionally keeps only the longest transcript per gene. + Args: + gtf_path (str): Path to the GTF file. + only_longest_transcript (bool): Whether to keep only the longest transcript per gene. + + Returns: + dict: A dictionary containing transcript and exon information. + """ genes = defaultdict(set) gene2transcripts = defaultdict(set) - transcripts = dict() - exons = dict() - exon2transcript = dict() - transcript2gene = dict() + transcripts = {} + exons = {} + exon2transcript = {} + transcript2gene = {} transcript2exon = defaultdict(set) skip_transcripts = set() - gtf_fields = ['seqname', 'source', 'feature', 'start', 'end', 'score', 'strand', 'frame', 'attribute'] + gtf_fields = ["seqname", "source", "feature", "start", "end", "score", "strand", "frame", "attribute"] with open(gtf_path) as infile: for line in infile: # skip header lines - if line.startswith("#"): continue + if line.startswith("#"): + continue line = line.strip().split("\t") if len(line) < 9: continue # parse the attributes into a dictionary line = dict(zip(gtf_fields, line)) - attribs = parse_gtf_attributes(line['attribute']) - - if line['feature'] == 'gene': - contig, start, end, strand = line['seqname'], line['start'], line['end'], line['strand'] - start, end = int(line['start'])-1, int(line['end']) - try: - gene_id = attribs['gene_id'] - except: + attribs = parse_gtf_attributes(line["attribute"]) + + if line["feature"] == "gene": + contig, start, end, strand = line["seqname"], line["start"], line["end"], line["strand"] + start, end = int(line["start"]) - 1, int(line["end"]) + gene_id = attribs.get("gene_id", None) + if not gene_id: continue genes[gene_id].add((contig, start, end, strand)) - elif line['feature'] == 'exon': - contig, start, end, strand = line['seqname'], line['start'], line['end'], line['strand'] - start, end = int(line['start'])-1, int(line['end']) - try: - gene_id = attribs['gene_id'] - except: + elif line["feature"] == "exon": + contig, start, end, strand = line["seqname"], line["start"], line["end"], line["strand"] + start, end = int(line["start"]) - 1, int(line["end"]) + gene_id = attribs.get("gene_id", None) + if not gene_id: continue - transcript_id = attribs['transcript_id'] + transcript_id = attribs["transcript_id"] gene2transcripts[gene_id].add(transcript_id) # Skip exons that have already been handled and are likely errors if transcript_id in skip_transcripts: continue - exon_number = int(attribs['exon_number']) + exon_number = int(attribs["exon_number"]) exon_id = (gene_id, transcript_id, exon_number) if exon_id in exons: @@ -77,39 +112,44 @@ def extract_transcript_exons(gtf_path: str, only_longest_transcript: bool): skip_transcripts.add(transcript_id) continue - exons[exon_id] = {"seqname":contig, "start":start, "end":end, "strand":strand} + exons[exon_id] = {"seqname": contig, "start": start, "end": end, "strand": strand} if exon_id in exon2transcript: raise Exception("Exon Already Exists in exon2transcript") exon2transcript[exon_id] = transcript_id transcript2exon[transcript_id].add(exon_id) - elif line['feature'] == 'transcript': - contig, start, end, strand = line['seqname'], line['start'], line['end'], line['strand'] - start, end = int(line['start'])-1, int(line['end']) - try: - gene_id = attribs['gene_id'] - except: + elif line["feature"] == "transcript": + contig, start, end, strand = line["seqname"], line["start"], line["end"], line["strand"] + start, end = int(line["start"]) - 1, int(line["end"]) + gene_id = attribs.get("gene_id", None) + if not gene_id: continue - - gbkey = attribs['gbkey'] - transcript_biotype = attribs['transcript_biotype'] - transcript_id = attribs['transcript_id'] + gbkey = attribs["gbkey"] + transcript_biotype = attribs["transcript_biotype"] + transcript_id = attribs["transcript_id"] if transcript_id in skip_transcripts: continue - transcripts[transcript_id] = {"seqname":contig, "start":start, "end":end, "strand":strand, "gbkey":gbkey, "transcript_biotype":transcript_biotype} + transcripts[transcript_id] = { + "seqname": contig, + "start": start, + "end": end, + "strand": strand, + "gbkey": gbkey, + "transcript_biotype": transcript_biotype, + } transcript2gene[transcript_id] = gene_id gene2transcripts[gene_id].add(transcript_id) - + if only_longest_transcript: transcript_lengths = defaultdict(int) for exon in exons: - transcript_lengths[exon[1]] += exons[exon]['end'] - exons[exon]['start'] + transcript_lengths[exon[1]] += exons[exon]["end"] - exons[exon]["start"] - keep_transcripts = dict() - keep_exons = dict() - keep_exon2transcript = dict() - keep_transcript2gene = dict() + keep_transcripts = {} + keep_exons = {} + keep_exon2transcript = {} + keep_transcript2gene = {} keep_transcript2exon = defaultdict(set) keep_skip_transcripts = set() @@ -123,7 +163,7 @@ def extract_transcript_exons(gtf_path: str, only_longest_transcript: bool): keep_exon2transcript[exon] = longest_transcript keep_transcript2exon[longest_transcript].add(exon) keep_transcript2gene[longest_transcript] = gene - + transcripts = keep_transcripts exons = keep_exons exon2transcript = keep_exon2transcript @@ -132,73 +172,103 @@ def extract_transcript_exons(gtf_path: str, only_longest_transcript: bool): skip_transcripts = keep_skip_transcripts return { - 'transcripts': transcripts, - 'exons': exons, - 'exon2transcript': exon2transcript, - 'transcript2gene': transcript2gene, - 'transcript2exon': transcript2exon + "transcripts": transcripts, + "exons": exons, + "exon2transcript": exon2transcript, + "transcript2gene": transcript2gene, + "transcript2exon": transcript2exon, } - + + def extract_default_transcript_sequences(transcript_info, fasta_records, output_file): + """Extracts default transcript sequences from the provided transcript information and writes them to an output file. - for transcript_id in transcript_info['transcripts']: - gene_id = transcript_info['transcript2gene'][transcript_id] - this_exons = list(sorted(transcript_info['transcript2exon'][transcript_id], key=lambda x: x[-1])) + Args: + transcript_info (dict): Dictionary containing transcript and exon information. + fasta_records (NvFaidx): Indexed FASTA records. + output_file (TextIO): File object to write the output sequences. + """ + for transcript_id in transcript_info["transcripts"]: + gene_id = transcript_info["transcript2gene"][transcript_id] + this_exons = sorted(transcript_info["transcript2exon"][transcript_id], key=lambda x: x[-1]) seqname = None exon_qc_failed = False if len(this_exons) > 1: for i in range(1, len(this_exons)): this_exon = this_exons[i] - prev_exon = this_exons[i-1] - this_coords = transcript_info['exons'][this_exon] - prev_coords = transcript_info['exons'][prev_exon] - if this_coords['strand'] != prev_coords['strand']: + prev_exon = this_exons[i - 1] + this_coords = transcript_info["exons"][this_exon] + prev_coords = transcript_info["exons"][prev_exon] + if this_coords["strand"] != prev_coords["strand"]: exon_qc_failed = True - if this_coords['strand'] == '+' and this_coords['start'] < prev_coords['start']: + if this_coords["strand"] == "+" and this_coords["start"] < prev_coords["start"]: exon_qc_failed = True - if this_coords['strand'] == '-' and this_coords['start'] > prev_coords['start']: + if this_coords["strand"] == "-" and this_coords["start"] > prev_coords["start"]: exon_qc_failed = True - if this_coords['seqname'] != prev_coords['seqname']: + if this_coords["seqname"] != prev_coords["seqname"]: exon_qc_failed = True - + if exon_qc_failed: continue - - transcript_seq = '' + + transcript_seq = "" for exon in this_exons: - coords = transcript_info['exons'][exon] + coords = transcript_info["exons"][exon] if seqname is None: - seqname = coords['seqname'] - exon_seq = str(fasta_records[coords['seqname']][coords['start']:coords['end']]) - if coords['strand'] == '-': + seqname = coords["seqname"] + exon_seq = str(fasta_records[coords["seqname"]][coords["start"] : coords["end"]]) + if coords["strand"] == "-": exon_seq = reverse_sequence(complement_sequence(exon_seq)) transcript_seq += exon_seq - - print(f'>{seqname}|{gene_id}|{transcript_id}\n{transcript_seq}', file=output_file) -def extract_stitched_transcript_sequences(transcript_info, fasta_records, output_file, stitch_token='@', promoter_size=1024, intron_window=32, overlap=False): - - for transcript_id in transcript_info['transcripts']: - gene_id = transcript_info['transcript2gene'][transcript_id] - this_exons = list(sorted(transcript_info['transcript2exon'][transcript_id], key=lambda x: x[-1])) + print(f">{seqname}|{gene_id}|{transcript_id}\n{transcript_seq}", file=output_file) + + +def extract_stitched_transcript_sequences( + transcript_info, fasta_records, output_file, stitch_token="@", promoter_size=1024, intron_window=32, overlap=False +): + """Extracts stitched transcript sequences from the provided transcript information and writes them to an output file. + + The "stitched" word refers to the process of combining sequences from different regions of the genome to form a single, + continuous transcript sequence. + This includes: + Promoter Region: A specified number of base pairs (bp) upstream of the transcript start site. + Exons: The coding regions of the transcript. + Intron Windows: A specified number of bp from the neighboring introns around each exon. + + The stitch_token is used to denote the boundaries between + these regions in the stitched transcript sequences. + + Args: + transcript_info (dict): Dictionary containing transcript and exon information. + fasta_records (NvFaidx): Indexed FASTA records. + output_file (TextIO): File object to write the output sequences. + stitch_token (str, optional): Token to use for stitching sequences. Defaults to "@". + promoter_size (int, optional): Number of bp to include in the promoter region. Defaults to 1024. + intron_window (int, optional): Number of bp to include from neighboring introns. Defaults to 32. + overlap (bool, optional): Whether to allow overlap of neighboring intron windows. Defaults to False. + """ + for transcript_id in transcript_info["transcripts"]: + gene_id = transcript_info["transcript2gene"][transcript_id] + this_exons = sorted(transcript_info["transcript2exon"][transcript_id], key=lambda x: x[-1]) exon_qc_failed = False if len(this_exons) > 1: for i in range(1, len(this_exons)): this_exon = this_exons[i] - prev_exon = this_exons[i-1] - this_coords = transcript_info['exons'][this_exon] - prev_coords = transcript_info['exons'][prev_exon] - if this_coords['strand'] != prev_coords['strand']: + prev_exon = this_exons[i - 1] + this_coords = transcript_info["exons"][this_exon] + prev_coords = transcript_info["exons"][prev_exon] + if this_coords["strand"] != prev_coords["strand"]: exon_qc_failed = True - if this_coords['strand'] == '+' and this_coords['start'] < prev_coords['start']: + if this_coords["strand"] == "+" and this_coords["start"] < prev_coords["start"]: exon_qc_failed = True - if this_coords['strand'] == '-' and this_coords['start'] > prev_coords['start']: + if this_coords["strand"] == "-" and this_coords["start"] > prev_coords["start"]: exon_qc_failed = True - if this_coords['seqname'] != prev_coords['seqname']: + if this_coords["seqname"] != prev_coords["seqname"]: exon_qc_failed = True - + if exon_qc_failed: continue @@ -206,59 +276,69 @@ def extract_stitched_transcript_sequences(transcript_info, fasta_records, output seqname = None for i in range(len(this_exons)): # Previous Exon - prev_exon = this_exons[i-1] if i > 0 else None - prev_coords = transcript_info['exons'].get(prev_exon, None) + prev_exon = this_exons[i - 1] if i > 0 else None + prev_coords = transcript_info["exons"].get(prev_exon, None) # Current Exon cur_exon = this_exons[i] - cur_coords = transcript_info['exons'].get(cur_exon, None) + cur_coords = transcript_info["exons"].get(cur_exon, None) exon_number = cur_exon[-1] if seqname is None: - seqname = cur_coords['seqname'] + seqname = cur_coords["seqname"] # Next Exon - next_exon = this_exons[i+1] if i < len(this_exons)-1 else None - next_coords = transcript_info['exons'].get(next_exon, None) + next_exon = this_exons[i + 1] if i < len(this_exons) - 1 else None + next_coords = transcript_info["exons"].get(next_exon, None) # Extract the stitched spliced sequence without overlapping intron windows. - intron_window_left = min(intron_window, math.floor(abs(cur_coords['start'] - prev_coords['end']) / 2)) if not overlap and prev_coords is not None else intron_window - intron_window_right = min(intron_window, math.ceil(abs(next_coords['start'] - cur_coords['end']) / 2)) if not overlap and next_coords is not None else intron_window - if cur_coords['strand'] == '+' and exon_number == 1: - exon_start = cur_coords['start'] - promoter_size - exon_end = cur_coords['end'] + intron_window_right - elif cur_coords['strand'] == '-' and exon_number == 1: - exon_start = cur_coords['start'] - intron_window_left - exon_end = cur_coords['end'] + promoter_size + intron_window_left = ( + min(intron_window, math.floor(abs(cur_coords["start"] - prev_coords["end"]) / 2)) + if not overlap and prev_coords is not None + else intron_window + ) + intron_window_right = ( + min(intron_window, math.ceil(abs(next_coords["start"] - cur_coords["end"]) / 2)) + if not overlap and next_coords is not None + else intron_window + ) + if cur_coords["strand"] == "+" and exon_number == 1: + exon_start = cur_coords["start"] - promoter_size + exon_end = cur_coords["end"] + intron_window_right + elif cur_coords["strand"] == "-" and exon_number == 1: + exon_start = cur_coords["start"] - intron_window_left + exon_end = cur_coords["end"] + promoter_size else: - exon_start = cur_coords['start'] - intron_window_left - exon_end = cur_coords['end'] + intron_window_right - exon_seq = str(fasta_records[cur_coords['seqname']][exon_start:exon_end]) - if cur_coords['strand'] == '-': + exon_start = cur_coords["start"] - intron_window_left + exon_end = cur_coords["end"] + intron_window_right + exon_seq = str(fasta_records[cur_coords["seqname"]][exon_start:exon_end]) + if cur_coords["strand"] == "-": exon_seq = stitch_token + reverse_sequence(complement_sequence(exon_seq)) transcript_seq += exon_seq - + if stitch_token and len(stitch_token) > 0: - transcript_seq = transcript_seq[len(stitch_token):] - - print(f'>{seqname}|{gene_id}|{transcript_id}\n{transcript_seq}', file=output_file) + transcript_seq = transcript_seq[len(stitch_token) :] -def run(args): + print(f">{seqname}|{gene_id}|{transcript_id}\n{transcript_seq}", file=output_file) - with ( - open(args.output_path, "w") if args.output_path is not None else sys.stdout - ) as output_file: +def run(args): + """Main function to run the transcript extraction process based on command line arguments. + + Args: + args (argparse.Namespace): Parsed command line arguments. + """ + with open(args.output_path, "w") if args.output_path is not None else sys.stdout as output_file: if args.verbose: logging.info("Indexing FASTA file...") fasta_index = NvFaidx(args.fasta_path) - if args.transcript_type == 'default': + if args.transcript_type == "default": if args.verbose: logging.info("Extracting default transcripts...") if args.only_longest_transcript: logging.info("Only extracting the longest transcript per gene.") else: logging.info("Extracting all transcripts regardless of length.") - - elif args.transcript_type == 'stitched': + + elif args.transcript_type == "stitched": if args.verbose: logging.info("Extracting stitched transcripts...") if args.only_longest_transcript: @@ -268,39 +348,72 @@ def run(args): transcript_info = extract_transcript_exons(args.gtf_path, args.only_longest_transcript) - if args.transcript_type == 'default': + if args.transcript_type == "default": extract_default_transcript_sequences(transcript_info, fasta_index, output_file) - elif args.transcript_type == 'stitched': + elif args.transcript_type == "stitched": extract_stitched_transcript_sequences( transcript_info, fasta_index, output_file, promoter_size=args.stitched_promoter, intron_window=args.stitched_intron, - overlap=args.stitched_overlap + overlap=args.stitched_overlap, ) + def parse_args(): - """Parse command line arguments for splicing transcripts.""" + """Parses command line arguments for the transcript extraction script. + + Returns: + argparse.Namespace: Parsed command line arguments. + """ ap = argparse.ArgumentParser(description="Extract spliced transcripts from a FASTA and GTF.") ap.add_argument("--fasta-path", type=str, required=True, help="Path to FASTA file to extract transcripts from.") - ap.add_argument("--gtf-path", type=str, required=True, help="Path to gene transfer format (GTF) file associated with the FASTA.") + ap.add_argument( + "--gtf-path", + type=str, + required=True, + help="Path to gene transfer format (GTF) file associated with the FASTA.", + ) ap.add_argument("--output-path", type=str, default=None, help="Path to output FASTA file.") - ap.add_argument("--transcript-type", type=str, default="default", choices=['default','stitched'], - help="Type of transcript to extract from the GTF and FASTA files for splicing. 'Stitched' transcripts include 1024 bp of sequence from the promoter and 32 bp around each exon.") - ap.add_argument("--stitched-promoter", type=int, default=1024, help="Number of bp to include in the promoter region when --transcript-type=stitched is used. Defaults to 1024.") - ap.add_argument("--stitched-intron", type=int, default=32, help="Number of bp to include from neighboring introns when --transcript-type=stitched is used. Defaults to 32.") - ap.add_argument("--stitched-overlap", action='store_true', - help="Allow overlap of neighboring intron windows when --transcript-type=stitched is used. Defaults to False, i.e. prevents overlap by shortening the intron windows for a contiguous splice.") - ap.add_argument("--only-longest-transcript", action='store_true', help="Only extract the longest transcript per gene.") - ap.add_argument("-v", "--verbose", action='store_true', help="Turn on verbose log messages.") + ap.add_argument( + "--transcript-type", + type=str, + default="default", + choices=["default", "stitched"], + help="Type of transcript to extract from the GTF and FASTA files for splicing. 'Stitched' transcripts include 1024 bp of sequence from the promoter and 32 bp around each exon.", + ) + ap.add_argument( + "--stitched-promoter", + type=int, + default=1024, + help="Number of bp to include in the promoter region when --transcript-type=stitched is used. Defaults to 1024.", + ) + ap.add_argument( + "--stitched-intron", + type=int, + default=32, + help="Number of bp to include from neighboring introns when --transcript-type=stitched is used. Defaults to 32.", + ) + ap.add_argument( + "--stitched-overlap", + action="store_true", + help="Allow overlap of neighboring intron windows when --transcript-type=stitched is used. Defaults to False, i.e. prevents overlap by shortening the intron windows for a contiguous splice.", + ) + ap.add_argument( + "--only-longest-transcript", action="store_true", help="Only extract the longest transcript per gene." + ) + ap.add_argument("-v", "--verbose", action="store_true", help="Turn on verbose log messages.") return ap.parse_args() + def main(): + """Entry point for the script. Parses arguments and runs the extraction process.""" args = parse_args() if args.verbose: logging.info(args) run(args) -if __name__ == '__main__': - main() \ No newline at end of file + +if __name__ == "__main__": + main() diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 8fda8579c6..4f4aa7cd20 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -37,7 +37,12 @@ def parse_args(): + "g__Escherichia;" + "s__Escherichia|" ) - ap.add_argument("--prompt", type=str, default=default_prompt, help="Prompt to generate text from Evo2. Defaults to a phylogenetic lineage tag for E coli.") + ap.add_argument( + "--prompt", + type=str, + default=default_prompt, + help="Prompt to generate text from Evo2. Defaults to a phylogenetic lineage tag for E coli.", + ) ap.add_argument( "--ckpt-dir", type=str, required=True, help="Path to checkpoint directory containing pre-trained Evo2 model." ) @@ -47,17 +52,26 @@ def parse_args(): ap.add_argument("--max-new-tokens", type=int, default=1024, help="Maximum number of tokens to generate.") # compute args: ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1.") - ap.add_argument("--pipeline-model-parallel-size", type=int, default=1, help="Order of pipeline parallelism. Defaults to 1.") - ap.add_argument("--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1.") + ap.add_argument( + "--pipeline-model-parallel-size", type=int, default=1, help="Order of pipeline parallelism. Defaults to 1." + ) + ap.add_argument( + "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." + ) # output args: - ap.add_argument("--output-file", type=str, default=None, help="Output file containing the generated text produced by the Evo2 model. If not provided, the output will be logged.") + ap.add_argument( + "--output-file", + type=str, + default=None, + help="Output file containing the generated text produced by the Evo2 model. If not provided, the output will be logged.", + ) # extra: ap.add_argument( "--ckpt-format", type=str, - choices=['torch_dist', 'zarr'], - default='torch_dist', - help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated." + choices=["torch_dist", "zarr"], + default="torch_dist", + help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated.", ) return ap.parse_args() @@ -104,7 +118,7 @@ def main(): ), text_only=True, ) - + if torch.distributed.get_rank() == 0: if args.output_file is None: logging.info(results) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 51d818852b..301cadac21 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -15,7 +15,7 @@ import argparse from collections import defaultdict -from dataclasses import dataclass, asdict +from dataclasses import asdict, dataclass import nvidia_resiliency_ext.ptl_resiliency as res_module import torch @@ -104,7 +104,10 @@ def parse_args(): "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." ) parser.add_argument( - "--limit-val-batches", type=int, default=20, help="Number of validation steps", + "--limit-val-batches", + type=int, + default=20, + help="Number of validation steps", ) parser.add_argument( "--ckpt-dir", @@ -139,14 +142,14 @@ def parse_args(): parser.add_argument( "--ckpt-format", type=str, - choices=['torch_dist', 'zarr'], - default='torch_dist', - help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated." + choices=["torch_dist", "zarr"], + default="torch_dist", + help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated.", ) parser.add_argument( "--tflops-callback", action="store_true", - help="Enable tflops calculation callback for Hyena / Evo2. Defaults to False." + help="Enable tflops calculation callback for Hyena / Evo2. Defaults to False.", ) # NSYS profiling/tooling arguments @@ -186,11 +189,15 @@ def parse_args(): @dataclass class TPOverlapCfg: + """Base configuration class for Tensor Parallelism (TP) overlap.""" + pass @dataclass class PipelineOverlapCfg(TPOverlapCfg): + """Configuration for Pipeline Parallelism overlap.""" + num_sm: int cga_size: int num_splits: int @@ -201,6 +208,8 @@ class PipelineOverlapCfg(TPOverlapCfg): @dataclass class RingExchangeOverlapCfg(TPOverlapCfg): + """Configuration for ring exchange overlap.""" + aggregate: bool = False method: str = "ring_exchange" num_sm: int = 1 @@ -209,14 +218,19 @@ class RingExchangeOverlapCfg(TPOverlapCfg): @dataclass class BulkOverlapCfg(TPOverlapCfg): + """Configuration for bulk overlap in TP.""" + num_sm: int cga_size: int set_sm_margin: bool method: str = "bulk" +# TODO(dorotat) why are we copy pasting those methods? They are in NeMo @dataclass class TransformerLayerTPOverlapCfg: + """Configuration for TP overlap in transformer layers.""" + qkv_dgrad: TPOverlapCfg qkv_wgrad: TPOverlapCfg fc1_dgrad: TPOverlapCfg @@ -246,7 +260,15 @@ class TransformerLayerTPOverlapCfg: def parse_dataset_config(dataset_config_path: str): - """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena.""" + """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena. + + Args: + dataset_config_path (str): Path to the dataset configuration YAML file. + + Returns: + defaultdict: A dictionary where keys are dataset splits and values are lists containing the normalized weight + and dataset prefix for each split. + """ blended_dataset_config = defaultdict(list) weight_sums = defaultdict(float) with open(dataset_config_path, "r") as config_file: @@ -359,7 +381,7 @@ def main(): MegatronCommOverlapCallback( tp_comm_overlap=True, tp_comm_overlap_cfg=userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, - wgrad_deferral_limit=22, # default from NeMo + wgrad_deferral_limit=22, # default from NeMo overlap_param_gather_with_optimizer_step=False, # Currently disabled due to an issue with checkpointing. align_param_gather=args.align_param_gather, ) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md index e4e96a6768..d1b1837fb0 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md @@ -62,4 +62,4 @@ arc_40b_zero3_w32_mp8_test_notfinal_ckpt/global_step1 │ ├── 40b_test_chkpt.yml │ └── opengenome.yml └── zero_pp_rank_*_mp_rank_*_model_states.pt -``` \ No newline at end of file +``` diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py index 48dd6f6c0c..46c4558ce7 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py @@ -1,65 +1,117 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +"""This script converts (potentially sharded) ZeRo1 checkpoint parameters to the desired level of model tensor parallelism for the Evo 2 architecture. + +It only supports Zero-1 checkpoints and does not convert any optimizer state, +only the parameters. + +Usage: + python convert_checkpoint_model_parallel_evo2.py \ + --input-checkpoint-dir /path/to/input/checkpoint/global_step1000 \ + --output-checkpoint-dir /path/to/output/checkpoint_mp2/global_step1000 \ + --output-model-parallelism 2 """ -Usage: python convert_checkpoint_model_parallel_evo2.py \ - --input-checkpoint-dir /path/to/input/checkpoint/global_step1000 \ - --output-checkpoint-dir /path/to/output/checkpoint_mp2/global_step1000 \ - --output-model-parallelism 2 -Loads the (potentially sharded) parameters in `input_checkpoint_dir` and then re-shards -them according to the desired level of model tensor parallelism. - -Specialized to the Evo 2 architecture, only supports Zero-1 checkpoints, and does not -convert any optimizer state (only the parameters). -""" import argparse import os import re from collections import OrderedDict from glob import glob from pathlib import Path -from typing import List +from typing import List, Optional, Set, Union import torch -from params import EVO2_PARAMS, Param from nemo.utils import logging +from params import EVO2_PARAMS, Param + DEVICE = "cpu" -DEFAULT_PARAM_PATTERN = r'sequential\.\d+\.(.+)' +DEFAULT_PARAM_PATTERN = r"sequential\.\d+\.(.+)" + def get_args(): + """Parse command-line arguments.""" parser = argparse.ArgumentParser( description="Convert checkpoint parameters to desired model parallelism.", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) - parser.add_argument('--source_dir', type=str, required=True, help='Path to the input checkpoint directory containing ZeRo1 checkpoint shards, i.e. mp_rank_*_model_states.pt.') - parser.add_argument('--glob-pattern', type=str, default='mp_rank_*_model_states.pt', required=False, help='Filename pattern to glob for ZeRo1 checkpoint shards.') - parser.add_argument('--output_dir', type=str, required=True, help='Path to the output checkpoint directory to dump the --mp_size converted model checkpoint (ZeRo1).') - parser.add_argument('--mp_size', type=int, required=True, help='Desired output model parallelism to convert to.') - parser.add_argument('--exclude-extra', action='store_true', help='Exclude extra states in the conversion. Default to False, i.e. include extra states.') + parser.add_argument( + "--source_dir", + type=str, + required=True, + help="Path to the input checkpoint directory containing ZeRo1 checkpoint shards, i.e. mp_rank_*_model_states.pt.", + ) + parser.add_argument( + "--glob-pattern", + type=str, + default="mp_rank_*_model_states.pt", + required=False, + help="Filename pattern to glob for ZeRo1 checkpoint shards.", + ) + parser.add_argument( + "--output_dir", + type=str, + required=True, + help="Path to the output checkpoint directory to dump the --mp_size converted model checkpoint (ZeRo1).", + ) + parser.add_argument("--mp_size", type=int, required=True, help="Desired output model parallelism to convert to.") + parser.add_argument( + "--exclude-extra", + action="store_true", + help="Exclude extra states in the conversion. Default to False, i.e. include extra states.", + ) parser.add_argument("--verbose", action="store_true", help="Print more information about the conversion.") args = parser.parse_args() return args -def concatenate_tensors_across_shards( - tensor_name: str, - data_shards: List[OrderedDict[str, torch.Tensor]], - partition_dim: int, - hidden_dim: int = None, - verbose: bool = False -) -> torch.tensor: +def concatenate_tensors_across_shards( + tensor_name: str, + data_shards: List[OrderedDict[str, torch.Tensor]], + partition_dim: int, + hidden_dim: Optional[int] = None, + verbose: bool = False, +) -> torch.Tensor: + """Concatenate tensor shards across multiple shards. + + Args: + tensor_name (str): Name of the tensor to concatenate. + data_shards (List[OrderedDict[str, torch.Tensor]]): List of data shards containing tensors. + partition_dim (int): Dimension along which to partition the tensor. + hidden_dim (int, optional): Hidden dimension of the tensor. Defaults to None. + verbose (bool, optional): Whether to print detailed information. Defaults to False. + + Returns: + torch.Tensor: Concatenated tensor. + """ # Retrieve tensor shards. - tensors = [ shard['module'][tensor_name] for shard in data_shards ] + tensors = [shard["module"][tensor_name] for shard in data_shards] # Check shape of tensors without tensor parallelism, i.e. stored in all shards of the checkpoint. if partition_dim is None: for i, tensor in enumerate(tensors): if not torch.allclose(tensors[0], tensor): - logging.info(f'WARNING: Synchronized params differ for param {tensor_name}: abs max diff = {(tensors[0] - tensor).abs().max()}.') + logging.info( + f"WARNING: Synchronized params differ for param {tensor_name}: abs max diff = {(tensors[0] - tensor).abs().max()}." + ) # Get the distribution of tensors[0] and tensor. if verbose: ref_tensor = tensors[0].flatten().to(torch.float32) ref_min, ref_max = ref_tensor.min(), ref_tensor.max() - + q = torch.tensor([0.25, 0.5, 0.75], device=ref_tensor.device) ref_quantiles = ref_tensor.quantile(q) logging.info(f"rank0 tensor: min={ref_min}, max={ref_max} quantiles={ref_quantiles}") @@ -68,7 +120,7 @@ def concatenate_tensors_across_shards( target_min, target_max = target_tensor.min(), target_tensor.max() target_quantiles = target_tensor.quantile(q) logging.info(f"rank{i} tensor: min={target_min}, max={target_max} quantiles={target_quantiles}") - + logging.info(f"rank0 tensor distribution:\n {ref_tensor.histc(100, min=ref_min, max=ref_max)}") logging.info(f"rank{i} distribution:\n {target_tensor.histc(100, min=ref_min, max=ref_max)}") @@ -86,44 +138,74 @@ def concatenate_tensors_across_shards( # Store expected hidden dimension for all tensors. expected_dim = tensor.shape[hidden_dim] if not tensor.shape[hidden_dim] == expected_dim: - raise ValueError(f'Tensor {tensor_name} has invalid hidden shape {tensor.shape}.') + raise ValueError(f"Tensor {tensor_name} has invalid hidden shape {tensor.shape}.") # Concatenate shards. return torch.cat(tensors, dim=partition_dim) def split_tensor_across_shards( - data_shards: List[OrderedDict], - tensor: torch.tensor, - tensor_name: str, - partition_dim: int, + data_shards: List[OrderedDict], + tensor: torch.Tensor, + tensor_name: str, + partition_dim: int, ) -> None: - + """Split a tensor across multiple shards. + + Args: + data_shards (List[OrderedDict]): List of data shards to store the split tensors. + tensor (torch.Tensor): Tensor to split. + tensor_name (str): Name of the tensor. + partition_dim (int): Dimension along which to partition the tensor. + """ if partition_dim is None: # No sharding. Synchronize weights across all shards. for data_shard in data_shards: - data_shard['module'][tensor_name] = tensor - data_shard['param_shapes'][tensor_name] = tensor.shape + data_shard["module"][tensor_name] = tensor + data_shard["param_shapes"][tensor_name] = tensor.shape else: # Split the tensor along the partition dimension across shards. n_shards = len(data_shards) if tensor.shape[partition_dim] % n_shards != 0: - raise ValueError(f"Cannot shard {tensor_name} of dimension {tensor.shape[partition_dim]} across {n_shards} evenly.") + raise ValueError( + f"Cannot shard {tensor_name} of dimension {tensor.shape[partition_dim]} across {n_shards} evenly." + ) for chunk, data_shard in zip( torch.chunk(tensor, chunks=n_shards, dim=partition_dim), data_shards, ): - data_shard['module'][tensor_name] = chunk.clone() - data_shard['param_shapes'][tensor_name] = chunk.shape + data_shard["module"][tensor_name] = chunk.clone() + data_shard["param_shapes"][tensor_name] = chunk.shape def format_output_filename(shard: int) -> str: - return f'mp_rank_{str(shard).zfill(2)}_model_states.pt' - - -def check_params(detected, expected, buffers: set[str], param_pattern=DEFAULT_PARAM_PATTERN, verbose=False): - """Check that all model parameters are expected.""" - + """Format the output filename for a given shard index. + + Args: + shard (int): Shard index. + + Returns: + str: Formatted output filename. + """ + return f"mp_rank_{str(shard).zfill(2)}_model_states.pt" + + +def check_params( + detected: List[str], + expected: Union[Set[str], List[str]], + buffers: Set[str], + param_pattern: str = DEFAULT_PARAM_PATTERN, + verbose: bool = False, +): + """Check that all model parameters are expected. + + Args: + detected (List[str]): Detected model parameters names. + expected (Set[str]): Expected model parameters names. + buffers (Set[str]): Set of buffer names. + param_pattern (str, optional): Regex pattern to match parameter names. Defaults to DEFAULT_PARAM_PATTERN. + verbose (bool, optional): Whether to print detailed information. Defaults to False. + """ # Expected model parameters. expected = set(expected) if not isinstance(expected, set) else expected # Detected model parameters. @@ -136,13 +218,13 @@ def check_params(detected, expected, buffers: set[str], param_pattern=DEFAULT_PA logging.info(f"Could not match {k}") detected_param_set = set(model_param_names) if verbose: - logging.info("Detected Params:\n {detected_params}".format(detected_params='\n '.join(detected_param_set))) + logging.info("Detected Params:\n {detected_params}".format(detected_params="\n ".join(detected_param_set))) # Log unexpected model parameters. missing_params = expected - detected_param_set extra_params = detected_param_set - expected extra_params = [param for param in extra_params if param not in buffers] - extra_params = [param for param in extra_params if not param.endswith('._extra_state')] + extra_params = [param for param in extra_params if not param.endswith("._extra_state")] if len(extra_params) > 0: logging.info(f"WARNING: detected extra params: {extra_params}") if len(missing_params) > 0: @@ -150,9 +232,28 @@ def check_params(detected, expected, buffers: set[str], param_pattern=DEFAULT_PA if not (extra_params or missing_params): logging.info("No missing or extra params detected!") -def convert(input_data_shards, output_data_shards, model_parameter_names: List[str], param_list: List[Param], verbose=False, exclude_extra=False): - """Convert model weights from input model parallelism to output model parallelism.""" - logging.info(f"Converting {len(model_parameter_names)} parameters from {len(input_data_shards)} input shards to {len(output_data_shards)} output shards...") + +def convert_model_weights( + input_data_shards: List[OrderedDict], + output_data_shards: List[OrderedDict], + model_parameter_names: List[str], + param_list: List[Param], + verbose: bool = False, + exclude_extra: bool = False, +): + """Convert model weights from input model parallelism to output model parallelism. + + Args: + input_data_shards (List[OrderedDict]): List of input data shards. + output_data_shards (List[OrderedDict]): List of output data shards. + model_parameter_names (List[str]): List of model parameter names. + param_list (List[Param]): List of parameter information. + verbose (bool, optional): Whether to print detailed information. Defaults to False. + exclude_extra (bool, optional): Whether to exclude extra states in the conversion. Defaults to False. + """ + logging.info( + f"Converting {len(model_parameter_names)} parameters from {len(input_data_shards)} input shards to {len(output_data_shards)} output shards..." + ) converted = 0 skipped = 0 for model_parameter in model_parameter_names: @@ -160,30 +261,28 @@ def convert(input_data_shards, output_data_shards, model_parameter_names: List[s logging.info(f"Processing {model_parameter}...") # Ignore FP8 extra state. - if model_parameter.endswith('._extra_state'): - if 'extra_state' in model_parameter: - logging.info(f'Ignoring {model_parameter} -> contains extra state.') + if model_parameter.endswith("._extra_state"): + if "extra_state" in model_parameter: + logging.info(f"Ignoring {model_parameter} -> contains extra state.") skipped += 1 continue # Get the partition dimension and hidden dimension of each parameter. param_info = None for param in param_list: - if '.'.join(model_parameter.split('.')[2:]) == param.name: + if ".".join(model_parameter.split(".")[2:]) == param.name: if param_info is None: param_info = param else: - raise ValueError(f'Found more than one matching model parallelism parameter for {model_parameter}: {param_info}, {param}') + raise ValueError( + f"Found more than one matching model parallelism parameter for {model_parameter}: {param_info}, {param}" + ) if param_info is None: - raise ValueError(f'Could not find {model_parameter} among known parameters.') + raise ValueError(f"Could not find {model_parameter} among known parameters.") # Concatenate shards. concatenated_tensor = concatenate_tensors_across_shards( - model_parameter, - input_data_shards, - param_info.partition_dim, - param_info.hidden_dim, - verbose=verbose + model_parameter, input_data_shards, param_info.partition_dim, param_info.hidden_dim, verbose=verbose ) # Split into shards. split_tensor_across_shards( @@ -194,70 +293,101 @@ def convert(input_data_shards, output_data_shards, model_parameter_names: List[s ) converted += 1 logging.info(f"Converted {converted} of {len(model_parameter_names)} parameters (skipped {skipped} params).") - num_params = len(output_data_shards[0]['module']) + num_params = len(output_data_shards[0]["module"]) logging.info(f"Total Params: {num_params}") - if not all(num_params == len(shard['module']) for shard in output_data_shards): - raise ValueError('Shards have different number of parameters, which is not permitted in model parallelism.') + if not all(num_params == len(shard["module"]) for shard in output_data_shards): + raise ValueError("Shards have different number of parameters, which is not permitted in model parallelism.") if not exclude_extra: logging.info("Adding extra states from rank0 input shard...") - rank0_model = input_data_shards[0]['module'] + rank0_model = input_data_shards[0]["module"] for k in rank0_model.keys(): for i, output_shard in enumerate(output_data_shards): - if k not in output_shard['module']: + if k not in output_shard["module"]: if i == 0: logging.info(f"Adding {k} to output shards.") - output_shard['module'][k] = rank0_model[k] - new_params = len(output_data_shards[0]['module']) - num_params + output_shard["module"][k] = rank0_model[k] + new_params = len(output_data_shards[0]["module"]) - num_params logging.info(f"Added {new_params} extra states, total params: {num_params + new_params}") - if not all(num_params + new_params == len(shard['module']) for shard in output_data_shards): - raise ValueError('Shards have different number of parameters after adding extra states.') + if not all(num_params + new_params == len(shard["module"]) for shard in output_data_shards): + raise ValueError("Shards have different number of parameters after adding extra states.") for shard_idx, output_data_shard in enumerate(output_data_shards): - output_path = Path(output_data_shard['output_dir']) / format_output_filename(shard_idx) + output_path = Path(output_data_shard["output_dir"]) / format_output_filename(shard_idx) torch.save( output_data_shard, output_path, ) logging.info(f"Converted checkpoint saved to: {output_path}") - -def convert_zero1_model_parallel_checkpoint(source_dir: str, output_dir: str, glob_pattern: str = 'mp_rank_*_model_states.pt', model_parallel: int = 8, param_list: List[Param] = EVO2_PARAMS, exclude_extra_params: bool = False, verbose: bool = False): - """Convert sharded ZeRo1 checkpoint to desired model parallelism.""" + +def convert_zero1_model_parallel_checkpoint( + source_dir: str, + output_dir: str, + glob_pattern: str = "mp_rank_*_model_states.pt", + model_parallel: int = 8, + param_list: List[Param] = EVO2_PARAMS, + exclude_extra_params: bool = False, + verbose: bool = False, +): + """Convert sharded ZeRo1 checkpoint to desired model parallelism. + + Args: + source_dir (str): Path to the input checkpoint directory. + output_dir (str): Path to the output checkpoint directory. + glob_pattern (str): Filename pattern to glob for ZeRo1 checkpoint shards. Defaults to "mp_rank_*_model_states.pt". + model_parallel (int): Desired output model parallelism. Defaults to 8. + param_list (List[Param]): List of parameter information. Defaults to EVO2_PARAMS. + exclude_extra_params (bool): Whether to exclude extra states in the conversion. Defaults to False. + verbose (bool): Whether to print detailed information. Defaults to False. + """ # Argument validation. if not os.path.exists(source_dir): - raise ValueError(f'Input checkpoint dir ({source_dir}) not found.') + raise ValueError(f"Input checkpoint dir ({source_dir}) not found.") os.makedirs(output_dir, exist_ok=True) logging.info(f"Converting checkpoint from {source_dir} to {output_dir}") # Identify all checkpoint model path files. - parameter_paths = sorted(glob(f'{source_dir}/{glob_pattern}')) + parameter_paths = sorted(glob(f"{source_dir}/{glob_pattern}")) if len(parameter_paths) == 0: raise ValueError(f"No parameter files found in {source_dir}") # Load all shards from the ZeRo1 checkpoint. - input_data_shards = [ torch.load(path, map_location=DEVICE) for path in parameter_paths ] + input_data_shards = [torch.load(path, map_location=DEVICE) for path in parameter_paths] buffers = {buf for x in input_data_shards for buf in x.get("buffer_names", [])} # Initialize output MP shards. output_data_shards = [ { - 'module': OrderedDict(), - 'param_shapes': OrderedDict(), - 'dp_world_size': input_data_shards[0]['dp_world_size'], - 'output_dir': output_dir, + "module": OrderedDict(), + "param_shapes": OrderedDict(), + "dp_world_size": input_data_shards[0]["dp_world_size"], + "output_dir": output_dir, } for _ in range(model_parallel) ] - model_parameter_names = input_data_shards[0]['module'].keys() - + model_parameter_names = input_data_shards[0]["module"].keys() + # Check no missing or extra params - check_params(detected=model_parameter_names, expected=set(param.name for param in param_list), buffers=buffers, verbose=verbose) + check_params( + detected=list(model_parameter_names), + expected={param.name for param in param_list}, + buffers=buffers, + verbose=verbose, + ) # Convert the checkpoint - convert(input_data_shards, output_data_shards, model_parameter_names, param_list, verbose=verbose, exclude_extra=exclude_extra_params) + convert_model_weights( + input_data_shards, + output_data_shards, + model_parameter_names, + param_list, + verbose=verbose, + exclude_extra=exclude_extra_params, + ) logging.info("Done!") -if __name__ == '__main__': + +if __name__ == "__main__": args = get_args() convert_zero1_model_parallel_checkpoint( args.source_dir, @@ -266,5 +396,5 @@ def convert_zero1_model_parallel_checkpoint(source_dir: str, output_dir: str, gl args.mp_size, EVO2_PARAMS, args.exclude_extra, - args.verbose - ) \ No newline at end of file + args.verbose, + ) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py index 6106fcef4b..3eab8ecad9 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py @@ -1,24 +1,56 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + #!/usr/bin/env python import argparse import os import time from multiprocessing import Pool +from typing import List, Optional import zero3_conversion_lib from zero3_conversion_lib import get_elapsed, process_single_rank def convert_zero_checkpoint_to_fp32_state_dict( - checkpoint_dir, - output_dir, - tag=None, - exclude_frozen_parameters=False, - mp_size=8, - overwrite=False, - num_workers=1, - ranks_to_process=None, + checkpoint_dir: str, + output_dir: str, + tag: Optional[str] = None, + exclude_frozen_parameters: bool = False, + mp_size: int = 8, + overwrite: bool = False, + num_workers: int = 1, + ranks_to_process: Optional[List[int]] = None, ): + """Converts a DeepSpeed Zero-3 checkpoint to a PyTorch FP32 state_dict. + + Args: + checkpoint_dir (str): Path to the desired checkpoint folder. + output_dir (str): Directory to save the PyTorch FP32 state_dict output files. + tag (Optional[str]): Checkpoint tag used as a unique identifier or sub-directory that contains the checkpoint. + exclude_frozen_parameters (bool): Whether to exclude frozen parameters. + mp_size (int): Model parallel size of the source checkpoint. + overwrite (bool): Whether to overwrite existing MP shards. + num_workers (int): Number of workers to use for processing. + ranks_to_process (Optional[List[int]]): List of ranks to process. + + Raises: + FileNotFoundError: If the checkpoint directory does not exist. + """ ds_checkpoint_dir = os.path.join(checkpoint_dir, tag) if tag is not None else checkpoint_dir if not os.path.isdir(ds_checkpoint_dir): @@ -33,30 +65,28 @@ def convert_zero_checkpoint_to_fp32_state_dict( if ranks_to_process is not None: ranks_to_process = list(ranks_to_process) assert len(ranks_to_process) <= mp_size, f"Expected {mp_size} ranks to process, got {len(ranks_to_process)}" - assert all(0 <= r < mp_size for r in ranks_to_process), f"Expected ranks to be in range [0, {mp_size}), got {ranks_to_process}" + assert all( + 0 <= r < mp_size for r in ranks_to_process + ), f"Expected ranks to be in range [0, {mp_size}), got {ranks_to_process}" else: ranks_to_process = list(range(mp_size)) print(f"Processing ranks: {ranks_to_process}", flush=True) - + start = time.time() if num_workers > 1: with Pool(num_workers) as p: p.starmap( process_single_rank, - [ - (i, ds_checkpoint_dir, output_dir, overwrite, exclude_frozen_parameters) - for i in ranks_to_process - ], + [(i, ds_checkpoint_dir, output_dir, overwrite, exclude_frozen_parameters) for i in ranks_to_process], ) else: for i in ranks_to_process: process_single_rank(i, ds_checkpoint_dir, output_dir, overwrite, exclude_frozen_parameters) total_time = get_elapsed(time.time() - start) - print( - f"All done!\n-> Total time: {total_time}\n-> All outputs written to {os.path.abspath(output_dir)}" - ) + print(f"All done!\n-> Total time: {total_time}\n-> All outputs written to {os.path.abspath(output_dir)}") + if __name__ == "__main__": parser = argparse.ArgumentParser() @@ -89,14 +119,14 @@ def convert_zero_checkpoint_to_fp32_state_dict( args.rank_end = args.mp_size - 1 else: assert args.rank_end < args.mp_size, "Expected end rank to be less than mp_size" - + assert args.rank_start < args.rank_end, "Expected start rank to be less than end rank" assert args.rank_start >= 0, "Expected start rank to be greater than 0" args.ranks_to_process = list(range(args.rank_start, args.rank_end + 1)) else: args.ranks_to_process = list(range(args.mp_size)) - print(f"Args:") + print("Args:") for k, v in args.__dict__.items(): print(f" {k}: {v}", flush=True) print("") diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py index 055f6e092e..709ce0e5b4 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py @@ -1,42 +1,60 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + from dataclasses import dataclass @dataclass class Param: - name: str # Name of the parameter in the checkpoint. + """A dataclass representing a parameter in a checkpoint. + + Attributes: + name (str): The name of the parameter in the checkpoint. + partition_dim (int): The dimension index that gets sharded. `None` for no sharding. + hidden_dim (int): The hidden dimension index. `None` for no hidden dimension. + """ + + name: str # Name of the parameter in the checkpoint. partition_dim: int # The dimension index that gets sharded. `None` for no sharding. - hidden_dim: int # The hidden dimension index. `None` for no hidden dimension. + hidden_dim: int # The hidden dimension index. `None` for no hidden dimension. + EVO2_PARAMS = [ # Only layer_00. - Param('word_embeddings.weight', 0, 1), #torch.Size([64, 8192]) - - Param('input_layernorm.weight', None, 0), #torch.Size([8192]) - Param('post_attention_layernorm.weight', None, 0), #torch.Size([8192]) - Param('pre_mlp_layernorm.weight', None, 0), #torch.Size([8192]) - Param('outer_mlp_layernorm.weight', None, 0), #torch.Size([8192]) - - Param('mixer.dense_projection.weight', 0, 1), #torch.Size([3072, 8192]), - Param('mixer.hyena_proj_conv.short_conv_weight', 0, None), #torch.Size([3072, 3]), - - Param('mixer.mixer.conv_bias', 0, None), #torch.Size([1024]), - Param('mixer.mixer.filter.decay', 0, None), #torch.Size([64, 8192]), - Param('mixer.mixer.filter.gamma', 0, None), #torch.Size([1024, 16]), - Param('mixer.mixer.filter.h', 0, None), #torch.Size([64, 8192]), - Param('mixer.mixer.filter.p', 0, None), #torch.Size([1024, 16]), - Param('mixer.mixer.filter.R', 0, None), #torch.Size([1024, 16]), - Param('mixer.mixer.filter.t', None, 0), #torch.Size([1, 1, seqlen]), - - Param('mixer.mixer.short_conv.short_conv_weight', 0, None), #torch.Size([64, 1, 7]), - - Param('mixer.rotary_emb.inv_freq', None, None), #torch.Size([64]) - Param('mixer.dense.weight', 1, 0), #torch.Size([8192, 2048]), - Param('mixer.dense.bias', None, 0), #torch.Size([8192]) - - Param('mlp.w1.weight', 0, 1), #torch.Size([2736, 8192]), - Param('mlp.w2.weight', 0, 1), #torch.Size([2736, 8192]), - Param('mlp.w3.weight', 1, 0), #torch.Size([8192, 2736]), - + Param("word_embeddings.weight", 0, 1), # torch.Size([64, 8192]) + Param("input_layernorm.weight", None, 0), # torch.Size([8192]) + Param("post_attention_layernorm.weight", None, 0), # torch.Size([8192]) + Param("pre_mlp_layernorm.weight", None, 0), # torch.Size([8192]) + Param("outer_mlp_layernorm.weight", None, 0), # torch.Size([8192]) + Param("mixer.dense_projection.weight", 0, 1), # torch.Size([3072, 8192]), + Param("mixer.hyena_proj_conv.short_conv_weight", 0, None), # torch.Size([3072, 3]), + Param("mixer.mixer.conv_bias", 0, None), # torch.Size([1024]), + Param("mixer.mixer.filter.decay", 0, None), # torch.Size([64, 8192]), + Param("mixer.mixer.filter.gamma", 0, None), # torch.Size([1024, 16]), + Param("mixer.mixer.filter.h", 0, None), # torch.Size([64, 8192]), + Param("mixer.mixer.filter.p", 0, None), # torch.Size([1024, 16]), + Param("mixer.mixer.filter.R", 0, None), # torch.Size([1024, 16]), + Param("mixer.mixer.filter.t", None, 0), # torch.Size([1, 1, seqlen]), + Param("mixer.mixer.short_conv.short_conv_weight", 0, None), # torch.Size([64, 1, 7]), + Param("mixer.rotary_emb.inv_freq", None, None), # torch.Size([64]) + Param("mixer.dense.weight", 1, 0), # torch.Size([8192, 2048]), + Param("mixer.dense.bias", None, 0), # torch.Size([8192]) + Param("mlp.w1.weight", 0, 1), # torch.Size([2736, 8192]), + Param("mlp.w2.weight", 0, 1), # torch.Size([2736, 8192]), + Param("mlp.w3.weight", 1, 0), # torch.Size([8192, 2736]), # Only last layer. - Param('norm.weight', None, 0), #torch.Size([8192]), + Param("norm.weight", None, 0), # torch.Size([8192]), ] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py index bb767a3c8e..45f36fde5f 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py @@ -1,18 +1,43 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + import argparse from nemo.collections import llm -from nemo.collections.llm.gpt.model.hyena import PyTorchHyenaImporter +from nemo.collections.llm.gpt.model.hyena import PyTorchHyenaImporter + def parse_args(): + """Parse command-line arguments.""" parser = argparse.ArgumentParser() - parser.add_argument("--model-path", type=str, required=True, help="Path to the Evo2 un-sharded (MP1) model checkpoint file.") + parser.add_argument( + "--model-path", type=str, required=True, help="Path to the Evo2 un-sharded (MP1) model checkpoint file." + ) parser.add_argument("--output-dir", type=str, required=True, help="Output directory path for the converted model.") - parser.add_argument("--model-type", type=str, choices=["7b", "40b", "test"], default="7b", - help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b).") + parser.add_argument( + "--model-type", + type=str, + choices=["7b", "40b", "test"], + default="7b", + help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b).", + ) return parser.parse_args() -if __name__ == "__main__": +if __name__ == "__main__": # Parse args. args = parse_args() @@ -27,4 +52,4 @@ def parse_args(): raise ValueError(f"Invalid model type: {args.model_type}") importer = PyTorchHyenaImporter(args.model_path, model_config=evo2_config) - importer.apply(args.output_dir) \ No newline at end of file + importer.apply(args.output_dir) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py index fe3ba7d56a..76a20710b4 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py @@ -1,6 +1,21 @@ -""" -Helper utility for converting ZeRO3 and ZeRO2 checkpoints to PyTorch. -""" +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +"""Helper utility for converting ZeRO3 and ZeRO2 checkpoints to PyTorch.""" + import glob import math import os @@ -8,27 +23,40 @@ import time from collections import OrderedDict from dataclasses import dataclass -from typing import Dict, List +from typing import Any, Dict, Iterable, List, Set import psutil import torch from tqdm import tqdm -BUFFER_NAMES = 'buffer_names' -DS_VERSION = 'ds_version' -FP32_FLAT_GROUPS = 'fp32_flat_groups' -FROZEN_PARAM_FRAGMENTS = 'frozen_param_fragments' -FROZEN_PARAM_SHAPES = 'frozen_param_shapes' + +BUFFER_NAMES = "buffer_names" +DS_VERSION = "ds_version" +FP32_FLAT_GROUPS = "fp32_flat_groups" +FROZEN_PARAM_FRAGMENTS = "frozen_param_fragments" +FROZEN_PARAM_SHAPES = "frozen_param_shapes" OPTIMIZER_STATE_DICT = "optimizer_state_dict" -PARAM_SHAPES = 'param_shapes' -PARTITION_COUNT = 'partition_count' +PARAM_SHAPES = "param_shapes" +PARTITION_COUNT = "partition_count" SINGLE_PARTITION_OF_FP32_GROUPS = "single_partition_of_fp32_groups" -ZERO_STAGE = 'zero_stage' +ZERO_STAGE = "zero_stage" EXTRA_STATE = "._extra_state" @dataclass -class zero_model_state: +class ZeroModelState: + """A dataclass representing the state of a ZeRO model. + + Attributes: + buffers (Dict): Buffers in the model state. + extra_states (Dict): Extra states in the model state. + param_shapes (List): Shapes of the parameters. + shared_params (List): Shared parameters in the model state. + ds_version (int): Version of the DeepSpeed checkpoint. + frozen_param_shapes (Dict): Shapes of the frozen parameters. + frozen_param_fragments (Dict): Fragments of the frozen parameters. + """ + buffers: Dict extra_states: Dict param_shapes: List @@ -42,7 +70,16 @@ class zero_model_state: device = torch.device("cpu") -def profile_memory_decorator(func): +def profile_memory_decorator(func: Iterable): + """A decorator to profile memory usage of a function. + + Args: + func (Iterable): The function to be decorated. + + Returns: + wrapper: The decorated function with memory profiling. + """ + def profile_memory(): pid = os.getpid() process = psutil.Process(pid) @@ -57,25 +94,58 @@ def wrapper(*args, **kwargs): return wrapper -def print_pid(msg): +def print_pid(msg: str): + """Prints the process ID along with a message. + + Args: + msg (str): The message to be printed. + """ pid = os.getpid() print(f"{pid=}:{msg}") -def atoi(text): - return int(text) if text.isdigit() else text +def atoi(text: str): + """Converts a string to an integer if it is a digit, otherwise returns the string. + Args: + text (str): The text to be converted. -def natural_keys(text): + Returns: + int or str: The converted integer or the original string. """ - alist.sort(key=natural_keys) sorts in human order - http://nedbatchelder.com/blog/200712/human_sorting.html - (See Toothy's implementation in the comments) + return int(text) if text.isdigit() else text + + +def natural_keys(text: str): + """Sorts a list in human order. + + Args: + text (str): The text to be sorted. + + Returns: + list: The sorted list. + + Note: + alist.sort(key=natural_keys) sorts in human order. + http://nedbatchelder.com/blog/200712/human_sorting.html + (See Toothy's implementation in the comments) """ return [atoi(c) for c in re.split(r"(\d+)", text)] -def get_checkpoint_files(checkpoint_dir, glob_pattern): +def get_checkpoint_files(checkpoint_dir: str, glob_pattern: str): + """Retrieves checkpoint files from a directory based on a glob pattern. + + Args: + checkpoint_dir (str): The directory to search for checkpoint files. + glob_pattern (str): The glob pattern to match files. + + Returns: + list: A sorted list of checkpoint files. + + Raises: + FileNotFoundError: If no files matching the glob pattern are found. + """ # XXX: need to test that this simple glob rule works for multi-node setup too ckpt_files = sorted(glob.glob(os.path.join(checkpoint_dir, glob_pattern)), key=natural_keys) @@ -85,24 +155,84 @@ def get_checkpoint_files(checkpoint_dir, glob_pattern): return ckpt_files -def get_model_files_by_rank(checkpoint_dir, rank): +def get_model_files_by_rank(checkpoint_dir: str, rank: int): + """Retrieves model files for a specific rank from a checkpoint directory. + + Args: + checkpoint_dir (str): The directory to search for model files. + rank (int): The rank to search for. + + Returns: + list: A list of model files for the specified rank. + """ return get_checkpoint_files(checkpoint_dir, f"*mp_rank_{rank:02}_model_states.pt") -def get_optim_files_by_rank(checkpoint_dir, rank): +def get_optim_files_by_rank(checkpoint_dir: str, rank: int): + """Retrieves optimizer files for a specific rank from a checkpoint directory. + + Args: + checkpoint_dir (str): The directory to search for optimizer files. + rank (int): The rank to search for. + + Returns: + list: A list of optimizer files for the specified rank. + """ return get_checkpoint_files(checkpoint_dir, f"*mp_rank_{rank:02}_optim_states.pt") -def create_ds_output_path(rank): +def create_ds_output_path(rank: int): + """Creates the output path for a DeepSpeed checkpoint. + + Args: + rank (int): The rank to create the output path for. + + Returns: + str: The output path for the DeepSpeed checkpoint. + """ return f"mp_rank_{rank:02}_model_states.pt" -def create_zero3_model_state_path(dp_rank, mp_rank): + +def create_zero3_model_state_path(dp_rank: int, mp_rank: int): + """Creates the path for a ZeRO3 model state file. + + Args: + dp_rank (int): The data parallel rank. + mp_rank (int): The model parallel rank. + + Returns: + str: The path for the ZeRO3 model state file. + """ return f"zero_pp_rank_{dp_rank}_mp_rank_{mp_rank:02}_model_states.pt" -def create_zero3_optim_state_path(dp_rank, mp_rank): + +def create_zero3_optim_state_path(dp_rank: int, mp_rank: int): + """Creates the path for a ZeRO3 optimizer state file. + + Args: + dp_rank (int): The data parallel rank. + mp_rank (int): The model parallel rank. + + Returns: + str: The path for the ZeRO3 optimizer state file. + """ return f"bf16_zero_pp_rank_{dp_rank}_mp_rank_{mp_rank:02}_optim_states.pt" -def get_model_state_file(checkpoint_dir, zero_stage): + +def get_model_state_file(checkpoint_dir: str, zero_stage: int): + """Retrieves the model state file from a checkpoint directory based on the ZeRO stage. + + Args: + checkpoint_dir (str): The directory to search for the model state file. + zero_stage (int): The ZeRO stage to search for. + + Returns: + str: The path to the model state file. + + Raises: + FileNotFoundError: If the directory or model state file is not found. + ValueError: If the ZeRO stage is not supported. + """ if not os.path.isdir(checkpoint_dir): raise FileNotFoundError(f"Directory '{checkpoint_dir}' doesn't exist") @@ -111,6 +241,8 @@ def get_model_state_file(checkpoint_dir, zero_stage): file = os.path.join(checkpoint_dir, "mp_rank_00_model_states.pt") elif zero_stage == 3: file = os.path.join(checkpoint_dir, "zero_pp_rank_0_mp_rank_00_model_states.pt") + else: + raise ValueError(f"Unsupported zero stage {zero_stage}. Expected 1, 2, or 3") if not os.path.exists(file): raise FileNotFoundError(f"can't find model states file at '{file}'") @@ -118,8 +250,18 @@ def get_model_state_file(checkpoint_dir, zero_stage): return file -def parse_model_states(files): +def parse_model_states(files: Set[str]): + """Parses model state files and returns a list of ZeroModelState objects. + + Args: + files (Set[str]): A set of file paths to parse. + + Returns: + List[ZeroModelState]: A list of parsed ZeroModelState objects. + Raises: + ValueError: If a file is not a model state checkpoint. + """ zero_model_states = [] for file in files: state_dict = torch.load(file, map_location=device) @@ -156,7 +298,7 @@ def parse_model_states(files): frozen_param_fragments = state_dict.get(FROZEN_PARAM_FRAGMENTS, None) - z_model_state = zero_model_state( + z_model_state = ZeroModelState( buffers=buffers, extra_states=extra_states, param_shapes=param_shapes, @@ -170,7 +312,19 @@ def parse_model_states(files): return zero_model_states -def parse_optim_states(files, ds_checkpoint_dir): +def parse_optim_states(files: Set[str], ds_checkpoint_dir: str): + """Parses optimizer state files and returns the ZeRO stage, world size, and fp32 flat groups. + + Args: + files (Set[str]): A set of file paths to parse. + ds_checkpoint_dir (str): The directory containing the DeepSpeed checkpoint. + + Returns: + tuple: A tuple containing the ZeRO stage, world size, and fp32 flat groups. + + Raises: + ValueError: If a file is not a ZeRO checkpoint or if the number of files does not match the expected world size. + """ total_files = len(files) state_dicts = [] for f in files: @@ -185,7 +339,7 @@ def parse_optim_states(files, ds_checkpoint_dir): } state_dicts.append(state_dict) - if not ZERO_STAGE in state_dicts[0][OPTIMIZER_STATE_DICT]: + if ZERO_STAGE not in state_dicts[0][OPTIMIZER_STATE_DICT]: raise ValueError(f"{files[0]} is not a zero checkpoint") zero_stage = state_dicts[0][OPTIMIZER_STATE_DICT][ZERO_STAGE] world_size = state_dicts[0][OPTIMIZER_STATE_DICT][PARTITION_COUNT] @@ -212,9 +366,7 @@ def parse_optim_states(files, ds_checkpoint_dir): raise ValueError(f"unknown zero stage {zero_stage}") if zero_stage <= 2: - fp32_flat_groups = [ - state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key] for i in range(len(state_dicts)) - ] + fp32_flat_groups = [state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key] for i in range(len(state_dicts))] elif zero_stage == 3: # if there is more than one param group, there will be multiple flattened tensors - one # flattened tensor per group - for simplicity merge them into a single tensor @@ -223,22 +375,25 @@ def parse_optim_states(files, ds_checkpoint_dir): # will require matching the sub-lists of param_shapes for each param group flattened tensor fp32_flat_groups = [ - torch.cat(state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key], 0) - for i in range(len(state_dicts)) + torch.cat(state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key], 0) for i in range(len(state_dicts)) ] return zero_stage, world_size, fp32_flat_groups -def _get_fp32_state_dict_from_zero_checkpoint(ds_checkpoint_dir, rank, exclude_frozen_parameters=False): - """ - Returns fp32 state_dict reconstructed from ds checkpoint +def _get_fp32_state_dict_from_zero_checkpoint( + ds_checkpoint_dir: str, rank: int, exclude_frozen_parameters: bool = False +): + """Returns the fp32 state dictionary reconstructed from a ZeRO checkpoint. Args: - - ``ds_checkpoint_dir``: path to the deepspeed checkpoint folder (where the optimizer files are) + ds_checkpoint_dir (str): Path to the DeepSpeed checkpoint folder. + rank (int): The rank to process. + exclude_frozen_parameters (bool): Whether to exclude frozen parameters. + Returns: + OrderedDict: The reconstructed fp32 state dictionary. """ - print_pid(f"Processing zero checkpoint '{ds_checkpoint_dir}'") # optim_files = get_optim_files(ds_checkpoint_dir) @@ -263,7 +418,9 @@ def _get_fp32_state_dict_from_zero_checkpoint(ds_checkpoint_dir, rank, exclude_f zero_stage, world_size, fp32_flat_groups = parse_optim_states(optim_files, ds_checkpoint_dir) assert len(optim_files) == world_size, f"Expected {world_size} optim files, got {len(optim_files)}" if debug: - print_pid(f" -> rank{rank} stage: {zero_stage} {world_size=} {len(fp32_flat_groups)=} {fp32_flat_groups.shape=}") + print_pid( + f" -> rank{rank} stage: {zero_stage} {world_size=} {len(fp32_flat_groups)=} {fp32_flat_groups.shape=}" + ) model_files = get_model_files_by_rank(ds_checkpoint_dir, rank=rank) model_files_check = get_checkpoint_files(ds_checkpoint_dir, f"zero_*_mp_rank_{rank:02d}_model_states.pt") @@ -288,15 +445,33 @@ def _get_fp32_state_dict_from_zero_checkpoint(ds_checkpoint_dir, rank, exclude_f ) -def zero3_partitioned_param_info(unpartitioned_numel, world_size): +def zero3_partitioned_param_info(unpartitioned_numel: int, world_size: int): + """Returns the partitioned and padding number of elements for a parameter. + + Args: + unpartitioned_numel (int): The number of elements in the unpartitioned parameter. + world_size (int): The world size. + + Returns: + tuple: A tuple containing the partitioned number of elements and the padding number of elements. + """ remainder = unpartitioned_numel % world_size padding_numel = (world_size - remainder) if remainder else 0 partitioned_numel = math.ceil(unpartitioned_numel / world_size) return partitioned_numel, padding_numel -def _zero3_merge_frozen_params(state_dict, world_size, zero_model_states): +def _zero3_merge_frozen_params(state_dict: Dict[str, Any], world_size: int, zero_model_states: List[ZeroModelState]): + """Merges frozen parameters into the state dictionary. + + Args: + state_dict (Dict[str, Any]): The state dictionary to update. + world_size (int): The world size. + zero_model_states (List[ZeroModelState]): The list of ZeroModelState objects. + Returns: + None + """ if zero_model_states[0].frozen_param_shapes is None or len(zero_model_states[0].frozen_param_shapes) == 0: return @@ -308,14 +483,13 @@ def _zero3_merge_frozen_params(state_dict, world_size, zero_model_states): frozen_param_shapes = zero_model_states[0].frozen_param_shapes wanted_params = len(frozen_param_shapes) wanted_numel = sum(s.numel() for s in frozen_param_shapes.values()) - avail_numel = ( - sum([p.numel() for p in zero_model_states[0].frozen_param_fragments.values()]) * world_size - ) + avail_numel = sum([p.numel() for p in zero_model_states[0].frozen_param_fragments.values()]) * world_size print_pid(f"Frozen params: Have {avail_numel} numels to process.") print_pid(f"Frozen params: Need {wanted_numel} numels in {wanted_params} params") total_params = 0 total_numel = 0 + partitioned_numel = 0 # TODO(cory) - this is a bug, should be initialized to ? for name, shape in zero_model_states[0].frozen_param_shapes.items(): total_params += partitioned_numel unpartitioned_numel = shape.numel() @@ -324,9 +498,7 @@ def _zero3_merge_frozen_params(state_dict, world_size, zero_model_states): param_frags = tuple(model_state.frozen_param_fragments[name] for model_state in zero_model_states) state_dict[name] = torch.cat(param_frags, 0).narrow(0, 0, unpartitioned_numel).view(shape) - partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info( - unpartitioned_numel, world_size - ) + partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info(unpartitioned_numel, world_size) if debug: print_pid( @@ -337,10 +509,26 @@ def _zero3_merge_frozen_params(state_dict, world_size, zero_model_states): # @profile_memory_decorator -def _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states): +def _zero3_merge_trainable_params( + state_dict: Dict[str, Any], + world_size: int, + fp32_flat_groups: List[torch.Tensor], + zero_model_states: List[ZeroModelState], +): + """Merges trainable parameters into the state dictionary. + + Args: + state_dict (Dict[str, Any]): The state dictionary to update. + world_size (int): The world size. + fp32_flat_groups (List[torch.Tensor]): The list of fp32 flat groups. + zero_model_states (List[ZeroModelState]): The list of ZeroModelState objects. + + Returns: + None + """ if os.environ.get("ZERO3_CONVERSION_DEBUG", "0") == "1": breakpoint() - + param_shapes = zero_model_states[0].param_shapes avail_numel = fp32_flat_groups[0].numel() * world_size # Reconstruction protocol: For zero3 we need to zip the partitions together at boundary of each @@ -368,14 +556,11 @@ def _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero total_params = 0 pid = os.getpid() for name, shape in tqdm(param_shapes.items(), desc=f"{pid=}: Gathering Sharded Weights"): - unpartitioned_numel = shape.numel() total_numel += unpartitioned_numel total_params += 1 # NOTE: partitioned_numel includes padding, padding applies if unpartitioned_numel is not divisible by world_size - partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info( - unpartitioned_numel, world_size - ) + partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info(unpartitioned_numel, world_size) if debug: print_pid( @@ -384,9 +569,7 @@ def _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero # XXX: memory usage doubles here state_dict[name] = ( - torch.cat( - tuple(fp32_flat_groups[i].narrow(0, offset, partitioned_numel) for i in range(world_size)), 0 - ) + torch.cat(tuple(fp32_flat_groups[i].narrow(0, offset, partitioned_numel) for i in range(world_size)), 0) .narrow(0, 0, unpartitioned_numel) .view(shape) ) @@ -402,9 +585,22 @@ def _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero def _get_fp32_state_dict_from_zero3_checkpoint( - world_size, fp32_flat_groups, zero_model_states, exclude_frozen_parameters + world_size: int, + fp32_flat_groups: List[torch.Tensor], + zero_model_states: List[ZeroModelState], + exclude_frozen_parameters: bool, ): + """Returns the fp32 state dictionary reconstructed from a ZeRO3 checkpoint. + Args: + world_size (int): The world size. + fp32_flat_groups (List[torch.Tensor]): The list of fp32 flat groups. + zero_model_states (List[ZeroModelState]): The list of ZeroModelState objects. + exclude_frozen_parameters (bool): Whether to exclude frozen parameters. + + Returns: + OrderedDict: The reconstructed fp32 state dictionary. + """ state_dict = OrderedDict() # buffers @@ -432,7 +628,15 @@ def _get_fp32_state_dict_from_zero3_checkpoint( return state_dict -def get_elapsed(t): +def get_elapsed(t: float): + """Converts elapsed time in seconds to a formatted string. + + Args: + t (float): The elapsed time in seconds. + + Returns: + str: The formatted elapsed time as a string. + """ minutes = t // 60 seconds = t % 60 if minutes > 0: @@ -449,7 +653,15 @@ def process_single_rank( overwrite: bool = False, exclude_frozen_parameters: bool = False, ): + """Processes a single rank to gather and save the state dictionary. + Args: + rank (int): The rank to process. + ds_checkpoint_dir (str): Path to the DeepSpeed checkpoint folder. + output_dir (str): Directory to save the output. + overwrite (bool): Whether to overwrite existing files. Default is False. + exclude_frozen_parameters (bool): Whether to exclude frozen parameters. Default is False. + """ print_pid(f"Gathering rank {rank} state_dict...") start = time.time() diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index f5317e0f61..231bca8516 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -22,6 +22,7 @@ class Evo2BlendedDatasetConfig(BaseModel): """Pydantic model class that specifies indexed datasets, dataset weights, and datasplits assignments for training.""" + dataset_prefix: None | str = None dataset_weight: None | float = None dataset_split: Literal["train", "validation", "test"] @@ -29,6 +30,7 @@ class Evo2BlendedDatasetConfig(BaseModel): class Evo2TaxonomyLineage(BaseModel): """Pydantic model class that defines the source lineage of a DNA sequence.""" + kingdom: None | str = None phylum: None | str = None clazz: None | str = None @@ -40,6 +42,7 @@ class Evo2TaxonomyLineage(BaseModel): class Evo2PreprocessingConfig(BaseModel): """Pydantic model class specifying the configuration schema for a preprocessed IndexedDataset (.bin, .idx).""" + # Paths datapaths: list[Path] = [] output_dir: None | Path = None @@ -92,4 +95,4 @@ class Evo2PreprocessingConfig(BaseModel): # SeqID Sub-String Indexing: "ABC" will have taxonomy data from "A". taxonomy_data: dict[str, Evo2TaxonomyLineage] = {} # Periodicity of injecting phylogenetic lineage tags in the sequence prior to tokenization. - prompt_spacer_length: int = 131072 \ No newline at end of file + prompt_spacer_length: int = 131072 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py index ed6d6862db..12ae84c46a 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py @@ -58,8 +58,9 @@ def load_weights_sharded_inplace_nemo2_to_mcore( distributed_checkpoint_dir, sharded_state_dict=sharded_state_dict ) + @pytest.mark.parametrize("seq_len", [8_192, 16_384]) -def test_golden_values(seq_len:int): +def test_golden_values(seq_len: int): """Step 1: # add local .ssh/*.pub key to eos ~/.ssh/authorized_keys mkdir -p arc_model/checkpoints/ @@ -93,9 +94,7 @@ def test_golden_values(seq_len:int): position_ids = torch.arange(len(input_seq)).unsqueeze(0).to(device) attention_mask = None outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) - gold_standard_no_fp8 = torch.load(gold_standard_no_fp8).to( - device=outputs.device, dtype=outputs.dtype - ) + gold_standard_no_fp8 = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) our_generation_str = "".join( [chr(idx) for idx in outputs.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy().tolist()] ) diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py index d953df92c7..4e4cfdea81 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/datamodule_utils.py @@ -72,6 +72,7 @@ def infer_global_batch_size( accumulate_grad_batches (int): The accumulation of gradient batches. Defaults to 1. tensor_model_parallel_size (int): The tensor model parallel size. Defaults to 1. pipeline_model_parallel_size (int): The pipeline model parallel size. Defaults to 1. + context_model_parallel_size (int): The context model parallel size. Defaults to 1. Returns: int: The global batch size. From 9cacf1b5599f2fc69b0847076d568c595e86f047 Mon Sep 17 00:00:00 2001 From: Jared Wilber Date: Tue, 14 Jan 2025 12:56:28 -0800 Subject: [PATCH 027/140] Add tests for parallel hyena operators used in evo2 --- .../tests/bionemo/test_hyena_operators.py | 153 ++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py new file mode 100644 index 0000000000..c3ef3d5d81 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py @@ -0,0 +1,153 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch +from megatron.core.transformer.transformer_config import TransformerConfig +from nemo.collections.llm.gpt.model.megatron.hyena.hyena_config import HyenaConfig +from nemo.collections.llm.gpt.model.megatron.hyena.hyena_utils import ( + ParallelCausalDepthwiseConv1d, + ParallelHyenaOperator, + ParallelShortHyenaOperator, +) + +from bionemo.testing import megatron_parallel_state_utils + + +@pytest.fixture +def hyena_config() -> HyenaConfig: + return HyenaConfig() + + +@pytest.fixture +def transformer_config() -> TransformerConfig: + return TransformerConfig(num_layers=2, hidden_size=864, num_attention_heads=1) + + +class TestParallelHyenaOperator: + @pytest.fixture + def operator(self, transformer_config: TransformerConfig, hyena_config: HyenaConfig) -> ParallelHyenaOperator: + with megatron_parallel_state_utils.distributed_model_parallel_state(): + yield ParallelHyenaOperator( + hidden_size=transformer_config.hidden_size, + transformer_config=transformer_config, + hyena_config=hyena_config, + max_sequence_length=1024, + operator_type="hyena_medium_conv", + init_method="small_init", + ) + + def test_initialization(self, operator: ParallelHyenaOperator): + assert operator.hidden_size == 864 + assert operator.operator_type == "hyena_medium_conv" + assert isinstance(operator.conv_bias, torch.nn.Parameter) + num_weights = sum([p.numel() for p in operator.parameters()]) + assert num_weights == 111456 + + def test_gpu_forward(self, operator: ParallelHyenaOperator): + device = torch.device("cuda") + operator = operator.to(device) + batch_size = 2 + seq_len = operator.L # operator.L maps to max_sequence_length + g = operator.num_groups + dg = operator.group_dim + + x1 = torch.ones((batch_size, seq_len, g, dg), device=device) + x2 = torch.ones((batch_size, seq_len, g, dg), device=device) + v = torch.ones((batch_size, seq_len, g, dg), device=device) + + output = operator(x1, x2, v) + assert output.shape[0] == batch_size + assert output.shape[1] == seq_len + assert output.shape[2] == operator.hidden_size + + +class TestParallelShortHyenaOperator: + @pytest.fixture + def operator(self, transformer_config: TransformerConfig, hyena_config: HyenaConfig) -> ParallelShortHyenaOperator: + with megatron_parallel_state_utils.distributed_model_parallel_state(): + yield ParallelShortHyenaOperator( + hidden_size=transformer_config.hidden_size, + transformer_config=transformer_config, + hyena_config=hyena_config, + init_method="small_init", + short_conv_class=ParallelCausalDepthwiseConv1d, + use_fast_causal_conv=False, + is_mlp=False, + local_init=False, + ) + + def test_initialization(self, operator: ParallelShortHyenaOperator): + assert operator.hidden_size == 864 + assert operator.pregate == True + assert operator.postgate == True + num_weights = sum([p.numel() for p in operator.parameters()]) + assert num_weights == 6048 + + def test_gpu_forward(self, operator: ParallelShortHyenaOperator): + device = torch.device("cuda") + operator = operator.to(device) + batch_size = 2 + seq_len = 1024 + g = operator.num_groups + dg = operator.group_dim + + x1 = torch.ones((batch_size, seq_len, g, dg), device=device) + x2 = torch.ones((batch_size, seq_len, g, dg), device=device) + v = torch.ones((batch_size, seq_len, g, dg), device=device) + + output = operator(x1, x2, v) + assert output.shape[0] == batch_size + assert output.shape[1] == seq_len + assert output.shape[2] == operator.hidden_size + + +class TestParallelCausalDepthwiseConv1d: + @pytest.fixture + def operator( + self, transformer_config: TransformerConfig, hyena_config: HyenaConfig + ) -> ParallelCausalDepthwiseConv1d: + with megatron_parallel_state_utils.distributed_model_parallel_state(): + yield ParallelCausalDepthwiseConv1d( + d_model=transformer_config.hidden_size, + transformer_config=transformer_config, + hyena_config=hyena_config, + kernel_size=hyena_config.short_conv_L, + init_method=transformer_config.init_method, + bias=hyena_config.conv_proj_bias, + use_fast_causal_conv=hyena_config.fast_conv_proj, + ) + + def test_initialization(self, operator: ParallelCausalDepthwiseConv1d): + assert operator.d_model == 864 + assert operator.kernel_size == 3 + assert operator.use_bias == True + num_weights = sum([p.numel() for p in operator.parameters()]) + assert num_weights == 2592 + + def test_gpu_forward(self, operator: ParallelCausalDepthwiseConv1d): + device = torch.device("cuda") + operator = operator.to(device) + batch_size = 2 + d_model = operator.d_model + seq_len = 1024 + + x1 = torch.ones((batch_size, d_model, seq_len), device=device) + output = operator(x1, False) + + assert output.shape[0] == batch_size + assert output.shape[1] == d_model + assert output.shape[2] == seq_len From 9ac11ebf4d4dfde253316ef258df5c5ed3c9ae59 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Tue, 14 Jan 2025 13:27:35 -0800 Subject: [PATCH 028/140] Rebase on OSS. --- .devcontainer/devcontainer.json | 2 +- .github/pull_request_template.md | 59 +- .github/workflows/pr-labels.yml | 48 + .github/workflows/pre-commit.yml | 26 - .github/workflows/unit-tests.yml | 125 ++ .gitignore | 1 - Dockerfile | 99 +- Dockerfile.arm | 100 +- README.md | 442 +---- arm_build/decord_ffmpeg6_fix.patch | 73 + ci/benchmarks/partial-conv/esm2_pretrain.yaml | 54 + ci/benchmarks/perf/esm2_pretrain.yaml | 65 + ci/scripts/run_pytest.sh | 106 +- .../images/esm2/esm2_pretrain_convergence.svg | 1522 +++++++++++++++++ docs/docs/docs.todo | 0 docs/docs/models/ESM-2/SUMMARY.md | 2 + docs/docs/models/{esm2.md => ESM-2/index.md} | 5 +- docs/docs/models/ESM-2/pre-training.md | 155 ++ .../background/megatron_datasets.md | 6 - .../jupyter-notebooks.ipynb | 13 +- .../user-guide/contributing/contributing.md | 192 ++- .../geneformer-celltype-classification.ipynb | 1093 ++++++++---- docs/docs/user-guide/examples/conftest.py | 23 + .../user-guide/getting-started/SUMMARY.md | 1 + .../user-guide/getting-started/development.md | 3 + docs/docs/user-guide/getting-started/index.md | 2 +- .../getting-started/training-models.md | 215 +++ docs/mkdocs.yml | 2 + docs/requirements.txt | 1 + internal/scripts/README.md | 43 + requirements-test.txt | 5 + .../src/bionemo/core/data/resources/esm2.yaml | 27 + .../src/bionemo/core/data/resources/scdl.yaml | 8 + .../core/data/resources/single_cell.yaml | 8 + .../core/data/test_load_notebook.ipynb | 42 +- .../src/bionemo/esm2/model/attention.py | 365 ---- .../finetune/finetune_token_classifier.py | 8 +- .../src/bionemo/esm2/model/model.py | 4 +- .../src/bionemo/esm2/run/config_models.py | 3 - .../bionemo-esm2/src/bionemo/esm2/run/main.py | 21 +- .../src/bionemo/esm2/scripts/train_esm2.py | 94 +- .../esm2/model/finetune/test_finetune.py | 74 +- .../bionemo/esm2/model/test_attention.py | 120 -- .../bionemo/esm2/scripts/test_infer_esm2.py | 11 +- .../esm2/scripts/test_pydantic_train.py | 2 + .../bionemo/esm2/scripts/test_train_esm2.py | 26 +- .../src/bionemo/evo2/run/train.py | 31 +- sub-packages/bionemo-example_model/README.md | 18 +- .../training_scripts/pretrain_mnist.py | 2 +- sub-packages/bionemo-fw/pyproject.toml | 1 - sub-packages/bionemo-geneformer/README.md | 2 +- .../bionemo-geneformer/pyproject.toml | 1 - .../scripts/geneformer_mlm_loss_eval.py | 9 + .../geneformer/data/singlecell/datamodule.py | 6 + .../geneformer/data/singlecell/dataset.py | 143 +- .../model/finetune_token_regressor.py | 8 +- .../bionemo/geneformer/run/config_models.py | 2 +- .../src/bionemo/geneformer/run/main.py | 21 +- .../geneformer/scripts/infer_geneformer.py | 13 +- .../bionemo/geneformer/scripts/sc_memmap.py | 324 ---- .../geneformer/scripts/train_geneformer.py | 49 +- .../tests/bionemo/geneformer/conftest.py | 51 + .../geneformer/scripts/test_pydantic_train.py | 28 +- .../scripts/test_train_geneformer.py | 105 +- .../tests/bionemo/geneformer/test_dataset.py | 583 +++++++ .../tests/bionemo/geneformer/test_model.py | 6 +- .../bionemo/geneformer/test_stop_and_go.py | 2 +- .../src/bionemo/llm/data/collate.py | 5 +- .../src/bionemo/llm/run/config_models.py | 10 + .../bionemo-llm/src/bionemo/llm/train.py | 41 +- .../src/bionemo/llm/utils/logger_utils.py | 6 +- sub-packages/bionemo-noodles/rust/src/lib.rs | 1 + .../src/bionemo/noodles/nvfaidx.py | 35 +- .../tests/bionemo/noodles/data/dupes.fasta | 17 + .../tests/bionemo/noodles/test_nvfaidx.py | 15 + .../tests/bionemo/scdl/conftest.py | 3 +- tach.toml | 1 + 77 files changed, 4719 insertions(+), 2116 deletions(-) create mode 100644 .github/workflows/pr-labels.yml delete mode 100644 .github/workflows/pre-commit.yml create mode 100644 .github/workflows/unit-tests.yml create mode 100644 arm_build/decord_ffmpeg6_fix.patch create mode 100644 ci/benchmarks/partial-conv/esm2_pretrain.yaml create mode 100644 ci/benchmarks/perf/esm2_pretrain.yaml create mode 100644 docs/docs/assets/images/esm2/esm2_pretrain_convergence.svg delete mode 100644 docs/docs/docs.todo create mode 100644 docs/docs/models/ESM-2/SUMMARY.md rename docs/docs/models/{esm2.md => ESM-2/index.md} (99%) create mode 100644 docs/docs/models/ESM-2/pre-training.md create mode 100644 docs/docs/user-guide/examples/conftest.py create mode 100644 docs/docs/user-guide/getting-started/training-models.md create mode 100644 internal/scripts/README.md delete mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/attention.py delete mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_attention.py delete mode 100644 sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/sc_memmap.py create mode 100644 sub-packages/bionemo-geneformer/tests/bionemo/geneformer/conftest.py create mode 100644 sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_dataset.py create mode 100644 sub-packages/bionemo-noodles/tests/bionemo/noodles/data/dupes.fasta diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index b8896f0f76..c32a3f63e8 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -24,7 +24,7 @@ "NUMBA_CACHE_DIR": "/tmp/" }, "postCreateCommand": "./.devcontainer/postCreateCommand.sh", - "remoteUser": "bionemo", + "remoteUser": "ubuntu", "customizations": { "vscode": { "extensions": [ diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 9222e01e6a..5b31e2e1da 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,45 +1,34 @@ -(**NOTE:** _**delete** these instructional lines as you fill-out this PR template_) +### Description + -(**NOTE:** _template is designed to be filled-in and used as the **squashed commit message for the entire PR**. _Italicized text_ is intended to be deleted as you fill in this template. Use the text between the `---`) +### Type of changes + ---- +- [ ] Bug fix (non-breaking change which fixes an issue) +- [ ] New feature (non-breaking change which adds functionality) +- [ ] Refactor +- [ ] Documentation update +- [ ] Other (please describe): -_High level summary of changes. Try to keep this as short and informative as possible: less is more._ +### CI Pipeline Configuration +Configure CI behavior by checking relevant boxes below. This will automatically apply labels. -_Describe your changes. You can be more detailed and descriptive here. If it is a code change, Be sure to answer:_ - - _What is changing?_ - - _What is the new or fixed functionality?_ - - _Why or when would someone want to use these changes?_ - - _How can someone use these changes?_ ---- +- [ ] [SKIP_CI](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#skip_ci) - Skip all continuous integration tests +- [ ] [INCLUDE_NOTEBOOKS_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_notebooks_tests) - Execute notebook validation tests in pytest -## Summary -_High level summary of changes. Try to keep this as short and informative as possible: less is more._ +> [!NOTE] +> By default, the notebooks validation tests are skipped unless explicitly enabled. -## Details -_Describe your changes. You can be more detailed and descriptive here._ - -## Usage -_How does a user interact with the changed code?_ +### Usage + ```python -python -m your.new.module -and -all -options -``` - -## Testing -_How do you prove that your code behaves the way you claim?_ - -Tests for these changes can be run via: -```shell -pytest -v tests/your/new/or/existing/test_functions.py::test_function +TODO: Add code snippet ``` +### Pre-submit Checklist + -(**NOTE:** _also **delete** this checklist as you fill-out this PR template_) - -**Most of the changes** to files with extensions `*.py`, `*.yaml`, `*.yml`, `Dockerfile*` or `requirements.txt` **DO REQUIRE both `pytest-` and `jet-` CI stages**. - -- [ ] Did you review the [Before your PR is "Ready for review" section](https://github.com/NVIDIA/bionemo-framework/-/blob/dev/CONTRIBUTING.md?ref_type=heads#before-pr-ready) before asking for review? -- [ ] Did you make sure your changes have tests? Did you test your changes locally? -- [ ] Can you add [the `SKIP_CI` label](https://github.com/NVIDIA/bionemo-framework/-/blob/dev/CONTRIBUTING.md?ref_type=heads#skip-ci) to your PR? -- [ ] Can you add [the `PYTEST_NOT_REQUIRED` label](https://github.com/NVIDIA/bionemo-framework/-/blob/dev/CONTRIBUTING.md?ref_type=heads#skip-pytest) to your PR? -- [ ] Can you add [the `JET_NOT_REQUIRED` label](https://github.com/NVIDIA/bionemo-framework/-/blob/dev/CONTRIBUTING.md?ref_type=heads#skip-jet) to your PR? + - [ ] I have tested these changes locally + - [ ] I have updated the documentation accordingly + - [ ] I have added/updated tests as needed + - [ ] All existing tests pass successfully diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml new file mode 100644 index 0000000000..f95d667a30 --- /dev/null +++ b/.github/workflows/pr-labels.yml @@ -0,0 +1,48 @@ +name: PR Label Management + +on: + pull_request: + types: [opened, edited, synchronize] + +jobs: + manage-labels: + runs-on: ubuntu-latest + permissions: + pull-requests: write + + steps: + - name: Check PR body and manage labels + uses: actions/github-script@v6 + with: + script: | + const prBody = context.payload.pull_request.body; + + const labelChecks = { + 'SKIP_CI': /\[x\]\s*\[SKIP_CI\]/i, + 'INCLUDE_NOTEBOOKS_TESTS': /\[x\]\s*\[INCLUDE_NOTEBOOKS_TESTS\]/i + }; + + const currentLabels = new Set( + context.payload.pull_request.labels.map(label => label.name) + ); + + for (const [label, pattern] of Object.entries(labelChecks)) { + const shouldHaveLabel = pattern.test(prBody); + const hasLabel = currentLabels.has(label); + + if (shouldHaveLabel && !hasLabel) { + await github.rest.issues.addLabels({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.payload.pull_request.number, + labels: [label] + }); + } else if (!shouldHaveLabel && hasLabel) { + await github.rest.issues.removeLabel({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: context.payload.pull_request.number, + name: label + }); + } + } diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml deleted file mode 100644 index 3a94eee0c1..0000000000 --- a/.github/workflows/pre-commit.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: pre-commit - -on: - pull_request: - branches: [main] - push: - branches: [main] - merge_group: - types: [checks_requested] -jobs: - pre-commit: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - submodules: 'recursive' - - uses: actions/setup-python@v5 - with: - python-version: '3.10' - cache: 'pip' - - run: pip install -r requirements-dev.txt - - run: ./ci/scripts/static_checks.sh - - uses: trufflesecurity/trufflehog@main - with: - extra_args: --only-verified diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml new file mode 100644 index 0000000000..7ff7533dcf --- /dev/null +++ b/.github/workflows/unit-tests.yml @@ -0,0 +1,125 @@ +name: "[Optional] BioNemo Image Build and Unit Tests" + +on: + pull_request: + branches: [main] + push: + branches: [main] + merge_group: + types: [checks_requested] + +defaults: + run: + shell: bash -x -e -u -o pipefail {0} + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + pre-commit: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + submodules: "recursive" + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: "pip" + - run: pip install -r requirements-dev.txt + - run: ./ci/scripts/static_checks.sh + - uses: trufflesecurity/trufflehog@main + with: + extra_args: --only-verified + + build-bionemo-image: + needs: pre-commit + runs-on: self-hosted-azure-cpu + if: ${{ !contains(github.event.pull_request.labels.*.name, 'SKIP_CI') }} + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + path: ${{ github.run_id }} + submodules: "recursive" + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Docker Metadata + id: metadata + uses: docker/metadata-action@v5 + with: + images: nemoci.azurecr.io/bionemo + labels: nemo.library=bionemo + tags: | + type=schedule + type=ref,event=branch + type=ref,event=tag + type=ref,event=pr + type=raw,value=${{ github.run_id }} + + - uses: int128/docker-build-cache-config-action@v1 + id: cache + with: + image: nemoci.azurecr.io/bionemo/build-cache + pull-request-cache: true + + - name: Build and push + uses: docker/build-push-action@v5 + with: + file: ${{ github.run_id }}/Dockerfile + context: ${{ github.run_id }}/ + push: true + tags: ${{ steps.metadata.outputs.tags }} + labels: ${{ steps.metadata.outputs.labels }} + cache-from: ${{ steps.cache.outputs.cache-from }} + cache-to: ${{ steps.cache.outputs.cache-to }} + + run-tests: + needs: build-bionemo-image + runs-on: self-hosted-nemo-gpus-1 + defaults: + run: + working-directory: ./${{ github.run_id }} + container: + image: nemoci.azurecr.io/bionemo:${{ github.run_id }} + options: --gpus all + volumes: + - /home/azureuser/actions-runner-bionemo/cache:/github/home/.cache + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + path: ${{ github.run_id }} + + - name: Run tests + env: + BIONEMO_DATA_SOURCE: ngc + run: ./ci/scripts/run_pytest.sh --no-nbval --skip-slow + + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v5 + with: + token: ${{ secrets.CODECOV_TOKEN }} + working-directory: ${{ github.run_id }} + + - name: Upload test results to Codecov + if: ${{ !cancelled() }} + uses: codecov/test-results-action@v1 + with: + token: ${{ secrets.CODECOV_TOKEN }} + working-directory: ${{ github.run_id }} + + clean-up: + needs: run-tests + runs-on: self-hosted-nemo-gpus-1 + if: ${{ always() }} + steps: + - name: clean up image + run: docker rmi nemoci.azurecr.io/bionemo:${{ github.run_id }} + +# TODO: exclude tests from base image; run tests from github workspace mounted in the image. +# TODO: figure out way of cleaning up working directory (requires sudo or for us to fix file ownership from release container) diff --git a/.gitignore b/.gitignore index 5b7a216c53..5fe5a0ab48 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,6 @@ docs/site/ *.nemo protein/ -singlecell/ results/ # Local configs diff --git a/Dockerfile b/Dockerfile index 1ddee4412a..479448aba3 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,12 +1,18 @@ # Base image with apex and transformer engine, but without NeMo or Megatron-LM. -ARG BASE_IMAGE=nvcr.io/nvidia/pytorch:24.10-py3 +# Note that the core NeMo docker container is defined here: +# https://gitlab-master.nvidia.com/dl/JoC/nemo-ci/-/blob/main/llm_train/Dockerfile.train +# with settings that get defined/injected from this config: +# https://gitlab-master.nvidia.com/dl/JoC/nemo-ci/-/blob/main/.gitlab-ci.yml +# We should keep versions in our container up to date to ensure that we get the latest tested perf improvements and +# training loss curves from NeMo. +ARG BASE_IMAGE=nvcr.io/nvidia/pytorch:24.12-py3 -FROM rust:1.82.0 as rust-env +FROM rust:1.82.0 AS rust-env RUN rustup set profile minimal && \ - rustup install 1.82.0 && \ - rustup target add x86_64-unknown-linux-gnu && \ - rustup default 1.82.0 + rustup install 1.82.0 && \ + rustup target add x86_64-unknown-linux-gnu && \ + rustup default 1.82.0 FROM ${BASE_IMAGE} AS bionemo2-base @@ -59,9 +65,10 @@ RUN pip install hatchling # needed to install nemo-run ARG NEMU_RUN_TAG=34259bd3e752fef94045a9a019e4aaf62bd11ce2 RUN pip install nemo_run@git+https://github.com/NVIDIA/NeMo-Run.git@${NEMU_RUN_TAG} -# Used for straggler detection in large runs. -ARG RESIL_COMMIT=97aad77609d2e25ed38ac5c99f0c13f93c48464e -RUN pip install --no-cache-dir "git+https://github.com/NVIDIA/nvidia-resiliency-ext.git@${RESIL_COMMIT}" +# TODO(@cye): This does not install corrently on PyTorch 24.12. +# # Used for straggler detection in large runs. +# ARG RESIL_COMMIT="97aad77609d2e25ed38ac5c99f0c13f93c48464e" +# RUN pip install --no-cache-dir "git+https://github.com/NVIDIA/nvidia-resiliency-ext.git@${RESIL_COMMIT}" RUN mkdir -p /workspace/bionemo2/ @@ -71,28 +78,44 @@ RUN rm -rf /build # Addressing Security Scan Vulnerabilities RUN rm -rf /opt/pytorch/pytorch/third_party/onnx -RUN apt-get update && \ - apt-get install -y openssh-client=1:8.9p1-3ubuntu0.10 && \ - rm -rf /var/lib/apt/lists/* -RUN apt purge -y libslurm37 libpmi2-0 && \ - apt autoremove -y # Use UV to install python packages from the workspace. This just installs packages into the system's python -# environment, and does not use the current uv.lock file. +# environment, and does not use the current uv.lock file. Note that with python 3.12, we now need to set +# UV_BREAK_SYSTEM_PACKAGES, since the pytorch base image has made the decision not to use a virtual environment and UV +# does not respect the PIP_BREAK_SYSTEM_PACKAGES environment variable set in the base dockerfile. COPY --from=ghcr.io/astral-sh/uv:0.4.25 /uv /usr/local/bin/uv ENV UV_LINK_MODE=copy \ UV_COMPILE_BYTECODE=1 \ UV_PYTHON_DOWNLOADS=never \ UV_SYSTEM_PYTHON=true \ - UV_NO_CACHE=1 + UV_NO_CACHE=1 \ + UV_BREAK_SYSTEM_PACKAGES=1 -# Install the bionemo-geomtric requirements ahead of copying over the rest of the repo, so that we can cache their +# Install the bionemo-geometric requirements ahead of copying over the rest of the repo, so that we can cache their # installation. These involve building some torch extensions, so they can take a while to install. RUN --mount=type=bind,source=./sub-packages/bionemo-geometric/requirements.txt,target=/requirements-pyg.txt \ - --mount=type=cache,id=uv-cache,target=/root/.cache,sharing=locked \ uv pip install --no-build-isolation -r /requirements-pyg.txt +COPY --from=rust-env /usr/local/cargo /usr/local/cargo +COPY --from=rust-env /usr/local/rustup /usr/local/rustup + +ENV PATH="/usr/local/cargo/bin:/usr/local/rustup/bin:${PATH}" +ENV RUSTUP_HOME="/usr/local/rustup" + +RUN < /etc/sudoers.d/$USERNAME \ +# Use a non-root user to use inside a devcontainer (with ubuntu 23 and later, we can use the default ubuntu user). +ARG USERNAME=ubuntu +RUN echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \ && chmod 0440 /etc/sudoers.d/$USERNAME # Here we delete the dist-packages directory from the pytorch base image, and copy over the dist-packages directory from # the build image. This ensures we have all the necessary dependencies installed (megatron, nemo, etc.). RUN < about getting an enterprise license for improved +expert-level support. -`bionemo2` code is partitioned into independently installable namespace packages. -These are located under the `sub-packages/` directory. Please refer to [PEP 420 – Implicit Namespace Packages](https://peps.python.org/pep-0420/) for details. +The `bionemo-framework` is partitioned into independently installable namespace packages. These are located under the +`sub-packages/` directory. Please refer to [PEP 420 – Implicit Namespace Packages](https://peps.python.org/pep-0420/) +for details. -## Documentation and Release Information +## Documentation -The latest released container for the BioNeMo Framework is available for download through [NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/bionemo-framework). Comprehensive documentation, including user guides, API references, and troubleshooting information, can be found in our official documentation set at: +Comprehensive documentation, +including user guides, API references, and troubleshooting information, can be found in our official documentation at + -https://docs.nvidia.com/bionemo-framework/latest/ +For those interested in exploring the latest developments and features not yet included in the released container, we +also maintain an up-to-date documentation set that reflects the current state of the `main` branch. This in-progress +documentation can be accessed at -For those interested in exploring the latest developments and features not yet included in the released container, we also maintain an up-to-date documentation set that reflects the current state of the `main` branch. This in-progress documentation can be accessed at: +Please note that while this documentation is generally accurate and helpful, it may contain references to features or +APIs not yet stabilized or released. As always, we appreciate feedback on our documentation and strive to continually +improve its quality. -https://nvidia.github.io/bionemo-framework/ +## Using the BioNeMo Framework -Please note that while this documentation is generally accurate and helpful, it may contain references to features or APIs not yet stabilized or released. As always, we appreciate feedback on our documentation and strive to continually improve its quality. +Full documentation on using the BioNeMo Framework is provided in our documentation: +. To facilitate the process of linking against optimized +versions of third-party dependencies, BioNeMo is primarily distributed as a containerized library. The latest released +container for the BioNeMo Framework is available for download through +[NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/bionemo-framework). Launching a pre-built +container can be accomplished through the `brev.dev` link at the top of the page, or by running -## Developing and Developer Certificate of Origin (DCO) -By contributing to this repo you acknowledge that either this is your original work, or have the right to submit the work -under our license, which as of this writing is Apache v2. See [license](LICENSE/license.txt) for the current license, -and the [contributing document](CONTRIBUTING.md) for more information. - -If you find yourself having made a number of commits in a PR, and need to sign them all, a useful tool is the following: -1. Find your first unsigned commit, say it is `mYcmtShrtHash`. -2. Run `git rebase --signoff mYcmtShrtHash^` to sign that commit and all future commits (in your branch please). -3. Push the updated commits `git push -f`. +```bash +docker run --rm -it \ + --gpus=all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \ + nvcr.io/nvidia/clara/bionemo-framework:main--nightly \ + /bin/bash +``` +### Setting up a local development environment -## Initializing 3rd-party dependencies as git submodules +#### Initializing 3rd-party dependencies as git submodules -The NeMo and Megatron-LM dependencies are vendored in the bionemo-2 repository workspace as git -submodules for development purposes. The pinned commits for these submodules represent the "last-known-good" versions of these packages that are -confirmed to be working with bionemo2 (and those that are tested in CI). +The NeMo and Megatron-LM dependencies are vendored in the bionemo-2 repository workspace as git submodules for +development purposes. The pinned commits for these submodules represent the "last-known-good" versions of these packages +that are confirmed to be working with bionemo2 (and those that are tested in CI). To initialize these sub-modules when cloning the repo, add the `--recursive` flag to the git clone command: @@ -51,380 +70,35 @@ Different branches of the repo can have different pinned versions of these third update submodules after switching branches or pulling recent changes! To configure git to automatically update submodules when switching branches, run + ```bash git config submodule.recurse true ``` + **NOTE**: this setting will not download **new** or remove **old** submodules with the branch's changes. You will have to run the full `git submodule update --init --recursive` command in these situations. -## First Time Setup -After cloning the repository, you need to run the setup script **first**: -```bash -./internal/scripts/setup_env_file.sh -``` -This will return an exit code of 1 on a first time run. - -## Release Image Building -To build the release image, run the following script: -```bash -DOCKER_BUILDKIT=1 ./ci/scripts/build_docker_image.sh \ - -regular-docker-builder \ - -image-name "nvcr.io/nvidian/cvai_bnmo_trng/bionemo:bionemo2-$(git rev-parse HEAD)" -``` - -## Development Image Building -To build the development image, run the following script: -```bash -./internal/scripts/build_dev_image.sh -``` - -## Interactive Shell in Development Image -After building the development image, you can start a container from it and open a bash shell in it by executing: -```bash -./internal/scripts/run_dev.sh -``` - -## Downloading artifacts (For NVIDIA Employees) -Set the AWS access info in environment prior to running the dev-container launch script: - -```bash -AWS_ACCESS_KEY_ID="team-bionemo" -AWS_SECRET_ACCESS_KEY=$(grep aws_secret_access_key ~/.aws/config | cut -d' ' -f 3) -AWS_REGION="us-east-1" -AWS_ENDPOINT_URL="https://pbss.s8k.io" -``` - -Running tests downloads the test data to a cache location when first invoked. - -For more information on adding new test artifacts, see the documentation in -[`bionemo.core.data.load`](sub-packages/bionemo-testing/src/bionemo/testing/data/README.md). - -## Updating pinned versions of NeMo / Megatron-LM - -Pinned commits are bumped by depend-a-bot. To update the pinned commits of NeMo or Megatron-LM manually, checkout the -commit of interest in the submodule folder, and then commit the result in the top-level bionemo repository. - -```bash -cd 3rdparty/NeMo/ -git fetch -git checkout -cd ../.. -git add '3rdparty/NeMo/' -git commit -m "updating NeMo commit" -``` - -## Testing Locally -Inside the development container, run `./ci/scripts/static_checks.sh` to validate that code changes will pass the code -formatting and license checks run during CI. In addition, run the longer `./ci/scripts/pr_test.sh` script to run unit -tests for all sub-packages. - - -## Publishing Packages - -### Add a new git tag - -We use [setuptools-scm](https://setuptools-scm.readthedocs.io/en/latest/) to dynamically determine the library version -from git tags. As an example: - -```bash -$ git tag 2.0.0a1 -$ docker build . -t bionemo-uv -$ docker run --rm -it bionemo-uv:latest python -c "from importlib.metadata import version; print(version('bionemo.esm2'))" -2.0.0a1 -``` - -Bionemo packages follow [semantic versioning 2.0](https://semver.org/) rules: API-breaking changes are `MAJOR`, new -features are `MINOR`, and bug-fixes and refactors are `PATCH` in `MAJOR.MINOR.PATCH` version string format. - -If subsequent commits are added after a git tag, the version string will reflect the additional commits (e.g. -`2.0.0a1.post1`). **NOTE**: we don't consider uncommitted changes in determining the version string. - -### Building a python wheel - -An overview for publishing packages with `uv` can be found here: https://docs.astral.sh/uv/guides/publish/ - -Build the bionemo sub-package project by executing the following for the desired package: -```shell -uv build sub-packages/bionemo-core/ -``` - -Produce a wheel file for the sub-package's code and its dependencies: -```shell -$ ls sub-packages/bionemo-core/dist/ -bionemo_core-2.0.0a1.post0-py3-none-any.whl bionemo_core-2.0.0a1.post0.tar.gz -``` - -### Uploading a python wheel - -After building, the wheel file may be uploaded to PyPI (or a compatible package registry) by executing -`uvx twine upload sub-packages/bionemo-core/dist/*`. - -### All steps together - -Assumes we're building a wheel for `bionemo-core`. -```bash -git tag MY-VERSION-TAG -uv build /sub-packages/bionemo-core -TWINE_PASSWORD="" TWINE_USERNAME="" uvx twine upload /sub-packages/bionemo-core/dist/* -``` -## Pydantic Configuration - -BioNeMo 2 provides two entrypoints for models with both argparse and pydantic. Both documented in the `Models` section below. -Pydantic based configuration is designed to accept a configuration yaml file as input, along with context specific arguments (e.g., should we resume from existing checkpoints?). These YAML configs go through a Pydantic Validator, in this case referred to as `MainConfig`. This Config is composed of several other Pydantic models, see the class definition for details. To pre-populate a config with reasonable defaults for various standard models, we provide 'recipes.' These are simple methods that instantiate the config object and then serialize it to a YAML configuration file. From this file, you may either submit it directly, or modify the various parameters to meet your usecase. For example, Weights and biases, devices, precision, and dataset options are all extremely useful to modify. Then, you would submit this config for training. - -These two workflows are packaged as executables when esm2 or geneformer are installed with pip. These commands will appear as: - -```bash -bionemo-geneformer-recipe -bionemo-esm2-recipe -bionemo-geneformer-train -bionemo-esm2-train -``` - -## Models -### ESM-2 -#### Running -First off, we have a utility function for downloading full/test data and model checkpoints called `download_bionemo_data` that our following examples currently use. This will download the object if it is not already on your local system, and then return the path either way. For example if you run this twice in a row, you should expect the second time you run it to return the path almost instantly. - -**NOTE**: NVIDIA employees should use `pbss` rather than `ngc` for the data source. - -```bash -export MY_DATA_SOURCE="ngc" -``` -or for NVIDIA internal employees with new data etc: -```bash -export MY_DATA_SOURCE="pbss" -``` - -```bash -# The fastest transformer engine environment variables in testing were the following two -TEST_DATA_DIR=$(download_bionemo_data esm2/testdata_esm2_pretrain:2.0 --source $MY_DATA_SOURCE); \ -ESM2_650M_CKPT=$(download_bionemo_data esm2/650m:2.0 --source $MY_DATA_SOURCE); \ - -train_esm2 \ - --train-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/train_clusters_sanity.parquet \ - --train-database-path ${TEST_DATA_DIR}/2024_03_sanity/train_sanity.db \ - --valid-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/valid_clusters.parquet \ - --valid-database-path ${TEST_DATA_DIR}/2024_03_sanity/validation.db \ - --result-dir ./results \ - --experiment-name test_experiment \ - --num-gpus 1 \ - --num-nodes 1 \ - --val-check-interval 10 \ - --num-dataset-workers 1 \ - --num-steps 10 \ - --max-seq-length 1024 \ - --limit-val-batches 2 \ - --micro-batch-size 2 \ - --restore-from-checkpoint-path ${ESM2_650M_CKPT} -``` - -##### Running with Pydantic configs +#### Building the bionemo-framework docker image -Alternatively, we provide a validated and serialized configuration file entrypoint for executing the same workflow. These can be generated using the `bionemo-esm2-recipe` entrypoints. Recipes -are available for 8m, 650m, and 3b ESM2 models. You may select which preset config to use by setting the `--recipe` parameter. -The output is then a serialized configuration file that may be used in the associated `bionemo-esm2-train` commands. +With a locally cloned bionemo-framework repository, an appropriately configured +[nvidia-container-toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) +build toolchain, and initialized submodules, the bionemo container can be built with ```bash -# The fastest transformer engine environment variables in testing were the following two -TEST_DATA_DIR=$(download_bionemo_data esm2/testdata_esm2_pretrain:2.0 --source $MY_DATA_SOURCE); \ -bionemo-esm2-recipe \ ---train-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/train_clusters_sanity.parquet \ ---train-database-path ${TEST_DATA_DIR}/2024_03_sanity/train_sanity.db \ ---valid-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/valid_clusters.parquet \ ---valid-database-path ${TEST_DATA_DIR}/2024_03_sanity/validation.db \ ---result-dir ./results \ ---dest my_config.yaml\ ---recipe esm2_8m_recipe -``` - -> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.yaml as you see fit - -> NOTE: To continue training from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the YAML with the correct field to ensure pretraining is initialized from an existing checkpoint. - -To submit a training job with the passed config, first update the yaml file with any additional execution parameters -of your choosing: number of devices, workers, steps, etc. Second, invoke our training entrypoint. To do this, we need -three things: - -- Configuration file, the YAML produced by the previous step -- Model config type, in this case the pretraining config. This will validate the arguments in the config YAML against - those required for pretraining. Alternatively, things like fine-tuning with custom task heads may be specified here. - This allows for mixing/matching Data Modules with various tasks. -- Data Config type, this specifies how to parse, validate, and prepare the DataModule. This may change depending on task, -for example, pretraining ESM2 uses a protein cluster oriented sampling method. In the case of inference or fine-tuning -a pretrained model, a simple fasta file may be sufficient. There is a one-to-one relationship between DataConfig types -and DataModule types. - -> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config YAML and populate it with your WandB details. - -``` -bionemo-esm2-train \ ---data-config-cls bionemo.esm2.run.config_models.ESM2DataConfig \ ---model-config-cls bionemo.esm2.run.config_models.ExposedESM2PretrainConfig \ ---config my_config.yaml +docker buildx build . -t my-container-tag ``` -> NOTE: both data-config-cls and model-config-cls have default values corresponding to ESM2DataConfig and ExposedESM2PretrainingConfig - -DataConfigCls and ModelConfigCls can also refer to locally defined types by the user. As long as python knows how to import -the specified path, they may be configured. For example, you may have a custom Dataset/DataModule that you would like to -mix with an existing recipe. In this case, you define a DataConfig object with the generic specified as your DataModule -type, and then pass in the config type to the training recipe. - +#### Intellisense and interactive debugging with the VSCode Devcontainer +We distribute a [development container](https://devcontainers.github.io/) configuration for vscode +(`.vscode/devcontainer.json`) that simplifies the process of local testing and development. Opening the +bionemo-framework folder with VSCode should prompt you to re-open the folder inside the devcontainer environment. -### Geneformer -#### Running - -Similar to ESM-2, you can download the dataset and checkpoint through our utility function. - -```bash -TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20240506 --source $MY_DATA_SOURCE); \ -GENEFORMER_10M_CKPT=$(download_bionemo_data geneformer/10M_240530:2.0 --source $MY_DATA_SOURCE); \ -train_geneformer \ - --data-dir ${TEST_DATA_DIR}/cellxgene_2023-12-15_small/processed_data \ - --result-dir ./results \ - --restore-from-checkpoint-path ${GENEFORMER_10M_CKPT} \ - --experiment-name test_experiment \ - --num-gpus 1 \ - --num-nodes 1 \ - --val-check-interval 10 \ - --num-dataset-workers 0 \ - --num-steps 55 \ - --seq-length 128 \ - --limit-val-batches 2 \ - --micro-batch-size 2 -``` - -To fine-tune, you to specify a different combination of model and loss. Pass the path to the outputted config file from the previous step as the `--restore-from-checkpoint-path`, and also change -`--training-model-config-class` to the newly created model-config-class. - -While no CLI option currently exists to hot swap in different data modules and processing functions _now_, you could -copy the `sub-projects/bionemo-geneformer/geneformer/scripts/train_geneformer.py` and modify the DataModule class that gets initialized. - -Simple fine-tuning example (**NOTE**: please change `--restore-from-checkpoint-path` to be the checkpoint directory path that was output last -by the previous train run) -```bash -TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20240506 --source $MY_DATA_SOURCE); \ -train_geneformer \ - --data-dir ${TEST_DATA_DIR}/cellxgene_2023-12-15_small/processed_data \ - --result-dir ./results \ - --experiment-name test_finettune_experiment \ - --num-gpus 1 \ - --num-nodes 1 \ - --val-check-interval 10 \ - --num-dataset-workers 0 \ - --num-steps 55 \ - --seq-length 128 \ - --limit-val-batches 2 \ - --micro-batch-size 2 \ - --training-model-config-class FineTuneSeqLenBioBertConfig \ - --restore-from-checkpoint-path results/test_experiment/dev/checkpoints/test_experiment--val_loss=4.3506-epoch=1-last -``` - -##### Running with Pydantic configs -Alternatively, we provide a validated and serialized configuration file entrypoint for executing the same workflow. Recipes -are available for 10m, and 106m geneformer models. Additionally we provide an example recipe of finetuning, where the objective -is to 'regress' on token IDs rather than the traditional masked language model approach. In practice, you will likely -need to implement your own DataModule, DataConfig, and Finetuning model. You can use the same overall approach, but with -customizations for your task. - - -```bash -TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20240506 --source $MY_DATA_SOURCE); \ -bionemo-geneformer-recipe \ - --recipe geneformer_10m_pretrain_recipe \ - --dest my_config.yaml \ - --data-path ${TEST_DATA_DIR}/cellxgene_2023-12-15_small/processed_data \ - --result-dir ./results -``` -> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.yaml as you see fit - -> NOTE: To pretrain from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the YAML with the correct field to ensure pretraining is initialized from an existing checkpoint. +> [!NOTE] +> The first time you launch the devcontainer, it may take a long time to build the image. Building the image locally +> (using the command shown above) will ensure that most of the layers are present in the local docker cache. -To submit a training job with the passed config, first update the yaml file with any additional execution parameters -of your choosing: number of devices, workers, steps, etc. Second, invoke our training entrypoint. To do this, we need -three things: +### Quick Start -- Configuration file, the YAML produced by the previous step -- Model config type, in this case the pretraining config. This will validate the arguments in the config YAML against - those required for pretraining. Alternatively, things like fine-tuning with custom task heads may be specified here. - This allows for mixing/matching Data Modules with various tasks. -- Data Config type, this specifies how to parse, validate, and prepare the DataModule. This may change depending on task, -for example, while fine-tuning you may want to use a custom Dataset/DataModule that includes PERTURB-seq. In this case, -the default pretraining DataConfig and DataModule will be insufficient. See ESM2 for additional example usecases. - -> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config YAML and populate it with your WandB details. - -```bash -bionemo-geneformer-train \ ---data-config-cls bionemo.geneformer.run.config_models.GeneformerPretrainingDataConfig \ ---model-config-cls bionemo.geneformer.run.config_models.ExposedGeneformerPretrainConfig \ ---config my_config.yaml -``` - -> NOTE: both data-config-cls and model-config-cls have default values corresponding to GeneformerPretrainingDataConfig and ExposedGeneformerPretrainConfig - -DataConfigCls and ModelConfigCls can also refer to locally defined types by the user. As long as python knows how to import -the specified path, they may be configured. For example, you may have a custom Dataset/DataModule that you would like to -mix with an existing recipe. In this case, you define a DataConfig object with the generic specified as your DataModule -type, and then pass in the config type to the training recipe. - - - -## Updating License Header on Python Files -If you add new Python (`.py`) files, be sure to run our license-check. If you have not already done sone, please install -the dev-requirements.txt. If you are working directly inside a release container, you may need to manually install these. -We recommend using the developer container for contributions. - -```bash -pip install -r dev-requirements.txt --user -python ./scripts/license_check.py --modify --replace --license-header ./license_header -c sub-packages/ -c docs/ -c scripts/ -c ci/ -c internal/ -``` - -## Updating the secrets baseline file - -If false-positives are raised by the [detect-secrets](https://github.com/Yelp/detect-secrets) pre-commit hook, they can -be added to the baseline files by running the following commands: - -```bash -detect-secrets scan --baseline .secrets.baseline --exclude-files '(.*\.ipynb|.*\.baseline)$' -detect-secrets scan --baseline .secrets-nb.baseline --exclude-files '^.(?!.*\.ipynb)' --exclude-lines '"(hash|id|image/\w+)":.*' -``` - -The resulting altered baseline files should then be committed. - -# UV-based python packaging - -BioNeMo FW is migrating to use `uv` (https://docs.astral.sh/uv/) for handling python packaging inside our docker containers. -In addition to streamlining how we specify intra-repo dependencies, it allows us to create a uv lockfile to pin our -dependencies for our bionemo docker container. - -We'll maintain two images going forward: - -2. An image that derives from `nvcr.io/nvidia/pytorch` that will be our performance baseline. The advantage of this - image base is that the performance of pytorch is validated by the NVIDIA pytorch team, but the downsides are that (1) - the overall image size is quite large, and (2) using `uv sync` to install a pinned virtual environment is not - possible with the existing python environment in the ngc image. - -2. An image that derives from `nvcr.io/nvidia/cuda`, where we use uv to create the python environment from scratch. This - image uses pytorch wheels from https://download.pytorch.org. - -Currently, the devcontainer derives from the cuda-based image above, while the release image derives from the pytorch -image. - - -## Runnings tests inside the CUDA container. - -```bash -docker run --rm -it \ - -v ${HOME}/.aws:/home/bionemo/.aws \ - -v ${HOME}/.ngc:/home/bionemo/.ngc \ - -v ${PWD}:/home/bionemo/ \ - -v ${HOME}/.cache:/home/bionemo/.cache \ - -e HOST_UID=$(id -u) \ - -e HOST_GID=$(id -g) \ - --gpus=all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \ - bionemo-uv:latest \ - py.test sub-packages/ scripts/ -``` +See the [tutorials pages](https://docs.nvidia.com/bionemo-framework/latest/user-guide/examples/bionemo-esm2/pretrain/) +for example applications and getting started guides. diff --git a/arm_build/decord_ffmpeg6_fix.patch b/arm_build/decord_ffmpeg6_fix.patch new file mode 100644 index 0000000000..cac6892280 --- /dev/null +++ b/arm_build/decord_ffmpeg6_fix.patch @@ -0,0 +1,73 @@ +# This is a patch file for decord https://github.com/dmlc/decord +# needed to build decord against ffmpeg6, taken from +# https://github.com/dmlc/decord/issues/186#issuecomment-1171882325 +# This needs to be removed once decord natively supports latest ffmpeg versions. +diff --git a/src/video/ffmpeg/ffmpeg_common.h b/src/video/ffmpeg/ffmpeg_common.h +index b0b973f..f0f7316 100644 +--- a/src/video/ffmpeg/ffmpeg_common.h ++++ b/src/video/ffmpeg/ffmpeg_common.h +@@ -21,6 +21,7 @@ + extern "C" { + #endif + #include ++#include + #include + #include + #include +diff --git a/src/video/nvcodec/cuda_threaded_decoder.cc b/src/video/nvcodec/cuda_threaded_decoder.cc +index 62bc7ee..957a90d 100644 +--- a/src/video/nvcodec/cuda_threaded_decoder.cc ++++ b/src/video/nvcodec/cuda_threaded_decoder.cc +@@ -17,7 +17,7 @@ namespace decord { + namespace cuda { + using namespace runtime; + +-CUThreadedDecoder::CUThreadedDecoder(int device_id, AVCodecParameters *codecpar, AVInputFormat *iformat) ++CUThreadedDecoder::CUThreadedDecoder(int device_id, AVCodecParameters *codecpar, const AVInputFormat *iformat) + : device_id_(device_id), stream_({device_id, false}), device_{}, ctx_{}, parser_{}, decoder_{}, + pkt_queue_{}, frame_queue_{}, + run_(false), frame_count_(0), draining_(false), +@@ -70,7 +70,7 @@ CUThreadedDecoder::CUThreadedDecoder(int device_id, AVCodecParameters *codecpar, + } + } + +-void CUThreadedDecoder::InitBitStreamFilter(AVCodecParameters *codecpar, AVInputFormat *iformat) { ++void CUThreadedDecoder::InitBitStreamFilter(AVCodecParameters *codecpar, const AVInputFormat *iformat) { + const char* bsf_name = nullptr; + if (AV_CODEC_ID_H264 == codecpar->codec_id) { + // H.264 +diff --git a/src/video/nvcodec/cuda_threaded_decoder.h b/src/video/nvcodec/cuda_threaded_decoder.h +index d7e6fcd..61958a1 100644 +--- a/src/video/nvcodec/cuda_threaded_decoder.h ++++ b/src/video/nvcodec/cuda_threaded_decoder.h +@@ -46,7 +46,7 @@ class CUThreadedDecoder final : public ThreadedDecoderInterface { + using FrameOrderQueuePtr = std::unique_ptr; + + public: +- CUThreadedDecoder(int device_id, AVCodecParameters *codecpar, AVInputFormat *iformat); ++ CUThreadedDecoder(int device_id, AVCodecParameters *codecpar, const AVInputFormat *iformat); + void SetCodecContext(AVCodecContext *dec_ctx, int width = -1, int height = -1, int rotation = 0); + bool Initialized() const; + void Start(); +@@ -70,7 +70,7 @@ class CUThreadedDecoder final : public ThreadedDecoderInterface { + void LaunchThreadImpl(); + void RecordInternalError(std::string message); + void CheckErrorStatus(); +- void InitBitStreamFilter(AVCodecParameters *codecpar, AVInputFormat *iformat); ++ void InitBitStreamFilter(AVCodecParameters *codecpar, const AVInputFormat *iformat); + + int device_id_; + CUStream stream_; +diff --git a/src/video/video_reader.cc b/src/video/video_reader.cc +index af4858d..99c9635 100644 +--- a/src/video/video_reader.cc ++++ b/src/video/video_reader.cc +@@ -145,7 +145,7 @@ VideoReader::~VideoReader(){ + + void VideoReader::SetVideoStream(int stream_nb) { + if (!fmt_ctx_) return; +- AVCodec *dec; ++ const AVCodec *dec; + int st_nb = av_find_best_stream(fmt_ctx_.get(), AVMEDIA_TYPE_VIDEO, stream_nb, -1, &dec, 0); + // LOG(INFO) << "find best stream: " << st_nb; + CHECK_GE(st_nb, 0) << "ERROR cannot find video stream with wanted index: " << stream_nb; diff --git a/ci/benchmarks/partial-conv/esm2_pretrain.yaml b/ci/benchmarks/partial-conv/esm2_pretrain.yaml new file mode 100644 index 0000000000..ead8763e86 --- /dev/null +++ b/ci/benchmarks/partial-conv/esm2_pretrain.yaml @@ -0,0 +1,54 @@ +scope: partial-conv +time_limit: 14400 +script_args: + # All arguments referenced in the script string must be specified here. + # Arguments not referenced in the script string must have the 'arg' field specified. + # See jet/core/configs.py for the specification of the configuration class + workspace: + value: /workspace/bionemo2 + key_segment: False + data_path: + value: /data/20240809_uniref_2024_03/data + key_segment: False + model: + value: esm2 + variant: + value: train + config_name: + value: 650M + precision: + value: [bf16-mixed] + nodes: + value: [4] + gpus: + value: 8 + batch_size: + value: 16 + max_steps: + value: 26500 +script: |- + WANDB_API_KEY=$BIONEMO_WANDB_API_KEY ${variant}_${model} \ + --train-cluster-path=${data_path}/train_clusters.parquet \ + --train-database-path=${data_path}/train.db \ + --valid-cluster-path=${data_path}/valid_clusters.parquet \ + --valid-database-path=${data_path}/validation.db \ + --micro-batch-size=${batch_size} \ + --num-nodes=${nodes} \ + --num-gpus=${gpus} \ + --val-check-interval=1000 \ + --limit-val-batches=1 \ + --num-steps=${max_steps} \ + --min-seq-length=1024 \ + --max-seq-length=1024 \ + --num-layers=33 \ + --hidden-size=1280 \ + --num-attention-heads=20 \ + --ffn-hidden-size=5120 \ + --create-tensorboard-logger \ + --experiment-name=${batch_size}bs_${nodes}node_${gpus}gpu_${max_steps}s_${precision}prec \ + --result-dir=${tensorboard_dir} \ + --wandb-project=${wandb_project_name} \ + --wandb-group=${model}_${variant}_${config_name} \ + --wandb-job-type=${pipeline_label}__${target} \ + --log-every-n-steps=50 \ + --disable-checkpointing; diff --git a/ci/benchmarks/perf/esm2_pretrain.yaml b/ci/benchmarks/perf/esm2_pretrain.yaml new file mode 100644 index 0000000000..a276047331 --- /dev/null +++ b/ci/benchmarks/perf/esm2_pretrain.yaml @@ -0,0 +1,65 @@ +scope: perf +time_limit: 1800 +script_args: + # All arguments referenced in the script string must be specified here. + # Arguments not referenced in the script string must have the 'arg' field specified. + # See jet/core/configs.py for the specification of the configuration class + workspace: + value: /workspace/bionemo2 + key_segment: False + data_path: + value: /data/20240809_uniref_2024_03/data + key_segment: False + model: esm2 + variant: train + config_name: 650M + precision: bf16-mixed + max_steps: 200 + gpus: 8 + acc_grad: 1 + products: + - nodes: 1 + batch_size: 16 + pp: 1 + tp: 1 + - nodes: 2 + batch_size: 16 + pp: 2 + tp: 1 + - nodes: 2 + batch_size: 16 + pp: 1 + tp: 2 + - nodes: 2 + batch_size: 16 + pp: 1 + tp: 1 +script: |- + WANDB_API_KEY=$BIONEMO_WANDB_API_KEY ${variant}_${model} \ + --train-cluster-path=${data_path}/train_clusters.parquet \ + --train-database-path=${data_path}/train.db \ + --valid-cluster-path=${data_path}/valid_clusters.parquet \ + --valid-database-path=${data_path}/validation.db \ + --micro-batch-size=${batch_size} \ + --num-nodes=${nodes} \ + --num-gpus=${gpus} \ + --val-check-interval=50 \ + --limit-val-batches=1 \ + --num-steps=${max_steps} \ + --min-seq-length=1024 \ + --max-seq-length=1024 \ + --num-layers=33 \ + --hidden-size=1280 \ + --num-attention-heads=20 \ + --ffn-hidden-size=5120 \ + --create-tensorboard-logger \ + --experiment-name=${batch_size}bs_${nodes}node_${gpus}gpu_${max_steps}s_${precision}prec \ + --result-dir=${tensorboard_dir} \ + --wandb-project=${wandb_project_name} \ + --wandb-group=${model}_${variant}_${config_name}__${target} \ + --wandb-job-type=${pipeline_label} \ + --log-every-n-steps=10 \ + --accumulate-grad-batches=${acc_grad} \ + --pipeline-model-parallel-size=${pp} \ + --tensor-model-parallel-size={tp} \ + --disable-checkpointing; diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 6a63bf0606..633a3cc801 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -15,30 +15,96 @@ # See the License for the specific language governing permissions and # limitations under the License. -set -xueo pipefail -export PYTHONDONTWRITEBYTECODE=1 -# NOTE: if a non-nvidia user wants to run the test suite, just run `export BIONEMO_DATA_SOURCE=ngc` prior to this call. -export BIONEMO_DATA_SOURCE="${BIONEMO_DATA_SOURCE:-pbss}" -# flexible GPU memory management, reducing the risk of fragmentation-related CUDA OOM -export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True -source "$(dirname "$0")/utils.sh" - -if ! set_bionemo_home; then - exit 1 -fi -python -m coverage erase +# Enable strict mode with better error handling +set -euox pipefail + +# Function to display usage information +usage() { + cat << EOF +Usage: $(basename "$0") [OPTIONS] + +Options: + --skip-docs Skip running tests in the docs directory + --no-nbval Skip jupyter notebook validation tests + --skip-slow Skip tests marked as slow (@pytest.mark.slow) + +Note: Documentation tests (docs/) are only run when notebook validation + is enabled (--no-nbval not set) and docs are not skipped + (--skip-docs not set) + -h, --help Display this help message +EOF + exit "${1:-0}" +} + +# Set default environment variables +: "${BIONEMO_DATA_SOURCE:=pbss}" +: "${PYTHONDONTWRITEBYTECODE:=1}" +: "${PYTORCH_CUDA_ALLOC_CONF:=expandable_segments:True}" +# Export necessary environment variables +export BIONEMO_DATA_SOURCE PYTHONDONTWRITEBYTECODE PYTORCH_CUDA_ALLOC_CONF + +# Initialize variables +declare -a coverage_files +SKIP_DOCS=false +NO_NBVAL=false +SKIP_SLOW=false error=false -for dir in docs/ ./sub-packages/bionemo-*/; do - echo "Running pytest in $dir" - python -m coverage run --parallel-mode --source=bionemo \ - -m pytest -v --nbval-lax --durations=0 --durations-min=60.0 "$dir" || error=true + +# Parse command line arguments +while (( $# > 0 )); do + case "$1" in + --skip-docs) SKIP_DOCS=true ;; + --no-nbval) NO_NBVAL=true ;; + --skip-slow) SKIP_SLOW=true ;; + -h|--help) usage ;; + *) echo "Unknown option: $1" >&2; usage 1 ;; + esac + shift done -python -m coverage combine -python -m coverage report --show-missing +# Source utility functions +SCRIPT_DIR="$(dirname "$(readlink -f "$0")")" +source "$SCRIPT_DIR/utils.sh" || { echo "Failed to source utils.sh" >&2; exit 1; } + +# Set up BioNeMo home directory +set_bionemo_home || exit 1 -if [ "$error" = true ]; then - exit 1 +# Echo some useful information +lscpu +nvidia-smi +uname -a + +# Set up pytest options +PYTEST_OPTIONS=( + -v + --durations=0 + --durations-min=30.0 + --cov=bionemo + --cov-append + --cov-report=xml:coverage.xml +) +[[ "$NO_NBVAL" != true ]] && PYTEST_OPTIONS+=(--nbval-lax) +[[ "$SKIP_SLOW" == true ]] && PYTEST_OPTIONS+=(-m "not slow") + +# Define test directories +TEST_DIRS=(./sub-packages/bionemo-*/) +if [[ "$NO_NBVAL" != true && "$SKIP_DOCS" != true ]]; then + TEST_DIRS+=(docs/) fi + +echo "Test directories: ${TEST_DIRS[*]}" + +# Run tests with coverage +for dir in "${TEST_DIRS[@]}"; do + echo "Running pytest in $dir" + + if ! pytest "${PYTEST_OPTIONS[@]}" --junitxml=$(basename $dir).junit.xml -o junit_family=legacy "$dir"; then + error=true + fi +done + +# Exit with appropriate status +$error && exit 1 +exit 0 diff --git a/docs/docs/assets/images/esm2/esm2_pretrain_convergence.svg b/docs/docs/assets/images/esm2/esm2_pretrain_convergence.svg new file mode 100644 index 0000000000..3d8db001da --- /dev/null +++ b/docs/docs/assets/images/esm2/esm2_pretrain_convergence.svg @@ -0,0 +1,1522 @@ + + + + + + + + 2025-01-07T14:20:56.875575 + image/svg+xml + + + Matplotlib v3.6.3, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/docs/docs.todo b/docs/docs/docs.todo deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/docs/docs/models/ESM-2/SUMMARY.md b/docs/docs/models/ESM-2/SUMMARY.md new file mode 100644 index 0000000000..cffc007da9 --- /dev/null +++ b/docs/docs/models/ESM-2/SUMMARY.md @@ -0,0 +1,2 @@ +- [Model Overview](index.md) +- [Pre-trained Checkpoints](pre-training.md) diff --git a/docs/docs/models/esm2.md b/docs/docs/models/ESM-2/index.md similarity index 99% rename from docs/docs/models/esm2.md rename to docs/docs/models/ESM-2/index.md index 789223a787..0ef474a35b 100644 --- a/docs/docs/models/esm2.md +++ b/docs/docs/models/ESM-2/index.md @@ -13,13 +13,14 @@ dimension of 1280. The 3B model has 36 layers, 40 attention heads, and a hidden These models are ready for commercial use. ### Third-Party Community Consideration + This model is not owned or developed by NVIDIA. This model has been developed and built to a third-party’s requirements for this application and use case [1]; see link to [Non-NVIDIA Model Card for ESM-2 3B model]( https://huggingface.co/facebook/esm2_t36_3B_UR50D) and [non-NVIDIA Model Card for ESM-2 650M model]( https://huggingface.co/facebook/esm2_t33_650M_UR50D) - ### References + [1] Lin, Z., Akin, H., Rao, R., Hie, B., Zhu, Z., Lu, W., Smetanin, N., Verkuil, R., Kabeli, O., Shmueli, Y. and dos Santos Costa, A., 2023. Evolutionary-scale prediction of atomic-level protein structure with a language model. Science, 379(6637), pp.1123-1130. @@ -98,7 +99,6 @@ Dataset](../datasets/uniprot.md). ESM-2 is as provided under the Apache 2.0 license. - ## Competitive Benchmarking ### Accuracy @@ -112,7 +112,6 @@ checkpoints is consistent with their outputs when evaluated with the HuggingFace | 650M | 7.001 | 7.002 | 6.95 :material-information-outline: | | 3B | 6.003 | 6.004 | 6.49 :material-information-outline: | - !!! info "Different Validation Sets" The HuggingFace and converted BioNeMo2 checkpoints were evaluated on a newly curated validation set. Perplexities diff --git a/docs/docs/models/ESM-2/pre-training.md b/docs/docs/models/ESM-2/pre-training.md new file mode 100644 index 0000000000..37701b4a87 --- /dev/null +++ b/docs/docs/models/ESM-2/pre-training.md @@ -0,0 +1,155 @@ +# Pre-training ESM-2 + +Pre-trained checkpoints for ESM-2 are available at the 8M, 650M, and 3B model sizes. These models were trained by the +bionemo-framework team to reproduce the original training results from Lin et al, Science (2023), with more recent +UniProt data and leveraging the bionemo training infrastructure. The full [pre-training data](../../datasets/uniprot.md) +and train/test splits are available. + +## Model Convergence + +Validation perplexity evaluated on the NVIDIA validation set. + +
+ ![ESM-2 Pre-training Convergence](../assets/images/esm2/esm2_pretrain_convergence.svg){ width="350" } +
+ +| Model Size | Perplexity at 500k updates | +| -------------- | ------ | +| 8M | 10.26 | +| 650M | 7.14 | +| 3B | 6.42 | + +## Pre-training recipes + +=== "8M" + + ```python + esm2_8m_ckpt_path = load("esm2/nv_8m:2.0") + ``` + + ### Training Script + + | Training Parameters | Value | + | ----------------------- | ------ | + | # of GPUs | 32 | + | GPU Type | A100 | + | Batch size (per device) | 64 | + + ```bash + train_esm2 \ + --create-tensorboard-logger \ + --resume-if-exists \ + --wandb-project= \ + --save-top-k=10 \ + --train-cluster-path=/data/train_clusters.parquet \ # (1)! + --train-database-path=/data/train.db \ + --valid-cluster-path=/data/valid_clusters.parquet \ + --valid-database-path=/data/validation.db \ + --num-steps=500_000 \ + --metric-to-monitor-for-checkpoints=val_loss \ + --micro-batch-size=64 \ + --num-nodes=4 \ + --num-gpus=8 \ + --val-check-interval=10000 \ + --limit-val-batches=1.0 \ + --result-dir=/results/esm2_pretrain_8m \ + --experiment-name=esm2_pretrain_8m \ + --num-layers=6 \ + --hidden-size=320 \ + --num-attention-heads=20 \ + --ffn-hidden-size=1280; + ``` + + 1. Paths here must be mounted into the `bionemo-framework` docker image. + +=== "650M" + + ```python + esm2_650m_ckpt_path = load("esm2/nv_650m:2.1") + ``` + + ### Training Script + + | Training Parameters | Value | + | ----------------------- | ------ | + | # of GPUs | 64 | + | GPU Type | H100 | + | Batch size (per device) | 32 | + + ```bash + train_esm2 \ + --create-tensorboard-logger \ + --resume-if-exists \ + --wandb-project= \ + --save-top-k=10 \ + --train-cluster-path=/data/train_clusters.parquet \ # (1)! + --train-database-path=/data/train.db \ + --valid-cluster-path=/data/valid_clusters.parquet \ + --valid-database-path=/data/validation.db \ + --num-steps=500_000 \ + --metric-to-monitor-for-checkpoints=val_loss \ + --micro-batch-size=32 \ + --num-nodes=8 \ + --num-gpus=8 \ + --val-check-interval=10000 \ + --limit-val-batches=1.0 \ + --result-dir=/results/esm2_pretrain_650m \ + --experiment-name=esm2_pretrain_650m \ + --min-seq-length=1024 \ + --max-seq-length=1024 \ + --num-layers=33 \ + --hidden-size=1280 \ + --num-attention-heads=20 \ + --ffn-hidden-size=5120; + ``` + + 1. Paths here must be mounted into the `bionemo-framework` docker image. + +=== "3B" + + ```python + esm2_3b_ckpt_path = load("esm2/nv_3b:2.1") + ``` + + ### Training Script + + | Training Parameters | Value | + | ----------------------- | ------ | + | # of GPUs | 128 | + | GPU Type | H100 | + | Batch size (per device) | 16 | + | warmup steps | 20,000 | + + ```bash + train_esm2 \ + --create-tensorboard-logger \ + --resume-if-exists \ + --wandb-project= \ + --save-top-k=10 \ + --train-cluster-path=/data/train_clusters.parquet \ # (2)! + --train-database-path=/data/train.db \ + --valid-cluster-path=/data/valid_clusters.parquet \ + --valid-database-path=/data/validation.db \ + --num-steps=500_000 \ + --warmup-steps=20_000 \ # (1)! + --metric-to-monitor-for-checkpoints=val_loss \ + --micro-batch-size=16 \ + --num-nodes=16 \ + --num-gpus=8 \ + --val-check-interval=2500 \ + --limit-val-batches=1.0 \ + --result-dir=/results/esm2_pretrain_3b \ + --experiment-name=esm2_pretrain_3b \ + --min-seq-length=1024 \ + --max-seq-length=1024 \ + --num-layers=36 \ + --hidden-size=2560 \ + --num-attention-heads=40 \ + --ffn-hidden-size=10240; + ``` + + 1. We had to increase the number of warmup steps 10x over the published training recipe for ESM-2 3B, which was + likely trained with fp16 precision. This gave us an overall similar initial curve, but avoided convergence issues + at around 2,000 steps. + + 2. Paths here must be mounted into the `bionemo-framework` docker image. diff --git a/docs/docs/user-guide/background/megatron_datasets.md b/docs/docs/user-guide/background/megatron_datasets.md index f25bab0748..d4875fe944 100644 --- a/docs/docs/user-guide/background/megatron_datasets.md +++ b/docs/docs/user-guide/background/megatron_datasets.md @@ -50,12 +50,6 @@ for sample in MultiEpochDatasetResampler(dataset, num_epochs=3, shuffle=True): ... ``` -!!! note "Very large datasets" - - For datasets where `len(dataset)` is too large for a shuffled list of indices to comfortably fit in memory, - [PRNGResampleDataset][bionemo.core.data.resamples.PRNGResampleDataset] offers a simple solution for shuffling a - dataset with replacement in O(1) memory. - ## Training Resumption To ensure identical behavior with and without job interruption, BioNeMo provides [MegatronDataModule][bionemo.llm.data.datamodule.MegatronDataModule] to save and load state dict for training resumption, and provides [WrappedDataLoader][nemo.lightning.data.WrappedDataLoader] to add a `mode` attribute to [DataLoader][torch.utils.data.DataLoader]. diff --git a/docs/docs/user-guide/contributing/Writing Documentation/jupyter-notebooks.ipynb b/docs/docs/user-guide/contributing/Writing Documentation/jupyter-notebooks.ipynb index 2e1aa81a5f..386e5f4826 100644 --- a/docs/docs/user-guide/contributing/Writing Documentation/jupyter-notebooks.ipynb +++ b/docs/docs/user-guide/contributing/Writing Documentation/jupyter-notebooks.ipynb @@ -71,7 +71,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 2, @@ -80,7 +80,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -127,16 +127,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "2.3.0a0+ebedce2\n" + "[0 1 2 3 4]\n" ] } ], "source": [ "#NBVAL_CHECK_OUTPUT\n", - "# pragma: allowlist secret\n", "\n", - "import torch\n", - "print(torch.__version__)" + "import numpy as np\n", + "\n", + "\n", + "print(np.arange(5))" ] } ], diff --git a/docs/docs/user-guide/contributing/contributing.md b/docs/docs/user-guide/contributing/contributing.md index b66b2211ee..db384c2982 100644 --- a/docs/docs/user-guide/contributing/contributing.md +++ b/docs/docs/user-guide/contributing/contributing.md @@ -7,12 +7,49 @@ These are initiated by the member commenting `/build-ci` directly on the PR. All PRs must have successful CI runs and sufficient code review before being merged. +## Developer Certificate of Origin (DCO) + +We require that all contributors "sign-off" on their commits (not GPG signing, just adding the `-s | --signoff` +argument, or follow the instructions below for auto-signing). This sign-off certifies that you adhere to the Developer +Certificate of Origin (DCO) ([full text](https://developercertificate.org/)); in short that the contribution is your +original work, or you have rights to submit it under the same license or a compatible license. + +Any contribution which contains commits that are not signed-off will not be accepted. + +To sign off on a commit, simply use the `--signoff` (or `-s`) option when committing your changes: + +```bash +git commit -s -m "Add cool feature." +``` + +This will append the following to your commit message: + +``` +Signed-off-by: Your Name +``` + +If you would like this to happen automatically to all of your commits, you can modify +your local `~/.git-config-template.txt` file. You can do this with a command like the +following: + +``` +echo "Signed-off-by: Your Name " > ~/.git-commit-template.txt +git config --local commit.template ~/.git-commit-template.txt +``` + +If you have a commit that you want to retroactively sign, you can do that with: + +``` +git commit --amend --no-edit --signoff +``` + ## Python Coding Standards This page contains the Python coding standards for the BioNeMo repository. They apply to all Python code in the repository (unless external constraints prevent it). -## Coding Style +### Coding Style + - We follow the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html) with a few tweaks. - The most important parts of this style guide that our code must adhere to are: - [Docstring](https://google.github.io/styleguide/pyguide.html#381-docstrings) @@ -21,15 +58,15 @@ repository (unless external constraints prevent it). - [Default iterators](https://google.github.io/styleguide/pyguide.html#28-default-iterators-and-operators) - [Bad naming / abbreviation](https://google.github.io/styleguide/pyguide.html#316-naming) - The exceptions to this style guide are: - + [Module](https://google.github.io/styleguide/pyguide.html#22-imports) imports. If a module is uniquely named, import + - [Module](https://google.github.io/styleguide/pyguide.html#22-imports) imports. If a module is uniquely named, import the module. Otherwise, import the value, type, or function directly. - Linting and formatting of all code is required by using `ruff` with BioNeMo's configured options. -- Unit testing with `pytest`. +- Unit testing with `pytest`. See [Unit Tests](#unit-tests) for more details. - Add type annotations everywhere. In particular, new code should all be type-annotated as thoroughly as possible. This also obviates the need for including type hints in the function docstring. It is ok to omit annotations for private helper functions, but use your best judgement. - Include docstrings for every class, function, and method exposed to the user. - + Docstrings **should** answer (a) what is the code doing and (b) why would someone use it. + - Docstrings **should** answer (a) what is the code doing and (b) why would someone use it. - Never use wildcard imports. - Define `__all__ = (,)` in modules: make explicit the API of each module, auto-documenting the most important definitions. - Minimize the use of `**kwargs`. @@ -39,9 +76,10 @@ repository (unless external constraints prevent it). - Private functions (functions starting with ``_``) shouldn't be called outside its host file. ### General Guidelines + - **User-oriented**: make it easy for end users, even at the cost of writing more code in the background - **Robust**: make it hard for users to make mistakes. -- **Well-tested**: please add simple, fast unit tests. +- **Well-tested**: please add simple, fast unit tests. See [Unit Tests](#unit-tests). - **Reusable**: for every piece of code, think about how it can be reused in the future and make it easy to reuse. - **Readable**: code should be easy to read and well documented (with comments and docstrings). - **Legal**: if you copy even one line of code from the Internet, make sure that the code allows the license that @@ -50,102 +88,55 @@ repository (unless external constraints prevent it). - **Consistent**: we work in a team. It is important to integrate changes with existing code. - **Readable**: your code should be easy to read and understand by any other engineer, including outside NVIDIA. Some tips: - + Document your code. Make all comments complete sentences, starting with a capitalized letter and ending with a + - Document your code. Make all comments complete sentences, starting with a capitalized letter and ending with a period. - + Avoid abbreviations: 'bn' is harder to understand than 'batch_norm'. - + Avoid baked-in constants throughout the code. Instead, specify them as parameters to your function. If you must have + - Avoid abbreviations: 'bn' is harder to understand than 'batch_norm'. + - Avoid baked-in constants throughout the code. Instead, specify them as parameters to your function. If you must have a constant, follow the naming guideline (e.g., `GLOBAL_CONSTANT`). - + Avoid functions that span hundreds of lines. Large functions are more difficult to read and more difficult to test. + - Avoid functions that span hundreds of lines. Large functions are more difficult to read and more difficult to test. If >120 lines, consider re-factoring it into smaller logical functions, each unit-tested and well-documented. - + Re-use code by importing. **Do not copy and paste code.** - + Usage of third-party code should be legally compatible and attributed. - - + - Re-use code by importing. **Do not copy and paste code.** + - Usage of third-party code should be legally compatible and attributed. ## Pull Request (PR) Guidelines -### Labeling Your PR - -If you are an external contributor (not an NVIDIA employee), please add the `contribution` label to your PR before submitting. Labels can be accessed in the right sidebar of the GitHub user interface when creating or editing a PR. - -### Signing Your Work - -* We require that all contributors "sign-off" on their commits (not GPG signing, just adding the `-s | --signoff` - argument, or follow the instructions below for auto-signing). This sign-off certifies that the contribution is your original - work, or you have rights to submit it under the same license or a compatible license. +### Labeling Your PR as External Contributor -* Any contribution which contains commits that are not signed-off will not be accepted. +If you are an external contributor (not an NVIDIA employee), please add the `contribution` label to your PR before +submitting. Labels can be accessed in the right sidebar of the GitHub user interface when creating or editing a PR. -* To sign off on a commit you simply use the `--signoff` (or `-s`) option when committing your changes: - ```bash - $ git commit -s -m "Add cool feature." - ``` - This will append the following to your commit message: - ``` - Signed-off-by: Your Name - ``` +### CI Pipeline Configuration Controls - If you would like this to happen automatically to all of your commits, you can modify - your local `~/.git-config-template.txt` file. You can do this with a command like the - following: +CI pipeline behavior can be controlled via checkboxes in PR descriptions to optimize test execution: - ``` - echo "Signed-off-by: Your Name " > ~/.git-commit-template.txt - git config --local commit.template ~/.git-commit-template.txt - ``` +Key behaviors: - If you have a commit that you want to retroactively sign, you can do that with: +- Controls processed automatically on PR submit/update +- Labels applied based on checkbox status +- Invalid combinations default to most restrictive option - ``` - git commit --amend --no-edit --signoff - ``` +#### **SKIP_CI** -* Full text of the DCO: +- Skips entire CI pipeline +- Use for documentation typos, README updates - ``` - Developer Certificate of Origin - Version 1.1 +#### **INCLUDE_NOTEBOOKS_TESTS** - Copyright (C) 2004, 2006 The Linux Foundation and its contributors. - 1 Letterman Drive - Suite D4700 - San Francisco, CA, 94129 +- Enables notebook validation tests +- Use when modifying notebooks or notebook-related code +- Disabled by default - Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. - ``` - - ``` - Developer's Certificate of Origin 1.1 - - By making a contribution to this project, I certify that: - - (a) The contribution was created in whole or in part by me and I have the right to submit it under the open source - license indicated in the file; or - - (b) The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate - open source license and I have the right under that license to submit that work with modifications, whether created - in whole or in part by me, under the same open source license (unless I am permitted to submit under a different - license), as indicated in the file; or - - (c) The contribution was provided directly to me by some other person who certified (a), (b) or (c) and I have not - modified it. - - (d) I understand and agree that this project and the contribution are public and that a record of the contribution - (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be - redistributed consistent with this project or the open source license(s) involved. - ``` - -### Developer workflows: +### Developer workflows You should always carefully test your changes. Run `pytest ...` in your container locally. All tests are done via `pytest`. Changes that affect model training accuracy or compute performance should be tested on SLURM. - Developer workflow for _external_ code contributions is as follows: 1. External developers must first [fork](https://help.github.com/en/articles/fork-a-repo) the -[upstream]({{ github_url }}) BioNeMo OSS repository and for BioNeMo2 (this branch) use the `main` branch as base. +[upstream](https://github.com/NVIDIA/bionemo-framework/tree/main) BioNeMo OSS repository and for BioNeMo2 (this branch) +use the `main` branch as base. 2. Clone the forked repository and push changes to the personal fork. @@ -162,22 +153,20 @@ Developer workflow for _internal_ or those developers that have been granted pus 2. Create a branch which ideally should be of the form `username/branch_description` 3. Push branch up to our repository `git push -u origin HEAD` - For both internal and external developers, the next step is opening a PR: 1. Once the code changes are staged on the fork and ready for review, a [Pull Request](https://help.github.com/en/articles/about-pull-requests) (PR) can be [requested](https://help.github.com/en/articles/creating-a-pull-request) to merge the changes from a branch of the fork or branch into `main`. - * Exercise caution when selecting the source and target branches for the PR. + - Exercise caution when selecting the source and target branches for the PR. Note that versioned releases of TensorRT OSS are posted to `release/` branches of the upstream repo. - * Creation of a PR creation kicks off the code review process. - * At least one TensorRT engineer will be assigned for the review. - * While under review, mark your PRs as work-in-progress by prefixing the PR title with [WIP]. + - Creation of a PR creation kicks off the code review process. + - At least one TensorRT engineer will be assigned for the review. + - While under review, mark your PRs as work-in-progress by prefixing the PR title with [WIP]. 2. Once ready, CI can be started by a developer with permissions when they add a `/build-ci` comment. This must pass prior to merging. - ### General guidelines **Send your PRs to the `main` branch**. Branch off from `main` when making your changes. @@ -185,7 +174,8 @@ Prefix your branches with your name or initials (for example, `your_name/branch_ our repository otherwise please create a fork with your branch and submit a PR with `main` as the target. - Make sure your PR does one thing. Have a clear answer to "What does this PR do?" -- Make sure you have the linters enabled via pre-commit hooks (`pre-commit install`) +- Make sure you have the linters enabled via pre-commit hooks (`pre-commit install`) (See also [Pre-commit + validation](#pre-commit-validation)) - Follow the default PR template - Make sure all unit tests finish successfully before running PR pipeline by invoking `pytest scripts sub-packages`. - Make sure you added necessary tests and documentation changes (could be just comments in the config files) for the @@ -198,12 +188,14 @@ our repository otherwise please create a fork with your branch and submit a PR w - Make sure to merge your PR when it is ready and pipeline is successful ### Unit tests + Contributors to BioNeMo FW are expected to unit test their introduced changes. After testing your code locally, trigger tests in the PR's CI. Let a code-owner know that you are ready for the build to run and they will leave a `/build-ci` comment on your PR which will run the CI test suite. #### Adding unit tests + Add unit tests under `tests` to examine use cases of new classes or methods that are being added to the codebase. Each test file must be for a particular file or module. For example if you have a file that is under `src/path/to/module/my_file_name.py` then your test should match the path at `tests/path/to/module/test_my_file_name.py`. @@ -212,3 +204,35 @@ integrating multiple examples of different files, then you can use the following above example, if you wanted to test functions from several files together that all exist in the same `src/path/to/module` then you could create a `tests/path/to/test_module.py` file. The same is true for parents of that module and so on. Generally unit tests should exist at the level of the individual file however. + +## Pre-commit validation + +We use [pre-commit](https://pre-commit.com/) for essential static checks. These checks are enforced on new PRs through +the CI process, but should also be run locally. After following the installation instructions for pre-commit, run +`pre-commit install` in the bionemo-framework repository to initialize the checks. + +To run pre-commit checks (and fix errors where possible), run `pre-commit run --all-files`. To ignore a pre-commit error +locally, use `git commit -n ...` to allow the commit to proceed with some failing pre-commit checks. + +### Updating License Header on Python Files + +If you add new Python (`.py`) files, be sure to run our license-check. If you have not already done sone, please install +the dev-requirements.txt. If you are working directly inside a release container, you may need to manually install these. +We recommend using the developer container for contributions. + +```bash +pip install -r dev-requirements.txt --user +python ./scripts/license_check.py --modify --replace --license-header ./license_header -c sub-packages/ -c docs/ -c scripts/ -c ci/ -c internal/ +``` + +### Updating the secrets baseline file + +If false-positives are raised by the [detect-secrets](https://github.com/Yelp/detect-secrets) pre-commit hook, they can +be added to the baseline files by running the following commands: + +```bash +detect-secrets scan --baseline .secrets.baseline --exclude-files '(.*\.ipynb|.*\.baseline)$' +detect-secrets scan --baseline .secrets-nb.baseline --exclude-files '^.(?!.*\.ipynb)' --exclude-lines '"(hash|id|image/\w+)":.*' +``` + +The resulting altered baseline files should then be committed. diff --git a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb index 35e1f88830..6347e540e9 100644 --- a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb +++ b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb @@ -6,7 +6,7 @@ "source": [ "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2p32dFTsjecDZOrOOJCok3qZuYV)\n", "\n", - "
NOTE It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits.
" + "NOTE: it takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits." ] }, { @@ -85,7 +85,18 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(8192, 60664)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#NBVAL_CHECK_OUTPUT\n", "import random\n", @@ -105,9 +116,21 @@ " indices = list(range(len(adata)))\n", " random.shuffle(indices)\n", "\n", - "micro_batch_size:int = 32" + "micro_batch_size:int = 32\n", + "num_steps:int = 256\n", + "selection = sorted(indices[:micro_batch_size*num_steps])\n", + "# NOTE: there's a current constraint that predict_step needs to be a function of micro-batch-size.\n", + "# this is something we are working on fixing. A quick hack is to set micro-batch-size=1, but this is\n", + "# slow. In this notebook we are going to use mbs=32 and subsample the anndata.\n", + "adata = adata[selection].copy() # so it's not a view\n", + "adata.shape" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, { "cell_type": "code", "execution_count": 3, @@ -116,16 +139,15 @@ "source": [ "import shutil\n", "from bionemo.core import BIONEMO_CACHE_DIR\n", - "\n", - "cleanup : bool = True\n", - "\n", + "cleanup:bool=True\n", "notebook_workdir = BIONEMO_CACHE_DIR / \"notebook_tutorials\" / \"geneformer_celltype_classification\"\n", "if cleanup and notebook_workdir.exists():\n", " shutil.rmtree(notebook_workdir)\n", "notebook_workdir.mkdir(parents=True, exist_ok=True)\n", + "input_dir = notebook_workdir / \"celltype-bench-dataset-input\"\n", "data_dir = notebook_workdir / \"celltype-bench-dataset\"\n", - "data_dir.mkdir(parents=True, exist_ok=True)\n", - "h5ad_outfile = data_dir / \"hs-celltype-bench.h5ad\"\n", + "input_dir.mkdir(parents=True, exist_ok=True)\n", + "h5ad_outfile = input_dir / \"hs-celltype-bench.h5ad\"\n", "adata.write_h5ad(h5ad_outfile)" ] }, @@ -140,50 +162,9 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_csv from `anndata` is deprecated. Import anndata.io.read_csv instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_excel from `anndata` is deprecated. Import anndata.io.read_excel instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_hdf from `anndata` is deprecated. Import anndata.io.read_hdf instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_loom from `anndata` is deprecated. Import anndata.io.read_loom instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_mtx from `anndata` is deprecated. Import anndata.io.read_mtx instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_text from `anndata` is deprecated. Import anndata.io.read_text instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_csv from `anndata` is deprecated. Import anndata.io.read_csv instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_excel from `anndata` is deprecated. Import anndata.io.read_excel instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_hdf from `anndata` is deprecated. Import anndata.io.read_hdf instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_loom from `anndata` is deprecated. Import anndata.io.read_loom instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_mtx from `anndata` is deprecated. Import anndata.io.read_mtx instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_text from `anndata` is deprecated. Import anndata.io.read_text instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "/usr/local/lib/python3.10/dist-packages/anndata/utils.py:429: FutureWarning: Importing read_umi_tools from `anndata` is deprecated. Import anndata.io.read_umi_tools instead.\n", - " warnings.warn(msg, FutureWarning)\n", - "Found 1 files\n", - "Starting to create memmap files...\n", - "Creating metadata...: 100%|███████████████████████| 1/1 [00:00<00:00, 2.05it/s]\n", - "Done creating `metadata.json`\n", - "Writing data into memmaps to /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/celltype-bench-dataset...\n", - "Merging AnnData into numpy memaps...: 100%|███████| 1/1 [00:01<00:00, 1.49s/it]\n", - "Saving dataframe ...\n", - "Done creating dataset ...\n" - ] - } - ], + "outputs": [], "source": [ - "!sc_memmap --data-path {data_dir} --save-path {data_dir} --obs-cols cell_type --strict-metadata" + "!convert_h5ad_to_scdl --data-path {input_dir} --save-path {data_dir}" ] }, { @@ -201,12 +182,12 @@ { "data": { "text/plain": [ - "['features.csv',\n", - " 'gene_expression_data.npy',\n", - " 'gene_expression_ind.npy',\n", - " 'gene_expression_ptr.npy',\n", - " 'hs-celltype-bench.h5ad',\n", - " 'metadata.json']" + "['col_ptr.npy',\n", + " 'data.npy',\n", + " 'features',\n", + " 'metadata.json',\n", + " 'row_ptr.npy',\n", + " 'version.json']" ] }, "execution_count": 5, @@ -221,25 +202,19 @@ "files" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Download Model Checkpoints" - ] - }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "from bionemo.core.data.load import load\n", + "# NOTE: calling the load(...) function directly does not currently work for downloads through NGC in an interactive\n", + "# notebook environment. Get aound this below by calling the CLI download endpoint which executes in a subshell.\n", "\n", "# 106m checkpoint\n", "geneformer_106m_out = !download_bionemo_data \"geneformer/106M_240530:2.0\"\n", "# 10m checkpoint\n", - "geneformer_10m_out = !download_bionemo_data \"geneformer/10M_240530:2.0\" \n", + "geneformer_10m_out = !download_bionemo_data \"geneformer/10M_240530:2.0\"\n", "# 10m bionemo2 trained checkpoint\n", "geneformer_10m_bnmo2_out = !download_bionemo_data \"geneformer/10M_241113:2.0\"\n", "# Result includes a list of outputs, the last one is the path so grab that from each:\n", @@ -254,10 +229,10 @@ "metadata": {}, "outputs": [], "source": [ - "result_path_10m = notebook_workdir / \"results_10m\"\n", - "result_path_10m_bnmo2 = notebook_workdir / \"results_10m_bnmo2\"\n", - "results_path_10m_random = notebook_workdir / \"results_10m_randomweights\"\n", - "result_path_106m = notebook_workdir / \"results_106m\"" + "result_path_10m = notebook_workdir / \"results_10m.pt\"\n", + "result_path_10m_bnmo2 = notebook_workdir / \"results_10m_bnmo2.pt\"\n", + "results_path_10m_random = notebook_workdir / \"results_10m_randomweights.pt\"\n", + "result_path_106m = notebook_workdir / \"results_106m.pt\"" ] }, { @@ -277,59 +252,142 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-16 20:19:36 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-23 20:23:33 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-12-16 20:19:36 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + "[NeMo W 2024-12-23 20:23:33 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-16 20:19:37 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-12-16 20:19:38 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-16 20:19:38 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:19:38 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:19:38 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:19:39 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:19:39 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:19:39 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:19:39 infer_geneformer:82] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-23 20:23:37 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:23:37 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:23:37 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:23:37 infer_geneformer:83] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-12-16 20:19:39 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-12-16 20:19:39 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:19:39 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo I 2024-12-23 20:23:37 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:23:38 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "WARNING: Logging before flag parsing goes to stderr.\n", - "W1216 20:19:39.949693 140641974060864 config.py:85] Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-12-16 20:19:41 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-12-16 20:19:41 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", - " warnings.warn(\n", - " \n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-12-16 20:19:41 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-12-16 20:19:41 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" + "2024-12-23 20:23:38 - /workspaces/bionemo-framework/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py - WARNING - Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2024-12-23 20:23:40 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[NeMo W 2024-12-23 20:23:40 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "2024-12-23 20:23:40 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", + "[NeMo I 2024-12-23 20:23:40 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", + "2024-12-23 20:23:40 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "2024-12-23 20:23:40 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + "Params for bucket 1 (10300032 elements):\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", + "\tmodule.embedding.word_embeddings.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.final_layernorm.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", + "\tmodule.lm_head.dense.weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", + "\tmodule.encoder.final_layernorm.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", + "\tmodule.lm_head.layer_norm.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", + "\tmodule.lm_head.dense.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", + "\tmodule.embedding.position_embeddings.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.lm_head.layer_norm.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", + "\tmodule.output_layer.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", + "2024-12-23 20:23:40 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", + "2024-12-23 20:23:40 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", + "2024-12-23 20:24:08 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m.pt/predictions__rank_0.pt\n", + "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" ] } ], @@ -342,7 +400,7 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids" + " --include-input-ids\n" ] }, { @@ -354,59 +412,142 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-16 20:21:10 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-23 20:24:25 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-12-16 20:21:11 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + "[NeMo W 2024-12-23 20:24:25 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-16 20:21:11 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-12-16 20:21:12 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:21:12 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:21:12 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:21:12 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:21:13 infer_geneformer:82] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-23 20:24:29 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:24:29 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:24:29 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:24:29 infer_geneformer:83] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-12-16 20:21:13 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-12-16 20:21:13 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:21:13 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo I 2024-12-23 20:24:29 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:24:29 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "WARNING: Logging before flag parsing goes to stderr.\n", - "W1216 20:21:13.782941 140199712900928 config.py:85] Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", - "[NeMo I 2024-12-16 20:21:14 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-12-16 20:21:14 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", - " warnings.warn(\n", - " \n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-12-16 20:21:15 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-12-16 20:21:15 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" + "2024-12-23 20:24:30 - /workspaces/bionemo-framework/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py - WARNING - Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", + "[NeMo I 2024-12-23 20:24:32 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[NeMo W 2024-12-23 20:24:32 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "2024-12-23 20:24:32 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", + "[NeMo I 2024-12-23 20:24:32 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", + "2024-12-23 20:24:32 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "2024-12-23 20:24:32 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + "Params for bucket 1 (10300032 elements):\n", + "\tmodule.lm_head.layer_norm.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", + "\tmodule.output_layer.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.embedding.position_embeddings.weight\n", + "\tmodule.encoder.final_layernorm.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", + "\tmodule.lm_head.dense.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.final_layernorm.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", + "\tmodule.lm_head.dense.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", + "\tmodule.lm_head.layer_norm.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.embedding.word_embeddings.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", + "2024-12-23 20:24:32 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", + "2024-12-23 20:24:32 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", + "2024-12-23 20:24:59 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_bnmo2.pt/predictions__rank_0.pt\n", + "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" ] } ], @@ -419,7 +560,7 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids" + " --include-input-ids\n" ] }, { @@ -431,54 +572,141 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-16 20:22:40 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-23 20:25:16 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-12-16 20:22:40 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + "[NeMo W 2024-12-23 20:25:17 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-16 20:22:40 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-12-16 20:22:41 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:22:41 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:22:41 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:22:41 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:22:42 infer_geneformer:82] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-23 20:25:20 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:25:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:25:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:25:20 infer_geneformer:83] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-12-16 20:22:42 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-12-16 20:22:42 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:22:42 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo I 2024-12-23 20:25:20 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:25:20 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "[NeMo I 2024-12-16 20:22:42 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-12-16 20:22:42 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-12-16 20:22:42 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" + "[NeMo I 2024-12-23 20:25:21 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[NeMo W 2024-12-23 20:25:21 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "2024-12-23 20:25:21 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", + "[NeMo I 2024-12-23 20:25:21 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", + "2024-12-23 20:25:21 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "2024-12-23 20:25:21 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + "Params for bucket 1 (10300032 elements):\n", + "\tmodule.lm_head.layer_norm.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.final_layernorm.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", + "\tmodule.encoder.final_layernorm.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", + "\tmodule.lm_head.layer_norm.bias\n", + "\tmodule.lm_head.dense.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", + "\tmodule.embedding.position_embeddings.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.lm_head.dense.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", + "\tmodule.output_layer.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.embedding.word_embeddings.weight\n", + "2024-12-23 20:25:21 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", + "2024-12-23 20:25:21 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", + "2024-12-23 20:25:47 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_randomweights.pt/predictions__rank_0.pt\n", + "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" ] } ], @@ -490,7 +718,7 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids" + " --include-input-ids\n" ] }, { @@ -502,59 +730,214 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-16 20:24:08 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "[NeMo W 2024-12-23 20:26:04 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-12-16 20:24:08 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + "[NeMo W 2024-12-23 20:26:04 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-16 20:24:09 ssm:31] The package `megatron.core` was not imported in this environment which is needed for SSMs.\n", - "[NeMo W 2024-12-16 20:24:10 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/db24ba3858005680e343d0e4714c7c91fde6d738e2bf4018d489c0b1541544df-singlecell-testdata-20240506.tar.gz.untar/cellxgene_2023-12-15_small/processed_data/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:24:10 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:24:10 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-16 20:24:10 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-16 20:24:10 infer_geneformer:82] *************** Preprocessing Finished ************\n", + "[NeMo W 2024-12-23 20:26:08 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:26:08 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:26:08 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2024-12-23 20:26:08 infer_geneformer:83] *************** Preprocessing Finished ************\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n", - "[NeMo W 2024-12-16 20:24:10 dataset:172] Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets.\n", - "[NeMo I 2024-12-16 20:24:10 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-16 20:24:10 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo I 2024-12-23 20:26:08 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:396] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:410] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:418] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:421] All context parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:422] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:429] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:430] All model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:476] Rank 0 has embedding group: [0]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:484] All embedding group ranks: [[0]]\n", + "[NeMo I 2024-12-23 20:26:08 megatron_init:485] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "WARNING: Logging before flag parsing goes to stderr.\n", - "W1216 20:24:11.353403 140648060589888 config.py:85] Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-12-16 20:24:12 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "[NeMo W 2024-12-16 20:24:12 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/torch/distributed/checkpoint/state_dict_loader.py:25: UserWarning: 'load_state_dict' is deprecated and will be removed in future versions. Please use 'load' instead.\n", - " warnings.warn(\n", - " \n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "[NeMo W 2024-12-16 20:24:13 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2024-12-16 20:24:13 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n" + "2024-12-23 20:26:08 - /workspaces/bionemo-framework/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py - WARNING - Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2024-12-23 20:26:11 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[NeMo W 2024-12-23 20:26:11 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "2024-12-23 20:26:11 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", + "[NeMo I 2024-12-23 20:26:11 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n", + "2024-12-23 20:26:11 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "2024-12-23 20:26:11 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + "Params for bucket 1 (106808960 elements):\n", + "\tmodule.encoder.layers.10.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.8.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.7.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.11.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", + "\tmodule.lm_head.dense.bias\n", + "\tmodule.encoder.layers.7.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.6.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.11.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.8.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.6.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.11.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.6.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.10.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.11.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.9.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.7.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.6.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.11.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.10.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", + "\tmodule.encoder.final_layernorm.bias\n", + "\tmodule.encoder.layers.9.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.6.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.10.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.8.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", + "\tmodule.lm_head.layer_norm.weight\n", + "\tmodule.encoder.layers.11.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.10.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.9.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.6.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.11.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.8.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.9.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.7.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.11.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.10.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.lm_head.layer_norm.bias\n", + "\tmodule.encoder.layers.9.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.10.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.8.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.7.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", + "\tmodule.embedding.position_embeddings.weight\n", + "\tmodule.encoder.final_layernorm.weight\n", + "\tmodule.encoder.layers.11.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.8.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.10.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.9.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.6.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.8.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", + "\tmodule.output_layer.bias\n", + "\tmodule.encoder.layers.9.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.7.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.10.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.7.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.6.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.8.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.9.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.7.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.6.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.11.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.8.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.9.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.7.mlp.linear_fc1.weight\n", + "\tmodule.encoder.layers.6.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.11.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.9.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.8.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", + "\tmodule.encoder.layers.10.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.7.self_attention.linear_qkv.layer_norm_bias\n", + "\tmodule.encoder.layers.6.self_attention.linear_qkv.layer_norm_weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", + "\tmodule.embedding.word_embeddings.weight\n", + "\tmodule.lm_head.dense.weight\n", + "\tmodule.encoder.layers.8.self_attention.linear_qkv.bias\n", + "\tmodule.encoder.layers.7.self_attention.linear_proj.weight\n", + "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", + "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + "\tmodule.encoder.layers.9.self_attention.linear_qkv.weight\n", + "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", + "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", + "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", + "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", + "2024-12-23 20:26:11 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", + "2024-12-23 20:26:11 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", + "2024-12-23 20:27:26 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_106m.pt/predictions__rank_0.pt\n", + "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" ] } ], @@ -567,7 +950,7 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids" + " --include-input-ids\n" ] }, { @@ -585,10 +968,10 @@ "outputs": [], "source": [ "def run_benchmark(data, labels, use_pca=True):\n", - " ''' \n", + " '''\n", " data - contains the single cell expression (or whatever feature) in each row.\n", " labels - contains the string label for each cell\n", - " \n", + "\n", " data_shape (R, C)\n", " labels_shape (R,)\n", " '''\n", @@ -638,12 +1021,12 @@ " if metric.startswith('test_'):\n", " results_out[metric] = (scores.mean(), scores.std())\n", " print(f\"{metric[5:]}: {scores.mean():.3f} (+/- {scores.std():.3f})\")\n", - " \n", + "\n", " predictions = cross_val_predict(pipeline, data, labels, cv=cv)\n", "\n", - " # Return confusion matrix and metrics.\n", + " # v Return confusion matrix and metrics.\n", " conf_matrix = confusion_matrix(labels, predictions)\n", - " \n", + "\n", " return results_out, conf_matrix" ] }, @@ -653,22 +1036,21 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(22502, 256)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_47840/2637469332.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " infer_Xs_10m = torch.load(result_path_10m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" + ] } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", "import torch\n", + "\n", + "\n", "infer_Xs_10m = torch.load(result_path_10m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_10m), (len(adata), len(infer_Xs_10m))\n", - "infer_Xs_10m.shape" + "assert infer_Xs_10m.shape == (8192, 256)\n" ] }, { @@ -677,22 +1059,18 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(22502, 256)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_47840/3276479409.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2 / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" + ] } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", - "import torch\n", "infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2 / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_10m_bnmo2), (len(adata), len(infer_Xs_10m))\n", - "infer_Xs_10m_bnmo2.shape" + "assert infer_Xs_10m_bnmo2.shape == (8192, 256)" ] }, { @@ -701,21 +1079,18 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(22502, 768)" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_47840/4058871012.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " infer_Xs_106m = torch.load(result_path_106m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" + ] } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", "infer_Xs_106m = torch.load(result_path_106m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_106m), (len(adata), len(infer_Xs_106m))\n", - "infer_Xs_106m.shape" + "assert infer_Xs_106m.shape == (8192, 768)" ] }, { @@ -724,22 +1099,18 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(22502, 256)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_47840/3286066556.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " infer_Xs_10m_random = torch.load(results_path_10m_random / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" + ] } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", - "import torch\n", "infer_Xs_10m_random = torch.load(results_path_10m_random / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", "assert len(adata) == len(infer_Xs_10m_random), (len(adata), len(infer_Xs_10m_random))\n", - "infer_Xs_10m_random.shape" + "assert infer_Xs_10m_random.shape == (8192, 256)" ] }, { @@ -752,7 +1123,7 @@ "import numpy as np\n", "# Now fetch the class labels and raw expression for the same dataset. These are used as labels in classification and as one of our baselines.\n", "\n", - "infer_metadata = pd.read_csv(data_dir/'features.csv')\n", + "infer_metadata = adata.obs\n", "raw_Xs = np.asarray(adata.X.todense())\n", "# Here we perform a norm over the total counts for each cell, adding a pseudocount to assist with the following logarithm.\n", "normed_Xs = (raw_Xs + 1) / raw_Xs.sum(axis=1, keepdims=True)\n", @@ -768,7 +1139,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_109448/2938980837.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", + "/tmp/ipykernel_47840/771671311.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", " ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='right')\n" ] }, @@ -784,7 +1155,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -794,7 +1165,7 @@ } ], "source": [ - "# Now we look at our dataset, how is the distribution of cell counts? Its clear that certain celltypes dominate the dataset, this is good to keep in mind when investigating models. \n", + "# Now we look at our dataset, how is the distribution of cell counts? Its clear that certain celltypes dominate the dataset, this is good to keep in mind when investigating models.\n", "# we expect the macro averages and F1-score to be the most reliable metrics for overall performance.\n", "from collections import Counter\n", "import seaborn as sb\n", @@ -816,7 +1187,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 1 29 1 ... 14 12 3]\n" + "[ 1 1 19 ... 17 14 14]\n" ] } ], @@ -825,7 +1196,7 @@ "from sklearn.preprocessing import LabelEncoder\n", "label_encoder = LabelEncoder()\n", "integer_labels = label_encoder.fit_transform(labels)\n", - "print(integer_labels) " + "print(integer_labels)" ] }, { @@ -835,7 +1206,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGsCAYAAACB/u5dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAbNklEQVR4nO3de3BU9fn48SdgWaEkEYSo1Ii3esELWhDESweUigw60FraoVQj42i1WGuxF1Md0VaN2o7FKsVLW/BShbGttlWU8QqdCoogVnC8w4SigNcEcGbBZL9/+DO/UkHZ8Fl2F16vmfPHnj179skZSd6ePbtbkcvlcgEAkECHYg8AAGw/hAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJBM0cJizpw5ceqpp0avXr2ioqIi7r///rz3MWvWrDj66KOjsrIyevbsGaeddlosW7Ys+awAwJYpWlisW7cu+vbtG5MnT27X45cuXRojR46ME044IRYtWhSzZs2Kd955J77xjW8knhQA2FIVpfAlZBUVFXHffffFqFGj2tZls9m45JJL4p577okPPvggDj300Lj22mtj8ODBERHx5z//OcaMGRPZbDY6dPi4j/7xj3/EyJEjI5vNxhe+8IUi/CQAsGMr2Wsszj///Jg7d25Mnz49/v3vf8fo0aPj5JNPjldffTUiIvr16xcdOnSIqVOnRktLSzQ1NcWdd94ZQ4cOFRUAUCQlecaisbEx9t1332hsbIxevXq1bTd06NAYMGBAXH311RERMXv27PjWt74V7777brS0tMSgQYNi5syZscsuuxThpwAASvKMxQsvvBAtLS1xwAEHRNeuXduW2bNnx+uvvx4REStXroyzzz476urqYv78+TF79uzo1KlTfPOb34wSaCUA2CHtVOwBNmXt2rXRsWPHWLBgQXTs2HGj+7p27RoREZMnT47q6uq47rrr2u676667ora2Np5++uk4+uijt+nMAECJhsWRRx4ZLS0tsXr16jj++OM3uc2HH37YdtHmJz6JkNbW1oLPCAB8WtFeClm7dm0sWrQoFi1aFBEfv3100aJF0djYGAcccECMHTs2zjjjjPjrX/8aS5cujWeeeSYaGhriwQcfjIiIESNGxPz58+MXv/hFvPrqq7Fw4cIYN25c9O7dO4488shi/VgAsEMr2sWbTz75ZAwZMuRT6+vq6mLatGmxYcOGuPLKK+OOO+6IFStWRI8ePeLoo4+OK664Ig477LCIiJg+fXpcd9118corr0SXLl1i0KBBce2118ZBBx20rX8cACBK5F0hAMD2oSTfFQIAlCdhAQAks83fFdLa2hpvvvlmVFZWRkVFxbZ+egCgHXK5XKxZsyZ69er1qXdl/rdtHhZvvvlm1NbWbuunBQASWL58eey5556bvX+bh0VlZWVEfDxYVVXVtn56AKAdmpubo7a2tu3v+OZs87D45OWPqqoqYQEAZebzLmNw8SYAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIJlt/rXplL+9L36w2CPkbdk1I4o9AsAOwRkLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAyeYfFihUr4rvf/W7suuuu0blz5zjssMPi2WefLcRsAECZ2Smfjd9///049thjY8iQIfHQQw9Fz54949VXX41u3boVaj4AoIzkFRbXXntt1NbWxtSpU9vW7bPPPsmHAgDKU14vhfz973+P/v37x+jRo6OmpiaOPPLIuO222z7zMdlsNpqbmzdaAIDtU15h8cYbb8SUKVPiy1/+csyaNSvOO++8uOCCC+L222/f7GMaGhqiurq6bamtrd3qoQGA0lSRy+VyW7pxp06don///vHUU0+1rbvgggti/vz5MXfu3E0+JpvNRjabbbvd3NwctbW10dTUFFVVVVsxOsWy98UPFnuEvC27ZkSxRwAoa83NzVFdXf25f7/zOmOxxx57RJ8+fTZad/DBB0djY+NmH5PJZKKqqmqjBQDYPuUVFscee2y8/PLLG6175ZVXonfv3kmHAgDKU15h8aMf/SjmzZsXV199dbz22mtx9913x6233hrjx48v1HwAQBnJKyyOOuqouO++++Kee+6JQw89NH75y1/GpEmTYuzYsYWaDwAoI3ldvJnCll78Qekqx4s3y5WLToFSUZCLNwEAPouwAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEgmr7C4/PLLo6KiYqPloIMOKtRsAECZ2SnfBxxyyCHx6KOP/v8d7JT3LgCA7VTeVbDTTjvF7rvvXohZAIAyl/c1Fq+++mr06tUr9t133xg7dmw0NjZ+5vbZbDaam5s3WgCA7VNeYTFw4MCYNm1aPPzwwzFlypRYunRpHH/88bFmzZrNPqahoSGqq6vbltra2q0eGgAoTRW5XC7X3gd/8MEH0bt377j++uvjrLPO2uQ22Ww2stls2+3m5uaora2NpqamqKqqau9TU0R7X/xgsUfYYSy7ZkSxRwCIiI//fldXV3/u3++tuvJyl112iQMOOCBee+21zW6TyWQik8lszdMAAGViqz7HYu3atfH666/HHnvskWoeAKCM5RUWP/7xj2P27NmxbNmyeOqpp+LrX/96dOzYMcaMGVOo+QCAMpLXSyH/+c9/YsyYMfHuu+9Gz54947jjjot58+ZFz549CzUfAFBG8gqL6dOnF2oOAGA74LtCAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhmq8LimmuuiYqKirjwwgsTjQMAlLN2h8X8+fPjlltuicMPPzzlPABAGWtXWKxduzbGjh0bt912W3Tr1i31TABAmWpXWIwfPz5GjBgRQ4cO/dxts9lsNDc3b7QAANunnfJ9wPTp02PhwoUxf/78Ldq+oaEhrrjiirwHAwDKT15nLJYvXx4//OEP409/+lPsvPPOW/SY+vr6aGpqaluWL1/erkEBgNKX1xmLBQsWxOrVq+MrX/lK27qWlpaYM2dO3HTTTZHNZqNjx44bPSaTyUQmk0kzLQBQ0vIKixNPPDFeeOGFjdaNGzcuDjrooPjZz372qagAAHYseYVFZWVlHHrooRut++IXvxi77rrrp9YDADsen7wJACST97tC/teTTz6ZYAwAYHvgjAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyeQVFlOmTInDDz88qqqqoqqqKgYNGhQPPfRQoWYDAMpMXmGx5557xjXXXBMLFiyIZ599Nk444YQYOXJkLFmypFDzAQBlZKd8Nj711FM3un3VVVfFlClTYt68eXHIIYckHQwAKD95hcV/a2lpiXvvvTfWrVsXgwYN2ux22Ww2stls2+3m5ub2PiUAUOLyvnjzhRdeiK5du0Ymk4lzzz037rvvvujTp89mt29oaIjq6uq2pba2dqsGBgBKV95hceCBB8aiRYvi6aefjvPOOy/q6urixRdf3Oz29fX10dTU1LYsX758qwYGAEpX3i+FdOrUKfbff/+IiOjXr1/Mnz8/brjhhrjllls2uX0mk4lMJrN1UwIAZWGrP8eitbV1o2soAIAdV15nLOrr62P48OGx1157xZo1a+Luu++OJ598MmbNmlWo+QCAMpJXWKxevTrOOOOMeOutt6K6ujoOP/zwmDVrVnzta18r1HwAQBnJKyz+8Ic/FGoOAGA74LtCAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMnmFRUNDQxx11FFRWVkZNTU1MWrUqHj55ZcLNRsAUGbyCovZs2fH+PHjY968efHII4/Ehg0b4qSTTop169YVaj4AoIzslM/GDz/88Ea3p02bFjU1NbFgwYL46le/mnQwAKD85BUW/6upqSkiIrp3777ZbbLZbGSz2bbbzc3NW/OUAEAJa/fFm62trXHhhRfGscceG4ceeuhmt2toaIjq6uq2pba2tr1PCQCUuHaHxfjx42Px4sUxffr0z9yuvr4+mpqa2pbly5e39ykBgBLXrpdCzj///HjggQdizpw5seeee37mtplMJjKZTLuGAwDKS15hkcvl4gc/+EHcd9998eSTT8Y+++xTqLkAgDKUV1iMHz8+7r777vjb3/4WlZWVsXLlyoiIqK6ujs6dOxdkQACgfOR1jcWUKVOiqakpBg8eHHvssUfbMmPGjELNBwCUkbxfCgEA2BzfFQIAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZHYq9gA7ur0vfrDYIwBAMs5YAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACCZvMNizpw5ceqpp0avXr2ioqIi7r///gKMBQCUo7zDYt26ddG3b9+YPHlyIeYBAMpY3l9CNnz48Bg+fHghZgEAylzBv900m81GNpttu93c3FzopwQAiqTgF282NDREdXV121JbW1vopwQAiqTgYVFfXx9NTU1ty/Llywv9lABAkRT8pZBMJhOZTKbQTwMAlACfYwEAJJP3GYu1a9fGa6+91nZ76dKlsWjRoujevXvstddeSYcDAMpL3mHx7LPPxpAhQ9puT5gwISIi6urqYtq0ackGAwDKT95hMXjw4MjlcoWYBQAoc66xAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACQjLACAZIQFAJCMsAAAkhEWAEAywgIASEZYAADJCAsAIBlhAQAkIywAgGSEBQCQjLAAAJIRFgBAMsICAEhmp2IPkNLeFz9Y7BEAYIfWrjMWkydPjr333jt23nnnGDhwYDzzzDOp5wIAylDeZyxmzJgREyZMiJtvvjkGDhwYkyZNimHDhsXLL78cNTU1hZgRdljleBZu2TUjij0CUER5n7G4/vrr4+yzz45x48ZFnz594uabb44uXbrEH//4x0LMBwCUkbzOWKxfvz4WLFgQ9fX1bes6dOgQQ4cOjblz527yMdlsNrLZbNvtpqamiIhobm5uz7yfqTX7YfJ9AvkpxL9toPg++bedy+U+c7u8wuKdd96JlpaW2G233TZav9tuu8VLL720ycc0NDTEFVdc8an1tbW1+Tw1UCaqJxV7AqCQ1qxZE9XV1Zu9v+DvCqmvr48JEya03W5tbY333nsvdt1116ioqNjq/Tc3N0dtbW0sX748qqqqtnp/OwLHrH0ct/Zx3NrHccufY9Y+W3rccrlcrFmzJnr16vWZ+8srLHr06BEdO3aMVatWbbR+1apVsfvuu2/yMZlMJjKZzEbrdtlll3yedotUVVX5DylPjln7OG7t47i1j+OWP8esfbbkuH3WmYpP5HXxZqdOnaJfv37x2GOPta1rbW2Nxx57LAYNGpTPrgCA7VDeL4VMmDAh6urqon///jFgwICYNGlSrFu3LsaNG1eI+QCAMpJ3WHz729+Ot99+Oy677LJYuXJlHHHEEfHwww9/6oLObSWTycTEiRM/9XILm+eYtY/j1j6OW/s4bvlzzNon9XGryH3e+0YAALaQLyEDAJIRFgBAMsICAEhGWAAAyZRtWFx11VVxzDHHRJcuXTb5gVvPP/98jBkzJmpra6Nz585x8MEHxw033LDtBy0xn3fcIiIaGxtjxIgR0aVLl6ipqYmf/OQn8dFHH23bQUvcK6+8EiNHjowePXpEVVVVHHfccfHEE08Ue6yy8OCDD8bAgQOjc+fO0a1btxg1alSxRyob2Ww2jjjiiKioqIhFixYVe5yStmzZsjjrrLNin332ic6dO8d+++0XEydOjPXr1xd7tJIzefLk2HvvvWPnnXeOgQMHxjPPPLNV+yvbsFi/fn2MHj06zjvvvE3ev2DBgqipqYm77rorlixZEpdccknU19fHTTfdtI0nLS2fd9xaWlpixIgRsX79+njqqafi9ttvj2nTpsVll122jSctbaecckp89NFH8fjjj8eCBQuib9++ccopp8TKlSuLPVpJ+8tf/hKnn356jBs3Lp5//vn417/+Fd/5zneKPVbZ+OlPf/q5H6fMx1566aVobW2NW265JZYsWRK/+c1v4uabb46f//znxR6tpMyYMSMmTJgQEydOjIULF0bfvn1j2LBhsXr16vbvNFfmpk6dmquurt6ibb///e/nhgwZUtiBysTmjtvMmTNzHTp0yK1cubJt3ZQpU3JVVVW5bDa7DScsXW+//XYuInJz5sxpW9fc3JyLiNwjjzxSxMlK24YNG3Jf+tKXcr///e+LPUpZmjlzZu6ggw7KLVmyJBcRueeee67YI5Wd6667LrfPPvsUe4ySMmDAgNz48ePbbre0tOR69eqVa2hoaPc+y/aMRXs0NTVF9+7diz1GSZs7d24cdthhG33g2bBhw6K5uTmWLFlSxMlKx6677hoHHnhg3HHHHbFu3br46KOP4pZbbomampro169fsccrWQsXLowVK1ZEhw4d4sgjj4w99tgjhg8fHosXLy72aCVv1apVcfbZZ8edd94ZXbp0KfY4ZcvfgI2tX78+FixYEEOHDm1b16FDhxg6dGjMnTu33fvdYcLiqaeeihkzZsQ555xT7FFK2sqVKz/1Kaqf3Haa/2MVFRXx6KOPxnPPPReVlZWx8847x/XXXx8PP/xwdOvWrdjjlaw33ngjIiIuv/zyuPTSS+OBBx6Ibt26xeDBg+O9994r8nSlK5fLxZlnnhnnnntu9O/fv9jjlK3XXnstbrzxxvje975X7FFKxjvvvBMtLS2b/J2/Nb/vSyosLr744qioqPjM5aWXXsp7v4sXL46RI0fGxIkT46STTirA5MVVqOO2o9nS45jL5WL8+PFRU1MT//znP+OZZ56JUaNGxamnnhpvvfVWsX+MbW5Lj1tra2tERFxyySVx2mmnRb9+/WLq1KlRUVER9957b5F/im1vS4/bjTfeGGvWrIn6+vpij1wS2vP7bsWKFXHyySfH6NGj4+yzzy7S5DuOvL8rpJAuuuiiOPPMMz9zm3333Tevfb744otx4oknxjnnnBOXXnrpVkxXulIet9133/1TVwSvWrWq7b7t2ZYex8cffzweeOCBeP/999u+Yvh3v/tdPPLII3H77bfHxRdfvA2mLR1betw+ia4+ffq0rc9kMrHvvvtGY2NjIUcsSfn89zZ37txPfY9D//79Y+zYsXH77bcXcMrSk+/vuzfffDOGDBkSxxxzTNx6660Fnq689OjRIzp27Nj2O/4Tq1at2qrf9yUVFj179oyePXsm29+SJUvihBNOiLq6urjqqquS7bfUpDxugwYNiquuuipWr14dNTU1ERHxyCOPRFVV1UZ/ELZHW3ocP/zww4j4+LXI/9ahQ4e2/yvfkWzpcevXr19kMpl4+eWX47jjjouIiA0bNsSyZcuid+/ehR6z5Gzpcfvtb38bV155ZdvtN998M4YNGxYzZsyIgQMHFnLEkpTP77sVK1bEkCFD2s6O/e+/2R1dp06dol+/fvHYY4+1ve27tbU1HnvssTj//PPbvd+SCot8NDY2xnvvvReNjY3R0tLS9p7u/fffP7p27RqLFy+OE044IYYNGxYTJkxoe72oY8eOSeOl3HzecTvppJOiT58+cfrpp8d1110XK1eujEsvvTTGjx/vGwP/n0GDBkW3bt2irq4uLrvssujcuXPcdtttsXTp0hgxYkSxxytZVVVVce6558bEiROjtrY2evfuHb/61a8iImL06NFFnq507bXXXhvd7tq1a0RE7LfffrHnnnsWY6SysGLFihg8eHD07t07fv3rX8fbb7/ddt/2fvY1HxMmTIi6urro379/DBgwICZNmhTr1q2LcePGtX+nW/9mleKoq6vLRcSnlieeeCKXy+VyEydO3OT9vXv3LurcxfZ5xy2Xy+WWLVuWGz58eK5z5865Hj165C666KLchg0bijd0CZo/f37upJNOynXv3j1XWVmZO/roo3MzZ84s9lglb/369bmLLrooV1NTk6usrMwNHTo0t3jx4mKPVVaWLl3q7aZbYOrUqZv8XVfGf/YK5sYbb8zttddeuU6dOuUGDBiQmzdv3lbtz9emAwDJeMEJAEhGWAAAyQgLACAZYQEAJCMsAIBkhAUAkIywAACSERYAQDLCAgBIRlgAAMkICwAgGWEBACTzf4NdJH4wKJz3AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -895,14 +1266,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" ] }, { @@ -910,11 +1285,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.789 (+/- 0.026)\n", - "precision: 0.682 (+/- 0.033)\n", - "recall: 0.573 (+/- 0.014)\n", - "f1_score: 0.593 (+/- 0.012)\n", - "roc_auc: 0.973 (+/- 0.007)\n" + "accuracy: 0.776 (+/- 0.035)\n", + "precision: 0.635 (+/- 0.043)\n", + "recall: 0.544 (+/- 0.024)\n", + "f1_score: 0.561 (+/- 0.032)\n", + "roc_auc: 0.970 (+/- 0.011)\n" ] } ], @@ -929,7 +1304,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -951,16 +1326,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" ] }, { @@ -968,11 +1345,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.418 (+/- 0.015)\n", - "precision: 0.204 (+/- 0.023)\n", - "recall: 0.100 (+/- 0.007)\n", - "f1_score: 0.089 (+/- 0.007)\n", - "roc_auc: 0.769 (+/- 0.014)\n" + "accuracy: 0.427 (+/- 0.025)\n", + "precision: 0.161 (+/- 0.028)\n", + "recall: 0.101 (+/- 0.010)\n", + "f1_score: 0.087 (+/- 0.011)\n", + "roc_auc: 0.751 (+/- 0.018)\n" ] } ], @@ -989,13 +1366,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_109448/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_47840/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1017,10 +1394,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" ] }, { @@ -1028,11 +1413,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.849 (+/- 0.018)\n", - "precision: 0.840 (+/- 0.020)\n", - "recall: 0.722 (+/- 0.019)\n", - "f1_score: 0.751 (+/- 0.015)\n", - "roc_auc: 0.990 (+/- 0.002)\n" + "accuracy: 0.839 (+/- 0.016)\n", + "precision: 0.788 (+/- 0.029)\n", + "recall: 0.677 (+/- 0.015)\n", + "f1_score: 0.702 (+/- 0.017)\n", + "roc_auc: 0.986 (+/- 0.006)\n" ] } ], @@ -1047,7 +1432,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1069,8 +1454,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" ] }, { @@ -1078,11 +1473,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.849 (+/- 0.021)\n", - "precision: 0.849 (+/- 0.029)\n", - "recall: 0.718 (+/- 0.031)\n", - "f1_score: 0.752 (+/- 0.028)\n", - "roc_auc: 0.989 (+/- 0.003)\n" + "accuracy: 0.834 (+/- 0.021)\n", + "precision: 0.790 (+/- 0.052)\n", + "recall: 0.675 (+/- 0.031)\n", + "f1_score: 0.703 (+/- 0.037)\n", + "roc_auc: 0.990 (+/- 0.007)\n" ] } ], @@ -1097,7 +1492,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1115,16 +1510,26 @@ "execution_count": 30, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.911 (+/- 0.016)\n", - "precision: 0.917 (+/- 0.019)\n", - "recall: 0.834 (+/- 0.019)\n", - "f1_score: 0.857 (+/- 0.019)\n", - "roc_auc: 0.995 (+/- 0.002)\n" + "accuracy: 0.906 (+/- 0.014)\n", + "precision: 0.916 (+/- 0.023)\n", + "recall: 0.820 (+/- 0.013)\n", + "f1_score: 0.845 (+/- 0.014)\n", + "roc_auc: 0.993 (+/- 0.005)\n" ] } ], @@ -1139,7 +1544,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1161,12 +1566,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_109448/805283967.py:42: FutureWarning: \n", + "/tmp/ipykernel_47840/3301380888.py:42: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", " sb.barplot(x='model', y='f1_score_mean', data=df, capsize=0.2, palette='viridis', ax=ax)\n", - "/tmp/ipykernel_109448/805283967.py:53: FutureWarning: \n", + "/tmp/ipykernel_47840/3301380888.py:53: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", @@ -1175,7 +1580,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1185,7 +1590,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1197,9 +1602,9 @@ "source": [ "data = {\n", " 'model': [\n", - " 'Baseline Logp1 PCA+RF', \n", + " 'Baseline Logp1 PCA+RF',\n", " '10M RandomWeights',\n", - " '10M parameters', \n", + " '10M parameters',\n", " '10M parameters BioNeMo2 re-trained',\n", " '106M parameters'],\n", " 'f1_score_mean': [\n", diff --git a/docs/docs/user-guide/examples/conftest.py b/docs/docs/user-guide/examples/conftest.py new file mode 100644 index 0000000000..ed7ba38376 --- /dev/null +++ b/docs/docs/user-guide/examples/conftest.py @@ -0,0 +1,23 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +def pytest_collectstart(collector): + if collector.fspath and collector.fspath.ext == ".ipynb": + collector.skip_compare += ( + "text/html", + "application/javascript", + "stderr", + ) diff --git a/docs/docs/user-guide/getting-started/SUMMARY.md b/docs/docs/user-guide/getting-started/SUMMARY.md index 12c3b28cb1..ba5fa64221 100644 --- a/docs/docs/user-guide/getting-started/SUMMARY.md +++ b/docs/docs/user-guide/getting-started/SUMMARY.md @@ -2,3 +2,4 @@ - [Access and Startup](access-startup.md) - [Initialization Guide](initialization-guide.md) - [Development](development.md) +- [Training Models](training-models.md) diff --git a/docs/docs/user-guide/getting-started/development.md b/docs/docs/user-guide/getting-started/development.md index f6be3bbd87..ce97a78cbe 100644 --- a/docs/docs/user-guide/getting-started/development.md +++ b/docs/docs/user-guide/getting-started/development.md @@ -56,6 +56,9 @@ The following components are present in each package: ## Model Training Process +!!! note + See also [Training Models](./training-models.md) + The process for pretraining models from BioNeMo involves running scripts located in the `scripts` directory. Each script exposes a Command-Line Interface (CLI) that contains and documents the options available for that model. diff --git a/docs/docs/user-guide/getting-started/index.md b/docs/docs/user-guide/getting-started/index.md index 372aab581f..adb790e94b 100644 --- a/docs/docs/user-guide/getting-started/index.md +++ b/docs/docs/user-guide/getting-started/index.md @@ -351,7 +351,7 @@ confirmed to be working with bionemo2 (and those that are tested in CI). To initialize these sub-modules when cloning the repo, add the `--recursive` flag to the git clone command: ```bash -git clone --recursive git@github.com:NVIDIA/bionemo-fw-ea.git +git clone --recursive git@github.com:NVIDIA/bionemo-framework.git ``` To download the pinned versions of these submodules within an existing git repository, run diff --git a/docs/docs/user-guide/getting-started/training-models.md b/docs/docs/user-guide/getting-started/training-models.md new file mode 100644 index 0000000000..85b1348508 --- /dev/null +++ b/docs/docs/user-guide/getting-started/training-models.md @@ -0,0 +1,215 @@ +# Training Models + +## Pydantic Configuration + +BioNeMo 2 provides two entrypoints for models with both argparse and pydantic. Both documented in the `Models` section below. +Pydantic based configuration is designed to accept a configuration yaml file as input, along with context specific +arguments (e.g., should we resume from existing checkpoints?). These YAML configs go through a Pydantic Validator, in +this case referred to as `MainConfig`. This Config is composed of several other Pydantic models, see the class +definition for details. To pre-populate a config with reasonable defaults for various standard models, we provide +'recipes.' These are simple methods that instantiate the config object and then serialize it to a YAML configuration +file. From this file, you may either submit it directly, or modify the various parameters to meet your usecase. For +example, Weights and biases, devices, precision, and dataset options are all extremely useful to modify. Then, you would +submit this config for training. + +These two workflows are packaged as executables when esm2 or geneformer are installed with pip. These commands will appear as: + +```bash +bionemo-geneformer-recipe +bionemo-esm2-recipe +bionemo-geneformer-train +bionemo-esm2-train +``` + +## ESM-2 + +### Running + +First off, we have a utility function for downloading full/test data and model checkpoints called `download_bionemo_data` that our following examples currently use. This will download the object if it is not already on your local system, and then return the path either way. For example if you run this twice in a row, you should expect the second time you run it to return the path almost instantly. + +**NOTE**: NVIDIA employees should use `pbss` rather than `ngc` for the data source. + +```bash +export MY_DATA_SOURCE="ngc" +``` + +or for NVIDIA internal employees with new data etc: + +```bash +export MY_DATA_SOURCE="pbss" +``` + +```bash +# The fastest transformer engine environment variables in testing were the following two +TEST_DATA_DIR=$(download_bionemo_data esm2/testdata_esm2_pretrain:2.0 --source $MY_DATA_SOURCE); \ +ESM2_650M_CKPT=$(download_bionemo_data esm2/650m:2.0 --source $MY_DATA_SOURCE); \ + +train_esm2 \ + --train-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/train_clusters_sanity.parquet \ + --train-database-path ${TEST_DATA_DIR}/2024_03_sanity/train_sanity.db \ + --valid-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/valid_clusters.parquet \ + --valid-database-path ${TEST_DATA_DIR}/2024_03_sanity/validation.db \ + --result-dir ./results \ + --experiment-name test_experiment \ + --num-gpus 1 \ + --num-nodes 1 \ + --val-check-interval 10 \ + --num-dataset-workers 1 \ + --num-steps 10 \ + --max-seq-length 1024 \ + --limit-val-batches 2 \ + --micro-batch-size 2 \ + --restore-from-checkpoint-path ${ESM2_650M_CKPT} +``` + +### Running with Pydantic configs + +Alternatively, we provide a validated and serialized configuration file entrypoint for executing the same workflow. These can be generated using the `bionemo-esm2-recipe` entrypoints. Recipes +are available for 8m, 650m, and 3b ESM2 models. You may select which preset config to use by setting the `--recipe` parameter. +The output is then a serialized configuration file that may be used in the associated `bionemo-esm2-train` commands. + +```bash +# The fastest transformer engine environment variables in testing were the following two +TEST_DATA_DIR=$(download_bionemo_data esm2/testdata_esm2_pretrain:2.0 --source $MY_DATA_SOURCE); \ +bionemo-esm2-recipe \ +--train-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/train_clusters_sanity.parquet \ +--train-database-path ${TEST_DATA_DIR}/2024_03_sanity/train_sanity.db \ +--valid-cluster-path ${TEST_DATA_DIR}/2024_03_sanity/valid_clusters.parquet \ +--valid-database-path ${TEST_DATA_DIR}/2024_03_sanity/validation.db \ +--result-dir ./results \ +--dest my_config.yaml\ +--recipe esm2_8m_recipe +``` + +> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.yaml as you see fit + +> NOTE: To continue training from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the YAML with the correct field to ensure pretraining is initialized from an existing checkpoint. + +To submit a training job with the passed config, first update the yaml file with any additional execution parameters +of your choosing: number of devices, workers, steps, etc. Second, invoke our training entrypoint. To do this, we need +three things: + +- Configuration file, the YAML produced by the previous step +- Model config type, in this case the pretraining config. This will validate the arguments in the config YAML against + those required for pretraining. Alternatively, things like fine-tuning with custom task heads may be specified here. + This allows for mixing/matching Data Modules with various tasks. +- Data Config type, this specifies how to parse, validate, and prepare the DataModule. This may change depending on task, +for example, pretraining ESM2 uses a protein cluster oriented sampling method. In the case of inference or fine-tuning +a pretrained model, a simple fasta file may be sufficient. There is a one-to-one relationship between DataConfig types +and DataModule types. + +> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config YAML and populate it with your WandB details. + +``` +bionemo-esm2-train \ +--data-config-cls bionemo.esm2.run.config_models.ESM2DataConfig \ +--model-config-cls bionemo.esm2.run.config_models.ExposedESM2PretrainConfig \ +--config my_config.yaml +``` + +> NOTE: both data-config-cls and model-config-cls have default values corresponding to ESM2DataConfig and ExposedESM2PretrainingConfig + +DataConfigCls and ModelConfigCls can also refer to locally defined types by the user. As long as python knows how to import +the specified path, they may be configured. For example, you may have a custom Dataset/DataModule that you would like to +mix with an existing recipe. In this case, you define a DataConfig object with the generic specified as your DataModule +type, and then pass in the config type to the training recipe. + +## Geneformer + +### Running + +Similar to ESM-2, you can download the dataset and checkpoint through our utility function. + +```bash +TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20241203 --source $MY_DATA_SOURCE); \ +GENEFORMER_10M_CKPT=$(download_bionemo_data geneformer/10M_240530:2.0 --source $MY_DATA_SOURCE); \ +train_geneformer \ + --data-dir ${TEST_DATA_DIR}/cellxgene_2023-12-15_small_processed_scdl \ + --result-dir ./results \ + --restore-from-checkpoint-path ${GENEFORMER_10M_CKPT} \ + --experiment-name test_experiment \ + --num-gpus 1 \ + --num-nodes 1 \ + --val-check-interval 10 \ + --num-dataset-workers 0 \ + --num-steps 55 \ + --seq-length 128 \ + --limit-val-batches 2 \ + --micro-batch-size 2 +``` + +To fine-tune, you to specify a different combination of model and loss. Pass the path to the outputted config file from the previous step as the `--restore-from-checkpoint-path`, and also change +`--training-model-config-class` to the newly created model-config-class. + +While no CLI option currently exists to hot swap in different data modules and processing functions _now_, you could +copy the `sub-projects/bionemo-geneformer/geneformer/scripts/train_geneformer.py` and modify the DataModule class that gets initialized. + +Simple fine-tuning example (**NOTE**: please change `--restore-from-checkpoint-path` to be the checkpoint directory path that was output last +by the previous train run) + +```bash +TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20241203 --source $MY_DATA_SOURCE); \ +train_geneformer \ + --data-dir ${TEST_DATA_DIR}/cellxgene_2023-12-15_small_processed_scdl \ + --result-dir ./results \ + --experiment-name test_finettune_experiment \ + --num-gpus 1 \ + --num-nodes 1 \ + --val-check-interval 10 \ + --num-dataset-workers 0 \ + --num-steps 55 \ + --seq-length 128 \ + --limit-val-batches 2 \ + --micro-batch-size 2 \ + --training-model-config-class FineTuneSeqLenBioBertConfig \ + --restore-from-checkpoint-path results/test_experiment/dev/checkpoints/test_experiment--val_loss=4.3506-epoch=1-last +``` + +### Running with Pydantic configs + +Alternatively, we provide a validated and serialized configuration file entrypoint for executing the same workflow. Recipes +are available for 10m, and 106m geneformer models. Additionally we provide an example recipe of finetuning, where the objective +is to 'regress' on token IDs rather than the traditional masked language model approach. In practice, you will likely +need to implement your own DataModule, DataConfig, and Finetuning model. You can use the same overall approach, but with +customizations for your task. + +```bash +TEST_DATA_DIR=$(download_bionemo_data single_cell/testdata-20241203 --source $MY_DATA_SOURCE); \ +bionemo-geneformer-recipe \ + --recipe 10m-pretrain \ + --dest my_config.json \ + --data-path ${TEST_DATA_DIR}/cellxgene_2023-12-15_small_processed_scdl \ + --result-dir ./results +``` + +> ⚠️ **IMPORTANT:** Inspect and edit the contents of the outputted my_config.yaml as you see fit + +> NOTE: To pretrain from an existing checkpoint, simply pass in the path --initial-ckpt-path to the recipe command. This will populate the YAML with the correct field to ensure pretraining is initialized from an existing checkpoint. + +To submit a training job with the passed config, first update the yaml file with any additional execution parameters +of your choosing: number of devices, workers, steps, etc. Second, invoke our training entrypoint. To do this, we need +three things: + +- Configuration file, the YAML produced by the previous step +- Model config type, in this case the pretraining config. This will validate the arguments in the config YAML against + those required for pretraining. Alternatively, things like fine-tuning with custom task heads may be specified here. + This allows for mixing/matching Data Modules with various tasks. +- Data Config type, this specifies how to parse, validate, and prepare the DataModule. This may change depending on task, +for example, while fine-tuning you may want to use a custom Dataset/DataModule that includes PERTURB-seq. In this case, +the default pretraining DataConfig and DataModule will be insufficient. See ESM2 for additional example usecases. + +> ⚠️ **Warning:** This setup does NO configuration of Weights and Biases. Edit your config YAML and populate it with your WandB details. + +```bash +bionemo-geneformer-train \ +--data-config-cls bionemo.geneformer.run.config_models.GeneformerPretrainingDataConfig \ +--model-config-cls bionemo.geneformer.run.config_models.ExposedGeneformerPretrainConfig \ +--config my_config.yaml +``` + +> NOTE: both data-config-cls and model-config-cls have default values corresponding to GeneformerPretrainingDataConfig and ExposedGeneformerPretrainConfig + +DataConfigCls and ModelConfigCls can also refer to locally defined types by the user. As long as python knows how to import +the specified path, they may be configured. For example, you may have a custom Dataset/DataModule that you would like to +mix with an existing recipe. In this case, you define a DataConfig object with the generic specified as your DataModule +type, and then pass in the config type to the training recipe. diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index 4b50d623bb..6adbf103cc 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -91,6 +91,8 @@ markdown_extensions: options: custom_icons: - overrides/.icons + - pymdownx.tabbed: + alternate_style: true - def_list - admonition - footnotes diff --git a/docs/requirements.txt b/docs/requirements.txt index 7a51be3a98..dad30202a1 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -9,3 +9,4 @@ mkdocs-include-dir-to-nav mkdocs-literate-nav mkdocs-site-urls mike +mistune==3.0.2 # temporary pin until https://github.com/lepture/mistune/issues/403 is resolved. diff --git a/internal/scripts/README.md b/internal/scripts/README.md new file mode 100644 index 0000000000..813786d620 --- /dev/null +++ b/internal/scripts/README.md @@ -0,0 +1,43 @@ +# Scripts for commonly performed bionemo-framework actions. + +## First Time Setup + +After cloning the repository, you need to run the setup script **first**: + +```bash +./internal/scripts/setup_env_file.sh +``` + +This will return an exit code of 1 on a first time run. + +## Release Image Building + +To build the release image, run the following script: + +```bash +DOCKER_BUILDKIT=1 ./ci/scripts/build_docker_image.sh \ + -regular-docker-builder \ + -image-name "nvcr.io/nvidian/cvai_bnmo_trng/bionemo:bionemo2-$(git rev-parse HEAD)" +``` + +## Development Image Building + +To build the development image, run the following script: + +```bash +./internal/scripts/build_dev_image.sh +``` + +## Interactive Shell in Development Image + +After building the development image, you can start a container from it and open a bash shell in it by executing: + +```bash +./internal/scripts/run_dev.sh +``` + +## Testing Locally + +Inside the development container, run `./ci/scripts/static_checks.sh` to validate that code changes will pass the code +formatting and license checks run during CI. In addition, run the longer `./ci/scripts/run_pytest.sh` script to run unit +tests for all sub-packages. diff --git a/requirements-test.txt b/requirements-test.txt index b8663cecf6..567b990cb7 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -8,3 +8,8 @@ awscli==1.33.33 nbval==0.11.0 # For NvFaidx equivalence tests pyfaidx==0.8.1.3 + +# Temporary pin for pytorch-lightning until megatron callbacks in ProgressPrinter can get fixed. +# See https://nvidia.slack.com/archives/C02A7LYGHK8/p1734727482697309 +pytorch-lightning<2.5.0 +lightning<2.5.0 diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml index bb3b4467e3..d93139d756 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml @@ -7,6 +7,33 @@ description: > A pretrained 650M parameter ESM2 model. See https://ngc.nvidia.com/catalog/models/nvidia:clara:esm2nv650m. +- tag: nv_3b:2.1 + ngc: "nvidia/clara/esm2nv3b:2.1" + ngc_registry: model + pbss: "s3://general-purpose/esm2/checkpoints/3b/esm2_3b_checkpoint.tar.gz" + sha256: a79327a4054bf8d1d7075e1b3c961dbc503da02d72ed15f707d9cbbd49d181b6 # pragma: allowlist secret + owner: Peter St John + description: > + An ESM-2 3B model pre-trained on NVIDIA's train/test data split. + +- tag: nv_650m:2.1 + ngc: "nvidia/clara/esm2nv650m:2.1" + ngc_registry: model + pbss: "s3://general-purpose/esm2/checkpoints/650m/esm2_650m_checkpoint.tar.gz" + sha256: b83e9b5d62f1499b443817c5cd0facd3bdd4013a51a897e05e17228bf650befe # pragma: allowlist secret + owner: Peter St John + description: > + An ESM-2 650M model pre-trained on NVIDIA's train/test data split. + +- tag: nv_8m:2.0 + ngc: "nvidia/clara/esm2nv8m:2.0" + ngc_registry: model + pbss: "s3://general-purpose/esm2/checkpoints/8m/esm2_8m_checkpoint.tar.gz" + sha256: b4ea4d52eea8a25d2c2838617ff678f0da22d384cee195b0c192686816078dcd # pragma: allowlist secret + owner: Peter St John + description: > + An ESM-2 8M model pre-trained on NVIDIA's train/test data split. + - tag: 650m:2.0 ngc: nvidia/clara/esm2nv650m:2.0 ngc_registry: model diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/scdl.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/scdl.yaml index f63fc33fc9..632b1d4843 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/scdl.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/scdl.yaml @@ -5,3 +5,11 @@ sha256: 7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9 # pragma: allowlist secret owner: Polina Binder description: Sample test data for SCDL. + +- tag: sample_scdl_feature_ids + ngc: nvidia/clara/scdl_sample_test_feature_ids:1.0 + ngc_registry: resource + pbss: s3://bionemo-ci/test-data/scdl_sample_test_feat_ids.tar.gz + sha256: 9020ba336dbfe33bddadba26ca0cde49958cbd73c5ad44f0960a5a4837c9db26 # pragma: allowlist secret + owner: Savitha Srinivasan + description: Sample test data for SCDL with feature IDs appended. diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/single_cell.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/single_cell.yaml index 80e8d17008..720369393c 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/single_cell.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/single_cell.yaml @@ -21,3 +21,11 @@ sha256: ab038b184de52e53ff7bcea5e01d97d55944c507db88c0495bdf9e5e9e0303a4 # pragma: allowlist secret owner: John St John description: Golden values for geneformer QA model. + +- tag: testdata-20241203 + ngc: nvidia/clara/singlecell-testdata:2.0 + ngc_registry: resource + pbss: "s3://bionemo-ci/test-data/singlecell/singlecell-scdltestdata-20241203.tar.gz" + sha256: d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3 # pragma: allowlist secret + owner: Savitha Srinivasan + description: Test data for single cell models in SCDL Memmap format. diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb index 9d4dcf5cfe..cd7d99ad72 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb @@ -6,8 +6,8 @@ "metadata": {}, "outputs": [], "source": [ - "from pathlib import Path\n", "import tempfile\n", + "from pathlib import Path\n", "\n", "from bionemo.core.data.load import load" ] @@ -21,14 +21,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Downloading data from 'nvidia/clara/scdl_sample_test:1.0' to file '/tmp/tmpqif5bfww/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz'.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Untarring contents of '/tmp/tmpqif5bfww/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz' to '/tmp/tmpqif5bfww/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz.untar'\n" + "Downloading data from 'nvidia/clara/scdl_sample_test:1.0' to file '/tmp/tmp7nmjzz19/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz'.\n", + "Untarring contents of '/tmp/tmp7nmjzz19/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz' to '/tmp/tmp7nmjzz19/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz.untar'\n" ] }, { @@ -36,11 +30,11 @@ "output_type": "stream", "text": [ "{\n", - " \"download_end\": \"2024-12-03 18:39:20\",\n", - " \"download_start\": \"2024-12-03 18:39:03\",\n", - " \"download_time\": \"17s\",\n", + " \"download_end\": \"2025-01-03 15:16:48\",\n", + " \"download_start\": \"2025-01-03 15:16:47\",\n", + " \"download_time\": \"0s\",\n", " \"files_downloaded\": 1,\n", - " \"local_path\": \"/tmp/tmpqif5bfww/tmprn0ysh0w/scdl_sample_test_v1.0\",\n", + " \"local_path\": \"/tmp/tmp7nmjzz19/tmpfuw2obcq/scdl_sample_test_v1.0\",\n", " \"size_downloaded\": \"964.91 KB\",\n", " \"status\": \"COMPLETED\"\n", "}\n" @@ -51,26 +45,6 @@ "with tempfile.TemporaryDirectory() as cache_dir:\n", " load(\"scdl/sample\", source=\"ngc\", cache_dir=Path(cache_dir))" ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Downloading data from 's3://bionemo-ci/test-data/scdl_sample_test.tar.gz' to file '/tmp/tmpl6cgwhyn/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz'.\n", - "s3://bionemo-ci/test-data/scdl_sample_test.tar.gz: 100%|██████████| 988k/988k [00:00<00:00, 2.70MB/s]\n", - "Untarring contents of '/tmp/tmpl6cgwhyn/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz' to '/tmp/tmpl6cgwhyn/7a4237537bf535dfa00301ce8cc7073e0a23d5bc8aa902ad65db9f51b57a6df9-scdl_sample_test.tar.gz.untar'\n" - ] - } - ], - "source": [ - "with tempfile.TemporaryDirectory() as cache_dir:\n", - " load(\"scdl/sample\", source=\"pbss\", cache_dir=Path(cache_dir))" - ] } ], "metadata": { @@ -89,7 +63,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/attention.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/attention.py deleted file mode 100644 index 63d93448e1..0000000000 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/attention.py +++ /dev/null @@ -1,365 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import os -from typing import Callable, Optional, Sequence, Union - -import torch -from megatron.core import parallel_state, tensor_parallel -from megatron.core.extensions.transformer_engine import TEDotProductAttention -from megatron.core.packed_seq_params import PackedSeqParams -from megatron.core.parallel_state import ( - get_context_parallel_global_ranks, - get_context_parallel_group, - get_tensor_model_parallel_group, -) -from megatron.core.tensor_parallel import get_cuda_rng_tracker -from megatron.core.transformer.dot_product_attention import DotProductAttention -from megatron.core.transformer.enums import AttnMaskType -from megatron.core.transformer.transformer_config import TransformerConfig -from megatron.core.utils import get_te_version, is_te_min_version -from torch import Tensor - - -__all__: Sequence[str] = ("ESM2DotProductAttention", "ESM2TEDotProductAttention") - - -class ESM2TEDotProductAttention(TEDotProductAttention): - """ESM2-Specific transformer engine core attention. - - Override the softmax_scale to 1.0 to match the ESM2 implementation while keeping the rest from the original TEDotProductAttention. - """ - - def __init__( - self, - config: TransformerConfig, - layer_number: int, - attn_mask_type: AttnMaskType, - attention_type: str, - attention_dropout: float | None = None, - softmax_scale: float = 1.0, - k_channels: int | None = None, - v_channels: int | None = None, - cp_comm_type: str = "p2p", - ): - """Initialize ESM2TEDotProductAttention.""" - self.config = config - self.te_forward_mask_type = False - self.qkv_format: str = "sbhd" - - if self.config.apply_query_key_layer_scaling != bool(int(os.getenv("NVTE_APPLY_QK_LAYER_SCALING", "0"))): - raise ValueError( - f"apply_query_key_layer_scaling is {self.config.apply_query_key_layer_scaling} " - f"but environment variable NVTE_APPLY_QK_LAYER_SCALING is " - f"{os.getenv('NVTE_APPLY_QK_LAYER_SCALING')}. Transformer Engine does not support " - f"setting query key layer scaling via argument, so these two must match." - ) - - extra_kwargs = {} - if is_te_min_version("0.11.0"): - extra_kwargs["num_gqa_groups"] = self.config.num_query_groups - elif self.config.num_query_groups != self.config.num_attention_heads: - raise ValueError( - f"Transformer Engine v{get_te_version()} does not support Grouped Query Attention, " - f"use a newer version of Transformer Engine. " - f"(num_query_groups ({self.config.num_query_groups}) != " - f"num_attention_heads ({self.config.num_attention_heads}))" - ) - - if is_te_min_version("0.10.0"): - extra_kwargs["attention_type"] = attention_type - # older version don't need attention_type - - if is_te_min_version("0.12.0", check_equality=False): - self.te_forward_mask_type = True - - # Only Transformer-Engine version >= 1.0.0 supports context parallelism - if is_te_min_version("1.0.0"): - if getattr(TEDotProductAttention, "cp_stream") is None: - TEDotProductAttention.cp_stream = torch.cuda.Stream() - extra_kwargs["cp_group"] = get_context_parallel_group(check_initialized=False) - extra_kwargs["cp_global_ranks"] = get_context_parallel_global_ranks(check_initialized=False) - extra_kwargs["cp_stream"] = TEDotProductAttention.cp_stream - if is_te_min_version("1.10.0"): - if cp_comm_type is None: - extra_kwargs["cp_comm_type"] = "p2p" - else: - extra_kwargs["cp_comm_type"] = cp_comm_type - else: - assert ( - self.config.context_parallel_size == 1 - ), "Only Transformer-Engine version >= 1.0.0 supports context parallelism!" - - if self.config.deterministic_mode: - if int(os.getenv("NVTE_ALLOW_NONDETERMINISTIC_ALGO", "1")) != 0: - raise RuntimeError( - "deterministic_mode is on and we are using DotProductAttention from " - "Transformer Engine, but NVTE_ALLOW_NONDETERMINISTIC_ALGO is not 0. " - f"Currently set to: {os.getenv('NVTE_ALLOW_NONDETERMINISTIC_ALGO', 'not set')}." - ) - - if config.window_size is not None: - # Check version - assert is_te_min_version("1.2.0"), ( - f"Transformer-Engine v{get_te_version()} must be >= 1.2.0 to support" "sliding window attention." - ) - extra_kwargs["window_size"] = config.window_size - - if is_te_min_version("1.10.0"): - # TE 1.10.0 introduces the ability to set the different k and v channels - kv_channels = ( - (k_channels, v_channels) - if k_channels is not None and v_channels is not None - else self.config.kv_channels - ) - else: - kv_channels = self.config.kv_channels - - extra_kwargs["softmax_scale"] = softmax_scale - - super(TEDotProductAttention, self).__init__( - num_attention_heads=self.config.num_attention_heads, - kv_channels=kv_channels, - attention_dropout=(self.config.attention_dropout if attention_dropout is None else attention_dropout), - attn_mask_type=attn_mask_type.name, - sequence_parallel=self.config.sequence_parallel, - tp_size=self.config.tensor_model_parallel_size, - get_rng_state_tracker=(get_cuda_rng_tracker if get_cuda_rng_tracker().is_initialized() else None), - tp_group=get_tensor_model_parallel_group(check_initialized=False), - layer_number=layer_number, - **extra_kwargs, - ) - - -class ESM2DotProductAttention(DotProductAttention): - """ESM2-Specific core attention. - - Region where selective activation recomputation is applied. - This region is memory intensive but less compute intensive which - makes activation checkpointing more efficient for LLMs (20B+). - See Reducing Activation Recomputation in Large Transformer Models: - https://arxiv.org/abs/2205.05198 for more details. - - We use the following notation: - h: hidden size - n: number of attention heads - p: number of tensor model parallel partitions - b: batch size - s: sequence length - """ - - def __init__( - self, - config: TransformerConfig, - layer_number: int, - attn_mask_type: AttnMaskType, - attention_type: str, - attention_dropout: Optional[float] = None, - ) -> None: - """Initializes the Attention class. - - Args: - config: The configuration object for the transformer. - layer_number: The layer number of the attention module. - attn_mask_type: The type of attention mask to be used. - attention_type: The type of attention mechanism. - attention_dropout: The dropout rate for attention weights. Defaults to None. - """ - super().__init__( - config=config, - layer_number=layer_number, - attn_mask_type=attn_mask_type, - attention_type=attention_type, - attention_dropout=attention_dropout, - ) - - def forward( - self, - query: Tensor, - key: Tensor, - value: Tensor, - attention_mask: Tensor, - attn_mask_type: Optional[AttnMaskType] = None, - packed_seq_params: Optional[PackedSeqParams] = None, - ): - """Forward pass of the ESM2DotProductAttention module. - - Args: - query: The query tensor of shape [sq, b, np, hn]. - key: The key tensor of shape [sk, b, ng, hn]. - value: The value tensor of shape [sk, b, ng, hn]. - attention_mask: The attention mask tensor of shape [b, np, sq, sk]. - attn_mask_type: The attention mask type, currently unused. Defaults to None. - packed_seq_params: The packed sequence parameters. These are used for context parallelism so will be needed - to be implemented if we want to support this. Defaults to None. - - Returns: - Tensor: The context tensor of shape [sq, b, hp]. - """ - if packed_seq_params is not None: - raise ValueError( - "Packed sequence is not supported by DotProductAttention. " "Please use TEDotProductAttention instead." - ) - - # =================================== - # Raw attention scores. [b, n/p, s, s] - # =================================== - - # expand the key and value [sk, b, ng, hn] -> [sk, b, np, hn] - # This is a noop for normal attention where ng == np. When using group query attention this - # creates a view that has the keys and values virtually repeated along their dimension to - # match the number of queries. - - # attn_mask_type is not used. - if (np_ng := self.num_attention_heads_per_partition // self.num_query_groups_per_partition) > 1: - key = key.repeat_interleave(np_ng, dim=2) - value = value.repeat_interleave(np_ng, dim=2) - - # [b, np, sq, sk] - b, np, sq, sk = query.size(1), query.size(2), query.size(0), key.size(0) - - # [sq, b, np, hn] -> [sq, b * np, hn] - # This will be a simple view when doing normal attention, but in group query attention - # the key and value tensors are repeated to match the queries so you can't use simple strides - # to extract the queries. - query = query.reshape(sq, b * np, -1) - # [sk, b, np, hn] -> [sk, b * np, hn] - key = key.view(sk, b * np, -1) - - # preallocting input tensor: [b * np, sq, sk] - matmul_input_buffer = parallel_state.get_global_memory_buffer().get_tensor( - (b * np, sq, sk), - query.dtype, - "mpu", - ) - - # Raw attention scores. [b * np, sq, sk] - matmul_result = torch.baddbmm( - matmul_input_buffer, - query.transpose(0, 1), # [b * np, sq, hn] - key.transpose(0, 1).transpose(1, 2), # [b * np, hn, sk] - beta=0.0, - alpha=(1.0 / self.norm_factor) if self.config.normalize_attention_scores else 1.0, - ) - - # change view to [b, np, sq, sk] - attention_scores = matmul_result.view(b, np, sq, sk) - - # =========================== - # Attention probs and dropout - # =========================== - - # attention scores and attention mask [b, np, sq, sk] - # ESM2 Customization - if self.config.use_esm_attention: - # NOTE: the slicing here is to make the attention_mask the same shape as the extended - # attention mask in ESM2. The multiplication by -3.4028e+38 (float32 min_val) is - # similarly motivated by ESM2's masking approach, which forces softmax of attention scores - # for masked entries to be close to 0. This number is replaced with min_val of the precision - # using min_val instead of -inf is stable in an special case where all sequence is masked - min_val = torch.finfo(attention_scores.dtype).min - - attention_probs: Tensor = self.esm2_scale_mask_softmax( - attention_scores.masked_fill(attention_mask[:, :, 0:1, :].to(bool), min_val) - ) - # END ESM2 Customization - else: - attention_probs: Tensor = self.scale_mask_softmax(attention_scores, attention_mask) - - # This is actually dropping out entire tokens to attend to, which might - # seem a bit unusual, but is taken from the original Transformer paper. - - if not self.config.sequence_parallel: - with tensor_parallel.get_cuda_rng_tracker().fork(): - attention_probs = self.attention_dropout(attention_probs) - else: - attention_probs = self.attention_dropout(attention_probs) - - # ========================= - # Context layer. [sq, b, hp] - # ========================= - - # value -> context layer. - # [sk, b, np, hn] --> [b, np, sq, hn] - - # context layer shape: [b, np, sq, hn] - b, np, sq, hn = value.size(1), value.size(2), query.size(0), value.size(3) - - # change view [sk, b * np, hn] - value = value.view(value.size(0), b * np, -1) - - # change view [b * np, sq, sk] - attention_probs = attention_probs.view(b * np, sq, -1) - - # matmul: [b * np, sq, hn] - context = torch.bmm(attention_probs, value.transpose(0, 1)) - - # change view [b, np, sq, hn] - context = context.view(b, np, sq, hn) - - # [b, np, sq, hn] --> [sq, b, np, hn] - context = context.permute(2, 0, 1, 3).contiguous() - - # [sq, b, np, hn] --> [sq, b, hp] - context = context.view(sq, b, self.hidden_size_per_partition) - - return context - - def esm2_scale_mask_softmax( - self, - input: Tensor, - mask: Optional[Tensor] = None, - scale: Optional[Union[float, int]] = None, - mask_func: Optional[Callable] = None, - ) -> Tensor: - """Scale Mask Softmax function. - - Args: - input: Tensor of shape (Batch, NP, SK, SQ). The input may or may not have already - had a mask applied to it. - mask: If a mask is to be applied, it will go here. - scale: A scale factor that will be applied before the softmax. - mask_func: An optional function to apply to the mask. If None, it is assumed that - the input already had the mask applied to it. - - Returns: - probs: Tensor of normalized probabilities after the softmax has been applied, - of shape (Batch, NP, SK, SQ). - """ - if self.attn_mask_type.name != "padding": - raise ValueError( - f"self.attn_mask_type: {self.attn_mask_type} is not 'padding'. " - "Only 'padding' type is supported currently." - ) - - original_dtype = input.dtype # Store original dtype - if ( - original_dtype == torch.float16 or original_dtype == torch.bfloat16 - ) and self.config.attention_softmax_in_fp32: - input = input.float() # Convert to float32 for softmax - - if scale is not None: - input = input * scale # Apply scaling - - if mask is not None and mask_func is not None: - input = mask_func(input, mask) # Apply mask function if provided - - probs = torch.nn.functional.softmax(input, dim=-1) # Apply softmax - - if self.config.attention_softmax_in_fp32 and original_dtype in (torch.float16, torch.bfloat16): - probs = probs.to(original_dtype) # Convert back to original dtype if necessary - - return probs diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py index 018ebb5acc..b0991669d8 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py @@ -27,6 +27,7 @@ from bionemo.esm2.api import ESM2GenericConfig, ESM2Model from bionemo.esm2.data import tokenizer +from bionemo.llm.data.collate import MLM_LOSS_IGNORE_INDEX from bionemo.llm.data.label2id_tokenizer import Label2IDTokenizer from bionemo.llm.data.types import BertSample from bionemo.llm.model.biobert.model import BioBertOutput @@ -230,6 +231,7 @@ def __init__( self.tokenizer = tokenizer label_tokenizer = Label2IDTokenizer() self.label_tokenizer = label_tokenizer.build_vocab("CHE") + self.label_cls_eos_id = MLM_LOSS_IGNORE_INDEX def __len__(self) -> int: """Length of dataset.""" @@ -257,13 +259,13 @@ def _tokenize_labels(self, labels_sequence: str) -> Tensor: # # for multi-label classification with BCEWithLogitsLoss # tokenized_labels = torch.nn.functional.one_hot(label_ids, num_classes=self.label_tokenizer.vocab_size) - # cls_eos = torch.full((1, self.label_tokenizer.vocab_size), -1, dtype=tokenized_labels.dtype) + # cls_eos = torch.full((1, self.label_tokenizer.vocab_size), self.label_cls_eos_id, dtype=tokenized_labels.dtype) # for multi-class (mutually exclusive) classification with CrossEntropyLoss tokenized_labels = label_ids - cls_eos = torch.tensor([-1], dtype=tokenized_labels.dtype) + cls_eos = torch.tensor([self.label_cls_eos_id], dtype=tokenized_labels.dtype) - # add cls / eos labels with padding value -1 to have the same shape as tokenized_sequence + # add cls / eos label ids with padding value -100 to have the same shape as tokenized_sequence labels = torch.cat((cls_eos, tokenized_labels, cls_eos)) return labels diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py index d0999c2773..b9c82ed258 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/model.py @@ -35,7 +35,6 @@ from torch.optim import Optimizer from bionemo.esm2.data.tokenizer import BioNeMoESMTokenizer -from bionemo.esm2.model.attention import ESM2DotProductAttention, ESM2TEDotProductAttention from bionemo.esm2.model.embedding import ESM2Embedding from bionemo.llm.api import MegatronLossType from bionemo.llm.model.biobert.model import BioBertConfig, MegatronBioBertModel, PositionEmbeddingKinds @@ -294,6 +293,7 @@ class ESM2GenericConfig(BioBertConfig[ESM2ModelT, MegatronLossType]): bias_activation_fusion: bool = True # True degrades accuracy slightly, but is faster. activation_func: Callable = F.gelu # esm_gelu_func # ESM2 MLP init_method_std: float = 0.02 + softmax_scale: float = 1.0 # embedding token_dropout: bool = True @@ -346,13 +346,11 @@ def __post_init__(self): super().__post_init__() if self.biobert_spec_option == BiobertSpecOption.esm2_bert_layer_with_transformer_engine_spec: self.apply_query_key_layer_scaling = False - self.core_attention_override = ESM2TEDotProductAttention elif self.biobert_spec_option == BiobertSpecOption.esm2_bert_layer_local_spec: logging.warning( "BiobertSpecOption.esm2_bert_layer_local_spec is depreciated. Use BiobertSpecOption.esm2_bert_layer_with_transformer_engine_spec instead." ) self.apply_query_key_layer_scaling = True - self.core_attention_override = ESM2DotProductAttention else: raise ValueError(f"Unknown biobert_spec_option: {self.biobert_spec_option}") diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py index 5ba6739164..ac21820875 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/config_models.py @@ -25,7 +25,6 @@ from bionemo.esm2.data.datamodule import ESMDataModule from bionemo.esm2.data.dataset import RandomMaskStrategy from bionemo.esm2.data.tokenizer import get_tokenizer -from bionemo.esm2.model.attention import ESM2DotProductAttention, ESM2TEDotProductAttention from bionemo.esm2.model.model import ESM2Config from bionemo.llm.model.biobert.model import BiobertSpecOption from bionemo.llm.run.config_models import ( @@ -188,14 +187,12 @@ def validate_and_set_attention_and_scaling(self): ) if self.biobert_spec_option == BiobertSpecOption.esm2_bert_layer_with_transformer_engine_spec: self.apply_query_key_layer_scaling = False - self.core_attention_override = ESM2TEDotProductAttention elif self.biobert_spec_option == BiobertSpecOption.esm2_bert_layer_local_spec: logging.warning( "BiobertSpecOption.esm2_bert_layer_local_spec is deprecated. " "Use BiobertSpecOption.esm2_bert_layer_with_transformer_engine_spec instead." ) self.apply_query_key_layer_scaling = True - self.core_attention_override = ESM2DotProductAttention return self def model_validator(self, global_cfg: MainConfig) -> MainConfig: diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py index 857db8ad48..d67f715bea 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/run/main.py @@ -78,6 +78,13 @@ def parse_args(): default=[0], help="Enable nsys profiling for these ranks.", ) + parser.add_argument( + "--disable-checkpointing", + action="store_false", + default=True, + dest="create_checkpoint_callback", + help="Disable creating a ModelCheckpoint callback.", + ) return parser.parse_args() def string_to_class(path: str): @@ -87,7 +94,12 @@ def string_to_class(path: str): module = importlib.import_module(module_path) return getattr(module, class_name) - def load_config(config_path: str, model_config_cls: Optional[str], data_config_cls: Optional[str]) -> MainConfig: + def load_config( + config_path: str, + model_config_cls: Optional[str], + data_config_cls: Optional[str], + create_checkpoint_callback: bool, + ) -> MainConfig: with open(config_path, "r") as f: config_dict = yaml.safe_load(f) @@ -109,10 +121,15 @@ def load_config(config_path: str, model_config_cls: Optional[str], data_config_c elif isinstance(data_config_cls, str): data_config_cls = string_to_class(data_config_cls) + # disable checkpointing if called from the command line + if not create_checkpoint_callback: + config_dict["training_config"]["enable_checkpointing"] = create_checkpoint_callback + config_dict["experiment_config"]["create_checkpoint_callback"] = create_checkpoint_callback + return MainConfig[model_config_cls, data_config_cls](**config_dict) args = parse_args() - config = load_config(args.config, args.model_config_cls, args.data_config_cls) + config = load_config(args.config, args.model_config_cls, args.data_config_cls, args.create_checkpoint_callback) if args.nsys_profiling: nsys_config = NsysConfig( diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py index 7d05455924..928ff81fa8 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py @@ -18,6 +18,7 @@ from typing import List, Optional, Sequence, get_args from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary +from megatron.core.distributed import DistributedDataParallelConfig from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm @@ -70,6 +71,7 @@ def main( wandb_offline: bool = False, wandb_tags: Optional[List[str]] = None, wandb_group: Optional[str] = None, + wandb_job_type: Optional[str] = None, wandb_id: Optional[str] = None, wandb_anonymous: Optional[bool] = False, wandb_log_model: bool = False, @@ -77,6 +79,7 @@ def main( tensor_model_parallel_size: int = 1, create_tensorboard_logger: bool = False, nemo1_init_path: Optional[Path] = None, + create_checkpoint_callback: bool = True, restore_from_checkpoint_path: Optional[str] = None, save_best_checkpoint: bool = True, save_last_checkpoint: bool = True, @@ -91,6 +94,10 @@ def main( hidden_size: int = 1280, num_attention_heads: int = 20, ffn_hidden_size: int = 1280 * 4, + overlap_grad_reduce: bool = True, + overlap_param_gather: bool = True, + average_in_collective: bool = True, + grad_reduce_in_fp32: bool = False, ) -> None: """Train an ESM2 model on UR data. @@ -124,6 +131,7 @@ def main( wandb_offline (bool): Run offline (data can be streamed later to wandb servers). wandb_tags (Optional[List[str]]): Tags associated with this run wandb_group (Optional[str]): A unique string shared by all runs in a given group + wandb_job_type (Optional[str]): Type of run, which is useful when you're grouping runs together into larger experiments using group. wandb_id (Optional[str]): Sets the version, mainly used to resume a previous run wandb_anonymous (Optional[bool]): Enables or explicitly disables anonymous logging wandb_log_model (bool): Save checkpoints in wandb dir to upload on W&B servers @@ -131,6 +139,7 @@ def main( tensor_model_parallel_size (int): tensor model parallel size create_tensorboard_logger (bool): create the tensorboard logger nemo1_init_path (Optional[Path]): Nemo 1 initialization path + create_checkpoint_callback (bool): create a ModelCheckpoint callback and attach it to the pytorch lightning trainer restore_from_checkpoint_path (Optional[str]): If set, restores the model from the directory passed in. Expects the checkpoint to be created by using the ModelCheckpoint class and always_save_context=True. save_best_checkpoint (bool): whether to save the best checkpoint @@ -146,6 +155,10 @@ def main( hidden_size (int): hidden size num_attention_heads (int): number of attention heads ffn_hidden_size (int): feed forward hidden size + overlap_grad_reduce (bool): overlap gradient reduction + overlap_param_gather (bool): overlap parameter gather + average_in_collective (bool): average in collective + grad_reduce_in_fp32 (bool): gradient reduction in fp32 """ # Create the result directory if it does not exist. result_dir.mkdir(parents=True, exist_ok=True) @@ -163,10 +176,18 @@ def main( strategy = nl.MegatronStrategy( tensor_model_parallel_size=tensor_model_parallel_size, pipeline_model_parallel_size=pipeline_model_parallel_size, - ddp="megatron", + pipeline_dtype=get_autocast_dtype(precision), + ddp=DistributedDataParallelConfig( + check_for_nan_in_grad=True, + overlap_grad_reduce=overlap_grad_reduce, + overlap_param_gather=overlap_param_gather, + average_in_collective=average_in_collective, + grad_reduce_in_fp32=grad_reduce_in_fp32, + use_distributed_optimizer=True, + ), find_unused_parameters=True, + gradient_as_bucket_view=True, ckpt_include_optimizer=True, - # NOTE: there are issues related to async that may occur, most recently observed due to duplicate filenames. ckpt_async_save=True, ckpt_parallel_load=True, ) @@ -182,6 +203,7 @@ def main( entity=wandb_entity, tags=wandb_tags, group=wandb_group, + job_type=wandb_job_type, id=wandb_id, anonymous=wandb_anonymous, log_model=wandb_log_model, @@ -213,7 +235,14 @@ def main( log_every_n_steps=log_every_n_steps, num_nodes=num_nodes, callbacks=callbacks, - plugins=nl.MegatronMixedPrecision(precision=precision), + plugins=nl.MegatronMixedPrecision( + precision=precision, + params_dtype=get_autocast_dtype(precision), + pipeline_dtype=get_autocast_dtype(precision), + grad_reduce_in_fp32=grad_reduce_in_fp32, + autocast_enabled=False, + ), + enable_checkpointing=create_checkpoint_callback, ) tokenizer = get_tokenizer() @@ -275,14 +304,17 @@ def main( ) # Configure our custom Checkpointer - checkpoint_callback = nl_callbacks.ModelCheckpoint( - save_last=save_last_checkpoint, - monitor=metric_to_monitor_for_checkpoints, # "val_loss", - save_top_k=save_top_k, - every_n_train_steps=val_check_interval, - always_save_context=True, # Enables the .nemo file-like checkpointing where all IOMixins are under SerDe - filename="{epoch}-{val_loss:.2f}-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. - ) + if create_checkpoint_callback: + checkpoint_callback = nl_callbacks.ModelCheckpoint( + save_last=save_last_checkpoint, + monitor=metric_to_monitor_for_checkpoints, # "val_loss", + save_top_k=save_top_k, + every_n_train_steps=val_check_interval, + always_save_context=True, # Enables the .nemo file-like checkpointing where all IOMixins are under SerDe + filename="{epoch}-{val_loss:.2f}-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. + ) + else: + checkpoint_callback = None # Setup the logger and train the model nemo_logger = setup_nemo_lightning_logger( @@ -325,6 +357,7 @@ def train_esm2_entrypoint(): wandb_project=args.wandb_project, wandb_tags=args.wandb_tags, wandb_group=args.wandb_group, + wandb_job_type=args.wandb_job_type, wandb_id=args.wandb_id, wandb_anonymous=args.wandb_anonymous, wandb_log_model=args.wandb_log_model, @@ -346,6 +379,7 @@ def train_esm2_entrypoint(): experiment_name=args.experiment_name, resume_if_exists=args.resume_if_exists, nemo1_init_path=args.nemo1_init_path, + create_checkpoint_callback=args.create_checkpoint_callback, restore_from_checkpoint_path=args.restore_from_checkpoint_path, save_best_checkpoint=args.save_best_checkpoint, save_last_checkpoint=args.save_last_checkpoint, @@ -360,6 +394,10 @@ def train_esm2_entrypoint(): hidden_size=args.hidden_size, num_attention_heads=args.num_attention_heads, ffn_hidden_size=args.ffn_hidden_size, + overlap_grad_reduce=not args.no_overlap_grad_reduce, + overlap_param_gather=not args.no_overlap_param_gather, + average_in_collective=not args.no_average_in_collective, + grad_reduce_in_fp32=args.grad_reduce_in_fp32, ) @@ -432,6 +470,12 @@ def get_parser(): parser.add_argument( "--wandb-group", type=str, default=None, help="A unique string shared by all runs in a given group" ) + parser.add_argument( + "--wandb-job-type", + type=str, + default=None, + help="A unique string representing a type of run, which is useful when you're grouping runs together into larger experiments using group.", + ) parser.add_argument( "--wandb-id", type=str, default=None, help="Sets the version, mainly used to resume a previous run" ) @@ -553,6 +597,13 @@ def get_parser(): required=False, help="Path to nemo1 file, if desired to load at init time.", ) + parser.add_argument( + "--disable-checkpointing", + action="store_false", + default=True, + dest="create_checkpoint_callback", + help="Disable creating a ModelCheckpoint callback.", + ) parser.add_argument( "--save-best-checkpoint", action="store_true", @@ -667,6 +718,27 @@ def get_parser(): default=4 * 1280, help="FFN hidden size of the model. Default is 4 * 1280.", ) + # DDP config + parser.add_argument( + "--no-overlap-grad-reduce", + action="store_true", + default=False, + ) + parser.add_argument( + "--no-overlap-param-gather", + action="store_true", + default=False, + ) + parser.add_argument( + "--no-average-in-collective", + action="store_true", + default=False, + ) + parser.add_argument( + "--grad-reduce-in-fp32", + action="store_true", + default=False, + ) return parser diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py index 1fcb2fca30..9c49d70c42 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py @@ -14,13 +14,10 @@ # limitations under the License. -from typing import Generator - import pytest from nemo.lightning import io -from bionemo.esm2.api import ESM2Config -from bionemo.esm2.data.datamodule import ESMDataModule +from bionemo.core.data.load import load from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule from bionemo.esm2.model.finetune.finetune_regressor import ( ESM2FineTuneSeqConfig, @@ -36,36 +33,15 @@ from bionemo.testing.callbacks import MetricTracker -@pytest.fixture(scope="module") -def esm2_2layer_config() -> Generator[ESM2Config, None, None]: - with megatron_parallel_state_utils.distributed_model_parallel_state(): - yield ESM2Config(num_layers=3, hidden_size=128) - - -@pytest.fixture -def pretrain_data_module(dummy_protein_dataset, dummy_parquet_train_val_inputs): - train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs - data_module = ESMDataModule( - train_cluster_path=train_cluster_path, - train_database_path=dummy_protein_dataset, - valid_cluster_path=valid_cluster_path, - valid_database_path=dummy_protein_dataset, - global_batch_size=8, - micro_batch_size=4, - min_seq_length=None, - max_seq_length=1024, - num_workers=1, - ) - yield data_module +# To download a 8M internally pre-trained ESM2 model +pretrain_ckpt_path = load("esm2/nv_8m:2.0") @pytest.mark.needs_gpu @pytest.mark.parametrize("with_peft", [True, False]) def test_esm2_finetune_token_classifier( tmp_path, - esm2_2layer_config, tokenizer, - pretrain_data_module, dummy_data_per_token_classification_ft, with_peft: bool, n_steps_train: int = 50, @@ -73,32 +49,13 @@ def test_esm2_finetune_token_classifier( ): if with_peft: pytest.xfail("FIXME PEFT fine-tuning not supported with fusions active") - with megatron_parallel_state_utils.distributed_model_parallel_state(seed): - ckpt_path, initial_metrics, trainer = train_model( - experiment_name="test_experiment", - experiment_dir=tmp_path / "pretrain", - config=esm2_2layer_config, - data_module=pretrain_data_module, - n_steps_train=n_steps_train, - metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), - tokenizer=tokenizer, - _use_rich_model_summary=False, - ) - pretrain_requires_grad = [p.requires_grad for _, p in trainer.model.named_parameters()] - assert all(pretrain_requires_grad), "Frozen parameters in pretraining" - - weights_ckpt = ckpt_path / "weights" - assert weights_ckpt.exists() - assert weights_ckpt.is_dir() - assert io.is_distributed_ckpt(weights_ckpt) - assert initial_metrics.collection_train["loss"][0] > initial_metrics.collection_train["loss"][-1] with megatron_parallel_state_utils.distributed_model_parallel_state(seed): if with_peft: peft = ESM2LoRA() else: peft = None - esm2_finetune_config = ESM2FineTuneTokenConfig(initial_ckpt_path=str(ckpt_path)) + esm2_finetune_config = ESM2FineTuneTokenConfig(initial_ckpt_path=str(pretrain_ckpt_path)) dataset = InMemoryPerTokenValueDataset(dummy_data_per_token_classification_ft, seed=seed) finetune_data_module = ESM2FineTuneDataModule(dataset, dataset) simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( @@ -137,9 +94,7 @@ def test_esm2_finetune_token_classifier( @pytest.mark.parametrize("with_peft", [True, False]) def test_esm2_finetune_regressor( tmp_path, - esm2_2layer_config, tokenizer, - pretrain_data_module, dummy_data_single_value_regression_ft, with_peft: bool, n_steps_train: int = 50, @@ -147,32 +102,13 @@ def test_esm2_finetune_regressor( ): if with_peft: pytest.xfail("FIXME PEFT fine-tuning not supported") - with megatron_parallel_state_utils.distributed_model_parallel_state(seed): - ckpt_path, initial_metrics, trainer = train_model( - experiment_name="test_experiment", - experiment_dir=tmp_path / "pretrain", - config=esm2_2layer_config, - data_module=pretrain_data_module, - n_steps_train=n_steps_train, - metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), - tokenizer=tokenizer, - _use_rich_model_summary=False, - ) - pretrain_requires_grad = [p.requires_grad for _, p in trainer.model.named_parameters()] - assert all(pretrain_requires_grad), "Frozen parameters in pretraining" - - weights_ckpt = ckpt_path / "weights" - assert weights_ckpt.exists() - assert weights_ckpt.is_dir() - assert io.is_distributed_ckpt(weights_ckpt) - assert initial_metrics.collection_train["loss"][0] > initial_metrics.collection_train["loss"][-1] with megatron_parallel_state_utils.distributed_model_parallel_state(seed): if with_peft: peft = ESM2LoRA() else: peft = None - esm2_regression_finetune_config = ESM2FineTuneSeqConfig(initial_ckpt_path=str(ckpt_path)) + esm2_regression_finetune_config = ESM2FineTuneSeqConfig(initial_ckpt_path=str(pretrain_ckpt_path)) dataset = InMemorySingleValueDataset(dummy_data_single_value_regression_ft, seed=seed) finetune_data_module = ESM2FineTuneDataModule(dataset, dataset) simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_attention.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_attention.py deleted file mode 100644 index 6383a04b65..0000000000 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_attention.py +++ /dev/null @@ -1,120 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import math - -import pytest -import torch -from megatron.core.transformer.enums import AttnMaskType - -from bionemo.esm2.api import ESM2Config -from bionemo.esm2.model.attention import ESM2DotProductAttention, ESM2TEDotProductAttention -from bionemo.testing import megatron_parallel_state_utils - - -@pytest.fixture(scope="module") -def config(): - with megatron_parallel_state_utils.distributed_model_parallel_state(): - yield ESM2Config( - seq_length=20, - hidden_size=4, - num_attention_heads=4, - attention_dropout=0.1, - use_esm_attention=True, - ) - - -@pytest.fixture(scope="module") -def local_attention_layer(config: ESM2Config) -> ESM2DotProductAttention: - return ESM2DotProductAttention( - config=config, - layer_number=0, - attn_mask_type=AttnMaskType.padding, - attention_type="normal", - ).eval() - - -@pytest.fixture(scope="module") -def attention_layer(config: ESM2Config) -> ESM2TEDotProductAttention: - return ESM2TEDotProductAttention( - config=config, - layer_number=0, - attn_mask_type=AttnMaskType.padding, - attention_type="self", - ).eval() - - -def test_init(attention_layer, config): - assert attention_layer.config.use_esm_attention - assert attention_layer.config == config - - -@pytest.mark.skip(reason="Not implemented yet for transformer engine") -def test_forward(attention_layer, config): - batch_size = 2 - sequence_length = config.seq_length - hidden_size = config.hidden_size - device = torch.device("cuda") - - query = torch.randn(sequence_length, batch_size, 1, hidden_size, device=device) - key = torch.randn(sequence_length, batch_size, 1, hidden_size, device=device) - value = torch.randn(sequence_length, batch_size, 1, hidden_size, device=device) - random_ints = torch.randint(0, 2, (batch_size, 1, sequence_length, sequence_length), device=device) - attention_mask = ((random_ints + torch.transpose(random_ints, dim0=2, dim1=3)) / 2).to( - dtype=torch.bool - ) # symmetric mask tensor - - if isinstance(attention_layer, ESM2TEDotProductAttention): - raise NotImplementedError("TE requires reshaped input and is not implemented yet") - else: - output = attention_layer(query, key, value, attention_mask) - assert output.shape == (sequence_length, batch_size, hidden_size) - - -@pytest.mark.skip(reason="Not implemented yet for transformer engine") -@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16, torch.half]) -def test_attention_with_mask(attention_layer, dtype): - sequence_length_val = 3 - sequence_length_query = 1 - batch_size = 2 - emb_dim = 4 - device = torch.device("cuda") - - # query and key such that the dot prod is an all-ones tensor - query = torch.ones(batch_size, sequence_length_query, 1, emb_dim, device=device, dtype=dtype) / math.sqrt(emb_dim) - key = torch.ones(batch_size, sequence_length_val, 1, emb_dim, device=device, dtype=dtype) / math.sqrt(emb_dim) - - query = query.transpose(0, 1) - key = key.transpose(0, 1) - - attention_mask = torch.zeros(batch_size, 1, 1, sequence_length_val, device=device, dtype=dtype) - attention_mask[0, :, :, 2:] = 1 # average first two tensors in val - attention_mask[1, :, :, 1:] = 1 # select first item from val - - values = torch.stack([torch.arange(sequence_length_val)] * batch_size).to(device=device, dtype=dtype) + 1.0 - values = torch.stack([values] * emb_dim, dim=2).unsqueeze(2).transpose(0, 1) - - assert values.shape == (sequence_length_val, batch_size, 1, emb_dim) - - # softmax will make the the avg first 2 tensors in vals (ones + twos)/2 and second row is just ones - if isinstance(attention_layer, ESM2TEDotProductAttention): - raise NotImplementedError("TE requires reshaped input and is not implemented yet") - else: - output = attention_layer(query, key, values, attention_mask) - expected_output = torch.tensor( - [[[1.5000, 1.5000, 1.5000, 1.5000], [1.0000, 1.0000, 1.0000, 1.0000]]], device=device, dtype=dtype - ) - assert torch.equal(output, expected_output) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py index aac0ed617d..13ae7c35dd 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py @@ -32,8 +32,12 @@ from bionemo.llm.utils.callbacks import IntervalT -esm2_650m_checkpoint_path = load("esm2/650m:2.0") -esm2_3b_checkpoint_path = load("esm2/3b:2.0", source="ngc") +# Function to check GPU memory +def check_gpu_memory(threshold_gb): + if torch.cuda.is_available(): + gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3) # Memory in GB + return gpu_memory < threshold_gb + return False # Function to check GPU memory @@ -140,7 +144,6 @@ def test_esm2_fine_tune_data_module_val_dataloader(data_module): @pytest.mark.parametrize("precision", ["fp32", "bf16-mixed"]) @pytest.mark.parametrize("prediction_interval", get_args(IntervalT)) -@pytest.mark.skipif(check_gpu_memory(30), reason="Skipping test due to insufficient GPU memory") def test_infer_runs( tmpdir, dummy_protein_csv, @@ -155,7 +158,7 @@ def test_infer_runs( infer_model( data_path=data_path, - checkpoint_path=esm2_650m_checkpoint_path, + checkpoint_path=load("esm2/nv_8m:2.0"), results_path=result_dir, min_seq_length=min_seq_len, prediction_interval=prediction_interval, diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py index 8ea2dac239..24e5488a27 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_pydantic_train.py @@ -51,6 +51,8 @@ def dummy_parquet_train_val_inputs(tmp_path): return train_cluster_path, valid_cluster_path +# TODO: These tests currently take an inordinate amount of time. See https://jirasw.nvidia.com/browse/BIONEMO-553 +@pytest.mark.slow def test_pretrain_pydantic_cli(dummy_protein_dataset, dummy_parquet_train_val_inputs, tmpdir): result_dir = tmpdir.mkdir("results") train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py index ab15ae0b4b..ab9040d395 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_train_esm2.py @@ -82,7 +82,10 @@ def dummy_parquet_train_val_inputs(tmp_path): return train_cluster_path, valid_cluster_path -def test_main_runs(monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_train_val_inputs): +@pytest.mark.parametrize("create_checkpoint_callback", [True, False]) +def test_main_runs( + monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_train_val_inputs, create_checkpoint_callback +): train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs result_dir = Path(tmpdir.mkdir("results")) @@ -119,6 +122,7 @@ def test_main_runs(monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_tra num_attention_heads=2, hidden_size=4, ffn_hidden_size=4 * 4, + create_checkpoint_callback=create_checkpoint_callback, ) assert (result_dir / "test_experiment").exists(), "Could not find test experiment directory." @@ -126,12 +130,20 @@ def test_main_runs(monkeypatch, tmpdir, dummy_protein_dataset, dummy_parquet_tra children = list((result_dir / "test_experiment").iterdir()) assert len(children) == 1, f"Expected 1 child in test experiment directory, found {children}." uq_rundir = children[0] # it will be some date. - assert ( - result_dir / "test_experiment" / uq_rundir / "checkpoints" - ).exists(), "Could not find test experiment checkpoints directory." - assert ( - result_dir / "test_experiment" / uq_rundir / "checkpoints" - ).is_dir(), "Test experiment checkpoints directory is supposed to be a directory." + + # checking directory with checkpoints + expected_exists = create_checkpoint_callback + actual_exists = (result_dir / "test_experiment" / uq_rundir / "checkpoints").exists() + assert expected_exists == actual_exists, ( + f"Checkpoints directory existence mismatch. " + f"Expected: {'exists' if expected_exists else 'does not exist'}, " + f"Found: {'exists' if actual_exists else 'does not exist'}." + ) + + if create_checkpoint_callback: + assert ( + result_dir / "test_experiment" / uq_rundir / "checkpoints" + ).is_dir(), "Test experiment checkpoints directory is supposed to be a directory." assert ( result_dir / "test_experiment" / uq_rundir / "nemo_log_globalrank-0_localrank-0.txt" ).is_file(), "Could not find experiment log." diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 301cadac21..ede0ce7a2b 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -17,7 +17,7 @@ from collections import defaultdict from dataclasses import asdict, dataclass -import nvidia_resiliency_ext.ptl_resiliency as res_module +# import nvidia_resiliency_ext.ptl_resiliency as res_module import torch import yaml from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary @@ -92,7 +92,7 @@ def parse_args(): ) parser.add_argument("--use-megatron-comm-overlap-llama3-8k", action="store_true", default=False) parser.add_argument("--align-param-gather", action="store_true", default=False) - parser.add_argument("--straggler-detection", action="store_true", default=False) + # parser.add_argument("--straggler-detection", action="store_true", default=False) parser.add_argument( "--model-size", type=str, @@ -363,19 +363,20 @@ def main(): ) callbacks.append(flop_meas_callback) - if args.straggler_detection: - callbacks.append( - res_module.StragglerDetectionCallback( - report_time_interval=300, - calc_relative_gpu_perf=True, - calc_individual_gpu_perf=True, - num_gpu_perf_scores_to_print=5, - gpu_relative_perf_threshold=0.7, - gpu_individual_perf_threshold=0.7, - stop_if_detected=True, - enable_ptl_logging=True, - ) - ) + # TODO(@cye): Add this back when it works with 24.12. + # if args.straggler_detection: + # callbacks.append( + # res_module.StragglerDetectionCallback( + # report_time_interval=300, + # calc_relative_gpu_perf=True, + # calc_individual_gpu_perf=True, + # num_gpu_perf_scores_to_print=5, + # gpu_relative_perf_threshold=0.7, + # gpu_individual_perf_threshold=0.7, + # stop_if_detected=True, + # enable_ptl_logging=True, + # ) + # ) if args.use_megatron_comm_overlap_llama3_8k: callbacks.append( MegatronCommOverlapCallback( diff --git a/sub-packages/bionemo-example_model/README.md b/sub-packages/bionemo-example_model/README.md index 4abb4f219b..2124680499 100644 --- a/sub-packages/bionemo-example_model/README.md +++ b/sub-packages/bionemo-example_model/README.md @@ -2,9 +2,9 @@ # Introduction -This is a minimalist package containing an example model that makes use of bionemo2 and nemo conventions. It contains the necessary models, dataloaders, datasets, and custom loss fucntions. The referenced classes and function are in `bionemo.example_model.lightning.lightning_basic`. +This is a minimalist package containing an example model that makes use of bionemo2 and nemo conventions. It contains the necessary models, dataloaders, datasets, and custom loss functions. The referenced classes and functions are in `bionemo.example_model.lightning.lightning_basic`. -This tutorial demonstrates the creation of a simple MNIST model. This should be run in a BioNeMo container. The BioNeMo Framework container can run in a brev.dev launchable: [![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU). It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credit. Notebooks and a shell interface can be launced by clicking `Open Notebook`. (Note: This links to the nightly release and may be out of sync with these docs.) +This tutorial demonstrates the creation of a simple MNIST model. This should be run in a BioNeMo container. The BioNeMo Framework container can run in a brev.dev launchable: [![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU). It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credit. Notebooks and a shell interface can be launched by clicking `Open Notebook`. (Note: This links to the nightly release and may be out of sync with these docs.) For this tutorial, we will reuse elements from the BioNeMo example_model package. @@ -26,10 +26,10 @@ Loss functions used here are `MSELossReduction` and `ClassifierLossReduction`. T # Datasets and Datamodules -Datasets used for model training must be compatible with Megatron datasets. To enable this, the output of a given index and epoch must be deterministic. However, we may wish to have a different ordering in every epoch. To enable this, the items in the dataset should be accessible by both the epoch and the index. This can be done by accessing elements of the dataset with `EpochIndex` from `bionemo.core.data.multi_epoch_dataset`. A simple way of doing this is to wrap a dataset with `IdentityMultiEpochDatasetWrapper` imported from `bionemo.core.data.multi_epoch_dataset`. In this example, in in `bionemo.example_model.lightning.lightning_basic`, we use a custom dataset `MNISTCustomDataset` that wraps the `__getitem__` method of the MNIST dataset such that it return a dict instead of a Tuple or tensor. The `MNISTCustomDataset` returns elements of type `MnistItem`, which is a `TypedDict`. +Datasets used for model training must be compatible with Megatron datasets. To enable this, the output of a given index and epoch must be deterministic. However, we may wish to have a different ordering in every epoch. To enable this, the items in the dataset should be accessible by both the epoch and the index. This can be done by accessing elements of the dataset with `EpochIndex` from `bionemo.core.data.multi_epoch_dataset`. A simple way of doing this is to wrap a dataset with `IdentityMultiEpochDatasetWrapper` imported from `bionemo.core.data.multi_epoch_dataset`. In this example, in in `bionemo.example_model.lightning.lightning_basic`, we use a custom dataset `MNISTCustomDataset` that wraps the `__getitem__` method of the MNIST dataset such that it returns a dict instead of a Tuple or tensor. The `MNISTCustomDataset` returns elements of type `MnistItem`, which is a `TypedDict`. -In the data module/data loader class, it is necessary to have a data_sampler method to shuffle the data and that allows the sampler to be used with Megatron. This is a nemo2 peculiarity. A `nemo.lightning.pytorch.plugins.MegatronDataSampler` is the best choice. It sets up the capability to utilize micro-batching and gradient accumulation. It is also the place where the global batch size is constructed. +In the data module/data loader class, it is necessary to have a data_sampler attribute to shuffle the data and that allows the sampler to be used with Megatron. This is a nemo2 peculiarity. A `nemo.lightning.pytorch.plugins.MegatronDataSampler` is the best choice. It sets up the capability to utilize micro-batching and gradient accumulation. It is also the place where the global batch size is constructed. Also the sampler will not shuffle your data. So you need to wrap your dataset in a dataset shuffler that maps sequential IDs to random IDs in your dataset. This can be done with `MultiEpochDatasetResampler` from `bionemo.core.data.multi_epoch_dataset`. @@ -75,7 +75,7 @@ Similarly, `ExampleFineTuneConfig` extends `ExampleGenericConfig` for finetuning # Training Module -It is helfpul to have a training module that inherits from `lightning.pytorch.LightningModule` which organizes the model architecture, training, validation, and testing logic while abstracting away boilerplate code, enabling easier and more scalable training. This wrapper can be used for all model and loss combinations specified in the config. +It is helpful to have a training module that inherits from `lightning.pytorch.LightningModule` which organizes the model architecture, training, validation, and testing logic while abstracting away boilerplate code, enabling easier and more scalable training. This wrapper can be used for all model and loss combinations specified in the config. In `bionemo.example_model.lightning.lightning_basic`, we define `BionemoLightningModule`. In this example, `training_step`, `validation_step`, and `predict_step` define the training, validation, and prediction loops are independent of the forward method. In nemo: @@ -88,7 +88,7 @@ In this example, `training_step`, `validation_step`, and `predict_step` define t Additionally, during these steps, we log the validation, testing, and training loss. This is done similarly to https://lightning.ai/docs/torchmetrics/stable/pages/lightning.html. These logs can then be exported to wandb, or other metric viewers. For more complicated tracking, it may be necessary to use pytorch callbacks: https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html. -Further `loss_reduction_class()`, `training_loss_reduction()`, `validation_loss_reduction(),` and` test_loss_reduction()` are defined based on what's in the config. Additionally, `configure_model()` is definated based on the config. +Further `loss_reduction_class()`, `training_loss_reduction()`, `validation_loss_reduction(),` and` test_loss_reduction()` are defined based on what's in the config. Additionally, `configure_model()` is defined based on the config. # Training the models In `bionemo.example_model.lightning.lightning_basic` a checkpoint_callback variable is defined. This enables .nemo file-like checkpointing. @@ -99,7 +99,7 @@ We specify a training strategy of type `nemo.lightning.MegatronStrategy`. This s We specify a trainer of type `nemo.lightning.Trainer`, which is an extension of the pytorch lightning trainer. This is where the devices, validation intervals, maximal steps, maximal number of epochs, and how frequently to log are specified. -we specify a nemo-logger. We can set TensorBoard and WandB logging, along with extra loggers. Here, we specify a `CSVLogger` from lightning.pytorch.loggers. +We specify a nemo-logger. We can set TensorBoard and WandB logging, along with extra loggers. Here, we specify a `CSVLogger` from lightning.pytorch.loggers. We can now proceed to training. The first pre-training scripts is `bionemo/example_model/training_scripts/pretrain_mnist.py` @@ -109,7 +109,7 @@ This script will print out the location of the final model: Then we can run a finetuning-script: ``` -python src/bionemo/example_model/training_scripts/training_scripts/finetune_mnist.py ---pretrain_ckpt_dirpath +python src/bionemo/example_model/training_scripts/finetune_mnist.py ---pretrain_ckpt_dirpath ``` A nuance here is that in the config file, we specify the initial checkpoint path, along with which keys to skip. In the previous model checkpoint, we did not have a head labelled "digit_classifier", so we specify it as a head to be skipped. @@ -121,4 +121,4 @@ Finally, we can run a classification task with python src/bionemo/example_model/training_scripts/predict_mnist.py --finetune_dir . ``` -The results can be viewed with TensorBoardLogger if that is configured, or as a CSV file created by the CSVLogger. +The results can be viewed with TensorBoardLogger if that is configured, or as a CSV file created by the `CSVLogger`. diff --git a/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py b/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py index a5adac3cc2..8cb277ff9e 100644 --- a/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py +++ b/sub-packages/bionemo-example_model/src/bionemo/example_model/training_scripts/pretrain_mnist.py @@ -44,7 +44,7 @@ def run_pretrain(name: str, directory_name: str): nemo_logger = NeMoLogger( log_dir=str(save_dir), name=name, - tensorboard=TensorBoardLogger(save_dir=directory_name, name=name), + tensorboard=TensorBoardLogger(save_dir=save_dir, name=name), ckpt=checkpoint_callback, extra_loggers=[CSVLogger(save_dir / "logs", name=name)], ) diff --git a/sub-packages/bionemo-fw/pyproject.toml b/sub-packages/bionemo-fw/pyproject.toml index 4090dabd7a..e6e8ad9bf7 100644 --- a/sub-packages/bionemo-fw/pyproject.toml +++ b/sub-packages/bionemo-fw/pyproject.toml @@ -30,7 +30,6 @@ dependencies = [ # external 'nltk', 'numba>=0.57.1', - 'tensorstore==0.1.45', 'zarr', ] diff --git a/sub-packages/bionemo-geneformer/README.md b/sub-packages/bionemo-geneformer/README.md index 7e35e1fde6..73e02f04c9 100644 --- a/sub-packages/bionemo-geneformer/README.md +++ b/sub-packages/bionemo-geneformer/README.md @@ -16,7 +16,7 @@ pytest -v . ## Acquiring Data -Datasets are expected to be in the form of AnnData (.h5ad) objects such as those downloaded from [Cell x Gene | CZI](https://chanzuckerberg.github.io/cellxgene-census/). They are then pre-processed with either `bionemo-geneformer/src/bionemo/geneformer/data/singlecell/sc_memmap.py` or with sc-DL. +Datasets are expected to be in the form of AnnData (.h5ad) objects such as those downloaded from [Cell x Gene | CZI](https://chanzuckerberg.github.io/cellxgene-census/). They are then pre-processed with `sub-packages/bionemo-scdl/src/bionemo/scdl/scripts/convert_h5ad_to_scdl.py`. ## Geneformer-nv 10M and 106M Refer to the Dataset cards and Model cards to learn more about the pre-trained checkpoints provided for both 10M and 106M of Geneformer-nv. diff --git a/sub-packages/bionemo-geneformer/pyproject.toml b/sub-packages/bionemo-geneformer/pyproject.toml index 4efd56a76f..b892a60e02 100644 --- a/sub-packages/bionemo-geneformer/pyproject.toml +++ b/sub-packages/bionemo-geneformer/pyproject.toml @@ -21,7 +21,6 @@ dependencies = [ [project.scripts] bionemo-geneformer-train= "bionemo.geneformer.run.main:main" bionemo-geneformer-recipe= "bionemo.geneformer.run.recipes:main" -sc_memmap = "bionemo.geneformer.scripts.sc_memmap:main_cli" infer_geneformer = "bionemo.geneformer.scripts.infer_geneformer:geneformer_infer_entrypoint" train_geneformer = "bionemo.geneformer.scripts.train_geneformer:entrypoint" geneformer_mlm_loss_eval = "bionemo.geneformer.scripts.geneformer_mlm_loss_eval:entrypoint" diff --git a/sub-packages/bionemo-geneformer/scripts/geneformer_mlm_loss_eval.py b/sub-packages/bionemo-geneformer/scripts/geneformer_mlm_loss_eval.py index c8965d092d..187c7bc296 100644 --- a/sub-packages/bionemo-geneformer/scripts/geneformer_mlm_loss_eval.py +++ b/sub-packages/bionemo-geneformer/scripts/geneformer_mlm_loss_eval.py @@ -128,6 +128,7 @@ def main( seq_len_nv: int = 2048, seq_len_hf: int = 2048, seed: int = 513, + include_unrecognized_vocab_in_dataset: bool = False, ): """Inference function (requires DDP and only training data that fits in memory).""" # This is just used to get the tokenizer :( @@ -185,6 +186,7 @@ def main( max_len=seq_len_nv, mask_prob=mask_prob, seed=seed, + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) ds_hf_nvfilt = SingleCellDataset( dataset_path, @@ -194,6 +196,7 @@ def main( mask_prob=mask_prob, eos_token=hf_tokenizer.token_to_id(hf_tokenizer.sep_token), # Stored in the special token seed=seed, + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) print(f"Loaded dataset of length (NV): {len(ds_nv)}, (HF): {len(ds_hf_nvfilt)}") @@ -299,6 +302,11 @@ def entrypoint(): ) parser.add_argument("--hf-model-path", type=str, default="ctheodoris/Geneformer", help="HF model path") parser.add_argument("--dataset-path", type=Path, help="Path to dataset directory", required=True) + parser.add_argument( + "--include-unrecognized-vocab-in-dataset", + action="store_true", + help="If set to true, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to false which means any gene identifier not in the user supplied tokenizer vocab will be excluded.", + ) args = parser.parse_args() main( @@ -307,6 +315,7 @@ def entrypoint(): args.dataset_path, args.hf_token_dictionary_path, args.hf_medians_dictionary_path, + args.include_unrecognized_vocab_in_dataset, ) diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py index 9ab6d0a021..b3b1d1011d 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/datamodule.py @@ -51,6 +51,7 @@ class SingleCellDataModule(MegatronDataModule): num_mask_per_sample (int): Number of masked versions of a single sample to be returned by each worker train_batch_size (int): Batch size for training val_batch_size (int): Batch size for validation + include_unrecognized_vocab_in_dataset (bool, optional): If set to True, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to False which means any gene identifier not in the user supplied tokenizer vocab will be excluded. Attributes: cfg (Config): Configuration object @@ -82,6 +83,7 @@ def __init__( # noqa: D107 num_workers: int = 10, # TODO can this be automatically set? persistent_workers: bool = True, pin_memory: bool = True, + include_unrecognized_vocab_in_dataset: bool = False, ) -> None: super().__init__() if predict_dataset_path is None: @@ -122,6 +124,7 @@ def __init__( # noqa: D107 mask_token_prob=self.mask_token_prob, random_token_prob=self.random_token_prob, seed=random_utils.get_seed_from_rng(rng), + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) self._val_dataset_ori = SingleCellDataset( self.data_path_val, @@ -132,6 +135,7 @@ def __init__( # noqa: D107 mask_token_prob=self.mask_token_prob, random_token_prob=self.random_token_prob, seed=random_utils.get_seed_from_rng(rng), + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) self._test_dataset_ori = SingleCellDataset( self.data_path_test, @@ -142,6 +146,7 @@ def __init__( # noqa: D107 mask_token_prob=self.mask_token_prob, random_token_prob=self.random_token_prob, seed=random_utils.get_seed_from_rng(rng), + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) self._predict_dataset_ori = None else: @@ -155,6 +160,7 @@ def __init__( # noqa: D107 mask_token_prob=self.mask_token_prob, random_token_prob=self.random_token_prob, seed=random_utils.get_seed_from_rng(rng), + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) self._train_dataset_ori = None self._val_dataset_ori = None diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/dataset.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/dataset.py index 2470192cc3..30bad886b3 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/dataset.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/dataset.py @@ -14,11 +14,10 @@ # limitations under the License. -import json import random import time from pathlib import Path -from typing import Any, Dict, Optional, Sequence, Tuple +from typing import Any, Optional, Sequence import numpy as np import torch @@ -33,6 +32,7 @@ from bionemo.geneformer.data.singlecell.utils import sample_or_truncate from bionemo.geneformer.tokenizer.gene_tokenizer import GeneTokenizer from bionemo.llm.data import masking, types +from bionemo.scdl.io.single_cell_memmap_dataset import SingleCellMemMapDataset __all__: Sequence[str] = ( @@ -46,19 +46,19 @@ class SingleCellDataset(Dataset): updates will contain more comprehensive workflows for generating a Sparse Memmap from scRNA-seq. Args: - data_path (str): Path where the single cell files are stored. It should contain the following files: - - `metadata.json`: Path containing feature subset associated with each dataset. - - `features.csv`: Feature subset associated with each sample. + data_path (str): Path where the single cell files are stored in SingleCell Memmap format. It should contain the following files: + - `metadata.json`: Path containing the number of rows int he dataset. - Gene expression matrix stored in CSR format as `numpy.memmap`: - - `gene_expression_data.npy`: Gene expression values. - - `gene_expression_ind.npy`: Gene indices associated with gene values. - - `gene_expression_ptr.npy`: Column indices for each sample. + - `data.npy`: Non-zero gene expression values. + - `col_ptr.npy`: Indices of the corresponding genes for each entry in data.npy. + - `row_ptr.npy`: Column index pointers for each cell sample. tokenizer: The tokenizer to use for tokenizing the input data. median_dict (dict, optional): A dictionary containing median values for each gene. Defaults to None. max_len (int, optional): The maximum length of the input sequence. Defaults to 1024. + include_unrecognized_vocab_in_dataset (bool, optional): If set to True, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to False which means any gene identifier not in the user supplied tokenizer vocab will be excluded. Attributes: - data_path (str): Path where the single cell files are stored. + data_path (str): Path where the single cell files are stored in SCDL memmap format. max_len (int): The maximum length of the input sequence. metadata (dict): Metadata loaded from `metadata.json`. gene_medians (dict): A dictionary containing median values for each gene. If None, a median of '1' is assumed for all genes. @@ -93,10 +93,11 @@ def __init__( # noqa: D107 random_token_prob: float = 0.1, prepend_cls_token: bool = True, eos_token: int | None = None, - assert_increasing_columns: bool = True, + include_unrecognized_vocab_in_dataset: bool = False, seed: int = np.random.SeedSequence().entropy, # type: ignore ): super().__init__() + self.data_path = data_path self.max_len = max_len self.random_token_prob = random_token_prob @@ -105,110 +106,33 @@ def __init__( # noqa: D107 self.prepend_cls_token = prepend_cls_token self._seed = seed self.eos_token = eos_token - # check if column indices are increasing for looking up genes. This is a way of spotting if the sc_memmap.py - # script produced properly strctured sparse files. - self.assert_increasing_columns = assert_increasing_columns - path = Path(data_path) - - # - metadata - metadata = json.load(open(path / "metadata.json", "r")) + self.scdl = SingleCellMemMapDataset(str(data_path)) + self.length = len(self.scdl) # - median dict self.gene_medians = median_dict - - # - train/val idxs sampled contiguously - total_el = sum([v["num_el"] for _, v in metadata.items()]) - self.num_samples = sum([v["shape"][0] for _, v in metadata.items()]) - # - load data - self.gene_data = np.memmap(path / "gene_expression_data.npy", dtype="float32", mode="r", shape=(total_el,)) - - self.gene_data_indices = np.memmap( - path / "gene_expression_ind.npy", dtype="int32", mode="r", shape=(total_el,) - ) - - self.gene_data_ptr = np.memmap( - path / "gene_expression_ptr.npy", dtype="int64", mode="r", shape=(self.num_samples + 1,) - ) self.tokenizer = tokenizer - rnd_key = next(iter(metadata)) - feature_ids = np.array(metadata[rnd_key]["feature_ids"]) - - # Determine if we need to store the full metadata (per file feature_ids) or just a single feature_id - # vector for all files. If we can do the later this is much more memory efficient. - # without this change, if num_workers>0, we seem to hit a memory leak after a relatively small number - # of steps. Online discussion points to native python objects like dictionaries of a lot of data - # being a primary culprit behind large RAM usage in dataloaders that use multiprocessing. - features_all_same = True - for m in metadata.values(): - if np.any(np.char.not_equal(np.array(m["feature_ids"]), feature_ids)): - features_all_same = False - break - - if not features_all_same: - # We need to store per-file metadata of feature_ids. Make sure you run with a lot of RAM or few dataset workers. - # we need to store per-file metadata in this case because some of the files have different subsets of the - # feature_ids. - logging.warning( - "Feature ids are not the same across datasets. This can cause heavy RAM usage " - "for large datasets, try setting num_workers to 0." - ) - self.metadata = metadata - self.feature_ids = None - - # map row indices to dataset id - self.dataset_ccum = np.zeros( - len(self.metadata), - ) - # Maps dataset ids to dataset names (used in the metadata dict) - self.dataset_map = {} - count = 0 - for i, k in enumerate(self.metadata): - self.dataset_ccum[i] = count - self.dataset_map[i] = k - count += self.metadata[k]["shape"][0] - self.dataset_ccum[0] = -1 - else: - # We can store a single feature_id vector for all datasets, and do not need to store the full metadata array. - logging.warning( - "Feature ids are the same across datasets. This is good, using the same feature_ids for all datasets." - ) - self.feature_ids = feature_ids - self.metadata = None + self.include_unrecognized_vocab_in_dataset = include_unrecognized_vocab_in_dataset def __len__(self): # noqa: D105 - return self.num_samples - - def metadata_lookup(self, idx) -> Dict[str, np.ndarray]: - """Go from a cell idx to the file-level metadata associated with that cell.""" - did = sum(~(self.dataset_ccum > idx)) - 1 - metadata = self.metadata[self.dataset_map[did]] - return metadata - - def lookup_cell_by_idx(self, idx) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: # noqa: D102 - ptr = slice(int(self.gene_data_ptr[idx]), int(self.gene_data_ptr[idx + 1])) - # col idxs poin to offsets in the original sparse metadata, this is for looking up metadata eg gene names - col_idxs = np.asarray(self.gene_data_indices[ptr]).astype(int) # keyed by ptr - if self.assert_increasing_columns and len(col_idxs) > 1: - is_increasing = np.diff(col_idxs) > 0 - if not np.all(is_increasing): - raise ValueError(f"Column indices are not increasing for {np.sum(~is_increasing)} pairs of genes") - gene_data = np.asarray(self.gene_data[ptr]).astype(int) # keyed by ptr - # Get feature_ids for this particular cell. Eitehr lookup by index if we need to, or if we already verified that - # metadata is not needed because feature_ids are the same for every file, then we can just use the single feature_ids - # vector instead. - feature_ids: np.ndarray = ( - self.feature_ids if self.metadata is None else self.metadata_lookup(idx)["feature_ids"] - ) - return gene_data, col_idxs, feature_ids + return self.length def __getitem__(self, index: EpochIndex) -> types.BertSample: """Performs a lookup and the required transformation for the model.""" rng = np.random.default_rng([self._seed, index.epoch, index.idx]) - gene_data, col_idxs, feature_ids = self.lookup_cell_by_idx(index.idx) + values, feature_ids = self.scdl.get_row(index.idx, return_features=True, feature_vars=["feature_id"]) + assert ( + len(feature_ids) == 1 + ) # we expect feature_ids to be a list containing one np.array with the row's feature ids + gene_data, col_idxs = np.array(values[0]), np.array(values[1]) + if len(gene_data) == 0: + raise ValueError( + "SingleCellMemap data provided is invalid; the gene expression data parsed for the specified index is empty." + ) return process_item( gene_data, col_idxs, - feature_ids, + feature_ids[0], self.tokenizer, gene_median=self.gene_medians, rng=rng, @@ -218,6 +142,7 @@ def __getitem__(self, index: EpochIndex) -> types.BertSample: random_token_prob=self.random_token_prob, prepend_cls_token=self.prepend_cls_token, eos_token=self.eos_token, + include_unrecognized_vocab_in_dataset=self.include_unrecognized_vocab_in_dataset, ) @@ -227,6 +152,7 @@ def _gather_medians( normalize: bool, vocab: dict[str, int], gene_median: dict[str, float], + include_unrecognized_vocab_in_dataset: bool = False, ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Filter out genes that are not in the provided tokenizer vocab, and tokenize the gene names.""" genes, tokens, medians = [], [], [] @@ -237,6 +163,8 @@ def _gather_medians( if normalize: med = gene_median[tok] # If not in the dictionary we default to no normalization (1) medians.append(med) + elif include_unrecognized_vocab_in_dataset: + raise ValueError(f"Provided gene identifier, {str(tok)}, is not in the tokenizer vocab.") return np.asarray(genes), np.asarray(tokens), np.asarray(medians) @@ -255,6 +183,7 @@ def process_item( # noqa: D417 normalize: bool = True, prepend_cls_token: bool = True, eos_token: None | int = None, + include_unrecognized_vocab_in_dataset: bool = False, ) -> types.BertSample: """Process a single item in the dataset. @@ -263,7 +192,7 @@ def process_item( # noqa: D417 Args: gene_data (list): List of gene data, these are expression counts. - gene_idxs (list): List of gene indices, these are keys in 'metadata['feature_ids']' and correspdong the CSR entry. These are computed by sc_memmap. + gene_idxs (list): List of gene indices, these are keys in 'metadata['feature_ids']' and corresponding the CSR entry. feature_ids (list): Feature ids for the full dataset. tokenizer (Tokenizer): Tokenizer object. gene_median (optional(dict)): Dictionary of gene medians. Defaults to None. Expects ensembl IDs to be keys. @@ -277,6 +206,7 @@ def process_item( # noqa: D417 dirichlet_alpha (float): Alpha value for dirichlet sampling if set by `probabilistic_dirichlet_sampling`. Defaults to 0.5. same_length (bool): when true, sample the same length of genes as you originally had before the dirichlet sampler. recompute_globals (bool): when true, global arrays are always recomputed. this is only useful for testing. + include_unrecognized_vocab_in_dataset (bool, optional): If set to True, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to False which means any gene identifier not in the user supplied tokenizer vocab will be excluded. Returns: dict: Processed item dictionary. @@ -298,7 +228,12 @@ def process_item( # noqa: D417 gene_names = feature_ids[gene_idxs] gene_expression_cell, token_ids, gene_expression_medians = _gather_medians( - gene_names, gene_data, normalize, tokenizer.vocab, gene_median + gene_names, + gene_data, + normalize, + tokenizer.vocab, + gene_median, + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) if normalize: @@ -348,7 +283,7 @@ def process_item( # noqa: D417 def _profile_sc_dataset(): - data_path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" / "train" + data_path = load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" / "train" preprocessor = GeneformerPreprocess( download_directory=data_path, medians_file_path=data_path / "medians.json", diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py index 18f975207b..52cf8d77d7 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py @@ -21,7 +21,7 @@ from megatron.core.transformer.transformer_config import TransformerConfig from nemo.collections.llm import fn from nemo.collections.llm.fn.mixin import FNMixin -from nemo.collections.llm.peft.lora import AdapterParallelAdd, LoRA +from nemo.collections.llm.peft.lora import LoRA, LoRALinear from nemo.collections.nlp.modules.common.megatron.adapters.parallel_adapters import ParallelLinearAdapter from nemo.collections.nlp.modules.common.megatron.utils import average_losses_across_data_parallel_group from nemo.lightning.megatron_parallel import ( @@ -271,9 +271,7 @@ def selective_freeze(self, m: nn.Module, name: str | None = None, prefix: str | FNMixin.freeze(m) return m - def transform( - self, m: nn.Module, name: str | None = None, prefix: str | None = None - ) -> nn.Module | AdapterParallelAdd: + def transform(self, m: nn.Module, name: str | None = None, prefix: str | None = None) -> nn.Module | LoRALinear: """Transforms the input model if the name is in the target modules.""" tp_size = parallel_state.get_tensor_model_parallel_world_size() if name in self.target_modules: @@ -317,5 +315,5 @@ def transform( model_parallel_config=getattr(m, "config", None), alpha=self.alpha, ) - return AdapterParallelAdd(m, adapter) + return LoRALinear(m, adapter) return m diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py index d01e57b37e..741fd7b99f 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/config_models.py @@ -44,7 +44,7 @@ class GeneformerDataArtifacts: class GeneformerPretrainingDataConfig(DataConfig[SingleCellDataModule]): """Configuration class for Geneformer pretraining data. - Expects train/test/val to be prior split by directory and processed by `sub-packages/bionemo-geneformer/src/bionemo/geneformer/data/singlecell/sc_memmap.py`. + Expects train/test/val to be prior split by directory and processed by `sub-packages/bionemo-scdl/src/bionemo/scdl/scripts/convert_h5ad_to_scdl.py`. Attributes: data_dir (str): Directory where the data is stored. diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py index 4b49946cef..377803d95c 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/run/main.py @@ -82,6 +82,13 @@ def parse_args(): default=[0], help="Enable nsys profiling for these ranks.", ) + parser.add_argument( + "--disable-checkpointing", + action="store_false", + default=True, + dest="create_checkpoint_callback", + help="Disable creating a ModelCheckpoint callback.", + ) return parser.parse_args() @@ -92,7 +99,12 @@ def string_to_class(path: str): module = importlib.import_module(module_path) return getattr(module, class_name) - def load_config(config_path: str, model_config_cls: Optional[str], data_config_cls: Optional[str]) -> MainConfig: + def load_config( + config_path: str, + model_config_cls: Optional[str], + data_config_cls: Optional[str], + create_checkpoint_callback: bool, + ) -> MainConfig: with open(config_path, "r") as f: config_dict = yaml.safe_load(f) @@ -106,6 +118,11 @@ def load_config(config_path: str, model_config_cls: Optional[str], data_config_c # We assume we get a string to some importable config... e.g. in the sub-package jensen, 'bionemo.jensen.configs.MyConfig' model_config_cls = string_to_class(model_config_cls) + # disable checkpointing if called from the command line + if not create_checkpoint_callback: + config_dict["training_config"]["enable_checkpointing"] = create_checkpoint_callback + config_dict["experiment_config"]["create_checkpoint_callback"] = create_checkpoint_callback + if data_config_cls is None: data_config_cls = GeneformerPretrainingDataConfig elif isinstance(data_config_cls, str): @@ -113,7 +130,7 @@ def load_config(config_path: str, model_config_cls: Optional[str], data_config_c return MainConfig[model_config_cls, data_config_cls](**config_dict) args = parse_args() - config = load_config(args.config, args.model_config_cls, args.data_config_cls) + config = load_config(args.config, args.model_config_cls, args.data_config_cls, args.create_checkpoint_callback) if args.nsys_profiling: nsys_config = NsysConfig( diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py index ae7b0aaa7b..dc9f118140 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/infer_geneformer.py @@ -49,6 +49,7 @@ def infer_model( num_dataset_workers: int = 0, prediction_interval: IntervalT = "epoch", config_class: Type[BioBertConfig] = GeneformerConfig, + include_unrecognized_vocab_in_dataset: bool = False, ) -> None: """Inference function (requires DDP and only training data that fits in memory).""" # create the directory to save the inference results @@ -56,7 +57,7 @@ def infer_model( # This is just used to get the tokenizer :( train_data_path: Path = ( - load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" / "train" + load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" / "train" ) # Setup the strategy and trainer @@ -120,6 +121,7 @@ def infer_model( persistent_workers=num_dataset_workers > 0, pin_memory=False, num_workers=num_dataset_workers, + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) config = config_class( seq_length=seq_length, @@ -162,13 +164,14 @@ def geneformer_infer_entrypoint(): num_nodes=args.num_nodes, num_dataset_workers=args.num_dataset_workers, config_class=args.config_class, + include_unrecognized_vocab_in_dataset=args.include_unrecognized_vocab_in_dataset, ) def get_parser(): """Return the cli parser for this tool.""" parser = argparse.ArgumentParser( - description="Infer sc_memmap processed single cell data with Geneformer from a checkpiont." + description="Infer processed single cell data in SCDL memmap format with Geneformer from a checkpoint." ) parser.add_argument( "--data-dir", @@ -248,6 +251,12 @@ def get_parser(): help="Micro-batch size. Global batch size is inferred from this.", ) + parser.add_argument( + "--include-unrecognized-vocab-in-dataset", + action="store_true", + help="If set to True, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to False which means any gene identifier not in the user supplied tokenizer vocab will be excluded.", + ) + # TODO consider whether nemo.run or some other method can simplify this config class lookup. config_class_options: Dict[str, Type[BioBertConfig]] = { "GeneformerConfig": GeneformerConfig, diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/sc_memmap.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/sc_memmap.py deleted file mode 100644 index 78933043a7..0000000000 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/sc_memmap.py +++ /dev/null @@ -1,324 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import argparse -import json -import os -from functools import partial -from multiprocessing import Lock, Manager, Pool -from pathlib import Path -from typing import Dict, List, Sequence - -import numpy as np -import pandas as pd -import scanpy -from tqdm import tqdm - - -GLOBAL_LOCK = Lock() - -__all__: Sequence[str] = ( - "create_metadata", - "calculate_running_sums", - "write_data", - "find_ann_data_files", -) - - -def create_metadata(file_path: Path, shared_dict: Dict[str, Dict[str, object]]) -> None: - """Extract a series of metadata values from `AnnData` required to process all files into memmaps. - - Note: it assumes var.feature_ids contains the gene symbols for each dataset and corresponds to the same order as the data.X columns. - - Args: - file_path (PosixPath): - Path to `AnnData` stored as *.h5ad. - shared_dict (Dict[str, Dict[str, object]]): - Dictionary to store the extracted metadata. - - Returns: - None: - If the file cannot be read or if the `data` object is None. - - """ - try: - data = scanpy.read_h5ad(file_path) - except Exception as e: - raise ValueError(f"Could not read {file_path}") from e - - if data is None: - return - - shape = data.shape - feature_ids = list(data.var.feature_id) - - if data.raw is not None: - X = data.raw.X - else: - X = data.X - - num_el = X.count_nonzero() # Count the number of non-zero elements in the sparse array, in total - # - metadata associated with each file - d = {"shape": shape, "feature_ids": feature_ids, "num_el": num_el, "file_path": str(file_path)} - - shared_dict[str(file_path)] = d - - -def calculate_running_sums(metadata): # noqa: D103 - num_el = 0 - cur_count = 0 - for k in metadata: - metadata[k]["running_el"] = num_el - metadata[k]["cur_count"] = cur_count - num_el += metadata[k]["num_el"] - cur_count += metadata[k]["shape"][0] - return metadata - - -def write_data( - file_path: Path, - obs_cols: list, - metadata: Dict[str, Dict[str, object]], - gene_data: np.ndarray, - gene_data_indices: np.ndarray, - gene_data_ptr: np.ndarray, - strict: bool = False, -) -> List[pd.DataFrame]: - """Writes `AnnData` into memmap. - - Args: - file_path (PosixPath): The path to the file. - obs_cols (List[str]): A list of columns to extract from each AnnData `obs` dataframe. - metadata (Dict[str, Dict[str, object]]): A dictionary containing metadata information - on number of elements, shape, and feature names. - gene_data (np.ndarray): The array to store gene data. - gene_data_indices (np.ndarray): The array to store gene data indices. - gene_data_ptr (np.ndarray): The array to store gene data pointers. - strict (bool): If True, only extract the columns specified in `obs_cols`. - - Returns: - List[pd.DataFrame]: The features extracted from the data. - """ - # - check if the file name exists in the metadata dictionary - if str(file_path) not in metadata: - return [] - - # Get the metadata for the file - meta = metadata[str(file_path)] - num_el = meta["num_el"] - running_el = meta["running_el"] - num_obs = meta["shape"][0] - cur_count = meta["cur_count"] - - try: - # - read the data from the file using scanpy - data = scanpy.read_h5ad(file_path) - except Exception: - print(f"couldn't read {file_path}") - return [] - - # - get the gene data from the data object - X = data.X if data.raw is None else data.raw.X # Use X if raw is not None, otherwise use raw - - # - store the gene data, indices, and pointers in the respective arrays - gene_data[running_el : running_el + num_el] = X.data # This is a flattened array with everything in it. - gene_data_indices[running_el : running_el + num_el] = X.indices.astype( - int - ) # these are flattened column indices eg [0, 1, 2, 0, 1, 3] for a 2x4 sparse matrix - gene_data_ptr[cur_count : cur_count + num_obs + 1] = X.indptr.astype(int) + int( - running_el - ) # These are mappings between row indices and ranges. eg [0, 3, 6] for a 2x4 sparse matrix - - # - extract the features from the data - # TODO: this doesnt work if obs_column doesnt have the right things in it. - if not strict: - new_obs_cols = list(set(data.obs.columns.tolist()) & set(obs_cols)) - features = data.obs[new_obs_cols] - else: - features = data.obs[obs_cols] - - # - flush the data arrays to disk - GLOBAL_LOCK.acquire() - gene_data.flush() - gene_data_ptr.flush() - gene_data_indices.flush() - GLOBAL_LOCK.release() - - return features - - -def find_ann_data_files(data_path: Path) -> List[Path]: - """Find all AnnData files with the extension '.h5ad' in the given data path and its subdirectories. - - Args: - data_path (str): The path to the directory containing the AnnData files. - - Returns: - List[str]: A list of file paths to the AnnData files. - """ - return sorted(data_path.rglob("*.h5ad")) - - -def main( - data_path: Path, - save_path: Path, - strict: bool, - num_proc: int, - use_mp: bool, - obs_cols: List[str], -) -> None: - if not save_path.exists(): - os.makedirs(save_path) - - file_paths = find_ann_data_files(data_path) - if len(file_paths) == 0: - raise ValueError(f"No files ending in .h5ad found in {data_path}, check your argument for data_path.") - - print(f"Found {len(file_paths)} files") - print("Starting to create memmap files...") - # - create metadata required to store data into memmap - - manager = Manager() - shared_dict = manager.dict() - metadata_path = save_path / "metadata.json" - if metadata_path.exists(): - print("Metadata already exists, loading...") - with open(metadata_path, "r") as fp: - metadata = json.load(fp) - else: - if use_mp: - with Pool(num_proc) as pool: - _ = list( - tqdm( - pool.imap(partial(create_metadata, shared_dict=shared_dict), file_paths), - desc="Creating metadata...", - total=len(file_paths), - ) - ) - else: - for file_path in tqdm(file_paths, desc="Creating metadata..."): - create_metadata(file_path, shared_dict) - - metadata = dict(shared_dict) - - for k, v in metadata.items(): - assert v["shape"][1] == len(v["feature_ids"]), f"feature names and shape mismatch for file {k}" - - with open(metadata_path, "w") as fp: - json.dump(metadata, fp) - - print("Done creating `metadata.json`") - - print(f"Writing data into memmaps to {save_path}...") - - # - calculate totals to initalize array sizes - total_el = sum([v["num_el"] for k, v in metadata.items()]) - num_samples = sum([v["shape"][0] for k, v in metadata.items()]) - gene_path = save_path - - # - init or append mode memmap files - gene_data = np.memmap( - gene_path / "gene_expression_data.npy", - dtype="float32", - mode="w+" if not os.path.exists(gene_path / "gene_expression_data.npy") else "r+", - shape=(total_el,), - ) - - gene_data_indices = np.memmap( - gene_path / "gene_expression_ind.npy", - dtype="int32", - mode="w+" if not os.path.exists(gene_path / "gene_expression_ind.npy") else "r+", - shape=(total_el,), - ) - - gene_data_ptr = np.memmap( - gene_path / "gene_expression_ptr.npy", - dtype="int64", - mode="w+" if not os.path.exists(gene_path / "gene_expression_ptr.npy") else "r+", - shape=(num_samples + 1,), - ) - - with open(save_path / "metadata.json", "rt") as rt: - metadata: dict = json.load(rt) - - # - start processing all files - metadata = calculate_running_sums(metadata) - - features = [] - for fp in tqdm(file_paths, desc="Merging AnnData into numpy memaps..."): - feature = write_data( - fp, - obs_cols=obs_cols, - metadata=metadata, - gene_data=gene_data, - gene_data_indices=gene_data_indices, - gene_data_ptr=gene_data_ptr, - strict=strict, - ) - features.append(feature) - - print("Saving dataframe ...") - df = pd.concat(features) - df.to_csv(save_path / "features.csv", index=False) - print("Done creating dataset ...") - - -def main_cli(): - parser = argparse.ArgumentParser("Converts a series of AnnData objects into a memmap format") - parser.add_argument("--save-path", "--sp", type=str, default="./", help="save path to save memmap files") - parser.add_argument("--data-path", "--dp", type=str, default="./data", help="path to the data") - parser.add_argument("--use-mp", "-mp", action="store_true", help="use multiprocessing") - parser.add_argument( - "--strict-metadata", - "-strict", - dest="strict", - action="store_true", - help="Fails if any of the columns in obs_cols are not present in the AnnData object.", - ) - parser.add_argument( - "--num-workers", "--nw", type=int, default=12, help="number of workers to use for multi-processing" - ) - parser.add_argument( - "--obs-cols", - nargs="+", - default=[ - "suspension_type", - "is_primary_data", - "cell_type", - "assay", - "disease", - "tissue_general", - "sex", - "tissue", - "self_reported_ethnicity", - "development_stage", - ], - help="series of columns to extract from each AnnData `obs` dataframe", - ) - # - XXX: obs-cols argument can be turned into a txt file input if the list is long - args = parser.parse_args() - main( - data_path=Path(args.data_path), - save_path=Path(args.save_path), - strict=args.strict, - num_proc=args.num_workers, - use_mp=args.use_mp, - obs_cols=args.obs_cols, - ) - - -if __name__ == "__main__": - main_cli() diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py index b4dad05ac3..f3e5fa2bd3 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/scripts/train_geneformer.py @@ -75,11 +75,13 @@ def main( wandb_offline: bool = False, wandb_tags: List[str] | None = None, wandb_group: Optional[str] = None, + wandb_job_type: Optional[str] = None, wandb_id: Optional[str] = None, wandb_anonymous: bool = False, wandb_log_model: bool = False, create_tensorboard_logger: bool = False, nemo1_init_path: Path | None = None, + create_checkpoint_callback: bool = True, restore_from_checkpoint_path: Path | None = None, num_layers: int = 6, hidden_size: int = 256, @@ -97,6 +99,7 @@ def main( gc_interval: int = 0, aligned_megatron_ddp: bool = False, recompilation_check: bool = False, + include_unrecognized_vocab_in_dataset: bool = False, # TODO add datamodule class, and ability to change data step to get full support for pretraining workflows ) -> None: """Train a Geneformer model on single cell data. @@ -131,11 +134,13 @@ def main( wandb_project (str): The name of the project to which this run will belong. wandb_tags (List[str]): Tags associated with this run. wandb_group (str): A unique string shared by all runs in a given group + wandb_job_type (Optional[str]): Type of run, which is useful when you're grouping runs together into larger experiments using group. wandb_offline (bool): Run offline (data can be streamed later to wandb servers). wandb_id (str): Sets the version, mainly used to resume a previous run. wandb_anonymous (bool): Enables or explicitly disables anonymous logging. wandb_log_model (bool): Save checkpoints in wandb dir to upload on W&B servers. create_tensorboard_logger (bool): create the tensorboard logger + create_checkpoint_callback (bool): create a ModelCheckpoint callback and attach it to the pytorch lightning trainer restore_from_checkpoint_path (path): If set, restores the model from the directory passed in. Expects the checkpoint to be created by using the ModelCheckpoint class and always_save_context=True. num_layers (int): Number of layers in geneformer. Default to 6. @@ -155,6 +160,7 @@ def main( good for clusters. This will likely slow down single node runs though. recompilation_check (bool): enable a recompilation check (only do on a small run) to verify that fused gpu kernels are not being regularly recompiled, which is very expensive, with a particular model/settings. + include_unrecognized_vocab_in_dataset (bool): If set to True, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to False which means any gene identifier not in the user supplied tokenizer vocab will be excluded.. """ # Create the result directory if it does not exist. if wandb_tags is None: @@ -213,6 +219,7 @@ def main( entity=wandb_entity, tags=wandb_tags, group=wandb_group, + job_type=wandb_job_type, id=wandb_id, anonymous=wandb_anonymous, log_model=wandb_log_model, @@ -251,6 +258,7 @@ def main( callbacks=callbacks, use_distributed_sampler=False, plugins=nl.MegatronMixedPrecision(precision=precision), + enable_checkpointing=create_checkpoint_callback, ) preprocessor = GeneformerPreprocess( @@ -279,6 +287,7 @@ def main( persistent_workers=num_dataset_workers > 0, pin_memory=False, num_workers=num_dataset_workers, + include_unrecognized_vocab_in_dataset=include_unrecognized_vocab_in_dataset, ) geneformer_config = config_class( num_layers=num_layers, @@ -325,14 +334,17 @@ def main( ), ) # Configure our custom Checkpointer - checkpoint_callback = nl_callbacks.ModelCheckpoint( - save_last=save_last_checkpoint, - monitor=metric_to_monitor_for_checkpoints, - save_top_k=save_top_k, - every_n_train_steps=val_check_interval, - always_save_context=True, # Enables the .nemo file-like checkpointing where all IOMixins are under SerDe - filename="{epoch}-{val_loss:.2f}-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. - ) + if create_checkpoint_callback: + checkpoint_callback = nl_callbacks.ModelCheckpoint( + save_last=save_last_checkpoint, + monitor=metric_to_monitor_for_checkpoints, + save_top_k=save_top_k, + every_n_train_steps=val_check_interval, + always_save_context=True, # Enables the .nemo file-like checkpointing where all IOMixins are under SerDe + filename="{epoch}-{val_loss:.2f}-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. + ) + else: + checkpoint_callback = None # Setup the logger and train the model nemo_logger = setup_nemo_lightning_logger( @@ -406,6 +418,12 @@ def get_parser(): parser.add_argument( "--wandb-group", type=str, default=None, help="A unique string shared by all runs in a given group" ) + parser.add_argument( + "--wandb-job-type", + type=str, + default=None, + help="A unique string representing a type of run, which is useful when you're grouping runs together into larger experiments using group.", + ) parser.add_argument( "--wandb-id", type=str, default=None, help="Sets the version, mainly used to resume a previous run" ) @@ -423,6 +441,11 @@ def get_parser(): default=0.01, help="Fraction of steps in which to ramp up the learning rate. Default is 0.01.", ) + parser.add_argument( + "--include-unrecognized-vocab-in-dataset", + action="store_true", + help="If set to true, a hard-check is performed to verify all gene identifers are in the user supplied tokenizer vocab. Defaults to False which means any gene identifier not in the user supplied tokenizer vocab will be excluded.", + ) parser.add_argument( "--cosine-hold-frac", type=float, @@ -515,6 +538,13 @@ def get_parser(): required=False, help="Path to nemo1 file, if desired to load at init time.", ) + parser.add_argument( + "--disable-checkpointing", + action="store_false", + default=True, + dest="create_checkpoint_callback", + help="Disable creating a ModelCheckpoint callback.", + ) parser.add_argument( "--save-best-checkpoint", action="store_true", @@ -654,6 +684,7 @@ def entrypoint(): wandb_project=args.wandb_project, wandb_tags=args.wandb_tags, wandb_group=args.wandb_group, + wandb_job_type=args.wandb_job_type, wandb_id=args.wandb_id, wandb_anonymous=args.wandb_anonymous, wandb_log_model=args.wandb_log_model, @@ -676,6 +707,7 @@ def entrypoint(): nsys_start_step=args.nsys_start_step, nsys_end_step=args.nsys_end_step, nsys_ranks=args.nsys_ranks, + create_checkpoint_callback=args.create_checkpoint_callback, restore_from_checkpoint_path=args.restore_from_checkpoint_path, config_class=args.training_model_config_class, save_last_checkpoint=args.save_last_checkpoint, @@ -685,6 +717,7 @@ def entrypoint(): gc_interval=args.gc_interval, aligned_megatron_ddp=args.aligned_megatron_ddp, recompilation_check=args.recompilation_check, + include_unrecognized_vocab_in_dataset=args.include_unrecognized_vocab_in_dataset, ) diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/conftest.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/conftest.py new file mode 100644 index 0000000000..1a0dc5f116 --- /dev/null +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/conftest.py @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path + +import pytest + +from bionemo.testing.data.load import load + + +@pytest.fixture +def test_directory() -> Path: + """Gets the path to the original synthetic single cell directory with test data (no feature ids). + + Returns: + A Path object that is the directory with specified test data. + """ + return load("scdl/sample") / "scdl_data" + + +@pytest.fixture +def test_directory_feat_ids() -> Path: + """Gets the path to the directory with the synthetic single cell data (with the feature ids appended). + + Returns: + A Path object that is the directory with specified test data. + """ + return load("scdl/sample_scdl_feature_ids") / "scdl_data_with_feature_ids" + + +@pytest.fixture +def cellx_small_directory() -> Path: + """Gets the path to the directory with with cellx small dataset in Single Cell Memmap format. + + Returns: + A Path object that is the directory with the specified test data. + """ + return load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py index ab7584e23b..ada85c4267 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_pydantic_train.py @@ -18,15 +18,22 @@ import subprocess from pathlib import Path +import pytest from lightning.fabric.plugins.environments.lightning import find_free_network_port from bionemo.core.data.load import load -data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" +@pytest.fixture +def data_path() -> Path: + """Gets the path to the directory with with cellx small dataset in Single Cell Memmap format. + Returns: + A Path object that is the directory with the specified test data. + """ + return load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" -def test_bionemo2_rootdir(): +def test_bionemo2_rootdir(data_path): data_error_str = ( "Please download test data with:\n" "`python scripts/download_artifacts.py --models all --model_dir ./models --data all --data_dir ./ --verbose --source pbss`" @@ -35,9 +42,10 @@ def test_bionemo2_rootdir(): assert data_path.is_dir(), f"Test data directory is supposed to be a directory.\n{data_error_str}" -def test_pretrain_cli_from_ckpt(tmpdir): +# TODO: These tests currently take an inordinate amount of time. See https://jirasw.nvidia.com/browse/BIONEMO-553 +@pytest.mark.slow +def test_pretrain_cli_from_ckpt(tmpdir, data_path): # Same as test_pretrain, but includes a checkpoint to initialize from. - data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" result_dir = Path(tmpdir.mkdir("results")) open_port = find_free_network_port() @@ -77,9 +85,11 @@ def test_pretrain_cli_from_ckpt(tmpdir): assert (result_dir / "test-experiment").exists(), "Could not find test experiment directory." -def test_pretrain_cli(tmpdir): +# TODO: These tests currently take an inordinate amount of time. See https://jirasw.nvidia.com/browse/BIONEMO-553 +@pytest.mark.slow +def test_pretrain_cli(tmpdir, data_path): """trains from scratch""" - data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" + # data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" result_dir = Path(tmpdir.mkdir("results")) open_port = find_free_network_port() @@ -117,9 +127,11 @@ def test_pretrain_cli(tmpdir): assert (result_dir / "test-experiment").exists(), "Could not find test experiment directory." -def test_finetune_cli(tmpdir): +# TODO: These tests currently take an inordinate amount of time. See https://jirasw.nvidia.com/browse/BIONEMO-553 +@pytest.mark.slow +def test_finetune_cli(tmpdir, data_path): """Uses CLI to invoke the entrypoint""" - data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" + # data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" result_dir = Path(tmpdir.mkdir("results")) checkpoint_path: Path = load("geneformer/10M_240530:2.0") diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py index 80e0d900cc..6ca0995971 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py @@ -29,18 +29,81 @@ from bionemo.testing import megatron_parallel_state_utils -data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" +@pytest.fixture +def data_path() -> Path: + """Gets the path to the directory with cellx small dataset in Single Cell Memmap format. + Returns: + A Path object that is the directory with the specified test data. + """ + return load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" -def test_bionemo2_rootdir(): +def test_bionemo2_rootdir(data_path): assert data_path.exists(), "Could not find test data directory." assert data_path.is_dir(), "Test data directory is supposed to be a directory." -@pytest.mark.parametrize("limit_val_batches", [0.0, 1]) -def test_val_dataloader_in_main_runs_with_limit_val_batches(tmpdir, limit_val_batches: float): +@pytest.mark.parametrize("create_checkpoint_callback", [True, False]) +def test_main_runs(tmpdir, create_checkpoint_callback: bool, data_path: Path): result_dir = Path(tmpdir.mkdir("results")) + with megatron_parallel_state_utils.distributed_model_parallel_state(): + main( + data_dir=data_path, + num_nodes=1, + devices=1, + seq_length=128, + result_dir=result_dir, + wandb_project=None, + wandb_offline=True, + num_steps=5, + limit_val_batches=1, + val_check_interval=2, + num_dataset_workers=0, + biobert_spec_option=BiobertSpecOption.bert_layer_local_spec, + lr=1e-4, + micro_batch_size=2, + accumulate_grad_batches=2, + cosine_rampup_frac=0.01, + cosine_hold_frac=0.01, + precision="bf16-mixed", + experiment_name="test_experiment", + resume_if_exists=False, + create_tensorboard_logger=False, + num_layers=2, + num_attention_heads=2, + hidden_size=4, + ffn_hidden_size=4 * 2, + create_checkpoint_callback=create_checkpoint_callback, + ) + + assert (result_dir / "test_experiment").exists(), "Could not find test experiment directory." + assert (result_dir / "test_experiment").is_dir(), "Test experiment directory is supposed to be a directory." + children = list((result_dir / "test_experiment").iterdir()) + assert len(children) == 1, f"Expected 1 child in test experiment directory, found {children}." + uq_rundir = children[0] # it will be some date. + + expected_exists = create_checkpoint_callback + actual_exists = (result_dir / "test_experiment" / uq_rundir / "checkpoints").exists() + + assert expected_exists == actual_exists, ( + f"Checkpoints directory existence mismatch. " + f"Expected: {'exists' if expected_exists else 'does not exist'}, " + f"Found: {'exists' if actual_exists else 'does not exist'}." + ) + + if create_checkpoint_callback: + assert ( + result_dir / "test_experiment" / uq_rundir / "checkpoints" + ).is_dir(), "Test experiment checkpoints directory is supposed to be a directory." + assert ( + result_dir / "test_experiment" / uq_rundir / "nemo_log_globalrank-0_localrank-0.txt" + ).is_file(), "Could not find experiment log." + + +@pytest.mark.parametrize("limit_val_batches", [0.0, 1]) +def test_val_dataloader_in_main_runs_with_limit_val_batches(tmpdir, data_path, limit_val_batches: float): + result_dir = Path(tmpdir.mkdir("results")) with megatron_parallel_state_utils.distributed_model_parallel_state(): main( data_dir=data_path, @@ -86,7 +149,39 @@ def test_val_dataloader_in_main_runs_with_limit_val_batches(tmpdir, limit_val_ba ).is_file(), "Could not find experiment log." -def test_pretrain_cli(tmpdir): +def test_throws_tok_not_in_vocab_error(tmpdir, data_path): + result_dir = Path(tmpdir.mkdir("results")) + with pytest.raises(ValueError) as error_info: + with megatron_parallel_state_utils.distributed_model_parallel_state(): + main( + data_dir=data_path, + num_nodes=1, + devices=1, + seq_length=128, + result_dir=result_dir, + wandb_project=None, + wandb_offline=True, + num_steps=55, + limit_val_batches=1, + val_check_interval=1, + num_dataset_workers=0, + biobert_spec_option=BiobertSpecOption.bert_layer_local_spec, + lr=1e-4, + micro_batch_size=2, + accumulate_grad_batches=2, + cosine_rampup_frac=0.01, + cosine_hold_frac=0.01, + precision="bf16-mixed", + experiment_name="test_experiment", + resume_if_exists=False, + create_tensorboard_logger=False, + include_unrecognized_vocab_in_dataset=True, + ) + + assert "not in the tokenizer vocab." in str(error_info.value) + + +def test_pretrain_cli(tmpdir, data_path): result_dir = Path(tmpdir.mkdir("results")) open_port = find_free_network_port() # NOTE: if you need to change the following command, please update the README.md example. diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_dataset.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_dataset.py new file mode 100644 index 0000000000..baf0eb3699 --- /dev/null +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_dataset.py @@ -0,0 +1,583 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-NvidiaProprietary +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +from unittest.mock import MagicMock + +import anndata as ad +import numpy as np +import pytest +import torch +from nemo.utils import logging + +from bionemo.core.data.multi_epoch_dataset import EpochIndex +from bionemo.core.utils import random_utils +from bionemo.geneformer.data.singlecell.dataset import SingleCellDataset +from bionemo.geneformer.data.singlecell.preprocess import GeneformerPreprocess +from bionemo.scdl.io.single_cell_memmap_dataset import SingleCellMemMapDataset +from bionemo.testing.megatron_dataset_compatibility import assert_dataset_elements_not_equal + + +def test_load_sc_datasets(tmp_path, test_directory_feat_ids): + tokenizer = MagicMock() + sc_memmap_dataset_path0 = tmp_path / "test_data_0" + ds_0 = SingleCellMemMapDataset( + sc_memmap_dataset_path0, h5ad_path=test_directory_feat_ids / "adata_sample0.h5ad" + ) # create the memmap dataset format from h5ad for testing purposes + dataset0 = SingleCellDataset(sc_memmap_dataset_path0, tokenizer) + assert len(dataset0) == len(ds_0) == 8 + sc_memmap_dataset_path1 = tmp_path / "test_data_1" + ds_1 = SingleCellMemMapDataset( + sc_memmap_dataset_path1, h5ad_path=test_directory_feat_ids / "adata_sample1.h5ad" + ) # create the memmap dataset format from h5ad for testing purposes + dataset1 = SingleCellDataset(sc_memmap_dataset_path1, tokenizer) + assert len(dataset1) == len(ds_1) == 6 + sc_memmap_dataset_path2 = tmp_path / "test_data_2" + ds_2 = SingleCellMemMapDataset( + sc_memmap_dataset_path2, h5ad_path=test_directory_feat_ids / "adata_sample2.h5ad" + ) # create the memmap dataset format from h5ad for testing purposes + dataset2 = SingleCellDataset(sc_memmap_dataset_path2, tokenizer) + assert len(dataset2) == len(ds_2) == 100 + + +def test_gene_not_in_tok_vocab(tmp_path, test_directory_feat_ids): + sc_memmap_dataset_path0 = tmp_path / "test_data_0_sc_memmap" + sc_h5ad_dataset_path0 = tmp_path / "test_data_0.h5ad" + + adata = ad.read_h5ad(test_directory_feat_ids / "adata_sample0.h5ad") + synthetic_ids = [ + "ENSG00000243485", + "ENSG00000186092", + "ENSG00000238009", + "ENSG00000239945", + "ENSG00000241860", + "ENSG00000241599", + "ENSG00000286448", + "ENSG00000236601", + "ENSG00000235146", + "ENSG00000229905", + ] + adata.var["feature_id"] = synthetic_ids + adata.write(sc_h5ad_dataset_path0) + SingleCellMemMapDataset( + sc_memmap_dataset_path0, h5ad_path=sc_h5ad_dataset_path0 + ) # create the memmap dataset format from h5ad for testing purposes + preprocessor = GeneformerPreprocess( + download_directory=sc_memmap_dataset_path0, + medians_file_path=sc_memmap_dataset_path0 / "medians.json", + tokenizer_vocab_path=sc_memmap_dataset_path0 / "geneformer.vocab", + ) + match preprocessor.preprocess(): + case {"tokenizer": tokenizer, "median_dict": median_dict}: + logging.info("*************** Preprocessing Finished ************") + case _: + logging.error("Preprocessing failed.") + + dataset0 = SingleCellDataset( + sc_memmap_dataset_path0, tokenizer, median_dict=median_dict, include_unrecognized_vocab_in_dataset=True + ) # type: ignore + index = EpochIndex(epoch=0, idx=3) + with pytest.raises(ValueError) as error_info: + dataset0.__getitem__(index) + assert "not in the tokenizer vocab." in str(error_info.value) + dataset0 = SingleCellDataset( + sc_memmap_dataset_path0, + tokenizer, + median_dict=median_dict, + ) # type: ignore + + item = dataset0.__getitem__(index) + assert np.array(item["text"].tolist()) == [0] + + +def test_empty_gene_data_input(tmp_path, test_directory_feat_ids): + sc_memmap_dataset_path0 = tmp_path / "test_data_0" + SingleCellMemMapDataset( + sc_memmap_dataset_path0, h5ad_path=test_directory_feat_ids / "adata_sample0.h5ad" + ) # create the memmap dataset format from h5ad for testing purposes + preprocessor = GeneformerPreprocess( + download_directory=sc_memmap_dataset_path0, + medians_file_path=sc_memmap_dataset_path0 / "medians.json", + tokenizer_vocab_path=sc_memmap_dataset_path0 / "geneformer.vocab", + ) + match preprocessor.preprocess(): + case {"tokenizer": tokenizer, "median_dict": median_dict}: + logging.info("*************** Preprocessing Finished ************") + case _: + logging.error("Preprocessing failed.") + dataset0 = SingleCellDataset(sc_memmap_dataset_path0, tokenizer, median_dict=median_dict) # type: ignore + index = EpochIndex(epoch=0, idx=1) + with pytest.raises(ValueError) as error_info: + dataset0.__getitem__(index) + assert ( + "SingleCellMemap data provided is invalid; the gene expression data parsed for the specified index is empty." + == str(error_info.value) + ) + + +def test_lookup_row(tmp_path, cellx_small_directory): + tokenizer = MagicMock() + dataset = SingleCellDataset(tmp_path / cellx_small_directory / "val", tokenizer) + values, feature_ids = dataset.scdl.get_row(0, return_features=True, feature_vars=["feature_id"]) + gene_data, col_idxs = values[0], values[1] + assert len(gene_data) == 440 + assert len(col_idxs) == 440 + assert len(feature_ids[0]) == 60664 + + values, feature_ids = dataset.scdl.get_row(len(dataset) - 1, return_features=True, feature_vars=["feature_id"]) + gene_data, col_idxs = values[0], values[1] + assert len(gene_data) == 1147 + assert len(col_idxs) == 1147 + assert len(feature_ids[0]) == 60664 + + +def test_get_item_synthetic(tmp_path, test_directory_feat_ids): + sc_memmap_dataset_path0 = tmp_path / "test_data_0" + SingleCellMemMapDataset( + sc_memmap_dataset_path0, h5ad_path=test_directory_feat_ids / "adata_sample0.h5ad" + ) # create the memmap dataset format from h5ad for testing purposes + preprocessor = GeneformerPreprocess( + download_directory=sc_memmap_dataset_path0, + medians_file_path=sc_memmap_dataset_path0 / "medians.json", + tokenizer_vocab_path=sc_memmap_dataset_path0 / "geneformer.vocab", + ) + match preprocessor.preprocess(): + case {"tokenizer": tokenizer, "median_dict": median_dict}: + logging.info("*************** Preprocessing Finished ************") + case _: + logging.error("Preprocessing failed.") + dataset0 = SingleCellDataset( + sc_memmap_dataset_path0, + tokenizer, + median_dict=median_dict, + mask_token_prob=0, + mask_prob=0, + random_token_prob=0, + ) # type: ignore + index = EpochIndex(epoch=0, idx=0) + item = dataset0.__getitem__(index) + assert np.all(np.array(item["text"]) == np.array([0, 10])) + assert np.all(np.array(item["types"]) == np.array([0, 0])) + assert np.all(np.array(item["attention_mask"]) == np.array([1, 1])) + assert np.all(np.array(item["labels"]) == np.array([-1, -100])) + assert np.all(np.array(item["loss_mask"]) == np.array([False, False])) + assert np.all(np.array(item["is_random"]) == np.array([0, 0])) + + +def test_GeneformerDataset_changes_with_epoch(tmp_path, cellx_small_directory): + preprocessor = GeneformerPreprocess( + download_directory=tmp_path / cellx_small_directory / "val", + medians_file_path=tmp_path / cellx_small_directory / "val" / "medians.json", + tokenizer_vocab_path=tmp_path / cellx_small_directory / "val" / "geneformer.vocab", + ) + match preprocessor.preprocess(): + case {"tokenizer": tokenizer, "median_dict": median_dict}: + logging.info("*************** Preprocessing Finished ************") + case _: + logging.error("Preprocessing failed.") + genformer_ds = SingleCellDataset( + tmp_path / cellx_small_directory / "val", + tokenizer, # type: ignore + median_dict=median_dict, # type: ignore + ) # type: ignore + + index_0 = EpochIndex(epoch=0, idx=0) + index_1 = EpochIndex(epoch=1, idx=0) + + # Tests megatron validity (subsequent calls to the same index produce the same result) and epoch non-determinism + assert_dataset_elements_not_equal(genformer_ds, index_0, index_1) + + +def test_get_item_cellx(tmp_path, cellx_small_directory): + preprocessor = GeneformerPreprocess( + download_directory=tmp_path / cellx_small_directory / "val", + medians_file_path=tmp_path / cellx_small_directory / "val" / "medians.json", + tokenizer_vocab_path=tmp_path / cellx_small_directory / "val" / "geneformer.vocab", + ) + match preprocessor.preprocess(): + case {"tokenizer": tokenizer, "median_dict": median_dict}: + logging.info("*************** Preprocessing Finished ************") + case _: + logging.error("Preprocessing failed.") + ds = SingleCellDataset( + tmp_path / cellx_small_directory / "val", + tokenizer, # type: ignore + median_dict=median_dict, # type: ignore + mask_prob=0, + mask_token_prob=0, + random_token_prob=0, + ) # type: ignore + index = EpochIndex(epoch=0, idx=2) + item = ds.__getitem__(index) + expected_output_first = np.array( + [ + 0, + 20502, + 15942, + 8191, + 2701, + 16227, + 8932, + 14368, + 5209, + 11346, + 10122, + 8806, + 530, + 8016, + 7788, + 6755, + 10695, + 5767, + 12231, + 3813, + 8639, + 11447, + 17704, + 20034, + 16715, + 3141, + 12632, + 18986, + 8715, + 16351, + 11897, + 3672, + 3364, + 2453, + 3833, + 6925, + 12089, + 6396, + 257, + 3951, + 14400, + 9758, + 6860, + 6267, + 467, + 11899, + 5070, + 8870, + 3974, + 3084, + 10804, + 2187, + 2346, + 17722, + 11845, + 11551, + 16387, + 12822, + 18577, + 10201, + 1955, + 2744, + 10991, + 11911, + 7822, + 20491, + 1078, + 2552, + 12177, + 6716, + 9503, + 10404, + 12220, + 8298, + 8471, + 4092, + 6885, + 2386, + 16454, + 5641, + 8417, + 12754, + 18000, + 154, + 15484, + 8458, + 2964, + 4217, + 469, + 3058, + 19800, + 5816, + 8309, + 17681, + 16909, + 9566, + 18037, + 17578, + 1634, + 11592, + ] + ) + expected_output_last = np.array( + [ + 4502, + 1145, + 12212, + 3667, + 14669, + 811, + 8670, + 2291, + 1986, + 10551, + 4544, + 15361, + 7906, + 12532, + 4719, + 1336, + 12062, + 16414, + 3438, + 12258, + 10295, + 3008, + 14606, + 19632, + 12418, + 12655, + 12185, + 235, + 12018, + 7505, + 11927, + 653, + 887, + 12533, + 1686, + 7289, + 103, + 17298, + 5611, + 20504, + 6552, + 8305, + 1436, + 4883, + 5578, + 708, + 20343, + 4390, + 6241, + 2563, + 16300, + 20888, + 1873, + 10956, + 4491, + 9515, + 2403, + 6269, + 14978, + 4828, + 12412, + 16728, + 9665, + 5084, + 3781, + 6255, + 8568, + 14059, + 6564, + 1629, + 758, + 14814, + 9749, + 15807, + 17317, + 6657, + 3829, + 7196, + 7329, + 2347, + 4812, + 1052, + 3615, + 13011, + 12175, + 10948, + 611, + 13008, + 8255, + 13747, + 8519, + 4764, + 13814, + 10324, + 14631, + 6182, + 7248, + 16740, + 6386, + 11411, + ] + ) + assert all(np.array(item["text"][:100]) == expected_output_first) + assert all(np.array(item["text"][-100:]) == expected_output_last) + assert np.array(item["labels"])[0] == -1 + assert np.all(np.array(item["labels"][1:]) == -100) + + +def test_dataset_process_item(): + tokenizer = MagicMock() + + tokenizer.pad_token = "pad" + tokenizer.cls_token = "cls" + tokenizer.mask_token = "mask" + tokenizer.ukw_token = "ukn" + tokenizer.gene_tok_to_ens = lambda x: x + tokenizer.mask_token_id = 6 + + # Need this to mock the underlying dictionary behavior with arbitrary keys + class gene_to_ens: + @staticmethod + def get(x, other): + return x + + tokenizer.gene_to_ens = gene_to_ens + tokenizer.vocab = {"GENE0": 1, "GENE1": 2, "GENE2": 3, "ukn": 7, "mask": 6, "cls": 5, "pad": 4} + + def tok_to_id(tok): + if tok == tokenizer.pad_token: + return 4 + if tok == tokenizer.cls_token: + return 5 + if tok == tokenizer.mask_token: + return 6 + if tok == tokenizer.ukw_token: + return 7 + if tok == "GENE0": + return 1 + if tok == "GENE1": + return 2 + if tok == "GENE2": + return 3 + + tokenizer.token_to_id = tok_to_id + # Create a sample input item + input_item = { + "expression": np.array([1, 2, 3]), + "indices": np.array([0, 1, 2]), + "metadata": np.array([f"GENE{i}" for i in range(3)]), + } + + # Process the input item + from bionemo.geneformer.data.singlecell.dataset import process_item + + seed = 42 + rng = np.random.default_rng(seed) + seed = random_utils.get_seed_from_rng(rng) + idx = 0 + rng = np.random.default_rng([seed, idx]) + + processed_item = process_item( + input_item["expression"], + input_item["indices"], + input_item["metadata"], + tokenizer, + gene_median={"GENE0": 1, "GENE1": 1, "GENE2": 1}, + max_len=5, + mask_prob=0, + rng=rng, + ) + assert all(processed_item["text"] == torch.tensor([5, 3, 2, 1])) # CLS, 1, 2, 3, but in reverse order + # The following is used as 'attention_mask' in NeMo, so it's probably the opposite of what you think it should be. + assert all(processed_item["attention_mask"] == torch.tensor([1, 1, 1, 1])) # this is all 1s + + ###### Check median rank norm, sorts in ascending order. ###### + + # 1/6/1=1/6 , 2/3/6 =2/18=1/9, 3/6/6 =3/36=1/12 => 3, 2, 1 + processed_item = process_item( + input_item["expression"], + input_item["indices"], + input_item["metadata"], + tokenizer, + gene_median={"GENE0": 1, "GENE1": 3, "GENE2": 6}, + max_len=4, + mask_prob=0, + target_sum=1, + rng=rng, + ) + assert all(processed_item["text"] == torch.tensor([5, 1, 2, 3])) + + # Checks median norm, should change the order due to medians. + # 1/6/.5=1/3, 2/6/1=2/6=1/3, 3/6/2=3/12=1/4 + processed_item = process_item( + input_item["expression"], + input_item["indices"], + input_item["metadata"], + tokenizer, + gene_median={"GENE0": 0.5, "GENE1": 1, "GENE2": 2}, + max_len=4, + mask_prob=0, + target_sum=1, + rng=rng, + ) + assert all(processed_item["text"] == torch.tensor([5, 1, 2, 3])) + + # Masking - test that no special tokens are masked, all when 100, none when 0 + processed_item = process_item( + input_item["expression"], + input_item["indices"], + input_item["metadata"], + tokenizer, + gene_median={"GENE0": 1, "GENE1": 1, "GENE2": 1}, + random_token_prob=0, + max_len=5, + mask_prob=1.0, + mask_token_prob=1.0, + target_sum=1, + rng=rng, + ) + # NOTE: we need to set masked tokens to MASK so that they are decoded. + assert all(processed_item["text"] == torch.tensor([5, 6, 6, 6])) # CLS, MASK, MASK, MASK + # NOTE: MASKed tokens are the only ones used by loss + assert all(processed_item["loss_mask"] == torch.tensor([False, True, True, True])) # NO, MASK, MASK, MASK, NO + # the ARBITRARY labels should be ignored due to loss mask. + assert all(processed_item["labels"] == torch.tensor([-1, 3, 2, 1])) # ARBITRARY, 3, 2, 1, ARBITRARY + assert all(processed_item["is_random"] == 0) # For now we don't support random masking. + + # checks sequence is truncated for a long sequence + processed_item = process_item( + input_item["expression"], + input_item["indices"], + input_item["metadata"], + tokenizer, + gene_median={"GENE0": 1, "GENE1": 1, "GENE2": 1}, + max_len=3, + mask_prob=0, + target_sum=1, + rng=rng, + ) + # Randomly permutes the other values, no fixed order + assert processed_item["text"][0] == torch.tensor([5]) + # Truncate to exactly three items + assert len(processed_item["text"]) == 3 + assert all(processed_item["loss_mask"] == torch.tensor([False, False, False])) # No mask applied diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py index d679eeb023..64dbda2f41 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_model.py @@ -14,7 +14,6 @@ # limitations under the License. import math -import re import tarfile from copy import deepcopy from pathlib import Path @@ -65,7 +64,7 @@ nemo2_release_checkpoint_path: Path = load("geneformer/10M_240530:2.0") nemo_1_per_layer_outputs_path: Path = load("single_cell/nemo1-geneformer-per-layer-outputs") nemo_1_expected_values_path: Path = load("single_cell/nemo1-geneformer-golden-vals") -data_path: Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" +data_path: Path = load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" CELLS_FOR_TEST: List[List[str]] = [ @@ -261,9 +260,6 @@ def __getitem__(self, idx): return {"text": self.input_ids[idx], "attention_mask": self.mask[idx]} -@pytest.mark.xfail( - re.search(r"h[1-9]00", torch.cuda.get_device_name().lower()) is not None, reason="Known issue on H100 GPUs" -) def test_geneformer_nemo1_v_nemo2_inference_golden_values( geneformer_config: GeneformerConfig, cells: List[List[str]], seed: int = 42 ): diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py index 07f91f6160..7be7abfce1 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/test_stop_and_go.py @@ -46,7 +46,7 @@ from bionemo.testing.harnesses.mode import Mode -DATA_PATH: pathlib.Path = load("single_cell/testdata-20240506") / "cellxgene_2023-12-15_small" / "processed_data" +DATA_PATH: pathlib.Path = load("single_cell/testdata-20241203") / "cellxgene_2023-12-15_small_processed_scdl" MODEL_PRECISION: Literal["bf16-mixed"] = "bf16-mixed" SEQ_LEN: int = 1024 diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py b/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py index e1b018cf63..9f72d4d04e 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/data/collate.py @@ -28,6 +28,9 @@ _warned_once: bool = False +MLM_LOSS_IGNORE_INDEX = -100 # This should match the masked value used in the MLM loss mask. + + def padding_collate_fn( batch: Sequence[_T], padding_values: dict[str, int], @@ -105,7 +108,7 @@ def bert_padding_collate_fn( "text": padding_value, "types": 0, "attention_mask": False, - "labels": -100, # This should match the masked value used in the MLM loss mask. + "labels": MLM_LOSS_IGNORE_INDEX, # This should match the masked value used in the MLM loss mask. "loss_mask": False, "is_random": 0, } diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py b/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py index e6c0f6177d..a2065a2a02 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py @@ -301,6 +301,7 @@ class TrainingConfig(BaseModel): accelerator (str, optional): The type of accelerator to use for training. Defaults to "gpu". gc_interval (int, optional): The interval of global steps at which to run synchronized garbage collection. Useful for synchronizing garbage collection when performing distributed training. Defaults to 0. include_perplexity (bool, optional): Whether to include perplexity in the validation logs. Defaults to False. + enable_checkpointing (bool, optional): Whether to enable checkpointing and configure a default ModelCheckpoint callback if there is no user-defined ModelCheckpoint. Corresponds to the same parameter name in pl.Trainer """ max_steps: int @@ -311,6 +312,7 @@ class TrainingConfig(BaseModel): # NOTE: VERY important for distributed training performance. gc_interval: int = 0 include_perplexity: bool = False + enable_checkpointing: bool = True class OptimizerSchedulerConfig(BaseModel): @@ -351,6 +353,7 @@ class ExperimentConfig(BaseModel): metric_to_monitor_for_checkpoints (str): Metric to monitor for saving top-k checkpoints. Default is "reduced_train_loss". save_top_k (int): Number of top checkpoints to save based on the monitored metric. Default is 2. create_tensorboard_logger (bool): Flag to create a TensorBoard logger. Default is False. + create_checkpoint_callback (bool): Flag to create a ModelCheckpoint callback """ save_every_n_steps: int @@ -362,6 +365,7 @@ class ExperimentConfig(BaseModel): metric_to_monitor_for_checkpoints: str = "reduced_train_loss" save_top_k: int = 2 create_tensorboard_logger: bool = False + create_checkpoint_callback: bool = True @field_serializer("result_dir") def serialize_paths(self, value: pathlib.Path) -> str: # noqa: D102 @@ -425,3 +429,9 @@ def run_bionemo_model_config_model_validators(self) -> "MainConfig": def run_data_config_model_validators(self) -> "MainConfig": """Runs the model validators on the data_config.""" return self.data_config.custom_model_validator(self) + + @model_validator(mode="after") + def validate_checkpointing_setting(self) -> "MainConfig": + """Validates the master configuration object.""" + self.training_config.enable_checkpointing = self.experiment_config.create_checkpoint_callback + return self diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/train.py b/sub-packages/bionemo-llm/src/bionemo/llm/train.py index 7626deb43c..094b763af6 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/train.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/train.py @@ -20,6 +20,7 @@ from typing import Optional from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary +from megatron.core.distributed import DistributedDataParallelConfig from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm @@ -30,6 +31,7 @@ from nemo.utils import logging from pydantic import BaseModel +from bionemo.core.utils.dtypes import get_autocast_dtype from bionemo.llm.lightning import BionemoLightningModule, PerplexityLoggingCallback from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.lr_scheduler import WarmupAnnealDecayHoldScheduler @@ -65,14 +67,17 @@ def nemo_logger_factory(experiment_config: ExperimentConfig, wandb_config: Optio Returns: nl.NeMoLogger: An instance of NeMoLogger configured with the specified settings. """ - checkpoint_callback = nl_callbacks.ModelCheckpoint( - save_last=experiment_config.save_last_checkpoint, - monitor=experiment_config.metric_to_monitor_for_checkpoints, - save_top_k=experiment_config.save_top_k, - every_n_train_steps=experiment_config.save_every_n_steps, - always_save_context=True, - filename="{epoch}-{val_loss:.2f}-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. - ) + if experiment_config.create_checkpoint_callback: + checkpoint_callback = nl_callbacks.ModelCheckpoint( + save_last=experiment_config.save_last_checkpoint, + monitor=experiment_config.metric_to_monitor_for_checkpoints, + save_top_k=experiment_config.save_top_k, + every_n_train_steps=experiment_config.save_every_n_steps, + always_save_context=True, + filename="{epoch}-{val_loss:.2f}-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. + ) + else: + checkpoint_callback = None nemo_logger = setup_nemo_lightning_logger( root_dir=experiment_config.result_dir, @@ -107,10 +112,17 @@ def setup_trainer( strategy = nl.MegatronStrategy( tensor_model_parallel_size=parallel_config.tensor_model_parallel_size, pipeline_model_parallel_size=parallel_config.pipeline_model_parallel_size, - ddp="megatron", + pipeline_dtype=get_autocast_dtype(training_config.precision), + ddp=DistributedDataParallelConfig( + check_for_nan_in_grad=True, + overlap_grad_reduce=True, + overlap_param_gather=False, # TODO waiting for NeMo fix + average_in_collective=True, + use_distributed_optimizer=True, + ), find_unused_parameters=True, + gradient_as_bucket_view=True, ckpt_include_optimizer=True, - # NOTE: there are issues related to async that may occur, most recently observed due to duplicate filenames. ckpt_async_save=True, ckpt_parallel_load=True, ) @@ -151,7 +163,14 @@ def setup_trainer( val_check_interval=training_config.val_check_interval, num_nodes=parallel_config.num_nodes, callbacks=callbacks, - plugins=nl.MegatronMixedPrecision(precision=training_config.precision), + plugins=nl.MegatronMixedPrecision( + precision=training_config.precision, + params_dtype=get_autocast_dtype(training_config.precision), + pipeline_dtype=get_autocast_dtype(training_config.precision), + grad_reduce_in_fp32=False, + autocast_enabled=False, + ), + enable_checkpointing=training_config.enable_checkpointing, ) return trainer diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py index 912d67bf7b..ed59a1a11b 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/logger_utils.py @@ -37,6 +37,7 @@ class WandbConfig(BaseModel): project: The name of the project to which this run will belong. tags: Tags associated with this run. group: A unique string shared by all runs in a given group + job_type: Type of run, which is useful when you're grouping runs together into larger experiments. offline: Run offline (data can be streamed later to wandb servers). id: Sets the version, mainly used to resume a previous run. anonymous: Enables or explicitly disables anonymous logging. @@ -47,7 +48,10 @@ class WandbConfig(BaseModel): # name: #Display name for the run. "This is handled by NeMoLogger" # save_dir: #Path where data is saved. "This is handled by NeMoLogger" tags: List[str] | None # Tags associated with this run. - group: str | None # A unique string shared by all runs in a given group + group: str | None # A unique string shared by all runs in a given group. + job_type: str | None = ( + None # Type of run, which is useful when you're grouping runs together into larger experiments. + ) offline: bool # Run offline (data can be streamed later to wandb servers). id: str | None # Sets the version, mainly used to resume a previous run. anonymous: bool # Enables or explicitly disables anonymous logging. diff --git a/sub-packages/bionemo-noodles/rust/src/lib.rs b/sub-packages/bionemo-noodles/rust/src/lib.rs index 28cd38fe76..0591608174 100644 --- a/sub-packages/bionemo-noodles/rust/src/lib.rs +++ b/sub-packages/bionemo-noodles/rust/src/lib.rs @@ -155,6 +155,7 @@ impl PyIndexedMmapFastaReader { .map(|record| PyFaidxRecord::from(record)) .collect(); } + fn read_sequence_mmap(&self, region_str: &str) -> PyResult { self.inner .read_sequence_mmap(region_str) diff --git a/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py b/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py index cd44ab1d49..896a48eadc 100644 --- a/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py +++ b/sub-packages/bionemo-noodles/src/bionemo/noodles/nvfaidx.py @@ -147,14 +147,38 @@ class NvFaidx: See Also: bionemo.noodles.nvfaidx.SequenceAccessor """ - def __init__(self, fasta_path: str | Path, faidx_path: Optional[str | Path] = None, ignore_existing_fai=True): + def __init__( + self, + fasta_path: str | Path, + faidx_path: Optional[str | Path] = None, + ignore_existing_fai: bool = True, + allow_duplicate_seqids: bool = False, + ): """Construct a dict-like object representing a memmapped, indexed FASTA file. + This is an indexed fasta reader. Consequences of this are that the FASTA file must be well formed, meaning + sequence-ids and line-lengths must conform to FASTA standards. Additionally, the order of returned seqid, sequence + pairs when iterating over the index is not guaranteed to be the same order as the underlying fasta file. + Args: fasta_path (str): Path to the FASTA file. faidx_path (str): Path to the FAI index file. If None, one will be created. ignore_existing_fai (bool): If True, ignore any existing FAI file and create an in-memory index. Note that this will also ignore `faidx_path`. + allow_duplicate_seqids (bool): If true, will produce index for invalid fastas which contain duplicate seqids. + In this scenario, indexing is performed by integer rather than strings. + + Example with invalid seqids. + >chr1 dupes|not|allowd + ATGATGATGATG + >chr1 whoops|there|is|dupe + ATGATGATGATG + NvFaidx: + { + 0 : SequenceAccessor(chr1 dupes|not|allowed), + 1 : SequenceAccessor(chr1 whoops|there|is|dupe) + } + """ if isinstance(fasta_path, Path): fasta_path = str(fasta_path) @@ -178,7 +202,14 @@ def __init__(self, fasta_path: str | Path, faidx_path: Optional[str | Path] = No case _: raise ValueError("unreachable condition.") - self.records: Dict[str, PyFaidxRecord] = {record.name: record for record in self.reader.records()} + self.records: Dict[str | int, PyFaidxRecord] = {record.name: record for record in self.reader.records()} + if len(self.records) != len(self.reader.records()): + if not allow_duplicate_seqids: + raise ValueError( + "Non-unique sequence-id detected in FASTA, this is invalid. Correct headers and try again or pass allow_duplicate_seqid'" + ) + else: + self.records: Dict[str | int, PyFaidxRecord] = dict(enumerate(self.reader.records())) def __getitem__(self, seqid: str) -> SequenceAccessor: # noqa: D105 if seqid not in self.records: diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/dupes.fasta b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/dupes.fasta new file mode 100644 index 0000000000..f201e4c158 --- /dev/null +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/data/dupes.fasta @@ -0,0 +1,17 @@ +>chr1 version|of|seq1 +ACTGACTGACTG +>chr1 version|of|seq2 +GGTCAAGGTCAA +>chr1 some|random|inputs +AGTCAAGGTCCA +CGTCAAGGTCCC +GGTCAAGGTCCG +TGTCAAGGTCCT +AGTCAAGGTCAA +CGTCAAGGTCAC +GGTCAAGGTCAG +>chr1 why|is|this|done +CCCCCCCCCCCC +ACGT +>chr1 stop|violated|fasta|spec +A diff --git a/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py index c273370efd..ece33e056d 100644 --- a/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py +++ b/sub-packages/bionemo-noodles/tests/bionemo/noodles/test_nvfaidx.py @@ -32,6 +32,11 @@ def sample_fasta(): return str(pathlib.Path(__file__).parent.parent.parent / "bionemo/noodles/data/sample.fasta") +@pytest.fixture +def dupes_fasta(): + return str(pathlib.Path(__file__).parent.parent.parent / "bionemo/noodles/data/dupes.fasta") + + def test_create_faidx_rustbind(): filename = create_test_fasta(num_seqs=2, seq_length=200) faidx_filename = PyIndexedMmapFastaReader.create_faidx(filename, force=False) @@ -345,6 +350,16 @@ def test_parallel_index_creation_nvfaidx(): assert all(lens_equal), (set(lens), sum(lens_equal)) +def test_duplicate_seqids(dupes_fasta): + # Fails since we will get back 1 entry in our dict with 5 in our records list. + with pytest.raises(ValueError): + index = NvFaidx(dupes_fasta, allow_duplicate_seqids=False) + + index = NvFaidx(dupes_fasta, allow_duplicate_seqids=True) + assert list(index.records.keys()) == list(range(5)) + assert len(index) == 5 + + def test_file_errors(): # test missing fasta file # test failure to parse fasta file diff --git a/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py b/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py index 0c128e76e2..8a90f3b049 100644 --- a/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py +++ b/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py @@ -29,7 +29,8 @@ def test_directory() -> Path: Returns: A Path object that is the directory with test data. """ - return load("scdl/sample") / "scdl_data" + # return load("scdl/sample") / "scdl_data" + return load("scdl/sample_scdl_feature_ids", source="pbss") / "scdl_data_with_feature_ids" @pytest.fixture diff --git a/tach.toml b/tach.toml index 1a09b9b94f..8bb10ef323 100644 --- a/tach.toml +++ b/tach.toml @@ -59,6 +59,7 @@ path = "bionemo.geneformer" depends_on = [ { path = "bionemo.core" }, { path = "bionemo.llm" }, + { path = "bionemo.scdl" }, ] [[modules]] From 5631b93c85dafaaf98fef95bdb478735a6e31412 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Tue, 14 Jan 2025 16:24:38 -0800 Subject: [PATCH 029/140] [cye/tp-comm-fix] Fix TP communication overlap inconsistency. --- 3rdparty/NeMo | 2 +- .../bionemo-evo2/src/bionemo/evo2/run/train.py | 15 ++++++++++----- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 96cca681f4..873d007bf9 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 96cca681f47ad452ef3f2bc304518a5ceb25644f +Subproject commit 873d007bf944c37a4e3c3a94e16c65bfbc3ffebb diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index ede0ce7a2b..025d043481 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -325,16 +325,21 @@ def main(): tokenizer=tokenizer, ) + # Retrieve model config. + config_modifiers_init = { + "tp_comm_overlap": args.use_megatron_comm_overlap_llama3_8k, + "seq_length": args.seq_length + } if args.model_size == "7b": - evo2_config = llm.Hyena7bConfig() + evo2_config = llm.Hyena7bConfig(**config_modifiers_init) elif args.model_size == "40b": - evo2_config = llm.Hyena40bConfig() + evo2_config = llm.Hyena40bConfig(**config_modifiers_init) elif args.model_size == "test": - evo2_config = llm.HyenaTestConfig() + evo2_config = llm.HyenaTestConfig(**config_modifiers_init) else: raise ValueError(f"Invalid model size: {args.model_size}") - evo2_config.seq_length = args.seq_length + # Instantiate model. model = llm.GPTModel(evo2_config, tokenizer=data.tokenizer) # Setup callbacks. @@ -380,7 +385,7 @@ def main(): if args.use_megatron_comm_overlap_llama3_8k: callbacks.append( MegatronCommOverlapCallback( - tp_comm_overlap=True, + tp_comm_overlap=evo2_config.tp_comm_overlap, tp_comm_overlap_cfg=userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, wgrad_deferral_limit=22, # default from NeMo overlap_param_gather_with_optimizer_step=False, # Currently disabled due to an issue with checkpointing. From 9ae9af0d024b878d4de856f0b27394b78a532694 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Thu, 16 Jan 2025 06:41:42 -0800 Subject: [PATCH 030/140] Add temporary fix for shard-tensor bug in Megatron-LM --- Dockerfile | 8 +- .../megatron-lm-mr2468-shard-tensor-fix.patch | 261 ++++++++++++++++++ .../bionemo/esm2/scripts/test_infer_esm2.py | 8 - .../src/bionemo/evo2/run/train.py | 2 +- .../tests/bionemo/test_hyena_operators.py | 6 +- 5 files changed, 272 insertions(+), 13 deletions(-) create mode 100644 ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch diff --git a/Dockerfile b/Dockerfile index 479448aba3..a3e0749f83 100644 --- a/Dockerfile +++ b/Dockerfile @@ -67,7 +67,7 @@ RUN pip install nemo_run@git+https://github.com/NVIDIA/NeMo-Run.git@${NEMU_RUN_T # TODO(@cye): This does not install corrently on PyTorch 24.12. # # Used for straggler detection in large runs. -# ARG RESIL_COMMIT="97aad77609d2e25ed38ac5c99f0c13f93c48464e" +# ARG RESIL_COMMIT=97aad77609d2e25ed38ac5c99f0c13f93c48464e # RUN pip install --no-cache-dir "git+https://github.com/NVIDIA/nvidia-resiliency-ext.git@${RESIL_COMMIT}" RUN mkdir -p /workspace/bionemo2/ @@ -267,3 +267,9 @@ RUN chmod 777 -R /workspace/bionemo2/ # FIXME the following results in unstable training curves even if faster. # See https://github.com/NVIDIA/bionemo-framework/pull/421 # ENV NVTE_FUSED_ATTN=1 NVTE_FLASH_ATTN=0 + +# Apply patches with temporary fixes +# FIXME(dorotat) remove when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2468 is merged +RUN MEGATRON_DIR=$(python -c 'import megatron; from pathlib import Path; print(Path(megatron.__path__[0]).parent)') && \ +patch -p1 -d $MEGATRON_DIR -i $PWD/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch && \ +rm $PWD/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch diff --git a/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch b/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch new file mode 100644 index 0000000000..21337b7b76 --- /dev/null +++ b/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch @@ -0,0 +1,261 @@ +diff --git a/megatron/core/dist_checkpointing/strategies/resharding.py b/megatron/core/dist_checkpointing/strategies/resharding.py +index c1c2bcec..8619084b 100644 +--- a/megatron/core/dist_checkpointing/strategies/resharding.py ++++ b/megatron/core/dist_checkpointing/strategies/resharding.py +@@ -1,3 +1,19 @@ ++# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. ++# SPDX-License-Identifier: LicenseRef-Apache2 ++# ++# 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. ++ ++ + # Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved. + + """ Performant resharding of flattened tensors. +@@ -27,7 +43,6 @@ from megatron.core.dist_checkpointing.dict_utils import ( + extract_matching_values, + ) + from megatron.core.dist_checkpointing.mapping import ( +- ReplicaId, + ShardedStateDict, + ShardedTensorFactory, + StateDict, +@@ -84,11 +99,7 @@ def is_nd_flattened_tensor(sh_ten: Any) -> bool: + Returns: + bool: whether the given object is a flattened ShardedTensor and is N-dimensional (N > 1) + """ +- return ( +- isinstance(sh_ten, ShardedTensor) +- and sh_ten.flattened_range is not None +- and len(sh_ten.global_shape) > 1 +- ) ++ return isinstance(sh_ten, ShardedTensor) and sh_ten.flattened_range is not None + + + # information needed to restore. With current implementation, this is a nested state dict +@@ -132,6 +143,10 @@ def apply_nd_flattened_tensors_reformulation( + try: + sh_ten_reformulation_metadata = reformulation_metadata[sh_ten.key] + except KeyError as e: ++ ++ # Handle legacy checkpointing where 1-D flatten tensor metadata was not saved ++ if len(sh_ten.global_shape) == 1: ++ return sh_ten + raise CheckpointingException( + f'Missing reformulation metadata for tensor {sh_ten}. Existing keys: {reformulation_metadata.keys()}' + ) from e +@@ -240,9 +255,12 @@ def reformulate_single_nd_flattened_tensor( + overlap_dim_offsets.append(range(first_overlap_dim_offset, next_overlap_dim_offset)) + + logger.debug( +- f'Generated the following number of overlap shards for each dimension: {list(map(len, overlap_dim_offsets))}' +- f' for fragmentation ckpt {ckpt_axis_fragmentation} vs app {sh_ten.axis_fragmentations} and chunk offset {sh_ten.local_chunk_offset_in_global()}' ++ f'Generated the following number of overlap shards for each dimension: ' ++ f'{list(map(len, overlap_dim_offsets))} for fragmentation ckpt ' ++ f'{ckpt_axis_fragmentation} vs app {sh_ten.axis_fragmentations} ' ++ f'and chunk offset {sh_ten.local_chunk_offset_in_global()}' + ) ++ + reformulated_sh_tens = {} + for chunk_offset in product(*overlap_dim_offsets): + global_offset = tuple( +diff --git a/megatron/core/dist_checkpointing/strategies/torch.py b/megatron/core/dist_checkpointing/strategies/torch.py +index ea95254a..eccc6009 100644 +--- a/megatron/core/dist_checkpointing/strategies/torch.py ++++ b/megatron/core/dist_checkpointing/strategies/torch.py +@@ -1,3 +1,19 @@ ++# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. ++# SPDX-License-Identifier: LicenseRef-Apache2 ++# ++# 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. ++ ++ + # Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved. + + """ Strategies using PyTorch distributed.checkpoint as an underlying format. """ +@@ -126,8 +142,10 @@ def flatten_state_dict( + + + def sharded_tensor_to_torch_sharded_tensor( +- sh_tens: List[ShardedTensor], rank: Optional[int] = None +-) -> TorchShardedTensor: ++ sh_tens: List[ShardedTensor], ++ rank: Optional[int] = None, ++ load_legacy_1d_flatten_tensors: bool = False, ++ ) -> TorchShardedTensor: + """Convert MCore ShardedTensor to PyT ShardedTensor. PyT requires information about all chunks. + + On high-level, this function follows the logic of +@@ -163,41 +181,22 @@ def sharded_tensor_to_torch_sharded_tensor( + + some_sh_ten = sh_tens[0] + has_flattened_range = some_sh_ten.flattened_range is not None +- is_flattened_range_1d = has_flattened_range and len(some_sh_ten.global_shape) == 1 + + for sh_ten in sh_tens: + assert (sh_ten.flattened_range is not None) == has_flattened_range, sh_tens + if not sh_ten.data.is_contiguous(): + sh_ten.data = sh_ten.data.contiguous() + ++ ++ if load_legacy_1d_flatten_tensors and len(some_sh_ten.global_shape) == 1: ++ # Legacy 1-D flattened tensors are loaded as non-flat regular ShardedTensors ++ has_flattened_range = False ++ + local_global_offsets = {} + + prepend_axis_num = sh_tens[0].prepend_axis_num + # Determine local shards according to tensor type (see docs) +- if is_flattened_range_1d: +- # Type (2) case: 1D flattened ShardedTensors +- for sh_ten in sh_tens: +- assert len(sh_ten.global_offset) == 1, sh_ten +- assert sh_ten.prepend_axis_num == 0, sh_ten +- local_global_offsets.setdefault(sh_ten.global_offset, []).append(sh_ten) +- +- global_shape = some_sh_ten.global_shape +- offsets_shape = ( +- some_sh_ten.local_shape +- ) # local shape is not flattened, we need it for chunk offsets +- +- local_shards = [ +- Shard.from_tensor_and_offsets( +- sh_ten.data, +- [ +- sh_ten.global_offset[0] + sh_ten.flattened_range.start +- ], # additional flattened offset +- rank, +- ) +- for sh_ten in sh_tens +- ] +- +- elif has_flattened_range: ++ if has_flattened_range: + # Type (3) case: N-D flattened ShardedTensors + for sh_ten in sh_tens: + local_global_offsets.setdefault(sh_ten.local_chunk_offset_in_global(), []).append( +@@ -250,10 +249,7 @@ def sharded_tensor_to_torch_sharded_tensor( + # local shard + placement = f"rank:{rank}/cuda" + for sh_ten in local_global_offsets[offset]: +- if is_flattened_range_1d: +- offset = (sh_ten.global_offset[0] + sh_ten.flattened_range.start,) +- size = sh_ten.data.shape +- elif has_flattened_range: ++ if has_flattened_range: + assert offset == sh_ten.local_chunk_offset_in_global() + # This is not an actual offset, but an offset of the whole shard + # This is needed for a PyT Dist internal integrity check +@@ -270,7 +266,7 @@ def sharded_tensor_to_torch_sharded_tensor( + # Due to a bug in PyT 24.05 container we must specify some concrete rank within a world size. + # The exact rank doesn't matter as long as it's different than my rank - hence (rank + 1) % WS. + placement = f"rank:{(rank + 1) % world_size}/cuda" +- if has_flattened_range and not is_flattened_range_1d: ++ if has_flattened_range: + offset = offset + (0,) + size = (1,) * len(offsets_shape) + global_shape[-1:] + else: +@@ -296,7 +292,7 @@ def sharded_tensor_to_torch_sharded_tensor( + # This won't be stored in the checkpoint, only for runtime purposes + pyt_sh_ten.mcore_sh_ten = sh_ten.without_data() + pyt_sh_ten.mcore_metadata = {} +- if has_flattened_range and not is_flattened_range_1d: ++ if has_flattened_range: + pyt_sh_ten.mcore_metadata['nd_reformulated_orig_global_shape'] = sh_ten.global_shape + return pyt_sh_ten + +@@ -305,6 +301,7 @@ def mcore_to_pyt_state_dict( + state_dict: Dict[str, List[ShardedBase]], + is_loading: bool = False, + init_device: torch.device = torch.device("cpu"), ++ load_legacy_1d_flatten_tensors: bool = False, + ) -> Dict[str, Union[TorchShardedTensor, io.BytesIO]]: + """Convert state dict with ShardedTensors and ShardedObjects + to state dict compatible with PyT Dist format. +@@ -348,7 +345,9 @@ def mcore_to_pyt_state_dict( + if sh_ten.allow_shape_mismatch and is_loading: + sh_ten.data.zero_() + +- torch_sh_ten = sharded_tensor_to_torch_sharded_tensor(sh_tens, rank) ++ torch_sh_ten = sharded_tensor_to_torch_sharded_tensor( ++ sh_tens, rank, load_legacy_1d_flatten_tensors ++ ) + torch_sh_ten.key = sh_tens[0].key + return torch_sh_ten + +@@ -535,6 +534,12 @@ class MCoreLoadPlanner(DefaultLoadPlanner): + else: + expected_shape = nd_flattened_tensor_reformulated_global_shape(sh_ten) + if loaded_shape != expected_shape: ++ if is_nd_flattened_tensor(sh_ten) and len(sh_ten.global_shape) == 1: ++ # Handle legacy 1-D flattened tensors checkpoint format ++ # where the global shape is not stored in the metadata ++ expected_shape = sh_ten.global_shape ++ if loaded_shape == expected_shape: ++ continue + _msg = ( + f'Global shape mismatch for loaded ({loaded_shape})' + f' and expected ({expected_shape}) tensor' +@@ -736,6 +741,12 @@ def get_reformulation_metadata( + 'nd_reformulated_orig_global_shape' + ] + except KeyError as e: ++ if len(sh_ten.global_shape) == 1: ++ warnings.warn( ++ f'Legacy checkpoint format detected for 1-D flattened tensor {sh_ten}. ' ++ 'Skip metadata reformulation.' ++ ) ++ continue + raise CheckpointingException( + f'Cannot find global shape metadata for N-D flattened tensor {sh_ten} ' + f'in checkpoint metadata: {ckpt_metadata.mcore_data}' +@@ -761,9 +772,15 @@ class TorchDistLoadShardedStrategy(LoadShardedStrategy): + Returns: loaded state dict + """ + # Apply N-D tensors resharding +- sharded_state_dict, formulation_restore_data = apply_nd_flattened_tensors_reformulation( +- sharded_state_dict, get_reformulation_metadata(sharded_state_dict, checkpoint_dir) +- ) ++ reformulation_metadata = get_reformulation_metadata(sharded_state_dict, checkpoint_dir) ++ sharded_state_dict, formulation_restore_data = apply_nd_flattened_tensors_reformulation(sharded_state_dict, reformulation_metadata) ++ ++ # Check if there are legacy 1-D flattened tensors in the checkpoint ++ has_legacy_1d_flattened_tensors = False ++ for sh_ten in nested_values(sharded_state_dict): ++ if is_nd_flattened_tensor(sh_ten) and sh_ten.key not in reformulation_metadata: ++ has_legacy_1d_flattened_tensors = True ++ break + + flexible_shape_sharded_tensors = [ + sh_ten +@@ -776,7 +793,9 @@ class TorchDistLoadShardedStrategy(LoadShardedStrategy): + (sharded_state_dict, flat_mapping, rename_mapping) = ( + _replace_state_dict_keys_with_sharded_keys(sharded_state_dict) + ) +- pyt_state_dict = mcore_to_pyt_state_dict(sharded_state_dict, True) ++ pyt_state_dict = mcore_to_pyt_state_dict( ++ sharded_state_dict, True, load_legacy_1d_flatten_tensors=has_legacy_1d_flattened_tensors ++ ) + # Load PyT Distributed format + checkpoint.load_state_dict( + pyt_state_dict, diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py index 13ae7c35dd..e601ce18ed 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py @@ -32,14 +32,6 @@ from bionemo.llm.utils.callbacks import IntervalT -# Function to check GPU memory -def check_gpu_memory(threshold_gb): - if torch.cuda.is_available(): - gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3) # Memory in GB - return gpu_memory < threshold_gb - return False - - # Function to check GPU memory def check_gpu_memory(threshold_gb): if torch.cuda.is_available(): diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 025d043481..45deaaeec9 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -328,7 +328,7 @@ def main(): # Retrieve model config. config_modifiers_init = { "tp_comm_overlap": args.use_megatron_comm_overlap_llama3_8k, - "seq_length": args.seq_length + "seq_length": args.seq_length, } if args.model_size == "7b": evo2_config = llm.Hyena7bConfig(**config_modifiers_init) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py index c3ef3d5d81..f633effdda 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py @@ -92,8 +92,8 @@ def operator(self, transformer_config: TransformerConfig, hyena_config: HyenaCon def test_initialization(self, operator: ParallelShortHyenaOperator): assert operator.hidden_size == 864 - assert operator.pregate == True - assert operator.postgate == True + assert operator.pregate + assert operator.postgate num_weights = sum([p.numel() for p in operator.parameters()]) assert num_weights == 6048 @@ -134,7 +134,7 @@ def operator( def test_initialization(self, operator: ParallelCausalDepthwiseConv1d): assert operator.d_model == 864 assert operator.kernel_size == 3 - assert operator.use_bias == True + assert operator.use_bias num_weights = sum([p.numel() for p in operator.parameters()]) assert num_weights == 2592 From c032408aa1cad1c8f08cbc2037fa247c78ab29b8 Mon Sep 17 00:00:00 2001 From: Jared Wilber Date: Thu, 16 Jan 2025 16:40:21 -0800 Subject: [PATCH 031/140] Add initial test for preprocess.py --- ...ts_rep_seq_distinct_sample_sequences.fasta | 16 ++++ .../bionemo/evo2/data/test_preprocess.py | 80 +++++++++++++++++++ 2 files changed, 96 insertions(+) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta new file mode 100644 index 0000000000..6820948285 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta @@ -0,0 +1,16 @@ +>FP010138_142154 FP010138 GRMZM2G113244_1 :+U EU:NC; range -499 to 100. +GTGGGCCAGGCCCATCGTTTGCATGCATGCACGATTGCACGCCCCCGGTGTCAATCGCGCGCAAATTGAGCTTGGGGCTTGGGCCTGCTGGCCCCTATCTACAGGAGTTCACCTTCACCTATGTTTAGGAATGTAGATACGAATGTATATTACTCGTTTTATATTTGTTTCTATAGTTTCTTTTCAAATTTATATTATATATAAATATTATTGAGTTGTGTGGCATGTTAAGTATCTAAGTTTAAATATATGAGTCGTCTGATATTTAATTACTCGGTCTCGGATATAGATTGTGAATCAGATCTGTTGATTTGTACAGTAGAGTGACGACTGACGAGTGACGTCCGAATGCTACGGGCAGCATGCCAGCATCCGCAACAGCGAGCAACCAGACGAGCTTGATCCCATCCCAGCCGTCCACGTACCCTTCGGATACACCGCTGAGGCGGTTGATGGGCACTGTTCCCTTGTCTTTGCCGAAACAGCGAGGCTTCCTCCCAATTCCAATCCAAGCCCCAACTAACGACCTCCGCCCATTCCGCTCGCGGTTGCCTCCGCCTCCGCCTCCGCCTCCGCGCCTAACCCAATCCAGAGCCAGGG +>FP010794_111285 FP010794 AT3G14130_1 :+U EU:NC; range -499 to 100. +AAAGTTACAAAGGTAAGAATAATCAAAGGATTCAAAAAAAGGGTTTAAAAACACACAAAAACACTTAAAAAAGATGACATTATATAATATAACTACCGGGCTTTCTATTCTCTGACGACGACGATACACATTAGAGGCTTCCCCGTGATTCGTCGCGGAACATAGGCATGACCATTGAGTAATTGGTCGTTGCCATTTTTATAGACATATATGTTCTGAGGTAAAAATTTGCAACTTTTCAAGAAACGCTTCGGTCTCTGAGACTGAGCATTGGTGTCAGAAGAGAAGAAATAAAAGCTCCCGTTGGAAAATGGCTCTCTGAAATGATGATGACTCGGTACGCCACGTCCTCATTGAGTTGAATAGTCAACGTTTACTGTGGGCAAAGACTCTAGACGACTTAGAGGGTTAGCAGGTGTTTTGTCGTTTTCTGTCTTGGTCTCCGACAGGACCGACTCTGTTCTCGTGTTCTTTTTTCCCTGTCATTTCCAGATTTCATAAAGCTAAAAGATATCTAATTTCTTTGTTTACCAGAGACTTAAACTGGTTTCTGTATCTTTTACTGGGTTCTTTCAGATATGTAAGTACTTCTAAAATCAA +>FP003588_9147 FP003588 Wipf3_1 :+U EU:NC; range -499 to 100. +GGCGCAAGCTTTTCTGCCCATCCTACCCCCGCCCCCAGCTCTCTCCACCCACACACCCACCGCCGCCTTTCAAGCCCAGGTCTAAATTGGGTGTACAGGGATGTACTGGATGTCTTCTTGGCTCTGTATTATATGTACCTGCTCATGCTCATGGGGACAACAGGCTGTCCCGTTCTCCCTTTGTCCCTTTGCTTATAGCGCTGTAGCAGGCTTAGCGAGGGCTCCGAAATGTTTGTAATATATAGATGAGGTGGCGTGCAGGGGAACTCCAGCCCTTGGCTCCATTGTCCCCTTGGCTCACACTCGGGACTCTGTACCTGGGAGCTGCGCTGCGCAGCCAGGACCGCCTCCTGGGTGCCAGAGCCACCCCGCCCTCTGGGTCGCGTCCCGGGGAGCCGGGCGGCGAGGCTCCAGGACGGCCGCCAGGAGCAGGTGGGGGCGGCGGCTCCGCCTCCGCGTCCCGGCAGCGCCTAAGCCCAGCCGGGAGAGCTTGGAGCGCAGAGCCCAGCTCAGCCAGGCGCGCAGAAGCAACGCCAGGCACTGCCGGCAGATCAACTGGGATCCTCGAGGCGGCAAGAGGACAGGGACAGCGGGGACCGC +>FP001999_32042 FP001999 ZNF800_1 :+U EU:NC; range -499 to 100. +CAAGAAAAAAGTAAGTTCAACTTTTGCCATTTAGCAATGCACTGACAGCCTTTTGGGGATCATCACTACTTACGGCTCATACATCTGCTCACCGCTTCCTAAGCCCTCTCCTAACCCTCCCCGAGTTTCAGTTCCACTGTACAGAGAACGCCGAGAGCAACAGTTTGGTGGCGGAGCAACCCGTCTCCGTGGGCGCGCACGCCGCACCGCAGACCTCACACCTCACCCTGGGCTTCGGCTCTCGGTCGGCCCGAAACTCCGGCCGCGGCCCTGGTGTCCCCTGCCCCGGTTCCCTCCCCTTGGACACGGCCCTCGCGCCCGCGGACCCGGTCGCCTCCCCATCCGCCGCAGCGGGTACAGCGCGTCGCCTCCCCAACAAGCGGGGGCGCCGACCGGGCGCATGCGCGCGGCGCTCCCGGGCGTGCCGGCCACACTCCCCCCACCCACTCGGTGAGCTTGTCACTTCCTGCCCTCGCCCCATCTCCGTCCGGGGTCAGTCAGTCGCTCCCTGTCGCTGCCGGAGAGTCTCTGCTTCCCCCTTCCTACGCGCTCCGCGGCGGTAGCTCGGGCTCTCCGGAGGAGGGAACGACAGAGAAAAAG +>FP004409_149038 FP004409 CASQ2_1 :+U EU:NC; range -499 to 100. +GAAAGGCAGGTGCAGAACATAAAGTTCACCTCGGGGGCTGCACTTGGTTCGTGTGTGAGCAGTGAGGAGGTAGGGGACAAGCAGCCCACCAGGAGGGGACAGGCTGGATTCTCTCCCTATAGTAATTGAATGAATCCGAGGTCTGGGTGGCCCTGTGTCTGTGCACACATCTCCACTGGCTGTTCCACCACTGTCCCACCTCTCTCCCGTCTCATCTTCTCTTCCTCCTTTTTGAGCTTATTTCTCTTTCTTGACCTTGCTGGCCTCCTTATTTCTCATGCACACGTTCTCCGCTTTCCTTCCTACCTCCTCCCTTTCCACCACTCTGGCCGACTGTATCAGCGAATCCCTCAACAGTGTCATATCTAACTTTTTTATTCATTGCATGATTTATTTTTAGCCTGAAACAACTGCATCCTAAAAATGGAGTTCCTGATGAGACAGGGGCTGGGCCGAGCTATGCGAGGTATCTGGGGCTGGGCCGCCCAGCCTGGCCCTCAGTCTCCGCTCGCGTGTGTCCTGAGCCCACGCGCACTGCTAGGCGGAGCCCAGGCGGCGGTGGACAGTCGGTCCCCGGGCCCAGGAGGGACACAGGAGAGG +>FP007746_105660 FP007746 Mad1l1_1 :+U EU:NC; range -499 to 100. +TCCCAGGACTTCTCATTCACAAAAGAAAGAAAGTGAAACAAGCTAACCAATCAAAACAGTGCCCAAACAAAACAACCTGTGTATACAAAGTGGCAAGATTCAGAGGCAACGCAACTTTCCAAAACTTTGTTCCCTTTCCGAGCGTGCCCAGCAGTTGTGCGGCAAGCCTTTAATTCCAGGGAGGCAGAGGCAGGCACGGGTGGATCTTTGTGAGTTCGAGGCTACACAGAGAAACATTGTCTCAAAAACAAAAACAAACAAACCTTTCCTCCTGCGCGGTGCTATTCCATACATTACGGCGCACCCCGGGGCAGTGGAAGAGCGCCCTGCGGGACAGGCAGCCGGGCCCAGTTTGGTTCCGGGTCCCCTGGCGGGACTGCGGTTTGTTCTCAGGCTACGCCCGTGGAGCACATATTTAATTCTTTACGGGCCGTTTTCTCAGATCTCGCGAGACCCCGGCGGAAGTCTCGCGATATATAGACACCGGCGGAGAGGAGGGAGATCTGAGCGGCTGCTGCAGCACCGGGCTCCTCAACTGAGGTAAGGGACCCGGTGGCGGGATCTGCGAGCGCCCCAGGCGCCTCGCGCCCTGCCCGACCG +>FP005252_170005 FP005252 CG17193_1 :+U EU:NT; range -499 to 100. +CGATCACAGCTACTTCTACATCGCCACGTTCGTCGCCGAACACATCGCCTACCATGCCGCCCTGCTCACAGCTTCCGCTTGATGATATTCCGCTTGTACATAATCGTTGGTTTCCACCGAAACCATAATTCAACGTAAATTTGGCAGTAAATAAACCAATTTCGACTGAGCTTCTAAAATGTATTCTTACATTCTTGACTTTAAACTTTGAACTTGGACTTTGAAAAACAAATATTTTTATTCATTCTAGGTGCCAATGTACAGAAGATTATACACAAATGGCGTGTACTTTGTTATTTCGGTTTTAAGTTCAGCAATTTCCTTTCACAAACAAAAACTTAAGTAATGGGTATTCAGCATTCGTCGAATTCCTAAGGACTTTTTCCCGGACTTGTGGTAAGGGTAAAAGCTCGCAACGTAGTAAAAGCTTTCCGGTTGTTGGTCCACGGCATGCTGGAAACTTTCCGCATCCTGGCATCCTGCGTACGATTCATTCATCAGTAGAAAAAACGCCGTCTGATGGAATAGATGTGCTAGTGACAGAGGGAACCGAACCGAACGGAGGTACCAAAAGGCGACATTCTCGACTCGTTTGGCGCC +>FP004145_60966 FP004145 Sprr2b_1 :+U EU:NC; range -499 to 100. +CCCCATGGCTTACTGAGGGGGGCACTTGGTATCTTTTGTTTCTCTTCTTTCTAACAAACTTGTAAATGTGTGAGGAAAATACCCCTCCACTTCTGAAAAAGGAAAGTGTAAATGGCTTTACACACTAGCAACGAACTAAGGATGAACTAAAGAGGTTCAAATAATGGAAAACCTTGAATTTAAGACAAATAGAGGCTGTCATGAAAAAAGGCTTATGCTTCCAGTCAAGAAAGAGATGTATCAAACAGTTGGAAAAGCTCCAAGTACCACAATTACTGGAAGCAAGAAGAAAGAAAAGGACTCTTGAGTCACAAGACTCAACCTAGTAATGATAGCCATGGGTGGGATATTTCCTATTTTGTAGAGTCCCTGTCCAGCCAGTTACGGATGAATTTGCATTTGTGTTAGGAAATTCCAGGACCAGCCCATTACAGGGAGATCCACTTCCCACTGGGTGAGGCAGGCAATCCTATAAAAAAGAGTCTCAGTGCTTGACTGCAGTATTCCTGGTACTCAAGCATTGGTCTGCTCCGGAGAACCTGGTGAGTCTGATTTCTTGAGTTCTTGAGAGGGTCTGCTCTTTTTGGTACTGTCATGAGC diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py new file mode 100644 index 0000000000..20e4f9d46b --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -0,0 +1,80 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path + +import pytest + +from bionemo.evo2.data.preprocess import Evo2Preprocessor +from bionemo.evo2.utils.config import Evo2PreprocessingConfig + + +@pytest.fixture +def preprocessing_config(tmp_path: Path) -> Evo2PreprocessingConfig: + """Creates a preprocessing configuration with test settings.""" + config_dict = { + "datapaths": ["test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta"], + "output_dir": str(tmp_path), + "output_prefix": "test_promoters_uint8_distinct", + "train_split": 1.0, + "overwrite": True, + "embed_reverse_complement": True, + "random_reverse_complement": 0.0, + "random_lineage_dropout": 0.0, + "include_sequence_id": False, + "transcribe": "back_transcribe", + "indexed_dataset_dtype": "uint8", + "tokenizer_type": "Byte-Level", + "vocab_file": None, + "vocab_size": None, + "merges_file": None, + "pretrained_tokenizer_model": None, + "special_tokens": None, + "fast_hf_tokenizer": True, + "append_eod": True, + "enforce_sample_length": None, + "ftfy": False, + "workers": 1, + "preproc_concurrency": 100000, + "chunksize": 25, + "drop_empty_sequences": True, + "nnn_filter": True, + } + return Evo2PreprocessingConfig(**config_dict) + + +@pytest.fixture +def preprocessor(preprocessing_config: Evo2PreprocessingConfig) -> Evo2Preprocessor: + """Creates an Evo2Preprocessor instance with test configuration.""" + return Evo2Preprocessor(preprocessing_config) + + +def test_preprocessor_creates_expected_files( + preprocessor: Evo2Preprocessor, preprocessing_config: Evo2PreprocessingConfig +) -> None: + """Verifies that preprocessing creates all expected output files.""" + preprocessor.preprocess_offline(preprocessing_config) + + # Check that all expected files exist + expected_files = [ + "test_promoters_uint8_distinct_byte-level_train.bin", + "test_promoters_uint8_distinct_byte-level_train.idx", + ] + + for filename in expected_files: + file_path = Path(preprocessing_config.output_dir) / filename + assert file_path.exists(), f"Expected file {file_path} was not created" + assert file_path.stat().st_size > 0, f"File {file_path} is empty" From b6d238f7ca17f7be9aeec739b37d87f664201baa Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Thu, 16 Jan 2025 18:05:14 -0800 Subject: [PATCH 032/140] Bump NeMo to pick up FLOPS calculations. --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 873d007bf9..f6d9c403a9 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 873d007bf944c37a4e3c3a94e16c65bfbc3ffebb +Subproject commit f6d9c403a90151d6d8bba8a4490d1145126e243b From 7822c048c3c0e801a0d6f3d07d9de15e1e043fad Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Tue, 21 Jan 2025 15:40:14 -0800 Subject: [PATCH 033/140] [cye/z3-log-fix] Fix parameter count log. --- 3rdparty/Megatron-LM | 2 +- .../src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index 14ca285dcc..f8887ce621 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit 14ca285dcc8b6862fbb992ef8de57402479c0e9f +Subproject commit f8887ce6212499ff8d882307e747948dad7c56b4 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py index 76a20710b4..ce2bd74103 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py @@ -489,9 +489,8 @@ def _zero3_merge_frozen_params(state_dict: Dict[str, Any], world_size: int, zero total_params = 0 total_numel = 0 - partitioned_numel = 0 # TODO(cory) - this is a bug, should be initialized to ? for name, shape in zero_model_states[0].frozen_param_shapes.items(): - total_params += partitioned_numel + total_params += 1 unpartitioned_numel = shape.numel() total_numel += unpartitioned_numel From 93782232b1e824ef0dfb3d56c2e085d5f511a0f0 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Tue, 21 Jan 2025 16:35:05 -0800 Subject: [PATCH 034/140] [cye/docker-patch-fix] Move Megatron patch to BioNeMo base image in Dockerfile. --- Dockerfile | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/Dockerfile b/Dockerfile index a3e0749f83..6a34456ca4 100644 --- a/Dockerfile +++ b/Dockerfile @@ -123,6 +123,13 @@ COPY ./LICENSE /workspace/bionemo2/LICENSE COPY ./3rdparty /workspace/bionemo2/3rdparty COPY ./sub-packages /workspace/bionemo2/sub-packages +# Apply patches with temporary fixes, before the modules are installed. (Use absolute path for patch filepath.) +# FIXME(dorotat) remove when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2468 is merged +COPY ./ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch /workspace/bionemo2/ci/scripts/ +RUN MEGATRON_DIR=./3rdparty/Megatron-LM && \ +patch -p1 -d $MEGATRON_DIR -i /workspace/bionemo2/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch && \ +rm ./ci/scripts/*.patch + # Note, we need to mount the .git folder here so that setuptools-scm is able to fetch git tag for version. # Includes a hack to install tensorstore 0.1.45, which doesn't distribute a pypi wheel for python 3.12, and the metadata # in the source distribution doesn't match the expected pypi version. @@ -258,6 +265,8 @@ COPY ./docs ./docs COPY --from=rust-env /usr/local/cargo /usr/local/cargo COPY --from=rust-env /usr/local/rustup /usr/local/rustup +# Remove patches in built container. +RUN rm ./ci/scripts/*.patch # RUN rm -rf /usr/local/cargo /usr/local/rustup RUN chmod 777 -R /workspace/bionemo2/ @@ -267,9 +276,3 @@ RUN chmod 777 -R /workspace/bionemo2/ # FIXME the following results in unstable training curves even if faster. # See https://github.com/NVIDIA/bionemo-framework/pull/421 # ENV NVTE_FUSED_ATTN=1 NVTE_FLASH_ATTN=0 - -# Apply patches with temporary fixes -# FIXME(dorotat) remove when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2468 is merged -RUN MEGATRON_DIR=$(python -c 'import megatron; from pathlib import Path; print(Path(megatron.__path__[0]).parent)') && \ -patch -p1 -d $MEGATRON_DIR -i $PWD/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch && \ -rm $PWD/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch From 9b9176a188702f9852c6d599f6ed8e78aeef9b4a Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Fri, 24 Jan 2025 07:45:49 -0800 Subject: [PATCH 035/140] shipping hotfix for dockers built locally - fix from main 17c6b205135352ad492ac50f723f6a5403e359a6 --- requirements-test.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/requirements-test.txt b/requirements-test.txt index 567b990cb7..2196be978d 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -13,3 +13,6 @@ pyfaidx==0.8.1.3 # See https://nvidia.slack.com/archives/C02A7LYGHK8/p1734727482697309 pytorch-lightning<2.5.0 lightning<2.5.0 + +# Temporary pin for triton +triton<=3.1.0 From 329548a968a96294427ce95f24405b3ec1958fa7 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Fri, 24 Jan 2025 13:06:33 -0800 Subject: [PATCH 036/140] [cye/1m-ckpt-config] Add HyenaConfig options for 1M context length dimensions. --- 3rdparty/NeMo | 2 +- .../bionemo-evo2/src/bionemo/evo2/run/train.py | 8 ++++++-- .../bionemo/evo2/utils/checkpoint/README.md | 4 ++-- .../evo2/utils/checkpoint/torch2nemo.py | 18 ++++++++++-------- 4 files changed, 19 insertions(+), 13 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index f6d9c403a9..648f866452 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit f6d9c403a90151d6d8bba8a4490d1145126e243b +Subproject commit 648f8664521587702c4ab89583c160dd033327a7 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 45deaaeec9..b4284ba6a2 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -96,9 +96,9 @@ def parse_args(): parser.add_argument( "--model-size", type=str, - choices=["7b", "40b", "test"], + choices=["7b", "7b_arc_1m", "40b", "40b_arc_1m", "test"], default="7b", - help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b).", + help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained with TP<=8.", ) parser.add_argument( "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." @@ -332,8 +332,12 @@ def main(): } if args.model_size == "7b": evo2_config = llm.Hyena7bConfig(**config_modifiers_init) + elif args.model_size == "7b_arc_1m": + evo2_config = llm.Hyena7bARCLongContextConfig(**config_modifiers_init) elif args.model_size == "40b": evo2_config = llm.Hyena40bConfig(**config_modifiers_init) + elif args.model_size == "40b_arc_1m": + evo2_config = llm.Hyena40bARCLongContextConfig(**config_modifiers_init) elif args.model_size == "test": evo2_config = llm.HyenaTestConfig(**config_modifiers_init) else: diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md index d1b1837fb0..10ed075afd 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md @@ -6,9 +6,9 @@ This library contains helper scripts for converting checkpoint formats for Evo2. To convert a single PyTorch or ZeRO-1 checkpoints (`.pt`) into NeMo2 format, run the following command: ``` -python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py --model-path --output-dir --model-type --ckpt-format +python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py --model-path --output-dir --model-size --ckpt-format ``` -where `--model-type` can be set to `7b` or `40b` and `--ckpt-format` can be set to `torch_dist` or `zarr`. +where `--model-size` can be set to `7b` or `40b` (or their `_arc_1m` variants with modified GLU dimensions) and `--ckpt-format` can be set to `torch_dist` or `zarr`. The NeMo2 checkpoint should have the following structure for `torch_dist`: ``` diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py index 45f36fde5f..d92e2ac8be 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py @@ -28,11 +28,11 @@ def parse_args(): ) parser.add_argument("--output-dir", type=str, required=True, help="Output directory path for the converted model.") parser.add_argument( - "--model-type", + "--model-size", type=str, - choices=["7b", "40b", "test"], + choices=["7b", "7b_arc_1m", "40b", "40b_arc_1m", "test"], default="7b", - help="Model size, choose between 7b, 40b, or test (4 layers, less than 1b).", + help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained with TP<=8.", ) return parser.parse_args() @@ -42,14 +42,16 @@ def parse_args(): args = parse_args() # Hyena Model Config - if args.model_type == "7b": + if args.model_size == "7b": evo2_config = llm.Hyena7bConfig() - elif args.model_type == "40b": + elif args.model_size == "7b_arc_1m": + evo2_config = llm.Hyena7bARCLongContextConfig() + elif args.model_size == "40b": evo2_config = llm.Hyena40bConfig() - elif args.model_type == "test": + elif args.model_size == "40b_arc_1m": + evo2_config = llm.Hyena40bARCLongContextConfig() + elif args.model_size == "test": evo2_config = llm.HyenaTestConfig() - else: - raise ValueError(f"Invalid model type: {args.model_type}") importer = PyTorchHyenaImporter(args.model_path, model_config=evo2_config) importer.apply(args.output_dir) From 2ca40b0e1d3cf3258b45c2a4ede91fd1181d9b21 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Fri, 24 Jan 2025 15:03:08 -0800 Subject: [PATCH 037/140] [cye/fix-tp-comm-overlap] Fix default tp_comm_overlap=True being used in inference, which is not appropriate. --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 648f866452..7c1881de96 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 648f8664521587702c4ab89583c160dd033327a7 +Subproject commit 7c1881de96858ae021e54002f2f2c3aec625b4dd From a494478668fbfc648a93807875cb7acba9bfcc29 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Mon, 27 Jan 2025 06:07:26 -0800 Subject: [PATCH 038/140] reducing scope of tested folders for evo2-dev --- .secrets.baseline | 95 +++++++++++++++++++++++++++++++++++++++- ci/scripts/run_pytest.sh | 8 +++- ci/scripts/utils.sh | 5 ++- 3 files changed, 104 insertions(+), 4 deletions(-) diff --git a/.secrets.baseline b/.secrets.baseline index c0824519f8..800bcd92ac 100644 --- a/.secrets.baseline +++ b/.secrets.baseline @@ -141,7 +141,100 @@ "is_verified": false, "line_number": 47 } + ], + "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta": [ + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "d0ec96cd08e29b76cea5f00b2c18ba35cbbe815a", + "is_verified": false, + "line_number": 2 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "06b2204c68a9a0e464ceb2062ba73e4fa85fa460", + "is_verified": false, + "line_number": 4 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "db62d3a64fd526a5ac69cbd17f243f7ab2f5330e", + "is_verified": false, + "line_number": 4 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "620d1584dcd0e9c89dbe870aa640dc531a749f4f", + "is_verified": false, + "line_number": 10 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "d2b58bf55cb4d2ef65f77dfbadd75e41eacd7293", + "is_verified": false, + "line_number": 10 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "ef32012bcc3136110a0ee29b7938588811aec63b", + "is_verified": false, + "line_number": 10 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "31849d2e825e5eaba354d3af405f97a3388a8fe2", + "is_verified": false, + "line_number": 12 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "71480ee432162113f6f45717a94845673240064f", + "is_verified": false, + "line_number": 14 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "a4f917b3de625d782d94cce85cfd8b901ec11a10", + "is_verified": false, + "line_number": 14 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "d195edefe192e7259b221c6a117876fbc122e74f", + "is_verified": false, + "line_number": 14 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "eb337e0858eda021d74d1ef12c59c671a0246503", + "is_verified": false, + "line_number": 14 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "533f3422b5da47eae9be37c28d0be7ee46f68bfd", + "is_verified": false, + "line_number": 16 + }, + { + "type": "AWS Access Key", + "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", + "hashed_secret": "d7fa10a32c3a012feb0915a11cc55ff07f1b1aa1", + "is_verified": false, + "line_number": 16 + } ] }, - "generated_at": "2024-11-01T22:26:03Z" + "generated_at": "2025-01-24T16:11:46Z" } diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 633a3cc801..2f8e20993b 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -89,7 +89,13 @@ PYTEST_OPTIONS=( [[ "$SKIP_SLOW" == true ]] && PYTEST_OPTIONS+=(-m "not slow") # Define test directories -TEST_DIRS=(./sub-packages/bionemo-*/) +#TODO(dorotat): those are temporary changes to speed up testing, should be removed after the evo2-dev in on Github +TEST_DIRS=( + ./sub-packages/bionemo-core + ./sub-packages/bionemo-evo2 + ./sub-packages/bionemo-llm + ./sub-packages/bionemo-testing +) if [[ "$NO_NBVAL" != true && "$SKIP_DOCS" != true ]]; then TEST_DIRS+=(docs/) fi diff --git a/ci/scripts/utils.sh b/ci/scripts/utils.sh index 1b07c78a7f..16ef4c8b37 100755 --- a/ci/scripts/utils.sh +++ b/ci/scripts/utils.sh @@ -20,10 +20,11 @@ check_git_repository() { if ! git diff-index --quiet HEAD --; then if [ $? -eq 128 ]; then echo "ERROR: Not in a git repository!" >&2 + return 0 else - echo "ERROR: Repository is dirty! Commit all changes before building the image!" >&2 + echo "Warning: Repository is dirty! Commit all changes before building the image!" >&2 + return 0 fi - return 1 fi } From 72a311e7d9640e03f0199a4cedf44dc97f20ce28 Mon Sep 17 00:00:00 2001 From: Jonathan Mitchell Date: Mon, 27 Jan 2025 17:25:54 -0800 Subject: [PATCH 039/140] Adds basic inference test --- .pre-commit-config.yaml | 2 +- .secrets.baseline | 97 +------------------ .../bionemo-evo2/tests/bionemo/test_evo2.py | 2 +- .../tests/bionemo/test_inference.py | 90 +++++++++++++++++ 4 files changed, 94 insertions(+), 97 deletions(-) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/test_inference.py diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c9b91149ae..15cc1e2e37 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -18,7 +18,7 @@ repos: hooks: - id: detect-secrets name: detect-secrets (everything but notebooks) - args: ['--baseline', '.secrets.baseline', '--exclude-files', '(.*\.ipynb|.*\.baseline)$', ] + args: ['--baseline', '.secrets.baseline', '--exclude-files', '(.*\.ipynb|.*\.baseline|.*\.fasta)$', ] exclude: package.lock.json - id: detect-secrets name: detect-secrets (notebooks only) diff --git a/.secrets.baseline b/.secrets.baseline index 800bcd92ac..8160e12319 100644 --- a/.secrets.baseline +++ b/.secrets.baseline @@ -128,7 +128,7 @@ { "path": "detect_secrets.filters.regex.should_exclude_file", "pattern": [ - "(.*\\.ipynb|.*\\.baseline)$" + "(.*\\.ipynb|.*\\.baseline|.*\\.fasta)$" ] } ], @@ -141,100 +141,7 @@ "is_verified": false, "line_number": 47 } - ], - "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta": [ - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "d0ec96cd08e29b76cea5f00b2c18ba35cbbe815a", - "is_verified": false, - "line_number": 2 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "06b2204c68a9a0e464ceb2062ba73e4fa85fa460", - "is_verified": false, - "line_number": 4 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "db62d3a64fd526a5ac69cbd17f243f7ab2f5330e", - "is_verified": false, - "line_number": 4 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "620d1584dcd0e9c89dbe870aa640dc531a749f4f", - "is_verified": false, - "line_number": 10 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "d2b58bf55cb4d2ef65f77dfbadd75e41eacd7293", - "is_verified": false, - "line_number": 10 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "ef32012bcc3136110a0ee29b7938588811aec63b", - "is_verified": false, - "line_number": 10 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "31849d2e825e5eaba354d3af405f97a3388a8fe2", - "is_verified": false, - "line_number": 12 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "71480ee432162113f6f45717a94845673240064f", - "is_verified": false, - "line_number": 14 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "a4f917b3de625d782d94cce85cfd8b901ec11a10", - "is_verified": false, - "line_number": 14 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "d195edefe192e7259b221c6a117876fbc122e74f", - "is_verified": false, - "line_number": 14 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "eb337e0858eda021d74d1ef12c59c671a0246503", - "is_verified": false, - "line_number": 14 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "533f3422b5da47eae9be37c28d0be7ee46f68bfd", - "is_verified": false, - "line_number": 16 - }, - { - "type": "AWS Access Key", - "filename": "sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta", - "hashed_secret": "d7fa10a32c3a012feb0915a11cc55ff07f1b1aa1", - "is_verified": false, - "line_number": 16 - } ] }, - "generated_at": "2025-01-24T16:11:46Z" + "generated_at": "2025-01-27T19:44:23Z" } diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py index 12ae84c46a..9d0b73906f 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py @@ -80,7 +80,7 @@ def test_golden_values(seq_len: int): ) else: raise e - with torch.inference_mode(), distributed_model_parallel_state(): + with distributed_model_parallel_state(), torch.no_grad(): hyena_config = llm.Hyena7bConfig(use_te=True, seq_length=seq_len) tokenizer = get_nmt_tokenizer( "byte-level", diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py new file mode 100644 index 0000000000..2eecf62ea9 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py @@ -0,0 +1,90 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import nemo.lightning as nl +import torch +from megatron.core.inference.common_inference_params import CommonInferenceParams +from nemo.collections.llm import generate + +from bionemo.core.data.load import load + + +RANDOM_SEED = 42 + + +def test_infer_model_generates_expected_single_token_output(): + # Create PTL trainer. + TENSOR_PARALLEL_SIZE = 1 + PIPELINE_MODEL_PARALLEL_SIZE = 1 + CONTEXT_PARALLEL_SIZE = 1 + NUM_GPUS = 1 + NUM_NODES = 1 + + strategy = nl.MegatronStrategy( + tensor_model_parallel_size=TENSOR_PARALLEL_SIZE, + pipeline_model_parallel_size=PIPELINE_MODEL_PARALLEL_SIZE, + context_parallel_size=CONTEXT_PARALLEL_SIZE, + pipeline_dtype=torch.bfloat16, + ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. + ckpt_save_optimizer=False, + ckpt_async_save=False, + save_ckpt_format="zarr", + ) + trainer = nl.Trainer( + accelerator="gpu", + num_nodes=NUM_NODES, + devices=NUM_GPUS, + strategy=strategy, + log_every_n_steps=1, + limit_val_batches=10, + num_sanity_val_steps=0, + plugins=nl.MegatronMixedPrecision( + precision="bf16-mixed", + params_dtype=torch.bfloat16, + ), + ) + + prompt = ( + "|d__Bacteria;" + + "p__Pseudomonadota;" + + "c__Gammaproteobacteria;" + + "o__Enterobacterales;" + + "f__Enterobacteriaceae;" + + "g__Escherichia;" + + "s__Escherichia|" + ) + temperature = 1.0 + top_k = 0 + top_p = 0.0 + max_new_tokens = 1 + checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") + + results = generate( + path=checkpoint_path, + prompts=[prompt], + trainer=trainer, + inference_params=CommonInferenceParams( + temperature, + top_k, + top_p, + return_log_probs=False, + num_tokens_to_generate=max_new_tokens, + ), + random_seed=RANDOM_SEED, + text_only=True, + ) + + assert isinstance(results, list) + assert results == ["T"] From d4cd785cfcf3be57dabbf4134dc997db832dad08 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Tue, 28 Jan 2025 08:51:42 -0800 Subject: [PATCH 040/140] [cye/deactivate-infer-tpcomm] Deactivate TP communication during inference to support those checkpoints. --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 7c1881de96..d4b893a46c 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 7c1881de96858ae021e54002f2f2c3aec625b4dd +Subproject commit d4b893a46c77dd39901f0072ee4d2a7d89df8c27 From 3ba8946bb11a264ac1321daa6c3ad53cd6b79dbc Mon Sep 17 00:00:00 2001 From: Jared Wilber Date: Tue, 28 Jan 2025 10:41:21 -0800 Subject: [PATCH 041/140] fix: ensure test looks in test file dir for required data Signed-off-by: Jared Wilber --- .../bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index 20e4f9d46b..77471ef6d1 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -25,8 +25,11 @@ @pytest.fixture def preprocessing_config(tmp_path: Path) -> Evo2PreprocessingConfig: """Creates a preprocessing configuration with test settings.""" + # grab dir where test located + test_dir = Path(__file__).parent + config_dict = { - "datapaths": ["test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta"], + "datapaths": [str(test_dir / "test_datasets" / "mmseqs_results_rep_seq_distinct_sample_sequences.fasta")], "output_dir": str(tmp_path), "output_prefix": "test_promoters_uint8_distinct", "train_split": 1.0, From 34938fc0b5a87329951e05781f96fb297ff318f6 Mon Sep 17 00:00:00 2001 From: John St John Date: Wed, 29 Jan 2025 14:24:46 -0800 Subject: [PATCH 042/140] m2.5 accuracy 7b runs --- .devcontainer/devcontainer.json | 10 +- 3rdparty/NeMo | 2 +- .../src/bionemo/evo2/run/train.py | 157 ++++++++---------- .../tests/config/test_dataset_config.yaml | 8 +- 4 files changed, 75 insertions(+), 102 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index c32a3f63e8..72d906fc92 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -13,11 +13,11 @@ }, "mounts": [ // Mount the local ~/.aws config to pass along AWS credentials for PBSS. - "source=${localEnv:HOME}/.aws,target=/home/bionemo/.aws,type=bind,consistency=cached", - "source=${localEnv:HOME}/.ngc,target=/home/bionemo/.ngc,type=bind,consistency=cached", - "source=${localEnv:HOME}/.cache,target=/home/bionemo/.cache,type=bind,consistency=cached", - "source=${localEnv:HOME}/.ssh,target=/home/bionemo/.ssh,readonly,type=bind,consistency=cached", - "source=${localEnv:HOME}/.netrc,target=/home/bionemo/.netrc,readonly,type=bind,consistency=cached" + "source=${localEnv:HOME}/.aws,target=/home/ubuntu/.aws,type=bind,consistency=cached", + "source=${localEnv:HOME}/.ngc,target=/home/ubuntu/.ngc,type=bind,consistency=cached", + "source=${localEnv:HOME}/.cache,target=/home/ubuntu/.cache,type=bind,consistency=cached", + "source=${localEnv:HOME}/.ssh,target=/home/ubuntu/.ssh,readonly,type=bind,consistency=cached", + "source=${localEnv:HOME}/.netrc,target=/home/ubuntu/.netrc,readonly,type=bind,consistency=cached" ], "containerEnv": { "TMPDIR": "/tmp", diff --git a/3rdparty/NeMo b/3rdparty/NeMo index d4b893a46c..b92de49003 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit d4b893a46c77dd39901f0072ee4d2a7d89df8c27 +Subproject commit b92de49003634813f385e25d02708dc5deb60cea diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index b4284ba6a2..307a464314 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -15,7 +15,7 @@ import argparse from collections import defaultdict -from dataclasses import asdict, dataclass +from dataclasses import asdict # import nvidia_resiliency_ext.ptl_resiliency as res_module import torch @@ -28,6 +28,7 @@ from nemo.collections import llm from nemo.collections.llm.gpt.data import PreTrainingDataModule from nemo.collections.llm.gpt.data.megatron.hyena import Evo2Dataset +from nemo.collections.llm.recipes.tp_overlap_configs.userbuffers import userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192 from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger from nemo.lightning.pytorch import callbacks as nl_callbacks @@ -45,6 +46,17 @@ torch._dynamo.config.suppress_errors = True +model_options = { + "7b": llm.Hyena7bConfig, + "7b_arc_longcontext": llm.Hyena7bARCLongContextConfig, + "7b_nv": llm.HyenaNV7bConfig, + "40b": llm.Hyena40bConfig, + "40b_arc_longcontext": llm.Hyena40bARCLongContextConfig, + "40b_nv": llm.HyenaNV40bConfig, + "test": llm.HyenaTestConfig, + "test_nv": llm.HyenaNVTestConfig, +} + def parse_args(): """Parse arguments for Evo2 model training.""" @@ -96,7 +108,7 @@ def parse_args(): parser.add_argument( "--model-size", type=str, - choices=["7b", "7b_arc_1m", "40b", "40b_arc_1m", "test"], + choices=sorted(model_options.keys()), default="7b", help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained with TP<=8.", ) @@ -115,6 +127,7 @@ def parse_args(): default=None, help="Directory to restore an initial checkpoint from. Use this for supervised fine-tuning.", ) + parser.add_argument("--wd", type=float, default=0.01, help="Weight decay for optimizer.") parser.add_argument( "--restore-optimizer-from-ckpt", action="store_true", @@ -151,7 +164,9 @@ def parse_args(): action="store_true", help="Enable tflops calculation callback for Hyena / Evo2. Defaults to False.", ) - + parser.add_argument("--lr", type=float, default=3e-4, help="Learning rate.") + parser.add_argument("--min-lr", type=float, default=3e-5, help="Min learning rate in cosine annealing.") + parser.add_argument("--warmup-steps", type=int, default=2500, help="Number of warmup steps in cosine annealing") # NSYS profiling/tooling arguments parser.add_argument( "--nsys-profiling", @@ -174,6 +189,12 @@ def parse_args(): required=False, help="End nsys profiling after this step.", ) + parser.add_argument( + "--no-renormalize-loss", + action="store_true", + default=False, + help="Do not renormalize the loss weights.", + ) # rank as list of integers parser.add_argument( "--nsys-ranks", @@ -183,82 +204,17 @@ def parse_args(): default=[0], help="Enable nsys profiling for these ranks.", ) - + parser.add_argument( + "--activation-checkpoint-recompute-num-layers", + type=int, + help="If set, override the default value set in the config.", + ) + recompute_group = parser.add_mutually_exclusive_group(required=False) + recompute_group.add_argument("--no-activation-checkpointing", action="store_true", default=False) + recompute_group.add_argument("--selective-activation-checkpointing", action="store_true", default=False) return parser.parse_args() -@dataclass -class TPOverlapCfg: - """Base configuration class for Tensor Parallelism (TP) overlap.""" - - pass - - -@dataclass -class PipelineOverlapCfg(TPOverlapCfg): - """Configuration for Pipeline Parallelism overlap.""" - - num_sm: int - cga_size: int - num_splits: int - set_sm_margin: bool - fp8_buf: bool = (False,) - method: str = "pipeline" - - -@dataclass -class RingExchangeOverlapCfg(TPOverlapCfg): - """Configuration for ring exchange overlap.""" - - aggregate: bool = False - method: str = "ring_exchange" - num_sm: int = 1 - set_sm_margin: bool = False - - -@dataclass -class BulkOverlapCfg(TPOverlapCfg): - """Configuration for bulk overlap in TP.""" - - num_sm: int - cga_size: int - set_sm_margin: bool - method: str = "bulk" - - -# TODO(dorotat) why are we copy pasting those methods? They are in NeMo -@dataclass -class TransformerLayerTPOverlapCfg: - """Configuration for TP overlap in transformer layers.""" - - qkv_dgrad: TPOverlapCfg - qkv_wgrad: TPOverlapCfg - fc1_dgrad: TPOverlapCfg - fc1_wgrad: TPOverlapCfg - qkv_fprop: TPOverlapCfg - proj_dgrad: TPOverlapCfg - fc1_fprop: TPOverlapCfg - fc2_dgrad: TPOverlapCfg - proj_fprop: TPOverlapCfg - fc2_fprop: TPOverlapCfg - - -# TODO: Add more configs and create a getter function for expose a single api -# Model configs: H100/70B/TP8/MBS1/SeqLen8K -userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192 = TransformerLayerTPOverlapCfg( - qkv_dgrad=BulkOverlapCfg(num_sm=4, cga_size=2, set_sm_margin=False), - qkv_wgrad=BulkOverlapCfg(num_sm=24, cga_size=2, set_sm_margin=False), - fc1_dgrad=BulkOverlapCfg(num_sm=2, cga_size=2, set_sm_margin=False), - fc1_wgrad=BulkOverlapCfg(num_sm=4, cga_size=2, set_sm_margin=False), - qkv_fprop=RingExchangeOverlapCfg(aggregate=False), - proj_dgrad=RingExchangeOverlapCfg(aggregate=False), - fc1_fprop=RingExchangeOverlapCfg(aggregate=False), - fc2_dgrad=RingExchangeOverlapCfg(aggregate=False), - proj_fprop=PipelineOverlapCfg(num_sm=24, cga_size=2, num_splits=4, set_sm_margin=True), - fc2_fprop=PipelineOverlapCfg(num_sm=16, cga_size=2, num_splits=4, set_sm_margin=True), -) - - def parse_dataset_config(dataset_config_path: str): """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena. @@ -325,23 +281,37 @@ def main(): tokenizer=tokenizer, ) + if args.no_activation_checkpointing: + activation_checkpointing_args = { + "recompute_granularity": None, + "recompute_method": None, + "recompute_num_layers": None, + } + elif args.selective_activation_checkpointing: + activation_checkpointing_args = { + "recompute_granularity": "selective", + "recompute_method": None, + "recompute_num_layers": None, + } + else: + if args.activation_checkpoint_recompute_num_layers is not None: + activation_checkpointing_args = { + "recompute_num_layers": args.activation_checkpoint_recompute_num_layers, + } + else: + activation_checkpointing_args = {} + # Retrieve model config. config_modifiers_init = { "tp_comm_overlap": args.use_megatron_comm_overlap_llama3_8k, "seq_length": args.seq_length, + "to_upper": "weighted" if args.no_renormalize_loss else "normalized_weighted", + **activation_checkpointing_args, } - if args.model_size == "7b": - evo2_config = llm.Hyena7bConfig(**config_modifiers_init) - elif args.model_size == "7b_arc_1m": - evo2_config = llm.Hyena7bARCLongContextConfig(**config_modifiers_init) - elif args.model_size == "40b": - evo2_config = llm.Hyena40bConfig(**config_modifiers_init) - elif args.model_size == "40b_arc_1m": - evo2_config = llm.Hyena40bARCLongContextConfig(**config_modifiers_init) - elif args.model_size == "test": - evo2_config = llm.HyenaTestConfig(**config_modifiers_init) - else: + + if args.model_size not in model_options: raise ValueError(f"Invalid model size: {args.model_size}") + evo2_config = model_options[args.model_size](**config_modifiers_init) # Instantiate model. model = llm.GPTModel(evo2_config, tokenizer=data.tokenizer) @@ -419,12 +389,14 @@ def main(): name=( f"evo2-size-{args.model_size}-TP{args.tensor_parallel_size}-" f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" - f"-GBS{global_batch_size}-MBS{args.micro_batch_size}" + f"-GBS{global_batch_size}-MBS{args.micro_batch_size}-RENORMLOSS{args.renormalize_loss}" + f"-NOAC{args.no_activation_checkpointing}-SELAC{args.selective_activation_checkpointing}" + f"-LR{args.lr}-MINLR{args.min_lr}-WUSTEPS{args.warmup_steps}-WD{args.wd}" f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" f"-NODES{args.num_nodes}-FP8{args.fp8}" ), id=args.wandb_run_id, # set this to use the same curve name for restarts. - project="bionemo_evo2", + project=args.wandb_project, save_dir=args.experiment_dir, ) loggers.append(wandb_logger) @@ -511,16 +483,17 @@ def main(): # Optimizer and scheduler setup opt_config = OptimizerConfig( optimizer="adam", - lr=0.0003, + lr=args.lr, adam_beta1=0.9, adam_beta2=0.95, + weight_decay=args.wd, use_distributed_optimizer=True, bf16=True, ) sched = CosineAnnealingScheduler( max_steps=trainer.max_steps, - warmup_steps=2500, - min_lr=0.000003, + warmup_steps=args.warmup_steps, + min_lr=args.min_lr, ) opt = MegatronOptimizerModule(opt_config, sched) diff --git a/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml index 47588ef1d2..5956d22498 100644 --- a/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml +++ b/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml @@ -1,10 +1,10 @@ - dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.18 -- dataset_prefix: /workspace/bionemo2/data/gtdb_imgpr/pretraining_data_gtdb_imgpr/data_gtdb_imgpr_train_text_CharLevelTokenizer_document +- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.24 -- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_train_text_CharLevelTokenizer_document +- dataset_prefix: /workspace/bionemo2/data/imgvr/pretraining_data_imgvr/data_imgvr_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.03 - dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document @@ -31,7 +31,7 @@ - dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.24 -- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_valid_text_CharLevelTokenizer_document +- dataset_prefix: /workspace/bionemo2/data/imgvr/pretraining_data_imgvr/data_imgvr_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.03 - dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document @@ -58,7 +58,7 @@ - dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.24 -- dataset_prefix: /workspace/bionemo2/data/imgvr_untagged/imgvr_untagged_data/data_imgvr_test_text_CharLevelTokenizer_document +- dataset_prefix: /workspace/bionemo2/data/imgvr/pretraining_data_imgvr/data_imgvr_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.03 - dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document From 5fe257615a9868dac3799ed413607e6a98eb32de Mon Sep 17 00:00:00 2001 From: Jonathan Mitchell Date: Wed, 29 Jan 2025 18:04:19 -0800 Subject: [PATCH 043/140] Fixes `test_evo2.py` unit test and adds enhancements to existing unit tests for Evo2 inference. --- .../bionemo-evo2/tests/bionemo/test_evo2.py | 73 +++++++----- .../tests/bionemo/test_inference.py | 110 +++++++++++++++--- 2 files changed, 138 insertions(+), 45 deletions(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py index 9d0b73906f..6a3aef90cd 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py @@ -13,18 +13,17 @@ # See the License for the specific language governing permissions and # limitations under the License. - import logging from pathlib import Path from typing import Literal, Set +import numpy as np import pytest import torch from megatron.core.transformer.module import Float16Module from nemo.collections import llm from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning.io.pl import MegatronCheckpointIO -from transformer_engine.pytorch.utils import get_cudnn_version, get_device_compute_capability from bionemo.core.data.load import load from bionemo.llm.utils.weight_utils import ( @@ -60,7 +59,7 @@ def load_weights_sharded_inplace_nemo2_to_mcore( @pytest.mark.parametrize("seq_len", [8_192, 16_384]) -def test_golden_values(seq_len: int): +def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): """Step 1: # add local .ssh/*.pub key to eos ~/.ssh/authorized_keys mkdir -p arc_model/checkpoints/ @@ -94,30 +93,46 @@ def test_golden_values(seq_len: int): position_ids = torch.arange(len(input_seq)).unsqueeze(0).to(device) attention_mask = None outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) - gold_standard_no_fp8 = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) - our_generation_str = "".join( - [chr(idx) for idx in outputs.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy().tolist()] - ) - their_generation_str_no_fp8 = "".join( - [ - chr(idx) - for idx in gold_standard_no_fp8.softmax(dim=-1) - .argmax(dim=-1) - .flatten() - .detach() - .cpu() - .numpy() - .tolist() - ] + gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) + + top_2_logits_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=True, largest=True, k=2) + ambiguous_positions = ( + top_2_logits_golden.values[..., 0] - top_2_logits_golden.values[..., 1] + ).abs() < 9.9e-3 # hand tunes for observed diffs from A100 and H100 + n_ambiguous = ambiguous_positions.sum() + + assert n_ambiguous <= 19 + + our_char_indices = outputs.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy() + not_amb_positions = ~ambiguous_positions.flatten().cpu().numpy() + # Generate our string, removing the ambiguous positions. + our_generation_str = "".join([chr(idx) for idx in our_char_indices[not_amb_positions].tolist()]) + # Do the same to the golden values + gold_std_char_indices = ( + gold_standard_no_fp8_tensor.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy() ) - char_matches_ours_v_theirs_no_fp8 = [ - our_generation_str[i] == their_generation_str_no_fp8[i] for i in range(len(their_generation_str_no_fp8)) - ] - token_similarity_vs_no_fp8 = sum(char_matches_ours_v_theirs_no_fp8) / len(char_matches_ours_v_theirs_no_fp8) - # We can get exact very tight numerical precision on H100 with cudnn 9.5+ (nvidia docker 24.10-py3 or better) - if get_cudnn_version() >= (9, 5, 0) and get_device_compute_capability() >= (9, 0): - assert token_similarity_vs_no_fp8 == 1.0 - torch.testing.assert_close(outputs, gold_standard_no_fp8) - else: - assert token_similarity_vs_no_fp8 >= 0.996 - torch.testing.assert_close(outputs, gold_standard_no_fp8, atol=0.3, rtol=3) + # Make the string + gold_std_str = "".join([chr(idx) for idx in gold_std_char_indices[not_amb_positions].tolist()]) + + # Ensure the two strings are equal. + assert all(np.array(list(our_generation_str)) == np.array(list(gold_std_str))) + + # Verify that the top-4 from the logit vectors are the same. + # A: 65 + # C: 67 + # G: 71 + # T: 84 + # Find the corresponding ATGC and compare the two vectors with those four values. + # Ensures that the top 4 ascii characters of the output are ACGT. + top_4_inds = outputs.topk(dim=-1, sorted=False, largest=True, k=4) + assert set(top_4_inds.indices.flatten().cpu().numpy().tolist()).issubset((65, 67, 71, 84)) + output_vector = outputs[0, -1, top_4_inds.indices] + + # Then its the top 4 indices of the gold standard tensor + top_4_inds_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=False, largest=True, k=4) + assert set(top_4_inds_golden.indices.flatten().cpu().numpy().tolist()).issubset((65, 67, 71, 84)) + gold_standard_no_fp8_vector = gold_standard_no_fp8_tensor[0, -1, top_4_inds_golden.indices] + + # Run cosine similarity between the two vectors. + logit_similarity = torch.nn.functional.cosine_similarity(output_vector, gold_standard_no_fp8_vector, dim=-1) + assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 9.9e-3 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py index 2eecf62ea9..ad7541ccc8 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py @@ -19,6 +19,7 @@ from nemo.collections.llm import generate from bionemo.core.data.load import load +from bionemo.testing.megatron_parallel_state_utils import _teardown_apex_megatron_cuda, clean_parallel_state_context RANDOM_SEED = 42 @@ -71,20 +72,97 @@ def test_infer_model_generates_expected_single_token_output(): max_new_tokens = 1 checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") - results = generate( - path=checkpoint_path, - prompts=[prompt], - trainer=trainer, - inference_params=CommonInferenceParams( - temperature, - top_k, - top_p, - return_log_probs=False, - num_tokens_to_generate=max_new_tokens, - ), - random_seed=RANDOM_SEED, - text_only=True, - ) + with clean_parallel_state_context(): + results = generate( + path=checkpoint_path, + prompts=[prompt], + trainer=trainer, + inference_params=CommonInferenceParams( + temperature, + top_k, + top_p, + return_log_probs=False, + num_tokens_to_generate=max_new_tokens, + ), + random_seed=RANDOM_SEED, + text_only=True, + ) + + assert isinstance(results, list) + assert results == ["T"] + _teardown_apex_megatron_cuda() + torch.cuda.empty_cache() + + +# def test_infer_model_generates_expected_single_token_output_from_input_seq(): +# # Create PTL trainer. +# # TODO: Uncomment when the GPU Memory allocation issue is resolved. +# _teardown_apex_megatron_cuda() +# torch.cuda.empty_cache() +# TENSOR_PARALLEL_SIZE = 1 +# PIPELINE_MODEL_PARALLEL_SIZE = 1 +# CONTEXT_PARALLEL_SIZE = 1 +# NUM_GPUS = 1 +# NUM_NODES = 1 + +# strategy = nl.MegatronStrategy( +# tensor_model_parallel_size=TENSOR_PARALLEL_SIZE, +# pipeline_model_parallel_size=PIPELINE_MODEL_PARALLEL_SIZE, +# context_parallel_size=CONTEXT_PARALLEL_SIZE, +# pipeline_dtype=torch.bfloat16, +# ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. +# ckpt_save_optimizer=False, +# ckpt_async_save=False, +# save_ckpt_format="zarr", +# ) +# trainer = nl.Trainer( +# accelerator="gpu", +# num_nodes=NUM_NODES, +# devices=NUM_GPUS, +# strategy=strategy, +# log_every_n_steps=1, +# limit_val_batches=10, +# num_sanity_val_steps=0, +# plugins=nl.MegatronMixedPrecision( +# precision="bf16-mixed", +# params_dtype=torch.bfloat16, +# ), +# ) +# # Last char from gold std removed. +# input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAA" +# deleted_char = "T" +# temperature = 1.0 +# top_k = 0 +# top_p = 0.0 +# max_new_tokens = 1 +# checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") +# gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") +# gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8) +# gold_standard_no_fp8_tensor = gold_standard_no_fp8_tensor[0, -1] +# results = generate( +# path=checkpoint_path, +# prompts=[input_seq], +# trainer=trainer, +# inference_params=CommonInferenceParams( +# temperature, +# top_k, +# top_p, +# return_log_probs=False, +# num_tokens_to_generate=max_new_tokens, +# ), +# random_seed=RANDOM_SEED, +# text_only=False, +# ) + +# # Text equal to "T" (deleted char) +# assert results[0].generated_text == deleted_char +# assert isinstance(results, list) + +# TODO: Later... +# Do comparison to test golden values for the logit vector. +# gold_standard_logits_vector = gold_standard_no_fp8_tensor - assert isinstance(results, list) - assert results == ["T"] +# Do cosine similarity between the two vectors, for the topk=4 indices. +# Make sure topk=4 = ACTG +# Use indices to go from 512 -> 4. +# Do cosine similarity between the two vectors. From 30e71e908ae2e34eaf65534486a5a3d6d2880700 Mon Sep 17 00:00:00 2001 From: John St John Date: Thu, 30 Jan 2025 09:10:05 -0800 Subject: [PATCH 044/140] Fix bug in wandb logger argparse. --- sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 307a464314..703f3170fb 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -389,8 +389,9 @@ def main(): name=( f"evo2-size-{args.model_size}-TP{args.tensor_parallel_size}-" f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" - f"-GBS{global_batch_size}-MBS{args.micro_batch_size}-RENORMLOSS{args.renormalize_loss}" + f"-GBS{global_batch_size}-MBS{args.micro_batch_size}-SkipLossRenorm{args.no_renormalize_loss}" f"-NOAC{args.no_activation_checkpointing}-SELAC{args.selective_activation_checkpointing}" + f"-ACRNL{evo2_config.recompute_num_layers}" f"-LR{args.lr}-MINLR{args.min_lr}-WUSTEPS{args.warmup_steps}-WD{args.wd}" f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" f"-NODES{args.num_nodes}-FP8{args.fp8}" From 635a5df8a533e90838746c1cba2735c29c246067 Mon Sep 17 00:00:00 2001 From: Cory Ye Date: Mon, 3 Feb 2025 11:41:31 -0800 Subject: [PATCH 045/140] [cye/pad-loss-mask] Fixes TP comm overlap bug with sequence parallel and reduce the size of torch_dist checkpoints. --- 3rdparty/NeMo | 2 +- Dockerfile | 6 ++-- ...atron-lm-mr2604-torch-dist-ckpt-size.patch | 32 +++++++++++++++++++ .../src/bionemo/evo2/run/train.py | 2 ++ 4 files changed, 39 insertions(+), 3 deletions(-) create mode 100644 ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch diff --git a/3rdparty/NeMo b/3rdparty/NeMo index b92de49003..2e32fb9f6e 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit b92de49003634813f385e25d02708dc5deb60cea +Subproject commit 2e32fb9f6eb035a009c7fcc10368b1e4f2f26f3a diff --git a/Dockerfile b/Dockerfile index 6a34456ca4..4d0c0e08d9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -124,10 +124,12 @@ COPY ./3rdparty /workspace/bionemo2/3rdparty COPY ./sub-packages /workspace/bionemo2/sub-packages # Apply patches with temporary fixes, before the modules are installed. (Use absolute path for patch filepath.) -# FIXME(dorotat) remove when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2468 is merged -COPY ./ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch /workspace/bionemo2/ci/scripts/ +# FIXME(dorotat) Remove when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2468 is merged. +# FIXME(cspades) Remove the torch_dist checkpoint size patch when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2604 is merged. +COPY ./ci/scripts/*.patch /workspace/bionemo2/ci/scripts/ RUN MEGATRON_DIR=./3rdparty/Megatron-LM && \ patch -p1 -d $MEGATRON_DIR -i /workspace/bionemo2/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch && \ +patch -p1 -d $MEGATRON_DIR -i /workspace/bionemo2/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch && \ rm ./ci/scripts/*.patch # Note, we need to mount the .git folder here so that setuptools-scm is able to fetch git tag for version. diff --git a/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch b/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch new file mode 100644 index 0000000000..fb064ff7ff --- /dev/null +++ b/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch @@ -0,0 +1,32 @@ +diff --git a/megatron/core/dist_checkpointing/strategies/filesystem_async.py b/megatron/core/dist_checkpointing/strategies/filesystem_async.py +index 47ab4d112..48de3218b 100644 +--- a/megatron/core/dist_checkpointing/strategies/filesystem_async.py ++++ b/megatron/core/dist_checkpointing/strategies/filesystem_async.py +@@ -113,6 +113,18 @@ class FileSystemWriterAsync(FileSystemWriter): + file_count += 1 + return file_name + ++ def _copy_to_cpu(ten: torch.Tensor): ++ """Pinned D2H copy (or a simple clone() if already on the CPU). ++ ++ Makes sure we perform a `clone` only if we detect incontiguous storage, ++ so that we don't blow up host memory unnecessarily. ++ """ ++ ten = ten.detach() ++ if ten.device.type != "cpu": ++ return ten.to("cpu", non_blocking=True) ++ is_view = ten.untyped_storage().size() != ten.numel() * ten.itemsize ++ return ten.clone() if is_view else ten ++ + # Prepare bytes / tensor data in each bucket, which will be assigned to each writer process + self.write_buckets = [] + for group_name, group_buckets in _split_by_separation_hint( +@@ -125,7 +137,7 @@ class FileSystemWriterAsync(FileSystemWriter): + if item.type == WriteItemType.BYTE_IO + ] + tensor_data = [ +- (item, planner.resolve_data(item).detach().to("cpu", non_blocking=True)) ++ (item, _copy_to_cpu(planner.resolve_data(item))) + for item in bucket + if item.type != WriteItemType.BYTE_IO + ] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 703f3170fb..2a61f4298b 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -279,6 +279,7 @@ def main(): seed=args.seed, num_workers=args.workers, tokenizer=tokenizer, + eod_mask_loss=False, ) if args.no_activation_checkpointing: @@ -306,6 +307,7 @@ def main(): "tp_comm_overlap": args.use_megatron_comm_overlap_llama3_8k, "seq_length": args.seq_length, "to_upper": "weighted" if args.no_renormalize_loss else "normalized_weighted", + "distribute_saved_activations": False if args.sequence_parallel else True, **activation_checkpointing_args, } From f14183047f30912f161d2d10e6f7979e2e216f9e Mon Sep 17 00:00:00 2001 From: Jared Wilber Date: Mon, 3 Feb 2025 14:45:13 -0800 Subject: [PATCH 046/140] Add longphase dataset config to repo --- .../config/longphase_dataset_config.yaml | 450 ++++++++++++++++++ 1 file changed, 450 insertions(+) create mode 100644 sub-packages/bionemo-evo2/tests/config/longphase_dataset_config.yaml diff --git a/sub-packages/bionemo-evo2/tests/config/longphase_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/config/longphase_dataset_config.yaml new file mode 100644 index 0000000000..93ac53f9c0 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/config/longphase_dataset_config.yaml @@ -0,0 +1,450 @@ +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.05 +- dataset_prefix: /workspace/bionemo2/data/long_gtdb_v220/imgpr_pretraining_data/data_imgpr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/long_gtdb_v220/gtdbv220_longcontext_pretraining_data/data_gtdb_stitched_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.235 +- dataset_prefix: /workspace/bionemo2/data/imgvr_tagged/imgvr_tag_data/data_imgvr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.02 +- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.01 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.0001 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.0025 +- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.05 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch1_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch2_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch3_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch4_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch5_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch6_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch7_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch8_animalia_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch1_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch2_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch3_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch4_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch5_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch6_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch7_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch8_plantae_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch1_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch2_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch3_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch4_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch5_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch6_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch7_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch8_fungi_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch1_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch2_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch3_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch4_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch5_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch6_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch7_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch8_protista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch1_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch2_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch3_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch4_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch5_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch6_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch7_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_train_batch8_chromista_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.05 +- dataset_prefix: /workspace/bionemo2/data/long_gtdb_v220/imgpr_pretraining_data/data_imgpr_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/long_gtdb_v220/gtdbv220_longcontext_pretraining_data/data_gtdb_stitched_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.235 +- dataset_prefix: /workspace/bionemo2/data/imgvr_tagged/imgvr_tag_data/data_imgvr_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.02 +- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.01 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.0001 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.0025 +- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.05 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch1_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch2_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch3_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch4_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch5_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch6_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch7_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch8_animalia_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch1_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch2_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch3_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch4_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch5_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch6_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch7_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch8_plantae_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch1_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch2_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch3_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch4_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch5_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch6_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch7_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch8_fungi_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch1_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch2_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch3_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch4_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch5_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch6_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch7_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch8_protista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch1_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch2_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch3_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch4_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch5_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch6_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch7_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_valid_batch8_chromista_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.05 +- dataset_prefix: /workspace/bionemo2/data/long_gtdb_v220/imgpr_pretraining_data/data_imgpr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/long_gtdb_v220/gtdbv220_longcontext_pretraining_data/data_gtdb_stitched_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.235 +- dataset_prefix: /workspace/bionemo2/data/imgvr_tagged/imgvr_tag_data/data_imgvr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.02 +- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.01 +- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.0001 +- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.0025 +- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.05 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch1_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch2_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch3_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch4_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch5_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch6_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch7_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch8_animalia_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.045 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch1_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch2_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch3_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch4_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch5_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch6_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch7_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch8_plantae_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.015 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch1_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch2_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch3_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch4_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch5_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch6_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch7_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch8_fungi_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch1_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch2_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch3_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch4_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch5_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch6_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch7_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch8_protista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch1_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch2_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch3_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch4_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch5_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch6_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch7_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 +- dataset_prefix: /workspace/bionemo2/data/eukaryote_ncbi/euk_ncbi_long_sequence/euk_ncbi_long_pretraining_data/data_test_batch8_chromista_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.001 From 493d444868f40c7aad7a0fea53cdfa32a25c252b Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska Date: Wed, 5 Feb 2025 10:05:52 -0800 Subject: [PATCH 047/140] bump Megatron-LM, nemo-savanna and rebase to main OSS --- .devcontainer/devcontainer.json | 1 + .devcontainer/initializeCommand.sh | 9 + .github/ISSUE_TEMPLATE/bug-report.yml | 102 + .github/ISSUE_TEMPLATE/feature-request.yml | 63 + .github/pull_request_template.md | 8 +- .github/workflows/approvals.yml | 74 + .github/workflows/blossom-ci.yml | 1 + .github/workflows/gh-docs-deploy.yml | 2 + .github/workflows/pr-labels.yml | 48 - .github/workflows/unit-tests.yml | 53 +- .gitignore | 1 + .secrets-nb.baseline | 4 +- .secrets.baseline | 4 +- 3rdparty/Megatron-LM | 2 +- 3rdparty/NeMo | 2 +- CODEOWNERS | 36 +- Dockerfile | 74 +- LICENSE/third_party.txt | 280 + README.md | 54 +- ci/benchmarks/partial-conv/esm2_pretrain.yaml | 4 +- .../megatron-lm-mr2468-shard-tensor-fix.patch | 261 - ci/scripts/run_pytest.sh | 11 +- ci/scripts/utils.sh | 2 +- .../images/esm2/esm2_device_scaling.png | Bin 0 -> 43993 bytes .../assets/images/esm2/esm2_model_scaling.png | Bin 0 -> 175636 bytes .../assets/images/esm2/esm2_model_scaling.svg | 298 +- .../images/esm2/esm2_pretrain_convergence.png | Bin 0 -> 28627 bytes .../esm2/esm2_single_node_training_perf.png | Bin 0 -> 32841 bytes .../dependency_file_imports.png | Bin 0 -> 99404 bytes .../dependency_graph_pyproject.png | Bin 0 -> 205322 bytes .../dependency_graph_tach.png | Bin 0 -> 167062 bytes docs/docs/models/ESM-2/index.md | 14 +- docs/docs/models/ESM-2/pre-training.md | 6 +- docs/docs/models/index.md | 2 +- .../user-guide/appendix/releasenotes-fw.md | 13 + .../user-guide/contributing/contributing.md | 6 + .../sub-package_dependency_graph.md | 17 + .../examples/bionemo-esm2/finetune.ipynb | 1017 ++++ .../examples/bionemo-esm2/finetune.md | 263 - .../examples/bionemo-esm2/inference.ipynb | 43 +- .../geneformer-celltype-classification.ipynb | 1452 +++--- .../user-guide/getting-started/development.md | 2 +- internal/Pypi_publish.md | 23 + pyproject.toml | 17 +- requirements-cve.txt | 2 - requirements-dev.txt | 2 +- .../src/bionemo/core/data/load.py | 38 +- .../src/bionemo/core/data/resources/esm2.yaml | 67 +- .../tests/bionemo/core/data/test_load.py | 24 +- sub-packages/bionemo-esm2/pyproject.toml | 1 + .../src/bionemo/esm2/data/datamodule.py | 6 +- .../src/bionemo/esm2/model/convert.py | 179 + .../bionemo/esm2/model/finetune/datamodule.py | 106 +- .../bionemo/esm2/model/finetune/dataset.py | 253 + .../esm2/model/finetune/finetune_regressor.py | 238 - .../finetune/finetune_token_classifier.py | 282 - .../src/bionemo/esm2/model/finetune/loss.py | 132 + .../esm2/model/finetune/sequence_model.py | 139 + .../esm2/model/finetune/token_model.py | 134 + .../src/bionemo/esm2/model/finetune/train.py | 189 - .../src/bionemo/esm2/scripts/finetune_esm2.py | 765 +++ .../src/bionemo/esm2/scripts/infer_esm2.py | 9 +- .../src/bionemo/esm2/scripts/train_esm2.py | 32 +- .../src/bionemo/esm2/testing/__init__.py | 14 + .../src/bionemo/esm2/testing/compare.py | 99 + .../tests/bionemo/esm2/conftest.py | 22 + .../bionemo/esm2/data/test_datamodule.py | 15 + .../esm2/model/finetune/test_datamodule.py | 81 + .../esm2/model/finetune/test_dataset.py | 174 + .../esm2/model/finetune/test_finetune.py | 143 - .../model/finetune/test_sequence_model.py | 51 + .../esm2/model/finetune/test_token_model.py | 52 + .../tests/bionemo/esm2/model/test_convert.py | 55 + .../tests/bionemo/esm2/model/test_model.py | 253 +- .../esm2/scripts/test_finetune_esm2.py | 388 ++ .../bionemo/esm2/scripts/test_infer_esm2.py | 83 +- sub-packages/bionemo-evo2/pyproject.toml | 4 +- .../src/bionemo/evo2/run/infer.py | 79 +- .../src/bionemo/evo2/run/train.py | 12 + .../evo2/data/test_dataset_config.yaml | 6 + ...omoters_uint8_distinct_byte-level_test.bin | 0 ...omoters_uint8_distinct_byte-level_test.idx | Bin 0 -> 42 bytes ...moters_uint8_distinct_byte-level_train.bin | Bin 0 -> 8414 bytes ...moters_uint8_distinct_byte-level_train.idx | Bin 0 -> 322 bytes ...romoters_uint8_distinct_byte-level_val.bin | Bin 0 -> 1202 bytes ...romoters_uint8_distinct_byte-level_val.idx | Bin 0 -> 82 bytes .../bionemo/evo2/data/test_preprocess.py | 1 + .../tests/bionemo/run/test_infer.py | 65 + .../bionemo-evo2/tests/bionemo/test_evo2.py | 19 +- .../tests/bionemo/test_inference.py | 2 + sub-packages/bionemo-fw/pyproject.toml | 1 + .../src/bionemo/fw/dependency_graph.py | 225 + .../tests/bionemo/fw/test_dependency_graph.py | 228 + .../src/bionemo/geneformer/api.py | 14 +- .../model/finetune_token_regressor.py | 5 +- .../scripts/test_train_geneformer.py | 1 + .../bionemo-llm/src/bionemo/llm/lightning.py | 156 +- .../src/bionemo/llm/model/config.py | 2 + .../bionemo-llm/src/bionemo/llm/model/loss.py | 31 +- .../src/bionemo/llm/run/config_models.py | 3 +- .../bionemo-llm/src/bionemo/llm/train.py | 11 +- .../tests/bionemo/llm/test_lightning.py | 152 +- sub-packages/bionemo-moco/LICENSE | 1 + sub-packages/bionemo-moco/README.md | 35 + sub-packages/bionemo-moco/VERSION | 1 + sub-packages/bionemo-moco/documentation.md | 4620 +++++++++++++++++ .../bionemo-moco/environment/Instructions.md | 8 + .../bionemo-moco/environment/moco_env.yaml | 41 + .../bionemo-moco/environment/setup.sh | 39 + ...continuous_data_interpolant_tutorial.ipynb | 1803 +++++++ .../discrete_data_interpolant_tutorial.ipynb | 1000 ++++ .../examples/ot_sampler_tutorial.ipynb | 644 +++ sub-packages/bionemo-moco/pyproject.toml | 34 + sub-packages/bionemo-moco/scripts/README.md | 35 + .../scripts/clean_documentation.py | 43 + .../scripts/create_documentation.sh | 2 + .../bionemo-moco/src/bionemo/moco/__init__.py | 20 + .../bionemo/moco/distributions/__init__.py | 14 + .../moco/distributions/prior/__init__.py | 23 + .../prior/continuous/__init__.py | 14 + .../prior/continuous/gaussian.py | 80 + .../prior/continuous/harmonic.py | 104 + .../distributions/prior/continuous/utils.py | 38 + .../distributions/prior/discrete/__init__.py | 14 + .../distributions/prior/discrete/custom.py | 72 + .../moco/distributions/prior/discrete/mask.py | 112 + .../distributions/prior/discrete/uniform.py | 60 + .../moco/distributions/prior/distribution.py | 64 + .../moco/distributions/time/__init__.py | 29 + .../bionemo/moco/distributions/time/beta.py | 75 + .../moco/distributions/time/distribution.py | 124 + .../moco/distributions/time/logit_normal.py | 77 + .../moco/distributions/time/uniform.py | 122 + .../bionemo/moco/distributions/time/utils.py | 35 + .../src/bionemo/moco/interpolants/__init__.py | 38 + .../moco/interpolants/base_interpolant.py | 241 + .../moco/interpolants/batch_augmentation.py | 62 + .../interpolants/continuous_time/__init__.py | 14 + .../continuous_time/continuous/__init__.py | 14 + .../continuous/continuous_flow_matching.py | 545 ++ .../continuous/optimal_transport/__init__.py | 14 + .../equivariant_ot_sampler.py | 243 + .../optimal_transport/kabsch_augmentation.py | 148 + .../optimal_transport/ot_sampler.py | 209 + .../continuous/optimal_transport/ot_types.py | 32 + .../continuous_time/continuous/vdm.py | 515 ++ .../continuous_time/discrete/__init__.py | 14 + .../discrete/discrete_flow_matching.py | 352 ++ .../continuous_time/discrete/mdlm.py | 374 ++ .../interpolants/discrete_time/__init__.py | 14 + .../discrete_time/continuous/__init__.py | 14 + .../discrete_time/continuous/ddpm.py | 537 ++ .../discrete_time/discrete/__init__.py | 14 + .../discrete_time/discrete/d3pm.py | 384 ++ .../moco/interpolants/discrete_time/utils.py | 43 + .../src/bionemo/moco/schedules/__init__.py | 14 + .../schedules/inference_time_schedules.py | 460 ++ .../bionemo/moco/schedules/noise/__init__.py | 14 + .../noise/continuous_noise_transforms.py | 182 + .../noise/continuous_snr_transforms.py | 294 ++ .../noise/discrete_noise_schedules.py | 173 + .../src/bionemo/moco/schedules/utils.py | 24 + .../prior/continuous/test_gaussian.py | 73 + .../prior/continuous/test_harmonic.py | 28 + .../prior/discrete/test_custom.py | 76 + .../distributions/prior/discrete/test_mask.py | 69 + .../prior/discrete/test_uniform.py | 68 + .../time/test_time_distribution.py | 146 + .../test_continuous_flow_matching.py | 273 + .../continuous/test_optimal_transport.py | 334 ++ .../continuous_time/continuous/test_vdm.py | 194 + .../discrete/test_discrete_flow_matching.py | 241 + .../continuous_time/discrete/test_mdlm.py | 183 + .../discrete_time/continuous/test_ddpm.py | 365 ++ .../discrete_time/discrete/test_d3pm.py | 157 + .../noise/test_continuous_noise_transforms.py | 73 + .../noise/test_continuous_snr_transforms.py | 127 + .../noise/test_discrete_noise_schedule.py | 64 + .../schedules/test_inference_schedules.py | 162 + .../tests/bionemo/moco/test_env.py | 51 + sub-packages/bionemo-scdl/README.md | 21 +- .../examples/example_notebook.ipynb | 64 +- .../bionemo-scdl/images/disk_space.png | Bin 0 -> 71701 bytes .../bionemo-scdl/images/throughput.png | Bin 0 -> 31447 bytes .../bionemo/scdl/index/row_feature_index.py | 14 +- .../scdl/io/single_cell_memmap_dataset.py | 16 +- .../scdl/index/test_row_feature_index.py | 23 +- .../src/bionemo/testing/lightning.py | 10 +- .../testing/megatron_parallel_state_utils.py | 30 +- tach.toml | 92 +- 190 files changed, 23316 insertions(+), 3317 deletions(-) create mode 100755 .devcontainer/initializeCommand.sh create mode 100644 .github/ISSUE_TEMPLATE/bug-report.yml create mode 100644 .github/ISSUE_TEMPLATE/feature-request.yml create mode 100644 .github/workflows/approvals.yml delete mode 100644 .github/workflows/pr-labels.yml delete mode 100644 ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch create mode 100644 docs/docs/assets/images/esm2/esm2_device_scaling.png create mode 100644 docs/docs/assets/images/esm2/esm2_model_scaling.png create mode 100644 docs/docs/assets/images/esm2/esm2_pretrain_convergence.png create mode 100644 docs/docs/assets/images/esm2/esm2_single_node_training_perf.png create mode 100644 docs/docs/assets/images/sub_package_graphs/dependency_file_imports.png create mode 100644 docs/docs/assets/images/sub_package_graphs/dependency_graph_pyproject.png create mode 100644 docs/docs/assets/images/sub_package_graphs/dependency_graph_tach.png create mode 100644 docs/docs/user-guide/contributing/sub-package_dependency_graph.md create mode 100644 docs/docs/user-guide/examples/bionemo-esm2/finetune.ipynb delete mode 100644 docs/docs/user-guide/examples/bionemo-esm2/finetune.md create mode 100644 internal/Pypi_publish.md create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/convert.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/dataset.py delete mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_regressor.py delete mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/loss.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/sequence_model.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/token_model.py delete mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/finetune_esm2.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/testing/__init__.py create mode 100644 sub-packages/bionemo-esm2/src/bionemo/esm2/testing/compare.py create mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_datamodule.py create mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_dataset.py delete mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py create mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_sequence_model.py create mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_token_model.py create mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_convert.py create mode 100644 sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_finetune_esm2.py create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py create mode 100644 sub-packages/bionemo-fw/src/bionemo/fw/dependency_graph.py create mode 100644 sub-packages/bionemo-fw/tests/bionemo/fw/test_dependency_graph.py create mode 120000 sub-packages/bionemo-moco/LICENSE create mode 100644 sub-packages/bionemo-moco/README.md create mode 100644 sub-packages/bionemo-moco/VERSION create mode 100644 sub-packages/bionemo-moco/documentation.md create mode 100644 sub-packages/bionemo-moco/environment/Instructions.md create mode 100644 sub-packages/bionemo-moco/environment/moco_env.yaml create mode 100644 sub-packages/bionemo-moco/environment/setup.sh create mode 100644 sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb create mode 100644 sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb create mode 100644 sub-packages/bionemo-moco/examples/ot_sampler_tutorial.ipynb create mode 100644 sub-packages/bionemo-moco/pyproject.toml create mode 100644 sub-packages/bionemo-moco/scripts/README.md create mode 100644 sub-packages/bionemo-moco/scripts/clean_documentation.py create mode 100644 sub-packages/bionemo-moco/scripts/create_documentation.sh create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/batch_augmentation.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/equivariant_ot_sampler.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/kabsch_augmentation.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_sampler.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_types.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py create mode 100644 sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_noise_transforms.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_snr_transforms.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py create mode 100644 sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py create mode 100644 sub-packages/bionemo-scdl/images/disk_space.png create mode 100644 sub-packages/bionemo-scdl/images/throughput.png diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 72d906fc92..52c76dc8b2 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -24,6 +24,7 @@ "NUMBA_CACHE_DIR": "/tmp/" }, "postCreateCommand": "./.devcontainer/postCreateCommand.sh", + "initializeCommand": "./.devcontainer/initializeCommand.sh", "remoteUser": "ubuntu", "customizations": { "vscode": { diff --git a/.devcontainer/initializeCommand.sh b/.devcontainer/initializeCommand.sh new file mode 100755 index 0000000000..29d7f06f75 --- /dev/null +++ b/.devcontainer/initializeCommand.sh @@ -0,0 +1,9 @@ +#!/bin/bash +# Create the mounted config directories if they don't already exist + +mkdir -p ~/.aws +mkdir -p ~/.ngc +mkdir -p ~/.cache +mkdir -p ~/.ssh +[ ! -f ~/.netrc ] && touch ~/.netrc +exit 0 diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml new file mode 100644 index 0000000000..6ebf552a85 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug-report.yml @@ -0,0 +1,102 @@ +name: Bug Report +description: Create a detailed bug report to help us resolve the issue +title: "[BUG] " +labels: ["bug", "triage"] +assignees: [] + +body: + - type: markdown + attributes: + value: | + Thanks for taking the time to fill out this bug report. Please provide as much detail as possible to help us investigate. + + - type: input + id: version + attributes: + label: BioNeMo Framework Version + description: What version or commit hash of the framework are you using? Please, specify a commit hash or version tag. Do not use 'latest', 'ToT' or 'nightly' as a reference. + placeholder: commit-hash or version tag, ie v1.2.3. + validations: + required: true + + - type: textarea + id: description + attributes: + label: Bug Description + description: Provide a clear and concise description of the bug + placeholder: | + Describe what happened and what you expected to happen. + Include any relevant context about when/where this occurs. + validations: + required: true + + - type: textarea + id: reproduction + attributes: + label: Steps to Reproduce + description: Provide detailed steps to reproduce the behavior + placeholder: | + 1. Configure environment with '...' + 2. Run command '...' + 3. Execute function '...' + 4. See error + + Code example: + ```python + # Minimal code that reproduces the issue + ``` + validations: + required: true + + - type: textarea + id: logs + attributes: + label: Error Messages and Logs + description: Include any relevant error messages, stack traces, or logs + render: shell + placeholder: | + ``` + Paste the full error message and stack trace here + ``` + validations: + required: false + + - type: input + id: docker-image-info + attributes: + label: Docker Image + description: If the issue occurred in a container, provide the docker image name. Visit [BioNeMo Framework NGC website](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/bionemo-framework/tags) for available images. + placeholder: e.g., nvcr.io/nvidia/clara/bionemo-framework:2.2 + validations: + required: false + + - type: textarea + id: system-info + attributes: + label: System Information + description: Provide details about your system environment + value: | + Environment Details: + - OS: [e.g., Ubuntu 20.04] + - CPU: [e.g., Intel i9-12900K] + - RAM: [e.g., 64GB] + + GPU Details: + - GPU Model: [e.g., NVIDIA RTX 4090] + - GPU Memory: [e.g., 24GB] + - CUDA Version: [e.g., 12.1] + - CUDA Driver: [e.g., 525.85.05] + - cuDNN Version: [e.g., 8.9.0] + + validations: + required: false + + - type: textarea + id: additional + attributes: + label: Additional Context + description: Add any other context about the problem here + placeholder: | + - Screenshots (if applicable) + - Links to relevant documentation + - Attempted solutions diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml new file mode 100644 index 0000000000..7e82ac2b8b --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature-request.yml @@ -0,0 +1,63 @@ +name: Feature request +description: Propose a feature +title: "[Feature] <Title>" +labels: ["triage", "feature"] +body: + - type: textarea + attributes: + label: Problem & Motivation + description: What problem does this solve? + placeholder: | + - Problem description + - Current pain points + - Related issues + validations: + required: true + + - type: input + id: version + attributes: + label: BioNeMo Framework Version + description: What version or commit hash of the framework are you using? Please, specify a commit hash or version tag. Do not use 'latest', 'ToT' or 'nightly' as a reference. + placeholder: commit-hash or version tag, ie v1.2.3. + validations: + required: true + + - type: dropdown + attributes: + label: Category + options: + - Model/Training + - Data Processing + - Inference + - API/Interface + - Other + validations: + required: true + + - type: textarea + attributes: + label: Proposed Solution + description: Technical approach + placeholder: | + - Implementation details + - Required changes + - Performance impact + validations: + required: true + + - type: textarea + attributes: + label: Expected Benefits + description: Quantify improvements + placeholder: | + - Performance gains + - Resource savings + validations: + required: true + + - type: textarea + attributes: + label: Code Example + description: Example code/pseudocode + render: python diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 5b31e2e1da..5171aed649 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -11,10 +11,12 @@ - [ ] Other (please describe): ### CI Pipeline Configuration -Configure CI behavior by checking relevant boxes below. This will automatically apply labels. +Configure CI behavior by applying the relevant labels: + +- [SKIP_CI](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#skip_ci) - Skip all continuous integration tests +- [INCLUDE_NOTEBOOKS_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_notebooks_tests) - Execute notebook validation tests in pytest +- [INCLUDE_SLOW_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_slow_tests) - Execute tests labelled as slow in pytest for extensive testing -- [ ] [SKIP_CI](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#skip_ci) - Skip all continuous integration tests -- [ ] [INCLUDE_NOTEBOOKS_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_notebooks_tests) - Execute notebook validation tests in pytest > [!NOTE] > By default, the notebooks validation tests are skipped unless explicitly enabled. diff --git a/.github/workflows/approvals.yml b/.github/workflows/approvals.yml new file mode 100644 index 0000000000..5ddeb03866 --- /dev/null +++ b/.github/workflows/approvals.yml @@ -0,0 +1,74 @@ +name: Enforce Tiered Approvals + +on: + pull_request_review: + +env: + TIER2_REVIEWERS: "jstjohn,trvachov,pstjohn" + +jobs: + check_approval: + runs-on: ubuntu-latest + outputs: + status: ${{ steps.check_tier2.outputs.status }} + steps: + - name: Get PR reviews + id: get_reviews + uses: actions/github-script@v6 + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + script: | + const { data: reviews } = await github.rest.pulls.listReviews({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: context.payload.pull_request.number, + }); + + const latestReviews = {}; + for (const review of reviews) { + latestReviews[review.user.login] = review.state; + } + + console.log('Latest Reviews:', latestReviews); + + const approvedUsers = Object.keys(latestReviews).filter(user => latestReviews[user] === 'APPROVED'); + + core.setOutput('approvedUsers', approvedUsers.join(',')); + + - name: Check +2 approvals (global tier) + id: check_tier2 + run: | + echo "Checking for +2 approvals..." + APPROVED_USERS="${{ steps.get_reviews.outputs.approvedUsers }}" + + TIER2_APPROVED=false + + echo "Approved Users: $APPROVED_USERS" + echo "Tier 2 Reviewers: $TIER2_REVIEWERS" + + IFS=',' read -ra reviewer_array <<< "$TIER2_REVIEWERS" + # Iterate over approved users and compare with cleaned TIER2_REVIEWERS + for USER in ${APPROVED_USERS//,/ }; do + echo "Checking approved USER: $USER" + for REVIEWER in "${reviewer_array[@]}"; do + echo "Comparing USER: $USER with REVIEWER: $REVIEWER" + if [[ "$USER" == "$REVIEWER" ]]; then + TIER2_APPROVED=true + break 2 + fi + done + done + + if [[ "$TIER2_APPROVED" == "true" ]]; then + echo "status=passed" >> $GITHUB_OUTPUT + else + echo "status=failed" >> $GITHUB_OUTPUT + fi + + has_approval: + needs: check_approval + if : ${{ needs.check_approval.outputs.status == 'passed' }} + runs-on: ubuntu-latest + steps: + - name: Approved + run: echo "This PR has been approved by a Tier 2 reviewer." diff --git a/.github/workflows/blossom-ci.yml b/.github/workflows/blossom-ci.yml index cc285eb356..842908155d 100644 --- a/.github/workflows/blossom-ci.yml +++ b/.github/workflows/blossom-ci.yml @@ -58,6 +58,7 @@ jobs: github.actor == 'guoqing-zhou' || github.actor == 'savitha-eng' || github.actor == 'sveccham' || + github.actor == 'nvdreidenbach' || github.actor == 'tshimko-nv') steps: - name: Check if comment is issued by authorized person diff --git a/.github/workflows/gh-docs-deploy.yml b/.github/workflows/gh-docs-deploy.yml index b9bc6f0497..240e7f1d39 100644 --- a/.github/workflows/gh-docs-deploy.yml +++ b/.github/workflows/gh-docs-deploy.yml @@ -5,6 +5,8 @@ on: branches: [main] pull_request: branches: [main] + merge_group: + types: [checks_requested] jobs: build-and-deploy: diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml deleted file mode 100644 index f95d667a30..0000000000 --- a/.github/workflows/pr-labels.yml +++ /dev/null @@ -1,48 +0,0 @@ -name: PR Label Management - -on: - pull_request: - types: [opened, edited, synchronize] - -jobs: - manage-labels: - runs-on: ubuntu-latest - permissions: - pull-requests: write - - steps: - - name: Check PR body and manage labels - uses: actions/github-script@v6 - with: - script: | - const prBody = context.payload.pull_request.body; - - const labelChecks = { - 'SKIP_CI': /\[x\]\s*\[SKIP_CI\]/i, - 'INCLUDE_NOTEBOOKS_TESTS': /\[x\]\s*\[INCLUDE_NOTEBOOKS_TESTS\]/i - }; - - const currentLabels = new Set( - context.payload.pull_request.labels.map(label => label.name) - ); - - for (const [label, pattern] of Object.entries(labelChecks)) { - const shouldHaveLabel = pattern.test(prBody); - const hasLabel = currentLabels.has(label); - - if (shouldHaveLabel && !hasLabel) { - await github.rest.issues.addLabels({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: context.payload.pull_request.number, - labels: [label] - }); - } else if (!shouldHaveLabel && hasLabel) { - await github.rest.issues.removeLabel({ - owner: context.repo.owner, - repo: context.repo.repo, - issue_number: context.payload.pull_request.number, - name: label - }); - } - } diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 7ff7533dcf..f73c236254 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -1,8 +1,9 @@ -name: "[Optional] BioNemo Image Build and Unit Tests" +name: "BioNemo Image Build and Unit Tests" on: pull_request: branches: [main] + types: [opened, synchronize, reopened, ready_for_review] push: branches: [main] merge_group: @@ -30,8 +31,15 @@ jobs: cache: "pip" - run: pip install -r requirements-dev.txt - run: ./ci/scripts/static_checks.sh + # For pull requests and merge_group events, trufflehog only runs on the diff between the base and head branches. + # For `push` events, (i.e., post-merge tests), we run trufflehog on the entire main branch by setting the base to + # ''. For some reason, the default behavior doesn't work well with the merge_group event, so we need to set these + # manually. - uses: trufflesecurity/trufflehog@main with: + path: ./ + base: ${{ github.event_name != 'push' && github.event.repository.default_branch || '' }} + head: HEAD extra_args: --only-verified build-bionemo-image: @@ -42,6 +50,9 @@ jobs: - name: Checkout repository uses: actions/checkout@v4 with: + # This working directory / path business is because our self-hosted runners are not ephemeral VMs, so we + # isolate each build into their own folder. Note that these are not currently cleaned up, so that will need to + # be automated in the future. path: ${{ github.run_id }} submodules: "recursive" @@ -61,6 +72,10 @@ jobs: type=ref,event=pr type=raw,value=${{ github.run_id }} + # This action sets up our cache-from and cache-to flags appropriately; see the README of this action for more + # info. It doesn't seem to cache correctly for merge_group events, so we need to add that as an extra argument in + # the step below. There's probably a slight optimization to be had here by caching from the pr- caches for + # merge_group events. See https://github.com/int128/docker-build-cache-config-action/issues/1005 for more info. - uses: int128/docker-build-cache-config-action@v1 id: cache with: @@ -75,7 +90,9 @@ jobs: push: true tags: ${{ steps.metadata.outputs.tags }} labels: ${{ steps.metadata.outputs.labels }} - cache-from: ${{ steps.cache.outputs.cache-from }} + cache-from: | + ${{ steps.cache.outputs.cache-from }} + ${{ github.event_name == 'merge_group' && 'nemoci.azurecr.io/bionemo/build-cache:main' || '' }} cache-to: ${{ steps.cache.outputs.cache-to }} run-tests: @@ -87,6 +104,8 @@ jobs: container: image: nemoci.azurecr.io/bionemo:${{ github.run_id }} options: --gpus all + # We mount the cache directory to avoid downloading the test data every run. Note that this only works because our + # VMs are not ephemeral, otherwise we'd need to cache the data somewhere that persists between runs. volumes: - /home/azureuser/actions-runner-bionemo/cache:/github/home/.cache steps: @@ -96,27 +115,53 @@ jobs: path: ${{ github.run_id }} - name: Run tests + # Tests in this stage generate code coverage metrics for the repository + # Coverage data is uploaded to Codecov in subsequent stages env: BIONEMO_DATA_SOURCE: ngc run: ./ci/scripts/run_pytest.sh --no-nbval --skip-slow + - name: Run slow tests + if: | + github.event_name == 'merge_group' || + (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'INCLUDE_SLOW_TESTS')) + env: + BIONEMO_DATA_SOURCE: ngc + run: pytest -v -m "slow" sub-packages/ + + - name: Run notebook tests + if: | + github.event_name == 'merge_group' || + (github.event_name == 'pull_request' && + contains(github.event.pull_request.labels.*.name, 'INCLUDE_NOTEBOOKS_TESTS')) + env: + BIONEMO_DATA_SOURCE: ngc + run: pytest -v --nbval-lax -p no:python docs/ sub-packages/ + - name: Upload coverage to Codecov + # Don't run coverage on merge queue CI to avoid duplicating reports + # to codecov. See https://github.com/matplotlib/napari-matplotlib/issues/155 + if: github.event_name != 'merge_group' uses: codecov/codecov-action@v5 with: token: ${{ secrets.CODECOV_TOKEN }} working-directory: ${{ github.run_id }} - name: Upload test results to Codecov - if: ${{ !cancelled() }} + # Don't run coverage on merge queue CI to avoid duplicating reports + # to codecov. See https://github.com/matplotlib/napari-matplotlib/issues/155 + if: ${{ !cancelled() && github.event_name != 'merge_group' }} uses: codecov/test-results-action@v1 with: token: ${{ secrets.CODECOV_TOKEN }} working-directory: ${{ github.run_id }} + # Again, because our VMs are not ephemeral, we need to clean up the image after the tests are done. Otherwise `docker + # images list` will get very cluttered and we'll run out of disk space on these runners. clean-up: needs: run-tests runs-on: self-hosted-nemo-gpus-1 - if: ${{ always() }} + if: ${{ success() || failure() }} steps: - name: clean up image run: docker rmi nemoci.azurecr.io/bionemo:${{ github.run_id }} diff --git a/.gitignore b/.gitignore index 5fe5a0ab48..9b65a94695 100644 --- a/.gitignore +++ b/.gitignore @@ -187,6 +187,7 @@ dist/ coverage.xml # Jupyter Notebook +notebooks/ .ipynb_checkpoints # System files diff --git a/.secrets-nb.baseline b/.secrets-nb.baseline index 1b65fbc998..c5c21c3f5e 100644 --- a/.secrets-nb.baseline +++ b/.secrets-nb.baseline @@ -145,9 +145,9 @@ "filename": "sub-packages/bionemo-scdl/examples/example_notebook.ipynb", "hashed_secret": "96619ff8b071d683484960c7ef1b5ab8f4d45bbc", "is_verified": false, - "line_number": 46 + "line_number": 45 } ] }, - "generated_at": "2024-11-26T01:53:13Z" + "generated_at": "2025-01-23T00:36:28Z" } diff --git a/.secrets.baseline b/.secrets.baseline index 8160e12319..d0c15aee89 100644 --- a/.secrets.baseline +++ b/.secrets.baseline @@ -139,9 +139,9 @@ "filename": "pyproject.toml", "hashed_secret": "79670e9c9d1c7ea5b81a96a2053d81437712c78e", "is_verified": false, - "line_number": 47 + "line_number": 45 } ] }, - "generated_at": "2025-01-27T19:44:23Z" + "generated_at": "2025-01-30T14:18:42Z" } diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index f8887ce621..2a9793d19e 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit f8887ce6212499ff8d882307e747948dad7c56b4 +Subproject commit 2a9793d19e3a5c0a557c899ad4b902302bbf5fdf diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 2e32fb9f6e..03d5a439d8 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 2e32fb9f6eb035a009c7fcc10368b1e4f2f26f3a +Subproject commit 03d5a439d87801b60faf8e92a016ca81029dd655 diff --git a/CODEOWNERS b/CODEOWNERS index 044d1864ad..64a0d264e8 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -31,6 +31,8 @@ # @trvachov - Timur Rvachov # @yzhang123 - Yang Zhang +# TODO: make this a team of bionemo-core contributors +* @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov @sichu2023 @skothenhill-nv @jomitchellnv @jwilber @cspades # ## LEGAL @@ -42,41 +44,23 @@ license_header @dorotat-nv @jstjohn @malcolmgreaves @trvachov # ## DOCUMENTATION # -README.md @dorotat-nv @jstjohn @malcolmgreaves @pstjohn -docs @dorotat-nv @jstjohn @malcolmgreaves @pstjohn -# These 2 are symlinks: actual content is under docs/ -CODE-REVIEW.md @jstjohn @malcolmgreaves @pstjohn @trvachov -CONTRIBUTING.md @jstjohn @malcolmgreaves @pstjohn @trvachov -docs/CODE-REVIEW.md @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov -docs/CONTRIBUTING.md @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov +**.md @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov @jwilber +docs @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov @jwilber # ## INFRASTRUCTURE # -.gitignore @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -.dockerignore @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -.devcontainer @dorotat-nv @malcolmgreaves @pstjohn -CODEOWNERS @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov +.* @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov +*.txt @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov +CODEOWNERS @jstjohn @pstjohn @trvachov Dockerfile @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -justfile @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -internal/ @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -3rdparty @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -pyproject.toml @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -requirements-cve.txt @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -requirements-dev.txt @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -requirements-test.txt @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -tach.yml @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -.secrets.baseline @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov ci/ @dorotat-nv @malcolmgreaves @pstjohn -.nspect-allowlist.toml @dorotat-nv @jstjohn @malcolmgreaves @ohadmo @pstjohn @trvachov -VERSION @dorotat-nv @jstjohn @malcolmgreaves @pstjohn @trvachov +.github @dorotat-nv @jstjohn @pstjohn @trvachov # ## LIBRARY CODE # -scripts @jstjohn @malcolmgreaves @skothenhill-nv - sub-packages/bionemo-fw @DejunL @dorotat-nv @farhadrgh @guoqing-zhou @jstjohn @malcolmgreaves @pstjohn @skothenhill-nv sub-packages/bionemo-testing @dorotat-nv @farhadrgh @jstjohn @malcolmgreaves @pstjohn @skothenhill-nv @@ -87,6 +71,8 @@ sub-packages/bionemo-llm @farhadrgh @dorotat-nv @jstjohn @malcolmgreaves @pstjoh sub-packages/bionemo-geometric @DejunL @guoqing-zhou @jstjohn @malcolmgreaves +sub-packages/bionemo-esm2 @pstjohn @jstjohn @skothenhill-nv @jomitchellnv @farhadrgh @sichu2023 + sub-packages/bionemo-example_model @jstjohn @malcolmgreaves @skothenhill-nv sub-packages/bionemo-geneformer @jstjohn @malcolmgreaves @skothenhill-nv @@ -94,3 +80,5 @@ sub-packages/bionemo-geneformer @jstjohn @malcolmgreaves @skothenhill-nv sub-packages/bionemo-scdl @jstjohn @malcolmgreaves @polinabinder1 @skothenhill-nv sub-packages/bionemo-noodles @skothenhill-nv @malcolmgreaves @jstjohn @edawson @cspades + +sub-packages/bionemo-moco @nvdreidenbach @DejunL @dorotat-nv @guoqing-zhou @jstjohn @malcolmgreaves @pstjohn @sichu2023 @zcao0420 @youhanl-nvidia diff --git a/Dockerfile b/Dockerfile index 4d0c0e08d9..34d3e00425 100644 --- a/Dockerfile +++ b/Dockerfile @@ -16,41 +16,32 @@ RUN rustup set profile minimal && \ FROM ${BASE_IMAGE} AS bionemo2-base -# Install NeMo dependencies. -WORKDIR /build - -ARG MAX_JOBS=4 -ENV MAX_JOBS=${MAX_JOBS} - -# See NeMo readme for the latest tested versions of these libraries -ARG APEX_COMMIT=810ffae374a2b9cb4b5c5e28eaeca7d7998fca0c -RUN git clone https://github.com/NVIDIA/apex.git && \ - cd apex && \ - git checkout ${APEX_COMMIT} && \ - pip install . -v --no-build-isolation --disable-pip-version-check --no-cache-dir \ - --config-settings "--build-option=--cpp_ext --cuda_ext --fast_layer_norm --distributed_adam --deprecated_fused_adam --group_norm" - -# Transformer Engine pre-1.7.0. 1.7 standardizes the meaning of bits in the attention mask to match -ARG TE_COMMIT=2215fa5c7557b66034068816020f9f611019e457 -RUN git clone https://github.com/NVIDIA/TransformerEngine.git && \ - cd TransformerEngine && \ - git fetch origin ${TE_COMMIT} && \ - git checkout FETCH_HEAD && \ - git submodule init && git submodule update && \ - NVTE_FRAMEWORK=pytorch NVTE_WITH_USERBUFFERS=1 MPI_HOME=/usr/local/mpi pip install . - # Install core apt packages. -RUN apt-get update \ - && apt-get install -y \ +RUN --mount=type=cache,id=apt-cache,target=/var/cache/apt,sharing=locked \ + --mount=type=cache,id=apt-lib,target=/var/lib/apt,sharing=locked \ + <<EOF +set -eo pipefail +apt-get update -qy +apt-get install -qyy \ libsndfile1 \ ffmpeg \ git \ curl \ pre-commit \ sudo \ - && rm -rf /var/lib/apt/lists/* + gnupg +apt-get upgrade -qyy \ + rsync +rm -rf /tmp/* /var/tmp/* +EOF -RUN apt-get install -y gnupg +# Reinstall TE to avoid debugpy bug in vscode: https://nvbugspro.nvidia.com/bug/5078830 +# Pull the latest TE version from https://github.com/NVIDIA/TransformerEngine/releases +# Use the version that matches the pytorch base container. +ARG TE_TAG=v1.13 +RUN NVTE_FRAMEWORK=pytorch NVTE_WITH_USERBUFFERS=1 MPI_HOME=/usr/local/mpi \ + pip --disable-pip-version-check --no-cache-dir install \ + git+https://github.com/NVIDIA/TransformerEngine.git@${TE_TAG} # Check the nemo dependency for causal conv1d and make sure this checkout # tag matches. If not, update the tag in the following line. @@ -72,9 +63,7 @@ RUN pip install nemo_run@git+https://github.com/NVIDIA/NeMo-Run.git@${NEMU_RUN_T RUN mkdir -p /workspace/bionemo2/ -# Delete the temporary /build directory. WORKDIR /workspace -RUN rm -rf /build # Addressing Security Scan Vulnerabilities RUN rm -rf /opt/pytorch/pytorch/third_party/onnx @@ -89,13 +78,13 @@ ENV UV_LINK_MODE=copy \ UV_COMPILE_BYTECODE=1 \ UV_PYTHON_DOWNLOADS=never \ UV_SYSTEM_PYTHON=true \ - UV_NO_CACHE=1 \ UV_BREAK_SYSTEM_PACKAGES=1 # Install the bionemo-geometric requirements ahead of copying over the rest of the repo, so that we can cache their # installation. These involve building some torch extensions, so they can take a while to install. RUN --mount=type=bind,source=./sub-packages/bionemo-geometric/requirements.txt,target=/requirements-pyg.txt \ - uv pip install --no-build-isolation -r /requirements-pyg.txt + --mount=type=cache,target=/root/.cache \ + uv pip install --no-build-isolation -r /requirements-pyg.txt COPY --from=rust-env /usr/local/cargo /usr/local/cargo COPY --from=rust-env /usr/local/rustup /usr/local/rustup @@ -103,19 +92,6 @@ COPY --from=rust-env /usr/local/rustup /usr/local/rustup ENV PATH="/usr/local/cargo/bin:/usr/local/rustup/bin:${PATH}" ENV RUSTUP_HOME="/usr/local/rustup" -RUN <<EOF -set -eo pipefail -uv pip install maturin --no-build-isolation - -pip install --use-deprecated=legacy-resolver --no-build-isolation \ - tensorstore==0.1.45 -sed -i 's/^Version: 0\.0\.0$/Version: 0.1.45/' \ - /usr/local/lib/python3.12/dist-packages/tensorstore-0.0.0.dist-info/METADATA -mv /usr/local/lib/python3.12/dist-packages/tensorstore-0.0.0.dist-info \ -/usr/local/lib/python3.12/dist-packages/tensorstore-0.1.45.dist-info -rm -rf /root/.cache/* -EOF - WORKDIR /workspace/bionemo2 # Install 3rd-party deps and bionemo submodules. @@ -124,11 +100,9 @@ COPY ./3rdparty /workspace/bionemo2/3rdparty COPY ./sub-packages /workspace/bionemo2/sub-packages # Apply patches with temporary fixes, before the modules are installed. (Use absolute path for patch filepath.) -# FIXME(dorotat) Remove when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2468 is merged. # FIXME(cspades) Remove the torch_dist checkpoint size patch when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2604 is merged. COPY ./ci/scripts/*.patch /workspace/bionemo2/ci/scripts/ RUN MEGATRON_DIR=./3rdparty/Megatron-LM && \ -patch -p1 -d $MEGATRON_DIR -i /workspace/bionemo2/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch && \ patch -p1 -d $MEGATRON_DIR -i /workspace/bionemo2/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch && \ rm ./ci/scripts/*.patch @@ -138,9 +112,11 @@ rm ./ci/scripts/*.patch RUN --mount=type=bind,source=./.git,target=./.git \ --mount=type=bind,source=./requirements-test.txt,target=/requirements-test.txt \ --mount=type=bind,source=./requirements-cve.txt,target=/requirements-cve.txt \ - <<EOF + --mount=type=cache,target=/root/.cache <<EOF set -eo pipefail +uv pip install maturin --no-build-isolation + uv pip install --no-build-isolation \ ./3rdparty/* \ ./sub-packages/bionemo-* \ @@ -203,7 +179,7 @@ ENV PATH="/usr/local/cargo/bin:/usr/local/rustup/bin:${PATH}" ENV RUSTUP_HOME="/usr/local/rustup" RUN --mount=type=bind,source=./requirements-dev.txt,target=/workspace/bionemo2/requirements-dev.txt \ - --mount=type=cache,id=uv-cache,target=/root/.cache,sharing=locked <<EOF + --mount=type=cache,target=/root/.cache <<EOF set -eo pipefail uv pip install -r /workspace/bionemo2/requirements-dev.txt rm -rf /tmp/* @@ -267,8 +243,6 @@ COPY ./docs ./docs COPY --from=rust-env /usr/local/cargo /usr/local/cargo COPY --from=rust-env /usr/local/rustup /usr/local/rustup -# Remove patches in built container. -RUN rm ./ci/scripts/*.patch # RUN rm -rf /usr/local/cargo /usr/local/rustup RUN chmod 777 -R /workspace/bionemo2/ diff --git a/LICENSE/third_party.txt b/LICENSE/third_party.txt index 48ff51c986..3b361fbda9 100644 --- a/LICENSE/third_party.txt +++ b/LICENSE/third_party.txt @@ -590,3 +590,283 @@ https://github.com/aqlaboratory/openfold/blob/main/LICENSE 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. + +Copyright MDLM Codebase +https://github.com/kuleshov-group/mdlm/blob/master/LICENSE + + 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. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + +Copyright MultiFlow Codebase +https://github.com/jasonkyuyim/multiflow/blob/main/LICENSE + +MIT License + +Copyright (c) 2024 Andrew Campbell, Jason Yim + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Copyright TorchCFM Codebase +https://github.com/atong01/conditional-flow-matching/blob/main/LICENSE + +MIT License + +Copyright (c) 2023 Alexander Tong + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Copyright Discrete Flow Models Codebase +https://github.com/andrew-cr/discrete_flow_models/blob/main/LICENSE + +MIT License + +Copyright (c) 2022 Andrej Karpathy + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index fd5729ceef..bbf0f74f1e 100644 --- a/README.md +++ b/README.md @@ -1,48 +1,40 @@ -# BioNeMo Framework (v2.0) +# BioNeMo Framework [![Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy/now?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU) [![Docs Build](https://img.shields.io/github/actions/workflow/status/NVIDIA/bionemo-framework/pages/pages-build-deployment?label=docs-build)](https://nvidia.github.io/bionemo-framework) +[![Test Status](https://github.com/NVIDIA/bionemo-framework/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/NVIDIA/bionemo-framework/actions/workflows/unit-tests.yml) [![Latest Tag](https://img.shields.io/github/v/tag/NVIDIA/bionemo-framework?label=latest-version)](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/bionemo-framework/tags) [![codecov](https://codecov.io/gh/NVIDIA/bionemo-framework/branch/main/graph/badge.svg?token=XqhegdZRqB)](https://codecov.io/gh/NVIDIA/bionemo-framework) -NVIDIA BioNeMo Framework is a collection of programming tools, libraries, and models for computational drug discovery. +NVIDIA BioNeMo Framework is a is a comprehensive suite of programming tools, libraries, and models designed for computational drug discovery. It accelerates the most time-consuming and costly stages of building and adapting biomolecular AI models by providing domain-specific, optimized models and tooling that are easily integrated into GPU-based computational resources for the fastest performance on the market. You can access BioNeMo Framework as a free community resource here in this repository or learn more at <https://www.nvidia.com/en-us/clara/bionemo/> about getting an enterprise license for improved expert-level support. -The `bionemo-framework` is partitioned into independently installable namespace packages. These are located under the +## Structure of the Framework + +The `bionemo-framework` is organized into independently installable namespace packages. These are located under the `sub-packages/` directory. Please refer to [PEP 420 – Implicit Namespace Packages](https://peps.python.org/pep-0420/) for details. -## Documentation - -Comprehensive documentation, -including user guides, API references, and troubleshooting information, can be found in our official documentation at -<https://docs.nvidia.com/bionemo-framework/latest/> -For those interested in exploring the latest developments and features not yet included in the released container, we -also maintain an up-to-date documentation set that reflects the current state of the `main` branch. This in-progress -documentation can be accessed at <https://nvidia.github.io/bionemo-framework/> +## Documentation Resources -Please note that while this documentation is generally accurate and helpful, it may contain references to features or -APIs not yet stabilized or released. As always, we appreciate feedback on our documentation and strive to continually -improve its quality. +- **Official Documentation:** For user guides, API references, and troubleshooting, visit our [official documentation](https://docs.nvidia.com/bionemo-framework/latest/). +- **In-Progress Documentation:** To explore the latest features and developments, check the documentation reflecting the current state of the `main` branch [here](https://nvidia.github.io/bionemo-framework/). Note that this may include references to features or APIs that are not yet finalized. -## Using the BioNeMo Framework +## Getting Started with BioNeMo Framework Full documentation on using the BioNeMo Framework is provided in our documentation: -<https://docs.nvidia.com/bionemo-framework/latest/user-guide/>. To facilitate the process of linking against optimized -versions of third-party dependencies, BioNeMo is primarily distributed as a containerized library. The latest released -container for the BioNeMo Framework is available for download through -[NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/bionemo-framework). Launching a pre-built -container can be accomplished through the `brev.dev` link at the top of the page, or by running +<https://docs.nvidia.com/bionemo-framework/latest/user-guide/>. To simplify the integration of optimized third-party dependencies, BioNeMo is primarily distributed as a containerized library. You can download the latest released container for the BioNeMo Framework from +[NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/clara/containers/bionemo-framework). To launch a pre-built container, you can use the brev.dev launchable [![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy/now?launchableID=env-2pPDA4sJyTuFf3KsCv5KWRbuVlU) or execute the following command: ```bash docker run --rm -it \ --gpus=all --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 \ - nvcr.io/nvidia/clara/bionemo-framework:main--nightly \ + nvcr.io/nvidia/clara/bionemo-framework:nightly \ /bin/bash ``` @@ -50,14 +42,14 @@ docker run --rm -it \ #### Initializing 3rd-party dependencies as git submodules -The NeMo and Megatron-LM dependencies are vendored in the bionemo-2 repository workspace as git submodules for -development purposes. The pinned commits for these submodules represent the "last-known-good" versions of these packages +The NeMo and Megatron-LM dependencies are included as git submodules in bionemo2. The pinned commits for these submodules represent the "last-known-good" versions of these packages that are confirmed to be working with bionemo2 (and those that are tested in CI). To initialize these sub-modules when cloning the repo, add the `--recursive` flag to the git clone command: ```bash git clone --recursive git@github.com:NVIDIA/bionemo-framework.git +cd bionemo-framework ``` To download the pinned versions of these submodules within an existing git repository, run @@ -66,10 +58,8 @@ To download the pinned versions of these submodules within an existing git repos git submodule update --init --recursive ``` -Different branches of the repo can have different pinned versions of these third-party submodules. Make sure you -update submodules after switching branches or pulling recent changes! +Different branches of the repo can have different pinned versions of these third-party submodules. Ensure submodules are automatically updated after switching branches or pulling updates by configuring git with: -To configure git to automatically update submodules when switching branches, run ```bash git config submodule.recurse true @@ -78,20 +68,20 @@ git config submodule.recurse true **NOTE**: this setting will not download **new** or remove **old** submodules with the branch's changes. You will have to run the full `git submodule update --init --recursive` command in these situations. -#### Building the bionemo-framework docker image +#### Build the Docker Image Locally -With a locally cloned bionemo-framework repository, an appropriately configured -[nvidia-container-toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) -build toolchain, and initialized submodules, the bionemo container can be built with + +With a locally cloned repository and initialized submodules, build the BioNeMo container using: ```bash docker buildx build . -t my-container-tag ``` -#### Intellisense and interactive debugging with the VSCode Devcontainer + +#### VSCode Devcontainer for Interactive Debugging We distribute a [development container](https://devcontainers.github.io/) configuration for vscode -(`.vscode/devcontainer.json`) that simplifies the process of local testing and development. Opening the +(`.devcontainer/devcontainer.json`) that simplifies the process of local testing and development. Opening the bionemo-framework folder with VSCode should prompt you to re-open the folder inside the devcontainer environment. > [!NOTE] diff --git a/ci/benchmarks/partial-conv/esm2_pretrain.yaml b/ci/benchmarks/partial-conv/esm2_pretrain.yaml index ead8763e86..1b51fe3cf3 100644 --- a/ci/benchmarks/partial-conv/esm2_pretrain.yaml +++ b/ci/benchmarks/partial-conv/esm2_pretrain.yaml @@ -48,7 +48,7 @@ script: |- --experiment-name=${batch_size}bs_${nodes}node_${gpus}gpu_${max_steps}s_${precision}prec \ --result-dir=${tensorboard_dir} \ --wandb-project=${wandb_project_name} \ - --wandb-group=${model}_${variant}_${config_name} \ - --wandb-job-type=${pipeline_label}__${target} \ + --wandb-group=${model}_${variant}_${config_name}__${target} \ + --wandb-job-type=${pipeline_label} \ --log-every-n-steps=50 \ --disable-checkpointing; diff --git a/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch b/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch deleted file mode 100644 index 21337b7b76..0000000000 --- a/ci/scripts/megatron-lm-mr2468-shard-tensor-fix.patch +++ /dev/null @@ -1,261 +0,0 @@ -diff --git a/megatron/core/dist_checkpointing/strategies/resharding.py b/megatron/core/dist_checkpointing/strategies/resharding.py -index c1c2bcec..8619084b 100644 ---- a/megatron/core/dist_checkpointing/strategies/resharding.py -+++ b/megatron/core/dist_checkpointing/strategies/resharding.py -@@ -1,3 +1,19 @@ -+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -+# SPDX-License-Identifier: LicenseRef-Apache2 -+# -+# 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. -+ -+ - # Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved. - - """ Performant resharding of flattened tensors. -@@ -27,7 +43,6 @@ from megatron.core.dist_checkpointing.dict_utils import ( - extract_matching_values, - ) - from megatron.core.dist_checkpointing.mapping import ( -- ReplicaId, - ShardedStateDict, - ShardedTensorFactory, - StateDict, -@@ -84,11 +99,7 @@ def is_nd_flattened_tensor(sh_ten: Any) -> bool: - Returns: - bool: whether the given object is a flattened ShardedTensor and is N-dimensional (N > 1) - """ -- return ( -- isinstance(sh_ten, ShardedTensor) -- and sh_ten.flattened_range is not None -- and len(sh_ten.global_shape) > 1 -- ) -+ return isinstance(sh_ten, ShardedTensor) and sh_ten.flattened_range is not None - - - # information needed to restore. With current implementation, this is a nested state dict -@@ -132,6 +143,10 @@ def apply_nd_flattened_tensors_reformulation( - try: - sh_ten_reformulation_metadata = reformulation_metadata[sh_ten.key] - except KeyError as e: -+ -+ # Handle legacy checkpointing where 1-D flatten tensor metadata was not saved -+ if len(sh_ten.global_shape) == 1: -+ return sh_ten - raise CheckpointingException( - f'Missing reformulation metadata for tensor {sh_ten}. Existing keys: {reformulation_metadata.keys()}' - ) from e -@@ -240,9 +255,12 @@ def reformulate_single_nd_flattened_tensor( - overlap_dim_offsets.append(range(first_overlap_dim_offset, next_overlap_dim_offset)) - - logger.debug( -- f'Generated the following number of overlap shards for each dimension: {list(map(len, overlap_dim_offsets))}' -- f' for fragmentation ckpt {ckpt_axis_fragmentation} vs app {sh_ten.axis_fragmentations} and chunk offset {sh_ten.local_chunk_offset_in_global()}' -+ f'Generated the following number of overlap shards for each dimension: ' -+ f'{list(map(len, overlap_dim_offsets))} for fragmentation ckpt ' -+ f'{ckpt_axis_fragmentation} vs app {sh_ten.axis_fragmentations} ' -+ f'and chunk offset {sh_ten.local_chunk_offset_in_global()}' - ) -+ - reformulated_sh_tens = {} - for chunk_offset in product(*overlap_dim_offsets): - global_offset = tuple( -diff --git a/megatron/core/dist_checkpointing/strategies/torch.py b/megatron/core/dist_checkpointing/strategies/torch.py -index ea95254a..eccc6009 100644 ---- a/megatron/core/dist_checkpointing/strategies/torch.py -+++ b/megatron/core/dist_checkpointing/strategies/torch.py -@@ -1,3 +1,19 @@ -+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -+# SPDX-License-Identifier: LicenseRef-Apache2 -+# -+# 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. -+ -+ - # Copyright (c) 2022-2023, NVIDIA CORPORATION. All rights reserved. - - """ Strategies using PyTorch distributed.checkpoint as an underlying format. """ -@@ -126,8 +142,10 @@ def flatten_state_dict( - - - def sharded_tensor_to_torch_sharded_tensor( -- sh_tens: List[ShardedTensor], rank: Optional[int] = None --) -> TorchShardedTensor: -+ sh_tens: List[ShardedTensor], -+ rank: Optional[int] = None, -+ load_legacy_1d_flatten_tensors: bool = False, -+ ) -> TorchShardedTensor: - """Convert MCore ShardedTensor to PyT ShardedTensor. PyT requires information about all chunks. - - On high-level, this function follows the logic of -@@ -163,41 +181,22 @@ def sharded_tensor_to_torch_sharded_tensor( - - some_sh_ten = sh_tens[0] - has_flattened_range = some_sh_ten.flattened_range is not None -- is_flattened_range_1d = has_flattened_range and len(some_sh_ten.global_shape) == 1 - - for sh_ten in sh_tens: - assert (sh_ten.flattened_range is not None) == has_flattened_range, sh_tens - if not sh_ten.data.is_contiguous(): - sh_ten.data = sh_ten.data.contiguous() - -+ -+ if load_legacy_1d_flatten_tensors and len(some_sh_ten.global_shape) == 1: -+ # Legacy 1-D flattened tensors are loaded as non-flat regular ShardedTensors -+ has_flattened_range = False -+ - local_global_offsets = {} - - prepend_axis_num = sh_tens[0].prepend_axis_num - # Determine local shards according to tensor type (see docs) -- if is_flattened_range_1d: -- # Type (2) case: 1D flattened ShardedTensors -- for sh_ten in sh_tens: -- assert len(sh_ten.global_offset) == 1, sh_ten -- assert sh_ten.prepend_axis_num == 0, sh_ten -- local_global_offsets.setdefault(sh_ten.global_offset, []).append(sh_ten) -- -- global_shape = some_sh_ten.global_shape -- offsets_shape = ( -- some_sh_ten.local_shape -- ) # local shape is not flattened, we need it for chunk offsets -- -- local_shards = [ -- Shard.from_tensor_and_offsets( -- sh_ten.data, -- [ -- sh_ten.global_offset[0] + sh_ten.flattened_range.start -- ], # additional flattened offset -- rank, -- ) -- for sh_ten in sh_tens -- ] -- -- elif has_flattened_range: -+ if has_flattened_range: - # Type (3) case: N-D flattened ShardedTensors - for sh_ten in sh_tens: - local_global_offsets.setdefault(sh_ten.local_chunk_offset_in_global(), []).append( -@@ -250,10 +249,7 @@ def sharded_tensor_to_torch_sharded_tensor( - # local shard - placement = f"rank:{rank}/cuda" - for sh_ten in local_global_offsets[offset]: -- if is_flattened_range_1d: -- offset = (sh_ten.global_offset[0] + sh_ten.flattened_range.start,) -- size = sh_ten.data.shape -- elif has_flattened_range: -+ if has_flattened_range: - assert offset == sh_ten.local_chunk_offset_in_global() - # This is not an actual offset, but an offset of the whole shard - # This is needed for a PyT Dist internal integrity check -@@ -270,7 +266,7 @@ def sharded_tensor_to_torch_sharded_tensor( - # Due to a bug in PyT 24.05 container we must specify some concrete rank within a world size. - # The exact rank doesn't matter as long as it's different than my rank - hence (rank + 1) % WS. - placement = f"rank:{(rank + 1) % world_size}/cuda" -- if has_flattened_range and not is_flattened_range_1d: -+ if has_flattened_range: - offset = offset + (0,) - size = (1,) * len(offsets_shape) + global_shape[-1:] - else: -@@ -296,7 +292,7 @@ def sharded_tensor_to_torch_sharded_tensor( - # This won't be stored in the checkpoint, only for runtime purposes - pyt_sh_ten.mcore_sh_ten = sh_ten.without_data() - pyt_sh_ten.mcore_metadata = {} -- if has_flattened_range and not is_flattened_range_1d: -+ if has_flattened_range: - pyt_sh_ten.mcore_metadata['nd_reformulated_orig_global_shape'] = sh_ten.global_shape - return pyt_sh_ten - -@@ -305,6 +301,7 @@ def mcore_to_pyt_state_dict( - state_dict: Dict[str, List[ShardedBase]], - is_loading: bool = False, - init_device: torch.device = torch.device("cpu"), -+ load_legacy_1d_flatten_tensors: bool = False, - ) -> Dict[str, Union[TorchShardedTensor, io.BytesIO]]: - """Convert state dict with ShardedTensors and ShardedObjects - to state dict compatible with PyT Dist format. -@@ -348,7 +345,9 @@ def mcore_to_pyt_state_dict( - if sh_ten.allow_shape_mismatch and is_loading: - sh_ten.data.zero_() - -- torch_sh_ten = sharded_tensor_to_torch_sharded_tensor(sh_tens, rank) -+ torch_sh_ten = sharded_tensor_to_torch_sharded_tensor( -+ sh_tens, rank, load_legacy_1d_flatten_tensors -+ ) - torch_sh_ten.key = sh_tens[0].key - return torch_sh_ten - -@@ -535,6 +534,12 @@ class MCoreLoadPlanner(DefaultLoadPlanner): - else: - expected_shape = nd_flattened_tensor_reformulated_global_shape(sh_ten) - if loaded_shape != expected_shape: -+ if is_nd_flattened_tensor(sh_ten) and len(sh_ten.global_shape) == 1: -+ # Handle legacy 1-D flattened tensors checkpoint format -+ # where the global shape is not stored in the metadata -+ expected_shape = sh_ten.global_shape -+ if loaded_shape == expected_shape: -+ continue - _msg = ( - f'Global shape mismatch for loaded ({loaded_shape})' - f' and expected ({expected_shape}) tensor' -@@ -736,6 +741,12 @@ def get_reformulation_metadata( - 'nd_reformulated_orig_global_shape' - ] - except KeyError as e: -+ if len(sh_ten.global_shape) == 1: -+ warnings.warn( -+ f'Legacy checkpoint format detected for 1-D flattened tensor {sh_ten}. ' -+ 'Skip metadata reformulation.' -+ ) -+ continue - raise CheckpointingException( - f'Cannot find global shape metadata for N-D flattened tensor {sh_ten} ' - f'in checkpoint metadata: {ckpt_metadata.mcore_data}' -@@ -761,9 +772,15 @@ class TorchDistLoadShardedStrategy(LoadShardedStrategy): - Returns: loaded state dict - """ - # Apply N-D tensors resharding -- sharded_state_dict, formulation_restore_data = apply_nd_flattened_tensors_reformulation( -- sharded_state_dict, get_reformulation_metadata(sharded_state_dict, checkpoint_dir) -- ) -+ reformulation_metadata = get_reformulation_metadata(sharded_state_dict, checkpoint_dir) -+ sharded_state_dict, formulation_restore_data = apply_nd_flattened_tensors_reformulation(sharded_state_dict, reformulation_metadata) -+ -+ # Check if there are legacy 1-D flattened tensors in the checkpoint -+ has_legacy_1d_flattened_tensors = False -+ for sh_ten in nested_values(sharded_state_dict): -+ if is_nd_flattened_tensor(sh_ten) and sh_ten.key not in reformulation_metadata: -+ has_legacy_1d_flattened_tensors = True -+ break - - flexible_shape_sharded_tensors = [ - sh_ten -@@ -776,7 +793,9 @@ class TorchDistLoadShardedStrategy(LoadShardedStrategy): - (sharded_state_dict, flat_mapping, rename_mapping) = ( - _replace_state_dict_keys_with_sharded_keys(sharded_state_dict) - ) -- pyt_state_dict = mcore_to_pyt_state_dict(sharded_state_dict, True) -+ pyt_state_dict = mcore_to_pyt_state_dict( -+ sharded_state_dict, True, load_legacy_1d_flatten_tensors=has_legacy_1d_flattened_tensors -+ ) - # Load PyT Distributed format - checkpoint.load_state_dict( - pyt_state_dict, diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 2f8e20993b..afe21e26be 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -79,8 +79,6 @@ uname -a # Set up pytest options PYTEST_OPTIONS=( -v - --durations=0 - --durations-min=30.0 --cov=bionemo --cov-append --cov-report=xml:coverage.xml @@ -96,8 +94,9 @@ TEST_DIRS=( ./sub-packages/bionemo-llm ./sub-packages/bionemo-testing ) + if [[ "$NO_NBVAL" != true && "$SKIP_DOCS" != true ]]; then - TEST_DIRS+=(docs/) + TEST_DIRS+=(docs/docs/user-guide/examples/bionemo-evo2/) fi echo "Test directories: ${TEST_DIRS[*]}" @@ -105,6 +104,12 @@ echo "Test directories: ${TEST_DIRS[*]}" # Run tests with coverage for dir in "${TEST_DIRS[@]}"; do echo "Running pytest in $dir" + # TODO(dorotat) - remove this change, only helpful for evo2 dev branch + if [ ! -d "$dir" ]; then + echo "Directory $dir not found, skipping..." + continue + fi + if ! pytest "${PYTEST_OPTIONS[@]}" --junitxml=$(basename $dir).junit.xml -o junit_family=legacy "$dir"; then error=true diff --git a/ci/scripts/utils.sh b/ci/scripts/utils.sh index 16ef4c8b37..33992d4bb9 100755 --- a/ci/scripts/utils.sh +++ b/ci/scripts/utils.sh @@ -20,7 +20,7 @@ check_git_repository() { if ! git diff-index --quiet HEAD --; then if [ $? -eq 128 ]; then echo "ERROR: Not in a git repository!" >&2 - return 0 + return 1 else echo "Warning: Repository is dirty! Commit all changes before building the image!" >&2 return 0 diff --git a/docs/docs/assets/images/esm2/esm2_device_scaling.png b/docs/docs/assets/images/esm2/esm2_device_scaling.png new file mode 100644 index 0000000000000000000000000000000000000000..1b12998c76ebfdac734e0d59f7ef620fa2456438 GIT binary patch literal 43993 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 G`u_kkI3`yB literal 0 HcmV?d00001 diff --git a/docs/docs/assets/images/esm2/esm2_model_scaling.png b/docs/docs/assets/images/esm2/esm2_model_scaling.png new file mode 100644 index 0000000000000000000000000000000000000000..93435b555a4b6f0116af96569bf6ce7a0994007c GIT binary patch literal 175636 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 XU-Ig%(v$__Co`wb(T|;C>-GNt2`!W* literal 0 HcmV?d00001 diff --git a/docs/docs/assets/images/esm2/esm2_model_scaling.svg b/docs/docs/assets/images/esm2/esm2_model_scaling.svg index b738b6c9eb..1348c169a7 100644 --- a/docs/docs/assets/images/esm2/esm2_model_scaling.svg +++ b/docs/docs/assets/images/esm2/esm2_model_scaling.svg @@ -6,7 +6,7 @@ <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <cc:Work> <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/> - <dc:date>2024-10-15T15:49:38.659090</dc:date> + <dc:date>2025-01-14T10:06:49.710062</dc:date> <dc:format>image/svg+xml</dc:format> <dc:creator> <cc:Agent> @@ -327,7 +327,7 @@ z <g id="line2d_1"> <path d="M 77.04 168.60375 L 255.926667 168.60375 -" clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_4"> <!-- 0 --> @@ -340,7 +340,7 @@ L 255.926667 168.60375 <g id="line2d_2"> <path d="M 77.04 140.589171 L 255.926667 140.589171 -" clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_5"> <!-- 20,000 --> @@ -397,7 +397,7 @@ z <g id="line2d_3"> <path d="M 77.04 112.574592 L 255.926667 112.574592 -" clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_6"> <!-- 40,000 --> @@ -436,7 +436,7 @@ z <g id="line2d_4"> <path d="M 77.04 84.560013 L 255.926667 84.560013 -" clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_7"> <!-- 60,000 --> @@ -489,7 +489,7 @@ z <g id="line2d_5"> <path d="M 77.04 56.545434 L 255.926667 56.545434 -" clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_8"> <!-- 80,000 --> @@ -549,7 +549,7 @@ z <g id="line2d_6"> <path d="M 77.04 28.530854 L 255.926667 28.530854 -" clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_9"> <!-- 100,000 --> @@ -766,7 +766,7 @@ L 121.761667 168.60375 L 121.761667 134.379739 L 85.984333 134.379739 z -" clip-path="url(#p132d84a9c7)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p32fb9bcc18)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_4"> <path d="M 175.427667 168.60375 @@ -774,7 +774,7 @@ L 211.205 168.60375 L 211.205 104.216442 L 175.427667 104.216442 z -" clip-path="url(#p132d84a9c7)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p32fb9bcc18)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_5"> <path d="M 121.761667 168.60375 @@ -782,7 +782,7 @@ L 157.539 168.60375 L 157.539 108.838848 L 121.761667 108.838848 z -" clip-path="url(#p132d84a9c7)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p32fb9bcc18)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_6"> <path d="M 211.205 168.60375 @@ -790,19 +790,19 @@ L 246.982333 168.60375 L 246.982333 34.314464 L 211.205 34.314464 z -" clip-path="url(#p132d84a9c7)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p32fb9bcc18)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="line2d_7"> - <path clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_8"> - <path clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_9"> - <path clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_10"> - <path clip-path="url(#p132d84a9c7)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p32fb9bcc18)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="patch_7"> <path d="M 67.04 168.60375 @@ -815,8 +815,8 @@ L 255.926667 178.60375 " style="fill: none; stroke: #ffffff; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square"/> </g> <g id="text_11"> - <!-- Model = ESM2-650M --> - <g style="fill: #262626" transform="translate(109.960521 21.6) scale(0.12 -0.12)"> + <!-- Model = ESM-2 650M --> + <g style="fill: #262626" transform="translate(108.293646 21.6) scale(0.12 -0.12)"> <defs> <path id="ArialMT-4d" d="M 475 0 L 475 4581 @@ -943,12 +943,13 @@ z <use xlink:href="#ArialMT-45" x="386.328125"/> <use xlink:href="#ArialMT-53" x="453.027344"/> <use xlink:href="#ArialMT-4d" x="519.726562"/> - <use xlink:href="#ArialMT-32" x="603.027344"/> - <use xlink:href="#ArialMT-2d" x="658.642578"/> - <use xlink:href="#ArialMT-36" x="691.943359"/> - <use xlink:href="#ArialMT-35" x="747.558594"/> - <use xlink:href="#ArialMT-30" x="803.173828"/> - <use xlink:href="#ArialMT-4d" x="858.789062"/> + <use xlink:href="#ArialMT-2d" x="603.027344"/> + <use xlink:href="#ArialMT-32" x="636.328125"/> + <use xlink:href="#ArialMT-20" x="691.943359"/> + <use xlink:href="#ArialMT-36" x="719.726562"/> + <use xlink:href="#ArialMT-35" x="775.341797"/> + <use xlink:href="#ArialMT-30" x="830.957031"/> + <use xlink:href="#ArialMT-4d" x="886.572266"/> </g> </g> </g> @@ -1001,7 +1002,7 @@ z <g id="line2d_11"> <path d="M 312.046667 168.60375 L 490.933333 168.60375 -" clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_15"> <!-- 0 --> @@ -1014,7 +1015,7 @@ L 490.933333 168.60375 <g id="line2d_12"> <path d="M 312.046667 143.550714 L 490.933333 143.550714 -" clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_16"> <!-- 5,000 --> @@ -1031,7 +1032,7 @@ L 490.933333 143.550714 <g id="line2d_13"> <path d="M 312.046667 118.497677 L 490.933333 118.497677 -" clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_17"> <!-- 10,000 --> @@ -1049,7 +1050,7 @@ L 490.933333 118.497677 <g id="line2d_14"> <path d="M 312.046667 93.444641 L 490.933333 93.444641 -" clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_18"> <!-- 15,000 --> @@ -1067,7 +1068,7 @@ L 490.933333 93.444641 <g id="line2d_15"> <path d="M 312.046667 68.391604 L 490.933333 68.391604 -" clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_19"> <!-- 20,000 --> @@ -1085,7 +1086,7 @@ L 490.933333 68.391604 <g id="line2d_16"> <path d="M 312.046667 43.338568 L 490.933333 43.338568 -" clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_20"> <!-- 25,000 --> @@ -1106,7 +1107,7 @@ L 356.768333 168.60375 L 356.768333 137.512932 L 320.991 137.512932 z -" clip-path="url(#pd2c222d47b)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_11"> <path d="M 410.434333 168.60375 @@ -1114,7 +1115,7 @@ L 446.211667 168.60375 L 446.211667 104.182372 L 410.434333 104.182372 z -" clip-path="url(#pd2c222d47b)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_12"> <path d="M 356.768333 168.60375 @@ -1122,7 +1123,7 @@ L 392.545667 168.60375 L 392.545667 113.48707 L 356.768333 113.48707 z -" clip-path="url(#pd2c222d47b)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_13"> <path d="M 446.211667 168.60375 @@ -1130,19 +1131,19 @@ L 481.989 168.60375 L 481.989 34.314464 L 446.211667 34.314464 z -" clip-path="url(#pd2c222d47b)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#p88ccfd3dd6)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="line2d_17"> - <path clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_18"> - <path clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_19"> - <path clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_20"> - <path clip-path="url(#pd2c222d47b)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#p88ccfd3dd6)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="patch_14"> <path d="M 302.046667 168.60375 @@ -1155,8 +1156,8 @@ L 490.933333 178.60375 " style="fill: none; stroke: #ffffff; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square"/> </g> <g id="text_21"> - <!-- Model = ESM2-3B --> - <g style="fill: #262626" transform="translate(352.635937 21.6) scale(0.12 -0.12)"> + <!-- Model = ESM-2 3B --> + <g style="fill: #262626" transform="translate(350.969062 21.6) scale(0.12 -0.12)"> <defs> <path id="ArialMT-33" d="M 269 1209 L 831 1284 @@ -1243,10 +1244,11 @@ z <use xlink:href="#ArialMT-45" x="386.328125"/> <use xlink:href="#ArialMT-53" x="453.027344"/> <use xlink:href="#ArialMT-4d" x="519.726562"/> - <use xlink:href="#ArialMT-32" x="603.027344"/> - <use xlink:href="#ArialMT-2d" x="658.642578"/> - <use xlink:href="#ArialMT-33" x="691.943359"/> - <use xlink:href="#ArialMT-42" x="747.558594"/> + <use xlink:href="#ArialMT-2d" x="603.027344"/> + <use xlink:href="#ArialMT-32" x="636.328125"/> + <use xlink:href="#ArialMT-20" x="691.943359"/> + <use xlink:href="#ArialMT-33" x="719.726562"/> + <use xlink:href="#ArialMT-42" x="775.341797"/> </g> </g> </g> @@ -1299,7 +1301,7 @@ z <g id="line2d_21"> <path d="M 547.053333 168.60375 L 725.94 168.60375 -" clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> +" clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_25"> <!-- 0 --> @@ -1310,29 +1312,31 @@ L 725.94 168.60375 </g> <g id="ytick_14"> <g id="line2d_22"> - <path d="M 547.053333 144.776694 -L 725.94 144.776694 -" clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> + <path d="M 547.053333 136.31491 +L 725.94 136.31491 +" clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_26"> - <!-- 500 --> - <g style="fill: #262626" transform="translate(509.20224 148.713491) scale(0.11 -0.11)"> - <use xlink:href="#ArialMT-35"/> - <use xlink:href="#ArialMT-30" x="55.615234"/> - <use xlink:href="#ArialMT-30" x="111.230469"/> + <!-- 1,000 --> + <g style="fill: #262626" transform="translate(500.029271 140.251707) scale(0.11 -0.11)"> + <use xlink:href="#ArialMT-31"/> + <use xlink:href="#ArialMT-2c" x="55.615234"/> + <use xlink:href="#ArialMT-30" x="83.398438"/> + <use xlink:href="#ArialMT-30" x="139.013672"/> + <use xlink:href="#ArialMT-30" x="194.628906"/> </g> </g> </g> <g id="ytick_15"> <g id="line2d_23"> - <path d="M 547.053333 120.949639 -L 725.94 120.949639 -" clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> + <path d="M 547.053333 104.02607 +L 725.94 104.02607 +" clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_27"> - <!-- 1,000 --> - <g style="fill: #262626" transform="translate(500.029271 124.886436) scale(0.11 -0.11)"> - <use xlink:href="#ArialMT-31"/> + <!-- 2,000 --> + <g style="fill: #262626" transform="translate(500.029271 107.962867) scale(0.11 -0.11)"> + <use xlink:href="#ArialMT-32"/> <use xlink:href="#ArialMT-2c" x="55.615234"/> <use xlink:href="#ArialMT-30" x="83.398438"/> <use xlink:href="#ArialMT-30" x="139.013672"/> @@ -1342,16 +1346,16 @@ L 725.94 120.949639 </g> <g id="ytick_16"> <g id="line2d_24"> - <path d="M 547.053333 97.122583 -L 725.94 97.122583 -" clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> + <path d="M 547.053333 71.73723 +L 725.94 71.73723 +" clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_28"> - <!-- 1,500 --> - <g style="fill: #262626" transform="translate(500.029271 101.05938) scale(0.11 -0.11)"> - <use xlink:href="#ArialMT-31"/> + <!-- 3,000 --> + <g style="fill: #262626" transform="translate(500.029271 75.674027) scale(0.11 -0.11)"> + <use xlink:href="#ArialMT-33"/> <use xlink:href="#ArialMT-2c" x="55.615234"/> - <use xlink:href="#ArialMT-35" x="83.398438"/> + <use xlink:href="#ArialMT-30" x="83.398438"/> <use xlink:href="#ArialMT-30" x="139.013672"/> <use xlink:href="#ArialMT-30" x="194.628906"/> </g> @@ -1359,14 +1363,14 @@ L 725.94 97.122583 </g> <g id="ytick_17"> <g id="line2d_25"> - <path d="M 547.053333 73.295527 -L 725.94 73.295527 -" clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> + <path d="M 547.053333 39.44839 +L 725.94 39.44839 +" clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> </g> <g id="text_29"> - <!-- 2,000 --> - <g style="fill: #262626" transform="translate(500.029271 77.232324) scale(0.11 -0.11)"> - <use xlink:href="#ArialMT-32"/> + <!-- 4,000 --> + <g style="fill: #262626" transform="translate(500.029271 43.385187) scale(0.11 -0.11)"> + <use xlink:href="#ArialMT-34"/> <use xlink:href="#ArialMT-2c" x="55.615234"/> <use xlink:href="#ArialMT-30" x="83.398438"/> <use xlink:href="#ArialMT-30" x="139.013672"/> @@ -1374,47 +1378,30 @@ L 725.94 73.295527 </g> </g> </g> - <g id="ytick_18"> - <g id="line2d_26"> - <path d="M 547.053333 49.468472 -L 725.94 49.468472 -" clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #ffffff; stroke-linecap: round"/> - </g> - <g id="text_30"> - <!-- 2,500 --> - <g style="fill: #262626" transform="translate(500.029271 53.405269) scale(0.11 -0.11)"> - <use xlink:href="#ArialMT-32"/> - <use xlink:href="#ArialMT-2c" x="55.615234"/> - <use xlink:href="#ArialMT-35" x="83.398438"/> - <use xlink:href="#ArialMT-30" x="139.013672"/> - <use xlink:href="#ArialMT-30" x="194.628906"/> - </g> - </g> - </g> </g> <g id="patch_17"> <path d="M 555.997667 168.60375 L 591.775 168.60375 -L 591.775 113.944484 -L 555.997667 113.944484 +L 591.775 131.56845 +L 555.997667 131.56845 z -" clip-path="url(#p58ee4650d4)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#pdf08924c2d)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_18"> <path d="M 645.441 168.60375 L 681.218333 168.60375 -L 681.218333 52.470681 -L 645.441 52.470681 +L 681.218333 89.915847 +L 645.441 89.915847 z -" clip-path="url(#p58ee4650d4)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#pdf08924c2d)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_19"> <path d="M 591.775 168.60375 L 627.552333 168.60375 -L 627.552333 108.083029 -L 591.775 108.083029 +L 627.552333 105.9634 +L 591.775 105.9634 z -" clip-path="url(#p58ee4650d4)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#pdf08924c2d)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_20"> <path d="M 681.218333 168.60375 @@ -1422,7 +1409,7 @@ L 716.995667 168.60375 L 716.995667 34.314464 L 681.218333 34.314464 z -" clip-path="url(#p58ee4650d4)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#pdf08924c2d)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_21"> <path d="M 591.775 168.60375 @@ -1430,7 +1417,7 @@ L 591.775 168.60375 L 591.775 168.60375 L 591.775 168.60375 z -" clip-path="url(#p58ee4650d4)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#pdf08924c2d)" style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> <g id="patch_22"> <path d="M 591.775 168.60375 @@ -1438,19 +1425,19 @@ L 591.775 168.60375 L 591.775 168.60375 L 591.775 168.60375 z -" clip-path="url(#p58ee4650d4)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> +" clip-path="url(#pdf08924c2d)" style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> + </g> + <g id="line2d_26"> + <path clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_27"> - <path clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_28"> - <path clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="line2d_29"> - <path clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> - </g> - <g id="line2d_30"> - <path clip-path="url(#p58ee4650d4)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> + <path clip-path="url(#pdf08924c2d)" style="fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round"/> </g> <g id="patch_23"> <path d="M 537.053333 168.60375 @@ -1462,9 +1449,41 @@ L 537.053333 27.6 L 725.94 178.60375 " style="fill: none; stroke: #ffffff; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square"/> </g> + <g id="text_30"> + <!-- * --> + <g style="fill: #262626" transform="translate(606.980367 107.577842) scale(0.12 -0.12)"> + <defs> + <path id="ArialMT-2a" d="M 200 3741 +L 344 4184 +Q 841 4009 1066 3881 +Q 1006 4447 1003 4659 +L 1456 4659 +Q 1447 4350 1384 3884 +Q 1706 4047 2122 4184 +L 2266 3741 +Q 1869 3609 1488 3566 +Q 1678 3400 2025 2975 +L 1650 2709 +Q 1469 2956 1222 3381 +Q 991 2941 816 2709 +L 447 2975 +Q 809 3422 966 3566 +Q 563 3644 200 3741 +z +" transform="scale(0.015625)"/> + </defs> + <use xlink:href="#ArialMT-2a"/> + </g> + </g> <g id="text_31"> - <!-- Model = ESM2-15B --> - <g style="fill: #262626" transform="translate(584.306042 21.6) scale(0.12 -0.12)"> + <!-- * --> + <g style="fill: #262626" transform="translate(696.4237 35.928906) scale(0.12 -0.12)"> + <use xlink:href="#ArialMT-2a"/> + </g> + </g> + <g id="text_32"> + <!-- Model = ESM-2 15B --> + <g style="fill: #262626" transform="translate(582.639167 21.6) scale(0.12 -0.12)"> <use xlink:href="#ArialMT-4d"/> <use xlink:href="#ArialMT-6f" x="83.300781"/> <use xlink:href="#ArialMT-64" x="138.916016"/> @@ -1476,16 +1495,17 @@ L 725.94 178.60375 <use xlink:href="#ArialMT-45" x="386.328125"/> <use xlink:href="#ArialMT-53" x="453.027344"/> <use xlink:href="#ArialMT-4d" x="519.726562"/> - <use xlink:href="#ArialMT-32" x="603.027344"/> - <use xlink:href="#ArialMT-2d" x="658.642578"/> - <use xlink:href="#ArialMT-31" x="691.943359"/> - <use xlink:href="#ArialMT-35" x="747.558594"/> - <use xlink:href="#ArialMT-42" x="803.173828"/> + <use xlink:href="#ArialMT-2d" x="603.027344"/> + <use xlink:href="#ArialMT-32" x="636.328125"/> + <use xlink:href="#ArialMT-20" x="691.943359"/> + <use xlink:href="#ArialMT-31" x="719.726562"/> + <use xlink:href="#ArialMT-35" x="775.341797"/> + <use xlink:href="#ArialMT-42" x="830.957031"/> </g> </g> </g> <g id="legend_1"> - <g id="text_32"> + <g id="text_33"> <!-- Library --> <g style="fill: #262626" transform="translate(106.529688 40.089375) scale(0.12 -0.12)"> <defs> @@ -1613,39 +1633,17 @@ L 83.79 48.288594 z " style="fill: #808080; stroke: #ffffff; stroke-linejoin: miter"/> </g> - <g id="text_33"> - <!-- GitHub --> + <g id="text_34"> + <!-- Baseline --> <g style="fill: #262626" transform="translate(114.59 55.988594) scale(0.11 -0.11)"> - <defs> - <path id="ArialMT-75" d="M 2597 0 -L 2597 488 -Q 2209 -75 1544 -75 -Q 1250 -75 995 37 -Q 741 150 617 320 -Q 494 491 444 738 -Q 409 903 409 1263 -L 409 3319 -L 972 3319 -L 972 1478 -Q 972 1038 1006 884 -Q 1059 663 1231 536 -Q 1403 409 1656 409 -Q 1909 409 2131 539 -Q 2353 669 2445 892 -Q 2538 1116 2538 1541 -L 2538 3319 -L 3100 3319 -L 3100 0 -L 2597 0 -z -" transform="scale(0.015625)"/> - </defs> - <use xlink:href="#ArialMT-47"/> - <use xlink:href="#ArialMT-69" x="77.783203"/> - <use xlink:href="#ArialMT-74" x="100"/> - <use xlink:href="#ArialMT-48" x="127.783203"/> - <use xlink:href="#ArialMT-75" x="200"/> - <use xlink:href="#ArialMT-62" x="255.615234"/> + <use xlink:href="#ArialMT-42"/> + <use xlink:href="#ArialMT-61" x="66.699219"/> + <use xlink:href="#ArialMT-73" x="122.314453"/> + <use xlink:href="#ArialMT-65" x="172.314453"/> + <use xlink:href="#ArialMT-6c" x="227.929688"/> + <use xlink:href="#ArialMT-69" x="250.146484"/> + <use xlink:href="#ArialMT-6e" x="272.363281"/> + <use xlink:href="#ArialMT-65" x="327.978516"/> </g> </g> <g id="patch_26"> @@ -1656,7 +1654,7 @@ L 83.79 63.848437 z " style="fill: #70a217; stroke: #ffffff; stroke-linejoin: miter"/> </g> - <g id="text_34"> + <g id="text_35"> <!-- BioNeMo2 --> <g style="fill: #262626" transform="translate(114.59 71.548437) scale(0.11 -0.11)"> <defs> @@ -1687,13 +1685,13 @@ z </g> </g> <defs> - <clipPath id="p132d84a9c7"> + <clipPath id="p32fb9bcc18"> <rect x="77.04" y="27.6" width="178.886667" height="141.00375"/> </clipPath> - <clipPath id="pd2c222d47b"> + <clipPath id="p88ccfd3dd6"> <rect x="312.046667" y="27.6" width="178.886667" height="141.00375"/> </clipPath> - <clipPath id="p58ee4650d4"> + <clipPath id="pdf08924c2d"> <rect x="547.053333" y="27.6" width="178.886667" height="141.00375"/> </clipPath> </defs> diff --git a/docs/docs/assets/images/esm2/esm2_pretrain_convergence.png b/docs/docs/assets/images/esm2/esm2_pretrain_convergence.png new file mode 100644 index 0000000000000000000000000000000000000000..aac352a80cb2ef51a213e372cdbc53113d235672 GIT binary patch literal 28627 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 literal 0 HcmV?d00001 diff --git a/docs/docs/assets/images/esm2/esm2_single_node_training_perf.png b/docs/docs/assets/images/esm2/esm2_single_node_training_perf.png new file mode 100644 index 0000000000000000000000000000000000000000..4096986a50e24cde96ace73723baea33356cc794 GIT binary patch literal 32841 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 literal 0 HcmV?d00001 diff --git a/docs/docs/assets/images/sub_package_graphs/dependency_file_imports.png b/docs/docs/assets/images/sub_package_graphs/dependency_file_imports.png new file mode 100644 index 0000000000000000000000000000000000000000..27db22499d7cde7bdcdc2289d2d6681c0848b4cf GIT binary patch literal 99404 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�l3rs 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 OZ)bbzXz3CB)&Bqm-ul4+ literal 0 HcmV?d00001 diff --git a/docs/docs/assets/images/sub_package_graphs/dependency_graph_pyproject.png b/docs/docs/assets/images/sub_package_graphs/dependency_graph_pyproject.png new file mode 100644 index 0000000000000000000000000000000000000000..e3f24065bcddd14b842e56841ac3610e8d223943 GIT binary patch literal 205322 zcmeFZg<Dl!_ceS72}wnyTS7oUq(cypkdj6k0Y$n&8Yz_$5eey#l2S@qP(VULN?MRk zX~}nPyzl4z#rOROFBe{V3Fqv+*P3h2F~=D5JiDtRM{u6<JPL&(P>`2VN1@JnpimeK zI9TvM=5?=C;4fj9+qy0q_77a#O`R-I%BC(3Huf$ykM7gESvWaAvbVdzCCqh$lit$B z#lcyGo7?t3zrbbh^pLwnBO7@WTnG7k&L|X-De?y`S0d*T3Jrx)kh!Jlk+d@IuKP-7 z1Z%@<fd=!I%-#Gl3a@p7bD1p{MOj*G5`T<e(T^ElX))jHm^*xFBk(5PJm%fi`$OcS zPwV!Y?#AYCPb_yPtw#xl-#<q~{-DZlXf~U0y>`8sCrNm#(>aBSL<)!a!oOe9pRV`1 zqh$W`wQU(c#mxBc7w=uAjf?;O>IDim7LR97|NX+hL{j^om&sr~$2I!*Rg8=nUog4< z^RnoG`%mKjebv)8$?KmK|MNQYwEuTGWNH52VxEOdbO7)7ztLFTpF5bQP#B<xlY1`h z0y+yXg_4DTo)VU`28nL`<_$YWvld5xSh(toXEE7k!k^2>W^XBV&xfRaiAqg-D9E#X zE`9F<FMq&?a^a+RoIPFb)GDv%O8Cs)hqe(rQqwasW)!Kg1Q8z)K7sei<>!;4FRrE) z<XFDzsee%pYf6oUuX3_j_{YqwNkod9Hc#|dmrMK?7B9A<L7Zp2K8xE7m131_*$0oW z^>tYHrVWZYG0vMNc3VHPLN{im@(}&eIMP{0QzRo}`{nFr7bgCBl>$z{bhT_&>;PkN zb-m$5VIn4sp6}nz`;Oc6jE|u6YHwX|WsAf>P6<)#*-3I0xm`|Bm1G>S#Nt|`wOFpb zwX@o(e7$G<LXp60&+w4k<tZUa`1O8~vjeM^lip`ZY^)i)y{YFD>SXMzB7oys9-4qF zXvSzoM2(Gv+(^jTiCwz%+=|M9p_tm0J)&OvF`M-b68y!*&+IoDX=eVurQ6wCMjKH` zl}{X(JdctW6e2_th`7kv(#zYoFTZgR$?2!h-&t!N>BMC65^nz5ZZMfnOmXG!Lqvt1 zU8*na<%n!j8&|L_PMuxKc9l6w$(%R*w@XM^L~wmG125a(8>6K=ODz3AH?5Z(S#t0x znG%EJ+x(;Jl6sq89}7Lx3!Fj0<)iIN)Goo_uDMSVv68+C6lD>jEHNF}Yc8GRCpaJs z&i(%P{<B2?E=lOsBHPc4N$P<{&yVTR8{uEC`URFmFJ-8N{quf*6BA8FZ9OjQ2gQh@ z`|B!{XmG!`AN$1AOEWCF{C)04+Q0X=rb$VlGA~bc)%6@D11!KL_6S*cXjjUA)))Jq zUz-lgznjxXzWQ=S6c^>nPH^#g{x;2dwVY39F_G)TbCwTR^K&cE7H7*32&K9E+O5?z zJGx#!6(V#v3)J1_vnVL1ij@t-dprxjQ_S@%*7=!$>mzFHv%69|{F`J)l($~46oo66 z<rT~bHJ)8zgzWE)a8+-@EjYr9w5YM|ex7aaYVhBk5oW;Tn%7wn4Of|U@;w){z&@&Y z!I8R(>}>z~Y5ykaWR4<h8P^!SNmCd00cER8L;Opk_!)%Fj#GALkDM$1_fbURw6*aP z>H`<d%~5?FRhr4wgpnBTe|KXw;O_<VL}Do)59~}a{(6n+KepuApQqa^-x4*`Soim6 z?lzu1@uDUit{9O$272+EGA)rajmKv{W;8TAD=99rOqhKMRUT;&=ayApFH&5O#2{)t zduo?we=n3!yX482%YQ(asbPKB`i0JT+B(nE5rWo$(7!iS{rT^OI=k9M?DDsXc~OEK z_r~R0!e$zq|GC!Rm34VrR`kqAkWLE4R%qYnPA;<=^1ps1<5u=9@i>dhJ9T%OnODqT z2@#gjp5==^(!XbgwVg^gV({|py9p+y&yH!fXL}dTb+&HiS+#X_3^89ztOoKAX_;ca z(#L$=7<Zo(-`#0ndNb_)A=bPqcKFX)&3c(cXlJJqs&R9+1Ad>!v<b8Bi@ZzCU?l6B zo3_x=%-cx3cQO0h5koxOZ5V!r0;*o4we&=tc$<yshhnsqQD>PYs#$3g4bE}&2|nFT zYSh%y(!uaNd$GOwWS90u6eQ6d8mwp)0{GcL1iO$>&4TEqz`p_IauzfhTq~UkH$+5r z9?@|0jy#DXqj+=U;Wra|D>Sc-3bemZeXhb1@+_~Dva+(r@y^iC>1lL1Ik|TRA1@LR z5TMq^GZ=2(q;;PE7919a$H~b#wY(fAIO$E|>gqaT#-bFDN>B>PN%f_)Z#Wk4++BHg zE)e7Q*LA;V)k{{Zj+7BtHGcb8#a&5HZy$SaY?qjL?=Ru8wbiGK&-FyTDN{^Py}jPF zJ{M%_=x2O%{3kn??b@xCIad$UCKIt6Vwa5TwpcWkD=#t<?6~Ug{XX=tSYqSU-2QZ< zS$gAyqnnX~c`-ezV^uMKuki3Pw=!i&b|Cu3M3`#kyWEm5rJ)tJpV#MAnx{|db$NS; z{Pe`|<_Tphh2G}Z;u|*{vKYnlkmLQTE4}X`;k|iioWUko^Tp9?=!C30iYn;iv3H5b z*Nd8(nqqv~C`(Jr#!>r*2!DT+uC8ulR~G??_B%;O$I{*Sqa$xl!|F@oUb{ir+00|( z<JTYcU0E5gsni;x_lysXU{%Ges<c#an9<`sS=Z_Qnea1RH+La0E+<^FUv51;{bbN% zbI4)~34_y<nc~vllXO!bOEHke3Zzukn=vZwiuN+o^ALLe{Q1Vtka2TI2Obv}m+nU= z=ETJKBLIRK+83d$n7=yMUSvYy=<Dml9x{4+dt+v4eVT?>kV)aJo;Dos>N5lpKYRA9 z>DxCI6tSC|8>5hrZkstTnq*LL@S|>V-y;t+$@n*K@Vvadey;i~k2xD3l@Gs8;;3Mr zfBq;ewRd8Tl$dQLxf&PM^mRb_oiGI}@)MnjLtU@%;MmxO+2!K8w>ifCJU0Z%Xea7N z%!~|n8b-GEsQ9%}#JmYg+nYON+5#2m{w42ANmEzE^TpSU{8&1T=utQ~oSjWgA2ECG zesql}y)kDQrGK<US61o1x4@iaFkW_gx^wEoj$DmE=lkt-e|osl!~|T`)B2{SzB?%5 zZ+2_<yRK#<H#@O^B)aNDlVli_6Bk!fUOq7KIyxF2d^+J_R;%sN{_l}iZ&;|lKg!Ct z8+?z00s{k4^ion%GPbsb#8OX%o#!n5+yb!(E*cpbNwLH{tDN+$VM=i_|2)E*QoA|P zdSBnEXy3fM_i{r_iZ9y8<myRg%Ok&5snE#&6E3~c5nRFU2`tf+AVQkFy47#3Gq+05 zVPoStJ3IGQ+8eK4H}?ILo#MBI>=&CZQdG=;iHV85h>i}}-ge<MswGF2c<wBDX-C$d zo*d>D6@?@x(_ADWiH?td>UXl0it-;G)}_AbUG?R+wzjtXojXmlpReo(?_!|Xx|2|- zOXib}ClL}Tl<&?7>;6zt^ZxXda8=cw%wsi%UD?8q%LiLVo}{M}UifAYJJC?)Ifktq z>ptPCnX2?28$2k<qmMBX#`9OERcNqLoPK7cCv|(|@Q3Z4jg6YIe&FiqpLbeOQL=?C z5(2AD53jTGh;e3o*}H43A7*>{M-XM=p^I5B<Z#)TRxHfl7XuANb+Xfd@+YbBYl>L@ zit?X4S(ey0-@9<seUNH$|NfJ{ChwKQKVIX%C%e&5Yjt(MAFoh+W;Sl_NtdRhoaxP! zE7z(DC8TK@DA0*cO2W6cw!Xr`a{u^X2j#y!RE&YDKiX6@sP(uYXg4OQqC$B2nqGf? z>yrgj*eaXTr5pW2gN^Mims3}SpQ!Fqf7uk&Mne^)h+xeo#9WIMtStG=>J@c==R^ax zt86g2l$n|NC!F!yckY~T38%n7xkpsOHp%Rr)%ED;H`mRuR#sQhB;PDp+t_?Aw;oy( z***HRh4L>oYi)u<i7GMwdU17#+n}mvdS4-iC0(c3h?tiIq8=Nid5H`S)i+%%h4W~% zTy@febnA&2v9J(|`OjmNzqJncgzGT_NizynR9CxJT^Rb14kh`g`x-91!ZPZS%FC)M zFM5xsWsU|`O<Jf%o%Pyhf|tMboCud#7=~Hzu2EsGr`<*Q=NM0>7Blz|32JEc=o%BD z$i<Hp;^X5R$C@rOy;Z?RU7CH6nNfzB_q(s0v#{{G_w!d*b_rIoiRdJ*4hB`FcC(7l zVYGyYmKR<#x&Qp5^Zdk)(AeVGN9Pg0C^`vR-UNJFTH28cimtj>55FbhqCDmj9!{;V zM^W5(K+n#89)3tvhoxp+W+A3<{KuWoqs_r({RduS;iMKy{_u}`S%UXx%c|`KToRII z8dbezqf-9UlY@f;bkzCt=V=$mV5$3e9AfwZxqF(cs6YoELCkYK_AP0bLj33-%+RLJ zruScLi)d5aX&#z!Fh?pWE8CAhU>(Owz?U#iQ@;Kn$EbOyAg=6`PUwMDSn=qHsMV>@ zp{wYVw-J+gD5#%DMWc|N(NL#b5~qO>Tudx1SigV&7IIr5-(C3;$RrnO(w!n6MZ>M; zRekK<d$%=auv*84kdRO!l;u#ktRjjCxkdgn1Zw^Zd5Qa^4;kdq;o8SHP>oGZ=st(L zb<4x)(xHr3ui~~w(aE{F35bb{mv@|^nY6uN*sBduaDM+wpg#Q=U;}+nV~{Z3^_fLu z)Qgvw709|j&CRnn%FVLUr5*469v{6vlQ6ILGBqp<?;#rMB>fl-wO%y7+cvbZNfZ<u zOG>%C?C7+v5}qW0VWma#?eiK2J##E|vf&i>dK5W|z|~dA%Y-gO^_irn6t&ZhzARlo zBfGWPNiw+5&-Sloxy6OSJuc0=tD|(3t*f@w6W&|OVt;<cpir@Qf-$fO>DkzDP!5~F z6vAQaRmFZ|qD*F5B6Mp#u1C^{?zTmt^{&Dx+wZ`p7hM&3$(3|l!I#TmOx(eHuW-I* zvb!O(&=h|L7ofkImni}R+uCM-{c3D&#fJ5iS5?JE)gEnjIJmgfE)NS%cwk7J>@(#T z6kMRD#^>hdzQU?lXVKi$#N#;q*~_STd+ms8tnR?1{V4nCICZf7<RQoI(FOsMl#<>= zj4ZJud3l2n|M9PN#q0O^4k9SSsx(@Ej~^Bg*9f17BQ}zf>TGm0%amG^5F0@-SGR9% zv;XVVLBNgMD210g|1HZaGE#KZ<%V53RAW5FhtlPmVuu+|-kYAQx3{-<Z~yF~>apZ= zaC4TE`E?%E_>PpDVR2gc*Fy^vi(wq0;o-EBjh`JQtV;3zkG{WUfT;TLuv^x|gdQR^ zIyN>qF_987Hu=QFgvU&Tpu@@0V~@v=KlS!rP*6}n`THIpi0_)+!Ys2DOW11Sc4Tqm zUb42{SYDjzt;@l7>eE0&9m_=o-v7LyZ9GKYLV`55yG^tRts}cOpksX7-26&=d%KCf zeH59o_l5O_(-ZM10z$%;#qT-SAAX|-xH5IHvpn+oCv4oB7r}Qg%?<QMyn>0=5BBwe z6Fz}z+PePJV>VU0n@ydw+)_7f`px|8?Y&QE=IZyYs~+#l8fjxGb#?N%Z1UAsnzD-d zV9*{Op*H$EicM!vy)h?=&#^1sxvQ`BtPw5nck6&PkME!u%0D=pbi%NP;HP3rfQGxy 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ℜ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 U{%*M?13&B5Zq|9AWq$Ji0n}JmIsgCw literal 0 HcmV?d00001 diff --git a/docs/docs/assets/images/sub_package_graphs/dependency_graph_tach.png b/docs/docs/assets/images/sub_package_graphs/dependency_graph_tach.png new file mode 100644 index 0000000000000000000000000000000000000000..315b45675a605418ba36dca04061e0b2955466af GIT binary patch literal 167062 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ð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 BBY*$^ literal 0 HcmV?d00001 diff --git a/docs/docs/models/ESM-2/index.md b/docs/docs/models/ESM-2/index.md index 0ef474a35b..660b00111f 100644 --- a/docs/docs/models/ESM-2/index.md +++ b/docs/docs/models/ESM-2/index.md @@ -121,9 +121,7 @@ checkpoints is consistent with their outputs when evaluated with the HuggingFace #### Single-node Training Performance -<figure markdown="span"> - ![ESM-2 Single-Device Training Performance](../assets/images/esm2/esm2_single_node_training_perf.svg){ width="350" } -</figure> +![ESM-2 Single-Device Training Performance](../../assets/images/esm2/esm2_single_node_training_perf.png) The pure-pytorch baseline (compiled with `torch.compile()`) raised an out-of-memory error for batch sizes larger than 16 at the ESM2-650M model size. The `bionemo2` model could handle batch sizes of 46, reaching a model flops utilization of @@ -131,19 +129,15 @@ at the ESM2-650M model size. The `bionemo2` model could handle batch sizes of 46 #### Model Scaling -<figure markdown="span"> - ![ESM-2 Model Scaling](../assets/images/esm2/esm2_model_scaling.svg) -</figure> +![ESM-2 Model Scaling](../../assets/images/esm2/esm2_model_scaling.png) Training ESM-2 at the 650M, 3B, and 15B model variants show improved performance with the BioNeMo2 framework over the pure-pytorch baseline. These experiments were conducted on 16x NVIDIA A100 or 16x NVIDIA H100 GPUs split across two -nodes. +nodes. <sup>*</sup>*Note:* 15B model variants were trained on 64 GPUs with the BioNeMo2 framework. #### Device Scaling -<figure markdown="span"> - ![ESM-2 Device Scaling](../assets/images/esm2/esm2_device_scaling.svg){ width="400" } -</figure> +![ESM-2 Device Scaling](../../assets/images/esm2/esm2_device_scaling.png) Training ESM-3B on 256 NVIDIA A100s on 32 nodes achieved 96.85% of the theoretical linear throughput expected from extrapolating single-node (8 GPU) performance, representing a model flops utilization of 60.6% at 256 devices. diff --git a/docs/docs/models/ESM-2/pre-training.md b/docs/docs/models/ESM-2/pre-training.md index 37701b4a87..0f1232ff4e 100644 --- a/docs/docs/models/ESM-2/pre-training.md +++ b/docs/docs/models/ESM-2/pre-training.md @@ -9,9 +9,7 @@ and train/test splits are available. Validation perplexity evaluated on the NVIDIA validation set. -<figure markdown="span"> - ![ESM-2 Pre-training Convergence](../assets/images/esm2/esm2_pretrain_convergence.svg){ width="350" } -</figure> +![ESM-2 Pre-training Convergence](../../assets/images/esm2/esm2_pretrain_convergence.png) | Model Size | Perplexity at 500k updates | | -------------- | ------ | @@ -24,7 +22,7 @@ Validation perplexity evaluated on the NVIDIA validation set. === "8M" ```python - esm2_8m_ckpt_path = load("esm2/nv_8m:2.0") + esm2_8m_ckpt_path = load("esm2/8m:2.0") ``` ### Training Script diff --git a/docs/docs/models/index.md b/docs/docs/models/index.md index b625464de0..4f9822c701 100644 --- a/docs/docs/models/index.md +++ b/docs/docs/models/index.md @@ -4,7 +4,7 @@ State-of-the-art models are continually integrated into the BioNeMo Framework. T | **Model** | **Modality** | **Uses** | | ------------------------------------------ | ------------------ | --------------------------------------------- | -| [ESM-2](./esm2.md) | Protein | Representation Learning | +| [ESM-2](./ESM-2/index.md) | Protein | Representation Learning | | [Geneformer](./geneformer.md) | Single Cell | Representation Learning | For more information about the models included in BioNeMo Framework, refer to the Model Cards linked in the table above or the original publications referenced in the respective model descriptions. diff --git a/docs/docs/user-guide/appendix/releasenotes-fw.md b/docs/docs/user-guide/appendix/releasenotes-fw.md index 0079c4b8de..0e376a70c0 100644 --- a/docs/docs/user-guide/appendix/releasenotes-fw.md +++ b/docs/docs/user-guide/appendix/releasenotes-fw.md @@ -1,5 +1,18 @@ # Release Notes +## BioNeMo Framework v2.3 + +### New Features + +* Distributed Inference Support for ESM2 and Geneformer + * Enables linear inference throughput as GPU number is increased + * [See ESM2 inference notebook](https://github.com/NVIDIA/bionemo-framework/blob/release-v2.3/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb) and use `--num-gpus` parameter. + +### Updates & Improvements + +* Prior Geneformer inference on H100 accuracy regression fixed. +* Base image updated to `nvcr.io/nvidia/pytorch:24.12-py3`; python updated to 3.12 among other core dependency upgrades ([base container release notes here](https://docs.nvidia.com/deeplearning/frameworks/pytorch-release-notes/rel-24-12.html#rel-24-12)). + ## BioNeMo Framework v2.2 ### New Features diff --git a/docs/docs/user-guide/contributing/contributing.md b/docs/docs/user-guide/contributing/contributing.md index db384c2982..28507e39a9 100644 --- a/docs/docs/user-guide/contributing/contributing.md +++ b/docs/docs/user-guide/contributing/contributing.md @@ -126,6 +126,12 @@ Key behaviors: - Use when modifying notebooks or notebook-related code - Disabled by default +#### **INCLUDE_SLOW_TESTS** + +- Enables unit tests labelled as slow ie CLI tests +- Use when modifying core functionalities and require extensive, end-2-end, testing +- Disabled by default + ### Developer workflows You should always carefully test your changes. Run `pytest ...` in your container locally. All tests are done via `pytest`. diff --git a/docs/docs/user-guide/contributing/sub-package_dependency_graph.md b/docs/docs/user-guide/contributing/sub-package_dependency_graph.md new file mode 100644 index 0000000000..1a022a80c3 --- /dev/null +++ b/docs/docs/user-guide/contributing/sub-package_dependency_graph.md @@ -0,0 +1,17 @@ +## Sub-Package Dependency Graph + +The script in `sub-packages/bionemo/fw/src/dependency_graph.py` generates a dependency graph for the BioNeMo sub-packages and verifies that the pyproject.toml and tach.toml files align and capture the dependencies needed for imports in the python files. Additionally, it checks dependencies between BioNeMo sub-packages and creates visual representations of the dependencies in pyproject.toml files, in tach.toml, and in the source files. + +These are visualizations of the dependency graph from the pyproject.toml files: + +<img src="../../assets/images/sub_package_graphs/dependency_graph_pyproject.png" alt="Dependency Graph" width="600"> + + +Similarly from the tach.toml file: + +<img src="../../assets/images/sub_package_graphs/dependency_graph_tach.png" alt="Dependency Graph" width="600"> + + +And these are the dependencies from the file imports: + +<img src="../../assets/images/sub_package_graphs/dependency_file_imports.png" alt="Dependency Graph" width="600"> diff --git a/docs/docs/user-guide/examples/bionemo-esm2/finetune.ipynb b/docs/docs/user-guide/examples/bionemo-esm2/finetune.ipynb new file mode 100644 index 0000000000..7c3682d009 --- /dev/null +++ b/docs/docs/user-guide/examples/bionemo-esm2/finetune.ipynb @@ -0,0 +1,1017 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy?launchableID=env-2rPWpPzzJIxq7SMRJIQehCxBymV)\n", + "\n", + "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits. </div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ESM-2 Fine-tuning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "The [ESM-2](https://www.science.org/doi/abs/10.1126/science.ade2574) model is a transformer-based protein language model that has achieved state-of-the-art results in various protein-related tasks. When fine-tuning ESM2, the task-head plays a crucial role. A task head refers to the additional layer or set of layers added on top of a pre-trained model, like the ESM-2 transformer-based protein language model, to adapt it for a specific downstream task. As a part of transfer learning, a pre-trained model is often utilized to learn generic features from a large-scale dataset. However, these features might not be directly applicable to the specific task at hand. By incorporating a task head, which consists of learnable parameters, the model can adapt and specialize to the target task. The task head serves as a flexible and adaptable component that learns task-specific representations by leveraging the pre-trained features as a foundation. Through fine-tuning, the task head enables the model to learn and extract task-specific patterns, improving performance and addressing the nuances of the downstream task. It acts as a critical bridge between the pre-trained model and the specific task, enabling efficient and effective transfer of knowledge." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> We divided the fine-tuning use cases to *sequence-level* and *token-level* tasks where a target value is expected per each protein sequence and each token respectively. The first part of this tutorial will guide you through the steps for creating a sequence-level regression fine-tuning task for simplicity. The techniques demonstrated here can be adapted for sequence-level classification and token-level tasks.\n", + "\n", + "The utilities described in this tutorial are available in:\n", + "\n", + "<pre>bionemo.esm2.model.finetune</pre> \n", + "\n", + "In the second part of the tutorial, we will cover loading a pre-trained model, fine-tuning it sequence-level regression/classification and token-level classification, and using the fine-tuned models for inference. For instructions on pre-training the ESM-2 model, please refer to the [ESM-2 Pretraining](./pretrain.md) tutorial.</div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building a Regression Fine-tune Module" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to define some key classes to successfully build a fine-tuning module in BioNeMo framework: \n", + "\n", + "1. **Loss Reduction Class** - To compute the supervised fine-tuning loss.\n", + "2. **Fine-Tuned Model Head** - Downstream task head model.\n", + "3. **Fine-Tuned Model** - Model that combines ESM-2 with the task head model.\n", + "4. **Fine-Tuning Config** - Configures the fine-tuning model and loss to use in the training and inference framework.\n", + "5. **Dataset** - Training and inference datasets for ESM2 fine-tuning." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1 - Loss Reduction Class" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A class for calculating the supervised loss of the fine-tune model from targets. We inherit from Megatron Bert Masked Language Model Loss (`BERTMLMLossWithReduction`) and override the `forward()` pass to compute MSE loss of the regression head within a micro-batch. The `reduce()` method is used for computing the average over the micro-batches and is only used for logging.\n", + "\n", + "```python\n", + "class RegressorLossReduction(BERTMLMLossWithReduction):\n", + " def forward(\n", + " self, batch: Dict[str, torch.Tensor], forward_out: Dict[str, torch.Tensor]\n", + " ) -> Tuple[torch.Tensor, Union[PerTokenLossDict, SameSizeLossDict]]:\n", + "\n", + " regression_output = forward_out[\"regression_output\"]\n", + " targets = batch[\"labels\"].to(dtype=regression_output.dtype) # [b, 1]\n", + "\n", + " loss = torch.nn.functional.mse_loss(regression_output, targets)\n", + " return loss, {\"avg\": loss}\n", + "\n", + " def reduce(self, losses_reduced_per_micro_batch: Sequence[ReductionT]) -> torch.Tensor:\n", + " losses = torch.stack([loss[\"avg\"] for loss in losses_reduced_per_micro_batch])\n", + " return losses.mean()\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2 - Fine-Tuned Model Head" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An MLP class for sequence-level regression. This class inherits `MegatronModule` and uses the fine-tune config (`TransformerConfig`) to configure the regression head for the fine-tuned ESM-2 model.\n", + "\n", + "```python\n", + "class MegatronMLPHead(MegatronModule):\n", + " def __init__(self, config: TransformerConfig):\n", + " super().__init__(config)\n", + " layer_sizes = [config.hidden_size, 256, 1]\n", + " self.linear_layers = torch.nn.ModuleList(\n", + " [torch.nn.Linear(i, o) for i, o in zip(layer_sizes[:-1], layer_sizes[1:])]\n", + " )\n", + " self.act = torch.nn.ReLU()\n", + " self.dropout = torch.nn.Dropout(p=config.ft_dropout)\n", + "\n", + " def forward(self, hidden_states: torch.Tensor) -> List[torch.Tensor]:\n", + " ...\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3 - Fine-Tuned Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A fine-tuned ESM-2 model class for token classification tasks. This class inherits from the `ESM2Model` class and adds the custom regression head `MegatronMLPHead` the we created in the previous step. Optionally one can freeze all or parts of the encoder by parsing through the model parameters in the model constructor.\n", + "\n", + "```python\n", + "class ESM2FineTuneSeqModel(ESM2Model):\n", + " def __init__(self, config, *args, post_process: bool = True, include_embeddings: bool = False, **kwargs):\n", + " super().__init__(config, *args, post_process=post_process, include_embeddings=True, **kwargs)\n", + "\n", + " # freeze encoder parameters\n", + " if config.encoder_frozen:\n", + " for _, param in self.named_parameters():\n", + " param.requires_grad = False\n", + "\n", + " if post_process:\n", + " self.regression_head = MegatronMLPHead(config)\n", + "\n", + " def forward(self, *args, **kwargs,):\n", + " output = super().forward(*args, **kwargs)\n", + " ...\n", + " output[\"regression_output\"] = self.regression_head(embeddings)\n", + " return output\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4 - Fine-Tuning Config" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A `dataclass` that configures the fine-tuned ESM-2 model. In this example `ESM2FineTuneSeqConfig` inherits from `ESM2GenericConfig` and adds custom arguments to setup the fine-tuned model. The `configure_model()` method of this `dataclass` is called within the `Lightning` module to call the model constructor with the `dataclass` arguments.\n", + "\n", + "The common arguments among different fine-tuning tasks are\n", + "\n", + "- `model_cls`: The fine-tune model class defined in previous step (`ESM2FineTuneSeqModel`)\n", + "- `initial_ckpt_path`: BioNeMo 2.0 ESM-2 pre-trained checkpoint\n", + "- `initial_ckpt_skip_keys_with_these_prefixes`: skips keys when loading parameters from a checkpoint. For example, we should not look for `regression_head` in the pre-trained checkpoint.\n", + "- `get_loss_reduction_class()`: Implements selection of the appropriate `MegatronLossReduction` class that we defined in the first step of this tutorial.\n", + "\n", + "```python\n", + "\n", + "@dataclass\n", + "class ESM2FineTuneSeqConfig(\n", + " ESM2GenericConfig[ESM2FineTuneSeqModel, RegressorLossReduction], iom.IOMixinWithGettersSetters\n", + "):\n", + " model_cls: Type[ESM2FineTuneSeqModel] = ESM2FineTuneSeqModel\n", + " # The following checkpoint path is for nemo2 checkpoints. Config parameters not present in\n", + " # self.override_parent_fields will be loaded from the checkpoint and override those values here.\n", + " initial_ckpt_path: str | None = None\n", + " # typical case is fine-tune the base biobert that doesn't have this head. If you are instead loading a checkpoint\n", + " # that has this new head and want to keep using these weights, please drop this next line or set to []\n", + " initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=lambda: [\"regression_head\"])\n", + "\n", + " encoder_frozen: bool = True # freeze encoder parameters\n", + " ft_dropout: float = 0.25 # MLP layer dropout\n", + "\n", + " def get_loss_reduction_class(self) -> Type[MegatronLossReduction]:\n", + " return RegressorLossReduction\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5 - Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "We will use a sample dataset for demonstration purposes. Create a dataset class by extending ```bionemo.esm2.model.finetune.dataset.InMemoryProteinDataset```. The `InMemoryProteinDataset` has a `classmethod` (`from_csv`) that reads data from a CSV file that has `sequences` and optionally `labels` columns. It is important to override the `transform_label()` method that returns a `torch.Tensor` containing the label in correct format. As an example we can use this method to add custom tokenization if `label` is a string." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "The custom dataset class will be appropriate (found in ```bionemo.esm2.model.finetune.dataset.InMemorySingleValueDataset```) as it facilitates predicting on a single value. An excerpt from the class is shown below. This example dataset has a class method `from_csv()` that expects a `data_path` to a CSV file that has `sequences`, and `labels` columns.\n", + "\n", + "```python\n", + "class InMemorySingleValueDataset(InMemoryProteinDataset):\n", + " def __init__(\n", + " self,\n", + " labels: pd.Series,\n", + " task_type: str = \"regression\",\n", + " tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(),\n", + " seed: int = np.random.SeedSequence().entropy,\n", + " ):\n", + " super().__init__(sequences, labels, task_type, tokenizer, seed)\n", + "\n", + " def transform_label(self, label: float) -> Tensor:\n", + " return torch.tensor([label], dtype=torch.float)\n", + "```\n", + "\n", + "The `transform_label` method allows for custom transformation of raw labels by casting or tokenization and need to be adjusted based on the data. Here we use this method to create a `float` tensor of the regression value." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### DataModule" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To coordinate the creation of training, validation and testing datasets from your data, we need to use a `datamodule` class. To do this we can directly use or extend the ```ESM2FineTuneDataModule``` class (located at ```bionemo.esm2.model.finetune.datamodule.ESM2FineTuneDataModule```) which defines helpful abstract methods that use your dataset class.\n", + "\n", + "```python\n", + "dataset = InMemorySingleValueDataset.from_csv(data_path)\n", + "data_module = ESM2FineTuneDataModule(\n", + " train_dataset=dataset,\n", + " valid_dataset=dataset\n", + " micro_batch_size=4, # size of a batch to be processed in a device\n", + " global_batch_size=8, # size of batch across all devices. Should be multiple of micro_batch_size\n", + ")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next part of this tutorial we will prepare the input needed to run sequence-level regression/classification and token-level classification fine-tuning examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Assumptions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All commands should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. For more information on how to build or pull the BioNeMo2 container, refer to the [Initialization Guide](../../getting-started/initialization-guide.md)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> Some of the cells below generate long text output. We're using <pre>%%capture --no-display --no-stderr cell_output</pre> to suppress this output. Comment or delete this line in the cells below to restore full output.</div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "import os\n", + "import shutil\n", + "import pandas as pd\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "warnings.simplefilter('ignore')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Work Directory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the work directory to store data and results:\n", + "\n", + "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> We set the following to clean up the work directory created by this notebook <pre>cleanup : bool = True</pre></div>" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "cleanup : bool = True" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Directory '/workspace/bionemo2/esm2_finetune_tutorial' created.\n" + ] + } + ], + "source": [ + "work_dir=\"/workspace/bionemo2/esm2_finetune_tutorial\"\n", + "\n", + "if cleanup and os.path.exists(work_dir):\n", + " shutil.rmtree(work_dir)\n", + "\n", + "if not os.path.exists(work_dir):\n", + " os.makedirs(work_dir)\n", + " print(f\"Directory '{work_dir}' created.\")\n", + "else:\n", + " print(f\"Directory '{work_dir}' already exists.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Download Pre-trained Model Checkpoints" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following code will download the internally pre-trained model, `esm2/8m:2.0`, from the NGC registry. Please refer to [ESM-2 Model Overview](../../../models/ESM-2/index.md) for a list of available checkpoints." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/ubuntu/.cache/bionemo/2957b2c36d5978d0f595d6f1b72104b312621cf0329209086537b613c1c96d16-esm2_hf_converted_8m_checkpoint.tar.gz.untar\n" + ] + } + ], + "source": [ + "from bionemo.core.data.load import load\n", + "\n", + "pretrain_checkpoint_path = load(\"esm2/8m:2.0\")\n", + "print(pretrain_checkpoint_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above example is downloading an internally trained 8M ESM-2 model. The pre-trained checkpoints can be downloaded from NGC resources using either the following bash command or the `load` function in `bionemo.core.data.load` as shown above.\n", + "\n", + "```bash\n", + "download_bionemo_data esm2/650m:2.0\n", + "```\n", + "\n", + "which returns the checkpoint path (e.g. `.../.cache/bionemo/975d29ee980fcb08c97401bbdfdcf8ce-esm2_650M_nemo2.tar.gz.untar`)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fine-tuning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can take advantage of the ESM2 fine-tuning script in ```bionemo.esm2.scripts.finetune_esm2``` or use the ```finetune_esm2``` executable the fine-tuning process given:\n", + "\n", + "- Pre-trained checkpoint of ESM2\n", + "- Finetune config class name that configures the finetune model and loss reduction\n", + "- Path to train and validation CSV data files\n", + "- Dataset class name\n", + "\n", + "To get the full list of arguments to tune a finetuning run use:\n", + "```bash\n", + "finetune_esm2 --help \n", + "```\n", + "\n", + "For a detailed description of training loop and the arguments please refer to the [ESM-2 Pretraining](./pretrain.md) tutorial.\n", + "\n", + "#### Scaled LR for fine-tune head parameters \n", + "We can assign a different LR for specific layers (e.g. task head) during fine-tuning by making it possible to specify the name of the target layer as well as the LR multiplier.\n", + "\n", + "- `--lr-multiplier`: is a float that scales `--lr`\n", + "- `--sclae-lr-layer`: is the name of the layers for which we scale the LR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<div class=\"alert alert-block alert-info\"> <b>NOTE</b>\n", + "\n", + "Due to Megatron limitations, the log produced by the training run iterates on steps/iterations and not epochs. Therefore, `Training epoch` counter stays at value zero while `iteration` and `global_step` increase during the course of training (example in the following).\n", + "\n", + "<pre>\n", + "Training epoch 0, iteration <x/max_steps> | ... | global_step: <x> | reduced_train_loss: ... | val_loss: ...\n", + "</pre>\n", + "\n", + "to achieve the same epoch-based effect while training, please choose the number of training steps (`num_steps`) so that:\n", + "\n", + "<pre>\n", + "num_steps * global_batch_size = len(dataset) * desired_num_epochs\n", + "</pre></div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sequence-level Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the purposes of this demo, we'll assume dataset consists of small set of protein sequences with a target value of `len(sequence) / 100.0` as their labels." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "artificial_sequence_data = [\n", + " \"TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI\",\n", + " \"LYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"GRFNVWLGGNESKIRQVLKAVKEIGVSPTLFAVYEKN\",\n", + " \"DELTALGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"KLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI\",\n", + " \"LFGAIGNAISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP\",\n", + " \"LGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"LYSGDHSTQGARFLRDLAENTGRAEYELLSLF\",\n", + " \"ISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP\",\n", + " \"SGSKASSDSQDANQCCTSCEDNAPATSYCVECSEPLCETCVEAHQRVKYTKDHTVRSTGPAKT\",\n", + "]\n", + "\n", + "data = [(seq, len(seq)/100.0) for seq in artificial_sequence_data]\n", + "\n", + "# Create a DataFrame\n", + "df = pd.DataFrame(data, columns=[\"sequences\", \"labels\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"regression_data.csv\")\n", + "df.to_csv(data_path, index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use the sequence-level fine-tune model config `ESM2FineTuneSeqConfig` and single-value dataset `InMemorySingleValueDataset` and set the task-type to `regression`. In addition to model and dataset configuration we can define the MLP task head and specify the number of hidden parameters (`mlp-hidden-size`), output layer size (`mlp-target-size`) and dropout (`mlp-ft-dropout`) in the following CLI call.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "! finetune_esm2 \\\n", + " --restore-from-checkpoint-path {pretrain_checkpoint_path} \\\n", + " --train-data-path {data_path} \\\n", + " --valid-data-path {data_path} \\\n", + " --config-class ESM2FineTuneSeqConfig \\\n", + " --dataset-class InMemorySingleValueDataset \\\n", + " --task-type \"regression\" \\\n", + " --mlp-ft-dropout 0.25 \\\n", + " --mlp-hidden-size 256 \\\n", + " --mlp-target-size 1 \\\n", + " --experiment-name \"sequence-level-regression\" \\\n", + " --num-steps 50 \\\n", + " --num-gpus 1 \\\n", + " --val-check-interval 10 \\\n", + " --log-every-n-steps 10 \\\n", + " --encoder-frozen \\\n", + " --lr 5e-3 \\\n", + " --lr-multiplier 1e2 \\\n", + " --scale-lr-layer \"regression_head\" \\\n", + " --result-dir {work_dir} \\\n", + " --micro-batch-size 2 \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The previous cell executes the finetuning and saves the checkpoints at the end of the run. The checkpoint path is logged at the end of the finetuning log file: \n", + "\n", + "```\n", + "[NeMo I $$$$-$$-$$ 22:04:28 nemo_logging:393] Async checkpoint save for step 50 (/workspace/bionemo2/esm2_finetune_tutorial/sequence-level-regression/dev/checkpoints/checkpoint-step=49-consumed_samples=100.0-last-v1.ckpt) finalized successfully.\n", + "```\n", + "\n", + "To avoid long text output from the previous cell, the log is captured and stored into the `cell_output` variable. To visualize the log file uncomment and execute the next cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# print(cell_output.stdout)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now use the checkpoint stored in the previous step to run inference. We will drop the `.ckpt` from the checkpoint path and provide that to the `--checkpoint-path` argument of `infer_esm2` executable.\n", + "\n", + "The input `--data-path` for inference is a CSV file with `sequences` column. It is also required to provide the appropriate `--config-class` name to load the model from the checkpoint. For a detailed description of inference arguments please refer to the [ESM-2 Inference](./inference.ipynb) tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a DataFrame\n", + "df = pd.DataFrame(artificial_sequence_data, columns=[\"sequences\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"sequences.csv\")\n", + "df.to_csv(data_path, index=False)\n", + "\n", + "checkpoint_path = f\"{work_dir}/sequence-level-regression/dev/checkpoints/checkpoint-step=49-consumed_samples=100.0-last\"\n", + "results_path = f\"{work_dir}/sequence-level-regression/infer/\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", + " --config-class ESM2FineTuneSeqConfig \\\n", + " --data-path {data_path} \\\n", + " --results-path {results_path} \\\n", + " --micro-batch-size 3 \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\" \\\n", + " --include-embeddings \\\n", + " --include-input-ids" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The inference results are written into a `.pt` file which can be loaded using PyTorch library:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input_ids\ttorch.Size([10, 1024])\n", + "embeddings\ttorch.Size([10, 320])\n", + "regression_output\ttorch.Size([10, 1])\n" + ] + } + ], + "source": [ + "import torch\n", + "results = torch.load(f\"{results_path}/predictions__rank_0.pt\")\n", + "\n", + "for key, val in results.items():\n", + " if val is not None:\n", + " print(f'{key}\\t{val.shape}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sequence-level Classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly for a sequence-level classification task we can create a dataset by labeling our sequences with arbitrary class names and take advantage of `Label2IDTokenizer` in the `transform_label()` method of `InMemorySingleValueDataset`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class_labels = [\n", + " \"E_class\",\n", + " \"C_class\",\n", + " \"H_class\",\n", + " \"H_class\",\n", + " \"C_class\",\n", + " \"H_class\",\n", + " \"H_class\",\n", + " \"C_class\",\n", + " \"H_class\",\n", + " \"C_class\",\n", + "]\n", + "\n", + "data = [(seq, label) for seq, label in zip(artificial_sequence_data, class_labels)]\n", + "\n", + "# Create a DataFrame\n", + "df = pd.DataFrame(data, columns=[\"sequences\", \"labels\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"classification_data.csv\")\n", + "df.to_csv(data_path, index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since this task is also a sequence-level fine-tuning, we will use `ESM2FineTuneSeqConfig` and single-value dataset `InMemorySingleValueDataset` but set the task-type to `classification`. For this classification task the MLP output layer size (`mlp-target-size`) should be set to number of classes in the dataset (3 in this example)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "! finetune_esm2 \\\n", + " --restore-from-checkpoint-path {pretrain_checkpoint_path} \\\n", + " --train-data-path {data_path} \\\n", + " --valid-data-path {data_path} \\\n", + " --config-class ESM2FineTuneSeqConfig \\\n", + " --dataset-class InMemorySingleValueDataset \\\n", + " --task-type \"classification\" \\\n", + " --mlp-ft-dropout 0.25 \\\n", + " --mlp-hidden-size 256 \\\n", + " --mlp-target-size 3 \\\n", + " --experiment-name \"sequence-level-classification\" \\\n", + " --num-steps 50 \\\n", + " --num-gpus 1 \\\n", + " --val-check-interval 10 \\\n", + " --log-every-n-steps 10 \\\n", + " --encoder-frozen \\\n", + " --lr 5e-3 \\\n", + " --lr-multiplier 1e2 \\\n", + " --scale-lr-layer \"classification_head\" \\\n", + " --result-dir {work_dir} \\\n", + " --micro-batch-size 2 \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Toke-level Classification data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this task we assign secondary structure label to each token in the sequence:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "secondary_structure_labels = [\n", + " \"EEEECCCCCHHHHHHHHHHHHHHHCCCEEEEEECCCHHHHHHHHHCCCCCCCCCEEE\",\n", + " \"CCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\",\n", + " \"HHHHHCCCCCHHHHHHHHHHHHHHCCCHHHHHHHHHH\",\n", + " \"HHHHHHHHHHCCCHHHHHCCCCCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\",\n", + " \"CHHHHHHHHHHHHHHHCCCEEEEEECCCHHHHHHHHHCCCCCCCCCEEE\",\n", + " \"HHHHHHHHHHHHHCHHHHHHHHHHHHCCCEECCCEEEECCEEEEECC\",\n", + " \"HHHHHCCCHHHHHCCCCCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\",\n", + " \"CCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\",\n", + " \"HHHHHCHHHHHHHHHHHHCCCEECCCEEEECCEEEEECC\",\n", + " \"CCCCCCCCCCCCCCCCCCCCCCCCCCEEECCCCEEECHHHHHHHHHCCCCCCCCEEECCCCCC\",\n", + "]\n", + "\n", + "data = [(seq, label) for (seq, label) in zip(artificial_sequence_data, secondary_structure_labels)]\n", + "\n", + "# Create a DataFrame\n", + "df = pd.DataFrame(data, columns=[\"sequences\", \"labels\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"token_classification_data.csv\")\n", + "df.to_csv(data_path, index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "! finetune_esm2 \\\n", + " --restore-from-checkpoint-path {pretrain_checkpoint_path} \\\n", + " --train-data-path {data_path} \\\n", + " --valid-data-path {data_path} \\\n", + " --config-class ESM2FineTuneTokenConfig \\\n", + " --dataset-class InMemoryPerTokenValueDataset \\\n", + " --task-type \"classification\" \\\n", + " --cnn-dropout 0.25 \\\n", + " --cnn-hidden-size 32 \\\n", + " --cnn-num-classes 3 \\\n", + " --experiment-name \"token-level-classification\" \\\n", + " --num-steps 50 \\\n", + " --num-gpus 1 \\\n", + " --val-check-interval 10 \\\n", + " --log-every-n-steps 10 \\\n", + " --encoder-frozen \\\n", + " --lr 5e-3 \\\n", + " --lr-multiplier 1e2 \\\n", + " --scale-lr-layer \"classification_head\" \\\n", + " --result-dir {work_dir} \\\n", + " --micro-batch-size 2 \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The previous cell executes the finetuning and saves the checkpoints at the end of the run. The checkpoint path is logged at the end of the finetuning log file: \n", + "\n", + "```\n", + "[NeMo I $$$$-$$-$$ 22:16:46 nemo_logging:393] Async checkpoint save for step 50 (/workspace/bionemo2/esm2_finetune_tutorial/token-level-classification/dev/checkpoints/checkpoint-step=49-consumed_samples=100.0-last.ckpt) finalized successfully.\n", + "```\n", + "\n", + "To avoid long text output from the previous cell, the log is captured and stored into the `cell_output` variable. To visualize the log file uncomment and execute the next cell:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# print(cell_output.stdout)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now use the checkpoint stored in the previous step to run inference. We will drop the `.ckpt` from the checkpoint path and provide that to the `--checkpoint-path` argument of `infer_esm2` executable.\n", + "\n", + "The input `--data-path` for inference is a CSV file with `sequences` column. It is also required to provide the appropriate `--config-class` name to load the model from the checkpoint. For a detailed description of inference arguments please refer to the [ESM-2 Inference](./inference.ipynb) tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a DataFrame\n", + "df = pd.DataFrame(artificial_sequence_data, columns=[\"sequences\"])\n", + "\n", + "# Save the DataFrame to a CSV file\n", + "data_path = os.path.join(work_dir, \"sequences.csv\")\n", + "df.to_csv(data_path, index=False)\n", + "\n", + "checkpoint_path = f\"{work_dir}/token-level-classification/dev/checkpoints/checkpoint-step=49-consumed_samples=100.0-last\"\n", + "results_path = f\"{work_dir}/token-level-classification/infer/\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-display --no-stderr cell_output\n", + "\n", + "! infer_esm2 --checkpoint-path {checkpoint_path} \\\n", + " --config-class ESM2FineTuneTokenConfig \\\n", + " --data-path {data_path} \\\n", + " --results-path {results_path} \\\n", + " --micro-batch-size 3 \\\n", + " --num-gpus 1 \\\n", + " --precision \"bf16-mixed\" \\\n", + " --include-embeddings \\\n", + " --include-hiddens \\\n", + " --include-input-ids" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# print(cell_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The inference results are written into a `.pt` file which can be loaded using PyTorch library:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hidden_states\ttorch.Size([10, 1024, 320])\n", + "input_ids\ttorch.Size([10, 1024])\n", + "embeddings\ttorch.Size([10, 320])\n", + "classification_output\ttorch.Size([10, 1024, 3])\n" + ] + } + ], + "source": [ + "import torch\n", + "results = torch.load(f\"{results_path}/predictions__rank_0.pt\")\n", + "\n", + "for key, val in results.items():\n", + " if val is not None:\n", + " print(f'{key}\\t{val.shape}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the label tokenizer to convert the classification output to class names. Note that for demonstration purposes we are using a small dataset of artificial sequences in this example. You may experience over-fitting and observe no change in the validation metrics. This amount of data and the short training run does not result in accurate predictions." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.esm2.data.tokenizer import get_tokenizer\n", + "\n", + "\n", + "tokenizer = get_tokenizer()\n", + "tokens = tokenizer.all_tokens\n", + "aa_tokens = ['L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C']\n", + "aa_indices = [i for i, token in enumerate(tokens) if token in aa_tokens]\n", + "extra_indices = [i for i, token in enumerate(tokens) if token not in aa_tokens]\n", + "\n", + "input_ids = results['input_ids'] # b, s\n", + "# mask where non-amino acid tokens are True\n", + "mask = ~torch.isin(input_ids, torch.tensor(extra_indices))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.llm.data.label2id_tokenizer import Label2IDTokenizer\n", + "\n", + "label_tokenizer = Label2IDTokenizer()\n", + "label_tokenizer = label_tokenizer.build_vocab(secondary_structure_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted Secondary Structures:\n", + "EEEECCCCCHHHHHHHHHHHHHHHCCCEEEEEECCCHHHHHHHHHCCCCCCCCCEEE\n", + "CCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\n", + "HHHHHCCCCCHHHHHHHHHHHHHHCCCHHHHHHHHHH\n", + "HHHHHHHHHHCCCHHHHHCCCCCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\n", + "CHHHHHHHHHHHHHHHCCCEEEEEECCCHHHHHHHHHCCCCCCCCCEEE\n", + "HHHHHHHHHHHHHCHHHHHHHHHHHHCCCEECCCEEEECCEEEEECC\n", + "HHHHHCCCHHHHHCCCCCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\n", + "CCCCCHHHHHHHHHHHHHHCCCCCHHHHHHCC\n", + "HHHHHCHHHHHHHHHHHHCCCEECCCEEEECCEEEEECC\n", + "CCCCCCCCCCCCCCCCCCCCCCCCCCEEECCCCEEECHHHHHHHHHCCCCCCCCEECCCCCCC\n" + ] + } + ], + "source": [ + "output_ids = torch.argmax(results[\"classification_output\"], dim=-1)\n", + "\n", + "print(\"Predicted Secondary Structures:\")\n", + "for i in range(output_ids.shape[0]):\n", + " ss_ids = output_ids[i][mask[i]]\n", + " print(label_tokenizer.ids_to_text(ss_ids.tolist()))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/docs/user-guide/examples/bionemo-esm2/finetune.md b/docs/docs/user-guide/examples/bionemo-esm2/finetune.md deleted file mode 100644 index 7968a22397..0000000000 --- a/docs/docs/user-guide/examples/bionemo-esm2/finetune.md +++ /dev/null @@ -1,263 +0,0 @@ -# ESM-2 Fine-Tuning - -This readme serves as a demo for implementing ESM-2 Fine-tuning module, running a regression example and using the model for inference. - -The ESM-2 model is a transformer-based protein language model that has achieved state-of-the-art results in various protein-related tasks. When fine-tuning ESM2, the task head plays a crucial role. A task head refers to the additional layer or set of layers added on top of a pre-trained model, like the ESM-2 transformer-based protein language model, to adapt it for a specific downstream task. As a part of transfer learning, a pre-trained model is often utilized to learn generic features from a large-scale dataset. However, these features might not be directly applicable to the specific task at hand. By incorporating a task head, which consists of learnable parameters, the model can adapt and specialize to the target task. The task head serves as a flexible and adaptable component that learns task-specific representations by leveraging the pre-trained features as a foundation. Through fine-tuning, the task head enables the model to learn and extract task-specific patterns, improving performance and addressing the nuances of the downstream task. It acts as a critical bridge between the pre-trained model and the specific task, enabling efficient and effective transfer of knowledge. - - -# Setup and Assumptions - -In this tutorial, we will demonstrate how to create a fine-tune module, train a regression task head, and use the fine-tuned model for inference. - -All commands should be executed inside the BioNeMo docker container, which has all ESM-2 dependencies pre-installed. This tutorial assumes that a copy of the BioNeMo framework repo exists on workstation or server and has been mounted inside the container at `/workspace/bionemo2`. (**Note**: This `WORKDIR` may be `/workspaces/bionemo-framework` if you are using the VSCode Dev Container.) For more information on how to build or pull the BioNeMo2 container, refer to the [Access and Startup](../../getting-started/access-startup.md). - -To successfully accomplish this we need to define some key classes: - -1. Loss Reduction Method - To compute the supervised fine-tuning loss. -2. Fine-Tuned Model Head - Downstream task head model. -3. Fine-Tuned Model - Model that combines ESM-2 with the task head model. -4. Fine-Tuning Config - Configures the fine-tuning model and loss to use in the training and inference framework. -5. Dataset - Training and inference datasets for ESM2. - -## 1 - Loss Reduction Class - -A class for calculating the supervised loss of the fine-tune model from targets. We inherit from Megatron Bert Masked Language Model Loss (`BERTMLMLossWithReduction`) and override the `forward()` pass to compute MSE loss of the regression head within a micro-batch. The `reduce()` method is used for computing the average over the micro-batches and is only used for logging. - -```python -class RegressorLossReduction(BERTMLMLossWithReduction): - def forward( - self, batch: Dict[str, torch.Tensor], forward_out: Dict[str, torch.Tensor] - ) -> Tuple[torch.Tensor, Union[PerTokenLossDict, SameSizeLossDict]]: - - targets = batch["labels"] # [b, 1] - regression_output = forward_out - loss = torch.nn.functional.mse_loss(regression_output, targets) - return loss, {"avg": loss} - - def reduce(self, losses_reduced_per_micro_batch: Sequence[ReductionT]) -> torch.Tensor: - losses = torch.stack([loss["avg"] for loss in losses_reduced_per_micro_batch]) - return losses.mean() -``` - -## 2 - Fine-Tuned Model Head - -An MLP class for sequence-level regression. This class inherits `MegatronModule` and uses the fine-tune config (`TransformerConfig`) to configure the regression head for the fine-tuned ESM-2 model. - -```python -class MegatronMLPHead(MegatronModule): - def __init__(self, config: TransformerConfig): - super().__init__(config) - layer_sizes = [config.hidden_size, 256, 1] - self.linear_layers = torch.nn.ModuleList( - [torch.nn.Linear(i, o) for i, o in zip(layer_sizes[:-1], layer_sizes[1:])] - ) - self.act = torch.nn.ReLU() - self.dropout = torch.nn.Dropout(p=config.ft_dropout) - - def forward(self, hidden_states: torch.Tensor) -> List[torch.Tensor]: - ... -``` - -## 3 - Fine-Tuned Model - -A fine-tuned ESM-2 model class for token classification tasks. This class inherits from the `ESM2Model` class and adds the custom regression head `MegatronMLPHead` the we created in the previous step. Optionally one can freeze all or parts of the encoder by parsing through the model parameters in the model constructor. - -```python -class ESM2FineTuneSeqModel(ESM2Model): - def __init__(self, config, *args, post_process: bool = True, return_embeddings: bool = False, **kwargs): - super().__init__(config, *args, post_process=post_process, return_embeddings=True, **kwargs) - - # freeze encoder parameters - if config.encoder_frozen: - for _, param in self.named_parameters(): - param.requires_grad = False - - if post_process: - self.regression_head = MegatronMLPHead(config) - - def forward(self, *args, **kwargs,): - output = super().forward(*args, **kwargs) - ... - regression_output = self.regression_head(embeddings) - return regression_output -``` - -## 4 - Fine-Tuning Config - -A `dataclass` that configures the fine-tuned ESM-2 model. In this example `ESM2FineTuneSeqConfig` inherits from `ESM2GenericConfig` and adds custom arguments to setup the fine-tuned model. The `configure_model()` method of this `dataclass` is called within the `Lightning` module to call the model constructor with the `dataclass` arguments. - -The common arguments among different fine-tuning tasks are - -- `model_cls`: The fine-tune model class (`ESM2FineTuneSeqModel`) -- `initial_ckpt_path`: BioNeMo 2.0 ESM-2 pre-trained checkpoint -- `initial_ckpt_skip_keys_with_these_prefixes`: skip keys when loading parameters from a checkpoint. Here we should not look for `regression_head` in the pre-trained checkpoint. -- `get_loss_reduction_class()`: Implements selection of the appropriate `MegatronLossReduction` class, e.g. `bionemo.esm2.model.finetune.finetune_regressor.RegressorLossReduction`. - -```python - -@dataclass -class ESM2FineTuneSeqConfig(ESM2GenericConfig[ESM2FineTuneSeqModel], iom.IOMixinWithGettersSetters): - model_cls: Type[ESM2FineTuneSeqModel] = ESM2FineTuneSeqModel - # The following checkpoint path is for nemo2 checkpoints. Config parameters not present in - # self.override_parent_fields will be loaded from the checkpoint and override those values here. - initial_ckpt_path: str | None = None - # typical case is fine-tune the base biobert that doesn't have this head. If you are instead loading a checkpoint - # that has this new head and want to keep using these weights, please drop this next line or set to [] - initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=lambda: ["regression_head"]) - - encoder_frozen: bool = True # freeze encoder parameters - ft_dropout: float = 0.25 # MLP layer dropout - - def get_loss_reduction_class(self) -> Type[MegatronLossReduction]: - return RegressorLossReduction -``` - -## 5 - Dataset - -We will use a sample dataset for demonstration purposes. Create a dataset class by extending from ```torch.utils.data.Dataset```. For the purposes of this demo, we'll assume dataset consists of small set of protein sequences with a target value of `len(sequence) / 100.0` as their labels. - -```python -data = [ - ("MVLSPADKTNVKAAWGKVGAHAGEYGAEALERH", 0.33), - ... -] -``` - -Therefore, the custom BioNeMo dataset class will be appropriate (found in ```bionemo.esm2.model.finetune.finetune_regressor.InMemorySingleValueDataset```) as it facilitates predicting on a single value. An excerpt from the class is shown below. This example dataset expected a sequence of `Tuple` that hold `(sequence, target)` values. However, one can simply extend ```InMemorySingleValueDataset``` class in a similar way to customize your class for your data. - -```python -class InMemorySingleValueDataset(Dataset): - def __init__( - self, - data: Sequence[Tuple[str, float]], - tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), - seed: int = np.random.SeedSequence().entropy, - ): -``` - -For any arbitrary data file formats, user can process the data into a list of tuples containing (sequence, label) and use this dataset class. Or override the dataset class to load their custom data files. - -To coordinate the creation of training, validation and testing datasets from your data, we need to use a `datamodule` class. To do this we can directly use or extend the ```ESM2FineTuneDataModule``` class (located at ```bionemo.esm2.model.finetune.datamodule.ESM2FineTuneDataModule```) which defines helpful abstract methods that use your dataset class. - -```python -dataset = InMemorySingleValueDataset(data) -data_module = ESM2FineTuneDataModule( - train_dataset=train_dataset, - valid_dataset=valid_dataset - micro_batch_size=4, # size of a batch to be processed in a device - global_batch_size=8, # size of batch across all devices. Should be multiple of micro_batch_size -) -``` - -# Fine-Tuning the Regressor Task Head for ESM2 - -Now we can put these five requirements together to fine-tune a regressor task head starting from a pre-trained 650M ESM-2 model (`pretrain_ckpt_path`). We can take advantage of a simple training loop in ```bionemo.esm2.model.fnetune.train``` and use the ```train_model()`` function to start the fine-tuning process in the following. - -```python -# create a List[Tuple] with (sequence, target) values -artificial_sequence_data = [ - "TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "GRFNVWLGGNESKIRQVLKAVKEIGVSPTLFAVYEKN", - "DELTALGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "KLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LFGAIGNAISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "LGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "ISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "SGSKASSDSQDANQCCTSCEDNAPATSYCVECSEPLCETCVEAHQRVKYTKDHTVRSTGPAKT", -] - -data = [(seq, len(seq)/100.0) for seq in artificial_sequence_data] - -# we are training and validating on the same dataset for simplicity -dataset = InMemorySingleValueDataset(data) -data_module = ESM2FineTuneDataModule(train_dataset=dataset, valid_dataset=dataset) - -experiment_name = "finetune_regressor" -n_steps_train = 50 -seed = 42 - -# To download a 650M pre-trained ESM2 model -pretrain_ckpt_path = load("esm2/650m:2.0") - -config = ESM2FineTuneSeqConfig( - initial_ckpt_path=str(pretrain_ckpt_path) -) - -checkpoint, metrics, trainer = train_model( - experiment_name=experiment_name, - experiment_dir=Path(experiment_results_dir), # new checkpoint will land in a subdir of this - config=config, # same config as before since we are just continuing training - data_module=data_module, - n_steps_train=n_steps_train, -) -``` - -This example is fully implemented in ```bionemo.esm2.model.finetune.train``` and can be executed by: -```bash -python -m bionemo.esm2.model.finetune.train -``` - -## Notes -1. The above example is fine-tuning a 650M ESM-2 model. The pre-trained checkpoints can be downloaded from NGC resources using either the following bash command or the `load` function in `bionemo.core.data.load` as shown above. - ```bash - download_bionemo_data esm2/650m:2.0 - ``` - and pass the output path (e.g. `.../.cache/bionemo/975d29ee980fcb08c97401bbdfdcf8ce-esm2_650M_nemo2.tar.gz.untar`) as an argument into `initial_ckpt_path` while setting the config object: - ```python - config = ESM2FineTuneSeqConfig( - initial_ckpt_path=str(pretrain_ckpt_path) - ) - ``` -2. Due to Megatron limitations, the log produced by the training run iterates on steps/iterations and not epochs. Therefore, `Training epoch` counter stays at value zero while `iteration` and `global_ste`p increase during the course of training (example in the following). - ```bash - Training epoch 0, iteration <x/max_steps> | ... | global_step: <x> | reduced_train_loss: ... | val_loss: ... - ``` - to achieve the same epoch-based effect while training, please choose the number of training steps (`n_steps_train`) so that: - ```bash - n_steps_train * global_batch_size = len(dataset) * desired_num_epochs - ``` -3. We are using a small dataset of artificial sequences as our fine-tuning data in this example. You may experience over-fitting and observe no change in the validation metrics. - -# Fine-Tuned ESM-2 Model Inference -Now we can use ```bionemo.esm2.model.finetune.train.infer``` to run inference on an example prediction dataset. -Record the checkpoint path reported at the end of the finetuning run, after executing `python -m bionemo.esm2.model.finetune.train` (e.g. `/tmp/tmp1b5wlnba/finetune_regressor/checkpoints/finetune_regressor--reduced_train_loss=0.0016-epoch=0-last`) and use that as an argument to inference script (`--checkpoint-path`). - -We download a CSV example dataset of articical sequences for this inference example. Please refer to [ESM-2 Inference](./inference) tutorial for detailed explanation of the arguments and how to create your own CSV file. - -```bash -mkdir -p $WORKDIR/esm2_finetune_tutorial - -# download sample data CSV for inference -DATA_PATH=$(download_bionemo_data esm2/testdata_esm2_infer:2.0) -RESULTS_PATH=$WORKDIR/esm2_finetune_tutorial/ - -infer_esm2 --checkpoint-path <finetune checkpoint path> \ - --data-path $DATA_PATH \ - --results-path $RESULTS_PATH \ - --config-class ESM2FineTuneSeqConfig -``` - -This will create a result `.pt` file under `$WORKDIR/esm2_finetune_tutorial/predictions__rank_0.pt` which can be loaded via PyTorch library in python environment: - -```python -import torch - -# Set the path to results file e.g. /workspace/bionemo2/esm2_finetune_tutorial/predictions__rank_0.pt -# results_path = /workspace/bionemo2/esm2_finetune_tutorial/predictions__rank_0.pt -results = torch.load(results_path) - -# results is a python dict which includes the following result tensors for this example: -# results['regression_output'] is a tensor with shape: torch.Size([10, 1]) -``` - -## Notes -- ESM2 Inference module takes the `--checkpoint-path` and `--config-class` arguments to create a config object by pointing the path in `initial_ckpt_path`. Since we need to load all the parameters from this checkpoint (and don't skip the head) we reset the `initial_ckpt_skip_keys_with_these_prefixes` in this config. - - ```python - config = ESM2FineTuneSeqConfig( - initial_ckpt_path = <finetuned checkpoint>, - initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=list) - ) - ``` diff --git a/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb b/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb index 5dfd17964f..f487e73011 100644 --- a/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb +++ b/docs/docs/user-guide/examples/bionemo-esm2/inference.ipynb @@ -141,11 +141,40 @@ "execution_count": 4, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading data from 'nvidia/clara/esm2nv650m:2.0' to file '/home/ubuntu/.cache/bionemo/0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997-esm2_650M_nemo2.tar.gz'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"download_end\": \"2025-01-14 22:01:24\",\n", + " \"download_start\": \"2025-01-14 22:01:05\",\n", + " \"download_time\": \"18s\",\n", + " \"files_downloaded\": 1,\n", + " \"local_path\": \"/home/ubuntu/.cache/bionemo/tmpfj1e52vw/esm2nv650m_v2.0\",\n", + " \"size_downloaded\": \"1.12 GB\",\n", + " \"status\": \"COMPLETED\"\n", + "}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Untarring contents of '/home/ubuntu/.cache/bionemo/0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997-esm2_650M_nemo2.tar.gz' to '/home/ubuntu/.cache/bionemo/0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997-esm2_650M_nemo2.tar.gz.untar'\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "/home/bionemo/.cache/bionemo/0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997-esm2_650M_nemo2.tar.gz.untar\n" + "/home/ubuntu/.cache/bionemo/0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997-esm2_650M_nemo2.tar.gz.untar\n" ] } ], @@ -168,7 +197,7 @@ "metadata": {}, "source": [ "\n", - "We use the `InMemoryCSVDataset` class to load the protein sequence data from a `.csv` file. This data file should at least have a `sequences` column and can optionally have a `labels` column used for fine-tuning applications. Here is an example of how to create your own inference input data using a list of sequences in python:" + "We use the `InMemoryProteinDataset` class to load the protein sequence data from a `.csv` file. This data file should at least have a `sequences` column and can optionally have a `labels` column used for fine-tuning applications. Here is an example of how to create your own inference input data using a list of sequences in python:" ] }, { @@ -238,12 +267,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "2024-12-16 20:19:23 - faiss.loader - INFO - Loading faiss with AVX512 support.\n", - "2024-12-16 20:19:23 - faiss.loader - INFO - Successfully loaded faiss with AVX512 support.\n", - "[NeMo W 2024-12-16 20:19:24 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "2025-01-14 22:01:45 - faiss.loader - INFO - Loading faiss with AVX512 support.\n", + "2025-01-14 22:01:45 - faiss.loader - INFO - Successfully loaded faiss with AVX512 support.\n", + "[NeMo W 2025-01-14 22:01:46 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", - "[NeMo W 2024-12-16 20:19:24 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed two minor releases later. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap(obj)`` instead.\n", + "[NeMo W 2025-01-14 22:01:46 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", "usage: infer_esm2 [-h] --checkpoint-path CHECKPOINT_PATH --data-path DATA_PATH\n", @@ -533,7 +562,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb index 6347e540e9..1e9b46c595 100644 --- a/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb +++ b/docs/docs/user-guide/examples/bionemo-geneformer/geneformer-celltype-classification.ipynb @@ -28,6 +28,14 @@ "execution_count": 1, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.12/dist-packages/optuna/study/_optimize.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from optuna import progress_bar as pbar_module\n" + ] + }, { "data": { "text/plain": [ @@ -70,14 +78,18 @@ } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", + "# NBVAL_CHECK_OUTPUT\n", "import cellxgene_census\n", + "\n", + "\n", "CENSUS_VERSION = \"2023-12-15\"\n", "with cellxgene_census.open_soma(census_version=CENSUS_VERSION) as census:\n", - " adata = cellxgene_census.get_anndata(census, \"Homo sapiens\",\n", - " obs_value_filter='dataset_id==\"8e47ed12-c658-4252-b126-381df8d52a3d\"',\n", - " )\n", - "uq_cells = sorted(adata.obs['cell_type'].unique().tolist())\n", + " adata = cellxgene_census.get_anndata(\n", + " census,\n", + " \"Homo sapiens\",\n", + " obs_value_filter='dataset_id==\"8e47ed12-c658-4252-b126-381df8d52a3d\"',\n", + " )\n", + "uq_cells = sorted(adata.obs[\"cell_type\"].unique().tolist())\n", "uq_cells" ] }, @@ -98,12 +110,13 @@ } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", + "# NBVAL_CHECK_OUTPUT\n", "import random\n", "from contextlib import contextmanager\n", "\n", + "\n", "@contextmanager\n", - "def random_seed(seed:int):\n", + "def random_seed(seed: int):\n", " state = random.getstate()\n", " random.seed(seed)\n", " try:\n", @@ -112,25 +125,21 @@ " # Go back to previous state\n", " random.setstate(state)\n", "\n", + "\n", "with random_seed(32):\n", " indices = list(range(len(adata)))\n", " random.shuffle(indices)\n", "\n", - "micro_batch_size:int = 32\n", - "num_steps:int = 256\n", - "selection = sorted(indices[:micro_batch_size*num_steps])\n", + "micro_batch_size: int = 32\n", + "num_steps: int = 256\n", + "selection = sorted(indices[: micro_batch_size * num_steps])\n", "# NOTE: there's a current constraint that predict_step needs to be a function of micro-batch-size.\n", "# this is something we are working on fixing. A quick hack is to set micro-batch-size=1, but this is\n", "# slow. In this notebook we are going to use mbs=32 and subsample the anndata.\n", - "adata = adata[selection].copy() # so it's not a view\n", + "adata = adata[selection].copy() # so it's not a view\n", "adata.shape" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, { "cell_type": "code", "execution_count": 3, @@ -138,8 +147,11 @@ "outputs": [], "source": [ "import shutil\n", + "\n", "from bionemo.core import BIONEMO_CACHE_DIR\n", - "cleanup:bool=True\n", + "\n", + "\n", + "cleanup: bool = True\n", "notebook_workdir = BIONEMO_CACHE_DIR / \"notebook_tutorials\" / \"geneformer_celltype_classification\"\n", "if cleanup and notebook_workdir.exists():\n", " shutil.rmtree(notebook_workdir)\n", @@ -196,9 +208,13 @@ } ], "source": [ - "#NBVAL_CHECK_OUTPUT\n", + "# NBVAL_CHECK_OUTPUT\n", "from glob import glob\n", - "files = sorted([f.split(\"/\")[-1] for f in glob(str(data_dir/\"*\"))]) # strip off the directory name and sort for the test\n", + "\n", + "\n", + "files = sorted(\n", + " [f.split(\"/\")[-1] for f in glob(str(data_dir / \"*\"))]\n", + ") # strip off the directory name and sort for the test\n", "files" ] }, @@ -208,19 +224,15 @@ "metadata": {}, "outputs": [], "source": [ - "# NOTE: calling the load(...) function directly does not currently work for downloads through NGC in an interactive\n", - "# notebook environment. Get aound this below by calling the CLI download endpoint which executes in a subshell.\n", + "from bionemo.core.data.load import load\n", + "\n", "\n", "# 106m checkpoint\n", - "geneformer_106m_out = !download_bionemo_data \"geneformer/106M_240530:2.0\"\n", + "geneformer_106m = load(\"geneformer/106M_240530:2.0\")\n", "# 10m checkpoint\n", - "geneformer_10m_out = !download_bionemo_data \"geneformer/10M_240530:2.0\"\n", + "geneformer_10m = load(\"geneformer/10M_240530:2.0\")\n", "# 10m bionemo2 trained checkpoint\n", - "geneformer_10m_bnmo2_out = !download_bionemo_data \"geneformer/10M_241113:2.0\"\n", - "# Result includes a list of outputs, the last one is the path so grab that from each:\n", - "geneformer_106m = geneformer_106m_out[-1]\n", - "geneformer_10m = geneformer_10m_out[-1]\n", - "geneformer_10m_bnmo2 = geneformer_10m_bnmo2_out[-1]" + "geneformer_10m_bnmo2 = load(\"geneformer/10M_241113:2.0\")" ] }, { @@ -252,142 +264,50 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-23 20:23:33 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", - " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", - " \n", - "[NeMo W 2024-12-23 20:23:33 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", + "[NeMo W 2025-01-23 16:25:59 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-23 20:23:37 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:23:37 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:23:37 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:23:37 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:23:37 infer_geneformer:83] *************** Preprocessing Finished ************\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "[NeMo I 2024-12-23 20:23:37 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:23:38 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2025-01-23 16:26:03 nemo_logging:405] Tokenizer vocab file: /root/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] *************** Preprocessing Finished ************\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:03 nemo_logging:393] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "----------------------------------------------------------------------------------------------------\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "2024-12-23 20:23:38 - /workspaces/bionemo-framework/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py - WARNING - Loading /home/bionemo/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-12-23 20:23:40 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "[NeMo W 2024-12-23 20:23:40 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "2024-12-23 20:23:40 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", - "[NeMo I 2024-12-23 20:23:40 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", - "2024-12-23 20:23:40 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", - "2024-12-23 20:23:40 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", - "Params for bucket 1 (10300032 elements):\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", - "\tmodule.embedding.word_embeddings.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.final_layernorm.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", - "\tmodule.lm_head.dense.weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", - "\tmodule.encoder.final_layernorm.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", - "\tmodule.lm_head.layer_norm.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", - "\tmodule.lm_head.dense.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", - "\tmodule.embedding.position_embeddings.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.lm_head.layer_norm.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", - "\tmodule.output_layer.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", - "2024-12-23 20:23:40 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", - "2024-12-23 20:23:40 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", - "2024-12-23 20:24:08 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m.pt/predictions__rank_0.pt\n", - "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" + "[WARNING | /usr/local/lib/python3.12/dist-packages/bionemo/llm/model/config.py]: Loading /root/.cache/bionemo/a27061ee347f453b1bf175e288df31e9813903ebcb4924a77ac50dccc730889d-geneformer_10M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2025-01-23 16:26:04 nemo_logging:393] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "[NeMo W 2025-01-23 16:26:04 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-01-23 16:26:04 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" ] } ], @@ -400,167 +320,24 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids\n" + " --include-input-ids" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[NeMo W 2024-12-23 20:24:25 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", - " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", - " \n", - "[NeMo W 2024-12-23 20:24:25 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", - " cm = get_cmap(\"Set1\")\n", - " \n", - "[NeMo W 2024-12-23 20:24:29 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:24:29 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:24:29 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:24:29 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:24:29 infer_geneformer:83] *************** Preprocessing Finished ************\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "[NeMo I 2024-12-23 20:24:29 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:24:29 megatron_init:485] Rank 0 has embedding rank: 0\n", - "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "----------------------------------------------------------------------------------------------------\n", - "distributed_backend=nccl\n", - "All distributed processes registered. Starting with 1 processes\n", - "----------------------------------------------------------------------------------------------------\n", - "\n", - "2024-12-23 20:24:30 - /workspaces/bionemo-framework/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py - WARNING - Loading /home/bionemo/.cache/bionemo/fb6e70cd6bd98fb8941b5de978e95db17a6b8596f1c03f4d641a6d2ba6599757-geneformer_10M_241113_nemo2.tar.gz.untar\n", - "[NeMo I 2024-12-23 20:24:32 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "[NeMo W 2024-12-23 20:24:32 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "2024-12-23 20:24:32 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", - "[NeMo I 2024-12-23 20:24:32 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", - "2024-12-23 20:24:32 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", - "2024-12-23 20:24:32 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", - "Params for bucket 1 (10300032 elements):\n", - "\tmodule.lm_head.layer_norm.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", - "\tmodule.output_layer.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.embedding.position_embeddings.weight\n", - "\tmodule.encoder.final_layernorm.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", - "\tmodule.lm_head.dense.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.final_layernorm.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", - "\tmodule.lm_head.dense.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", - "\tmodule.lm_head.layer_norm.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.embedding.word_embeddings.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", - "2024-12-23 20:24:32 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", - "2024-12-23 20:24:32 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", - "2024-12-23 20:24:59 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_bnmo2.pt/predictions__rank_0.pt\n", - "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" - ] - } - ], + "outputs": [], "source": [ - "!infer_geneformer \\\n", - " --data-dir {data_dir} \\\n", - " --checkpoint-path {geneformer_10m_bnmo2} \\\n", - " --results-path {result_path_10m_bnmo2} \\\n", - " --micro-batch-size {micro_batch_size} \\\n", - " --seq-len 2048 \\\n", - " --num-dataset-workers 10 \\\n", - " --num-gpus 1 \\\n", - " --include-input-ids\n" + "# !infer_geneformer \\\n", + "# --data-dir {data_dir} \\\n", + "# --checkpoint-path {geneformer_10m_bnmo2} \\\n", + "# --results-path {result_path_10m_bnmo2} \\\n", + "# --micro-batch-size {micro_batch_size} \\\n", + "# --seq-len 2048 \\\n", + "# --num-dataset-workers 10 \\\n", + "# --num-gpus 1 \\\n", + "# --include-input-ids" ] }, { @@ -572,141 +349,49 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-23 20:25:16 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", - " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", - " \n", - "[NeMo W 2024-12-23 20:25:17 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", + "[NeMo W 2025-01-23 16:26:41 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-23 20:25:20 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:25:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:25:20 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:25:20 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:25:20 infer_geneformer:83] *************** Preprocessing Finished ************\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "[NeMo I 2024-12-23 20:25:20 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:25:20 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2025-01-23 16:26:45 nemo_logging:405] Tokenizer vocab file: /root/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] *************** Preprocessing Finished ************\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:26:45 nemo_logging:393] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "----------------------------------------------------------------------------------------------------\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "[NeMo I 2024-12-23 20:25:21 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "[NeMo W 2024-12-23 20:25:21 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "2024-12-23 20:25:21 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", - "[NeMo I 2024-12-23 20:25:21 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n", - "2024-12-23 20:25:21 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", - "2024-12-23 20:25:21 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", - "Params for bucket 1 (10300032 elements):\n", - "\tmodule.lm_head.layer_norm.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.final_layernorm.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", - "\tmodule.encoder.final_layernorm.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", - "\tmodule.lm_head.layer_norm.bias\n", - "\tmodule.lm_head.dense.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", - "\tmodule.embedding.position_embeddings.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.lm_head.dense.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", - "\tmodule.output_layer.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.embedding.word_embeddings.weight\n", - "2024-12-23 20:25:21 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", - "2024-12-23 20:25:21 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", - "2024-12-23 20:25:47 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_10m_randomweights.pt/predictions__rank_0.pt\n", - "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" + "[NeMo I 2025-01-23 16:26:46 nemo_logging:393] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "[NeMo W 2025-01-23 16:26:46 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-01-23 16:26:46 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 10300032\n" ] } ], @@ -718,7 +403,7 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids\n" + " --include-input-ids" ] }, { @@ -730,214 +415,50 @@ "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2024-12-23 20:26:04 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", - " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", - " \n", - "[NeMo W 2024-12-23 20:26:04 nemo_logging:361] /usr/local/lib/python3.10/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", + "[NeMo W 2025-01-23 16:27:23 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pyannote/core/notebook.py:134: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n", " cm = get_cmap(\"Set1\")\n", " \n", - "[NeMo W 2024-12-23 20:26:08 preprocess:101] Tokenizer vocab file: /home/bionemo/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", - "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:26:08 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:26:08 remote:124] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", - "[NeMo I 2024-12-23 20:26:08 remote:136] No checksum provided, filename exists. Assuming it is complete.\n", - "[NeMo I 2024-12-23 20:26:08 infer_geneformer:83] *************** Preprocessing Finished ************\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "HPU available: False, using: 0 HPUs\n", - "[NeMo I 2024-12-23 20:26:08 megatron_strategy:315] Fixing mis-match between ddp-config & mcore-optimizer config\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:396] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:402] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:407] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:410] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:418] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:421] All context parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:422] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:429] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:430] All model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:439] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:443] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:444] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:464] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:476] Rank 0 has embedding group: [0]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:482] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:483] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:484] All embedding group ranks: [[0]]\n", - "[NeMo I 2024-12-23 20:26:08 megatron_init:485] Rank 0 has embedding rank: 0\n", + "[NeMo W 2025-01-23 16:27:26 nemo_logging:405] Tokenizer vocab file: /root/.cache/bionemo/d8e3ea569bc43768c24aa651aff77722df202078415528497c22394046b08cc3-singlecell-scdltestdata-20241203.tar.gz.untar/cellxgene_2023-12-15_small_processed_scdl/train/geneformer.vocab already exists. Overwriting...\n", + "[NeMo I 2025-01-23 16:27:26 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:27:26 nemo_logging:393] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_name_id_dict_gc30M.pkl?download=true\n", + "[NeMo I 2025-01-23 16:27:26 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:27:26 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:27:26 nemo_logging:393] Resource already exists, skipping download: https://huggingface.co/ctheodoris/Geneformer/resolve/main/geneformer/gene_dictionaries_30m/gene_median_dictionary_gc30M.pkl?download=true\n", + "[NeMo I 2025-01-23 16:27:26 nemo_logging:393] No checksum provided, filename exists. Assuming it is complete.\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] *************** Preprocessing Finished ************\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "----------------------------------------------------------------------------------------------------\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "2024-12-23 20:26:08 - /workspaces/bionemo-framework/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py - WARNING - Loading /home/bionemo/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", - "[NeMo I 2024-12-23 20:26:11 base:44] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "[NeMo W 2024-12-23 20:26:11 megatron_strategy:329] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "2024-12-23 20:26:11 - megatron.core.num_microbatches_calculator - INFO - setting number of microbatches to constant 1\n", - "[NeMo I 2024-12-23 20:26:11 megatron_parallel:549] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n", - "2024-12-23 20:26:11 - megatron.core.distributed.distributed_data_parallel - INFO - Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=True, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", - "2024-12-23 20:26:11 - megatron.core.distributed.param_and_grad_buffer - INFO - Number of buckets for gradient all-reduce / reduce-scatter: 1\n", - "Params for bucket 1 (106808960 elements):\n", - "\tmodule.encoder.layers.10.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.8.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.7.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.11.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.weight\n", - "\tmodule.lm_head.dense.bias\n", - "\tmodule.encoder.layers.7.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.6.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.11.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.8.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.6.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.11.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.6.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.10.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.11.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.9.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.7.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.6.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.11.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.10.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.weight\n", - "\tmodule.encoder.final_layernorm.bias\n", - "\tmodule.encoder.layers.9.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.6.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.10.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.8.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.bias\n", - "\tmodule.lm_head.layer_norm.weight\n", - "\tmodule.encoder.layers.11.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.10.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.9.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.6.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.11.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.8.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.5.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.9.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.7.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.11.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.10.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.lm_head.layer_norm.bias\n", - "\tmodule.encoder.layers.9.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.5.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.10.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.8.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.7.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.4.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.bias\n", - "\tmodule.embedding.position_embeddings.weight\n", - "\tmodule.encoder.final_layernorm.weight\n", - "\tmodule.encoder.layers.11.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.8.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.10.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.9.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.6.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.8.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.4.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.bias\n", - "\tmodule.output_layer.bias\n", - "\tmodule.encoder.layers.9.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.7.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.3.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.10.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.7.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.6.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.8.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.9.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.7.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.3.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.6.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.11.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.8.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.1.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.9.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.7.mlp.linear_fc1.weight\n", - "\tmodule.encoder.layers.6.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.4.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.1.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.11.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.9.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.8.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.2.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.0.self_attention.linear_proj.bias\n", - "\tmodule.encoder.layers.10.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.7.self_attention.linear_qkv.layer_norm_bias\n", - "\tmodule.encoder.layers.6.self_attention.linear_qkv.layer_norm_weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.0.mlp.linear_fc1.weight\n", - "\tmodule.embedding.word_embeddings.weight\n", - "\tmodule.lm_head.dense.weight\n", - "\tmodule.encoder.layers.8.self_attention.linear_qkv.bias\n", - "\tmodule.encoder.layers.7.self_attention.linear_proj.weight\n", - "\tmodule.encoder.layers.4.mlp.linear_fc1.layer_norm_bias\n", - "\tmodule.encoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", - "\tmodule.encoder.layers.9.self_attention.linear_qkv.weight\n", - "\tmodule.encoder.layers.5.mlp.linear_fc1.bias\n", - "\tmodule.encoder.layers.3.mlp.linear_fc2.weight\n", - "\tmodule.encoder.layers.1.mlp.linear_fc2.bias\n", - "\tmodule.encoder.layers.0.self_attention.linear_qkv.layer_norm_bias\n", - "2024-12-23 20:26:11 - megatron.core.optimizer - INFO - Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.999, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", - "2024-12-23 20:26:11 - root - INFO - Instantiating MegatronPretrainingSampler with total_samples: 8192 and consumed_samples: 0\n", - "2024-12-23 20:27:26 - root - INFO - Inference predictions are stored in /home/bionemo/.cache/bionemo/notebook_tutorials/geneformer_celltype_classification/results_106m.pt/predictions__rank_0.pt\n", - "dict_keys(['token_logits', 'binary_logits', 'input_ids', 'embeddings'])\n" + "[WARNING | /usr/local/lib/python3.12/dist-packages/bionemo/llm/model/config.py]: Loading /root/.cache/bionemo/7d67a526379eb8581f2aaaf03425ae9ec81a38570b24ddc8b22818e5d26ea772-geneformer_106M_240530_nemo2.tar.gz.untar\n", + "[NeMo I 2025-01-23 16:27:27 nemo_logging:393] Padded vocab_size: 25472, original vocab_size: 25429, dummy tokens: 43.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "[NeMo W 2025-01-23 16:27:28 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-01-23 16:27:28 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 106808960\n" ] } ], @@ -950,7 +471,7 @@ " --seq-len 2048 \\\n", " --num-dataset-workers 10 \\\n", " --num-gpus 1 \\\n", - " --include-input-ids\n" + " --include-input-ids" ] }, { @@ -1008,7 +529,7 @@ " 'recall': make_scorer(recall_score, average='macro'),\n", " 'f1_score': make_scorer(f1_score, average='macro'),\n", " # 'roc_auc' requires probability or decision function; hence use multi_class if applicable\n", - " 'roc_auc': make_scorer(roc_auc_score, multi_class='ovr', needs_proba=True),\n", + " 'roc_auc': make_scorer(roc_auc_score, multi_class='ovr'),\n", " }\n", "\n", " # Perform stratified cross-validation with multiple metrics using the pipeline\n", @@ -1039,7 +560,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47840/2637469332.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + "/tmp/ipykernel_5543/2637469332.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " infer_Xs_10m = torch.load(result_path_10m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" ] } @@ -1057,20 +578,11 @@ "cell_type": "code", "execution_count": 14, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_47840/3276479409.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2 / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" - ] - } - ], + "outputs": [], "source": [ - "infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2 / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", - "assert len(adata) == len(infer_Xs_10m_bnmo2), (len(adata), len(infer_Xs_10m))\n", - "assert infer_Xs_10m_bnmo2.shape == (8192, 256)" + "# infer_Xs_10m_bnmo2 = torch.load(result_path_10m_bnmo2 / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n", + "# assert len(adata) == len(infer_Xs_10m_bnmo2), (len(adata), len(infer_Xs_10m))\n", + "# assert infer_Xs_10m_bnmo2.shape == (8192, 256)" ] }, { @@ -1082,7 +594,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47840/4058871012.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + "/tmp/ipykernel_5543/4058871012.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " infer_Xs_106m = torch.load(result_path_106m / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" ] } @@ -1102,7 +614,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47840/3286066556.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + "/tmp/ipykernel_5543/3286066556.py:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", " infer_Xs_10m_random = torch.load(results_path_10m_random / \"predictions__rank_0.pt\")['embeddings'].float().cpu().numpy()\n" ] } @@ -1139,7 +651,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47840/771671311.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", + "/tmp/ipykernel_5543/771671311.py:10: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", " ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha='right')\n" ] }, @@ -1155,7 +667,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 1 Axes>" ] @@ -1206,7 +718,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 1 Axes>" ] @@ -1266,18 +778,131 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", " warnings.warn(\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n" ] }, { @@ -1285,11 +910,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.776 (+/- 0.035)\n", - "precision: 0.635 (+/- 0.043)\n", - "recall: 0.544 (+/- 0.024)\n", - "f1_score: 0.561 (+/- 0.032)\n", - "roc_auc: 0.970 (+/- 0.011)\n" + "accuracy: 0.775 (+/- 0.035)\n", + "precision: 0.635 (+/- 0.044)\n", + "recall: 0.546 (+/- 0.029)\n", + "f1_score: 0.561 (+/- 0.035)\n", + "roc_auc: nan (+/- nan)\n" ] } ], @@ -1304,7 +929,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 2 Axes>" ] @@ -1326,18 +951,131 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", " warnings.warn(\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n" ] }, { @@ -1345,11 +1083,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.427 (+/- 0.025)\n", - "precision: 0.161 (+/- 0.028)\n", - "recall: 0.101 (+/- 0.010)\n", - "f1_score: 0.087 (+/- 0.011)\n", - "roc_auc: 0.751 (+/- 0.018)\n" + "accuracy: 0.399 (+/- 0.008)\n", + "precision: 0.143 (+/- 0.017)\n", + "recall: 0.092 (+/- 0.006)\n", + "f1_score: 0.079 (+/- 0.007)\n", + "roc_auc: nan (+/- nan)\n" ] } ], @@ -1366,13 +1104,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47840/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_5543/3742577664.py:16: RuntimeWarning: invalid value encountered in divide\n", " _ = sb.heatmap(cm / cm.sum(axis=0), cmap=sb.color_palette(\"Blues\", as_cmap=True), vmin=0, vmax=1, linewidth=0.1, linecolor='lightgrey', xticklabels=labels, yticklabels=labels)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 2 Axes>" ] @@ -1394,18 +1132,131 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", " warnings.warn(\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n" ] }, { @@ -1417,7 +1268,7 @@ "precision: 0.788 (+/- 0.029)\n", "recall: 0.677 (+/- 0.015)\n", "f1_score: 0.702 (+/- 0.017)\n", - "roc_auc: 0.986 (+/- 0.006)\n" + "roc_auc: nan (+/- nan)\n" ] } ], @@ -1432,7 +1283,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 2 Axes>" ] @@ -1449,60 +1300,18 @@ "cell_type": "code", "execution_count": 28, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cross-validation metrics:\n", - "accuracy: 0.834 (+/- 0.021)\n", - "precision: 0.790 (+/- 0.052)\n", - "recall: 0.675 (+/- 0.031)\n", - "f1_score: 0.703 (+/- 0.037)\n", - "roc_auc: 0.990 (+/- 0.007)\n" - ] - } - ], + "outputs": [], "source": [ - "results_10m_bnmo2, cm_10m_bnmo2 = run_benchmark(infer_Xs_10m_bnmo2, integer_labels, use_pca=False)" + "# results_10m_bnmo2, cm_10m_bnmo2 = run_benchmark(infer_Xs_10m_bnmo2, integer_labels, use_pca=False)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 640x480 with 2 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plot_cm(cm_10m_bnmo2)" + "# plot_cm(cm_10m_bnmo2)" ] }, { @@ -1514,10 +1323,123 @@ "name": "stderr", "output_type": "stream", "text": [ - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_scorer.py:610: FutureWarning: The `needs_threshold` and `needs_proba` parameter are deprecated in version 1.4 and will be removed in 1.6. You can either let `response_method` be `None` or set it to `predict` to preserve the same behaviour.\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", " warnings.warn(\n", - "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + "/usr/local/lib/python3.12/dist-packages/sklearn/model_selection/_validation.py:978: UserWarning: Scoring failed. The score on this train-test partition for these parameters will be set to nan. Details: \n", + "Traceback (most recent call last):\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 140, in __call__\n", + " score = scorer._score(\n", + " ^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_scorer.py\", line 388, in _score\n", + " return self._sign * self._score_func(y_true, y_pred, **scoring_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/utils/_param_validation.py\", line 216, in wrapper\n", + " return func(*args, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 635, in roc_auc_score\n", + " return _multiclass_roc_auc_score(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/sklearn/metrics/_ranking.py\", line 707, in _multiclass_roc_auc_score\n", + " if not np.allclose(1, y_score.sum(axis=1)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + " File \"/usr/local/lib/python3.12/dist-packages/numpy/core/_methods.py\", line 49, in _sum\n", + " return umr_sum(a, axis, dtype, out, keepdims, initial, where)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1\n", + "\n", + " warnings.warn(\n" ] }, { @@ -1525,11 +1447,11 @@ "output_type": "stream", "text": [ "Cross-validation metrics:\n", - "accuracy: 0.906 (+/- 0.014)\n", - "precision: 0.916 (+/- 0.023)\n", - "recall: 0.820 (+/- 0.013)\n", - "f1_score: 0.845 (+/- 0.014)\n", - "roc_auc: 0.993 (+/- 0.005)\n" + "accuracy: 0.905 (+/- 0.015)\n", + "precision: 0.912 (+/- 0.025)\n", + "recall: 0.819 (+/- 0.015)\n", + "f1_score: 0.843 (+/- 0.016)\n", + "roc_auc: nan (+/- nan)\n" ] } ], @@ -1544,7 +1466,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 640x480 with 2 Axes>" ] @@ -1566,12 +1488,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47840/3301380888.py:42: FutureWarning: \n", + "/tmp/ipykernel_5543/808009756.py:42: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", " sb.barplot(x='model', y='f1_score_mean', data=df, capsize=0.2, palette='viridis', ax=ax)\n", - "/tmp/ipykernel_47840/3301380888.py:53: FutureWarning: \n", + "/tmp/ipykernel_5543/808009756.py:53: FutureWarning: \n", "\n", "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", "\n", @@ -1580,7 +1502,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAPJCAYAAAD+rtLDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAACz20lEQVR4nOzde1yUZf7/8TegDHgALeRkrHhKMgUKV5ZSq21yPKyptYV2UMlwNW2r2bIwBU+JVhK1WZhFaq1JB9fa1S9mU9S2ohZkbZbmGU8zogUoJijM749+Tk2Aid46Iq/n43E/cq77c11zXeaob+/7vsbL6XQ6BQAAAAA4K96engAAAAAAXAwIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAA0UpGRkRo1apSnpwEAFw3CFQA0cAsXLpSXl1etx2OPPeaqe//99zV69Gh169ZNPj4+ioyMrNf7HDlyRGlpaerWrZuaN2+uSy+9VLGxsXrggQe0b98+g1d1fjgcDj388MOKiopSs2bN1Lx5c8XFxWnmzJkqKSnx9PQAAA1ME09PAABgjOnTp6t9+/Zubd26dXP9eMmSJcrJydHVV1+t8PDweo19/Phx9enTR5s2bdLIkSN1//3368iRI9q4caOWLFmioUOH1ntMT/vss880YMAAHTlyRHfddZfi4uIkSZ9//rlmz56tTz75RO+//76HZ3lubd68Wd7e/DsrABiFcAUAF4n+/furR48edZ6fNWuWFixYoKZNm+pPf/qTvv7669Mee/ny5friiy/0j3/8Q3fccYfbuWPHjqmysvKM511f5eXlat68+VmNUVJSoqFDh8rHx0dffPGFoqKi3M4/8cQTWrBgwVm9x4XK6XTq2LFj8vf3l8lk8vR0AOCiwj9XAUAjER4erqZNm55R323btkmSrr322hrn/Pz8FBAQ4Na2adMm3X777WrTpo38/f3VpUsXPf744241X3zxhfr376+AgAC1aNFCN954o9auXetWc/KWx48//lj33XefgoODddlll7nO/9///Z969+6t5s2bq2XLlho4cKA2btz4m+uZP3++9u7dq4yMjBrBSpJCQkI0efJkt7YXXnhBV155pUwmk8LDwzV+/Pgatw5ef/316tatm7766itdd911atasmTp16qS3335bkvTxxx8rPj7e9XPywQcfuPWfOnWqvLy8XD9/AQEBuvTSS/XAAw/o2LFjbrWvvvqq/vjHPyo4OFgmk0ldu3bViy++WGMtkZGR+tOf/qRVq1apR48e8vf31/z5813nfvnM1fHjxzVt2jR17txZfn5+uvTSS9WrVy+tXr3abcwPP/zQ9fPeqlUrDR48WN9++22ta9m6datGjRqlVq1aKTAwUElJSTp69Ggt/1cAoOEjXAHARaK0tFQHDx50O4zSrl07SdLixYvldDpPWfvVV18pPj5eH374oZKTk/Xss89qyJAh+te//uWq2bhxo3r37q0vv/xSEydO1JQpU7Rjxw5df/31WrduXY0x77vvPn3zzTdKTU11PUf22muvaeDAgWrRooXmzJmjKVOm6JtvvlGvXr20c+fOU87xvffek7+/v/785z+f1vqnTp2q8ePHKzw8XHPnztWtt96q+fPnq2/fvjp+/Lhb7Q8//KA//elPio+P15NPPimTyaRhw4YpJydHw4YN04ABAzR79myVl5frz3/+sw4fPlzj/W6//XYdO3ZM6enpGjBggJ577jmNGTPGrebFF19Uu3btNGnSJM2dO1cRERG67777NG/evBrjbd68WcOHD9dNN92kZ599VrGxsXWuc9q0abrhhhv0/PPP6/HHH9fvfvc7FRYWumo++OADWSwWHThwQFOnTpXVatWaNWt07bXX1vrzfvvtt+vw4cNKT0/X7bffroULF2ratGmn8bMOAA2QEwDQoL366qtOSbUedRk4cKCzXbt2p/0eR48edXbp0sUpydmuXTvnqFGjnK+88orT4XDUqO3Tp4+zZcuWzl27drm1V1dXu348ZMgQp6+vr3Pbtm2utn379jlbtmzp7NOnT4219erVy3nixAlX++HDh52tWrVyJicnu72H3W53BgYG1mj/tdatWztjYmJOa+0HDhxw+vr6Ovv27eusqqpytT///PNOSc7s7GxX23XXXeeU5FyyZImrbdOmTU5JTm9vb+fatWtd7atWrXJKcr766quutrS0NKck58033+w2h/vuu88pyfnll1+62o4ePVpjrhaLxdmhQwe3tnbt2jklOXNzc2vUt2vXzjly5EjX65iYGOfAgQNP8bPhdMbGxjqDg4Odhw4dcrV9+eWXTm9vb+eIESNqrOWee+5x6z906FDnpZdeesr3AICGiitXAHCRmDdvnlavXu12GMXf31/r1q3TI488Iumn2/VGjx6tsLAw3X///aqoqJAkFRcX65NPPtE999yj3/3ud25jeHl5SZKqqqr0/vvva8iQIerQoYPrfFhYmO644w59+umnKisrc+ubnJwsHx8f1+vVq1erpKREw4cPd7tS5+Pjo/j4eH300UenXE9ZWZlatmx5Wmv/4IMPVFlZqQcffNBt84fk5GQFBARoxYoVbvUtWrTQsGHDXK+7dOmiVq1a6YorrlB8fLyr/eSPt2/fXuM9x48f7/b6/vvvlyStXLnS1ebv7+/68cmrltddd522b9+u0tJSt/7t27eXxWL5zbW2atVKGzdu1JYtW2o9v3//fm3YsEGjRo3SJZdc4mqPjo7WTTfd5Da/k8aOHev2unfv3jp06FCN/8cAcDFgQwsAuEj07NnzlBtanK3AwEA9+eSTevLJJ7Vr1y7ZbDY9/fTTev755xUYGKiZM2e6gsIvdyn8teLiYh09elRdunSpce6KK65QdXW1du/erSuvvNLV/utdEE/+5f+Pf/xjre/x62fAajtf2+14tdm1a5ck1Zivr6+vOnTo4Dp/0mWXXeYKkicFBgYqIiKiRpv0022Ev9a5c2e31x07dpS3t7fbbXf//e9/lZaWpvz8/BrPMJWWlrrGl2r+/NVl+vTpGjx4sC6//HJ169ZN/fr10913363o6GhJdf9cSD/9v1u1alWNDUd+HbJbt24t6ad1/9b/JwBoaAhXAIB6a9eune655x4NHTpUHTp00D/+8Q/NnDnznL3fL6/SSFJ1dbWkn567Cg0NrVHfpMmp/3iLiorShg0bVFlZKV9fX+MmKrldYTuddudvPMMmqUZY27Ztm2688UZFRUUpIyNDERER8vX11cqVK/XMM8+4fn5O+vXPX1369Omjbdu26d1339X777+vl19+Wc8884yysrJ07733ntYYv3Y26waAhoZwBQA4Y61bt1bHjh1d27qfvM3vVNu8t2nTRs2aNdPmzZtrnNu0aZO8vb1rXOX5tY4dO0qSgoODZTab6z3vQYMGKT8/X++8846GDx9+ytqTm3ls3rzZ7TbGyspK7dix44ze/7ds2bLF7WrT1q1bVV1d7fri53/961+qqKjQe++953Zl6Lduhzwdl1xyiZKSkpSUlKQjR46oT58+mjp1qu699163n4tf27Rpk4KCgs56m3wAaMh45goA8Ju+/PLLWncf3LVrl7755hvXbWJt2rRRnz59lJ2draKiIrfak1cqfHx81LdvX7377rtut7k5HA4tWbJEvXr1+s3bxSwWiwICAjRr1qwau/VJP916eCpjx45VWFiY/va3v+m7776rcf7AgQOuK3Fms1m+vr567rnn3K62vPLKKyotLdXAgQNP+V5n4tc7/v3973+X9NN3mUk/Xw365XxKS0v16quvntX7Hjp0yO11ixYt1KlTJ9czdWFhYYqNjdWiRYvctqH/+uuv9f7772vAgAFn9f4A0NBx5QoAGomvvvpK7733nqSfroSUlpa6AkRMTIwGDRpUZ9/Vq1crLS1NN998s/7whz+oRYsW2r59u7Kzs1VRUaGpU6e6ap977jn16tVLV199tcaMGaP27dtr586dWrFihTZs2CBJmjlzplavXq1evXrpvvvuU5MmTTR//nxVVFToySef/M21BAQE6MUXX9Tdd9+tq6++WsOGDVObNm1UVFSkFStW6Nprr9Xzzz9fZ//WrVvrn//8pwYMGKDY2FjdddddiouLkyQVFhbqjTfeUEJCgqSfAmNKSoqmTZumfv366eabb9bmzZv1wgsv6Pe//73uuuuu35xvfe3YsUM333yz+vXrp/z8fL3++uu64447FBMTI0nq27evfH19NWjQIP3lL3/RkSNHtGDBAgUHB2v//v1n/L5du3bV9ddfr7i4OF1yySX6/PPP9fbbb2vChAmumqeeekr9+/dXQkKCRo8erR9//FF///vfFRgY6PbrAAAaJY/uVQgAOGsntyv/7LPPTquutuOX23HXZvv27c7U1FTnH/7wB2dwcLCzSZMmzjZt2jgHDhzo/PDDD2vUf/31186hQ4c6W7Vq5fTz83N26dLFOWXKFLeawsJCp8VicbZo0cLZrFkz5w033OBcs2ZNvdb20UcfOS0WizMwMNDp5+fn7Nixo3PUqFHOzz///JTrOWnfvn3Ohx56yHn55Zc7/fz8nM2aNXPGxcU5n3jiCWdpaalb7fPPP++MiopyNm3a1BkSEuIcN26c84cffnCrue6665xXXnlljfdp165drVucS3KOHz/e9frk9uXffPON889//rOzZcuWztatWzsnTJjg/PHHH936vvfee87o6Ginn5+fMzIy0jlnzhxndna2U5Jzx44dv/neJ8/98v/9zJkznT179nS2atXK6e/v74yKinI+8cQTzsrKSrd+H3zwgfPaa691+vv7OwMCApyDBg1yfvPNN241J9dSXFzs1n7y/+kv5wgAFwsvp5MnSgEAuBCc/BLf4uJiBQUFeXo6AIB64pkrAAAAADAA4QoAAAAADEC4AgAAAAADeDRcffLJJxo0aJDCw8Pl5eWl5cuX/2afvLw8XX311TKZTOrUqZMWLlxYo2bevHmKjIyUn5+f4uPjtX79euMnDwCAwaZOnSqn08nzVgDQQHk0XJWXlysmJqbG93nUZceOHRo4cKBuuOEGbdiwQQ8++KDuvfderVq1ylWTk5Mjq9WqtLQ0FRYWKiYmRhaLRQcOHDhXywAAAAAAXTC7BXp5eemf//ynhgwZUmfNo48+qhUrVujrr792tQ0bNkwlJSXKzc2VJMXHx+v3v/+96/tNqqurFRERofvvv1+PPfbYOV0DAAAAgMarQX2JcH5+vsxms1ubxWLRgw8+KEmqrKxUQUGBUlJSXOe9vb1lNpuVn59f57gVFRWub5+Xfgpk33//vS699FJ5eXkZuwgAAAAADYbT6dThw4cVHh4ub+9T3/jXoMKV3W5XSEiIW1tISIjKysr0448/6ocfflBVVVWtNZs2bapz3PT0dE2bNu2czBkAAABAw7d7925ddtllp6xpUOHqXElJSZHVanW9Li0t1e9+9zvt3r1bAQEBHpwZAAAAAE8qKytTRESEWrZs+Zu1DSpchYaGyuFwuLU5HA4FBATI399fPj4+8vHxqbUmNDS0znFNJpNMJlON9oCAAMIVAAAAgNN6XKhBfc9VQkKCbDabW9vq1auVkJAgSfL19VVcXJxbTXV1tWw2m6sGAAAAAM4Fj4arI0eOaMOGDdqwYYOkn7Za37Bhg4qKiiT9dLveiBEjXPVjx47V9u3bNXHiRG3atEkvvPCC3nzzTT300EOuGqvVqgULFmjRokX69ttvNW7cOJWXlyspKem8rg0AAABA4+LR2wI///xz3XDDDa7XJ597GjlypBYuXKj9+/e7gpYktW/fXitWrNBDDz2kZ599VpdddplefvllWSwWV01iYqKKi4uVmpoqu92u2NhY5ebm1tjkAgAAAACMdMF8z9WFpKysTIGBgSotLeWZKwAAAKARq082aFDPXAEAAADAhYpwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAE8Hq7mzZunyMhI+fn5KT4+XuvXr6+z9vjx45o+fbo6duwoPz8/xcTEKDc3161m6tSp8vLycjuioqLO9TIAAAAANHIeDVc5OTmyWq1KS0tTYWGhYmJiZLFYdODAgVrrJ0+erPnz5+vvf/+7vvnmG40dO1ZDhw7VF1984VZ35ZVXav/+/a7j008/PR/LAQAAANCIeTRcZWRkKDk5WUlJSeratauysrLUrFkzZWdn11r/2muvadKkSRowYIA6dOigcePGacCAAZo7d65bXZMmTRQaGuo6goKCzsdyAAAAADRiHgtXlZWVKigokNls/nky3t4ym83Kz8+vtU9FRYX8/Pzc2vz9/WtcmdqyZYvCw8PVoUMH3XnnnSoqKjrlXCoqKlRWVuZ2AAAAAEB9eCxcHTx4UFVVVQoJCXFrDwkJkd1ur7WPxWJRRkaGtmzZourqaq1evVrLli3T/v37XTXx8fFauHChcnNz9eKLL2rHjh3q3bu3Dh8+XOdc0tPTFRgY6DoiIiKMWSQAAACARsPjG1rUx7PPPqvOnTsrKipKvr6+mjBhgpKSkuTt/fMy+vfvr9tuu03R0dGyWCxauXKlSkpK9Oabb9Y5bkpKikpLS13H7t27z8dyAAAAAFxEPBaugoKC5OPjI4fD4dbucDgUGhpaa582bdpo+fLlKi8v165du7Rp0ya1aNFCHTp0qPN9WrVqpcsvv1xbt26ts8ZkMikgIMDtAAAAAID68Fi48vX1VVxcnGw2m6uturpaNptNCQkJp+zr5+entm3b6sSJE3rnnXc0ePDgOmuPHDmibdu2KSwszLC5AwAAAMCvefS2QKvVqgULFmjRokX69ttvNW7cOJWXlyspKUmSNGLECKWkpLjq161bp2XLlmn79u36z3/+o379+qm6uloTJ0501Tz88MP6+OOPtXPnTq1Zs0ZDhw6Vj4+Phg8fft7XBwAAAKDxaOLJN09MTFRxcbFSU1Nlt9sVGxur3Nxc1yYXRUVFbs9THTt2TJMnT9b27dvVokULDRgwQK+99ppatWrlqtmzZ4+GDx+uQ4cOqU2bNurVq5fWrl2rNm3anO/lAQAAAGhEvJxOp9PTk7jQlJWVKTAwUKWlpTx/BQAAADRi9ckGDWq3QAAAAAC4UBGuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAM4PFwNW/ePEVGRsrPz0/x8fFav359nbXHjx/X9OnT1bFjR/n5+SkmJka5ublnNSYAAAAAGMGj4SonJ0dWq1VpaWkqLCxUTEyMLBaLDhw4UGv95MmTNX/+fP3973/XN998o7Fjx2ro0KH64osvznhMAAAAADCCl9PpdHrqzePj4/X73/9ezz//vCSpurpaERERuv/++/XYY4/VqA8PD9fjjz+u8ePHu9puvfVW+fv76/XXXz+jMWtTVlamwMBAlZaWKiAg4GyXCQAAAKCBqk828NiVq8rKShUUFMhsNv88GW9vmc1m5efn19qnoqJCfn5+bm3+/v769NNPz3jMk+OWlZW5HQAAAABQHx4LVwcPHlRVVZVCQkLc2kNCQmS322vtY7FYlJGRoS1btqi6ulqrV6/WsmXLtH///jMeU5LS09MVGBjoOiIiIs5ydQAAAAAaG49vaFEfzz77rDp37qyoqCj5+vpqwoQJSkpKkrf32S0jJSVFpaWlrmP37t0GzRgAAABAY+GxcBUUFCQfHx85HA63dofDodDQ0Fr7tGnTRsuXL1d5ebl27dqlTZs2qUWLFurQocMZjylJJpNJAQEBbgcAAAAA1IfHwpWvr6/i4uJks9lcbdXV1bLZbEpISDhlXz8/P7Vt21YnTpzQO++8o8GDB5/1mAAAAABwNpp48s2tVqtGjhypHj16qGfPnsrMzFR5ebmSkpIkSSNGjFDbtm2Vnp4uSVq3bp327t2r2NhY7d27V1OnTlV1dbUmTpx42mMCAAAAwLng0XCVmJio4uJipaamym63KzY2Vrm5ua4NKYqKityepzp27JgmT56s7du3q0WLFhowYIBee+01tWrV6rTHBAAAAIBzwaPfc3Wh4nuuAAAAAEgN5HuuAAAAAOBiQrgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAB4PV/PmzVNkZKT8/PwUHx+v9evXn7I+MzNTXbp0kb+/vyIiIvTQQw/p2LFjrvNTp06Vl5eX2xEVFXWulwEAAACgkWviyTfPycmR1WpVVlaW4uPjlZmZKYvFos2bNys4OLhG/ZIlS/TYY48pOztb11xzjb777juNGjVKXl5eysjIcNVdeeWV+uCDD1yvmzTx6DIBAAAANAIevXKVkZGh5ORkJSUlqWvXrsrKylKzZs2UnZ1da/2aNWt07bXX6o477lBkZKT69u2r4cOH17ja1aRJE4WGhrqOoKCg87EcAAAAAI2Yx8JVZWWlCgoKZDabf56Mt7fMZrPy8/Nr7XPNNdeooKDAFaa2b9+ulStXasCAAW51W7ZsUXh4uDp06KA777xTRUVFp5xLRUWFysrK3A4AAAAAqA+P3S938OBBVVVVKSQkxK09JCREmzZtqrXPHXfcoYMHD6pXr15yOp06ceKExo4dq0mTJrlq4uPjtXDhQnXp0kX79+/XtGnT1Lt3b3399ddq2bJlreOmp6dr2rRpxi0OAAAAQKPj8Q0t6iMvL0+zZs3SCy+8oMLCQi1btkwrVqzQjBkzXDX9+/fXbbfdpujoaFksFq1cuVIlJSV688036xw3JSVFpaWlrmP37t3nYzkAAAAALiIeu3IVFBQkHx8fORwOt3aHw6HQ0NBa+0yZMkV333237r33XklS9+7dVV5erjFjxujxxx+Xt3fNrNiqVStdfvnl2rp1a51zMZlMMplMZ7EaAAAAAI2dx65c+fr6Ki4uTjabzdVWXV0tm82mhISEWvscPXq0RoDy8fGRJDmdzlr7HDlyRNu2bVNYWJhBMwcAAACAmjy6R7nVatXIkSPVo0cP9ezZU5mZmSovL1dSUpIkacSIEWrbtq3S09MlSYMGDVJGRoauuuoqxcfHa+vWrZoyZYoGDRrkClkPP/ywBg0apHbt2mnfvn1KS0uTj4+Phg8f7rF1AgAAALj4eTRcJSYmqri4WKmpqbLb7YqNjVVubq5rk4uioiK3K1WTJ0+Wl5eXJk+erL1796pNmzYaNGiQnnjiCVfNnj17NHz4cB06dEht2rRRr169tHbtWrVp0+a8rw8AAADupn1yj6engEYirU/tX+90Lnk567qfrhErKytTYGCgSktLFRAQ4OnpAAAAXDQIVzhfjApX9ckGDWq3QAAAAAC4UBGuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAM4PFwNW/ePEVGRsrPz0/x8fFav379KeszMzPVpUsX+fv7KyIiQg899JCOHTt2VmMCAAAAwNnyaLjKycmR1WpVWlqaCgsLFRMTI4vFogMHDtRav2TJEj322GNKS0vTt99+q1deeUU5OTmaNGnSGY8JAAAAAEbwaLjKyMhQcnKykpKS1LVrV2VlZalZs2bKzs6utX7NmjW69tprdccddygyMlJ9+/bV8OHD3a5M1XdMAAAAADCCx8JVZWWlCgoKZDabf56Mt7fMZrPy8/Nr7XPNNdeooKDAFaa2b9+ulStXasCAAWc8piRVVFSorKzM7QAAAACA+mjiqTc+ePCgqqqqFBIS4tYeEhKiTZs21drnjjvu0MGDB9WrVy85nU6dOHFCY8eOdd0WeCZjSlJ6erqmTZt2lisCAAAA0Jh5fEOL+sjLy9OsWbP0wgsvqLCwUMuWLdOKFSs0Y8aMsxo3JSVFpaWlrmP37t0GzRgAAABAY+GxK1dBQUHy8fGRw+Fwa3c4HAoNDa21z5QpU3T33Xfr3nvvlSR1795d5eXlGjNmjB5//PEzGlOSTCaTTCbTWa4IAAAAQGPmsStXvr6+iouLk81mc7VVV1fLZrMpISGh1j5Hjx6Vt7f7lH18fCRJTqfzjMYEAAAAACN47MqVJFmtVo0cOVI9evRQz549lZmZqfLyciUlJUmSRowYobZt2yo9PV2SNGjQIGVkZOiqq65SfHy8tm7dqilTpmjQoEGukPVbYwIAAADAueDRcJWYmKji4mKlpqbKbrcrNjZWubm5rg0pioqK3K5UTZ48WV5eXpo8ebL27t2rNm3aaNCgQXriiSdOe0wAAAAAOBe8nE6n09OTuNCUlZUpMDBQpaWlCggI8PR0AAAALhrTPrnH01NAI5HWx5jvua1PNmhQuwUCAAAAwIWKcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABLohwNW/ePEVGRsrPz0/x8fFav359nbXXX3+9vLy8ahwDBw501YwaNarG+X79+p2PpQAAAABopJp4egI5OTmyWq3KyspSfHy8MjMzZbFYtHnzZgUHB9eoX7ZsmSorK12vDx06pJiYGN12221udf369dOrr77qem0ymc7dIgAAAAA0eh6/cpWRkaHk5GQlJSWpa9euysrKUrNmzZSdnV1r/SWXXKLQ0FDXsXr1ajVr1qxGuDKZTG51rVu3Ph/LAQAAANBIeTRcVVZWqqCgQGaz2dXm7e0ts9ms/Pz80xrjlVde0bBhw9S8eXO39ry8PAUHB6tLly4aN26cDh06VOcYFRUVKisrczsAAAAAoD48Gq4OHjyoqqoqhYSEuLWHhITIbrf/Zv/169fr66+/1r333uvW3q9fPy1evFg2m01z5szRxx9/rP79+6uqqqrWcdLT0xUYGOg6IiIiznxRAAAAABoljz9zdTZeeeUVde/eXT179nRrHzZsmOvH3bt3V3R0tDp27Ki8vDzdeOONNcZJSUmR1Wp1vS4rKyNgAQAAAKgXj165CgoKko+PjxwOh1u7w+FQaGjoKfuWl5dr6dKlGj169G++T4cOHRQUFKStW7fWet5kMikgIMDtAAAAAID68Gi48vX1VVxcnGw2m6uturpaNptNCQkJp+z71ltvqaKiQnfddddvvs+ePXt06NAhhYWFnfWcAQAAAKA2Ht8t0Gq1asGCBVq0aJG+/fZbjRs3TuXl5UpKSpIkjRgxQikpKTX6vfLKKxoyZIguvfRSt/YjR47okUce0dq1a7Vz507ZbDYNHjxYnTp1ksViOS9rAgAAAND4ePyZq8TERBUXFys1NVV2u12xsbHKzc11bXJRVFQkb2/3DLh582Z9+umnev/992uM5+Pjo6+++kqLFi1SSUmJwsPD1bdvX82YMYPvugIAAABwzng5nU6npydxoSkrK1NgYKBKS0t5/goAAMBA0z65x9NTQCOR1qf2782tr/pkA4/fFggAAAAAFwPCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAS6IcDVv3jxFRkbKz89P8fHxWr9+fZ21119/vby8vGocAwcOdNU4nU6lpqYqLCxM/v7+MpvN2rJly/lYCgAAAIBGyuPhKicnR1arVWlpaSosLFRMTIwsFosOHDhQa/2yZcu0f/9+1/H111/Lx8dHt912m6vmySef1HPPPaesrCytW7dOzZs3l8Vi0bFjx87XsgAAAAA0Mk08PYGMjAwlJycrKSlJkpSVlaUVK1YoOztbjz32WI36Sy65xO310qVL1axZM1e4cjqdyszM1OTJkzV48GBJ0uLFixUSEqLly5dr2LBh53hFAADUrkfWFE9PAY3E52NneHoKQKPk0StXlZWVKigokNlsdrV5e3vLbDYrPz//tMZ45ZVXNGzYMDVv3lyStGPHDtntdrcxAwMDFR8fX+eYFRUVKisrczsAAAAAoD48Gq4OHjyoqqoqhYSEuLWHhITIbrf/Zv/169fr66+/1r333utqO9mvPmOmp6crMDDQdURERNR3KQAAAAAaOY8/c3U2XnnlFXXv3l09e/Y8q3FSUlJUWlrqOnbv3m3QDAEAAAA0Fh4NV0FBQfLx8ZHD4XBrdzgcCg0NPWXf8vJyLV26VKNHj3ZrP9mvPmOaTCYFBAS4HQAAAABQHx4NV76+voqLi5PNZnO1VVdXy2azKSEh4ZR933rrLVVUVOiuu+5ya2/fvr1CQ0PdxiwrK9O6det+c0wAAAAAOFMe3y3QarVq5MiR6tGjh3r27KnMzEyVl5e7dg8cMWKE2rZtq/T0dLd+r7zyioYMGaJLL73Urd3Ly0sPPvigZs6cqc6dO6t9+/aaMmWKwsPDNWTIkPO1LAAAAACNjMfDVWJiooqLi5Wamiq73a7Y2Fjl5ua6NqQoKiqSt7f7BbbNmzfr008/1fvvv1/rmBMnTlR5ebnGjBmjkpIS9erVS7m5ufLz8zvn6wEAAADQOHk5nU6npydxoSkrK1NgYKBKS0t5/goAYBi+5wrny4X8PVfTPrnH01NAI5HWJ9uQceqTDRr0boEAAAAAcKEgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAj4erefPmKTIyUn5+foqPj9f69etPWV9SUqLx48crLCxMJpNJl19+uVauXOk6P3XqVHl5ebkdUVFR53oZAAAAABq5Jp5885ycHFmtVmVlZSk+Pl6ZmZmyWCzavHmzgoODa9RXVlbqpptuUnBwsN5++221bdtWu3btUqtWrdzqrrzySn3wwQeu102aeHSZAAAAABoBj6aOjIwMJScnKykpSZKUlZWlFStWKDs7W4899liN+uzsbH3//fdas2aNmjZtKkmKjIysUdekSROFhoae07kDAAAAwC957LbAyspKFRQUyGw2/zwZb2+ZzWbl5+fX2ue9995TQkKCxo8fr5CQEHXr1k2zZs1SVVWVW92WLVsUHh6uDh066M4771RRUdEp51JRUaGysjK3AwAAAADqw2Ph6uDBg6qqqlJISIhbe0hIiOx2e619tm/frrfffltVVVVauXKlpkyZorlz52rmzJmumvj4eC1cuFC5ubl68cUXtWPHDvXu3VuHDx+ucy7p6ekKDAx0HREREcYsEgAAAECj0aAeRqqurlZwcLBeeukl+fj4KC4uTnv37tVTTz2ltLQ0SVL//v1d9dHR0YqPj1e7du305ptvavTo0bWOm5KSIqvV6npdVlZGwAIAAABQLx4LV0FBQfLx8ZHD4XBrdzgcdT4vFRYWpqZNm8rHx8fVdsUVV8hut6uyslK+vr41+rRq1UqXX365tm7dWudcTCaTTCbTGa4EAAAAADx4W6Cvr6/i4uJks9lcbdXV1bLZbEpISKi1z7XXXqutW7equrra1fbdd98pLCys1mAlSUeOHNG2bdsUFhZm7AIAAAAA4Bc8+j1XVqtVCxYs0KJFi/Ttt99q3LhxKi8vd+0eOGLECKWkpLjqx40bp++//14PPPCAvvvuO61YsUKzZs3S+PHjXTUPP/ywPv74Y+3cuVNr1qzR0KFD5ePjo+HDh5/39QEAAABoPDz6zFViYqKKi4uVmpoqu92u2NhY5ebmuja5KCoqkrf3z/kvIiJCq1at0kMPPaTo6Gi1bdtWDzzwgB599FFXzZ49ezR8+HAdOnRIbdq0Ua9evbR27Vq1adPmvK8PAAAAQOPh8Q0tJkyYoAkTJtR6Li8vr0ZbQkKC1q5dW+d4S5cuNWpqAAAAAHDaPHpbIAAAAABcLAhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAG8Hi4mjdvniIjI+Xn56f4+HitX7/+lPUlJSUaP368wsLCZDKZdPnll2vlypVnNSYAAAAAnC2PhqucnBxZrValpaWpsLBQMTExslgsOnDgQK31lZWVuummm7Rz5069/fbb2rx5sxYsWKC2bdue8ZgAAAAAYASPhquMjAwlJycrKSlJXbt2VVZWlpo1a6bs7Oxa67Ozs/X9999r+fLluvbaaxUZGanrrrtOMTExZzwmAAAAABjBY+GqsrJSBQUFMpvNP0/G21tms1n5+fm19nnvvfeUkJCg8ePHKyQkRN26ddOsWbNUVVV1xmNKUkVFhcrKytwOAAAAAKgPj4WrgwcPqqqqSiEhIW7tISEhstvttfbZvn273n77bVVVVWnlypWaMmWK5s6dq5kzZ57xmJKUnp6uwMBA1xEREXGWqwMAAADQ2Hh8Q4v6qK6uVnBwsF566SXFxcUpMTFRjz/+uLKyss5q3JSUFJWWlrqO3bt3GzRjAAAAAI1FE0+9cVBQkHx8fORwONzaHQ6HQkNDa+0TFhampk2bysfHx9V2xRVXyG63q7Ky8ozGlCSTySSTyXQWqwEAAADQ2HnsypWvr6/i4uJks9lcbdXV1bLZbEpISKi1z7XXXqutW7equrra1fbdd98pLCxMvr6+ZzQmAAAAABjBo7cFWq1WLViwQIsWLdK3336rcePGqby8XElJSZKkESNGKCUlxVU/btw4ff/993rggQf03XffacWKFZo1a5bGjx9/2mMCAAAAwLngsdsCJSkxMVHFxcVKTU2V3W5XbGyscnNzXRtSFBUVydv75/wXERGhVatW6aGHHlJ0dLTatm2rBx54QI8++uhpjwkAAAAA54KX0+l0enoSF5qysjIFBgaqtLRUAQEBnp4OAOAi0SNriqengEbi87EzPD2FOk375B5PTwGNRFofY77ntj7ZoEHtFggAAAAAFyrCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABigiacn0BgMHJTm6SmgkVjxr2mengIAAECjxZUrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwAAXRLiaN2+eIiMj5efnp/j4eK1fv77O2oULF8rLy8vt8PPzc6sZNWpUjZp+/fqd62UAAAAAaMQ8vltgTk6OrFarsrKyFB8fr8zMTFksFm3evFnBwcG19gkICNDmzZtdr728vGrU9OvXT6+++qrrtclkMn7yAAAAAPD/efzKVUZGhpKTk5WUlKSuXbsqKytLzZo1U3Z2dp19vLy8FBoa6jpCQkJq1JhMJrea1q1bn8tlAAAAAGjkPBquKisrVVBQILPZ7Grz9vaW2WxWfn5+nf2OHDmidu3aKSIiQoMHD9bGjRtr1OTl5Sk4OFhdunTRuHHjdOjQoTrHq6ioUFlZmdsBAAAAAPXh0XB18OBBVVVV1bjyFBISIrvdXmufLl26KDs7W++++65ef/11VVdX65prrtGePXtcNf369dPixYtls9k0Z84cffzxx+rfv7+qqqpqHTM9PV2BgYGuIyIiwrhFAgAAAGgUPP7MVX0lJCQoISHB9fqaa67RFVdcofnz52vGjBmSpGHDhrnOd+/eXdHR0erYsaPy8vJ044031hgzJSVFVqvV9bqsrIyABQAAAKBePHrlKigoSD4+PnI4HG7tDodDoaGhpzVG06ZNddVVV2nr1q111nTo0EFBQUF11phMJgUEBLgdAAAAAFAfHg1Xvr6+iouLk81mc7VVV1fLZrO5XZ06laqqKv3vf/9TWFhYnTV79uzRoUOHTlkDAAAAAGfD47sFWq1WLViwQIsWLdK3336rcePGqby8XElJSZKkESNGKCUlxVU/ffp0vf/++9q+fbsKCwt11113adeuXbr33nsl/bTZxSOPPKK1a9dq586dstlsGjx4sDp16iSLxeKRNQIAAAC4+Hn8mavExEQVFxcrNTVVdrtdsbGxys3NdW1yUVRUJG/vnzPgDz/8oOTkZNntdrVu3VpxcXFas2aNunbtKkny8fHRV199pUWLFqmkpETh4eHq27evZsyYwXddAQAAADhnPB6uJGnChAmaMGFCrefy8vLcXj/zzDN65pln6hzL399fq1atMnJ6AAAAAPCbPH5bIAAAAABcDAhXAAAAAGAAwhUAAAAAGOCMwtWJEyf0wQcfaP78+Tp8+LAkad++fTpy5IihkwMAAACAhqLeG1rs2rVL/fr1U1FRkSoqKnTTTTepZcuWmjNnjioqKpSVlXUu5gkAAAAAF7R6X7l64IEH1KNHD/3www/y9/d3tQ8dOtTty4ABAAAAoDGp95Wr//znP1qzZo18fX3d2iMjI7V3717DJgYAAAAADUm9r1xVV1erqqqqRvuePXvUsmVLQyYFAAAAAA1NvcNV3759lZmZ6Xrt5eWlI0eOKC0tTQMGDDBybgAAAADQYNT7tsCnn35a/fr1U9euXXXs2DHdcccd2rJli4KCgvTGG2+cizkCAAAAwAWv3uEqIiJCX375pXJycvTll1/qyJEjGj16tO688063DS4AAAAAoDGpV7g6fvy4oqKi9O9//1t33nmn7rzzznM1LwAAAABoUOr1zFXTpk117NixczUXAAAAAGiw6r2hxfjx4zVnzhydOHHiXMwHAAAAABqkej9z9dlnn8lms+n9999X9+7d1bx5c7fzy5YtM2xyAAAAANBQ1DtctWrVSrfeeuu5mAsAAAAANFj1DlevvvrquZgHAAAAADRo9Q5XJxUXF2vz5s2SpC5duqhNmzaGTQoAAAAAGpp6b2hRXl6ue+65R2FhYerTp4/69Omj8PBwjR49WkePHj0XcwQAAACAC169w5XVatXHH3+sf/3rXyopKVFJSYneffddffzxx/rb3/52LuYIAAAAABe8et8W+M477+jtt9/W9ddf72obMGCA/P39dfvtt+vFF180cn4AAAAA0CDU+8rV0aNHFRISUqM9ODiY2wIBAAAANFr1DlcJCQlKS0vTsWPHXG0//vijpk2bpoSEBEMnBwAAAAANRb1vC3z22WdlsVh02WWXKSYmRpL05Zdfys/PT6tWrTJ8ggAAAADQENQ7XHXr1k1btmzRP/7xD23atEmSNHz4cN15553y9/c3fIIAAAAA0BCc0fdcNWvWTMnJyUbPBQAAAAAarHo/c5Wenq7s7Owa7dnZ2ZozZ44hkwIAAACAhqbe4Wr+/PmKioqq0X7llVcqKyvLkEkBAAAAQENT73Blt9sVFhZWo71Nmzbav3//GU1i3rx5ioyMlJ+fn+Lj47V+/fo6axcuXCgvLy+3w8/Pz63G6XQqNTVVYWFh8vf3l9ls1pYtW85obgAAAABwOuodriIiIvTf//63Rvt///tfhYeH13sCOTk5slqtSktLU2FhoWJiYmSxWHTgwIE6+wQEBGj//v2uY9euXW7nn3zyST333HPKysrSunXr1Lx5c1ksFrft4wEAAADASPUOV8nJyXrwwQf16quvateuXdq1a5eys7P10EMPndEmFxkZGUpOTlZSUpK6du2qrKwsNWvWrNbnuk7y8vJSaGio6/jllxo7nU5lZmZq8uTJGjx4sKKjo7V48WLt27dPy5cvr/f8AAAAAOB01Hu3wEceeUSHDh3Sfffdp8rKSkmSn5+fHn30UaWkpNRrrMrKShUUFLj18/b2ltlsVn5+fp39jhw5onbt2qm6ulpXX321Zs2apSuvvFKStGPHDtntdpnNZld9YGCg4uPjlZ+fr2HDhtUYr6KiQhUVFa7XZWVl9VoHAAAAANT7ypWXl5fmzJmj4uJirV27Vl9++aW+//57paam1vvNDx48qKqqKrcrT5IUEhIiu91ea58uXbooOztb7777rl5//XVVV1frmmuu0Z49eyTJ1a8+Y6anpyswMNB1RERE1HstAAAAABq3eoerk1q0aKHf//73atmypbZt26bq6moj51WnhIQEjRgxQrGxsbruuuu0bNkytWnTRvPnzz/jMVNSUlRaWuo6du/ebeCMAQAAADQGpx2usrOzlZGR4dY2ZswYdejQQd27d1e3bt3qHUqCgoLk4+Mjh8Ph1u5wOBQaGnpaYzRt2lRXXXWVtm7dKkmufvUZ02QyKSAgwO0AAAAAgPo47XD10ksvqXXr1q7Xubm5evXVV7V48WJ99tlnatWqlaZNm1avN/f19VVcXJxsNpurrbq6WjabTQkJCac1RlVVlf73v/+5todv3769QkND3cYsKyvTunXrTntMAAAAAKiv097QYsuWLerRo4fr9bvvvqvBgwfrzjvvlCTNmjVLSUlJ9Z6A1WrVyJEj1aNHD/Xs2VOZmZkqLy93jTVixAi1bdtW6enpkqTp06frD3/4gzp16qSSkhI99dRT2rVrl+69915JPz0T9uCDD2rmzJnq3Lmz2rdvrylTpig8PFxDhgyp9/wAAAAA4HScdrj68ccf3W6XW7NmjUaPHu163aFDhzo3jDiVxMREFRcXKzU1VXa7XbGxscrNzXVtSFFUVCRv758vsP3www9KTk6W3W5X69atFRcXpzVr1qhr166umokTJ6q8vFxjxoxRSUmJevXqpdzc3BpfNgwAAAAARjntcNWuXTsVFBSoXbt2OnjwoDZu3Khrr73Wdd5utyswMPCMJjFhwgRNmDCh1nN5eXlur5955hk988wzpxzPy8tL06dP1/Tp089oPgAAAABQX6cdrkaOHKnx48dr48aN+vDDDxUVFaW4uDjX+TVr1qhbt27nZJIAAAAAcKE77XA1ceJEHT16VMuWLVNoaKjeeustt/P//e9/NXz4cMMnCAAAAAANwWmHK29v71PeavfrsAUAAAAAjckZf4kwAAAAAOBnhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIaFq927d+uee+4xajgAAAAAaFAMC1fff/+9Fi1aZNRwAAAAANCgnPb3XL333nunPL99+/azngwAAAAANFSnHa6GDBkiLy8vOZ3OOmu8vLwMmRQAAAAANDSnfVtgWFiYli1bpurq6lqPwsLCczlPAAAAALignXa4iouLU0FBQZ3nf+uqFgAAAABczE77tsBHHnlE5eXldZ7v1KmTPvroI0MmBQAAAAANzWmHq969e5/yfPPmzXXddded9YQAAAAAoCE67dsCt2/fzm1/AAAAAFCH0w5XnTt3VnFxset1YmKiHA7HOZkUAAAAADQ0px2ufn3VauXKlad8BgsAAAAAGpPTDlcAAAAAgLqddrjy8vKq8SXBfGkwAAAAAPzktHcLdDqdGjVqlEwmkyTp2LFjGjt2rJo3b+5Wt2zZMmNnCAAAAAANwGmHq5EjR7q9vuuuuwyfDAAAAAA0VKcdrl599dVzOQ8AAAAAaNDY0AIAAAAADEC4AgAAAAADEK4AAAAAwAAXRLiaN2+eIiMj5efnp/j4eK1fv/60+i1dulReXl4aMmSIW/uoUaNcW8efPPr163cOZg4AAAAAP/F4uMrJyZHValVaWpoKCwsVExMji8WiAwcOnLLfzp079fDDD6t37961nu/Xr5/279/vOt54441zMX0AAAAAkHQBhKuMjAwlJycrKSlJXbt2VVZWlpo1a6bs7Ow6+1RVVenOO+/UtGnT1KFDh1prTCaTQkNDXUfr1q3P1RIAAAAAwLPhqrKyUgUFBTKbza42b29vmc1m5efn19lv+vTpCg4O1ujRo+usycvLU3BwsLp06aJx48bp0KFDddZWVFSorKzM7QAAAACA+vBouDp48KCqqqoUEhLi1h4SEiK73V5rn08//VSvvPKKFixYUOe4/fr10+LFi2Wz2TRnzhx9/PHH6t+/v6qqqmqtT09PV2BgoOuIiIg480UBAAAAaJRO+0uELwSHDx/W3XffrQULFigoKKjOumHDhrl+3L17d0VHR6tjx47Ky8vTjTfeWKM+JSVFVqvV9bqsrIyABQAAAKBePBqugoKC5OPjI4fD4dbucDgUGhpao37btm3auXOnBg0a5Gqrrq6WJDVp0kSbN29Wx44da/Tr0KGDgoKCtHXr1lrDlclkkslkOtvlAAAAAGjEPHpboK+vr+Li4mSz2Vxt1dXVstlsSkhIqFEfFRWl//3vf9qwYYPruPnmm3XDDTdow4YNdV5t2rNnjw4dOqSwsLBzthYAAAAAjZvHbwu0Wq0aOXKkevTooZ49eyozM1Pl5eVKSkqSJI0YMUJt27ZVenq6/Pz81K1bN7f+rVq1kiRX+5EjRzRt2jTdeuutCg0N1bZt2zRx4kR16tRJFovlvK4NAAAAQOPh8XCVmJio4uJipaamym63KzY2Vrm5ua5NLoqKiuTtffoX2Hx8fPTVV19p0aJFKikpUXh4uPr27asZM2Zw6x8AAACAc8bj4UqSJkyYoAkTJtR6Li8v75R9Fy5c6Pba399fq1atMmhmAAAAAHB6PP4lwgAAAABwMSBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAY4IIIV/PmzVNkZKT8/PwUHx+v9evXn1a/pUuXysvLS0OGDHFrdzqdSk1NVVhYmPz9/WU2m7Vly5ZzMHMAAAAA+InHw1VOTo6sVqvS0tJUWFiomJgYWSwWHThw4JT9du7cqYcffli9e/euce7JJ5/Uc889p6ysLK1bt07NmzeXxWLRsWPHztUyAAAAADRyHg9XGRkZSk5OVlJSkrp27aqsrCw1a9ZM2dnZdfapqqrSnXfeqWnTpqlDhw5u55xOpzIzMzV58mQNHjxY0dHRWrx4sfbt26fly5ef49UAAAAAaKw8Gq4qKytVUFAgs9nsavP29pbZbFZ+fn6d/aZPn67g4GCNHj26xrkdO3bIbre7jRkYGKj4+Pg6x6yoqFBZWZnbAQAAAAD14dFwdfDgQVVVVSkkJMStPSQkRHa7vdY+n376qV555RUtWLCg1vMn+9VnzPT0dAUGBrqOiIiI+i4FAAAAQCPn8dsC6+Pw4cO6++67tWDBAgUFBRk2bkpKikpLS13H7t27DRsbAAAAQOPQxJNvHhQUJB8fHzkcDrd2h8Oh0NDQGvXbtm3Tzp07NWjQIFdbdXW1JKlJkybavHmzq5/D4VBYWJjbmLGxsbXOw2QyyWQyne1yAAAAADRiHr1y5evrq7i4ONlsNldbdXW1bDabEhISatRHRUXpf//7nzZs2OA6br75Zt1www3asGGDIiIi1L59e4WGhrqNWVZWpnXr1tU6JgAAAAAYwaNXriTJarVq5MiR6tGjh3r27KnMzEyVl5crKSlJkjRixAi1bdtW6enp8vPzU7du3dz6t2rVSpLc2h988EHNnDlTnTt3Vvv27TVlyhSFh4fX+D4sAAAAADCKx8NVYmKiiouLlZqaKrvdrtjYWOXm5ro2pCgqKpK3d/0usE2cOFHl5eUaM2aMSkpK1KtXL+Xm5srPz+9cLAEAAAAAPB+uJGnChAmaMGFCrefy8vJO2XfhwoU12ry8vDR9+nRNnz7dgNkBAAAAwG9rULsFAgAAAMCFinAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAS6IcDVv3jxFRkbKz89P8fHxWr9+fZ21y5YtU48ePdSqVSs1b95csbGxeu2119xqRo0aJS8vL7ejX79+53oZAAAAABqxJp6eQE5OjqxWq7KyshQfH6/MzExZLBZt3rxZwcHBNeovueQSPf7444qKipKvr6/+/e9/KykpScHBwbJYLK66fv366dVXX3W9NplM52U9AAAAABonj1+5ysjIUHJyspKSktS1a1dlZWWpWbNmys7OrrX++uuv19ChQ3XFFVeoY8eOeuCBBxQdHa1PP/3Urc5kMik0NNR1tG7d+nwsBwAAAEAj5dFwVVlZqYKCApnNZlebt7e3zGaz8vPzf7O/0+mUzWbT5s2b1adPH7dzeXl5Cg4OVpcuXTRu3DgdOnSoznEqKipUVlbmdgAAAABAfXj0tsCDBw+qqqpKISEhbu0hISHatGlTnf1KS0vVtm1bVVRUyMfHRy+88IJuuukm1/l+/frplltuUfv27bVt2zZNmjRJ/fv3V35+vnx8fGqMl56ermnTphm3MAAAAACNjsefuToTLVu21IYNG3TkyBHZbDZZrVZ16NBB119/vSRp2LBhrtru3bsrOjpaHTt2VF5enm688cYa46WkpMhqtbpel5WVKSIi4pyvAwAAAMDFw6PhKigoSD4+PnI4HG7tDodDoaGhdfbz9vZWp06dJEmxsbH69ttvlZ6e7gpXv9ahQwcFBQVp69attYYrk8nEhhcAAAAAzopHn7ny9fVVXFycbDabq626ulo2m00JCQmnPU51dbUqKirqPL9nzx4dOnRIYWFhZzVfAAAAAKiLx28LtFqtGjlypHr06KGePXsqMzNT5eXlSkpKkiSNGDFCbdu2VXp6uqSfno/q0aOHOnbsqIqKCq1cuVKvvfaaXnzxRUnSkSNHNG3aNN16660KDQ3Vtm3bNHHiRHXq1Mltq3YAAAAAMJLHw1ViYqKKi4uVmpoqu92u2NhY5ebmuja5KCoqkrf3zxfYysvLdd9992nPnj3y9/dXVFSUXn/9dSUmJkqSfHx89NVXX2nRokUqKSlReHi4+vbtqxkzZnDrHwAAAIBzxuPhSpImTJigCRMm1HouLy/P7fXMmTM1c+bMOsfy9/fXqlWrjJweAAAAAPwmj3+JMAAAAABcDAhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGuCDC1bx58xQZGSk/Pz/Fx8dr/fr1ddYuW7ZMPXr0UKtWrdS8eXPFxsbqtddec6txOp1KTU1VWFiY/P39ZTabtWXLlnO9DAAAAACNmMfDVU5OjqxWq9LS0lRYWKiYmBhZLBYdOHCg1vpLLrlEjz/+uPLz8/XVV18pKSlJSUlJWrVqlavmySef1HPPPaesrCytW7dOzZs3l8Vi0bFjx87XsgAAAAA0Mh4PVxkZGUpOTlZSUpK6du2qrKwsNWvWTNnZ2bXWX3/99Ro6dKiuuOIKdezYUQ888ICio6P16aefSvrpqlVmZqYmT56swYMHKzo6WosXL9a+ffu0fPny87gyAAAAAI2JR8NVZWWlCgoKZDabXW3e3t4ym83Kz8//zf5Op1M2m02bN29Wnz59JEk7duyQ3W53GzMwMFDx8fF1jllRUaGysjK3AwAAAADqw6Ph6uDBg6qqqlJISIhbe0hIiOx2e539SktL1aJFC/n6+mrgwIH6+9//rptuukmSXP3qM2Z6eroCAwNdR0RExNksCwAAAEAj5PHbAs9Ey5YttWHDBn322Wd64oknZLValZeXd8bjpaSkqLS01HXs3r3buMkCAAAAaBSaePLNg4KC5OPjI4fD4dbucDgUGhpaZz9vb2916tRJkhQbG6tvv/1W6enpuv766139HA6HwsLC3MaMjY2tdTyTySSTyXSWqwEAAADQmHn0ypWvr6/i4uJks9lcbdXV1bLZbEpISDjtcaqrq1VRUSFJat++vUJDQ93GLCsr07p16+o1JgAAAADUh0evXEmS1WrVyJEj1aNHD/Xs2VOZmZkqLy9XUlKSJGnEiBFq27at0tPTJf30fFSPHj3UsWNHVVRUaOXKlXrttdf04osvSpK8vLz04IMPaubMmercubPat2+vKVOmKDw8XEOGDPHUMgEAAABc5DwerhITE1VcXKzU1FTZ7XbFxsYqNzfXtSFFUVGRvL1/vsBWXl6u++67T3v27JG/v7+ioqL0+uuvKzEx0VUzceJElZeXa8yYMSopKVGvXr2Um5srPz+/874+AAAAAI2Dl9PpdHp6EheasrIyBQYGqrS0VAEBAWc93sBBaQbMCvhtK/41zdNTAHAKPbKmeHoKaCQ+HzvD01Oo07RP7vH0FNBIpPWp/Xtz66s+2aBB7hYIAAAAABcawhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGuCDC1bx58xQZGSk/Pz/Fx8dr/fr1ddYuWLBAvXv3VuvWrdW6dWuZzeYa9aNGjZKXl5fb0a9fv3O9DAAAAACNmMfDVU5OjqxWq9LS0lRYWKiYmBhZLBYdOHCg1vq8vDwNHz5cH330kfLz8xUREaG+fftq7969bnX9+vXT/v37Xccbb7xxPpYDAAAAoJHyeLjKyMhQcnKykpKS1LVrV2VlZalZs2bKzs6utf4f//iH7rvvPsXGxioqKkovv/yyqqurZbPZ3OpMJpNCQ0NdR+vWrc/HcgAAAAA0Uh4NV5WVlSooKJDZbHa1eXt7y2w2Kz8//7TGOHr0qI4fP65LLrnErT0vL0/BwcHq0qWLxo0bp0OHDtU5RkVFhcrKytwOAAAAAKgPj4argwcPqqqqSiEhIW7tISEhstvtpzXGo48+qvDwcLeA1q9fPy1evFg2m01z5szRxx9/rP79+6uqqqrWMdLT0xUYGOg6IiIiznxRAAAAABqlJp6ewNmYPXu2li5dqry8PPn5+bnahw0b5vpx9+7dFR0drY4dOyovL0833nhjjXFSUlJktVpdr8vKyghYAAAAAOrFo1eugoKC5OPjI4fD4dbucDgUGhp6yr5PP/20Zs+erffff1/R0dGnrO3QoYOCgoK0devWWs+bTCYFBAS4HQAAAABQHx4NV76+voqLi3PbjOLk5hQJCQl19nvyySc1Y8YM5ebmqkePHr/5Pnv27NGhQ4cUFhZmyLwBAAAA4Nc8vlug1WrVggULtGjRIn377bcaN26cysvLlZSUJEkaMWKEUlJSXPVz5szRlClTlJ2drcjISNntdtntdh05ckSSdOTIET3yyCNau3atdu7cKZvNpsGDB6tTp06yWCweWSMAAACAi5/Hn7lKTExUcXGxUlNTZbfbFRsbq9zcXNcmF0VFRfL2/jkDvvjii6qsrNSf//xnt3HS0tI0depU+fj46KuvvtKiRYtUUlKi8PBw9e3bVzNmzJDJZDqvawMAAADQeHg8XEnShAkTNGHChFrP5eXlub3euXPnKcfy9/fXqlWrDJoZAAAAAJwej98WCAAAAAAXA8IVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABLohwNW/ePEVGRsrPz0/x8fFav359nbULFixQ79691bp1a7Vu3Vpms7lGvdPpVGpqqsLCwuTv7y+z2awtW7ac62UAAAAAaMQ8Hq5ycnJktVqVlpamwsJCxcTEyGKx6MCBA7XW5+Xlafjw4froo4+Un5+viIgI9e3bV3v37nXVPPnkk3ruueeUlZWldevWqXnz5rJYLDp27Nj5WhYAAACARsbj4SojI0PJyclKSkpS165dlZWVpWbNmik7O7vW+n/84x+67777FBsbq6ioKL388suqrq6WzWaT9NNVq8zMTE2ePFmDBw9WdHS0Fi9erH379mn58uXncWUAAAAAGhOPhqvKykoVFBTIbDa72ry9vWU2m5Wfn39aYxw9elTHjx/XJZdcIknasWOH7Ha725iBgYGKj4+vc8yKigqVlZW5HQAAAABQHx4NVwcPHlRVVZVCQkLc2kNCQmS3209rjEcffVTh4eGuMHWyX33GTE9PV2BgoOuIiIio71IAAAAANHIevy3wbMyePVtLly7VP//5T/n5+Z3xOCkpKSotLXUdu3fvNnCWAAAAABqDJp5886CgIPn4+MjhcLi1OxwOhYaGnrLv008/rdmzZ+uDDz5QdHS0q/1kP4fDobCwMLcxY2Njax3LZDLJZDKd4SoAAAAAwMNXrnx9fRUXF+fajEKSa3OKhISEOvs9+eSTmjFjhnJzc9WjRw+3c+3bt1doaKjbmGVlZVq3bt0pxwQAAACAs+HRK1eSZLVaNXLkSPXo0UM9e/ZUZmamysvLlZSUJEkaMWKE2rZtq/T0dEnSnDlzlJqaqiVLligyMtL1HFWLFi3UokULeXl56cEHH9TMmTPVuXNntW/fXlOmTFF4eLiGDBniqWUCAAAAuMh5PFwlJiaquLhYqampstvtio2NVW5urmtDiqKiInl7/3yB7cUXX1RlZaX+/Oc/u42TlpamqVOnSpImTpyo8vJyjRkzRiUlJerVq5dyc3PP6rksAAAAADgVj4crSZowYYImTJhQ67m8vDy31zt37vzN8by8vDR9+nRNnz7dgNkBAAAAwG9r0LsFAgAAAMCFgnAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAAQhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFwBAAAAgAEIVwAAAABgAMIVAAAAABiAcAUAAAAABiBcAQAAAIABCFcAAAAAYADCFQAAAAAYgHAFAAAAAAYgXAEAAACAATwerubNm6fIyEj5+fkpPj5e69evr7N248aNuvXWWxUZGSkvLy9lZmbWqJk6daq8vLzcjqioqHO4AgAAAADwcLjKycmR1WpVWlqaCgsLFRMTI4vFogMHDtRaf/ToUXXo0EGzZ89WaGhoneNeeeWV2r9/v+v49NNPz9USAAAAAECSh8NVRkaGkpOTlZSUpK5duyorK0vNmjVTdnZ2rfW///3v9dRTT2nYsGEymUx1jtukSROFhoa6jqCgoHO1BAAAAACQ5MFwVVlZqYKCApnN5p8n4+0ts9ms/Pz8sxp7y5YtCg8PV4cOHXTnnXeqqKjolPUVFRUqKytzOwAAAACgPjwWrg4ePKiqqiqFhIS4tYeEhMhut5/xuPHx8Vq4cKFyc3P14osvaseOHerdu7cOHz5cZ5/09HQFBga6joiIiDN+fwAAAACNk8c3tDBa//79ddtttyk6OloWi0UrV65USUmJ3nzzzTr7pKSkqLS01HXs3r37PM4YAAAAwMWgiafeOCgoSD4+PnI4HG7tDofjlJtV1FerVq10+eWXa+vWrXXWmEymUz7DBQAAAAC/xWNXrnx9fRUXFyebzeZqq66uls1mU0JCgmHvc+TIEW3btk1hYWGGjQkAAAAAv+axK1eSZLVaNXLkSPXo0UM9e/ZUZmamysvLlZSUJEkaMWKE2rZtq/T0dEk/bYLxzTffuH68d+9ebdiwQS1atFCnTp0kSQ8//LAGDRqkdu3aad++fUpLS5OPj4+GDx/umUUCAAAAaBQ8Gq4SExNVXFys1NRU2e12xcbGKjc317XJRVFRkby9f764tm/fPl111VWu108//bSefvppXXfddcrLy5Mk7dmzR8OHD9ehQ4fUpk0b9erVS2vXrlWbNm3O69oAAAAANC4eDVeSNGHCBE2YMKHWcycD00mRkZFyOp2nHG/p0qVGTQ0AAAAATttFt1sgAAAAAHgC4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwAAeD1fz5s1TZGSk/Pz8FB8fr/Xr19dZu3HjRt16662KjIyUl5eXMjMzz3pMAAAAADCCR8NVTk6OrFar0tLSVFhYqJiYGFksFh04cKDW+qNHj6pDhw6aPXu2QkNDDRkTAAAAAIzg0XCVkZGh5ORkJSUlqWvXrsrKylKzZs2UnZ1da/3vf/97PfXUUxo2bJhMJpMhYwIAAACAETwWriorK1VQUCCz2fzzZLy9ZTablZ+ff17HrKioUFlZmdsBAAAAAPXhsXB18OBBVVVVKSQkxK09JCREdrv9vI6Znp6uwMBA1xEREXFG7w8AAACg8fL4hhYXgpSUFJWWlrqO3bt3e3pKAAAAABqYJp5646CgIPn4+MjhcLi1OxyOOjerOFdjmkymOp/hAgAAAIDT4bErV76+voqLi5PNZnO1VVdXy2azKSEh4YIZEwAAAABOh8euXEmS1WrVyJEj1aNHD/Xs2VOZmZkqLy9XUlKSJGnEiBFq27at0tPTJf20YcU333zj+vHevXu1YcMGtWjRQp06dTqtMQEAAADgXPBouEpMTFRxcbFSU1Nlt9sVGxur3Nxc14YURUVF8vb++eLavn37dNVVV7leP/3003r66ad13XXXKS8v77TGBAAAAIBzwaPhSpImTJigCRMm1HruZGA6KTIyUk6n86zGBAAAAIBzgd0CAQAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwABNPD0BAI1DvHWGp6eARmJdxhRPTwEA0Ehx5QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxwQYSrefPmKTIyUn5+foqPj9f69etPWf/WW28pKipKfn5+6t69u1auXOl2ftSoUfLy8nI7+vXrdy6XAAAAAKCR83i4ysnJkdVqVVpamgoLCxUTEyOLxaIDBw7UWr9mzRoNHz5co0eP1hdffKEhQ4ZoyJAh+vrrr93q+vXrp/3797uON95443wsBwAAAEAj5fFwlZGRoeTkZCUlJalr167KyspSs2bNlJ2dXWv9s88+q379+umRRx7RFVdcoRkzZujqq6/W888/71ZnMpkUGhrqOlq3bn0+lgMAAACgkfJouKqsrFRBQYHMZrOrzdvbW2azWfn5+bX2yc/Pd6uXJIvFUqM+Ly9PwcHB6tKli8aNG6dDhw7VOY+KigqVlZW5HQAAAABQHx4NVwcPHlRVVZVCQkLc2kNCQmS322vtY7fbf7O+X79+Wrx4sWw2m+bMmaOPP/5Y/fv3V1VVVa1jpqenKzAw0HVERESc5coAAAAANDZNPD2Bc2HYsGGuH3fv3l3R0dHq2LGj8vLydOONN9aoT0lJkdVqdb0uKysjYAEAAACoF49euQoKCpKPj48cDodbu8PhUGhoaK19QkND61UvSR06dFBQUJC2bt1a63mTyaSAgAC3AwAAAADqw6PhytfXV3FxcbLZbK626upq2Ww2JSQk1NonISHBrV6SVq9eXWe9JO3Zs0eHDh1SWFiYMRMHAAAAgF/x+G6BVqtVCxYs0KJFi/Ttt99q3LhxKi8vV1JSkiRpxIgRSklJcdU/8MADys3N1dy5c7Vp0yZNnTpVn3/+uSZMmCBJOnLkiB555BGtXbtWO3fulM1m0+DBg9WpUydZLBaPrBEAAADAxc/jz1wlJiaquLhYqampstvtio2NVW5urmvTiqKiInl7/5wBr7nmGi1ZskSTJ0/WpEmT1LlzZy1fvlzdunWTJPn4+Oirr77SokWLVFJSovDwcPXt21czZsyQyWTyyBoBAAAAXPw8Hq4kacKECa4rT7+Wl5dXo+22227TbbfdVmu9v7+/Vq1aZeT0AAAAAOA3efy2QAAAAAC4GBCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMQLgCAAAAAAMQrgAAAADAAIQrAAAAADAA4QoAAAAADEC4AgAAAAADEK4AAAAAwACEKwAAAAAwAOEKAAAAAAxAuAIAAAAAAxCuAAAAAMAAhCsAAAAAMADhCgAAAAAMcEGEq3nz5ikyMlJ+fn6Kj4/X+vXrT1n/1ltvKSoqSn5+furevbtWrlzpdt7pdCo1NVVhYWHy9/eX2WzWli1bzuUSAAAAADRyHg9XOTk5slqtSktLU2FhoWJiYmSxWHTgwIFa69esWaPhw4dr9OjR+uKLLzRkyBANGTJEX3/9tavmySef1HPPPaesrCytW7dOzZs3l8Vi0bFjx87XsgAAAAA0Mh4PVxkZGUpOTlZSUpK6du2qrKwsNWvWTNnZ2bXWP/vss+rXr58eeeQRXXHFFZoxY4auvvpqPf/885J+umqVmZmpyZMna/DgwYqOjtbixYu1b98+LV++/DyuDAAAAEBj0sSTb15ZWamCggKlpKS42ry9vWU2m5Wfn19rn/z8fFmtVrc2i8XiCk47duyQ3W6X2Wx2nQ8MDFR8fLzy8/M1bNiwGmNWVFSooqLC9bq0tFSSVFZWdsZr+6Xjxyt+uwgwgFG/Zs+FqgquHOP8uKA/Bz/y5wHOjwv5c3CsvNLTU0AjYdTn4OQ4TqfzN2s9Gq4OHjyoqqoqhYSEuLWHhIRo06ZNtfax2+211tvtdtf5k2111fxaenq6pk2bVqM9IiLi9BYCXCACA+d4egqAxwW+MMvTUwA8LtD6lKenAHjcbP3D0PEOHz6swMDAU9Z4NFxdKFJSUtyuhlVXV+v777/XpZdeKi8vLw/OrPEqKytTRESEdu/erYCAAE9PB/AIPgdo7PgMAHwOLgROp1OHDx9WeHj4b9Z6NFwFBQXJx8dHDofDrd3hcCg0NLTWPqGhoaesP/lfh8OhsLAwt5rY2NhaxzSZTDKZTG5trVq1qs9ScI4EBATwGwkaPT4HaOz4DAB8Djztt65YneTRDS18fX0VFxcnm83maquurpbNZlNCQkKtfRISEtzqJWn16tWu+vbt2ys0NNStpqysTOvWratzTAAAAAA4Wx6/LdBqtWrkyJHq0aOHevbsqczMTJWXlyspKUmSNGLECLVt21bp6emSpAceeEDXXXed5s6dq4EDB2rp0qX6/PPP9dJLL0mSvLy89OCDD2rmzJnq3Lmz2rdvrylTpig8PFxDhgzx1DIBAAAAXOQ8Hq4SExNVXFys1NRU2e12xcbGKjc317UhRVFRkby9f77Ads0112jJkiWaPHmyJk2apM6dO2v58uXq1q2bq2bixIkqLy/XmDFjVFJSol69eik3N1d+fn7nfX04MyaTSWlpaTVu1wQaEz4HaOz4DAB8DhoaL+fp7CkIAAAAADglj3+JMAAAAABcDAhXAAAAAGAAwhUAAAAAGIBwBQAAAAAGIFzhvPr888914MABT08DAAAAMBzhCufNvHnz1LNnT33//feengrgMdXV1Z6eAuBRtX0G2LgYjc0vPwdlZWUenAmMRrjCeTF//nz97W9/01tvvaWoqChPTwfwiOrqatf39i1dulSFhYU6ceKEh2cFnD+//Ay8/fbb+te//iVJ8vLy8uS0gPPql5+D5557TpmZmdq6dauHZwWjEK5wzmVnZ+v+++/XO++8o1tvvdXVvmnTJg/OCji/nE6n6w/TlJQUWa1WrV+/Xj/++KOHZwacH7/8DEycOFETJ07U3r175XA43GqAi90vPwczZ85Up06d5Ofn5+FZwShNPD0BXNw2btyohx9+WAMHDtTAgQNd7bfccouOHz+ud955R76+vh6cIXB+nPyX+dmzZys7O1srV65U9+7d+fWPRuPkZ+Cpp57SokWLtHz5ciUkJNSocTqdXMnCRW/hwoVasmSJVq9erZiYGElSZWWl7Ha7fve730kSn4UGiitXOKdatWqlv/zlL9q2bZtmz54tSUpMTNR3332n559/nr9Y4qL3y/vqKyoq9N///leTJk1SXFycHA6HVq1apVtuuUWzZs1SQUGBB2cKnBu//AxUVVVp9erVmjRpkhISErRjxw699957uu222zR69GhVVFS4AhZwMfn1s4bFxcWKjY1VTEyMtmzZohdeeEFXX321LBaLZs2aJYnbZRsqrlzhnGrbtq0mTJggX19fLV68WC+//LJatmyp1atXKywszNPTA86pEydOqEmTn36b/eKLL3TVVVdp69atCgoK0ttvv63XX39dP/zwg5o2baolS5bo0KFDuuqqq+Tl5cUfqrgo/PJWwNdff13x8fG69NJLtXr1al166aVasmSJjh07pqCgIH3wwQe6/fbb9e677/LrHxedk5+DOXPmKCQkRFVVVdq3b5/uueceFRYWKioqSn/605/UokULPffcc7r99tvVqVMnD88aZ4IrVzBcSUmJ7Ha763Xbtm2VnJys2267TRUVFbr++utdwaqqqspT0wTOqbfeekszZsyQJD300EMaPXq0JCkzM1MffPCBxo8fr+7du2vGjBn64IMP1K9fP+3cuVPe3t78xRIXherqatev5SeffFKTJk3S0aNH9cc//lGSNG7cOPXo0UNPPPGE3nzzTf3lL3/huRNcdH55xWrRokWaO3eurr32Wt19992yWCzav3+/xo4dq+nTp2v27Nm65ppr1KFDB7Vo0cKDs8bZ4MoVDJWTk6MXXnhBO3bsUPfu3TV16lTFxcXpsssu01/+8hdJ0ptvvqnWrVsrNTVVPj4+qqqqko+Pj4dnDhirrKxMM2bMUF5enjZs2KD//Oc/kiSLxaKCggJVVFQoIiJC0k9/+H799dfq3LmzJ6cMGOrkv9R/88032rhxo+bNm6eYmBjFxMQoMTFRZWVluuyyy1z1H374If9Sj4vOyc/BBx98oKKiIk2bNs31e/0TTzyhyspK+fn5yel06scff1RmZqZat26t4OBgT04bZ4ErVzDM/Pnzde+998psNuvRRx/Vhg0bNGnSJB0/flySFB4err/85S+6/fbbtXTpUs2cOVOSCFa4KI0ePVp/+MMf9J///Ed33323oqOj5XQ65XQ6FRwcrIiICB0+fFjvv/++Bg8erL179+qZZ56RxI5puHi88cYbslgs+s9//uP2l8WAgABddtllOnLkiD799FP17dtXBw4c0PPPPy+JzwAuHk6nU3v37lXfvn2Vlpbmtjuml5eX/Pz8dOTIEb3++usaOnSoioqKtHz5cnl7e/O9iA0U4QqGeOWVV/TXv/5Vr7/+uqZMmaLx48drxIgRstls+vzzz1114eHhuvfee5WYmKi5c+dq4cKFnps0YLCTfyE8+d9evXpp0qRJevHFFzVt2rQaOz9t2bJF8+bNU3V1tQoLC9WkSRNVVVVxWyAuGn/+85/1+9//Xjt37tSHH36oY8eOSfr5M/Kf//xHL730kpo3b66CggI+A7go/PLPAi8vL7Vt21afffaZAgMDZbPZtGXLFkk/b1hx4sQJffvtt7r88sv1+eefq2nTpjpx4oTrqhcaFi8n/zyEs1RSUqKoqCgFBwfriy++cF2JuvHGG/XRRx9p6dKlkn66HapZs2Zq2rSp7Ha7VqxYoVGjRnHlCheF48ePq2nTppKk8vJyNW/e3HVuwYIFGjt2rNLS0jRlyhTXH6iffPKJoqKiFBQUJG9vb7cNMICG5pdfjCr9vKHLiRMndMstt2jbtm1KS0vTkCFD3HaK3bhxo6644go+A7go/PJz8P3338tkMunEiRMKDAxUfn6+/vjHP2ro0KGaM2eO69ZwSfrxxx/l5+cnLy8vHpdo4AhXMMSaNWs0ZMgQ9e3bV6+99ppuu+02ffHFFxoyZIhatGihhQsXKjQ0VM2bN9ctt9yiO+64Q5dccokk8ZsIGrTPPvtMMTExrr8sPvPMM1q3bp18fHz017/+VTExMfLz89PLL7+scePGaeLEibrjjjtcD/e///778vLyqvEXU6Ah+eWv34ULF6qwsFA//vij+vTpo7vvvlsnTpzQ4MGDtW/fPk2aNEmDBw+u8VUcfAbQ0P3y7oTZs2fLZrPp+++/V1hYmKZPn66rr75aa9eu1Q033KBbb71V6enpbgHr12OggXICBlmzZo2zVatWzsDAQGd0dLRz586drnMVFRXON99803nbbbc5b7zxRmdVVZUHZwoYIzU11RkZGelcvny50+l0OufOnets2bKl02q1Ojt37uzs3r27c/78+c4jR444nU6n87XXXnP6+Pg4u3bt6oyNjXVWVlZ6cvqA4R555BHnZZdd5hwzZowzJSXF6eXl5Zw+fbrT6XQ6jx8/7hw4cKAzLi7OuWjRIufx48c9PFvg3Jg0aZIzKCjI+cYbbzhXrFjhjI2NdQYHBzsPHDjgdDqdzrVr1zqbN2/u7N+/v9PhcHh4tjAa/0QEwyQkJGjVqlUKCAhQ27ZtFRISIumnW0N8fX1122236c0339Tq1avl7e3NA8to8B5++GF17NhRs2bN0rJly/T111/rX//6l+bOnavvvvtO0dHRmj9/vl577TWVl5frrrvu0saNG/XSSy+poKDAdV89cDGw2WzKycnRm2++qfnz5+u6666TJNeOgE2aNNE///lPeXt766OPPuL2P1yUioqK9MEHHygnJ0fDhg1TVVWVdu7cqalTp6pNmzY6fvy44uPjtWLFCv34448KCgry9JRhMG4LRL04T3G5+uQtHWvXrlX//v1lsVj00ksvKSAgwO38yV9yXPZGQ3by2ZDy8nINHDhQhw8fVkVFhd544w11795d0k+3vI4aNUrffPONxowZozvuuEMtW7Z0jcEtsWjIfvl7upeXl1577TUtWbJE//d//6d33nlHo0aN0ty5czVmzBiVlpZq06ZNio+Pd21YwS2AuBj8+u9FX3zxhW666Sbt2rVLH3/8sRITE/XUU09p7NixOnr0qF5++WUlJia6/gFa4pbYiw3/J1EvXl5eOnHihI4ePepqO7lV6MnfGP7whz9o5cqVWr16tcaNG6fS0lK3815eXgQrNGjV1dWuf3Vv3ry5/vWvfyksLEybNm3SmjVrXFejfHx8tGjRInXv3l0zZ86UzWZzG4dghYbq2LFjrt/TS0pKJEktW7ZURUWFsrOzlZSUpKeeekpjxoyRJH388cd65plntGfPHvn4+LDNNC4K33//vevvMzk5OZKkDh066JprrtHs2bM1bNgwzZ07V2PHjpUkbdu2TR999JG+++47ST/vKkiwurjwfxOnzel0qqqqSjfffLOefvpplZWVSfrpN4UlS5boT3/6k6s2ISFBK1as0BtvvKGMjAxPTRk4J07+Qbhq1Sp9+eWXatmypXJycnTDDTdowYIFWrFihStgeXt7Kzs7W2PGjNGgQYM8OW3AECtWrND8+fMlSWPHjtU111yjyspKRUZG6ujRo7rvvvuUkpLi+gvljz/+6NpuvW3btq5x+AslGrJ///vfMpvN2r9/vx566CHde++92rNnj1q2bKnmzZvriSee0NixY13/wFBeXq5HH31UlZWVuvbaayVxB8/FitsCUW9Lly7V5MmTNW7cOP3tb3/Tu+++q5EjRyo1NVVWq9WtduPGjerSpQv31uOi8MtbNz799FPdc889uuGGG/Twww+rc+fOOnz4sG6++WaVl5fr8ccf18CBA2v82udWQDR09913n959911dccUV+vLLL5WXl6crr7xSkjRv3jw98cQTuuWWWzRgwAB5e3vrmWeekd1ud32P1aluLwcairKyMkVFRalp06YqKSnRJ598opiYGEk/3Tbeu3dvlZaWqk+fPgoNDVVeXp6+//571/O23Ap48SJc4Yz885//1COPPKLevXvrrbfeUmZmpu6999466/nuEjR0v/wL4VNPPSWHw6ElS5bohx9+0KhRo/TXv/5VV1xxhQ4fPqzBgwfr2LFj+utf/6rbb7+dP0Bx0UlISNC6dev06KOPasaMGW6/v8+dO1erV6/Whx9+qPj4eF166aV666231LRpU/5xAReFk99r+PDDDysjI0Pdu3fX8uXL1a5dO9fv98ePH9fkyZP1v//9T02aNNHll1+u2bNnu777jb8TXbwIV6iX6upqOZ1O+fj46LHHHtNTTz2lW265Ra+//rpMJpOnpwecE85ffXfJrFmzlJOTo6CgIP373//WG2+8IbPZrAceeEBdunTR4cOHde211yo+Pl4LFizw8OyBs3fyM1BRUaETJ07ovvvuU2VlpT777DP99a9/1d13363WrVu76svLy7V7926FhISoVatWrud1+QslGrJfX3XNzc1Vy5YtdddddykkJEQLFixQt27dVF1d7faPCL/8knn+geHiR7hCvZz8jWXZsmW65557dMcdd+j//u//dP/992vMmDFq0aKFp6cIGGbVqlWyWCyu1z/++KP69++vXr16aebMma72zMxMzZo1S7feeqsefPBBdenSRUePHpXJZOIPUTR4v7x96dd/MRw/frxWrlyphx56yC1gORwOdkPDReWXv4Z3794tk8kkp9OpkJAQFRcXq0ePHgoLC1N2dra6du0qSfr73/+u+++///+1d+dxNab/48dfp84pKUSIsQ1iMGNvLBHGTrLvkewVYwxDlsk6doYpprImxl5i0mBMso6mlYlRsg1jpyJpOXX//vDrfGuYz/fzncnkHO/nf+7Nu8fjvs99va/7ut5XUYYtioB0IYn/Vf6eGpVKxZEjRxg6dChr1qzB1dWVAwcOMGXKFNLS0pg2bRpmZmZFHLEQ/9y8efO4ceMGnTt31t3/xsbGmJqa6qpl5vXET548mbi4OPbs2YNGo2HSpEnY2NgA0ksp9Fv+BqWPjw+nTp0iPT2devXqsXjxYtatW8ekSZPw9vYmKysLR0dHJkyYQGZmJqdOndK9PySxEvpMURTdPbxgwQKOHDnCgwcPsLa2Zvz48QwfPpy4uDhsbW1xcXHB1dWVffv2kZCQgLu7u7wD3jHyaydecfDgQX755Rd+//134H+q2eTm5pKbm0tcXBxbtmzB1dUVRVHo1asXixYt4sKFCxQrVqwoQxei0AwdOpSNGzeiUqmIj48HwMTEhA8++IDdu3fzxx9/oFardeWkq1WrRr169Th58iQ//PADgG4IrRD6Kq9BOWPGDBYuXIiNjQ1du3Zl6dKluLi4AODl5UWvXr1Yv3493bt359mzZ7plB6RwhTAEeffx3Llz8fLy4ssvv2TXrl2ULl2aESNGkJSUROnSpYmOjsbExITNmzeTmZnJ5cuXMTY2lmUH3jEyLFAUEBsbS9OmTenSpQtmZma0bNmSsWPHYmlpqTsmf0/86xYElkpQwpDs378fT09PvvjiC11jslmzZqSnpxMUFIS1tTUWFhYMHDiQUaNGcfToUQIDA7ly5Yp8xRUGITIyEicnJzZu3EibNm04cuQIffr04ZtvvmHs2LG6406fPk1WVhZt27bF2NhY5lgJg/L48WMGDBjAtGnT6NatGyEhIQwfPpwlS5bg6urKixcvMDMzIzMzk0ePHvHee+/JXMN3lHy5EgXUr18fOzs73n//fUaOHImvry/Ozs64ubmRnJxMRkYGxsbG5M/J/5xISWIlDEmVKlX48MMP2bJlCwEBAcDLhMvS0pLWrVvTrl07GjRowPnz53FwcMDe3p5SpUqRk5NTxJELUTgePHiAhYUFbdq0ITg4mP79+7N69WrGjh1LamoqBw8eBKB169a0b98eY2NjcnJypEEpDEp6ejrnz5/HxsaGw4cPM2TIEF1ilZGRwdq1a7l8+TKmpqZUqlQJlUpVYMF58e6Q5Ero5PWuDBkyBGNjYxwdHTl16hQTJ07k8uXLNGjQgC+++ILjx48XmIMlhKF43dANW1tbZs+eTaVKlfD19WXHjh1UqlSJ06dPs2jRIpycnBg9ejSXL18G4Mcff8Ta2lrmmAiDUaVKFSwsLPj6669xdnZm5cqVjB8/HoDz58+zceNGEhMTC5wjw2GFPnvdoC4rKys6dOiAl5cXAwcOZNWqVbqFsn///XdOnz7N1atXC5wj74F3kwwLFK+IjIykc+fObN68mT59+pCTk0OjRo1Qq9V8+OGH7N27l7Zt2zJjxgzat29f1OEKUSjyT9z39/fn+vXrXLt2jU8//ZRmzZqRmJjIvHnz+P333xk3bhzOzs4Fzr927RqrVq1i165dhIeHU79+/aL4M4T42/6qot+1a9cYPXo0Z8+excPDgwULFgCQkZFB//79KVGiBDt27JDONmEQ8j8HT548Qa1WU7JkSQA8PDxYsWIFY8eOxdfXF5VKxdOnTxkyZAhZWVkcPnxYOhaEJFfvuoSEBFJSUsjKysLe3l633dPTk9u3b7N06VK6dOlC6dKlCQ4OpkSJEhw+fJigoCD8/PzkR0TovT/PG5w+fTo7duygS5cuPH/+nMDAQJYuXcrUqVM5f/48y5cv5/bt2zg5OTFu3Djg5Qv4hx9+wNfXl7Vr19KwYcMi+3uE+Dvyz5X18vLi6tWr5ObmsnjxYkqUKMEPP/yAq6srzZo1o3379lhaWrJp0yYePHhATEyMrriL9NQLQzF37lz279+PhYUF7du31y2/4ezszNGjR2nVqhWWlpZcuXKF1NRUoqKi0Gg08hwISa7eZTt27ODbb7+lXLlydO/enTFjxuherqGhocydO5dbt27RoEEDtm7dSsWKFV8pViFlpoW+y8rKwsTEBIDvv/8ed3d3QkJCaNiwIVFRUTRr1ozdu3czYMAAAH799VemT5/O+++/j4+Pj+46z58/R6vVUqpUqSL5O4QoDIsWLeLrr7+mQ4cOREVFoSgKwcHBNGzYkODgYPbs2cPRo0dp2LAh1tbWbN26FY1GI5P2hUHx9/fH09OTadOm8fvvv7N+/Xp69uzJ9u3bgZcdEL/99hvPnj2jXr16TJ8+HbVaLc+BACS5emdt3bqVCRMmsH79elq0aEGNGjVeOWbw4MEcO3aMhIQErKysiiBKId6sH3/8ER8fHwICArCwsMDf35+QkBD27dvHjh07cHV1ZdmyZbi5ufH06VOePHnC+++/z5UrV6hZsyZGRkbSSyn02p/v38mTJ9O3b1/atGlDcnIyAwcO5LfffiMkJIRGjRqRk5NDcnIyFhYWuqU3pEEp9N2fn4Ndu3aRk5ODk5MTWVlZHDlyhGHDhtGjRw++++67115DOptFHmkRvIOio6OZN28ea9asYejQobrEKi/PzpvU7+rqio2NDXFxcQX2C2EofvnlF6Kjo/nll18AuHfvHg8ePODYsWO4ubnpEiuAffv2sXTpUp49e0atWrUksRJ6L//9GxERwbFjx7h79y4lSpQA0A0Hr1evHj179uT8+fMYGxtTtmxZXWKlKIokVkKv5V8gOCAgAG9vb1atWsXjx4+Bl+sbdu/ene+++45Dhw7pluT4M0msRB5pFbyDLl++TIUKFejevXuB7XnD/fJ+ZBo1akR2djbbtm0rsF8IQzFz5kysra11E/SHDx/Os2fP6Ny5M4sXL9YlVi9evCA4OJicnBwsLCx050tiJfRZ3v07bdo0OnfujKurK3v37iUmJoasrCwAzM3N2b9/Px9++CHNmjXjypUrBa4h7wWhz/JPdfD09GTs2LHs2rWLxMREDh06xJMnT4CXiVO3bt347rvvCAgIYNGiRUUZtnjLScvgHRQVFUVKSgrvvffeK/vyvk4lJSVx9+5d3N3dSUpKkq9WwmCkpKTovs4aGRnh6+tLbGwsixcvplKlSjg7O/Phhx8SGxtLUlISR48epV+/fty8eRMfHx9UKpU8D0Kv5b9/w8LCOHnyJHv27GHv3r306NGDWbNmER4eTnZ2NvAywdq7dy/u7u6vHUIuhL7KS6yuXr1KTEwMP//8MyEhIYSEhBAZGYm7uzupqanAywSra9eunD59Gg8Pj6IMW7zlJLl6B1lYWPDkyRPS0tIACix2qlKpyMnJYf369fz4448MGjSIkydPSoNSGISgoCA6dOjA2rVrefHiBQC1atVizJgxHDhwgEuXLjF27FhcXFyIjo6mQYMGzJw5E2NjY6KiolCr1eTk5EhvvdBrefdvQEAAwcHBtGnThi5dutC4cWMOHjyIra0tzs7OHD9+HK1WC7x8b6xevVq3QLAQhmLVqlX07t2bzMxMqlSpQunSpbG3tyc0NJSjR48yfvx4nj59CrxMsOzs7HTFK4R4HUmu3gFXr17l0qVLxMbGAjBkyBBSU1OZOnUq8PLHIq+HEuDZs2dcvnyZ0qVLY2FhgZGR0StVAoXQN1qtlvj4eC5evEhQUBAtW7bk/PnzlChRgrFjx3L79m02b96MhYUFn376KdHR0Zw5c4bQ0FAOHjyoq4gm4+qFodizZw9r164lNjaWjIwM3fZDhw5ha2vLqFGjCA0NfSWZkmdAGBIHBwfu37/P2bNnCywC3KJFC3744Qd++ukn+vfvz/PnzwucJ3MNxV+R5MrAbdu2jd69e9OmTRvs7e1ZtmwZ9erVY8KECWzZsoWJEycCoNFogJcT+ocNG0ZKSgpDhw7VXUcSK6Hv1Go1vXv3pm7dugwbNoxBgwYxdOhQ5s6dS7FixfDz8+Prr7/m1KlTmJiYYGRkRKNGjbC2tkalUpGbmysvU6G3XjfyICQkhDFjxnD58mW2b99eoPEYEhJC5cqV2bBhgyRTwmDkDQnPoygKderUISIiAjMzM+bNm0dSUpJuf/PmzQkMDMTY2BgzM7N/O1yhp6QUuwHz9fXl008/xcfHB3NzcyIiIvDy8mL37t106tSJWbNmsWnTJurWrUvbtm15+vQply9fJisri3PnzqHRaKS0qNB7KSkpWFpa6v7t5+fHnDlzSExMJCoqiv379xMeHs6QIUOIjIwkLS2Nbdu2UbFixaILWohClL8qYFZWFjk5OQUaioMHD+bChQtMnz6dgQMHUrx48deeK4Q+y38vX79+nRcvXlCnTh1UKhUqlYrExESaN2+OnZ0d33zzDTY2Nv/xGkL8FUmuDNS+ffsYOHAgp0+fxs7ODoDbt2/To0cPbGxs2LdvH/fv3ycqKgpvb2+ePHlC5cqVadq0KR4eHrIYnjAIoaGheHt7M3z48AJfYseMGUPx4sVZtWoVz58/58SJE7i5uaEoCvfv3ycwMJA+ffoUYeRCFI78jcEVK1Zw7tw54uPjmTRpEm3atKF+/frAywTr119/xcPDg759+xaoiikNSqHv8t/Dc+fOZffu3aSkpGBlZcXChQtp164dZcqUISEhgZYtW9K6dWuWL19OnTp1ijhyoY/k19IApaenExERAaArI5qbm0vlypWpUqUKpqam5OTkYG1tjYODA4cPHyY8PJygoCBmz56tm7QviZXQd+np6RgbGzNhwgTGjx/PpUuXgJfzDhMTE4mOjsbS0pJevXpx7tw5Bg8eTO/evenZs2cRRy5E4chrUM6aNYsVK1ZgZ2eHi4sLX3/9NatWreLcuXPAy0VTGzZsyOeff86pU6deew0h9FXePTx//nw2bNjA0qVLuXHjBmXKlGH27Nns3buXJ0+e8MEHH3Du3DlCQkLYtGlTEUct9JYiDNL169eVqVOnKiVKlFC2b9+uKIqi7Nu3T1GpVMrx48d1x+Xm5hZRhEL8O+7evavs2bNHKV++vGJra6ssXLhQyc3NVdzc3BR7e/sCx6anp+ueCa1WWxThClHoAgMDlZo1ayq//PKLoiiKcu7cOUWlUik1a9ZUBg0apERGRuqO9fT0lHtfGIz8bZyYmBilRYsWSmhoqKIoivLjjz8qJUuWVJo1a6aULVtW8fPzUx49eqQoiqLcvHlTyc7OLpKYhf6TYYEG7NatW6xevZpNmzYxYsQItm/fzrJlyxg7dqwM8xAG66/u7Xv37rFgwQLCwsIoW7YsCxcuZNSoUbi6ur6yZoki1TGFHsv/DGRmZnLu3DkiIyP54osv+P7773F2duabb77B3NycoUOHMmDAAMaMGUO7du1015D5tkLf5f8df/ToEVqtlqNHj+Lk5MTp06cZOHAgX331FWPHjqVly5akpqYyevRoxowZQ6lSpQBkeoT4WyS5MnC3bt3im2++Ye3atQwePBh/f38URUFRFEmuhMHJ36gMDw/n8ePHtG3bllKlSqHRaEhPTycuLo558+YRHR1N8eLFKVGiBIGBgdStW7eIoxeicM2cORMbGxscHBwwNjZGrVbTs2dPHB0dmT59Orm5udSrV4/k5GQ+/fRTvvzyy6IOWYhCkT+xGjduHFeuXCEkJISMjAysrKwYMmQI5cqV063dNmjQIE6fPk27du3Yvn27dK6Jf0TScQNXpUoVJk6ciEqlYv369XTt2pXBgwcXdVhCvBF5iZWHhwfr16/H1NQUlUrFkiVLcHR0xMrKCjs7O44ePcq6devw8/PD0tKSDz74oIgjF+Kfy9+gDAsL49tvv+XHH3+kQoUKANy8eZN79+5Rq1Yt4OXX3FatWtGhQwd5LwiDkvcc3L9/nxs3bjBv3jzMzc0xNzdHq9Xy8OFD3n//fd07Q6PRcPDgQRo3boxKpZLRC+IfkeTqHfD+++8zadIkcnNzcXd3Jz09nVGjRhV1WEIUmrwXoaIoJCQkcPLkSUJCQvjwww+ZOXMmCxYs4NmzZzg5OVGmTBkAJkyYQKdOnbCxscHIyEiGygq9l9cY9PX1JTs7m1mzZtGsWTPd/vT0dMzMzDh16hRarRZ/f3+ysrIYMmQIKpVKhgIKg+Ll5cWOHTuoUKECTZo00W1Xq9VUrFhRVzHwwoULpKSk0KhRI3kXiEIhd48eu3fvHpmZmf/VsVWqVGHy5Mn06dOHXbt2veHIhPj35Obm6hqVz58/x8zMDDs7O+zs7LC0tMTHx4cePXqwevVqduzYQXJysu7c2rVry8tUGJSUlBTWr1/PZ599xo0bN4D/WUC4bt26jB8/nmPHjjF79myeP39OaGiormNCEithKLKysjA2NubevXtcvnyZEiVKAOjaTNu2baNdu3a6L1hxcXEYGxvLu0AUCplzpae2bdvGV199xapVq+jatet/PeHywYMHlC1bVn48hMGZO3cuR44cISkpiVq1ahESEoKVlZVu/2effUZoaCijR49mwoQJupetEIbm8uXLeHh4EBkZyalTp6hZsybZ2dloNBoAfv/9d1QqFZUqVcLIyEgm7Qu9l3/0Ql5n25MnTzhw4ACffvopgwcPZuPGjQBkZGRQrFgxoOA8XXkORGGR5EoPHTt2jJEjR+p+FDZs2EDHjh3/Tz8K0jsj9F3+l+jOnTuZOHEi8+bN4+TJk5w5c4Zhw4YxdepUrK2tdeeMGDGC9PR09uzZI+Pphd778+943rC+3Nxcrl69ysiRI7lz5w5nzpyhYsWKBRKsv7qGEPom/z384MEDihUrhqmpKaampiQnJxMUFMSMGTMYOHAg69atA15+2TIxMdFdQ+ZYicIkyZWeef78OStXruTu3busXLmSoUOHEhERwdatW//PCZYQhuDw4cMcOXIEW1tbnJycAJgzZw6hoaF07tyZyZMnU758ed3xeS9ieZkKfZa/Qblhwwaio6N59uwZQ4cOxcHBAYCrV6/i7OzM/fv3OXXqFBUrVpT7XhiU/M/BsmXLOHDgAJmZmZQrV46tW7dibW1NSkoKQUFBzJo1i/79+7N27doijloYOumu0jPFixenU6dODB8+HAsLCw4ePEizZs0YMWIEx44dIzs7+5VzJH8WhuqXX35h5syZBAQEFOh9X7BgAd27d+fIkSN4e3tz9+5d3b68OVbSwBT6LO9+nzFjBgsWLCAzM5PSpUvj6OiIn58fiqJQs2ZNAgICeO+996hVqxaPHz+W+14YlLznYPbs2axevZpx48Yxb948/vjjD9q0acPVq1extLSkb9++LFmyhG+//ZaVK1cWcdTC0ElypWdUKhV2dna0atVKlzR9//33ugTrp59+Ijc3l5SUFDZs2MDz58/lZSoMVrNmzRg5ciRWVlZs3LixQBK1YMECHB0d8ff35/vvvy9wngyDEoYgICCAXbt2ERQUxJYtW3B0dATA3d2d5cuXA1CzZk02bNjAsGHDsLS0LMJohXgzjh07xg8//MC+fftwcXEBXq7xmZWVhb29PUlJSVhaWtKrVy8OHjzI559/XrQBC4MnwwL1wF+NiVcUhZycHN1QQEdHRyIjI1mzZg2rV6/GzMyMsLAwaUgKg/BX80sAvv32WwICAqhXrx6LFy/WresDsHHjRkaOHCmV0IRByczMxM/PD1NTU8aPH09ISAhOTk6sWrWK1NRUPDw88PLyws3NrUAHm5RbF4bm9OnTHD9+HE9PTw4fPoyzszPz5s2jQ4cOfPLJJ1haWhIUFESdOnV058hzIN4kSa7ecvkblAkJCZQsWRKVSlWg8Zh/knK3bt04cuQI9evXJyoqCo1GI2Pshd7L/xz4+voSERFBdnY2LVq0YOLEiQCsXbuWHTt2UKdOHZYsWVKgkAXIy1Tot9dVQ7t27RoqlQq1Wk337t0ZPXo0kydPJiYmBjs7O7Kysti6dSvDhw8v4uiFKBx/1dl8584dypcvj4ODA7a2tixatIj09HS6d+/OuXPn6NChA4cOHSqCiMW7SD5pvOXyj6vv1q0btra2tG/fHn9/f90xGo2G3Nxcnj17xosXL2jRogXR0dFoNBq0Wq0kVkLv5T0HHh4ezJkzB5VKRW5uLpMnT2bgwIGkpKQwceJEBg0aRFJSEq6urjx58qTANSSxEvoq/xzB9PR04GWyVaNGDapXr86tW7dQqVS6QhZmZma4uroSFBTEkCFDiixuIQpT/sTq2rVrXL16lWfPngHw3nvvcefOHRITE2nZsiXwsuPZ2tqaU6dOvTI0XIg3SUrLvaXy907u378ff39/Nm3aRFpaGr/++iujR4/m/v37eHh4oCgKiqLw9ddfk5SUxPXr11Gr1bJmg9Brf/7iGhkZyXfffUdgYCD29vYATJ06lU6dOjF58mT8/f357LPPSEtL4/bt2zK/RBgERVEKVEMLCwvD2NiY+vXr4+npiYWFBS9evCA+Pp7o6Giys7OZPn06Go2G3r17A7J+jzAM+TvZDh48yO+//07r1q2xt7fnyy+/pGrVqrz33nt4eHiQmprKhg0byM7OpmnTprJYvPhXybDAt1xISAjff/89NWrUwMPDQ7d9/fr1uLq6cvDgQXr06AG8nMD53nvvYWxsLC9Todfc3Nzo27cvHTp00L0Mw8LCGDlyJJGRkZQvX153jx8/fpzu3buzf/9+unbtCvxPYiYvU6HP8ncwrFq1ivnz5/PFF1+QlJREfHw8aWlpnDt3jjJlyjB16lRWr15NjRo1KFmyJBERETIsXBiE/L/j27dvZ8aMGaxbt46cnBx+/vlnAgMDcXBwwNvbm7i4OKZMmcKTJ0+oVKkSwcHButE98i4Q/xZJrt5i58+fZ9y4cSQkJDB16lQ8PT11X6lyc3NxcnLC1NSUTZs2FVgYUn5EhL774IMP0Gq1+Pv706pVK4yMjIiPj6dx48bs37+fHj166Kpl3r9/n1atWrF48WIGDRqku4Y0KoWhiIyMxMvLi4EDB+oqAl64cAE3NzfS0tKIiIigWLFiREVFkZ2dTbNmzaSTTRickydPEhgYSPXq1Zk8eTIAT548Ye/evaxYsYL58+fr1jq8e/cuFSpUQKVSyXMg/nXSAn+L/DnPbdiwIRMnTqR69eoEBARw4cIFVCqVbgJz6dKlefToUYHECqTMtNBfubm5wMviLZUqVcLZ2ZlTp06RmZlJnTp1cHJyYunSpYSFhemeBXNzc4oVK/bKtSSxEoYgMDCQMWPGcOrUqQJFWj766COWL1+OVqvVzSextbWlZcuWGBsbF6gkK4Q+UxSFxMREunXrhre3N/fv39ftK1OmDAMHDqR27dqcPXtWt71ixYq60QvyHIh/m7TC3xL5e9k3b97M/PnzARg+fDjTp0+nQoUKzJo1i0uXLqFSqXjx4gWXLl16pSKaEIbi0KFDaDQaZsyYwblz51Cr1YwbNw5ra2smTJjAypUrCQgIoH///mg0Gvr371/UIQtR6Fq1akWdOnW4c+cO+/bt03XCGRkZ0aBBAzIzM7l27dor50kBF2EoVCoVtWvXJjg4mEqVKhEeHk5UVJRuf+nSpfnggw9ISEggOzu7wLnS2SyKgqTzb4H8w/giIiI4cuQIR48exdraGldXV4YMGUJ2djbe3t7Y2dnRtGlTypUrR2pqKn5+foAMgRKGIe85mDJlCrdv38bKyooLFy4wevRo/P39ad26NWZmZuzdu5fly5djY2ND+fLliYyM1PXWS6NSGIqcnBwqVKjAt99+i5GREWFhYfj4+ODu7g68rBRrbm6OqalpEUcqxJuT177p1KkTGzZsYOzYsXh5eeHq6oqdnR0pKSlERERQt27dV0byCFEUZM7VW8TDw4OoqCjMzc11jcXPP/+cqVOnArB7925WrFiBSqXCzc2NUaNGAQXXuRJC323YsIHp06dz7NgxypUrh1arZciQIdy/f5/t27fTunVrAFJSUjAxMcHMzEzG1Qu991cdA3mdbw8ePGDixInExMTQuHFjGjZsSHR0NJcuXeLixYty7wuDkJ6eTvHixV/Znr8DOSQkBFdXVwAaNGhAsWLF+OOPPzh58iSmpqbS2SyKnHwvfUvs3LkTX19fvvrqK/bt20dYWBg9e/bEz8+P1atXAzBo0CA+/fRTrKysOHToEElJSQDyUhUG5ebNm7Rs2ZImTZpQtWpVatSowZkzZ7CyssLNzY0TJ06QlZWFpaUlxYsX1y2sKs+B0Ff79+9nw4YNpKWlvbIvr4R0+fLlWbduHc2bNyc4OJgzZ87Qtm1bEhISUKvV5OTkFEHkQhSejRs3Ym9vz9WrV1/Zl/c7D9CjRw+2bNlCTk4Ojx8/pmfPnkRERGBqakpWVpYkVqLISXL1lkhISOCjjz6iZcuWmJiYULduXSZPnkzjxo1ZsmQJvr6+AIwYMYKhQ4fy9OlT3NzcSEhIkB8SYRDyilk8ffqU27dv6+7rjIwM1Go1Hh4eXLx4kcGDB3Pp0qUC58ozIPRVdHQ0/fr1w93dnR07dvDixYtXjslLsMqVK4eXlxd9+/bFyMiIEiVKFDhGCH2kKArPnz/nyy+/JDY2lkGDBr12HmH+BKtTp05s3ryZe/fucebMGRITEwEwMTH5V2MX4nXk17iI5TUoq1atSmpqqu5rFEDt2rVxcXHh6dOnrFq1Cm9vbwCcnZ0ZNGgQZmZmmJubF0ncQvxTefd+nrzG4bhx47hz5w4zZ84E0FUCtLCwYNKkSfTs2ZP69ev/u8EK8YY0atSIDh06UKNGDSZOnIivry+ZmZmvHJeXYFlZWeHl5UXx4sXZtm0ba9euBaSDQeivvKqvU6dOpXfv3hgbG/PJJ5/8r1+wunXrxrp16wgLC2POnDlcvnz53w5diNeS5Opf9lcNyrp16/L06VMCAgIKlBktXbo0jo6O9OjRg6CgIN2PzZgxY9i+fTuVK1f+94IXopAoiqK793ft2sW8efM4ePAgt2/f5qOPPmLmzJns3buXyZMn8+jRI5KSkli7di0WFhb4+fnpilcIoc+0Wi2KotCyZUuGDBmCl5cXU6dO5dtvv/2PCZa1tTXffvstpqamhIaGkpqaWgTRC1G46tevT2xsLMuWLaNp06Z07Njxf/2C1aNHD5YvX87FixcpVarUvx2yEK8lBS3+RfmrAu7bt4+7d++SmprKiBEjqFKlCv7+/kycOJHx48fTsWNHatWqxaRJk6hTpw79+vXD3t6eI0eO0KlTpyL+S4T4+/JPNp45cyZ+fn7Y2Nhw48YNunbtyvTp0/nggw/YsmULc+fOJSsrC3Nzc8qWLUtERIQUbxEGJyoqijZt2hAWFkZ8fDzjxo3j66+/xs3N7bWVAPPeJQ8fPiQrK4tKlSoVQdRC/DOZmZmv3N+jRo0iOzub+fPnM3LkSG7fvs2PP/5IjRo1Xjk//7skLS0NCwuLfyVuIf5XivjXTZkyRbG2tlZatGih1KxZU7GyslL8/f0VRVGUbdu2KS1atFAsLS2VGjVqKA0bNlQyMzOV5ORk5aOPPlJOnz5dxNELUTiioqKUPn36KOfOnVMURVH27Nmj2NvbK3379lXi4uIURVGUtLQ05dChQ8rx48cVrVarKIqiZGdnF1nMQvxTe/bsUVatWqWcOHGiwPaZM2cqEydOVBRFUZYtW6aoVCplzZo1SkZGxmuvk5OT88ZjFeJNWb9+vWJjY6N4e3sXaNeEhoYqHTt2VJ48eaI8fvxYadWqlVKzZk3l6tWr//F6ubm5bzpkIf5rklz9ywIDA5Xy5csr58+fV9LT0xVFUZRx48YpFSpUUPbv368oiqLcuHFDuXDhghIREaH7wZg6dapiY2Oj3L17t6hCF6LQBAQEKD179lQcHR0LNB4DAwMVe3t7pX///srZs2dfOS8vwRJCH0VHRysqlUoxNTVV6tevrwwaNEg5ceKE8vTpU+X48eNK7dq1lfv37yuKoijLly9XNBqNsnDhQiUrK6uIIxei8KSmpio1a9ZUVCqV0rt3b6VSpUrK559/roSHhyuKoigtW7ZUpk+friiKoty7d09p166dYm5urvzxxx9FGbYQ/zWZc/Uvu3//PtWrV6dWrVq64U1+fn506NCBKVOmkJ2dTbVq1ahfvz7NmjXj7NmzDBw4kG3btrF3714qVKhQxH+BEP/cw4cPiY2NJS4ujuvXr+u29+3bl88//5zHjx/z5ZdfvlIVUBYIFvqsSZMmODs7k5ubi4uLC2lpaaxcuZJOnTpRvHhxihUrxvz588nNzWXatGl4enpy5MgRWWZAGJSSJUsSGBhIrVq1ePbsGRs2bODGjRvMmTMHBwcH7OzsCAsL49atW1hbW7N9+3ZGjBiBtbV1UYcuxH9F5lz9y5YvX86aNWu4c+cOAC9evMDMzIzLly9jb2/PoUOHaNasme74u3fvsmjRItzd3alXr15RhS3E36b8xYKO/v7+LFu2jNatW/PFF1/wwQcf6Pbt2LGDM2fO4O3tLSWmhUHI/xz069eP2NhYvL29qVatGnv37iU0NJSEhAQaN25MaGiorhJs3nl/9RwJoS/Onz/PRx99pOski4uLo2PHjvTu3RtPT080Gg3z5s3jzJkzJCcnEx0dTcWKFQtc468W2xbibSLJ1Ruk1Wpf6XG8c+cO9vb2tGrVioCAAN32mJgYBg0axP79+/noo4+A/3mp5i+EIYQ+yX/v3rt3j6ysLCpUqKBbi2TdunVs2rSJ5s2b8/nnn1O7du3/eA0h9E1SUhI5OTloNBqqV6+uS5B69erF2bNn2bx5M46Ojly/fp3Y2FhsbGxo0KBBgWRKEiuh7/z9/VmwYAHz5s3D2dlZd0/HxsbSuXNn7Ozs2L17N8WKFSMpKYlixYpRuXJlufeFXpLk6g04fvw49vb2qNXqV3pZsrOz+e6771i1ahW1atViyZIlpKSksGjRIpKTkzlx4oQ0JIVByJ8UzZs3j6NHj3LhwgUGDhxIp06dGDJkCABr165ly5YttGzZUr7QCoOyefNm5s2bh4mJCTdu3GDcuHH06dNHV/G1b9++hIWFsW3bNrp37657V0iDUhiSnTt3MmrUKDZu3EivXr1eqeoXGxtLly5d+Pjjj9m5cyclS5YE5DkQ+kuSq0J2//597O3tKVmyJBERERgbG7/yBevZs2ccPXqU+fPnc+PGDSpWrIi1tTU//fQTGo1GeuqFQZkzZw6+vr74+PhQrlw5PD09efr0Ka6urowfPx6Ab7/9liVLlvDZZ5/xxRdfFHHEQvxz4eHh9OrVC29vbz7++GPi4+NZsWIFpUqVwsXFBScnJ+DlEMHw8HC2bt1K586ddV91hTAE6enpDB06lHbt2jF58mRu3LhBREQECQkJ9OzZkypVqmBlZUVsbCzdunWjZcuWbNy4ESsrq6IOXYi/TZKrQqbVavnxxx+ZPXs25ubmhIeHF0iw/twTc/nyZXJycqhbty5GRkavHUoohL46efIkEyZMwMfHh9atW3Py5Ek6d+5M06ZNSU9PZ9KkSYwcORKAwMBAevfuLePphUFYvXo1wcHBnDhxQrctIiKCZcuW8eTJEz7//HN69eoFwKBBg9i7dy+nTp2iVatWRRWyEIUuOTmZJk2asGXLFqpVq0bnzp2xtrbm9u3bZGRkMGLECCZMmEDVqlWJi4ujSZMmTJ8+naVLlxZ16EL8bfJ5pJCp1Wo6derE0qVLSU1NpV27duTk5KBWq8nOztYlVnfu3GHOnDlUrVqVDz/8ECMjI3JzcyWxEgalZs2auLi40KJFC44ePUrfvn3x8fFh165dJCcns3LlSlauXAm87ME3NjYmJyeniKMW4p8rVqwYjx8/5sGDB8DLIU7Nmzdn1qxZaDQa9uzZw8OHDwHYvXs3s2bNokWLFkUZshCFTq1WU61aNdLS0lixYgWOjo58//333LhxAw8PD4KDgzl27BgAjRo1IjExkUWLFhVx1EL8M/Ll6g3RarWEhYXxxRdfUKpUKY4fP45arSY3N5dHjx7Rv39/7t27x2+//SY99cIgnD9/nrt37wLwySefYGpqSk5ODi9evMDU1JQBAwbQoEED5s6di7GxMT179uTatWt06NCBNWvWyNh6YVBOnDiBg4MDPj4+DB8+vMBw72PHjtGlSxd++ukn2rVrV+A8Gb0gDEXeSJ2BAwcSFRVF9erVcXd3p1+/frpjxowZQ2RkJLGxsQWmQ0hVQKHP5MvVG6JWq2nfvj0rV64kNTWVTz75BEVR0Gq19OvXj0ePHnHx4kWMjY3Jzc0t6nCF+Ee2bNlCv379GDt2LKNGjcLJyYmMjAyMjY2xsLAgNzeXGzduoFKpMDY2JiMjAwsLC+bMmaNLrKSfRxiCvPu4bdu2fPrpp4wbN47jx4/rRicAdOzYkXr16vHrr7++cr4kVkKfJSUlkZCQwLVr13QdZmvWrKF8+fIcP36cp0+fFji+adOmVKtW7ZV55pJYCX0mydUblD/Bevr0KXZ2drRv357Hjx9z/vx5NBoNWq1WilcIvebn54erqysLFizg+PHjDB8+nODgYHbu3Am87IHMyMjgo48+4ueff2bGjBk4OjqSmJhI//79dcsNyJcroa9OnTrFzz//rLuP84a2enp6MnjwYBwcHAgODtYlV6mpqeTk5FC6dOmiDFuIQrV582bat2+Pg4MDtWvXxt3dnRMnTvDee++xcOFC6tSpw6JFizhz5gyPHj0iOzubAwcOUKZMmaIOXYhCJcMC/6a/quj3uu1arZbjx4/j5uaGmZkZMTExusRKeimFPjt48CC9e/dm37599O3bF4CLFy9Sv3595s6dy9y5c3VDQ86ePYuPjw9Xr16lQoUK7N69W6pjCr23a9cuhg4dSsOGDdm4cSNNmjQp0FGQmprKnDlz8PHxYcCAAVhaWpKQkMCDBw+IiYmRd4AwCH9VHbNEiRJMnDiRPn36EBUVxaRJk0hMTKRs2bJYWFiQnZ1NVFQUGo1GSq8LgyHJ1d+QvzH4yy+/oNVqyc7Opm3btn95TnZ2NjExMXz88cdSFVAYBK1Wy4wZMzh48CAuLi7MmjULgAEDBhAYGEjfvn2pUKECVlZWjB49mqpVqwKQlZWFRqNBpVLJcyD0Wnx8PC4uLjg4OBAUFIRKpWLz5s00bdr0lUbirl27OHr0KI8ePaJq1aqsXr0ajUYjc0uEQfhP1TEfP37MrFmz6NKlCwDfffcd6enpaDQahg8f/tola4TQZ5Jc/R/l71mZNWuWbqhHRkYGLVq0wM/Pj1KlSv3lOSATNYXhSElJYdmyZYSHh+Pg4EBsbCxXr15l1qxZ1K5dm23btvHrr78SGxuLubk5a9asoXfv3oAsECn037lz59i1axdTpkyhcuXK1K9fH7VazaZNm3QJVv7OuD83IKVBKQyFj48P69atIywsjPLly+t+36Oiopg5cyblypXDy8uLsmXLvnKutImEoZHk6m9atWoVS5YsITQ0FFtbW5YtW8bs2bM5e/asrpyuNB6FIctrNKakpLB48WL279/Po0ePiImJoXr16gWOCQ4O5sqVK3z++efSmBQG48WLF9y7d093v2dkZNC0aVNdgmVrawtAWloaFhYWBc6V94MwJH+3OqYQhkgmOvxNv/76K0uWLKFZs2YEBwezfPlyfHx8aNGiBRkZGQDy4hQGLa/6maWlJbNnz6Z///7UrFmTrVu36iqmabVaAHr37s20adNQq9W6bULoOzMzM11ilZWVRbFixYiNjUWr1TJ69GhiYmK4e/cubm5ubN++vcC58n4QhuCfVscUwhBJcvU3ZGVlERERgUajITw8nBEjRrBkyRLGjx+PVqtlyZIlHDhwoKjDFKJQvW5x37wXaKlSpfDw8KB9+/YcPnxYV8jCxMTklfPky5UwRCYmJmi1WkxMTIiNjSU3NxcXFxc6dOhAREQEgwcPLuoQhSgUUh1TiP9MWjn/i9dVMjMxMWHIkCFs376ds2fP4uXlxZgxYwBITk4mKirqteOKhdBX+/fv5/79+wwbNuyV4U35v2DNmjULlUrFsWPHePr0KWvWrJGx9OKdoVarycnJwcTEhNDQUKpVq0bLli0JDw/X7ZPnQeiz11XHzLunixcvzpo1ayhZsiQDBw4sUB1TrVZLB4N4Z8iXq/8gf2IVHx9PXFyc7hO4nZ0dN2/epFmzZrRs2RKAO3fu4OLiQnJyMu7u7kUWtxCFKTo6mn79+uHu7s6OHTt48eLFK8fkT7BmzpxJgwYNSE9Pl4WBxTvH2NiYhw8f0q9fP+rWrcuJEyd0S29IYiX0WXx8PCtXrsTT0xOtVsvIkSOJjo4u8DtfqlQpvvnmGwICAjA1NeXWrVvUqVOH6OhoXQeDEIZOClr8F2bMmMGWLVtQqVSULVuW7du306hRI/bt28ecOXNQFAWNRoOZmRm5ubmcPXtWSuwKg5GTk0PXrl25fv06v//+O8uWLcPd3R1TU9NXjs3rkEhLS8Pc3ByVSiUT98U7JzExkUWLFrFx40ZZ01AYDKmOKcR/R5Kr18ifFIWGhjJp0iS8vb0xMzNj2bJlxMTEsGfPHtq2bUtcXBxXrlwhMTGRunXr0qtXL1mzQRiMvOITCxYsQFEUKlWqhLu7O6tWrfrLBCt/MiWJlXgX5b/v5V0gDIVUxxTivyPJVT7Pnz/H3Nxc929/f3+ePXtGVlYWU6dO1W3v2bMn586dY9++fbRp0+aV68gXK2FooqKiaNOmDWFhYcTHxzNu3Di+/vpr3NzcXptgCSGEMFxZWVmYmJiQlZVF48aNUavVbNmyhYoVKzJ9+nS6dOnCsGHDijpMIYqEJFf/n52dHaNGjdIVpsjIyKBx48YkJCQwYcIEvL29Cxzfq1cvoqKi8Pf3p2PHjtIjIwzG3r17uXXrFra2tgU6D2bNmsWzZ8/w9vZm+fLlzJgxg9WrV+Pq6ioJlhBCvGPyvspmZWXphgVqtVq0Wi2XLl2SL7binSXJ1f/33Xff0b9/f0xNTcnMzMTU1JRHjx7h5OREQkICoaGh1KtXr8Cn7VatWmFlZcXBgweLOHohCkdMTAy2traYmJhQu3Zt6tWrh7u7O40bNyY6Oprx48dz6tQpypcvz4oVK5g9ezZz5szBw8MDjUZT1OELIYT4F+WN1Ll161aB6pgy71y8y9755CouLo5GjRrp/v3VV1+Rnp7OtGnTKF26NE+ePKFr166kpaURHBxM7dq1CyRYryvVLoQ+c3FxYceOHSxdupSwsDCMjIx48OABXl5ejB07ltatW+Pt7Y2RkRELFy7k6NGjnDx5Ur7eCiHEO+jhw4c4ODjw/Plzzp8/r1ssXr5ciXfVO50VTJs2DWdnZ44dO6bbptFoWLp0Kb6+vqSkpFCmTBkOHz6MhYUFffr04cqVKwUakflXIRdCn+X1s/j7++Po6MjatWtxc3Nj8eLFdOnShQkTJnD9+nXi4+N15dg9PT11idU73k8jhBDvpOTkZOrWrUtcXJwkVkLwjn+5unnzJv3796dUqVJMnz6dzp07A7B27VomTZrEwoULmTBhApaWljx58gQHBweuXLlCbGwsVapUKeLohSgcSUlJ5OTkoNFoqF69uq7zoFevXpw9e5bNmzfj6OjI9evXiY2NxcbGhgYNGkhVQCGEEFIdU4g/eWeTq7yxwLdv36Z37966BKtLly4AeHl5MXny5AIJ1qNHj5gxYwZ+fn4yjlgYhM2bNzNv3jxMTEy4ceMG48aNo0+fPnTq1AmAvn37EhYWxrZt2+jevbvuvpdkSgghhBDiVe9scgX/08Ny69YtevfujaWl5WsTrEWLFjF+/HjKlCmjO1cmagp9Fx4eTq9evfD29ubjjz8mPj6eFStWUKpUKVxcXHBycgKgX79+hIeHs3XrVjp37oyJiUkRRy6EEEII8XZ65+Zc5Z8fpVarycnJoUqVKgQFBZGSksKyZcs4cuQIAJMmTcLLy4vZs2fz/fffF7iOJFZC38XGxtKoUSOcnZ2pW7cuAwYMwNvbmxIlSrBhwwYOHDgAQGBgIB07dqRnz55ERkYWcdRCCCGEEG+vd2pgbP7Kfjt37iQhIYEXL17Qo0cP7O3tOXDgAL1792b58uUAdOnShYkTJ2JtbU2fPn2KMnQhCl2xYsV4/PgxDx48oHz58iiKQvPmzZk1axYzZ85kz5492NnZUa5cOXbv3k2tWrVo0aJFUYcthBBCCPHWeqe+XOUlVtOmTWPmzJlcvHiRBw8e0LZtW/z9/alcuTLBwcE8ffqUlStX6nruBwwYoKuAI4ShqFevHjdu3NB9qc0bIWxra4uHhwe7du3i4sWLuuO/+uorjI2N5TkQQgghhPgL71RyBXDgwAF27NjB3r172bt3LwMGDADQLYBauXJlgoKCSEhI4KeffipwrlTAEYYgL4lq27Ytn376KePGjeP48eMFlhXo2LEj9erV49dff33lfHkOhBBCCCFe751rJd2+fZv27dvz8ccfs2/fPkaOHImvry9OTk6kpqby8OFDbGxsiIyMpGzZskUdrhCF4tSpU6jVapo3b46RkZGuIIunpyf37t3DwcGBHTt20KNHD4yMjEhNTSUnJ4fSpUsXdehCCCGEEHrDoJOr/HOs8mi1WpKTk9mzZw9jxoxh+fLljBs3DoCQkBDCw8NZtmwZ1tbWgFQFFPpv165dDB06lIYNG7Jx40aaNGmiu6eLFy/OmjVrKFmyJAMHDmTAgAFYWlqSkJCAWq1m8ODBRRy9EEIIIYT+MNhhgfkTq1OnTvH7778D0LRpU+7fv8+IESOYO3cubm5uADx//pydO3diYmJSoLdeEiuhz+Lj41m5ciWenp5otVpGjhxJdHQ0+VdgKFWqFN988w0BAQGYmppy69Yt6tSpQ3R0tK6iphBCCCGE+N8Z5DpX+Rc4nT17Nnv37mXp0qU4ODhgamrKjBkz2LZtG+PGjaNnz56kp6ezcOFC7t27R1RUFGq1WhZJFQbh3Llz7Nq1iylTplC5cmXq16+PWq1m06ZNNG3aFJVKVaAjIm/ttzx//rcQQgghhPhrBplc5Zk3bx6+vr7s3LmTpk2bUrJkSd2+mTNn8tNPPxEVFUXz5s0pVaoU33//PRqNRoYCCoPx4sUL7t27R/Xq1QHIyMigadOmugTL1tYWgLS0NCwsLAqcKx0MQgghhBD/NwabXP3xxx84Ojoyffp0Bg8ezMOHD7l9+zZBQUHY2trSq1cvMjIyuHDhApUqVaJixYoYGRlJT70wWFlZWZiYmJCVlUXjxo1Rq9Vs2bKFihUrMn36dLp06cKwYcOKOkwhhBBCCL1lsMnVzZs36dy5M3PmzKFMmTLs2bOH+Ph4kpOTKVasGK6urkycOLHAOa8rgCGEIcnrPMjKytINC9RqtWi1Wi5duiQdC0IIIYQQ/4BBZBJ5a/PkV61aNRo2bMisWbPo3bs3VlZWLF68mMTERMqVK8fDhw9fOUcSK2Ho8gpUmJiYEBoaSnx8PKVLl+bixYtSvEIIIYQQ4h/S+27q/F+bfv31VxRFwdjYmA8//JA9e/YQHh5OmTJlaNCgQYHzTExMiiJcIYqcsbExDx8+pF+/ftStW5cTJ06gVqtlSKwQQgghxD+k18MC80+49/T05MCBA9y/f5/atWvTuXNnPD09dcc+e/aMP/74g6lTp3Lr1i1iYmKkISneWYmJiSxatIiNGzei0WgksRJCCCGEKAR6PQ4uL7FasGABfn5+rFmzhp9//pm6desyd+5cZs+erTv2wIEDODk5kZmZKev3iHderVq12Lp1qyRWQgghhBCFSO9bVDExMRw9epTdu3fzySefcOTIEXbt2sXAgQPx9vZGrVYzf/58hg0bhqWlJd26dcPY2FgalOKdlr/EujwHQgghhBCFQ6+/XAHUqVOHnj17Ymtry/Hjxxk5ciSrVq1i48aNtGnThoULF+Lu7g5Ajx49MDY2JicnRxqUQgghhBBCiEKlVxnGTz/9xIULF7h79y6enp6UKFGC4sWLM2XKFNRqNbt376Zv3744OztjampK7dq1SU9P586dOwUKX8gCwUIIIYQQQojCpjdfrjZu3MjQoUM5dOgQ27dv5+OPPyY7Oxt4OawpOzub8+fPk5qaiqmpKRkZGdy6dYuRI0cSHByMkZHRa0u2CyGEEEIIIURh0Ivkys/PDzc3N3x9fQkODubkyZOkpaURFxdHXrFDjUbDoEGDCAsLY9CgQbRv354rV64wdOhQ4GVlQVnHSgghhBBCCPGmvPWl2IODg+nbty8HDhzA0dERgBcvXtCoUSM6dOjAb7/9Rr9+/ejXrx8mJiZs376dn376iYoVK7J27Vo0Gg05OTkyFFAIIYQQQgjxRr3Vc64yMzM5cuQINWrU4Nq1a7rtTk5OPHv2jJIlS2Jubs6UKVP4448/WLJkCZ999hmfffaZ7lipCiiEEEIIIYT4N7z1X67u3r3LsmXLiIiIYPDgwZw+fZqkpCSCgoKoXr06AM7Ozhw5coSLFy9StmxZ3bn5FxkWQgghhBBCiDfprZ+EVLFiRWbMmIGtrS3ffPMNYWFhhISEUL16ddLT0wFo3bo11apVe6VghSRWQgghhBBCiH/LW59cAVSoUIEvv/wSR0dHqlevzs6dOwEoXrw4Wq2Wffv2UaNGDcqVK1fEkQohhBBCCCHeVW/9sMD87t27x6JFi/jll18YMGAAX3zxBT179uTq1aucP38etVotQwGFEEIIIYQQRUKvkit4mWAtXryY6OhokpKSsLS0JD4+Ho1GI8UrhBBCCCGEEEVG75IreJlgeXh48PDhQw4cOCCJlRBCCCGEEKLI6WVyBZCcnEypUqUwMjKSxEoIIYQQQghR5PQ2ucqTm5uLkZFe1OUQQgghhBBCGDC9T66EEEIIIYQQ4m0gn3yEEEIIIYQQohBIciWEEEIIIYQQhUCSKyGEEEIIIYQoBJJcCSGEEEIIIUQhkORKCCGEEEIIIQqBJFdCCCGEEEIIUQgkuRJCCCH+D8LDw1GpVKSkpPzX57z//vusWbPmjcUkhBDi7SDJlRBCCIPi4uKCSqXC1dX1lX0TJkxApVLh4uLy7wcmhBDC4ElyJYQQwuBUqVKFXbt28eLFC922jIwMduzYQdWqVYswMiGEEIZMkishhBAGp0mTJlSpUoWgoCDdtqCgIKpWrUrjxo112zIzM5k0aRLly5enWLFitG7dmsjIyALXCg0NpXbt2piZmfHJJ59w48aNV/6/06dPY29vj5mZGVWqVGHSpEk8f/78jf19Qggh3k6SXAkhhDBIo0aNYsuWLbp/b968mZEjRxY4Zvr06QQGBrJ161ZiYmKwsbGhS5cuPHnyBIBbt27Rt29fHB0diYuLY8yYMcyYMaPANa5evUrXrl3p168fFy5cYPfu3Zw+fZqJEye++T9SCCHEW0WSKyGEEAZp2LBhnD59mps3b3Lz5k3OnDnDsGHDdPufP3+Oj48PK1asoFu3btSrV48NGzZgZmbGpk2bAPDx8aFmzZqsWrWKDz74ACcnp1fmay1ZsgQnJycmT55MrVq1sLOzw8vLi4CAADIyMv7NP1kIIUQRUxd1AEIIIcSbUK5cORwcHPD390dRFBwcHChbtqxu/9WrV8nOzqZVq1a6bRqNhmbNmvHbb78B8Ntvv9G8efMC123ZsmWBf58/f54LFy7w3Xff6bYpikJubi7Xr1+nbt26b+LPE0II8RaS5EoIIYTBGjVqlG543rp1697I/5GWlsb48eOZNGnSK/ukeIYQQrxbJLkSQghhsLp27UpWVhYqlYouXboU2FezZk1MTEw4c+YM1apVAyA7O5vIyEgmT54MQN26dTl48GCB886dO1fg302aNOHSpUvY2Ni8uT9ECCGEXpA5V0IIIQyWsbExv/32G5cuXcLY2LjAPnNzc9zc3Jg2bRqHDx/m0qVLjB07lvT0dEaPHg2Aq6srV65cYdq0aSQkJLBjxw78/f0LXMfDw4OzZ88yceJE4uLiuHLlCgcOHJCCFkII8Q6S5EoIIYRBK1myJCVLlnztvqVLl9KvXz+GDx9OkyZNSEpK4siRI5QuXRp4OawvMDCQ4OBgGjZsiK+vL4sXLy5wjQYNGnDixAkSExOxt7encePGzJkzh/fee++N/21CCCHeLipFUZSiDkIIIYQQQggh9J18uRJCCCGEEEKIQiDJlRBCCCGEEEIUAkmuhBBCCCGEEKIQSHIlhBBCCCGEEIVAkishhBBCCCGEKASSXAkhhBBCCCFEIZDkSgghhBBCCCEKgSRXQgghhBBCCFEIJLkSQgghhBBCiEIgyZUQQgghhBBCFAJJroQQQgghhBCiEPw/0oE+ZSUiLO8AAAAASUVORK5CYII=", "text/plain": [ "<Figure size 1000x1000 with 1 Axes>" ] @@ -1590,7 +1512,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 1000x1000 with 1 Axes>" ] @@ -1605,34 +1527,34 @@ " 'Baseline Logp1 PCA+RF',\n", " '10M RandomWeights',\n", " '10M parameters',\n", - " '10M parameters BioNeMo2 re-trained',\n", + " # '10M parameters BioNeMo2 re-trained',\n", " '106M parameters'],\n", " 'f1_score_mean': [\n", " logp1_results['test_f1_score'][0],\n", " results_10m_random['test_f1_score'][0],\n", " results_10m['test_f1_score'][0],\n", - " results_10m_bnmo2['test_f1_score'][0],\n", + " # results_10m_bnmo2['test_f1_score'][0],\n", " results_106M['test_f1_score'][0]\n", " ],\n", " 'f1_score_std': [\n", " logp1_results['test_f1_score'][1],\n", " results_10m_random['test_f1_score'][1],\n", " results_10m['test_f1_score'][1],\n", - " results_10m_bnmo2['test_f1_score'][1],\n", + " # results_10m_bnmo2['test_f1_score'][1],\n", " results_106M['test_f1_score'][1]\n", " ],\n", " 'accuracy_mean': [\n", " logp1_results['test_accuracy'][0],\n", " results_10m_random['test_accuracy'][0],\n", " results_10m['test_accuracy'][0],\n", - " results_10m_bnmo2['test_accuracy'][0],\n", + " # results_10m_bnmo2['test_accuracy'][0],\n", " results_106M['test_accuracy'][0]\n", " ],\n", " 'accuracy_std': [\n", " logp1_results['test_accuracy'][1],\n", " results_10m_random['test_accuracy'][1],\n", " results_10m['test_accuracy'][1],\n", - " results_10m_bnmo2['test_accuracy'][1],\n", + " # results_10m_bnmo2['test_accuracy'][1],\n", " results_106M['test_accuracy'][1]\n", " ]\n", "}\n", @@ -1665,7 +1587,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1679,9 +1601,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/docs/docs/user-guide/getting-started/development.md b/docs/docs/user-guide/getting-started/development.md index ce97a78cbe..ae8a0997f7 100644 --- a/docs/docs/user-guide/getting-started/development.md +++ b/docs/docs/user-guide/getting-started/development.md @@ -136,7 +136,7 @@ of the model. The fine-tuning steps will be application-specific, but a general 6. **Run inference**: Once the model is fine-tuned, use it to make predictions on new, unseen data. For more information on fine-tuning a model, refer to the [ESM-2 Fine-tuning -Tutorial](../examples/bionemo-esm2/finetune.md). +Tutorial](../examples/bionemo-esm2/finetune.ipynb). ## Advanced Developer Documentation diff --git a/internal/Pypi_publish.md b/internal/Pypi_publish.md new file mode 100644 index 0000000000..8454fbc531 --- /dev/null +++ b/internal/Pypi_publish.md @@ -0,0 +1,23 @@ +This is an overview of how to release bionemo sub-packages. + + +1. The code should be in a sub-directory of `bionemo-framework/sub-packages`. The package should be named bionemo-<package_name>. For an example of the directory structure, see https://github.com/NVIDIA/bionemo-framework/tree/main/sub-packages/bionemo-scdl. +The directory should contain: + - a `pyproject.toml` file with the dependencies + - a `README.md` + - a `LICENSE` file + - a `VERSION` file + - the source code should be in src/bionemo/package-name. + - the test should be in tests/bionemo/package-name. The test directory structure should be the same as the source code directory structure. +2. Create some tests that can be run in a notebook within the package or as a small python script that verifies that the package is correctly installed. These can be re-purposed for QA test plan. +3. In the VERSION file in the root of the sub-package, set the package version. Currently, the sub-package versions are independent of the overall BioNeMo version. An ideal approach is to specify the bionemo sub-package versions. That the package depends on. This may create issues. For example, an issue could arise if the latest version of your sub-package depends on the newest bionemo-core, but the latest pushed version of bionemo-core does not have these changes. It may be necessary to update bionemo-core then, but before updating another package, it should be tested and its authors should be consulted. +4. Make sure that the directory dist doesn’t exist or is empty. +5. Run `python -m build .` +6. Create a test-pypi and pypi account if you don’t have one at: https://test.pypi.org/ and https://pypi.org/ +7. Upload to test-pypi with: + `twine upload --repository-url https://test.pypi.org/legacy/ dist/* --non-interactive -u $TWINE_USERNAME -p $TWINE_PASSWORD` +8. In a clean python environment, download the package from test-pypi: +`pip install --index-url https://test.pypi.org/simple/ --no-deps package-name` +9. Run the code/notebooks from step 3. +10. If everything looks good, upload it to the actual pypi repository: `twine upload dist/* --non-interactive -u $TWINE_USERNAME -p $TWINE_PASSWORD --verbose` +11. Run steps 7 and 8 with pypi instead of test-pypi. diff --git a/pyproject.toml b/pyproject.toml index c4b9f6e6af..02f0566665 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,11 +16,13 @@ dependencies = [ # **ALL** bionemo sub-packages 'bionemo-core', 'bionemo-esm2', + 'bionemo-evo2', 'bionemo-example_model', 'bionemo-fw', 'bionemo-geneformer', 'bionemo-geometric', 'bionemo-llm', + 'bionemo-moco', 'bionemo-scdl', 'bionemo-size-aware-batching', 'bionemo-testing', @@ -36,11 +38,7 @@ dependencies = [ build = ['flash-attn', 'pip'] [tool.uv.workspace] -members = [ - "3rdparty/*", - "sub-packages/bionemo-*/", - "internal/infra-bionemo/", -] +members = ["3rdparty/*", "internal/infra-bionemo/", "sub-packages/bionemo-*/"] [tool.uv.sources] # external @@ -56,6 +54,7 @@ bionemo-fw = { workspace = true } bionemo-geneformer = { workspace = true } bionemo-geometric = { workspace = true } bionemo-llm = { workspace = true } +bionemo-moco = { workspace = true } bionemo-noodles = { workspace = true } bionemo-scdl = { workspace = true } bionemo-size-aware-batching = { workspace = true } @@ -76,6 +75,7 @@ dev-dependencies = [ "tenacity", ] no-build-isolation-package = ["flash-attn"] +cache-keys = [{ git = { commit = true } }] [tool.black] line-length = 119 @@ -113,10 +113,11 @@ convention = "google" [tool.pytest.ini_options] norecursedirs = ["3rdparty"] -addopts = ["--ignore=3rdparty"] +addopts = ["--durations-min=30.0", "--durations=0", "--ignore=3rdparty"] +markers = ["slow: marks tests as slow (deselect with '-m \"not slow\"')"] [tool.pyright] -include = ["./scripts/", "./sub-packages/", "./internal/"] +include = ["./internal/", "./scripts/", "./sub-packages/"] exclude = ["*/tests/"] executionEnvironments = [ { "root" = ".", pythonVersion = "3.10", extraPaths = [ @@ -126,11 +127,13 @@ executionEnvironments = [ # bionemo sub-packages './sub-packages/bionemo-core/src', './sub-packages/bionemo-esm2/src', + './sub-packages/bionemo-evo2/src', './sub-packages/bionemo-example_model/src', './sub-packages/bionemo-fw/src', './sub-packages/bionemo-geneformer/src', './sub-packages/bionemo-geometric/src', './sub-packages/bionemo-llm/src', + './sub-packages/bionemo-moco/src', './sub-packages/bionemo-noodles/src', './sub-packages/bionemo-scdl/src', './sub-packages/bionemo-size-aware-batching/src', diff --git a/requirements-cve.txt b/requirements-cve.txt index 357f0d6a81..e8228799f7 100644 --- a/requirements-cve.txt +++ b/requirements-cve.txt @@ -8,5 +8,3 @@ nltk>=3.9.1 pillow>=10.3.0 tornado>=6.4.2 wandb>=0.19.1 # Addresses CVE GHSA-v778-237x-gjrc -lightning<=2.4 -pytorch_lightning<=2.4 diff --git a/requirements-dev.txt b/requirements-dev.txt index ad7b93282c..77aaa3714c 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,7 +1,7 @@ ruff==0.5.1 # Needs to match the version of ruff used in .pre-commit-config.yaml. black==23.1.0 pre-commit==3.4.0 -virtualenv==20.26.3 +virtualenv==20.26.6 ipdb==0.13.11 click==8.1.7 tenacity==8.5.0 diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/load.py b/sub-packages/bionemo-core/src/bionemo/core/data/load.py index f4c8731d5b..a1789986e5 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/load.py +++ b/sub-packages/bionemo-core/src/bionemo/core/data/load.py @@ -21,11 +21,9 @@ import tempfile from dataclasses import dataclass from pathlib import Path -from typing import Literal, Optional, Sequence, TextIO +from typing import TYPE_CHECKING, Literal, Optional, Sequence, TextIO -import boto3 import nest_asyncio -import ngcsdk import pooch from botocore.config import Config from tqdm import tqdm @@ -34,6 +32,12 @@ from bionemo.core.data.resource import Resource, get_all_resources +if TYPE_CHECKING: + import ngcsdk + +logger = pooch.get_logger() + + __all__: Sequence[str] = ( "load", "default_ngc_client", @@ -46,6 +50,8 @@ def default_pbss_client(): """Create a default S3 client for PBSS.""" + import boto3 + retry_config = Config(retries={"max_attempts": 10, "mode": "standard"}) return boto3.client("s3", endpoint_url="https://pbss.s8k.io", config=retry_config) @@ -69,12 +75,33 @@ def progress_callback(bytes_transferred): s3.download_file(bucket, key, output_file, Callback=progress_callback) -def default_ngc_client() -> ngcsdk.Client: +def default_ngc_client(use_guest_if_api_key_invalid: bool = True) -> "ngcsdk.Client": """Create a default NGC client. This should load the NGC API key from ~/.ngc/config, or from environment variables passed to the docker container. """ - return ngcsdk.Client() + import ngcsdk + + client = ngcsdk.Client() + + try: + client.configure() + + except ValueError as e: + if use_guest_if_api_key_invalid: + logger.error(f"Error configuring NGC client: {e}, signing in as guest.") + client = ngcsdk.Client("no-apikey") + client.configure( + api_key="no-apikey", # pragma: allowlist secret + org_name="no-org", + team_name="no-team", + ace_name="no-ace", + ) + + else: + raise + + return client @dataclass @@ -91,7 +118,6 @@ class NGCDownloader: def __call__(self, url: str, output_file: str | Path, _: pooch.Pooch) -> None: """Download a file from NGC.""" client = default_ngc_client() - client.configure() nest_asyncio.apply() download_fns = { diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml index d93139d756..ddc5033b3e 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/esm2.yaml @@ -7,32 +7,14 @@ description: > A pretrained 650M parameter ESM2 model. See https://ngc.nvidia.com/catalog/models/nvidia:clara:esm2nv650m. -- tag: nv_3b:2.1 - ngc: "nvidia/clara/esm2nv3b:2.1" +- tag: 8m:2.0 + ngc: nvidia/clara/esm2nv8m:2.0 ngc_registry: model - pbss: "s3://general-purpose/esm2/checkpoints/3b/esm2_3b_checkpoint.tar.gz" - sha256: a79327a4054bf8d1d7075e1b3c961dbc503da02d72ed15f707d9cbbd49d181b6 # pragma: allowlist secret + pbss: s3://general-purpose/esm2/checkpoints/converted/8m/esm2_hf_converted_8m_checkpoint.tar.gz + sha256: 2957b2c36d5978d0f595d6f1b72104b312621cf0329209086537b613c1c96d16 # pragma: allowlist secret owner: Peter St John <pstjohn@nvidia.com> description: > - An ESM-2 3B model pre-trained on NVIDIA's train/test data split. - -- tag: nv_650m:2.1 - ngc: "nvidia/clara/esm2nv650m:2.1" - ngc_registry: model - pbss: "s3://general-purpose/esm2/checkpoints/650m/esm2_650m_checkpoint.tar.gz" - sha256: b83e9b5d62f1499b443817c5cd0facd3bdd4013a51a897e05e17228bf650befe # pragma: allowlist secret - owner: Peter St John <pstjohn@nvidia.com> - description: > - An ESM-2 650M model pre-trained on NVIDIA's train/test data split. - -- tag: nv_8m:2.0 - ngc: "nvidia/clara/esm2nv8m:2.0" - ngc_registry: model - pbss: "s3://general-purpose/esm2/checkpoints/8m/esm2_8m_checkpoint.tar.gz" - sha256: b4ea4d52eea8a25d2c2838617ff678f0da22d384cee195b0c192686816078dcd # pragma: allowlist secret - owner: Peter St John <pstjohn@nvidia.com> - description: > - An ESM-2 8M model pre-trained on NVIDIA's train/test data split. + A NeMo2 compatible checkpoint converted from the huggingface facebook/esm2_t6_8M_UR50D model. - tag: 650m:2.0 ngc: nvidia/clara/esm2nv650m:2.0 @@ -41,7 +23,7 @@ sha256: 0798767e843e3d54315aef91934d28ae7d8e93c2849d5fcfbdf5fac242013997 # pragma: allowlist secret owner: Farhad Ramezanghorbani <farhadr@nvidia.com> description: > - A pretrained 650M parameter ESM2 model. See https://ngc.nvidia.com/catalog/models/nvidia:clara:esm2nv650m. + A NeMo2 compatible checkpoint converted from the huggingface facebook/esm2_t33_650M_UR50D model. - tag: 3b:2.0 ngc: nvidia/clara/esm2nv3b:2.0 @@ -50,13 +32,40 @@ sha256: a2248cfed1ef39f83bd32a0e08b84c0a8f39325d383e2d92767022ff7f5260ed # pragma: allowlist secret owner: Farhad Ramezanghorbani <farhadr@nvidia.com> description: > - A pretrained 3B parameter ESM2 model. See https://ngc.nvidia.com/catalog/models/nvidia:clara:esm2nv3b. + A NeMo2 compatible checkpoint converted from the huggingface facebook/esm2_t36_3B_UR50D model. + +# - tag: nv_8m:2.1 +# ngc: "nvidia/clara/esm2nv8m:2.1" +# ngc_registry: model +# pbss: "s3://general-purpose/esm2/checkpoints/8m/esm2_8m_checkpoint.tar.gz" +# sha256: b4ea4d52eea8a25d2c2838617ff678f0da22d384cee195b0c192686816078dcd # pragma: allowlist secret +# owner: Peter St John <pstjohn@nvidia.com> +# description: > +# An ESM-2 8M model pre-trained on NVIDIA's train/test data split. + +- tag: nv_650m:2.1 + ngc: "nvidia/clara/esm2nv650m:2.1" + ngc_registry: model + pbss: "s3://general-purpose/esm2/checkpoints/650m/esm2_650m_checkpoint.tar.gz" + sha256: b83e9b5d62f1499b443817c5cd0facd3bdd4013a51a897e05e17228bf650befe # pragma: allowlist secret + owner: Peter St John <pstjohn@nvidia.com> + description: > + An ESM-2 650M model pre-trained on NVIDIA's train/test data split. + +- tag: nv_3b:2.1 + ngc: "nvidia/clara/esm2nv3b:2.1" + ngc_registry: model + pbss: "s3://general-purpose/esm2/checkpoints/3b/esm2_3b_checkpoint.tar.gz" + sha256: a79327a4054bf8d1d7075e1b3c961dbc503da02d72ed15f707d9cbbd49d181b6 # pragma: allowlist secret + owner: Peter St John <pstjohn@nvidia.com> + description: > + An ESM-2 3B model pre-trained on NVIDIA's train/test data split. - tag: fulldata_esm2_pretrain:2.0 ngc: nvidia/clara/esm2_pretrain_nemo2_data:1.0 ngc_registry: resource pbss: "s3://general-purpose/esm2/pretrain/2024_03.tar.gz" - sha256: 404d0ad8de58fa8aae96f8d9f54263a088bc7e4f7d668215afbe04c28416151b # pragma: allowlist secret + sha256: 404d0ad8de58fa8aae96f8d9f54263a088bc7e4f7d668215afbe04c28416151b # pragma: allowlist secret owner: Peter St John <pstjohn@nvidia.com> description: Full data for ESM2 pretraining. @@ -64,14 +73,14 @@ ngc: nvidia/clara/esm2_pretrain_nemo2_testdata:1.0 ngc_registry: resource pbss: "s3://general-purpose/esm2/pretrain/2024_03_sanity.tar.gz" - sha256: 006911f92bbc0ded7ea302bbdbfab4c694b409e699c32fd49de1c527a99dba3e # pragma: allowlist secret + sha256: 006911f92bbc0ded7ea302bbdbfab4c694b409e699c32fd49de1c527a99dba3e # pragma: allowlist secret owner: Peter St John <pstjohn@nvidia.com> description: Test data for ESM2 pretraining. - tag: esm2_inference_testdata:2.0 - ngc: nvidia/clara/esm2_inference_testdata:2.0 # TODO: upload to NGC + ngc: nvidia/clara/esm2_inference_testdata:2.0 # TODO: upload to NGC ngc_registry: resource pbss: "s3://bionemo-ci/test_data/esm2/artificial_protein_sequences.csv" - sha256: 14ae3acfbf82218bc9e3e53d21a5b0594ba7c0369e169c9f1034e3fe4378d175 # pragma: allowlist secret + sha256: 14ae3acfbf82218bc9e3e53d21a5b0594ba7c0369e169c9f1034e3fe4378d175 # pragma: allowlist secret owner: Farhad Ramezanghorbani <farhadr@nvidia.com> description: Test data for ESM2 inference. diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py index ee8146b5dd..8b36690a9f 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py @@ -21,6 +21,7 @@ from pathlib import Path from unittest.mock import Mock, patch +import ngcbpc.environ import pytest from bionemo.core.data.load import default_ngc_client, default_pbss_client, load @@ -110,6 +111,7 @@ def test_load_with_file(mocked_s3_download, tmp_path): ) mocked_s3_download.side_effect = lambda _1, output_file, _2: Path(output_file).write_text("test") + # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/bar", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_file() assert file_path.read_text() == "test" @@ -132,6 +134,7 @@ def write_compressed_text(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_text + # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_file() assert file_path.read_text() == "test" @@ -155,6 +158,7 @@ def write_compressed_text(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_text + # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") # Assert the file remained compressed. @@ -190,6 +194,7 @@ def write_compressed_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_dir + # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_dir() assert (file_path / "test_file").read_text() == "test" @@ -223,6 +228,7 @@ def write_tarfile_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_tarfile_dir + # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") # Assert the file stays as a tarfile. @@ -269,10 +275,20 @@ def test_default_pbss_client(): assert client.meta.endpoint_url == "https://pbss.s8k.io" -@pytest.mark.xfail(reason="Logging into NGC is not required to download artifacts in BioNeMo.") -def test_default_ngc_client(): - clt = default_ngc_client() - assert clt.api_key is not None +@patch("ngcbpc.api.authentication.Authentication.validate_api_key") +def test_default_ngc_client_raises_when_api_key_invalid(mocked_validate_api_key, monkeypatch): + monkeypatch.setattr(ngcbpc.environ, "NGC_CLI_API_KEY", "invalidapikey") # pragma: allowlist secret + mocked_validate_api_key.return_value = False + with pytest.raises(ValueError, match="Invalid apikey for NGC service location"): + default_ngc_client(use_guest_if_api_key_invalid=False) + + +@patch("ngcbpc.api.authentication.Authentication.validate_api_key") +def test_default_ngc_client_returns_guest_key_when_api_key_invalid(mocked_validate_api_key, monkeypatch): + monkeypatch.setattr(ngcbpc.environ, "NGC_CLI_API_KEY", "invalidapikey") # pragma: allowlist secret + mocked_validate_api_key.return_value = False + client = default_ngc_client() + assert client.api_key == "no-apikey" # pragma: allowlist secret @patch("bionemo.core.data.load.default_ngc_client") diff --git a/sub-packages/bionemo-esm2/pyproject.toml b/sub-packages/bionemo-esm2/pyproject.toml index aa8f7715ed..4acce854fa 100644 --- a/sub-packages/bionemo-esm2/pyproject.toml +++ b/sub-packages/bionemo-esm2/pyproject.toml @@ -22,6 +22,7 @@ bionemo-esm2-train= "bionemo.esm2.run.main:main" bionemo-esm2-recipe= "bionemo.esm2.run.recipes:main" infer_esm2 = "bionemo.esm2.scripts.infer_esm2:infer_esm2_entrypoint" train_esm2 = "bionemo.esm2.scripts.train_esm2:train_esm2_entrypoint" +finetune_esm2 = "bionemo.esm2.scripts.finetune_esm2:finetune_esm2_entrypoint" # Make sure that the tokenizer files are included along with the python files during installation. [tool.setuptools.package-data] diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py index ac08ffb47e..8407b81fda 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/data/datamodule.py @@ -65,8 +65,8 @@ def __init__( valid_cluster_path: A path to the parquet files containing UniRef50 validation clusters. valid_database_path: A path to the sqlite file mapping UniRef50 cluster IDs to sequences. seed: Input random seed. If None, initializes randomly. Defaults to 42. - min_seq_length: Whether to pad sequences to a minimum length. If None, no extra padding is added. Defaults - to None. + min_seq_length: Whether to pad sequences to a minimum length. If None, sequences are padded to the maximum + sequence length. Defaults to None. max_seq_length: The maximum context length for the ESM transformer. Defaults to 1024. micro_batch_size: Passed to MegatronDataSampler. Defaults to 4. global_batch_size: Passed to MegatronDataSampler.. Defaults to 8. @@ -87,7 +87,7 @@ def __init__( self._valid_cluster_path = valid_cluster_path self._valid_database_path = valid_database_path self._seed = seed - self._min_seq_length = min_seq_length + self._min_seq_length = min_seq_length if min_seq_length is not None else max_seq_length self._max_seq_length = max_seq_length self._mask_prob = mask_prob self._mask_token_prob = mask_token_prob diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/convert.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/convert.py new file mode 100644 index 0000000000..06be1fa0a1 --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/convert.py @@ -0,0 +1,179 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path + +import torch +from nemo.lightning import io, teardown +from nemo.lightning.pytorch.utils import dtype_from_hf +from transformers import AutoConfig as HFAutoConfig +from transformers import AutoModelForMaskedLM + +from bionemo.esm2.data.tokenizer import BioNeMoESMTokenizer, get_tokenizer +from bionemo.esm2.model.model import ESM2Config +from bionemo.llm.lightning import BionemoLightningModule +from bionemo.llm.model.biobert.lightning import biobert_lightning_module + + +@io.model_importer(BionemoLightningModule, "hf") +class HFESM2Importer(io.ModelConnector[AutoModelForMaskedLM, BionemoLightningModule]): + """Converts a Hugging Face ESM-2 model to a NeMo ESM-2 model.""" + + def init(self) -> BionemoLightningModule: + """Initialize the converted model.""" + return biobert_lightning_module(self.config, tokenizer=self.tokenizer) + + def apply(self, output_path: Path) -> Path: + """Applies the transformation. + + Largely inspired by + https://docs.nvidia.com/nemo-framework/user-guide/latest/nemo-2.0/features/hf-integration.html + """ + source = AutoModelForMaskedLM.from_pretrained(str(self), trust_remote_code=True, torch_dtype="auto") + target = self.init() + trainer = self.nemo_setup(target) + self.convert_state(source, target) + self.nemo_save(output_path, trainer) + + print(f"Converted ESM-2 model to Nemo, model saved to {output_path}") + + teardown(trainer, target) + del trainer, target + + return output_path + + def convert_state(self, source, target): + """Converting HF state dict to NeMo state dict.""" + mapping = { + # "esm.encoder.layer.0.attention.self.rotary_embeddings.inv_freq": "rotary_pos_emb.inv_freq", + "esm.encoder.layer.*.attention.output.dense.weight": "encoder.layers.*.self_attention.linear_proj.weight", + "esm.encoder.layer.*.attention.output.dense.bias": "encoder.layers.*.self_attention.linear_proj.bias", + "esm.encoder.layer.*.attention.LayerNorm.weight": "encoder.layers.*.self_attention.linear_qkv.layer_norm_weight", + "esm.encoder.layer.*.attention.LayerNorm.bias": "encoder.layers.*.self_attention.linear_qkv.layer_norm_bias", + "esm.encoder.layer.*.intermediate.dense.weight": "encoder.layers.*.mlp.linear_fc1.weight", + "esm.encoder.layer.*.intermediate.dense.bias": "encoder.layers.*.mlp.linear_fc1.bias", + "esm.encoder.layer.*.output.dense.weight": "encoder.layers.*.mlp.linear_fc2.weight", + "esm.encoder.layer.*.output.dense.bias": "encoder.layers.*.mlp.linear_fc2.bias", + "esm.encoder.layer.*.LayerNorm.weight": "encoder.layers.*.mlp.linear_fc1.layer_norm_weight", + "esm.encoder.layer.*.LayerNorm.bias": "encoder.layers.*.mlp.linear_fc1.layer_norm_bias", + "esm.encoder.emb_layer_norm_after.weight": "encoder.final_layernorm.weight", + "esm.encoder.emb_layer_norm_after.bias": "encoder.final_layernorm.bias", + "lm_head.dense.weight": "lm_head.dense.weight", + "lm_head.dense.bias": "lm_head.dense.bias", + "lm_head.layer_norm.weight": "lm_head.layer_norm.weight", + "lm_head.layer_norm.bias": "lm_head.layer_norm.bias", + } + + # lm_head.bias + return io.apply_transforms( + source, + target, + mapping=mapping, + transforms=[_pad_embeddings, _pad_bias, _import_qkv_weight, _import_qkv_bias], + ) + + @property + def tokenizer(self) -> BioNeMoESMTokenizer: + """We just have the one tokenizer for ESM-2.""" + return get_tokenizer() + + @property + def config(self) -> ESM2Config: + """Returns the transformed ESM-2 config given the model tag.""" + source = HFAutoConfig.from_pretrained(str(self), trust_remote_code=True) + output = ESM2Config( + num_layers=source.num_hidden_layers, + hidden_size=source.hidden_size, + ffn_hidden_size=source.intermediate_size, + position_embedding_type="rope", + num_attention_heads=source.num_attention_heads, + seq_length=source.max_position_embeddings, + fp16=(dtype_from_hf(source) == torch.float16), + bf16=(dtype_from_hf(source) == torch.bfloat16), + params_dtype=dtype_from_hf(source), + ) + + return output + + +@io.state_transform( + source_key="esm.embeddings.word_embeddings.weight", + target_key="embedding.word_embeddings.weight", +) +def _pad_embeddings(ctx: io.TransformCTX, source_embed): + """Pad the embedding layer to the new input dimension.""" + nemo_embedding_dimension = ctx.target.config.make_vocab_size_divisible_by + hf_embedding_dimension = source_embed.size(0) + num_padding_rows = nemo_embedding_dimension - hf_embedding_dimension + padding_rows = torch.zeros(num_padding_rows, source_embed.size(1)) + return torch.cat((source_embed, padding_rows), dim=0) + + +@io.state_transform( + source_key="lm_head.bias", + target_key="output_layer.bias", +) +def _pad_bias(ctx: io.TransformCTX, source_bias): + """Pad the embedding layer to the new input dimension.""" + nemo_embedding_dimension = ctx.target.config.make_vocab_size_divisible_by + hf_embedding_dimension = source_bias.size(0) + output_bias = torch.zeros(nemo_embedding_dimension, dtype=source_bias.dtype, device=source_bias.device) + output_bias[:hf_embedding_dimension] = source_bias + return output_bias + + +@io.state_transform( + source_key=( + "esm.encoder.layer.*.attention.self.query.weight", + "esm.encoder.layer.*.attention.self.key.weight", + "esm.encoder.layer.*.attention.self.value.weight", + ), + target_key="encoder.layers.*.self_attention.linear_qkv.weight", +) +def _import_qkv_weight(ctx: io.TransformCTX, query, key, value): + """Pad the embedding layer to the new input dimension.""" + concat_weights = torch.cat((query, key, value), dim=0) + input_shape = concat_weights.size() + np = ctx.target.config.num_attention_heads + # transpose weights + # [sequence length, batch size, num_splits_model_parallel * attention head size * #attention heads] + # --> [sequence length, batch size, attention head size * num_splits_model_parallel * #attention heads] + concat_weights = concat_weights.view(3, np, -1, query.size()[-1]) + concat_weights = concat_weights.transpose(0, 1).contiguous() + concat_weights = concat_weights.view(*input_shape) + return concat_weights + + +@io.state_transform( + source_key=( + "esm.encoder.layer.*.attention.self.query.bias", + "esm.encoder.layer.*.attention.self.key.bias", + "esm.encoder.layer.*.attention.self.value.bias", + ), + target_key="encoder.layers.*.self_attention.linear_qkv.bias", +) +def _import_qkv_bias(ctx: io.TransformCTX, query, key, value): + """Pad the embedding layer to the new input dimension.""" + concat_biases = torch.cat((query, key, value), dim=0) + input_shape = concat_biases.size() + np = ctx.target.config.num_attention_heads + # transpose biases + # [num_splits_model_parallel * attention head size * #attention heads] + # --> [attention head size * num_splits_model_parallel * #attention heads] + concat_biases = concat_biases.view(3, np, -1) + concat_biases = concat_biases.transpose(0, 1).contiguous() + concat_biases = concat_biases.view(*input_shape) + return concat_biases diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py index 09526572ef..7104f64373 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/datamodule.py @@ -15,119 +15,27 @@ import functools -import os -from typing import Literal, Sequence, Tuple, Union +from typing import Literal, Union -import numpy as np -import pandas as pd -import torch -import torch.utils.data from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS from nemo.lightning.data import WrappedDataLoader from nemo.lightning.pytorch.plugins import MegatronDataSampler from nemo.utils import logging -from torch import Tensor -from torch.utils.data import Dataset from bionemo.core.data.multi_epoch_dataset import IdentityMultiEpochDatasetWrapper, MultiEpochDatasetResampler from bionemo.esm2.data import tokenizer -from bionemo.esm2.model.finetune.finetune_regressor import InMemorySingleValueDataset -from bionemo.esm2.model.finetune.finetune_token_classifier import InMemoryPerTokenValueDataset +from bionemo.esm2.model.finetune.dataset import ( + InMemoryPerTokenValueDataset, + InMemoryProteinDataset, + InMemorySingleValueDataset, +) from bionemo.llm.data import collate from bionemo.llm.data.datamodule import MegatronDataModule -from bionemo.llm.data.types import BertSample from bionemo.llm.utils.datamodule_utils import infer_num_samples Mode = Literal["train", "validation", "test", "predict"] - - -class InMemoryCSVDataset(Dataset): - """An in-memory dataset that tokenize strings into BertSample instances.""" - - def __init__( - self, - data_path: str | os.PathLike, - tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), - seed: int = np.random.SeedSequence().entropy, # type: ignore - ): - """Initializes a dataset for single-value regression fine-tuning. - - This is an in-memory dataset that does not apply masking to the sequence. But keeps track of <mask> in the - dataset sequences provided. - - Args: - data_path (str | os.PathLike): A path to the CSV file containing sequences. - labels (Optional[Sequence[float | str]]): An optional sequence of labels with 1:1 mapping to sequences. - tokenizer (tokenizer.BioNeMoESMTokenizer, optional): The tokenizer to use. Defaults to tokenizer.get_tokenizer(). - seed: Random seed for reproducibility. This seed is mixed with the index of the sample to retrieve to ensure - that __getitem__ is deterministic, but can be random across different runs. If None, a random seed is - generated. - """ - self.sequences, self.labels = self.load_data(data_path) - - self.seed = seed - self._len = len(self.sequences) - self.tokenizer = tokenizer - - def __len__(self) -> int: - """The size of the dataset.""" - return self._len - - def __getitem__(self, index: int) -> BertSample: - """Obtains the BertSample at the given index.""" - sequence = self.sequences[index] - tokenized_sequence = self._tokenize(sequence) - - label = tokenized_sequence if len(self.labels) == 0 else torch.Tensor([self.labels[index]]) - # Overall mask for a token being masked in some capacity - either mask token, random token, or left as-is - loss_mask = ~torch.isin(tokenized_sequence, Tensor(self.tokenizer.all_special_ids)) - - return { - "text": tokenized_sequence, - "types": torch.zeros_like(tokenized_sequence, dtype=torch.int64), - "attention_mask": torch.ones_like(tokenized_sequence, dtype=torch.int64), - "labels": label, - "loss_mask": loss_mask, - "is_random": torch.zeros_like(tokenized_sequence, dtype=torch.int64), - } - - def load_data(self, csv_path: str | os.PathLike) -> Tuple[Sequence, Sequence]: - """Loads data from a CSV file, returning sequences and optionally labels. - - This method should be implemented by subclasses to process labels for their specific dataset. - - Args: - csv_path (str | os.PathLike): The path to the CSV file containing the data. - The file is expected to have at least one column named 'sequence'. A 'label' column is optional. - - Returns: - Tuple[Sequence, Sequence]: A tuple where the first element is a list of sequences and the second element is - a list of labels. If the 'label' column is not present, an empty list is returned for labels. - """ - df = pd.read_csv(csv_path) - sequences = df["sequences"].tolist() - - if "labels" in df.columns: - labels = df["labels"].tolist() - else: - labels = [] - return sequences, labels - - def _tokenize(self, sequence: str) -> Tensor: - """Tokenize a protein sequence. - - Args: - sequence: The protein sequence. - - Returns: - The tokenized sequence. - """ - tensor = self.tokenizer.encode(sequence, add_special_tokens=True, return_tensors="pt") - return tensor.flatten() # type: ignore - - -DATASET_TYPES = Union[InMemoryPerTokenValueDataset, InMemorySingleValueDataset, InMemoryCSVDataset, None] +DATASET_TYPES = Union[InMemoryPerTokenValueDataset, InMemorySingleValueDataset, InMemoryProteinDataset, None] class ESM2FineTuneDataModule(MegatronDataModule): diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/dataset.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/dataset.py new file mode 100644 index 0000000000..9273e271f3 --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/dataset.py @@ -0,0 +1,253 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import os +from typing import Literal, Sequence + +import numpy as np +import pandas as pd +import torch +import torch.utils.data +from torch import Tensor +from torch.utils.data import Dataset + +from bionemo.esm2.data import tokenizer +from bionemo.llm.data.collate import MLM_LOSS_IGNORE_INDEX +from bionemo.llm.data.label2id_tokenizer import Label2IDTokenizer +from bionemo.llm.data.types import BertSample + + +__all__: Sequence[str] = ( + "InMemoryProteinDataset", + "InMemorySingleValueDataset", + "InMemoryPerTokenValueDataset", +) + + +class InMemoryProteinDataset(Dataset): + """An in-memory dataset that tokenize strings into BertSample instances.""" + + def __init__( + self, + sequences: pd.Series, + labels: pd.Series | None = None, + task_type: Literal["classification", "regression", None] = None, + tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), + seed: int = np.random.SeedSequence().entropy, # type: ignore + ): + """Initializes a dataset of protein sequences. + + This is an in-memory dataset that does not apply masking to the sequence. But keeps track of <mask> in the + dataset sequences provided. + + Args: + sequences (pd.Series): A pandas Series containing protein sequences. + labels (pd.Series, optional): A pandas Series containing labels. Defaults to None. + task_type (str, optional): Fine-tuning task type. Defaults to None. + tokenizer (tokenizer.BioNeMoESMTokenizer, optional): The tokenizer to use. Defaults to tokenizer.get_tokenizer(). + seed: Random seed for reproducibility. This seed is mixed with the index of the sample to retrieve to ensure + that __getitem__ is deterministic, but can be random across different runs. If None, a random seed is + generated. + """ + self.sequences = sequences + self.labels = labels + self.task_type = task_type + + self.seed = seed + self._len = len(self.sequences) + self.tokenizer = tokenizer + + @classmethod + def from_csv( + cls, + csv_path: str | os.PathLike, + task_type: Literal["classification", "regression", None] = None, + tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), + ignore_labels: bool = False, + ): + """Class method to create a ProteinDataset instance from a CSV file. + + Args: + csv_path: path to CSV file containing sequences and optionally labels column. + task_type (str, optional): Fine-tuning task type. Defaults to None. + tokenizer (tokenizer.BioNeMoESMTokenizer, optional): The tokenizer to use. Defaults to tokenizer.get_tokenizer(). + ignore_labels (bool): ignore labels column if exist (to avoid reading labels during inference) + """ + df = pd.read_csv(csv_path) + + # Validate presence of required columns + if "sequences" not in df.columns: + raise KeyError("The CSV must contain a 'sequences' column.") + + sequences = df["sequences"] + labels = None + if not ignore_labels: + labels = df["labels"] + + return cls(sequences, labels=labels, task_type=task_type, tokenizer=tokenizer) + + def __len__(self) -> int: + """The size of the dataset.""" + return self._len + + def __getitem__(self, index: int) -> BertSample: + """Obtains the BertSample at the given index.""" + sequence = self.sequences[index] + tokenized_sequence = self._tokenize(sequence) + + label = tokenized_sequence if self.labels is None else self.transform_label(self.labels.iloc[index]) + # Overall mask for a token being masked in some capacity - either mask token, random token, or left as-is + loss_mask = ~torch.isin(tokenized_sequence, Tensor(self.tokenizer.all_special_ids)) + + return { + "text": tokenized_sequence, + "types": torch.zeros_like(tokenized_sequence, dtype=torch.int64), + "attention_mask": torch.ones_like(tokenized_sequence, dtype=torch.int64), + "labels": label, + "loss_mask": loss_mask, + "is_random": torch.zeros_like(tokenized_sequence, dtype=torch.int64), + } + + def _tokenize(self, sequence: str) -> Tensor: + """Tokenize a protein sequence. + + Args: + sequence: The protein sequence. + + Returns: + The tokenized sequence. + """ + tensor = self.tokenizer.encode(sequence, add_special_tokens=True, return_tensors="pt") + return tensor.flatten() # type: ignore + + def transform_label(self, label): + """Transform the label. + + This method should be implemented by subclass if label needs additional transformation. + + Args: + label: label to be transformed + + Returns: + transformed_label + """ + return label + + +class InMemorySingleValueDataset(InMemoryProteinDataset): + """An in-memory dataset that tokenizes strings into BertSample instances.""" + + def __init__( + self, + sequences: pd.Series, + labels: pd.Series, + task_type: Literal["classification", "regression"] = "regression", + tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), + seed: int = np.random.SeedSequence().entropy, # type: ignore + ): + """Initializes a dataset for single-value fine-tuning. + + This is an in-memory dataset that does not apply masking to the sequence. But keeps track of <mask> in the + dataset sequences provided. + + Args: + sequences (pd.Series): A pandas Series containing protein sequences. + labels (pd.Series, optional): A pandas Series containing labels. Defaults to None. + task_type (str): Fine-tuning task type. Defaults to regression. + tokenizer (tokenizer.BioNeMoESMTokenizer, optional): The tokenizer to use. Defaults to tokenizer.get_tokenizer(). + seed: Random seed for reproducibility. This seed is mixed with the index of the sample to retrieve to ensure + that __getitem__ is deterministic, but can be random across different runs. If None, a random seed is + generated. + """ + super().__init__(sequences, labels, task_type, tokenizer, seed) + + self.task_type = task_type + if self.task_type == "classification": + label_tokenizer = Label2IDTokenizer() + self.label_tokenizer = label_tokenizer.build_vocab(self.labels.values.reshape(-1, 1)) + + def transform_label(self, label: float | str) -> Tensor: + """Transform the regression label. + + Args: + label: single regression/classification value + + Returns: + tokenized label + """ + if self.task_type == "regression": + return torch.tensor([label], dtype=torch.float) + elif self.task_type == "classification": + tokenized_label = torch.tensor(self.label_tokenizer.text_to_ids([label])) + return tokenized_label + else: + raise ValueError(f"{self.task_type} task type is not supported with {self.__class__.__name__}") + + +class InMemoryPerTokenValueDataset(InMemoryProteinDataset): + """An in-memory dataset of labeled strings, which are tokenized on demand.""" + + def __init__( + self, + sequences: pd.Series, + labels: pd.Series, + task_type: Literal["classification", "regression"] = "classification", + tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), + seed: int = np.random.SeedSequence().entropy, # type: ignore + ): + """Initializes a dataset for per-token classification fine-tuning. + + This is an in-memory dataset that does not apply masking to the sequence. But keeps track of <mask> in the + dataset sequences provided. + + Args: + sequences (pd.Series): A pandas Series containing protein sequences. + labels (pd.Series, optional): A pandas Series containing labels. Defaults to None. + task_type (str): Fine-tuning task type. Defaults to classification. Regression per-token values are not supported. + tokenizer (tokenizer.BioNeMoESMTokenizer, optional): The tokenizer to use. Defaults to tokenizer.get_tokenizer(). + seed: Random seed for reproducibility. This seed is mixed with the index of the sample to retrieve to ensure + that __getitem__ is deterministic, but can be random across different runs. If None, a random seed is + generated. + """ + super().__init__(sequences, labels, task_type, tokenizer, seed) + + self.task_type = task_type + if not task_type == "classification": + raise ValueError(f"{task_type} task type is not supported with {self.__class__.__name__}") + + label_tokenizer = Label2IDTokenizer() + self.label_tokenizer = label_tokenizer.build_vocab(self.labels.values) + self.label_cls_eos_id = MLM_LOSS_IGNORE_INDEX + + def transform_label(self, label: str) -> Tensor: + """Transform the sequence label by tokenizing them. + + This method tokenizes a sequence of labels into a tensor of tokens and adds CLS/EOS tokens. + + Args: + label: label sequence to be transformed + + Returns: + tokenized label + """ + tokenized_labels = torch.tensor(self.label_tokenizer.text_to_ids(label)) + + # for multi-class (mutually exclusive) classification with CrossEntropyLoss + cls_eos = torch.tensor([self.label_cls_eos_id], dtype=tokenized_labels.dtype) + + # add cls / eos label ids with padding value -100 to have the same shape as tokenized_sequence + labels = torch.cat((cls_eos, tokenized_labels, cls_eos)) + return labels diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_regressor.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_regressor.py deleted file mode 100644 index f63a194190..0000000000 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_regressor.py +++ /dev/null @@ -1,238 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -from dataclasses import dataclass, field -from typing import Dict, List, Sequence, Tuple, Type - -import numpy as np -import torch -from megatron.core import parallel_state -from megatron.core.transformer.module import MegatronModule -from megatron.core.transformer.transformer_config import TransformerConfig -from torch import Tensor -from torch.utils.data import Dataset - -from bionemo.esm2.api import ESM2GenericConfig, ESM2Model -from bionemo.esm2.data import tokenizer -from bionemo.llm.data.types import BertSample -from bionemo.llm.model.biobert.model import BioBertOutput -from bionemo.llm.model.loss import BERTMLMLossWithReduction, PerTokenLossDict, SameSizeLossDict -from bionemo.llm.utils import iomixin_utils as iom - - -# This package demonstrates how you can take a pretrained ESM2 module and fine-tune the regressor -# to output sequence-level regression predictions. - -__all__: Sequence[str] = ( - "RegressorLossReduction", - "MegatronMLPHead", - "ESM2FineTuneSeqModel", - "ESM2FineTuneSeqConfig", - "InMemorySingleValueDataset", -) - - -class RegressorLossReduction(BERTMLMLossWithReduction): - """A class for calculating the MSE loss of regression output. - - This class used for calculating the loss, and for logging the reduced loss across micro batches. - """ - - def forward( - self, batch: Dict[str, Tensor], forward_out: Dict[str, Tensor] - ) -> Tuple[Tensor, PerTokenLossDict | SameSizeLossDict]: - """Calculates the loss within a micro-batch. A micro-batch is a batch of data on a single GPU. - - Args: - batch: A batch of data that gets passed to the original forward inside LitAutoEncoder. - forward_out: the output of the forward method inside classification head. - - Returns: - A tuple containing [<loss_tensor>, ReductionT] where the loss tensor will be used for - backpropagation and the ReductionT will be passed to the reduce method - (which currently only works for logging.). - """ - regression_output = forward_out["regression_output"] - targets = batch["labels"].to(dtype=regression_output.dtype) # [b, 1] - - cp_size = parallel_state.get_context_parallel_world_size() - if cp_size == 1: - loss = torch.nn.functional.mse_loss(regression_output, targets) - else: # TODO: support CP with masked_token_loss_context_parallel - raise NotImplementedError("Context Parallel support is not implemented for this loss") - - return loss, {"avg": loss} - - def reduce(self, losses_reduced_per_micro_batch: Sequence[SameSizeLossDict]) -> Tensor: - """Works across micro-batches. (data on single gpu). - - Note: This currently only works for logging and this loss will not be used for backpropagation. - - Args: - losses_reduced_per_micro_batch: a list of the outputs of forward - - Returns: - A tensor that is the mean of the losses. (used for logging). - """ - losses = torch.stack([loss["avg"] for loss in losses_reduced_per_micro_batch]) - return losses.mean() - - -class MegatronMLPHead(MegatronModule): - """An MLP class for sequence-level regression.""" - - def __init__(self, config: TransformerConfig): - """Constructor.""" - super().__init__(config) - - layer_sizes = [config.hidden_size, 256, 1] - self.linear_layers = torch.nn.ModuleList( - [torch.nn.Linear(i, o) for i, o in zip(layer_sizes[:-1], layer_sizes[1:])] # noqa: RUF007 - ) - self.act = torch.nn.ReLU() - self.dropout = torch.nn.Dropout(p=config.ft_dropout) - - def forward(self, hidden_states: Tensor) -> List[Tensor]: - """Inference.""" - # [b, s, h] - for layer in self.linear_layers[:-1]: - hidden_states = self.dropout(self.act(layer(hidden_states))) - - output = self.linear_layers[-1](hidden_states) - return output - - -class ESM2FineTuneSeqModel(ESM2Model): - """ESM2 model that is suitable for fine-tuning on downstream tasks.""" - - def __init__(self, config, *args, post_process: bool = True, include_embeddings: bool = False, **kwargs): - """Constructs an instance of the ESM2 model suitable for fine-tuning.""" - super().__init__(config, *args, post_process=post_process, include_embeddings=True, **kwargs) - - # freeze encoder parameters - if config.encoder_frozen: - for _, param in self.named_parameters(): - param.requires_grad = False - - self.include_embeddings_finetuning = ( - include_embeddings # this include_embeddings is for the final output of fine-tuning - ) - # If post_process is True that means that we are at the last megatron parallelism stage and we can - # apply the head. - if post_process: - # if we are doing post process (eg pipeline last stage) then we need to add the output layers - self.regression_head = MegatronMLPHead(config) - - def forward(self, *args, **kwargs) -> BioBertOutput | Tensor: - """Inference.""" - output = super().forward(*args, **kwargs) - # Stop early if we are not in post_process mode (for example if we are in the middle of model parallelism) - if not self.post_process: - return output # we are not at the last pipeline stage so just return what the parent has - # Double check that the output from the parent has everything we need to do prediction in this head. - if not isinstance(output, dict) or "embeddings" not in output: - raise ValueError( - f"Expected to find 'embeddings' in the output, and output to be dictionary-like, found {output},\n" - "Make sure include_embeddings=True in the call to super().__init__" - ) - # Get the embeddings from the parent output, and pull out the [CLS] token for this task - embeddings: Tensor = output["embeddings"] - # Predict our 1d regression target - regression_output = self.regression_head(embeddings) - if not self.include_embeddings_finetuning: - del output["embeddings"] - output["regression_output"] = regression_output - return output - - -@dataclass -class ESM2FineTuneSeqConfig( - ESM2GenericConfig[ESM2FineTuneSeqModel, RegressorLossReduction], iom.IOMixinWithGettersSetters -): - """ExampleConfig is a dataclass that is used to configure the model. - - Timers from ModelParallelConfig are required for megatron forward compatibility. - """ - - model_cls: Type[ESM2FineTuneSeqModel] = ESM2FineTuneSeqModel - # typical case is fine-tune the base biobert that doesn't have this head. If you are instead loading a checkpoint - # that has this new head and want to keep using these weights, please drop this next line or set to [] - initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=lambda: ["regression_head"]) - - encoder_frozen: bool = True # freeze encoder parameters - ft_dropout: float = 0.25 # MLP layer dropout - - def get_loss_reduction_class(self) -> Type[RegressorLossReduction]: - """Returns RegressorLossReduction class.""" - return RegressorLossReduction - - -class InMemorySingleValueDataset(Dataset): - """An in-memory dataset that tokenizes strings into BertSample instances.""" - - def __init__( - self, - data: Sequence[Tuple[str, float]], - tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), - seed: int = np.random.SeedSequence().entropy, # type: ignore - ): - """Initializes a dataset for single-value regression fine-tuning. - - This is an in-memory dataset that does not apply masking to the sequence. - - Args: - data (Sequence[Tuple[str, float]]): A sequence of tuples containing the sequence and target data. - tokenizer (tokenizer.BioNeMoESMTokenizer, optional): The tokenizer to use. Defaults to tokenizer.get_tokenizer(). - seed: Random seed for reproducibility. This seed is mixed with the index of the sample to retrieve to ensure - that __getitem__ is deterministic, but can be random across different runs. If None, a random seed is - generated. - """ - self.data = data - self.seed = seed - self._len = len(self.data) - self.tokenizer = tokenizer - - def __len__(self) -> int: - """The size of the dataset.""" - return self._len - - def __getitem__(self, index: int) -> BertSample: - """Obtains the BertSample at the given index.""" - sequence, target = self.data[index] - tokenized_sequence = self._tokenize(sequence) - # Overall mask for a token being masked in some capacity - either mask token, random token, or left as-is - loss_mask = ~torch.isin(tokenized_sequence, Tensor(self.tokenizer.all_special_ids)) - - return { - "text": tokenized_sequence, - "types": torch.zeros_like(tokenized_sequence, dtype=torch.int64), - "attention_mask": torch.ones_like(tokenized_sequence, dtype=torch.int64), - "labels": torch.tensor([target], dtype=torch.float), - "loss_mask": loss_mask, - "is_random": torch.zeros_like(tokenized_sequence, dtype=torch.int64), - } - - def _tokenize(self, sequence: str) -> Tensor: - """Tokenize a protein sequence. - - Args: - sequence: The protein sequence. - - Returns: - The tokenized sequence. - """ - tensor = self.tokenizer.encode(sequence, add_special_tokens=True, return_tensors="pt") - return tensor.flatten() # type: ignore diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py deleted file mode 100644 index b0991669d8..0000000000 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/finetune_token_classifier.py +++ /dev/null @@ -1,282 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -from dataclasses import dataclass, field -from typing import List, Sequence, Tuple, Type, TypedDict - -import numpy as np -import torch -from megatron.core import parallel_state -from megatron.core.transformer.module import MegatronModule -from megatron.core.transformer.transformer_config import TransformerConfig -from torch import Tensor -from torch.utils.data import Dataset - -from bionemo.esm2.api import ESM2GenericConfig, ESM2Model -from bionemo.esm2.data import tokenizer -from bionemo.llm.data.collate import MLM_LOSS_IGNORE_INDEX -from bionemo.llm.data.label2id_tokenizer import Label2IDTokenizer -from bionemo.llm.data.types import BertSample -from bionemo.llm.model.biobert.model import BioBertOutput -from bionemo.llm.model.loss import BERTMLMLossWithReduction, PerTokenLossDict, SameSizeLossDict -from bionemo.llm.utils import iomixin_utils as iom - - -"""This package demonstrates how you can take a pretrained ESM2 module and fine-tune the classifier -token to output secondary structure predictions. -""" - -__all__: Sequence[str] = ( - "ClassifierLossReduction", - "MegatronConvNetHead", - "ESM2FineTuneTokenModel", - "ESM2FineTuneTokenConfig", - "InMemoryPerTokenValueDataset", - "ClassifierInput", - "Esm2FineTuneTokenOutput", -) - - -class ClassifierInput(TypedDict): - """Used as input in the ClassifierLossReduction's forward method.""" - - labels: Tensor - loss_mask: Tensor - - -class Esm2FineTuneTokenOutput(BioBertOutput): - """Inference output from ESM2FineTuneTokenModel.""" - - classification_output: Tensor - - -class ClassifierLossReduction(BERTMLMLossWithReduction): - """A class for calculating the cross entropy loss of classification output. - - This class used for calculating the loss, and for logging the reduced loss across micro batches. - """ - - def forward( - self, batch: ClassifierInput, forward_out: Esm2FineTuneTokenOutput - ) -> Tuple[Tensor, PerTokenLossDict | SameSizeLossDict]: - """Calculates the loss within a micro-batch. A micro-batch is a batch of data on a single GPU. - - Args: - batch: A batch of data that gets passed to the original forward inside LitAutoEncoder. - forward_out: the output of the forward method inside classification head. - - Returns: - A tuple where the loss tensor will be used for backpropagation and the dict will be passed to - the reduce method, which currently only works for logging. - """ - targets = batch["labels"] # [b, s] - # [b, s, num_class] -> [b, num_class, s] to satisfy input dims for cross_entropy loss - classification_output = forward_out["classification_output"].permute(0, 2, 1) - loss_mask = batch["loss_mask"] # [b, s] - - cp_size = parallel_state.get_context_parallel_world_size() - if cp_size == 1: - losses = torch.nn.functional.cross_entropy(classification_output, targets, reduction="none") - # losses may contain NaNs at masked locations. We use masked_select to filter out these NaNs - masked_loss = torch.masked_select(losses, loss_mask) - loss = masked_loss.sum() / loss_mask.sum() - else: # TODO: support CP with masked_token_loss_context_parallel - raise NotImplementedError("Context Parallel support is not implemented for this loss") - - return loss, {"avg": loss} - - def reduce(self, losses_reduced_per_micro_batch: Sequence[SameSizeLossDict]) -> Tensor: - """Works across micro-batches. (data on single gpu). - - Note: This currently only works for logging and this loss will not be used for backpropagation. - - Args: - losses_reduced_per_micro_batch: a list of the outputs of forward - - Returns: - A tensor that is the mean of the losses. (used for logging). - """ - losses = torch.stack([loss["avg"] for loss in losses_reduced_per_micro_batch]) - return losses.mean() - - -class MegatronConvNetHead(MegatronModule): - """A convolutional neural network class for residue-level classification.""" - - def __init__(self, config: TransformerConfig): - """Constructor.""" - super().__init__(config) - - self.finetune_model = torch.nn.Sequential( - torch.nn.Conv2d(config.hidden_size, config.cnn_hidden_dim, kernel_size=(7, 1), padding=(3, 0)), # 7x32 - torch.nn.ReLU(), - torch.nn.Dropout(config.cnn_dropout), - ) - # class_heads (torch.nn.ModuleList): A list of convolutional layers, each corresponding to a different class head. - # These are used for producing logits scores of varying sizes as specified in `output_sizes`. - self.class_heads = torch.nn.Conv2d(32, config.cnn_num_classes, kernel_size=(7, 1), padding=(3, 0)) - - def forward(self, hidden_states: Tensor) -> List[Tensor]: - """Inference.""" - # [b, s, h] -> [b, h, s, 1] - hidden_states = hidden_states.permute(0, 2, 1).unsqueeze(dim=-1) - hidden_states = self.finetune_model(hidden_states) # [b, 32, s, 1] - output = self.class_heads(hidden_states).squeeze(dim=-1).permute(0, 2, 1) # [b, s, output_size] - return output - - -class ESM2FineTuneTokenModel(ESM2Model): - """An ESM2 model that is suitable for fine tuning.""" - - def __init__(self, config, *args, include_hiddens: bool = False, post_process: bool = True, **kwargs): - """Constructor.""" - super().__init__(config, *args, include_hiddens=True, post_process=post_process, **kwargs) - - # freeze encoder parameters - if config.encoder_frozen: - for _, param in self.named_parameters(): - param.requires_grad = False - - self.include_hiddens_finetuning = ( - include_hiddens # this include_hiddens is for the final output of fine-tuning - ) - # If post_process is True that means that we are at the last megatron parallelism stage and we can - # apply the head. - if post_process: - # if we are doing post process (eg pipeline last stage) then we need to add the output layers - self.classification_head = MegatronConvNetHead(config) - - def forward(self, *args, **kwargs) -> Tensor | BioBertOutput | Esm2FineTuneTokenOutput: - """Inference.""" - output: Tensor | BioBertOutput | Esm2FineTuneTokenOutput = super().forward(*args, **kwargs) - # Stop early if we are not in post_process mode (for example if we are in the middle of model parallelism) - if not self.post_process: - return output # we are not at the last pipeline stage so just return what the parent has - # Double check that the output from the parent has everything we need to do prediction in this head. - if not isinstance(output, dict) or "hidden_states" not in output: - raise ValueError( - f"Expected to find 'hidden_states' in the output, and output to be dictionary-like, found {output},\n" - "Make sure include_hiddens=True in the call to super().__init__" - ) - # Get the hidden state from the parent output, and pull out the [CLS] token for this task - hidden_states: Tensor = output["hidden_states"] - # Predict our 1d regression target - classification_output = self.classification_head(hidden_states) - if not self.include_hiddens_finetuning: - del output["hidden_states"] - output["classification_output"] = classification_output - return output - - -@dataclass -class ESM2FineTuneTokenConfig( - ESM2GenericConfig[ESM2FineTuneTokenModel, ClassifierLossReduction], iom.IOMixinWithGettersSetters -): - """ExampleConfig is a dataclass that is used to configure the model. - - Timers from ModelParallelConfig are required for megatron forward compatibility. - """ - - model_cls: Type[ESM2FineTuneTokenModel] = ESM2FineTuneTokenModel - # typical case is fine-tune the base biobert that doesn't have this head. If you are instead loading a checkpoint - # that has this new head and want to keep using these weights, please drop this next line or set to [] - initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=lambda: ["classification_head"]) - - encoder_frozen: bool = True # freeze encoder parameters - cnn_num_classes: int = 3 # number of classes in each label - cnn_dropout: float = 0.25 - cnn_hidden_dim: int = 32 # The number of output channels in the bottleneck layer of the convolution. - - def get_loss_reduction_class(self) -> Type[ClassifierLossReduction]: - """The loss function type.""" - return ClassifierLossReduction - - -class InMemoryPerTokenValueDataset(Dataset): - """An in-memory dataset of labeled strings, which are tokenized on demand.""" - - def __init__( - self, - data: Sequence[Tuple[str, str]], - tokenizer: tokenizer.BioNeMoESMTokenizer = tokenizer.get_tokenizer(), - seed: int = np.random.SeedSequence().entropy, # type: ignore - ): - """Initializes a dataset for per-token classification fine-tuning. - - This is an in-memory dataset that does not apply masking to the sequence. - - Args: - data: A sequence of tuples containing the sequence and target data. - tokenizer: The tokenizer to use. Defaults to tokenizer.get_tokenizer(). - seed: Random seed for reproducibility. This seed is mixed with the index of the sample to retrieve to - ensure that __getitem__ is deterministic, but can be random across different runs. If None, a random - seed is generated. - """ - self.data = data - self.seed = seed - self._len = len(self.data) - self.tokenizer = tokenizer - label_tokenizer = Label2IDTokenizer() - self.label_tokenizer = label_tokenizer.build_vocab("CHE") - self.label_cls_eos_id = MLM_LOSS_IGNORE_INDEX - - def __len__(self) -> int: - """Length of dataset.""" - return self._len - - def __getitem__(self, index: int) -> BertSample: - """Gets a BertSample associated to the supplied index.""" - sequence, target = self.data[index] - tokenized_sequence = self._tokenize(sequence) - # Overall mask for a token being masked in some capacity - either mask token, random token, or left as-is - loss_mask = ~torch.isin(tokenized_sequence, torch.tensor(self.tokenizer.all_special_ids)) - labels = self._tokenize_labels(target) - - return { - "text": tokenized_sequence, - "types": torch.zeros_like(tokenized_sequence, dtype=torch.int64), - "attention_mask": torch.ones_like(tokenized_sequence, dtype=torch.int64), - "labels": labels, - "loss_mask": loss_mask, - "is_random": torch.zeros_like(tokenized_sequence, dtype=torch.int64), - } - - def _tokenize_labels(self, labels_sequence: str) -> Tensor: - label_ids = torch.tensor(self.label_tokenizer.text_to_ids(labels_sequence)) - - # # for multi-label classification with BCEWithLogitsLoss - # tokenized_labels = torch.nn.functional.one_hot(label_ids, num_classes=self.label_tokenizer.vocab_size) - # cls_eos = torch.full((1, self.label_tokenizer.vocab_size), self.label_cls_eos_id, dtype=tokenized_labels.dtype) - - # for multi-class (mutually exclusive) classification with CrossEntropyLoss - tokenized_labels = label_ids - cls_eos = torch.tensor([self.label_cls_eos_id], dtype=tokenized_labels.dtype) - - # add cls / eos label ids with padding value -100 to have the same shape as tokenized_sequence - labels = torch.cat((cls_eos, tokenized_labels, cls_eos)) - return labels - - def _tokenize(self, sequence: str) -> Tensor: - """Tokenize a protein sequence. - - Args: - sequence: The protein sequence. - - Returns: - The tokenized sequence. - """ - tensor = self.tokenizer.encode(sequence, add_special_tokens=True, return_tensors="pt") - return tensor.flatten() # type: ignore diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/loss.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/loss.py new file mode 100644 index 0000000000..33321ac69e --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/loss.py @@ -0,0 +1,132 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Dict, Sequence, Tuple + +import torch +from megatron.core import parallel_state +from torch import Tensor + +from bionemo.llm.model.loss import BERTMLMLossWithReduction, PerTokenLossDict, SameSizeLossDict + + +__all__: Sequence[str] = ( + "RegressorLossReduction", + "ClassifierLossReduction", +) + + +class RegressorLossReduction(BERTMLMLossWithReduction): + """A class for calculating the MSE loss of regression output. + + This class used for calculating the loss, and for logging the reduced loss across micro batches. + """ + + def forward( + self, batch: Dict[str, Tensor], forward_out: Dict[str, Tensor] + ) -> Tuple[Tensor, PerTokenLossDict | SameSizeLossDict]: + """Calculates the loss within a micro-batch. A micro-batch is a batch of data on a single GPU. + + Args: + batch: A batch of data that gets passed to the original forward inside LitAutoEncoder. + forward_out: the output of the forward method inside classification head. + + Returns: + A tuple containing [<loss_tensor>, ReductionT] where the loss tensor will be used for + backpropagation and the ReductionT will be passed to the reduce method + (which currently only works for logging.). + """ + regression_output = forward_out["regression_output"] + targets = batch["labels"].to(dtype=regression_output.dtype) # [b, 1] + + cp_size = parallel_state.get_context_parallel_world_size() + if cp_size == 1: + loss = torch.nn.functional.mse_loss(regression_output, targets) + else: + raise NotImplementedError("Context Parallel support is not implemented for this loss") + + return loss, {"avg": loss} + + def reduce(self, losses_reduced_per_micro_batch: Sequence[SameSizeLossDict]) -> Tensor: + """Works across micro-batches. (data on single gpu). + + Note: This currently only works for logging and this loss will not be used for backpropagation. + + Args: + losses_reduced_per_micro_batch: a list of the outputs of forward + + Returns: + A tensor that is the mean of the losses. (used for logging). + """ + losses = torch.stack([loss["avg"] for loss in losses_reduced_per_micro_batch]) + return losses.mean() + + +class ClassifierLossReduction(BERTMLMLossWithReduction): + """A class for calculating the cross entropy loss of classification output. + + This class used for calculating the loss, and for logging the reduced loss across micro batches. + """ + + def forward( + self, batch: Dict[str, Tensor], forward_out: Dict[str, Tensor] + ) -> Tuple[Tensor, PerTokenLossDict | SameSizeLossDict]: + """Calculates the loss within a micro-batch. A micro-batch is a batch of data on a single GPU. + + Args: + batch: A batch of data that gets passed to the original forward inside LitAutoEncoder. + forward_out: the output of the forward method inside classification head. + + Returns: + A tuple where the loss tensor will be used for backpropagation and the dict will be passed to + the reduce method, which currently only works for logging. + """ + targets = batch["labels"].squeeze() # [b] or [b, s] for sequence-level or token-level classification + + classification_output = forward_out["classification_output"] # [b, num_class] or [b, s, num_class] + # [b, s, num_class] -> [b, num_class, s] to satisfy toke-level input dims for cross_entropy loss + if classification_output.dim() == 3: + classification_output = classification_output.permute(0, 2, 1) + + loss_mask = batch["loss_mask"] # [b, s] + + cp_size = parallel_state.get_context_parallel_world_size() + if cp_size == 1: + losses = torch.nn.functional.cross_entropy(classification_output, targets, reduction="none") + # token-level losses may contain NaNs at masked locations. We use masked_select to filter out these NaNs + if classification_output.dim() == 3: + masked_loss = torch.masked_select(losses, loss_mask) + loss = masked_loss.sum() / loss_mask.sum() + else: + loss = losses.mean() # sequence-level single value classification + else: + raise NotImplementedError("Context Parallel support is not implemented for this loss") + + return loss, {"avg": loss} + + def reduce(self, losses_reduced_per_micro_batch: Sequence[SameSizeLossDict]) -> Tensor: + """Works across micro-batches. (data on single gpu). + + Note: This currently only works for logging and this loss will not be used for backpropagation. + + Args: + losses_reduced_per_micro_batch: a list of the outputs of forward + + Returns: + A tensor that is the mean of the losses. (used for logging). + """ + losses = torch.stack([loss["avg"] for loss in losses_reduced_per_micro_batch]) + return losses.mean() diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/sequence_model.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/sequence_model.py new file mode 100644 index 0000000000..3b3c18d42b --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/sequence_model.py @@ -0,0 +1,139 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from dataclasses import dataclass, field +from typing import List, Literal, Sequence, Type + +import torch +from megatron.core.transformer.module import MegatronModule +from megatron.core.transformer.transformer_config import TransformerConfig +from torch import Tensor + +from bionemo.esm2.api import ESM2GenericConfig, ESM2Model +from bionemo.esm2.model.finetune.loss import ClassifierLossReduction, RegressorLossReduction +from bionemo.llm.model.biobert.model import BioBertOutput +from bionemo.llm.model.loss import BERTMLMLossWithReduction +from bionemo.llm.utils import iomixin_utils as iom + + +# This package demonstrates how you can take a pretrained ESM2 module and fine-tune the regressor +# to output sequence-level regression predictions. + +__all__: Sequence[str] = ( + "MegatronMLPHead", + "ESM2FineTuneSeqModel", + "ESM2FineTuneSeqConfig", +) + + +class MegatronMLPHead(MegatronModule): + """An MLP class for sequence-level regression.""" + + def __init__(self, config: TransformerConfig): + """Constructor.""" + super().__init__(config) + + layer_sizes = [config.hidden_size, config.mlp_hidden_size, config.mlp_target_size] + self.linear_layers = torch.nn.ModuleList( + [torch.nn.Linear(i, o) for i, o in zip(layer_sizes[:-1], layer_sizes[1:])] # noqa: RUF007 + ) + self.act = torch.nn.ReLU() + self.dropout = torch.nn.Dropout(p=config.mlp_ft_dropout) + + def forward(self, hidden_states: Tensor) -> List[Tensor]: + """Inference.""" + # [b, s, h] + for layer in self.linear_layers[:-1]: + hidden_states = self.dropout(self.act(layer(hidden_states))) + + output = self.linear_layers[-1](hidden_states) + return output + + +class ESM2FineTuneSeqModel(ESM2Model): + """ESM2 model that is suitable for fine-tuning on downstream tasks.""" + + def __init__(self, config, *args, post_process: bool = True, include_embeddings: bool = False, **kwargs): + """Constructs an instance of the ESM2 model suitable for fine-tuning.""" + super().__init__(config, *args, post_process=post_process, include_embeddings=True, **kwargs) + + # freeze encoder parameters + if config.encoder_frozen: + for _, param in self.named_parameters(): + param.requires_grad = False + + self.include_embeddings_finetuning = ( + include_embeddings # this include_embeddings is for the final output of fine-tuning + ) + # If post_process is True that means that we are at the last megatron parallelism stage and we can + # apply the head. + if post_process: + self.task_type = config.task_type + # if we are doing post process (eg pipeline last stage) then we need to add the output layers + self.head_name = f"{self.task_type}_head" # Example: 'regression_head' or 'classification_head' + # Set the attribute dynamically + setattr(self, self.head_name, MegatronMLPHead(config)) + + def forward(self, *args, **kwargs) -> BioBertOutput | Tensor: + """Inference.""" + output = super().forward(*args, **kwargs) + # Stop early if we are not in post_process mode (for example if we are in the middle of model parallelism) + if not self.post_process: + return output # we are not at the last pipeline stage so just return what the parent has + # Double check that the output from the parent has everything we need to do prediction in this head. + if not isinstance(output, dict) or "embeddings" not in output: + raise ValueError( + f"Expected to find 'embeddings' in the output, and output to be dictionary-like, found {output},\n" + "Make sure include_embeddings=True in the call to super().__init__" + ) + # Get the embeddings from the parent output, and pull out the [CLS] token for this task + embeddings: Tensor = output["embeddings"] + # Predict our 1d regression target + task_head = getattr(self, self.head_name) + output[f"{self.task_type}_output"] = task_head(embeddings) + if not self.include_embeddings_finetuning: + del output["embeddings"] + return output + + +@dataclass +class ESM2FineTuneSeqConfig( + ESM2GenericConfig[ESM2FineTuneSeqModel, BERTMLMLossWithReduction], iom.IOMixinWithGettersSetters +): + """ExampleConfig is a dataclass that is used to configure the model. + + Timers from ModelParallelConfig are required for megatron forward compatibility. + """ + + model_cls: Type[ESM2FineTuneSeqModel] = ESM2FineTuneSeqModel + # typical case is fine-tune the base biobert that doesn't have this head. If you are instead loading a checkpoint + # that has this new head and want to keep using these weights, please drop this next line or set to [] + initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=lambda: ["regression_head"]) + + task_type: Literal["classification", "regression"] = "regression" + encoder_frozen: bool = True # freeze encoder parameters + mlp_ft_dropout: float = 0.25 # MLP layer dropout + mlp_hidden_size: int = 256 + mlp_target_size: int = 1 + + def get_loss_reduction_class(self) -> Type[BERTMLMLossWithReduction]: + """Returns RegressorLossReduction class.""" + if self.task_type == "regression": + return RegressorLossReduction + elif self.task_type == "classification": + return ClassifierLossReduction + else: + raise ValueError(f"Unsupported task_type: {self.task_type}") diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/token_model.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/token_model.py new file mode 100644 index 0000000000..9a9fd2f440 --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/token_model.py @@ -0,0 +1,134 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from dataclasses import dataclass, field +from typing import List, Literal, Sequence, Type + +import torch +from megatron.core.transformer.module import MegatronModule +from megatron.core.transformer.transformer_config import TransformerConfig +from torch import Tensor + +from bionemo.esm2.api import ESM2GenericConfig, ESM2Model +from bionemo.esm2.model.finetune.loss import ClassifierLossReduction +from bionemo.llm.model.biobert.model import BioBertOutput +from bionemo.llm.utils import iomixin_utils as iom + + +"""This package demonstrates how you can take a pretrained ESM2 module and fine-tune the classifier +token to output secondary structure predictions. +""" + +__all__: Sequence[str] = ( + "MegatronConvNetHead", + "ESM2FineTuneTokenModel", + "ESM2FineTuneTokenConfig", +) + + +class MegatronConvNetHead(MegatronModule): + """A convolutional neural network class for residue-level classification.""" + + def __init__(self, config: TransformerConfig): + """Constructor.""" + super().__init__(config) + + self.finetune_model = torch.nn.Sequential( + torch.nn.Conv2d(config.hidden_size, config.cnn_hidden_size, kernel_size=(7, 1), padding=(3, 0)), # 7x32 + torch.nn.ReLU(), + torch.nn.Dropout(config.cnn_dropout), + ) + # class_heads (torch.nn.ModuleList): A list of convolutional layers, each corresponding to a different class head. + # These are used for producing logits scores of varying sizes as specified in `output_sizes`. + self.class_heads = torch.nn.Conv2d(32, config.cnn_num_classes, kernel_size=(7, 1), padding=(3, 0)) + + def forward(self, hidden_states: Tensor) -> List[Tensor]: + """Inference.""" + # [b, s, h] -> [b, h, s, 1] + hidden_states = hidden_states.permute(0, 2, 1).unsqueeze(dim=-1) + hidden_states = self.finetune_model(hidden_states) # [b, 32, s, 1] + output = self.class_heads(hidden_states).squeeze(dim=-1).permute(0, 2, 1) # [b, s, output_size] + return output + + +class ESM2FineTuneTokenModel(ESM2Model): + """An ESM2 model that is suitable for fine tuning.""" + + def __init__(self, config, *args, include_hiddens: bool = False, post_process: bool = True, **kwargs): + """Constructor.""" + super().__init__(config, *args, include_hiddens=True, post_process=post_process, **kwargs) + + # freeze encoder parameters + if config.encoder_frozen: + for _, param in self.named_parameters(): + param.requires_grad = False + + self.include_hiddens_finetuning = ( + include_hiddens # this include_hiddens is for the final output of fine-tuning + ) + # If post_process is True that means that we are at the last megatron parallelism stage and we can + # apply the head. + if post_process: + self.task_type = config.task_type + # if we are doing post process (eg pipeline last stage) then we need to add the output layers + self.head_name = f"{self.task_type}_head" # Example: 'regression_head' or 'classification_head' + setattr(self, self.head_name, MegatronConvNetHead(config)) + + def forward(self, *args, **kwargs) -> Tensor | BioBertOutput: + """Inference.""" + output = super().forward(*args, **kwargs) + # Stop early if we are not in post_process mode (for example if we are in the middle of model parallelism) + if not self.post_process: + return output # we are not at the last pipeline stage so just return what the parent has + # Double check that the output from the parent has everything we need to do prediction in this head. + if not isinstance(output, dict) or "hidden_states" not in output: + raise ValueError( + f"Expected to find 'hidden_states' in the output, and output to be dictionary-like, found {output},\n" + "Make sure include_hiddens=True in the call to super().__init__" + ) + # Get the hidden state from the parent output, and pull out the [CLS] token for this task + hidden_states: Tensor = output["hidden_states"] + # Predict our 1d regression target + task_head = getattr(self, self.head_name) + output[f"{self.task_type}_output"] = task_head(hidden_states) + if not self.include_hiddens_finetuning: + del output["hidden_states"] + return output + + +@dataclass +class ESM2FineTuneTokenConfig( + ESM2GenericConfig[ESM2FineTuneTokenModel, ClassifierLossReduction], iom.IOMixinWithGettersSetters +): + """ExampleConfig is a dataclass that is used to configure the model. + + Timers from ModelParallelConfig are required for megatron forward compatibility. + """ + + model_cls: Type[ESM2FineTuneTokenModel] = ESM2FineTuneTokenModel + # typical case is fine-tune the base biobert that doesn't have this head. If you are instead loading a checkpoint + # that has this new head and want to keep using these weights, please drop this next line or set to [] + initial_ckpt_skip_keys_with_these_prefixes: List[str] = field(default_factory=lambda: ["classification_head"]) + + task_type: Literal["classification", "regression"] = "classification" + encoder_frozen: bool = True # freeze encoder parameters + cnn_num_classes: int = 3 # number of classes in each label + cnn_dropout: float = 0.25 + cnn_hidden_size: int = 32 # The number of output channels in the bottleneck layer of the convolution. + + def get_loss_reduction_class(self) -> Type[ClassifierLossReduction]: + """The loss function type.""" + return ClassifierLossReduction diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py deleted file mode 100644 index 638729e3f4..0000000000 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/model/finetune/train.py +++ /dev/null @@ -1,189 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import tempfile -from pathlib import Path -from typing import Sequence, Tuple - -import lightning.pytorch as pl -from lightning.pytorch.callbacks import Callback, RichModelSummary -from lightning.pytorch.loggers import TensorBoardLogger -from megatron.core.optimizer.optimizer_config import OptimizerConfig -from nemo import lightning as nl -from nemo.collections import llm as nllm -from nemo.lightning import resume -from nemo.lightning.nemo_logger import NeMoLogger -from nemo.lightning.pytorch import callbacks as nl_callbacks -from nemo.lightning.pytorch.callbacks.model_transform import ModelTransform -from nemo.lightning.pytorch.callbacks.peft import PEFT -from nemo.lightning.pytorch.optim.megatron import MegatronOptimizerModule - -from bionemo.core.data.load import load -from bionemo.esm2.api import ESM2GenericConfig -from bionemo.esm2.data.tokenizer import BioNeMoESMTokenizer, get_tokenizer -from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule -from bionemo.esm2.model.finetune.finetune_regressor import ESM2FineTuneSeqConfig, InMemorySingleValueDataset -from bionemo.llm.model.biobert.lightning import biobert_lightning_module - - -__all__: Sequence[str] = ("train_model",) - - -def train_model( - experiment_name: str, - experiment_dir: Path, - config: ESM2GenericConfig, - data_module: pl.LightningDataModule, - n_steps_train: int, - metric_tracker: Callback | None = None, - tokenizer: BioNeMoESMTokenizer = get_tokenizer(), - peft: PEFT | None = None, - _use_rich_model_summary: bool = True, -) -> Tuple[Path, Callback | None, nl.Trainer]: - """Trains a BioNeMo ESM2 model using PyTorch Lightning. - - Parameters: - experiment_name: The name of the experiment. - experiment_dir: The directory where the experiment will be saved. - config: The configuration for the ESM2 model. - data_module: The data module for training and validation. - n_steps_train: The number of training steps. - metric_tracker: Optional callback to track metrics - tokenizer: The tokenizer to use. Defaults to `get_tokenizer()`. - peft: The PEFT (Parameter-Efficient Fine-Tuning) module. Defaults to None. - _use_rich_model_summary: Whether to use the RichModelSummary callback, omitted in our test suite until - https://nvbugspro.nvidia.com/bug/4959776 is resolved. Defaults to True. - - Returns: - A tuple containing the path to the saved checkpoint, a MetricTracker - object, and the PyTorch Lightning Trainer object. - """ - checkpoint_callback = nl_callbacks.ModelCheckpoint( - save_last=True, - save_on_train_epoch_end=True, - monitor="reduced_train_loss", # TODO find out how to get val_loss logged and use "val_loss", - every_n_train_steps=n_steps_train // 2, - always_save_context=True, # Enables the .nemo file-like checkpointing where all IOMixins are under SerDe - ) - - # Setup the logger and train the model - nemo_logger = NeMoLogger( - log_dir=str(experiment_dir), - name=experiment_name, - tensorboard=TensorBoardLogger(save_dir=experiment_dir, name=experiment_name), - ckpt=checkpoint_callback, - ) - # Needed so that the trainer can find an output directory for the profiler - # ckpt_path needs to be a string for SerDe - optimizer = MegatronOptimizerModule( - config=OptimizerConfig( - lr=5e-4, - optimizer="adam", - use_distributed_optimizer=True, - fp16=config.fp16, - bf16=config.bf16, - ) - ) - module = biobert_lightning_module(config=config, tokenizer=tokenizer, optimizer=optimizer, model_transform=peft) - - strategy = nl.MegatronStrategy( - tensor_model_parallel_size=1, - pipeline_model_parallel_size=1, - ddp="megatron", - find_unused_parameters=True, - enable_nemo_ckpt_io=True, - ) - - if _use_rich_model_summary: - # RichModelSummary is not used in the test suite until https://nvbugspro.nvidia.com/bug/4959776 is resolved due - # to errors with serialization / deserialization. - callbacks: list[Callback] = [RichModelSummary(max_depth=4)] - else: - callbacks = [] - - if metric_tracker is not None: - callbacks.append(metric_tracker) - if peft is not None: - callbacks.append( - ModelTransform() - ) # Callback needed for PEFT fine-tuning using NeMo2, i.e. biobert_lightning_module(model_transform=peft). - - trainer = nl.Trainer( - accelerator="gpu", - devices=1, - strategy=strategy, - limit_val_batches=2, - val_check_interval=n_steps_train // 2, - max_steps=n_steps_train, - num_nodes=1, - log_every_n_steps=n_steps_train // 2, - callbacks=callbacks, - plugins=nl.MegatronMixedPrecision(precision="bf16-mixed"), - ) - nllm.train( - model=module, - data=data_module, - trainer=trainer, - log=nemo_logger, - resume=resume.AutoResume( - resume_if_exists=True, # Looks for the -last checkpoint to continue training. - resume_ignore_no_checkpoint=True, # When false this will throw an error with no existing checkpoint. - ), - ) - ckpt_path = Path(checkpoint_callback.last_model_path.replace(".ckpt", "")) - return ckpt_path, metric_tracker, trainer - - -if __name__ == "__main__": - # set the results directory - experiment_results_dir = tempfile.TemporaryDirectory().name - - # create a List[Tuple] with (sequence, target) values - artificial_sequence_data = [ - "TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "GRFNVWLGGNESKIRQVLKAVKEIGVSPTLFAVYEKN", - "DELTALGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "KLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LFGAIGNAISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "LGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "ISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "SGSKASSDSQDANQCCTSCEDNAPATSYCVECSEPLCETCVEAHQRVKYTKDHTVRSTGPAKT", - ] - data = [(seq, len(seq) / 100.0) for seq in artificial_sequence_data] - - # we are training and validating on the same dataset for simplicity - dataset = InMemorySingleValueDataset(data) - data_module = ESM2FineTuneDataModule(train_dataset=dataset, valid_dataset=dataset) - - experiment_name = "finetune_regressor" - n_steps_train = 50 - seed = 42 - - # To download a 650M pre-trained ESM2 model - pretrain_ckpt_path = load("esm2/650m:2.0") - - config = ESM2FineTuneSeqConfig(initial_ckpt_path=str(pretrain_ckpt_path)) - - checkpoint, metrics, trainer = train_model( - experiment_name=experiment_name, - experiment_dir=Path(experiment_results_dir), # new checkpoint will land in a subdir of this - config=config, # same config as before since we are just continuing training - data_module=data_module, - n_steps_train=n_steps_train, - ) - print(f"Experiment completed with checkpoint stored at {checkpoint}") diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/finetune_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/finetune_esm2.py new file mode 100644 index 0000000000..b572291b71 --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/finetune_esm2.py @@ -0,0 +1,765 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import argparse +from pathlib import Path +from typing import Dict, List, Optional, Sequence, Tuple, Type, get_args + +from lightning.pytorch.callbacks import Callback, LearningRateMonitor, RichModelSummary +from megatron.core.distributed import DistributedDataParallelConfig +from megatron.core.optimizer import OptimizerConfig +from nemo import lightning as nl +from nemo.collections import llm +from nemo.lightning import resume +from nemo.lightning.pytorch import callbacks as nl_callbacks +from nemo.lightning.pytorch.optim import MegatronOptimizerModule + +from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype +from bionemo.esm2.data.tokenizer import get_tokenizer +from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule +from bionemo.esm2.model.finetune.dataset import ( + InMemoryPerTokenValueDataset, + InMemoryProteinDataset, + InMemorySingleValueDataset, +) +from bionemo.esm2.model.finetune.sequence_model import ESM2FineTuneSeqConfig +from bionemo.esm2.model.finetune.token_model import ESM2FineTuneTokenConfig +from bionemo.llm.model.biobert.lightning import biobert_lightning_module +from bionemo.llm.model.biobert.model import BioBertConfig +from bionemo.llm.utils.datamodule_utils import float_or_int_or_none, infer_global_batch_size +from bionemo.llm.utils.logger_utils import WandbConfig, setup_nemo_lightning_logger + + +__all__: Sequence[str] = ("train_model", "finetune_esm2_entrypoint", "get_parser") + + +SUPPORTED_CONFIGS = { + "ESM2FineTuneSeqConfig": ESM2FineTuneSeqConfig, + "ESM2FineTuneTokenConfig": ESM2FineTuneTokenConfig, +} + +SUPPORTED_DATASETS = { + "InMemoryProteinDataset": InMemoryProteinDataset, + "InMemorySingleValueDataset": InMemorySingleValueDataset, + "InMemoryPerTokenValueDataset": InMemoryPerTokenValueDataset, +} + + +def train_model( + train_data_path: Path, + valid_data_path: Path, + num_nodes: int, + devices: int, + min_seq_length: Optional[int], + max_seq_length: int, + result_dir: Path, + num_steps: int, + limit_val_batches: int, + val_check_interval: int, + log_every_n_steps: Optional[int], + num_dataset_workers: int, + lr: float, + micro_batch_size: int, + accumulate_grad_batches: int, + experiment_name: str, + resume_if_exists: bool, + precision: PrecisionTypes, + task_type: str = "regression", + encoder_frozen: bool = False, + scale_lr_layer: Optional[str] = None, + lr_multiplier: float = 1.0, + # single value classification / regression mlp + mlp_ft_dropout: float = 0.25, + mlp_hidden_size: int = 256, + mlp_target_size: int = 1, + # token-level classification cnn + cnn_dropout: float = 0.25, + cnn_hidden_size: int = 32, + cnn_num_classes: int = 3, + wandb_entity: Optional[str] = None, + wandb_project: Optional[str] = None, + wandb_offline: bool = False, + wandb_tags: Optional[List[str]] = None, + wandb_group: Optional[str] = None, + wandb_id: Optional[str] = None, + wandb_anonymous: Optional[bool] = False, + wandb_log_model: bool = False, + pipeline_model_parallel_size: int = 1, + tensor_model_parallel_size: int = 1, + create_tensorboard_logger: bool = False, + restore_from_checkpoint_path: Optional[str] = None, + save_last_checkpoint: bool = True, + metric_to_monitor_for_checkpoints: str = "val_loss", + save_top_k: int = 2, + nsys_profiling: bool = False, + nsys_start_step: int = 0, + nsys_end_step: Optional[int] = None, + nsys_ranks: List[int] = [0], + dataset_class: Type[InMemoryProteinDataset] = InMemorySingleValueDataset, + config_class: Type[BioBertConfig] = ESM2FineTuneSeqConfig, + metric_tracker: Callback | None = None, + overlap_grad_reduce: bool = False, # Default to False to avoid communication issue in gradient synchronization step + overlap_param_gather: bool = True, + average_in_collective: bool = True, + grad_reduce_in_fp32: bool = False, +) -> Tuple[Path, Callback | None, nl.Trainer]: + """Train an ESM2 model on UR data. + + Args: + train_data_path (Path): path to train CSV + valid_data_path (Path): path to validation CSV + num_nodes (int): Number of nodes to run on + devices (int): number of devices + min_seq_length (Optional[int]): minimum sequence length + max_seq_length (int): maximum sequence length + result_dir (Path): directory to store results, logs and checkpoints + num_steps (int): number of steps to train the model for + limit_val_batches (int): limit the number of validation global batches to this many + val_check_interval (int): number of steps to periodically check the validation loss + log_every_n_steps (Optional[int]): log every n steps + num_dataset_workers (int): number of dataset workers + lr (float): learning rate + micro_batch_size (int): micro batch size, from this and parallelism settings we infer the global batch size + accumulate_grad_batches (int): number of batches to accumulate gradients for + experiment_name (str): experiment name, this is the name used for the wandb run, and the sub-directory of the + result_dir that stores the logs and checkpoints. + resume_if_exists (bool): attempt to resume if the checkpoint exists [FIXME @skothenhill this doesn't work yet] + precision (PrecisionTypes): Precision type for training (e.g., float16, float32) + task_type (str): Fine-tuning task type. Default is regression. + encoder_frozen (bool): Freeze the encoder parameters. Default is False. + scale_lr_layer (Optional[str]): layer names for which the lr is scaled by lr_multiplier + lr_multiplier (float): lr multiplier for parameters in scale_lr_layer + mlp_ft_dropout (float): dropout for single value classification / regression mlp + mlp_hidden_size (int): dimension of hidden layer in mlp task head + mlp_target_size: (int): output dimension of the mlp task head (number of classes in classification tasks) + cnn_dropout (float): dropout for token-level classification cnn + cnn_hidden_size (int): hidden dimension of cnn head + cnn_num_classes (int): number of classes in token-level classification + wandb_entity (Optional[str]): The team posting this run (default: your username or your default team) + wandb_project (Optional[str]): The name of the project to which this run will belong + wandb_offline (bool): Run offline (data can be streamed later to wandb servers). + wandb_tags (Optional[List[str]]): Tags associated with this run + wandb_group (Optional[str]): A unique string shared by all runs in a given group + wandb_id (Optional[str]): Sets the version, mainly used to resume a previous run + wandb_anonymous (Optional[bool]): Enables or explicitly disables anonymous logging + wandb_log_model (bool): Save checkpoints in wandb dir to upload on W&B servers + pipeline_model_parallel_size (int): pipeline model parallel size + tensor_model_parallel_size (int): tensor model parallel size + create_tensorboard_logger (bool): create the tensorboard logger + restore_from_checkpoint_path (Optional[str]): If set, restores the model from the directory passed in. Expects the + checkpoint to be created by using the ModelCheckpoint class and always_save_context=True. + save_last_checkpoint (bool): whether to save the last checkpoint + metric_to_monitor_for_checkpoints (str): metric to monitor for checkpoints + save_top_k (int): number of top checkpoints to save + nsys_profiling (bool): whether to enable nsys profiling + nsys_start_step (int): start step for nsys profiling + nsys_end_step (Optional[int]): end step for nsys profiling + nsys_ranks (List[int]): ranks for nsys profiling + dataset_class (Type[InMemoryProteinDataset]): The dataset class for loading the data from a CSV file + config_class (Type[BioBertConfig]): The config class for configuring the model using checkpoint provided + metric_tracker: Optional callback to track metrics (used for testing) + overlap_grad_reduce (bool): overlap gradient reduction + overlap_param_gather (bool): overlap parameter gather + average_in_collective (bool): average in collective + grad_reduce_in_fp32 (bool): gradient reduction in fp32 + """ + # Create the result directory if it does not exist. + result_dir.mkdir(parents=True, exist_ok=True) + + # Setup the strategy and trainer + global_batch_size = infer_global_batch_size( + micro_batch_size=micro_batch_size, + num_nodes=num_nodes, + devices=devices, + accumulate_grad_batches=accumulate_grad_batches, + tensor_model_parallel_size=tensor_model_parallel_size, + pipeline_model_parallel_size=pipeline_model_parallel_size, + ) + + strategy = nl.MegatronStrategy( + tensor_model_parallel_size=tensor_model_parallel_size, + pipeline_model_parallel_size=pipeline_model_parallel_size, + ddp=DistributedDataParallelConfig( + check_for_nan_in_grad=True, + overlap_grad_reduce=overlap_grad_reduce, + overlap_param_gather=overlap_param_gather, + average_in_collective=average_in_collective, + grad_reduce_in_fp32=grad_reduce_in_fp32, + use_distributed_optimizer=True, + ), + find_unused_parameters=True, + gradient_as_bucket_view=True, + ckpt_include_optimizer=True, + ckpt_async_save=True, + ckpt_parallel_load=True, + ) + + # for wandb integration + # Please refer to https://pytorch-lightning.readthedocs.io/en/0.7.6/api/lightning.pytorch.loggers.html" + wandb_config: Optional[WandbConfig] = ( + None + if wandb_project is None + else WandbConfig( + offline=wandb_offline, + project=wandb_project, + entity=wandb_entity, + tags=wandb_tags, + group=wandb_group, + id=wandb_id, + anonymous=wandb_anonymous, + log_model=wandb_log_model, + ) + ) + + callbacks = [ + RichModelSummary(max_depth=4), + LearningRateMonitor(), + nl_callbacks.PreemptionCallback(), + ] + if metric_tracker is not None: + callbacks.append(metric_tracker) + if nsys_profiling: + if nsys_end_step is None: + nsys_end_step = num_steps + callbacks.append( + nl_callbacks.NsysCallback( + start_step=nsys_start_step, end_step=nsys_end_step, ranks=nsys_ranks, gen_shape=True + ) + ) + + trainer = nl.Trainer( + devices=devices, + max_steps=num_steps, + accelerator="gpu", + strategy=strategy, + limit_val_batches=limit_val_batches, # This controls upsampling and downsampling + val_check_interval=val_check_interval, + log_every_n_steps=log_every_n_steps, + num_nodes=num_nodes, + callbacks=callbacks, + plugins=nl.MegatronMixedPrecision( + precision=precision, + params_dtype=get_autocast_dtype(precision), + pipeline_dtype=get_autocast_dtype(precision), + grad_reduce_in_fp32=grad_reduce_in_fp32, + autocast_enabled=False, + ), + ) + + tokenizer = get_tokenizer() + + # Initialize the data module. + train_dataset = dataset_class.from_csv(train_data_path, task_type=task_type) + valid_dataset = dataset_class.from_csv(valid_data_path, task_type=task_type) + + data_module = ESM2FineTuneDataModule( + train_dataset=train_dataset, + valid_dataset=valid_dataset, + global_batch_size=global_batch_size, + micro_batch_size=micro_batch_size, + min_seq_length=min_seq_length, + max_seq_length=max_seq_length, + num_workers=num_dataset_workers, + tokenizer=tokenizer, + ) + # Configure the model + config = config_class( + task_type=task_type, + encoder_frozen=encoder_frozen, + params_dtype=get_autocast_dtype(precision), + pipeline_dtype=get_autocast_dtype(precision), + autocast_dtype=get_autocast_dtype(precision), # setting this speeds things up a lot + tensor_model_parallel_size=tensor_model_parallel_size, + pipeline_model_parallel_size=pipeline_model_parallel_size, + initial_ckpt_path=str(restore_from_checkpoint_path), + initial_ckpt_skip_keys_with_these_prefixes=[f"{task_type}_head"], + ) + # Mapping of task-dependent config attributes to their new values + task_dependent_attr = { + "mlp_ft_dropout": mlp_ft_dropout, + "mlp_hidden_size": mlp_hidden_size, + "mlp_target_size": mlp_target_size, + "cnn_dropout": cnn_dropout, + "cnn_hidden_size": cnn_hidden_size, + "cnn_num_classes": cnn_num_classes, + } + # Update attributes only if they exist in the config + for attr, value in task_dependent_attr.items(): + if hasattr(config, attr): + setattr(config, attr, value) + + optimizer = MegatronOptimizerModule( + config=OptimizerConfig( + lr=lr, + optimizer="adam", # fused_adam not supported + use_distributed_optimizer=True, + weight_decay=0.01, + adam_beta1=0.9, + adam_beta2=0.98, + ), + ) + # fiddle is not serializing lambda fn + # to bypass serialization of lambda fn scale_lr_condition as part of optimizer configuration + if scale_lr_layer: + optimizer.scale_lr_cond = lambda name, param: scale_lr_layer in name + optimizer.lr_mult = lr_multiplier + + module = biobert_lightning_module(config=config, tokenizer=tokenizer, optimizer=optimizer) + + # Configure our custom Checkpointer + checkpoint_callback = nl_callbacks.ModelCheckpoint( + save_last=save_last_checkpoint, + monitor=metric_to_monitor_for_checkpoints, # "val_loss", + save_top_k=save_top_k, + every_n_train_steps=val_check_interval, + always_save_context=True, # Enables the .nemo file-like checkpointing where all IOMixins are under SerDe + filename="checkpoint-{step}-{consumed_samples}", # Including step and consumed_samples in the checkpoint filename prevents duplicate filenames and bugs related to this. + ) + + # Setup the logger and train the model + nemo_logger = setup_nemo_lightning_logger( + root_dir=result_dir, + name=experiment_name, + initialize_tensorboard_logger=create_tensorboard_logger, + wandb_config=wandb_config, + ckpt_callback=checkpoint_callback, + ) + + llm.train( + model=module, + data=data_module, + trainer=trainer, + log=nemo_logger, + resume=resume.AutoResume( + resume_if_exists=resume_if_exists, # Looks for the -last checkpoint to continue training. + resume_ignore_no_checkpoint=True, # When false this will throw an error with no existing checkpoint. + ), + ) + ckpt_path = Path(checkpoint_callback.last_model_path.replace(".ckpt", "")) + return ckpt_path, metric_tracker, trainer + + +def finetune_esm2_entrypoint(): + """Entrypoint for running ESM2 finetuning.""" + # 1. get arguments + parser = get_parser() + args = parser.parse_args() + + # to avoid padding for single value labels: + if args.min_seq_length is not None and args.datset_class is InMemorySingleValueDataset: + parser.error("Arguments --min-seq-length cannot be set when using InMemorySingleValueDataset.") + + # 2. Call pretrain with args + train_model( + train_data_path=args.train_data_path, + valid_data_path=args.valid_data_path, + num_nodes=args.num_nodes, + devices=args.num_gpus, + min_seq_length=args.min_seq_length, + max_seq_length=args.max_seq_length, + result_dir=args.result_dir, + wandb_entity=args.wandb_entity, + wandb_project=args.wandb_project, + wandb_tags=args.wandb_tags, + wandb_group=args.wandb_group, + wandb_id=args.wandb_id, + wandb_anonymous=args.wandb_anonymous, + wandb_log_model=args.wandb_log_model, + wandb_offline=args.wandb_offline, + num_steps=args.num_steps, + limit_val_batches=args.limit_val_batches, + val_check_interval=args.val_check_interval, + log_every_n_steps=args.log_every_n_steps, + num_dataset_workers=args.num_dataset_workers, + lr=args.lr, + micro_batch_size=args.micro_batch_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + tensor_model_parallel_size=args.tensor_model_parallel_size, + accumulate_grad_batches=args.accumulate_grad_batches, + precision=args.precision, + task_type=args.task_type, + encoder_frozen=args.encoder_frozen, + scale_lr_layer=args.scale_lr_layer, + lr_multiplier=args.lr_multiplier, + # single value classification / regression mlp + mlp_ft_dropout=args.mlp_ft_dropout, + mlp_hidden_size=args.mlp_hidden_size, + mlp_target_size=args.mlp_target_size, + # token-level classification cnn + cnn_dropout=args.cnn_dropout, + cnn_hidden_size=args.cnn_hidden_size, + cnn_num_classes=args.cnn_num_classes, + experiment_name=args.experiment_name, + resume_if_exists=args.resume_if_exists, + restore_from_checkpoint_path=args.restore_from_checkpoint_path, + save_last_checkpoint=args.save_last_checkpoint, + metric_to_monitor_for_checkpoints=args.metric_to_monitor_for_checkpoints, + save_top_k=args.save_top_k, + nsys_profiling=args.nsys_profiling, + nsys_start_step=args.nsys_start_step, + nsys_end_step=args.nsys_end_step, + nsys_ranks=args.nsys_ranks, + dataset_class=args.dataset_class, + config_class=args.config_class, + overlap_grad_reduce=args.overlap_grad_reduce, + overlap_param_gather=not args.no_overlap_param_gather, + average_in_collective=not args.no_average_in_collective, + grad_reduce_in_fp32=args.grad_reduce_in_fp32, + ) + + +def get_parser(): + """Return the cli parser for this tool.""" + # TODO migrate to hydra config + # Parse the arguments and pull them out into local variables for ease of future refactor to a + # config management system. + parser = argparse.ArgumentParser(description="Pretrain ESM2 with UR data.") + parser.add_argument( + "--train-data-path", + type=Path, + required=True, + help="Path to the train data CSV file", + ) + parser.add_argument( + "--valid-data-path", + type=Path, + required=True, + help="Path to the valid data CSV file", + ) + parser.add_argument( + "--precision", + type=str, + choices=get_args(PrecisionTypes), + required=False, + default="bf16-mixed", + help="Precision type to use for training.", + ) + parser.add_argument( + "--task-type", + type=str, + choices=["regression", "classification"], + required=True, + default="regression", + help="Fine-tuning task type.", + ) + parser.add_argument( + "--encoder-frozen", + action="store_true", + default=False, + help="Freeze the encoder parameters", + ) + parser.add_argument( + "--lr", + type=float, + required=False, + default=4e-4, + help="Learning rate for training. Default is 4e-4", + ) + parser.add_argument( + "--scale-lr-layer", + type=str, + required=False, + default=None, + help="Layer name for which we scale the lr by lr-multiplier", + ) + parser.add_argument( + "--lr-multiplier", + type=float, + required=False, + default=1.0, + help="Learning rate multiplier for layers with scale-lr-layer in their name", + ) + parser.add_argument( + "--mlp-ft-dropout", + type=float, + required=False, + default=0.25, + help="Dropout for single value classification / regression mlp. Default is 0.25", + ) + parser.add_argument( + "--mlp-hidden-size", + type=int, + required=False, + default=256, + help="Dimension of hidden layer in mlp task head. Default is 256", + ) + parser.add_argument( + "--mlp-target-size", + type=int, + required=False, + default=1, + help="Output dimension of the mlp task head. Set to 1 for regression and number of classes for classification tasks. Default is 1", + ) + parser.add_argument( + "--cnn-dropout", + type=float, + required=False, + default=0.25, + help="Dropout for token-level classification cnn. Default is 0.25", + ) + parser.add_argument( + "--cnn-hidden-size", + type=int, + required=False, + default=32, + help="Hidden dimension of cnn head. Default is 32", + ) + parser.add_argument( + "--cnn-num-classes", + type=int, + required=False, + default=3, + help="Number of classes for token-level classification cnn. Default is 3", + ) + parser.add_argument( + "--create-tensorboard-logger", action="store_true", default=False, help="Create a tensorboard logger." + ) + # FIXME (@skothenhill) figure out how checkpointing and resumption should work with the new nemo trainer + parser.add_argument( + "--resume-if-exists", action="store_true", default=False, help="Resume training if a checkpoint exists." + ) + parser.add_argument( + "--result-dir", type=Path, required=False, default=Path("./results"), help="Path to the result directory." + ) + parser.add_argument("--experiment-name", type=str, required=False, default="esm2", help="Name of the experiment.") + + parser.add_argument("--wandb-entity", type=str, default=None, help="The team posting this run") + parser.add_argument("--wandb-project", type=str, default=None, help="Wandb project name ") + parser.add_argument("--wandb-tags", nargs="+", type=str, default=None, help="Tags associated with this run") + parser.add_argument( + "--wandb-group", type=str, default=None, help="A unique string shared by all runs in a given group" + ) + parser.add_argument( + "--wandb-id", type=str, default=None, help="Sets the version, mainly used to resume a previous run" + ) + parser.add_argument( + "--wandb-anonymous", action="store_true", help="Enable or explicitly disable anonymous logging" + ) + parser.add_argument( + "--wandb-log-model", action="store_true", help="Save checkpoints in wandb dir to upload on W&B servers" + ) + parser.add_argument("--wandb-offline", action="store_true", help="Use wandb in offline mode") + parser.add_argument( + "--num-gpus", + type=int, + required=False, + default=1, + help="Number of GPUs to use for training. Default is 1.", + ) + parser.add_argument( + "--num-nodes", + type=int, + required=False, + default=1, + help="Number of nodes to use for training. Default is 1.", + ) + parser.add_argument( + "--num-steps", + type=int, + required=False, + default=500000, + help="Number of steps to use for training. Default is 500000.", + ) + parser.add_argument( + "--num-dataset-workers", + type=int, + required=False, + default=1, + help="Number of workers to use for training. Default is 1.", + ) + parser.add_argument( + "--val-check-interval", + type=int, + required=False, + default=10000, + help="Number of steps between validation. Default is 10000.", + ) + parser.add_argument( + "--log-every-n-steps", + type=int, + required=False, + help="Number of steps between logging. Default is 50.", + ) + parser.add_argument( + "--min-seq-length", + type=float_or_int_or_none, + required=False, + default=None, + help="Minimum sequence length. Sampled will be padded if less than this value. Set 'None' to unset minimum.", + ) + parser.add_argument( + "--max-seq-length", + type=int, + required=False, + default=1024, + help="Maximum sequence length. Samples will be truncated if exceeds this value.", + ) + parser.add_argument( + "--limit-val-batches", + type=float_or_int_or_none, + required=False, + default=2, + help="Number of global batches used for validation if int. Fraction of validation dataset if float. Default is 2.", + ) + parser.add_argument( + "--micro-batch-size", + type=int, + required=False, + default=64, + help="Micro-batch size. Global batch size is inferred from this.", + ) + parser.add_argument( + "--pipeline-model-parallel-size", + type=int, + required=False, + default=1, + help="Pipeline model parallel size. Default is 1.", + ) + parser.add_argument( + "--tensor-model-parallel-size", + type=int, + required=False, + default=1, + help="Tensor model parallel size. Default is 1.", + ) + parser.add_argument( + "--accumulate-grad-batches", + type=int, + required=False, + default=1, + help="Gradient accumulation steps. Global batch size is inferred from this.", + ) + parser.add_argument( + "--save-last-checkpoint", + action="store_true", + default=True, + help="Save the last checkpoint.", + ) + parser.add_argument( + "--metric-to-monitor-for-checkpoints", + type=str, + required=False, + default="val_loss", + help="The metric to monitor for checkpointing.", + ) + parser.add_argument( + "--save-top-k", + type=int, + required=False, + default=2, + help="Save the top k checkpoints.", + ) + parser.add_argument( + "--restore-from-checkpoint-path", + type=Path, + required=False, + default=None, + help="Path to the checkpoint directory to restore from. Will override `--resume-if-exists` when set.", + ) + parser.add_argument( + "--nsys-profiling", + action="store_true", + default=False, + help="Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling output you must run the whole program with `nsys`. For example: " + " `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true --capture-range=cudaProfilerApi --capture-range-end=stop [regular python command here]`", + ) + # start, end, rank + parser.add_argument( + "--nsys-start-step", + type=int, + required=False, + default=0, + help="Start nsys profiling after this step.", + ) + parser.add_argument( + "--nsys-end-step", + type=int, + required=False, + help="End nsys profiling after this step.", + ) + # rank as list of integers + parser.add_argument( + "--nsys-ranks", + type=int, + nargs="+", + required=False, + default=[0], + help="Enable nsys profiling for these ranks.", + ) + # DDP config + parser.add_argument( + "--overlap-grad-reduce", + action="store_true", + default=False, + ) + parser.add_argument( + "--no-overlap-param-gather", + action="store_true", + default=False, + ) + parser.add_argument( + "--no-average-in-collective", + action="store_true", + default=False, + ) + parser.add_argument( + "--grad-reduce-in-fp32", + action="store_true", + default=False, + ) + + config_class_options: Dict[str, Type[BioBertConfig]] = SUPPORTED_CONFIGS + + def config_class_type(desc: str) -> Type[BioBertConfig]: + try: + return config_class_options[desc] + except KeyError: + raise argparse.ArgumentTypeError( + f"Do not recognize key {desc}, valid options are: {config_class_options.keys()}" + ) + + parser.add_argument( + "--config-class", + type=config_class_type, + default=ESM2FineTuneSeqConfig, + help="Model configs link model classes with losses, and handle model initialization (including from a prior " + "checkpoint). This is how you can fine-tune a model. First train with one config class that points to one model " + "class and loss, then implement and provide an alternative config class that points to a variant of that model " + "and alternative loss. In the future this script should also provide similar support for picking different data " + f"modules for fine-tuning with different data types. Choices: {config_class_options.keys()}", + ) + + dataset_class_options: Dict[str, Type[InMemoryProteinDataset]] = SUPPORTED_DATASETS + + def dataset_class_type(desc: str) -> Type[InMemoryProteinDataset]: + try: + return dataset_class_options[desc] + except KeyError: + raise argparse.ArgumentTypeError( + f"Do not recognize key {desc}, valid options are: {dataset_class_options.keys()}" + ) + + parser.add_argument( + "--dataset-class", + type=dataset_class_type, + default=InMemorySingleValueDataset, + help=f"Dataset class name for finetuning. Choices: {config_class_options.keys()}", + ) + return parser + + +if __name__ == "__main__": + finetune_esm2_entrypoint() diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py index bdfaa4fe6b..5dbb86aac9 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/infer_esm2.py @@ -23,9 +23,10 @@ from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype from bionemo.esm2.api import ESM2Config from bionemo.esm2.data.tokenizer import get_tokenizer -from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule, InMemoryCSVDataset -from bionemo.esm2.model.finetune.finetune_regressor import ESM2FineTuneSeqConfig -from bionemo.esm2.model.finetune.finetune_token_classifier import ESM2FineTuneTokenConfig +from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule +from bionemo.esm2.model.finetune.dataset import InMemoryProteinDataset +from bionemo.esm2.model.finetune.sequence_model import ESM2FineTuneSeqConfig +from bionemo.esm2.model.finetune.token_model import ESM2FineTuneTokenConfig from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.biobert.model import BioBertConfig from bionemo.llm.utils.callbacks import IntervalT, PredictionWriter @@ -110,7 +111,7 @@ def infer_model( plugins=nl.MegatronMixedPrecision(precision=precision), ) - dataset = InMemoryCSVDataset(data_path=data_path) + dataset = InMemoryProteinDataset.from_csv(data_path, ignore_labels=True) datamodule = ESM2FineTuneDataModule( predict_dataset=dataset, micro_batch_size=micro_batch_size, diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py index 928ff81fa8..d1f624fbf1 100644 --- a/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/scripts/train_esm2.py @@ -25,13 +25,13 @@ from nemo.lightning import resume from nemo.lightning.pytorch import callbacks as nl_callbacks from nemo.lightning.pytorch.optim import MegatronOptimizerModule +from nemo.utils.exp_manager import TimingCallback from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype from bionemo.esm2.api import ESM2Config from bionemo.esm2.data.datamodule import ESMDataModule from bionemo.esm2.data.dataset import RandomMaskStrategy from bionemo.esm2.data.tokenizer import get_tokenizer -from bionemo.llm.lightning import PerplexityLoggingCallback from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.biobert.model import BiobertSpecOption from bionemo.llm.model.lr_scheduler import WarmupAnnealDecayHoldScheduler @@ -84,6 +84,8 @@ def main( save_best_checkpoint: bool = True, save_last_checkpoint: bool = True, metric_to_monitor_for_checkpoints: str = "val_loss", + log_train_ppl: bool = False, + log_val_ppl: bool = True, save_top_k: int = 2, nsys_profiling: bool = False, nsys_start_step: int = 0, @@ -145,6 +147,8 @@ def main( save_best_checkpoint (bool): whether to save the best checkpoint save_last_checkpoint (bool): whether to save the last checkpoint metric_to_monitor_for_checkpoints (str): metric to monitor for checkpoints + log_train_ppl (bool): log training perplexity + log_val_ppl (bool): log validation perplexity save_top_k (int): number of top checkpoints to save nsys_profiling (bool): whether to enable nsys profiling nsys_start_step (int): start step for nsys profiling @@ -211,10 +215,10 @@ def main( ) callbacks = [ - PerplexityLoggingCallback(log_train=False, log_val=True), RichModelSummary(max_depth=4), LearningRateMonitor(), nl_callbacks.PreemptionCallback(), + TimingCallback(), ] if nsys_profiling: if nsys_end_step is None: @@ -301,6 +305,9 @@ def main( anneal_percentage=0.10, ), ), + # perplexity logging + log_train_ppl=log_train_ppl, + log_val_ppl=log_val_ppl, ) # Configure our custom Checkpointer @@ -384,6 +391,8 @@ def train_esm2_entrypoint(): save_best_checkpoint=args.save_best_checkpoint, save_last_checkpoint=args.save_last_checkpoint, metric_to_monitor_for_checkpoints=args.metric_to_monitor_for_checkpoints, + log_train_ppl=args.log_train_ppl, + log_val_ppl=args.log_val_ppl, save_top_k=args.save_top_k, nsys_profiling=args.nsys_profiling, nsys_start_step=args.nsys_start_step, @@ -637,6 +646,25 @@ def get_parser(): default="val_loss", help="The metric to monitor for checkpointing.", ) + parser.add_argument( + "--log-train-ppl", + action="store_true", + default=False, + help="Log perplexity during training. Requires synchronization every training step and hurts performance. Enable only when necessary.", + ) + parser.add_argument( + "--log-val-ppl", + action="store_true", + default=False, + help="Log perplexity during validation.", + ) + parser.add_argument( + "--no-log-val-ppl", + action="store_false", + dest="log_val_ppl", + default=True, + help="Disable logging perplexity during validation.", + ) parser.add_argument( "--save-top-k", type=int, diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/testing/__init__.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/testing/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/testing/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-esm2/src/bionemo/esm2/testing/compare.py b/sub-packages/bionemo-esm2/src/bionemo/esm2/testing/compare.py new file mode 100644 index 0000000000..e8690c1d04 --- /dev/null +++ b/sub-packages/bionemo-esm2/src/bionemo/esm2/testing/compare.py @@ -0,0 +1,99 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import gc +from pathlib import Path + +import torch +from megatron.core.transformer.module import Float16Module +from transformers import AutoModelForMaskedLM + +from bionemo.core.utils.dtypes import PrecisionTypes, get_autocast_dtype +from bionemo.esm2.data.tokenizer import get_tokenizer +from bionemo.esm2.model.model import ESM2Config + + +def assert_model_equivalence( + ckpt_path: Path | str, + model_tag: str, + precision: PrecisionTypes = "fp32", + rtol: float | None = None, + atol: float | None = None, +) -> None: + """Testing utility to compare the outputs of a NeMo2 checkpoint to the original HuggingFace model weights. + + Compares the cosine similarity of the logit and hidden state outputs of a NeMo2 model checkpoint to the outputs of + the corresponding HuggingFace model. + + Args: + ckpt_path: A path to a NeMo2 checkpoint for an ESM-2 model. + model_tag: The HuggingFace model tag for the model to compare against. + precision: The precision type to use for the comparison. Defaults to "fp32". + rtol: The relative tolerance to use for the comparison. Defaults to None, which chooses the tolerance based on + the precision. + atol: The absolute tolerance to use for the comparison. Defaults to None, which chooses the tolerance based on + the precision. + """ + tokenizer = get_tokenizer() + + test_proteins = [ + "MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLA", + "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLAGG", + ] + tokens = tokenizer(test_proteins, return_tensors="pt", padding=True, truncation=True).to("cuda") + input_ids = tokens["input_ids"] + attention_mask = tokens["attention_mask"] + + dtype = get_autocast_dtype(precision) + nemo_config = ESM2Config( + initial_ckpt_path=str(ckpt_path), + include_embeddings=True, + include_hiddens=True, + params_dtype=dtype, + pipeline_dtype=dtype, + autocast_dtype=dtype, + bf16=dtype is torch.bfloat16, + fp16=dtype is torch.float16, + ) + + nemo_model = nemo_config.configure_model(tokenizer).to("cuda").eval() + + if dtype is torch.float16 or dtype is torch.bfloat16: + nemo_model = Float16Module(nemo_config, nemo_model) + + nemo_output = nemo_model(input_ids, attention_mask) + nemo_logits = nemo_output["token_logits"].transpose(0, 1).contiguous()[..., : tokenizer.vocab_size] + nemo_hidden_state = nemo_output["hidden_states"] + + del nemo_model + gc.collect() + torch.cuda.empty_cache() + + hf_model = AutoModelForMaskedLM.from_pretrained(model_tag, torch_dtype=get_autocast_dtype(precision)).cuda().eval() + hf_output_all = hf_model(input_ids, attention_mask, output_hidden_states=True) + hf_hidden_state = hf_output_all.hidden_states[-1] + + # Rather than directly comparing the logit or hidden state tensors, we compare their cosine similarity. These + # should be essentially 1 if the outputs are equivalent, but is less sensitive to small numerical differences. + # We don't care about the padding tokens, so we only compare the non-padding tokens. + logit_similarity = torch.nn.functional.cosine_similarity(nemo_logits, hf_output_all.logits, dim=2) + logit_similarity = logit_similarity[attention_mask == 1] + + hidden_state_similarity = torch.nn.functional.cosine_similarity(nemo_hidden_state, hf_hidden_state, dim=2) + hidden_state_similarity = hidden_state_similarity[attention_mask == 1] + + torch.testing.assert_close(logit_similarity, torch.ones_like(logit_similarity), rtol=rtol, atol=atol) + torch.testing.assert_close(hidden_state_similarity, torch.ones_like(hidden_state_similarity), rtol=rtol, atol=atol) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/conftest.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/conftest.py index 2e0c7a0f7f..7e7dfb1b23 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/conftest.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/conftest.py @@ -87,3 +87,25 @@ def dummy_data_single_value_regression_ft(dummy_data_per_token_classification_ft """ data = [(seq, len(seq) / 100.0) for seq, _ in dummy_data_per_token_classification_ft] return data + + +@pytest.fixture +def dummy_data_single_value_classification_ft(dummy_data_per_token_classification_ft): + """Fixture providing dummy data for per-token classification fine-tuning. + + Returns: + list: A list of dummy data for per-token classification fine-tuning. + """ + data = [(seq, f"Class_{label[0]}") for seq, label in dummy_data_per_token_classification_ft] + return data + + +@pytest.fixture +def dummy_protein_sequences(dummy_data_per_token_classification_ft): + """Fixture providing dummy data for per-token classification fine-tuning. + + Returns: + list: A list of dummy data for per-token classification fine-tuning. + """ + data = [seq for seq, _ in dummy_data_per_token_classification_ft] + return data diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py index c5d0ee73fe..fe47cd2fe3 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/data/test_datamodule.py @@ -39,6 +39,21 @@ def test_create_esm_datamodule_raises_without_trainer(dummy_protein_dataset, dum data_module.setup() +def test_esm_datamodule_sets_min_seq_len_to_max_seq_len(dummy_protein_dataset, dummy_parquet_train_val_inputs): + train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs + + # Initialize the data module. + data_module = ESMDataModule( + train_cluster_path=train_cluster_path, + train_database_path=dummy_protein_dataset, + valid_cluster_path=valid_cluster_path, + valid_database_path=dummy_protein_dataset, + max_seq_length=36, + ) + + assert data_module._min_seq_length == 36 + + def test_create_esm_datamodule_raises_without_trainer_max_steps(dummy_protein_dataset, dummy_parquet_train_val_inputs): train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_datamodule.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_datamodule.py new file mode 100644 index 0000000000..3a8c3cd98d --- /dev/null +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_datamodule.py @@ -0,0 +1,81 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pandas as pd +import pytest +from torch.utils.data import DataLoader + +from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule +from bionemo.esm2.model.finetune.dataset import InMemoryProteinDataset + + +@pytest.fixture +def dummy_protein_csv(tmp_path, dummy_protein_sequences): + """Create a mock protein dataset.""" + csv_file = tmp_path / "protein_dataset.csv" + # Create a DataFrame + df = pd.DataFrame(dummy_protein_sequences, columns=["sequences"]) + + # Save the DataFrame to a CSV file + df.to_csv(csv_file, index=False) + return csv_file + + +@pytest.fixture +def dataset(dummy_protein_csv): + return InMemoryProteinDataset.from_csv(dummy_protein_csv, ignore_labels=True) + + +@pytest.fixture +def data_module(dataset): + return ESM2FineTuneDataModule(predict_dataset=dataset) + + +def test_in_memory_csv_dataset(dataset): + assert len(dataset) > 0 + sample = dataset[0] + assert isinstance(sample, dict) + assert "text" in sample + assert "labels" in sample + + +def test_esm2_fine_tune_data_module_init(data_module): + assert data_module.train_dataset is None + assert data_module.valid_dataset is None + assert data_module.predict_dataset is not None + + +def test_esm2_fine_tune_data_module_predict_dataloader(data_module): + predict_dataloader = data_module.predict_dataloader() + assert isinstance(predict_dataloader, DataLoader) + batch = next(iter(predict_dataloader)) + assert isinstance(batch, dict) + assert "text" in batch + + +def test_esm2_fine_tune_data_module_setup(data_module): + with pytest.raises(RuntimeError): + data_module.setup("fit") + + +def test_esm2_fine_tune_data_module_train_dataloader(data_module): + with pytest.raises(AttributeError): + data_module.train_dataloader() + + +def test_esm2_fine_tune_data_module_val_dataloader(data_module): + with pytest.raises(AttributeError): + data_module.val_dataloader() diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_dataset.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_dataset.py new file mode 100644 index 0000000000..8fdcfa8093 --- /dev/null +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_dataset.py @@ -0,0 +1,174 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pandas as pd +import pytest +import torch +from torch import Tensor + +from bionemo.esm2.model.finetune.dataset import ( + InMemoryPerTokenValueDataset, + InMemoryProteinDataset, + InMemorySingleValueDataset, +) +from bionemo.llm.data.collate import MLM_LOSS_IGNORE_INDEX +from bionemo.llm.data.label2id_tokenizer import Label2IDTokenizer + + +def data_to_csv(data, tmp_path, with_label=True): + """Create a mock protein dataset.""" + csv_file = tmp_path / "protein_dataset.csv" + # Create a DataFrame + df = pd.DataFrame(data, columns=["sequences", "labels"] if with_label else ["sequences"]) + + # Save the DataFrame to a CSV file + df.to_csv(csv_file, index=False) + return csv_file + + +@pytest.fixture +def dataset_no_labels(dummy_protein_sequences, tmp_path): + csv_path = data_to_csv(dummy_protein_sequences, tmp_path, with_label=False) + return InMemoryProteinDataset.from_csv(csv_path, ignore_labels=True) + + +@pytest.fixture +def dataset_regression_labels(dummy_data_single_value_regression_ft, tmp_path): + csv_path = data_to_csv(dummy_data_single_value_regression_ft, tmp_path, with_label=True) + return InMemorySingleValueDataset.from_csv(csv_path, ignore_labels=False, task_type="regression") + + +@pytest.fixture +def dataset_per_token_classification_labels(dummy_data_per_token_classification_ft, tmp_path): + csv_path = data_to_csv(dummy_data_per_token_classification_ft, tmp_path, with_label=True) + return InMemoryPerTokenValueDataset.from_csv(csv_path, ignore_labels=False, task_type="classification") + + +def test_in_memory_protein_dataset_length_no_labels(dataset_no_labels, dummy_protein_sequences): + assert len(dataset_no_labels) == len(dummy_protein_sequences) + + +def test_in_memory_protein_dataset_length_with_regression_labels( + dataset_regression_labels, dummy_data_single_value_regression_ft +): + assert len(dataset_regression_labels) == len(dummy_data_single_value_regression_ft) + + +def test_in_memory_protein_dataset_length_with_class_labels( + dataset_per_token_classification_labels, dummy_data_per_token_classification_ft +): + assert len(dataset_per_token_classification_labels) == len(dummy_data_per_token_classification_ft) + + +def test_in_memory_protein_dataset_getitem_no_labels(dataset_no_labels): + sample = dataset_no_labels[0] + assert isinstance(sample, dict) + assert "text" in sample + assert "labels" in sample + assert isinstance(sample["text"], Tensor) + assert isinstance(sample["labels"], Tensor) + + +def test_in_memory_protein_dataset_getitem_with_regression_labels(dataset_regression_labels): + assert isinstance(dataset_regression_labels, InMemoryProteinDataset) + sample = dataset_regression_labels[0] + assert isinstance(sample, dict) + assert "text" in sample + assert "labels" in sample + assert isinstance(sample["text"], Tensor) + assert isinstance(sample["labels"], Tensor) + assert sample["labels"].dtype == torch.float + + +def test_in_memory_protein_dataset_getitem_with_class_labels(dataset_per_token_classification_labels): + assert isinstance(dataset_per_token_classification_labels, InMemoryProteinDataset) + assert isinstance(dataset_per_token_classification_labels.label_tokenizer, Label2IDTokenizer) + assert dataset_per_token_classification_labels.label_cls_eos_id == MLM_LOSS_IGNORE_INDEX + + sample = dataset_per_token_classification_labels[0] + assert isinstance(sample, dict) + assert "text" in sample + assert "labels" in sample + assert isinstance(sample["text"], Tensor) + assert isinstance(sample["labels"], Tensor) + assert sample["labels"].dtype == torch.int64 + + +def test_in_memory_protein_dataset_tokenization(dataset_no_labels): + sample = dataset_no_labels[0] + tokenized_sequence = sample["text"] + assert isinstance(tokenized_sequence, Tensor) + assert tokenized_sequence.ndim == 1 # Ensure it's flattened. + + +def test_transofrm_classification_label( + dataset_per_token_classification_labels, dummy_data_per_token_classification_ft +): + pre_transfrom = dummy_data_per_token_classification_ft[0][1] + label_ids = torch.tensor(dataset_per_token_classification_labels.label_tokenizer.text_to_ids(pre_transfrom)) + cls_eos = torch.tensor([dataset_per_token_classification_labels.label_cls_eos_id]) + post_transform = torch.cat((cls_eos, label_ids, cls_eos)) + + assert torch.equal(dataset_per_token_classification_labels.transform_label(pre_transfrom), post_transform) + + +def test_transofrm_regression_label(dataset_regression_labels): + """Ensure labels are transformed correctly.""" + transformed_label = dataset_regression_labels.transform_label(1.0) + assert isinstance(transformed_label, Tensor) + assert transformed_label.dtype == torch.float + + +def test_in_memory_protein_dataset_no_labels_fallback(dataset_no_labels): + """Ensure the dataset works even when labels are missing.""" + sample = dataset_no_labels[0] + assert isinstance(sample, dict) + assert "labels" in sample + assert isinstance(sample["labels"], Tensor) + + +def test_in_memory_protein_dataset_invalid_index(dataset_no_labels): + """Test if out-of-range index raises an error.""" + with pytest.raises(KeyError): + _ = dataset_no_labels[100] + + +def test_in_memory_protein_dataset_missing_sequences_column(tmp_path): + """Test behavior when the CSV file is empty.""" + csv_file = tmp_path / "invalid.csv" + pd.DataFrame({"wrong_column": ["MKTFFS"]}).to_csv(csv_file, index=False) + with pytest.raises(KeyError): + _ = InMemoryProteinDataset.from_csv(csv_file, ignore_labels=True) + + +def test_in_memory_protein_dataset_special_tokens_masking(dataset_no_labels): + """Ensure loss mask correctly handles special tokens.""" + sample = dataset_no_labels[0] + assert "loss_mask" in sample + assert isinstance(sample["loss_mask"], Tensor) + assert sample["loss_mask"].dtype == torch.bool + + +def test_in_memory_protein_dataset_non_existent_file(): + """Ensure proper error handling for missing files.""" + with pytest.raises(FileNotFoundError): + InMemoryProteinDataset.from_csv("non_existent_file.csv") + + +def test_load_w_missing_labels(dummy_protein_sequences, tmp_path): + csv_path = data_to_csv(dummy_protein_sequences, tmp_path, with_label=False) + with pytest.raises(KeyError): + InMemoryProteinDataset.from_csv(csv_path, ignore_labels=False) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py deleted file mode 100644 index 9c49d70c42..0000000000 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_finetune.py +++ /dev/null @@ -1,143 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import pytest -from nemo.lightning import io - -from bionemo.core.data.load import load -from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule -from bionemo.esm2.model.finetune.finetune_regressor import ( - ESM2FineTuneSeqConfig, - InMemorySingleValueDataset, -) -from bionemo.esm2.model.finetune.finetune_token_classifier import ( - ESM2FineTuneTokenConfig, - InMemoryPerTokenValueDataset, -) -from bionemo.esm2.model.finetune.peft import ESM2LoRA -from bionemo.esm2.model.finetune.train import train_model -from bionemo.testing import megatron_parallel_state_utils -from bionemo.testing.callbacks import MetricTracker - - -# To download a 8M internally pre-trained ESM2 model -pretrain_ckpt_path = load("esm2/nv_8m:2.0") - - -@pytest.mark.needs_gpu -@pytest.mark.parametrize("with_peft", [True, False]) -def test_esm2_finetune_token_classifier( - tmp_path, - tokenizer, - dummy_data_per_token_classification_ft, - with_peft: bool, - n_steps_train: int = 50, - seed: int = 42, -): - if with_peft: - pytest.xfail("FIXME PEFT fine-tuning not supported with fusions active") - - with megatron_parallel_state_utils.distributed_model_parallel_state(seed): - if with_peft: - peft = ESM2LoRA() - else: - peft = None - esm2_finetune_config = ESM2FineTuneTokenConfig(initial_ckpt_path=str(pretrain_ckpt_path)) - dataset = InMemoryPerTokenValueDataset(dummy_data_per_token_classification_ft, seed=seed) - finetune_data_module = ESM2FineTuneDataModule(dataset, dataset) - simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( - experiment_name="finetune_new_head", - experiment_dir=tmp_path / "finetune_new_head", # new checkpoint will land in a subdir of this - config=esm2_finetune_config, # same config as before since we are just continuing training - data_module=finetune_data_module, - n_steps_train=n_steps_train, - metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), - tokenizer=tokenizer, - peft=peft, - _use_rich_model_summary=False, - ) - - weights_ckpt = simple_ft_checkpoint / "weights" - assert weights_ckpt.exists() - assert weights_ckpt.is_dir() - assert io.is_distributed_ckpt(weights_ckpt) - assert simple_ft_metrics.collection_train["loss"][0] > simple_ft_metrics.collection_train["loss"][-1] - - if with_peft: - assert trainer.model.model_transform is not None - model = trainer.model[0].module.module.module - assert all(not p.requires_grad for p in model.embedding.parameters()) - assert all(not p.requires_grad for name, p in model.encoder.named_parameters() if "adapter" not in name) - assert all(p.requires_grad for name, p in model.encoder.named_parameters() if "adapter" in name) - assert all(p.requires_grad for p in model.classification_head.parameters()) - else: - encoder_requires_grad = [ - p.requires_grad for name, p in trainer.model.named_parameters() if "classification_head" not in name - ] - assert not all(encoder_requires_grad), "Pretrained model is not fully frozen during fine-tuning" - - -@pytest.mark.needs_gpu -@pytest.mark.parametrize("with_peft", [True, False]) -def test_esm2_finetune_regressor( - tmp_path, - tokenizer, - dummy_data_single_value_regression_ft, - with_peft: bool, - n_steps_train: int = 50, - seed: int = 42, -): - if with_peft: - pytest.xfail("FIXME PEFT fine-tuning not supported") - - with megatron_parallel_state_utils.distributed_model_parallel_state(seed): - if with_peft: - peft = ESM2LoRA() - else: - peft = None - esm2_regression_finetune_config = ESM2FineTuneSeqConfig(initial_ckpt_path=str(pretrain_ckpt_path)) - dataset = InMemorySingleValueDataset(dummy_data_single_value_regression_ft, seed=seed) - finetune_data_module = ESM2FineTuneDataModule(dataset, dataset) - simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( - experiment_name="finetune_new_head_regression", - experiment_dir=tmp_path / "finetune_new_head_regression", # new checkpoint will land in a subdir of this - config=esm2_regression_finetune_config, # same config as before since we are just continuing training - data_module=finetune_data_module, - n_steps_train=n_steps_train, - metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), - tokenizer=tokenizer, - peft=peft, - _use_rich_model_summary=False, - ) - - weights_ckpt = simple_ft_checkpoint / "weights" - assert weights_ckpt.exists() - assert weights_ckpt.is_dir() - assert io.is_distributed_ckpt(weights_ckpt) - assert simple_ft_metrics.collection_train["loss"][0] > simple_ft_metrics.collection_train["loss"][-1] - - if with_peft: - assert trainer.model.model_transform is not None - model = trainer.model[0].module.module.module - assert all(not p.requires_grad for p in model.embedding.parameters()) - assert all(not p.requires_grad for name, p in model.encoder.named_parameters() if "adapter" not in name) - assert all(p.requires_grad for name, p in model.encoder.named_parameters() if "adapter" in name) - assert all(p.requires_grad for p in model.regression_head.parameters()) - else: - encoder_requires_grad = [ - p.requires_grad for name, p in trainer.model.named_parameters() if "regression_head" not in name - ] - assert not all(encoder_requires_grad), "Pretrained model is not fully frozen during fine-tuning" diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_sequence_model.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_sequence_model.py new file mode 100644 index 0000000000..68b11394a4 --- /dev/null +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_sequence_model.py @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest + +from bionemo.core.data.load import load +from bionemo.esm2.data import tokenizer +from bionemo.esm2.model.finetune.sequence_model import ( + ESM2FineTuneSeqConfig, + ESM2FineTuneSeqModel, + MegatronMLPHead, +) +from bionemo.testing import megatron_parallel_state_utils + + +@pytest.fixture +def config(): + return ESM2FineTuneSeqConfig(encoder_frozen=True, mlp_ft_dropout=0.50, initial_ckpt_path=str(load("esm2/8m:2.0"))) + + +@pytest.fixture +def finetune_seq_model(config): + with megatron_parallel_state_utils.distributed_model_parallel_state(): + model = config.configure_model(tokenizer.get_tokenizer()) + yield model + + +def test_ft_config(config): + assert config.initial_ckpt_skip_keys_with_these_prefixes == ["regression_head"] + assert config.encoder_frozen + assert config.mlp_ft_dropout == 0.50 + + +def test_ft_model_initialized(finetune_seq_model): + assert isinstance(finetune_seq_model, ESM2FineTuneSeqModel) + assert isinstance(finetune_seq_model.regression_head, MegatronMLPHead) + assert finetune_seq_model.post_process + assert not finetune_seq_model.include_embeddings_finetuning diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_token_model.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_token_model.py new file mode 100644 index 0000000000..c9f3411011 --- /dev/null +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/finetune/test_token_model.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest + +from bionemo.esm2.data import tokenizer +from bionemo.esm2.model.finetune.token_model import ( + ESM2FineTuneTokenConfig, + ESM2FineTuneTokenModel, + MegatronConvNetHead, +) +from bionemo.testing import megatron_parallel_state_utils + + +@pytest.fixture +def config(): + return ESM2FineTuneTokenConfig(encoder_frozen=True, cnn_dropout=0.1, cnn_hidden_size=32, cnn_num_classes=5) + + +@pytest.fixture +def finetune_token_model(config): + with megatron_parallel_state_utils.distributed_model_parallel_state(): + model = config.configure_model(tokenizer.get_tokenizer()) + yield model + + +def test_ft_config(config): + assert config.initial_ckpt_skip_keys_with_these_prefixes == ["classification_head"] + assert config.encoder_frozen + assert config.cnn_dropout == 0.1 + assert config.cnn_hidden_size == 32 + assert config.cnn_num_classes == 5 + + +def test_ft_model_initialized(finetune_token_model): + assert isinstance(finetune_token_model, ESM2FineTuneTokenModel) + assert isinstance(finetune_token_model.classification_head, MegatronConvNetHead) + assert finetune_token_model.post_process + assert not finetune_token_model.include_hiddens_finetuning diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_convert.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_convert.py new file mode 100644 index 0000000000..de8a23a107 --- /dev/null +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_convert.py @@ -0,0 +1,55 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +from nemo.lightning import io + +from bionemo.esm2.model.convert import HFESM2Importer # noqa: F401 +from bionemo.esm2.model.model import ESM2Config +from bionemo.esm2.testing.compare import assert_model_equivalence +from bionemo.llm.model.biobert.lightning import biobert_lightning_module +from bionemo.testing import megatron_parallel_state_utils + + +# pytestmark = pytest.mark.xfail( +# reason="These tests are failing due to a bug in nemo global state when run in the same process as previous " +# "checkpoint save/load scripts." +# ) + + +def test_nemo2_conversion_equivalent_8m(tmp_path): + model_tag = "facebook/esm2_t6_8M_UR50D" + module = biobert_lightning_module(config=ESM2Config()) + io.import_ckpt(module, f"hf://{model_tag}", tmp_path / "nemo_checkpoint") + with megatron_parallel_state_utils.distributed_model_parallel_state(): + assert_model_equivalence(tmp_path / "nemo_checkpoint", model_tag) + + +def test_nemo2_conversion_equivalent_8m_bf16(tmp_path): + model_tag = "facebook/esm2_t6_8M_UR50D" + module = biobert_lightning_module(config=ESM2Config()) + io.import_ckpt(module, f"hf://{model_tag}", tmp_path / "nemo_checkpoint") + with megatron_parallel_state_utils.distributed_model_parallel_state(precision="bf16"): + assert_model_equivalence(tmp_path / "nemo_checkpoint", model_tag, precision="bf16") + + +@pytest.mark.slow +def test_nemo2_conversion_equivalent_650m(tmp_path): + model_tag = "facebook/esm2_t33_650M_UR50D" + module = biobert_lightning_module(config=ESM2Config()) + io.import_ckpt(module, f"hf://{model_tag}", tmp_path / "nemo_checkpoint") + with megatron_parallel_state_utils.distributed_model_parallel_state(): + assert_model_equivalence(tmp_path / "nemo_checkpoint", model_tag, atol=1e-4, rtol=1e-4) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py index 63630cc49d..8895b3719a 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/model/test_model.py @@ -13,19 +13,14 @@ # See the License for the specific language governing permissions and # limitations under the License. -import gc import io import tarfile -from copy import deepcopy -from pathlib import Path -from typing import List, Tuple from unittest import mock import pytest import torch -from nemo.collections.common.tokenizers.huggingface.auto_tokenizer import AutoTokenizer from torch import Tensor -from transformers import EsmForMaskedLM +from transformers import AutoModelForMaskedLM from bionemo.core.data.load import load from bionemo.core.utils.dtypes import get_autocast_dtype @@ -34,77 +29,65 @@ from bionemo.esm2.data.datamodule import ESMDataModule from bionemo.esm2.data.tokenizer import get_tokenizer from bionemo.esm2.model.embedding import ESM2Embedding +from bionemo.esm2.testing.compare import assert_model_equivalence from bionemo.llm.model.biobert.model import MegatronBioBertModel from bionemo.llm.utils.weight_utils import nemo1_to_nemo2_biobert_key_mapping from bionemo.testing import megatron_parallel_state_utils -nemo1_checkpoint_path: Path = load("esm2/nv_650m:1.0") - +def test_esm2_model_initialized(): + with megatron_parallel_state_utils.distributed_model_parallel_state(): + tokenizer = get_tokenizer() + config = ESM2Config() + model = config.configure_model(tokenizer) -def reduce_hiddens(hiddens: Tensor, attention_mask: Tensor) -> Tensor: - """reduce last layer's hidden values to embeddings + assert isinstance(model, MegatronBioBertModel) + assert isinstance(model, ESM2Model) + assert isinstance(model.embedding, ESM2Embedding) - Args: - hiddens: [b, s, h] tensor of hidden values - attention_mask: [b, s] attention mask tensor - Returns: - reduced embedding tensor [b, h] - """ - masks = torch.sum(attention_mask, dim=1) - embeddings = torch.zeros( - size=(hiddens.shape[0], hiddens.shape[2]), - dtype=torch.float32, - device=torch.cuda.current_device(), - ) - for i, (hidden, mask) in enumerate(zip(hiddens, masks)): - embeddings[i, :] = torch.mean(hidden[1 : mask - 1], dim=0) - return embeddings +def test_esm2_nemo1_checkpoint(): + with tarfile.open(load("esm2/nv_650m:1.0"), "r") as ckpt, torch.no_grad(): + ckpt_file = ckpt.extractfile("./model_weights.ckpt") + old_state_dict = torch.load(ckpt_file) + # megatron is not registering inv_freq params anymore. + # TODO: update Bionemo checkpoints + old_state_dict.pop("model.language_model.rotary_pos_emb.inv_freq") -@pytest.fixture(scope="module") -def esm2_config() -> ESM2Config: - with megatron_parallel_state_utils.distributed_model_parallel_state(): - yield ESM2Config() + with megatron_parallel_state_utils.distributed_model_parallel_state(): + tokenizer = get_tokenizer() + config = ESM2Config() + model = config.configure_model(tokenizer) + new_state_dict = model.state_dict_for_save_checkpoint() + # Set the new_model_prefix to "" since we are looking at the base megatron model and not the lightning module + # which stores a copy of this model into self.module + old_keys = { + nemo1_to_nemo2_biobert_key_mapping(k, new_model_prefix="", te_mapping=True) for k in old_state_dict + } + assert len(old_keys) == len(old_state_dict), "Mapping unexpectedly discarded some keys." -@pytest.fixture(scope="module") -def esm2_650M_config_w_ckpt() -> ESM2Config: - with megatron_parallel_state_utils.distributed_model_parallel_state(): - yield ESM2Config(nemo1_ckpt_path=nemo1_checkpoint_path) + new_keys = set(new_state_dict) + for k, v in old_state_dict.items(): + # Make sure the shapes of the weights match. + assert ( + new_state_dict[nemo1_to_nemo2_biobert_key_mapping(k, new_model_prefix="", te_mapping=True)].shape + == v.shape + ) + extra_keys = new_keys.difference(old_keys) + extra_non_null_keys = { + k + for k in extra_keys + if not k.endswith("._extra_state") + and new_state_dict[k] is not None + and not isinstance(new_state_dict[k], io.BytesIO) + } + assert not extra_non_null_keys, "There are new keys that have state that is missing from the old checkpoint." -@pytest.fixture(scope="module") -def esm2_model(esm2_config) -> ESM2Model: - with megatron_parallel_state_utils.distributed_model_parallel_state(): - tokenizer = get_tokenizer() - model = esm2_config.configure_model(tokenizer) - yield model - - -@pytest.fixture(scope="module") -def sample_data() -> List[Tuple[str, str]]: - """Generates sample protein sequences for sanity checks, including mask tokens.""" - max_length = 1022 # The maximum length of the protein sequences to be considered. - sample_data = [ - ( - "protein1", - "MNGTEGPNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQHKKLRTPLNYILLNLAVADLFMVLGGFTSTLYTSLHGYFVFGPTGCNLEGFFATLGGEIALWSLVVLAIERYVVVCKPMSNFRFGENHAIMGVAFTWVMALACAAPPLAGWSRYIPEGLQCSCGIDYYTLKPEVNNESFVIYMFVVHFTIPMIIIFFCYGQLVFTVKEAAAQQQESATTQKAEKEVTRMVIIMVIAFLICWVPYASVAFYIFTHQGSNFGPIFMTIPAFFAKSAAIYNPVIYIMMNKQFRNCMLTTICCGKNPLGDDEASATVSKTETSQVAPA", - ), - ("protein2", "MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLA"), - ( - "protein3", - "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLAGG", - ), - ( - "protein4", - "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLA", - ), - ] - # add another sample protein that uses the maximum length to test this edge case - sample_data.append(("protein5", (sample_data[0][1] * 3)[:max_length])) - yield sample_data + missing_old_keys = old_keys.difference(new_keys) + assert not missing_old_keys, "There are keys in the old checkpoint that are missing from the new model." def _compute_loss(model, dataloader, vocab_size=None): @@ -134,98 +117,14 @@ def _compute_loss(model, dataloader, vocab_size=None): return mean_loss -def test_esm2_model_initialized(esm2_model): - assert isinstance(esm2_model, MegatronBioBertModel) - assert isinstance(esm2_model, ESM2Model) - assert isinstance(esm2_model.embedding, ESM2Embedding) - - -def test_esm2_650m_checkpoint(esm2_model): - with tarfile.open(nemo1_checkpoint_path, "r") as ckpt, torch.no_grad(): - ckpt_file = ckpt.extractfile("./model_weights.ckpt") +def test_esm2_loss(dummy_protein_dataset, dummy_parquet_train_val_inputs): + hf_model_tag = "facebook/esm2_t6_8M_UR50D" + nv_model_tag = "esm2/8m:2.0" + # hf_model_tag = "facebook/esm2_t33_650M_UR50D" + # nv_model_tag = "esm2/650m:2.0" - old_state_dict = torch.load(ckpt_file) - # megatron is not registering inv_freq params anymore. - # TODO: update Bionemo checkpoints - old_state_dict.pop("model.language_model.rotary_pos_emb.inv_freq") - - new_state_dict = esm2_model.state_dict_for_save_checkpoint() - - # Set the new_model_prefix to "" since we are looking at the base megatron model and not the lightning module which stores a copy of - # this model into self.module - old_keys = { - nemo1_to_nemo2_biobert_key_mapping(k, new_model_prefix="", te_mapping=True) for k in old_state_dict - } - assert len(old_keys) == len(old_state_dict), "Mapping unexpectedly discarded some keys." - - new_keys = set(new_state_dict) - for k, v in old_state_dict.items(): - # Make sure the shapes of the weights match. - assert ( - new_state_dict[nemo1_to_nemo2_biobert_key_mapping(k, new_model_prefix="", te_mapping=True)].shape - == v.shape - ) - - extra_keys = new_keys.difference(old_keys) - extra_non_null_keys = { - k for k in extra_keys if new_state_dict[k] is not None and not isinstance(new_state_dict[k], io.BytesIO) - } - assert not extra_non_null_keys, "There are new keys that have state that is missing from the old checkpoint." - - missing_old_keys = old_keys.difference(new_keys) - assert not missing_old_keys, "There are keys in the old checkpoint that are missing from the new model." - - -def test_esm2_golden_values(esm2_650M_config_w_ckpt, sample_data): - tokenizer = AutoTokenizer(pretrained_model_name="facebook/esm2_t33_650M_UR50D") - tokens = tokenizer.tokenizer([row[1] for row in sample_data], return_tensors="pt", padding=True).to("cuda") - input_ids = tokens["input_ids"] - attention_mask = tokens["attention_mask"] - - # HF 650M model - hf_model = EsmForMaskedLM.from_pretrained( - "facebook/esm2_t33_650M_UR50D", torch_dtype=get_autocast_dtype(32) - ).cuda() - - with torch.no_grad(): - hf_output_all = hf_model(input_ids, attention_mask, output_hidden_states=True) - hf_logits = hf_output_all.logits * attention_mask.unsqueeze(-1) - hf_embeddings = reduce_hiddens(hf_output_all.hidden_states[-1], attention_mask) - - # free GPU RAM - del hf_model - gc.collect() - torch.cuda.empty_cache() - - # configure the model to return logits - model = esm2_650M_config_w_ckpt.configure_model(get_tokenizer()).cuda() - model.eval() - result = model(input_ids, attention_mask) - # token_logits is s,b and for simplicity here let's transpose to b,s. In general this reduces performance. - logits = result["token_logits"].transpose(0, 1).contiguous()[..., : tokenizer.vocab_size] - logits = logits * attention_mask.unsqueeze(-1) # incorporate masking logic - - # free GPU RAM - del model - gc.collect() - torch.cuda.empty_cache() - - # configure the model to return hiddens - esm2_650M_config_hiddens = deepcopy(esm2_650M_config_w_ckpt) - esm2_650M_config_hiddens.set_hparam("return_only_hidden_states", True) - model = esm2_650M_config_hiddens.configure_model(get_tokenizer()).cuda() - model.eval() - hiddens = model(input_ids, attention_mask) - embeddings = reduce_hiddens(torch.transpose(hiddens, 0, 1).float(), attention_mask) - - torch.testing.assert_close(logits, hf_logits, atol=0.2, rtol=0.0) - torch.testing.assert_close(embeddings, hf_embeddings, atol=5e-3, rtol=0.0) - - -def test_esm2_loss(esm2_650M_config_w_ckpt, dummy_protein_dataset, dummy_parquet_train_val_inputs): train_cluster_path, valid_cluster_path = dummy_parquet_train_val_inputs - compute_hf_reference: bool = True seed: int = 42 with ( @@ -235,8 +134,8 @@ def test_esm2_loss(esm2_650M_config_w_ckpt, dummy_protein_dataset, dummy_parquet ): tokenizer = get_tokenizer() - # ESM2 model initialized with 650M params - model = esm2_650M_config_w_ckpt.configure_model(tokenizer).cuda() + # ESM2 model initialized with params + model = ESM2Config(initial_ckpt_path=str(load(nv_model_tag))).configure_model(tokenizer).cuda() # Initialize the data module. data_module = ESMDataModule( @@ -268,14 +167,42 @@ def test_esm2_loss(esm2_650M_config_w_ckpt, dummy_protein_dataset, dummy_parquet mean_loss = _compute_loss(model, train_dataloader, vocab_size=tokenizer.vocab_size) - if compute_hf_reference: - # HF model initialized with 650M params - hf_model = EsmForMaskedLM.from_pretrained( - "facebook/esm2_t33_650M_UR50D", torch_dtype=get_autocast_dtype(32) - ).cuda() - hf_mean_loss = _compute_loss(hf_model, train_dataloader) - print(f"hf_mean_loss: {hf_mean_loss}") - else: - hf_mean_loss = torch.tensor(2.9279041290283203).cuda() + # HF model initialized with params + hf_model = AutoModelForMaskedLM.from_pretrained(hf_model_tag, torch_dtype=get_autocast_dtype(32)).cuda() + hf_mean_loss = _compute_loss(hf_model, train_dataloader) + print(f"hf_mean_loss: {hf_mean_loss}") torch.testing.assert_close(mean_loss, hf_mean_loss, atol=1e-3, rtol=0.0) + + +@pytest.mark.parametrize("precision", ["fp32", "bf16", "fp16", "bf16-mixed"]) +def test_model_equivalence_with_huggingface_8m(precision): + model_tag = "facebook/esm2_t6_8M_UR50D" + ckpt_path = load("esm2/8m:2.0") + with megatron_parallel_state_utils.distributed_model_parallel_state(precision=precision): + assert_model_equivalence(ckpt_path, model_tag, precision=precision) + + +@pytest.mark.slow +def test_model_equivalence_with_huggingface_650m(): + model_tag = "facebook/esm2_t33_650M_UR50D" + ckpt_path = load("esm2/650m:2.0") + with megatron_parallel_state_utils.distributed_model_parallel_state(): + assert_model_equivalence(ckpt_path, model_tag, atol=1e-4, rtol=1e-4) + + +@pytest.mark.slow +def test_model_equivalence_with_huggingface_650m_bf16(): + model_tag = "facebook/esm2_t33_650M_UR50D" + ckpt_path = load("esm2/650m:2.0") + with megatron_parallel_state_utils.distributed_model_parallel_state(precision="bf16"): + assert_model_equivalence(ckpt_path, model_tag, precision="bf16") + + +@pytest.mark.slow +@pytest.mark.skip(reason="This test triggers a large download from huggingface and requires considerable GPU memory.") +def test_model_equivalence_with_huggingface_3b(): + model_tag = "facebook/esm2_t36_3B_UR50D" + ckpt_path = load("esm2/3b:2.0") + with megatron_parallel_state_utils.distributed_model_parallel_state(): + assert_model_equivalence(ckpt_path, model_tag, atol=1e-4, rtol=1e-4) diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_finetune_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_finetune_esm2.py new file mode 100644 index 0000000000..f078c1ab39 --- /dev/null +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_finetune_esm2.py @@ -0,0 +1,388 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path +from unittest.mock import patch + +import pandas as pd +import pytest +from nemo.lightning import io + +from bionemo.core.data.load import load +from bionemo.esm2.model.finetune.dataset import InMemoryPerTokenValueDataset, InMemorySingleValueDataset +from bionemo.esm2.model.finetune.sequence_model import ESM2FineTuneSeqConfig +from bionemo.esm2.model.finetune.token_model import ESM2FineTuneTokenConfig +from bionemo.esm2.scripts.finetune_esm2 import finetune_esm2_entrypoint, get_parser, train_model +from bionemo.testing import megatron_parallel_state_utils +from bionemo.testing.callbacks import MetricTracker + + +def data_to_csv(data, tmp_path): + """Create a mock protein dataset.""" + csv_file = tmp_path / "protein_dataset.csv" + # Create a DataFrame + df = pd.DataFrame(data, columns=["sequences", "labels"]) + + # Save the DataFrame to a CSV file + df.to_csv(csv_file, index=False) + return csv_file + + +@pytest.mark.parametrize("encoder_frozen", [True, False]) +def test_esm2_finetune_token_classifier( + tmp_path, + dummy_data_per_token_classification_ft, + encoder_frozen, + n_steps_train: int = 50, + seed: int = 42, +): + with megatron_parallel_state_utils.distributed_model_parallel_state(seed): + simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( + train_data_path=data_to_csv(dummy_data_per_token_classification_ft, tmp_path), + valid_data_path=data_to_csv(dummy_data_per_token_classification_ft, tmp_path), + experiment_name="finetune_new_head_token_classification", + restore_from_checkpoint_path=str(load("esm2/8m:2.0")), + num_steps=n_steps_train, + num_nodes=1, + devices=1, + min_seq_length=None, + max_seq_length=1024, + result_dir=tmp_path / "finetune", + limit_val_batches=2, + val_check_interval=n_steps_train // 2, + log_every_n_steps=n_steps_train // 2, + num_dataset_workers=10, + lr=1e-5, + scale_lr_layer="classification_head", + lr_multiplier=1e2, + micro_batch_size=4, + accumulate_grad_batches=1, + resume_if_exists=False, + precision="bf16-mixed", + task_type="classification", + encoder_frozen=encoder_frozen, + dataset_class=InMemoryPerTokenValueDataset, + config_class=ESM2FineTuneTokenConfig, + metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), + ) + + weights_ckpt = simple_ft_checkpoint / "weights" + assert weights_ckpt.exists() + assert weights_ckpt.is_dir() + assert io.is_distributed_ckpt(weights_ckpt) + assert simple_ft_metrics.collection_train["loss"][0] > simple_ft_metrics.collection_train["loss"][-1] + + encoder_requires_grad = [ + p.requires_grad for name, p in trainer.model.named_parameters() if "classification_head" not in name + ] + assert ( + not all(encoder_requires_grad) == encoder_frozen + ), f"Conflict in param requires_grad when encoder_frozen={encoder_frozen}" + + +@pytest.mark.parametrize("encoder_frozen", [True, False]) +def test_esm2_finetune_regressor( + tmp_path, + dummy_data_single_value_regression_ft, + encoder_frozen, + n_steps_train: int = 50, + seed: int = 42, +): + with megatron_parallel_state_utils.distributed_model_parallel_state(seed): + simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( + train_data_path=data_to_csv(dummy_data_single_value_regression_ft, tmp_path), + valid_data_path=data_to_csv(dummy_data_single_value_regression_ft, tmp_path), + experiment_name="finetune_new_head_regression", + restore_from_checkpoint_path=str(load("esm2/8m:2.0")), + num_steps=n_steps_train, + num_nodes=1, + devices=1, + min_seq_length=None, + max_seq_length=1024, + result_dir=tmp_path / "finetune", + limit_val_batches=2, + val_check_interval=n_steps_train // 2, + log_every_n_steps=n_steps_train // 2, + num_dataset_workers=10, + lr=1e-5, + scale_lr_layer="regression_head", + lr_multiplier=1e2, + micro_batch_size=4, + accumulate_grad_batches=1, + resume_if_exists=False, + precision="bf16-mixed", + task_type="regression", + encoder_frozen=encoder_frozen, + dataset_class=InMemorySingleValueDataset, + config_class=ESM2FineTuneSeqConfig, + metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), + ) + + weights_ckpt = simple_ft_checkpoint / "weights" + assert weights_ckpt.exists() + assert weights_ckpt.is_dir() + assert io.is_distributed_ckpt(weights_ckpt) + assert simple_ft_metrics.collection_train["loss"][0] > simple_ft_metrics.collection_train["loss"][-1] + + encoder_requires_grad = [ + p.requires_grad for name, p in trainer.model.named_parameters() if "regression_head" not in name + ] + assert ( + not all(encoder_requires_grad) == encoder_frozen + ), f"Conflict in param requires_grad when encoder_frozen={encoder_frozen}" + + +@pytest.mark.parametrize("encoder_frozen", [True, False]) +def test_esm2_finetune_classifier( + tmp_path, + dummy_data_single_value_classification_ft, + encoder_frozen, + n_steps_train: int = 50, + seed: int = 42, +): + with megatron_parallel_state_utils.distributed_model_parallel_state(seed): + simple_ft_checkpoint, simple_ft_metrics, trainer = train_model( + train_data_path=data_to_csv(dummy_data_single_value_classification_ft, tmp_path), + valid_data_path=data_to_csv(dummy_data_single_value_classification_ft, tmp_path), + experiment_name="finetune_new_head_classification", + restore_from_checkpoint_path=str(load("esm2/8m:2.0")), + num_steps=n_steps_train, + num_nodes=1, + devices=1, + min_seq_length=None, + max_seq_length=1024, + result_dir=tmp_path / "finetune", + limit_val_batches=2, + val_check_interval=n_steps_train // 2, + log_every_n_steps=n_steps_train // 2, + num_dataset_workers=10, + lr=1e-5, + scale_lr_layer="classification_head", + lr_multiplier=1e2, + micro_batch_size=4, + accumulate_grad_batches=1, + resume_if_exists=False, + precision="bf16-mixed", + task_type="classification", + mlp_target_size=3, + encoder_frozen=encoder_frozen, + dataset_class=InMemorySingleValueDataset, + config_class=ESM2FineTuneSeqConfig, + metric_tracker=MetricTracker(metrics_to_track_val=["loss"], metrics_to_track_train=["loss"]), + ) + + weights_ckpt = simple_ft_checkpoint / "weights" + assert weights_ckpt.exists() + assert weights_ckpt.is_dir() + assert io.is_distributed_ckpt(weights_ckpt) + assert simple_ft_metrics.collection_train["loss"][0] > simple_ft_metrics.collection_train["loss"][-1] + + encoder_requires_grad = [ + p.requires_grad for name, p in trainer.model.named_parameters() if "classification_head" not in name + ] + assert ( + not all(encoder_requires_grad) == encoder_frozen + ), f"Conflict in param requires_grad when encoder_frozen={encoder_frozen}" + + +@pytest.fixture +def mock_train_model(): + with patch("bionemo.esm2.scripts.finetune_esm2.train_model") as mock_train: + yield mock_train + + +@pytest.fixture +def mock_parser_args(): + """Fixture to create mock arguments for the parser.""" + return [ + "--train-data-path", + str(Path("train.csv")), + "--valid-data-path", + str(Path("valid.csv")), + "--num-gpus", + "1", + "--num-nodes", + "1", + "--max-seq-length", + "1024", + "--result-dir", + str(Path("./results")), + "--lr", + "0.001", + "--task-type", + "regression", + ] + + +def test_finetune_esm2_entrypoint(mock_train_model, mock_parser_args): + """Test the finetune_esm2_entrypoint function with mocked arguments.""" + with patch("sys.argv", ["finetune_esm2_entrypoint.py"] + mock_parser_args): + finetune_esm2_entrypoint() + + # Check if train_model was called once + mock_train_model.assert_called_once() + + # Check if the arguments were passed correctly + called_kwargs = mock_train_model.call_args.kwargs + assert called_kwargs["train_data_path"] == Path("train.csv") + assert called_kwargs["valid_data_path"] == Path("valid.csv") + assert called_kwargs["devices"] == 1 + assert called_kwargs["num_nodes"] == 1 + assert called_kwargs["max_seq_length"] == 1024 + assert called_kwargs["lr"] == 0.001 + assert called_kwargs["result_dir"] == Path("./results") + + +def test_get_parser(): + """Test the argument parser with all possible arguments.""" + parser = get_parser() + args = parser.parse_args( + [ + "--train-data-path", + "train.csv", + "--valid-data-path", + "valid.csv", + "--precision", + "bf16-mixed", + "--task-type", + "classification", + "--lr", + "0.001", + "--create-tensorboard-logger", + "--resume-if-exists", + "--result-dir", + "./results", + "--experiment-name", + "esm2_experiment", + "--wandb-entity", + "my_team", + "--wandb-project", + "ft_project", + "--wandb-tags", + "tag1", + "tag2", + "--wandb-group", + "group1", + "--wandb-id", + "1234", + "--wandb-anonymous", + "--wandb-log-model", + "--wandb-offline", + "--num-gpus", + "2", + "--num-nodes", + "1", + "--num-steps", + "1000", + "--num-dataset-workers", + "4", + "--val-check-interval", + "500", + "--log-every-n-steps", + "100", + "--min-seq-length", + "512", + "--max-seq-length", + "1024", + "--limit-val-batches", + "2", + "--micro-batch-size", + "32", + "--pipeline-model-parallel-size", + "2", + "--tensor-model-parallel-size", + "2", + "--accumulate-grad-batches", + "2", + "--save-last-checkpoint", + "--metric-to-monitor-for-checkpoints", + "val_loss", + "--save-top-k", + "5", + "--restore-from-checkpoint-path", + "./checkpoint", + "--nsys-profiling", + "--nsys-start-step", + "10", + "--nsys-end-step", + "50", + "--nsys-ranks", + "0", + "1", + "--overlap-grad-reduce", + "--no-overlap-param-gather", + "--no-average-in-collective", + "--grad-reduce-in-fp32", + "--dataset-class", + "InMemoryPerTokenValueDataset", + "--config-class", + "ESM2FineTuneTokenConfig", + "--encoder-frozen", + "--lr-multiplier", + "1e2", + "--scale-lr-layer", + "dummy_layer", + ] + ) + + # Assertions for all arguments + assert args.train_data_path == Path("train.csv") + assert args.valid_data_path == Path("valid.csv") + assert args.precision == "bf16-mixed" + assert args.task_type == "classification" + assert args.lr == 0.001 + assert args.create_tensorboard_logger is True + assert args.resume_if_exists is True + assert args.result_dir == Path("./results") + assert args.experiment_name == "esm2_experiment" + assert args.wandb_entity == "my_team" + assert args.wandb_project == "ft_project" + assert args.wandb_tags == ["tag1", "tag2"] + assert args.wandb_group == "group1" + assert args.wandb_id == "1234" + assert args.wandb_anonymous is True + assert args.wandb_log_model is True + assert args.wandb_offline is True + assert args.num_gpus == 2 + assert args.num_nodes == 1 + assert args.num_steps == 1000 + assert args.num_dataset_workers == 4 + assert args.val_check_interval == 500 + assert args.log_every_n_steps == 100 + assert args.min_seq_length == 512 + assert args.max_seq_length == 1024 + assert args.limit_val_batches == 2 + assert args.micro_batch_size == 32 + assert args.pipeline_model_parallel_size == 2 + assert args.tensor_model_parallel_size == 2 + assert args.accumulate_grad_batches == 2 + assert args.save_last_checkpoint is True + assert args.metric_to_monitor_for_checkpoints == "val_loss" + assert args.save_top_k == 5 + assert args.restore_from_checkpoint_path == Path("./checkpoint") + assert args.nsys_profiling is True + assert args.nsys_start_step == 10 + assert args.nsys_end_step == 50 + assert args.nsys_ranks == [0, 1] + assert args.overlap_grad_reduce is True + assert args.no_overlap_param_gather is True + assert args.no_average_in_collective is True + assert args.grad_reduce_in_fp32 is True + assert args.dataset_class == InMemoryPerTokenValueDataset + assert args.config_class == ESM2FineTuneTokenConfig + assert args.encoder_frozen is True + assert args.lr_multiplier == 100 + assert args.scale_lr_layer == "dummy_layer" diff --git a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py index e601ce18ed..b3c349b8f3 100644 --- a/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py +++ b/sub-packages/bionemo-esm2/tests/bionemo/esm2/scripts/test_infer_esm2.py @@ -19,45 +19,17 @@ import pandas as pd import pytest import torch -from torch.utils.data import DataLoader from bionemo.core.data.load import load from bionemo.core.utils.dtypes import get_autocast_dtype from bionemo.esm2.api import ESM2Config from bionemo.esm2.data.tokenizer import get_tokenizer -from bionemo.esm2.model.finetune.datamodule import ESM2FineTuneDataModule, InMemoryCSVDataset from bionemo.esm2.scripts.infer_esm2 import infer_model from bionemo.llm.data import collate from bionemo.llm.lightning import batch_collator from bionemo.llm.utils.callbacks import IntervalT -# Function to check GPU memory -def check_gpu_memory(threshold_gb): - if torch.cuda.is_available(): - gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3) # Memory in GB - return gpu_memory < threshold_gb - return False - - -@pytest.fixture -def dummy_protein_sequences(): - """Create a list of artificial protein sequences""" - artificial_sequence_data = [ - "TLILGWSDKLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "GRFNVWLGGNESKIRQVLKAVKEIGVSPTLFAVYEKN", - "DELTALGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "KLGSLLNQLAIANESLGGGTIAVMAERDKEDMELDIGKMEFDFKGTSVI", - "LFGAIGNAISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "LGGLLHDIGKPVQRAGLYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "LYSGDHSTQGARFLRDLAENTGRAEYELLSLF", - "ISAIHGQSAVEELVDAFVGGARISSAFPYSGDTYYLPKP", - "SGSKASSDSQDANQCCTSCEDNAPATSYCVECSEPLCETCVEAHQRVKYTKDHTVRSTGPAKT", - ] - return artificial_sequence_data - - @pytest.fixture def dummy_protein_csv(tmp_path, dummy_protein_sequences): """Create a mock protein dataset.""" @@ -70,16 +42,6 @@ def dummy_protein_csv(tmp_path, dummy_protein_sequences): return csv_file -@pytest.fixture -def dataset(dummy_protein_csv): - return InMemoryCSVDataset(dummy_protein_csv) - - -@pytest.fixture -def data_module(dataset): - return ESM2FineTuneDataModule(predict_dataset=dataset) - - @pytest.fixture def padded_tokenized_sequences(dummy_protein_sequences): tokenizer = get_tokenizer() @@ -91,49 +53,6 @@ def padded_tokenized_sequences(dummy_protein_sequences): return collated_batch["text"] -def test_in_memory_csv_dataset(dataset): - assert len(dataset) > 0 - sample = dataset[0] - assert isinstance(sample, dict) - assert "text" in sample - assert "labels" in sample - - -def test_in_memory_csv_dataset_load_data(dataset, dummy_protein_csv): - sequences, labels = dataset.load_data(dummy_protein_csv) - assert isinstance(sequences, list) - assert isinstance(labels, list) - - -def test_esm2_fine_tune_data_module_init(data_module): - assert data_module.train_dataset is None - assert data_module.valid_dataset is None - assert data_module.predict_dataset is not None - - -def test_esm2_fine_tune_data_module_predict_dataloader(data_module): - predict_dataloader = data_module.predict_dataloader() - assert isinstance(predict_dataloader, DataLoader) - batch = next(iter(predict_dataloader)) - assert isinstance(batch, dict) - assert "text" in batch - - -def test_esm2_fine_tune_data_module_setup(data_module): - with pytest.raises(RuntimeError): - data_module.setup("fit") - - -def test_esm2_fine_tune_data_module_train_dataloader(data_module): - with pytest.raises(AttributeError): - data_module.train_dataloader() - - -def test_esm2_fine_tune_data_module_val_dataloader(data_module): - with pytest.raises(AttributeError): - data_module.val_dataloader() - - @pytest.mark.parametrize("precision", ["fp32", "bf16-mixed"]) @pytest.mark.parametrize("prediction_interval", get_args(IntervalT)) def test_infer_runs( @@ -150,7 +69,7 @@ def test_infer_runs( infer_model( data_path=data_path, - checkpoint_path=load("esm2/nv_8m:2.0"), + checkpoint_path=load("esm2/8m:2.0"), results_path=result_dir, min_seq_length=min_seq_len, prediction_interval=prediction_interval, diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index 2179dd5d6a..638ea3a61c 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -11,7 +11,9 @@ requires-python = ">=3.10" license = { file = "LICENSE" } dynamic = ["version"] dependencies = [ - "bionemo-noodles" + "bionemo-noodles", + "bionemo-core", + "bionemo-llm", ] [project.scripts] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 4f4aa7cd20..ad62cb3de6 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -15,6 +15,7 @@ import argparse +from typing import Literal, Optional import nemo.lightning as nl import torch @@ -23,6 +24,9 @@ from nemo.utils import logging +CheckpointFormats = Literal["torch_dist", "zarr"] + + def parse_args(): """Parse arguments for Evo2 inference.""" ap = argparse.ArgumentParser() @@ -77,23 +81,50 @@ def parse_args(): return ap.parse_args() -def main(): - """Inference workflow for Evo2.""" - # Parse args. - args = parse_args() +def infer( + prompt: str, + ckpt_dir: str, + temperature: float, + top_k: int, + top_p: float, + max_new_tokens: int, + tensor_parallel_size: int, + pipeline_model_parallel_size: int, + context_parallel_size: int, + output_file: Optional[str] = None, + ckpt_format: CheckpointFormats = "torch_dist", +): + """Inference workflow for Evo2. + Args: + prompt (str): Prompt to generate text from Evo2. + ckpt_dir (str): Path to checkpoint directory containing pre-trained Evo2 model. + temperature (float): Temperature during sampling for generation. + top_k (int): Top K during sampling for generation. + top_p (float): Top P during sampling for generation. + max_new_tokens (int): Maximum number of tokens to generate. + tensor_parallel_size (int): Order of tensor parallelism. + pipeline_model_parallel_size (int): Order of pipeline parallelism. + context_parallel_size (int): Order of context parallelism. + output_file (str): Output file containing the generated text produced by the Evo2 model. + ckpt_format (CheckpointFormats): Checkpoint format to use. + + Returns: + None + """ # Create PTL trainer. trainer = nl.Trainer( accelerator="gpu", strategy=nl.MegatronStrategy( - tensor_model_parallel_size=args.tensor_parallel_size, - pipeline_model_parallel_size=args.pipeline_model_parallel_size, - context_parallel_size=args.context_parallel_size, + tensor_model_parallel_size=tensor_parallel_size, + pipeline_model_parallel_size=pipeline_model_parallel_size, + context_parallel_size=context_parallel_size, pipeline_dtype=torch.bfloat16, ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. ckpt_save_optimizer=False, ckpt_async_save=False, - save_ckpt_format=args.ckpt_format, + save_ckpt_format=ckpt_format, + ckpt_load_strictness="log_all", ), log_every_n_steps=1, limit_val_batches=10, @@ -106,26 +137,40 @@ def main(): # transformers generate method has more options than NeMo/Megatron. results = generate( - path=args.ckpt_dir, - prompts=[args.prompt], + path=ckpt_dir, + prompts=[prompt], trainer=trainer, inference_params=CommonInferenceParams( - args.temperature, - args.top_k, - args.top_p, + temperature, + top_k, + top_p, return_log_probs=False, - num_tokens_to_generate=args.max_new_tokens, + num_tokens_to_generate=max_new_tokens, ), text_only=True, ) if torch.distributed.get_rank() == 0: - if args.output_file is None: + if output_file is None: logging.info(results) else: - with open(args.output_file, "w") as f: + with open(output_file, "w") as f: f.write(f"{results}\n") if __name__ == "__main__": - main() + # Parse args. + args = parse_args() + infer( + prompt=args.prompt, + ckpt_dir=args.ckpt_dir, + temperature=args.temperature, + top_k=args.top_k, + top_p=args.top_p, + max_new_tokens=args.max_new_tokens, + tensor_parallel_size=args.tensor_parallel_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + context_parallel_size=args.context_parallel_size, + output_file=args.output_file, + ckpt_format=args.ckpt_format, + ) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 2a61f4298b..e4c61d1813 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -82,6 +82,15 @@ def parse_args(): ) parser.add_argument("--wandb-project", type=str, default="bionemo_evo2", help="Wandb project name") parser.add_argument("--wandb-run-id", type=str, default=None, help="Wandb run identifier") + parser.add_argument( + "--wandb-group", type=str, default=None, help="A unique string shared by all runs in a given group" + ) + parser.add_argument( + "--wandb-job-type", + type=str, + default=None, + help="A unique string representing a type of run, which is useful when you're grouping runs together into larger experiments using group.", + ) parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallelism.") parser.add_argument("--fp8", action="store_true", help="Set to enable FP8") parser.add_argument("--micro-batch-size", type=int, default=1, help="Micro-batch size for data-parallel training.") @@ -398,6 +407,8 @@ def main(): f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" f"-NODES{args.num_nodes}-FP8{args.fp8}" ), + group=args.wandb_group, + job_type=args.wandb_job_type, id=args.wandb_run_id, # set this to use the same curve name for restarts. project=args.wandb_project, save_dir=args.experiment_dir, @@ -437,6 +448,7 @@ def main(): ckpt_save_optimizer=True, ckpt_async_save=args.ckpt_async_save, save_ckpt_format=args.ckpt_format, + ckpt_load_strictness="log_all", # or rebasing to https://github.com/NVIDIA/NeMo/pull/11988/files#diff-7667eae242a8ef776bff78cd08e79bc81df4896a450f0a781f6ed317a3dfb7ffR139 ) trainer = nl.Trainer( devices=args.devices, diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml new file mode 100644 index 0000000000..51c9606739 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml @@ -0,0 +1,6 @@ +- dataset_prefix: /workspace/bionemo2/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train + dataset_split: train + dataset_weight: 1.0 +- dataset_prefix: /workspace/bionemo2/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val + dataset_split: validation + dataset_weight: 1.0 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin new file mode 100644 index 0000000000..e69de29bb2 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx new file mode 100644 index 0000000000000000000000000000000000000000..5896b07cd8488e90ac5ea44bde70bb0343065dc5 GIT binary patch literal 42 acmebE^>p!ciC|!0WPkt|4HtllGXMZkIRX#> literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin new file mode 100644 index 0000000000000000000000000000000000000000..15221e3374a5209e145f93fd06cc68d85403c48b GIT binary patch literal 8414 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 literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx new file mode 100644 index 0000000000000000000000000000000000000000..f40faa5af120aecc73a3268d559e8932ed8e97ce GIT binary patch literal 322 zcmebE^>p!ciC|!0WPkuhJ}849N=Gs=Fpz_x+QE83>`g2X5pH$}ox%yB_i{sMF{s7) z0ucTQAqcG~3ZbjSA@pTQ2(2Rnp<Cr3G>n9K1n6uqV209A>ls*~d^RWzbq)guln-?l T0~eGJbshr`l+O#LVc`S-Gd&Ih literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin new file mode 100644 index 0000000000000000000000000000000000000000..9dd51c243e4c32344704ce9ab61dbfa093bb47cf GIT binary patch literal 1202 zcmZ9K+id_r2m{j^;)4e0zn09HJt>M#w@<K*+1Z)tE{Cq|+1+9B{+`Odz3!gb*)HSq z70aEPW)vq=H`(k>SVFgiFOa)9xe*4KJa<*l6kJ)8!{(&0W|vs81Od<?)OT$RAK7L` zkSTnrf-~|WB>5Kz6+7xhY7&Whyq-~NKvO>vq$`qO@gvEyR1S~Y#bLVL;+54{yvAUW zyPLT~zH7o=u}rG|!I4HJR(Y5Pjb1)cx~ReSjE0yJifBum1#lh>ACJueLvZA0bV!$w zK=syOfJX@-#V$+nUEKAb(HkoemBE4-XMPldKpoRBj&N7SIveHxM`5_tmU#CC*`#zH z46Ar}mcaoisY0puP6(pK6vN;pdMv=#eH4fa3E_%1A9dPHIOIw`Q<Gv5c_uO9<B3Xe ziA`%m;d_X80fOdI5g>v)U$$I6Lgk=Si}c$=1D+_mL3Q^mxiMaOqU34PVo)$djLaY? zgGp%d%?3N5ZzD6#F_C8&=UI4R3}=s*-BrW6%2mlsfH}VOH^P;&6oPko1E`Jbz6dli eMG(|>845+96vNH1M+mstb@ocJ8~2zj?dKPz1W<Ya literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx new file mode 100644 index 0000000000000000000000000000000000000000..2cfb8caa9a3fe9e62315775aa8c954a2dd200b45 GIT binary patch literal 82 ncmebE^>p!ciC|!0WPkuhCMbg$N=E_(Ko|y)*&s2PMwk)+&({Me literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index 77471ef6d1..cf42ef77ca 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -28,6 +28,7 @@ def preprocessing_config(tmp_path: Path) -> Evo2PreprocessingConfig: # grab dir where test located test_dir = Path(__file__).parent + # TODO (dorotat) move mmseqs_results_rep_seq_distinct_sample_sequences.fasta to PBSS and use load(...) config_dict = { "datapaths": [str(test_dir / "test_datasets" / "mmseqs_results_rep_seq_distinct_sample_sequences.fasta")], "output_dir": str(tmp_path), diff --git a/sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py new file mode 100644 index 0000000000..448e6e8710 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py @@ -0,0 +1,65 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import torch + +from bionemo.core.data.load import load +from bionemo.evo2.run.infer import infer +from bionemo.testing.megatron_parallel_state_utils import _teardown_apex_megatron_cuda, clean_parallel_state_context + + +RANDOM_SEED = 42 + + +def test_run_infer(): + # Create PTL trainer. + tensor_parallel_size = 1 + pipeline_model_parallel_size = 1 + context_parallel_size = 1 + temperature = 1.0 + top_k = 0 + top_p = 0.0 + max_new_tokens = 1 + + # generation args: + default_prompt = ( + "|d__Bacteria;" + + "p__Pseudomonadota;" + + "c__Gammaproteobacteria;" + + "o__Enterobacterales;" + + "f__Enterobacteriaceae;" + + "g__Escherichia;" + + "s__Escherichia|" + ) + + # TODO (dorotat) remove PBSS source once the model is available on NGC + checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") + + with clean_parallel_state_context(): + infer( + prompt=default_prompt, + ckpt_dir=checkpoint_path, + temperature=temperature, + top_k=top_k, + top_p=top_p, + max_new_tokens=max_new_tokens, + tensor_parallel_size=tensor_parallel_size, + pipeline_model_parallel_size=pipeline_model_parallel_size, + context_parallel_size=context_parallel_size, + ) + + _teardown_apex_megatron_cuda() + torch.cuda.empty_cache() diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py index 6a3aef90cd..b6a25ba5ea 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py @@ -53,24 +53,21 @@ def load_weights_sharded_inplace_nemo2_to_mcore( k, skip_keys_with_these_prefixes ) # and "_extra_state" not in k # extra state is needed for fp8 sharded states } + # Load the checkpoint with strict=false to allow for missing keys (backward compatibility) + # Error: megatron.core.dist_checkpointing.core.CheckpointingException: + # Object shard ... module.decoder.final_norm._extra_state/shard_0_1.pt not found MegatronCheckpointIO(save_ckpt_format=ckpt_format).load_checkpoint( - distributed_checkpoint_dir, sharded_state_dict=sharded_state_dict + distributed_checkpoint_dir, sharded_state_dict=sharded_state_dict, strict=False ) @pytest.mark.parametrize("seq_len", [8_192, 16_384]) def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): - """Step 1: - # add local .ssh/*.pub key to eos ~/.ssh/authorized_keys - mkdir -p arc_model/checkpoints/ - rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/interleaved_hyena_7b arc_model/checkpoints/ - mkdir -p arc_model/gold_standards/ - rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/interleaved_7b_golden_value.pt arc_model/gold_standards/ - rsync -avz --progress --partial login-eos01.eos.clusters.nvidia.com:/lustre/fsw/healthcareeng_bionemo/arc_evo2/savanna_outputs/final_7b_no_fp8_golden_value.pt arc_model/gold_standards/ - """ try: - evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.0") / "weights" - gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") + # TODO (dorotat) remove PBSS source once the model is available on NGC + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.0", source="pbss") / "weights" + # TODO (dorotat) remove PBSS source once the model is available on NGC + gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0", source="pbss") except ValueError as e: if e.args[0].endswith("does not have an NGC URL."): raise ValueError( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py index ad7541ccc8..4526aa0834 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py @@ -42,6 +42,7 @@ def test_infer_model_generates_expected_single_token_output(): ckpt_save_optimizer=False, ckpt_async_save=False, save_ckpt_format="zarr", + ckpt_load_strictness="log_all", ) trainer = nl.Trainer( accelerator="gpu", @@ -70,6 +71,7 @@ def test_infer_model_generates_expected_single_token_output(): top_k = 0 top_p = 0.0 max_new_tokens = 1 + # TODO (dorotat) remove PBSS source once the model is available on NGC checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") with clean_parallel_state_context(): diff --git a/sub-packages/bionemo-fw/pyproject.toml b/sub-packages/bionemo-fw/pyproject.toml index e6e8ad9bf7..e19d4c2d8b 100644 --- a/sub-packages/bionemo-fw/pyproject.toml +++ b/sub-packages/bionemo-fw/pyproject.toml @@ -30,6 +30,7 @@ dependencies = [ # external 'nltk', 'numba>=0.57.1', + 'toml', 'zarr', ] diff --git a/sub-packages/bionemo-fw/src/bionemo/fw/dependency_graph.py b/sub-packages/bionemo-fw/src/bionemo/fw/dependency_graph.py new file mode 100644 index 0000000000..7478c913fd --- /dev/null +++ b/sub-packages/bionemo-fw/src/bionemo/fw/dependency_graph.py @@ -0,0 +1,225 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import logging +import os +import re +from collections import defaultdict +from pathlib import Path + +import matplotlib.pyplot as plt +import networkx as nx +import toml + + +def parse_dependencies(pyproject_path): + """Parse dependencies from a pyproject.toml file.""" + with open(pyproject_path, "r") as f: + pyproject_data = toml.load(f) + dependencies = {} + package_name = None + + # Extract package name + try: + package_name = pyproject_data["project"]["name"] + except KeyError: + print(f"Warning: Could not find package name in {pyproject_path}") + + # Extract dependencies + try: + deps = pyproject_data["project"]["dependencies"] + if isinstance(deps, dict): # If dependencies are a dictionary + for dep, version in deps.items(): + if dep.startswith("bionemo-"): + dependencies[dep] = version # Keep dependency with its version + + elif isinstance(deps, list): # If dependencies are a list + for dep in deps: + if dep.startswith("bionemo-"): + dependencies[dep] = "unpinned" + except KeyError: + print(f"Warning: Could not find dependencies in {pyproject_path}") + + if "tool" in pyproject_data and "maturin" in pyproject_data["tool"]: + dep = pyproject_data["tool"]["maturin"]["module-name"] + if dep.startswith("bionemo."): + dependencies[dep.replace(".", "-")] = "unpinned" + + return package_name, dependencies + + +def build_dependency_graph(base_dir, directories): + """Build a dependency graph for all sub-packages.""" + pyproject_files = [] + for directory in directories: + pyproject_files.append(base_dir / directory / "pyproject.toml") + dependency_graph = defaultdict(dict) + + for pyproject_file in pyproject_files: + package_name, dependencies = parse_dependencies(pyproject_file) + if package_name: + dependency_graph[package_name] = dependencies + + return dependency_graph + + +def visualize_dependency_graph(dependency_graph, filename): + """Visualize the dependency graph using NetworkX.""" + G = nx.DiGraph() + edge_labels = {} + + # Track all packages explicitly + all_packages = set(dependency_graph.keys()) + + for package, dependencies in dependency_graph.items(): + if isinstance(dependencies, dict): + for dep, version in dependencies.items(): + G.add_edge(dep, package) # Add edge from package to dependency + edge_labels[(dep, package)] = version # Label the edge with the version + all_packages.add(dep) + else: + for dep in dependencies: + G.add_edge(dep, package) # Add edge from package to dependency + all_packages.add(dep) + + # Ensure isolated nodes (without edges) are included in the graph + for package in all_packages: + if package not in G: + G.add_node(package) + # Use a circular layout, ensuring packages are evenly distributed + pos = nx.circular_layout(G) + + plt.figure(figsize=(14, 10)) + nx.draw( + G, + pos, + with_labels=True, + node_size=3000, + node_color="lightblue", + font_size=10, + font_weight="bold", + arrowsize=20, + edge_color="gray", + ) + + # Draw edge labels for the dependency versions + nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8, font_color="red") + plt.title("Dependency Graph", fontsize=16) + plt.savefig(filename) + + +def find_bionemo_subpackages(base_dir, directories): + """Find all unique `bionemo.<name>` imports in Python files within a directory.""" + bionemo_import_pattern = re.compile( + r"^\s*(?:from|import)\s+bionemo\.([a-zA-Z_][a-zA-Z0-9_]*)(?:\s+|\.|$)", re.MULTILINE + ) + found_imports = {} + for dir_name in directories: + directory = base_dir / dir_name / "src" + subpackages = set() + + for file_path in Path(directory).rglob("*.py"): + try: + with open(file_path, "r", encoding="utf-8") as f: + content = f.read() + matches = bionemo_import_pattern.findall(content) + subpackages.update(matches) + except Exception as e: + print(f"Error reading file {file_path}: {e}") + full_subpackage_names = {f"bionemo-{subpackage}" for subpackage in subpackages} + if dir_name in full_subpackage_names: + full_subpackage_names.remove(dir_name) + found_imports[dir_name] = full_subpackage_names + return found_imports + + +def parse_tach_toml(toml_path): + """Parse dependencies from a tach.toml file.""" + tach_toml_dependencies = {} + with open(toml_path, "r") as f: + toml_data = toml.load(f) + for module in toml_data["modules"]: + tach_toml_dependencies[(module["path"].replace(".", "-"))] = [ + item.replace(".", "-") for item in module["depends_on"] + ] + return tach_toml_dependencies + + +def resolve_dependencies(subpackage, toml_imports, resolved=None, seen=None): + """Recursively resolve all dependencies, including transitive ones.""" + if resolved is None: + resolved = set() + if seen is None: + seen = set() + + if subpackage in seen: + return resolved # Avoid circular dependencies + seen.add(subpackage) + + for dep in toml_imports.get(subpackage, []): + resolved.add(dep) + if dep in toml_imports: # Resolve further if it's a subpackage + resolve_dependencies(dep, toml_imports, resolved, seen) + + return resolved + + +if __name__ == "__main__": + script_path = Path(__file__).resolve() + logger = logging.getLogger(__name__) + + # Get the parent directory + parent_directory = script_path.parents[5] + base_dir = parent_directory / "sub-packages" + directories = [d for d in os.listdir(base_dir) if os.path.isdir(base_dir / d)] + pyproject_dependency_graph = build_dependency_graph(base_dir, directories) + + tach_toml_dependency_graph = parse_tach_toml(parent_directory / "tach.toml") + file_path_imports = find_bionemo_subpackages(base_dir, directories) + console_handler = logging.StreamHandler() + logger.setLevel(logging.INFO) + logger.addHandler(console_handler) + + pyproject_not_toml = set(pyproject_dependency_graph.keys()) - set(tach_toml_dependency_graph.keys()) + toml_not_pyproject = set(tach_toml_dependency_graph.keys()) - set(pyproject_dependency_graph.keys()) + + if len(pyproject_not_toml) > 0: + logger.warning(f"\npyproject.toml - tach.toml: {', '.join(pyproject_not_toml)}") + if len(toml_not_pyproject) > 0: + logger.warning(f"\npyproject.toml - tach.toml: {', '.join(toml_not_pyproject)}") + + for name, dependency_graph in zip( + ["pyproject.toml", "tach.toml"], [pyproject_dependency_graph, tach_toml_dependency_graph] + ): + logger.warning(f"\nDependencies not resolved in {name}:") + for directory in file_path_imports: + resolved_dependencies = resolve_dependencies(directory, dependency_graph) + if not (file_path_imports[directory] <= resolved_dependencies): + logger.warning(f"{directory} : {file_path_imports[directory] - resolved_dependencies}") + + logger.warning("\nDifferences in pyproject.toml and tach.toml per-package: ") + for d in pyproject_dependency_graph: + if d in tach_toml_dependency_graph: + pyproject_minus_tach = set(pyproject_dependency_graph[d].keys()) - set(tach_toml_dependency_graph[d]) + tach_minus_pyproject = set(tach_toml_dependency_graph[d]) - set(pyproject_dependency_graph[d].keys()) + if len(pyproject_minus_tach) > 0: + logger.warning(f"{d} project.toml - tach.toml: {' ,'.join(pyproject_minus_tach)}") + if len(tach_minus_pyproject) > 0: + logger.warning(f"{d} tach.toml - project.toml: {', '.join(tach_minus_pyproject)}") + + visualize_dependency_graph(pyproject_dependency_graph, "dependency_graph_pyproject.png") + visualize_dependency_graph(tach_toml_dependency_graph, "dependency_graph_tach.png") + visualize_dependency_graph(file_path_imports, "dependency_file_imports.png") diff --git a/sub-packages/bionemo-fw/tests/bionemo/fw/test_dependency_graph.py b/sub-packages/bionemo-fw/tests/bionemo/fw/test_dependency_graph.py new file mode 100644 index 0000000000..f0e0b57d27 --- /dev/null +++ b/sub-packages/bionemo-fw/tests/bionemo/fw/test_dependency_graph.py @@ -0,0 +1,228 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import toml + +from bionemo.fw.dependency_graph import ( + build_dependency_graph, + find_bionemo_subpackages, + parse_dependencies, + parse_tach_toml, + resolve_dependencies, + visualize_dependency_graph, +) + + +@pytest.fixture +def temp_project_structure(tmp_path): + """Creates a temporary directory structure with pyproject.toml files.""" + subpackage1 = tmp_path / "bionemo-subpackage1" + subpackage2 = tmp_path / "bionemo-subpackage2" + subpackage1.mkdir() + subpackage2.mkdir() + + pyproject_data1 = {"project": {"name": "bionemo-subpackage1", "dependencies": ["bionemo-core", "bionemo-utils"]}} + with open(subpackage1 / "pyproject.toml", "w") as f: + toml.dump(pyproject_data1, f) + + pyproject_data2 = {"project": {"name": "bionemo-subpackage2", "dependencies": ["bionemo-subpackage1"]}} + with open(subpackage2 / "pyproject.toml", "w") as f: + toml.dump(pyproject_data2, f) + + yield tmp_path # Provide the base directory path + + +def test_parse_dependencies_list_format(tmp_path): + """Test parsing dependencies when dependencies are in a list format.""" + pyproject_data = {"project": {"name": "bionemo-example", "dependencies": ["bionemo-core", "bionemo-utils"]}} + pyproject_toml = tmp_path / "pyproject.toml" + pyproject_toml.write_text(toml.dumps(pyproject_data)) + package_name, dependencies = parse_dependencies(pyproject_toml) + + assert package_name == "bionemo-example" + assert dependencies == {"bionemo-core": "unpinned", "bionemo-utils": "unpinned"} + + +def test_parse_dependencies_dict_format(tmp_path): + """Test parsing dependencies when dependencies are in a dictionary format.""" + pyproject_data = { + "project": {"name": "bionemo-example", "dependencies": {"bionemo-core": "1.0.0", "bionemo-utils": "2.0.0"}} + } + pyproject_toml = tmp_path / "pyproject.toml" + + pyproject_toml.write_text(toml.dumps(pyproject_data)) + package_name, dependencies = parse_dependencies(pyproject_toml) + + assert package_name == "bionemo-example" + assert dependencies == {"bionemo-core": "1.0.0", "bionemo-utils": "2.0.0"} + + +def test_parse_dependencies_missing_sections(tmp_path): + """Test handling missing project name and dependencies.""" + pyproject_data = {} + pyproject_toml = tmp_path / "pyproject.toml" + + pyproject_toml.write_text(toml.dumps(pyproject_data)) + + package_name, dependencies = parse_dependencies(pyproject_toml) + + assert package_name is None + assert dependencies == {} + + +def test_build_dependency_graph(temp_project_structure): + """Test building the dependency graph.""" + directories = ["bionemo-subpackage1", "bionemo-subpackage2"] + dependency_graph = build_dependency_graph(temp_project_structure, directories) + + # Debugging: Print the graph if it's empty + if not dependency_graph: + print("DEBUG: Dependency graph is empty. Check pyproject.toml paths.") + assert "bionemo-subpackage1" in dependency_graph + assert "bionemo-subpackage2" in dependency_graph + assert dependency_graph["bionemo-subpackage1"] == {"bionemo-core": "unpinned", "bionemo-utils": "unpinned"} + assert dependency_graph["bionemo-subpackage2"] == {"bionemo-subpackage1": "unpinned"} + + +def test_resolve_dependencies(): + """Test resolving transitive dependencies.""" + toml_imports = { + "bionemo-subpackage1": ["bionemo-core", "bionemo-utils"], + "bionemo-subpackage2": ["bionemo-subpackage1"], + } + + resolved = resolve_dependencies("bionemo-subpackage2", toml_imports) + assert resolved == {"bionemo-subpackage1", "bionemo-core", "bionemo-utils"} + + +def test_parse_tach_toml(tmp_path): + """Test parsing a tach.toml file.""" + pyproject_data = { + "modules": [ + {"path": "bionemo.core", "depends_on": ["bionemo.utils"]}, + {"path": "bionemo.utils", "depends_on": []}, + ] + } + pyproject_toml = tmp_path / "pyproject.toml" + pyproject_toml.write_text(toml.dumps(pyproject_data)) + + tach_toml_dependencies = parse_tach_toml(pyproject_toml) + + assert tach_toml_dependencies == { + "bionemo-core": ["bionemo-utils"], + "bionemo-utils": [], + } + + +def test_visualize_dependency_graph(tmp_path): + """Test visualization of the dependency graph (ensuring no exceptions).""" + dependency_graph = { + "bionemo-subpackage1": {"bionemo-core": "unpinned", "bionemo-utils": "unpinned"}, + "bionemo-subpackage2": {"bionemo-subpackage1": "unpinned"}, + } + visualize_dependency_graph(dependency_graph, tmp_path / "output.png") + assert (tmp_path / "output.png").exists() + + +def test_find_bionemo_subpackages(temp_project_structure): + """Test finding bionemo subpackages in Python files.""" + subpackage_src = temp_project_structure / "bionemo-subpackage1" / "src" + subpackage_src.mkdir(parents=True, exist_ok=True) + + # Create a Python file with some bionemo imports + python_file = subpackage_src / "example.py" + with open(python_file, "w") as f: + f.write("import bionemo.core\n" "from bionemo.utils import some_function\n" "import bionemo.experiment\n") + + directories = ["bionemo-subpackage1"] + found_imports = find_bionemo_subpackages(temp_project_structure, directories) + + assert "bionemo-subpackage1" in found_imports + assert found_imports["bionemo-subpackage1"] == {"bionemo-core", "bionemo-utils", "bionemo-experiment"} + + +def test_find_bionemo_subpackages_multiple_files(temp_project_structure): + """Test `find_bionemo_subpackages` when scanning multiple files.""" + subpackage_src = temp_project_structure / "bionemo-subpackage1" / "src" + subpackage_src.mkdir(parents=True, exist_ok=True) + + # Create multiple Python files + python_file1 = subpackage_src / "file1.py" + python_file2 = subpackage_src / "file2.py" + + with open(python_file1, "w") as f: + f.write("import bionemo.data\n") + + with open(python_file2, "w") as f: + f.write("from bionemo.visualization import plot_graph\n") + + directories = ["bionemo-subpackage1"] + found_imports = find_bionemo_subpackages(temp_project_structure, directories) + + assert "bionemo-subpackage1" in found_imports + assert found_imports["bionemo-subpackage1"] == {"bionemo-data", "bionemo-visualization"} + + +def test_find_bionemo_subpackages_no_imports(temp_project_structure): + """Test `find_bionemo_subpackages` when there are no bionemo imports.""" + subpackage_src = temp_project_structure / "bionemo-subpackage1" / "src" + subpackage_src.mkdir(parents=True, exist_ok=True) + + # Create a Python file with NO bionemo imports + python_file = subpackage_src / "empty.py" + with open(python_file, "w") as f: + f.write("print('Hello, world!')\n") + + directories = ["bionemo-subpackage1"] + found_imports = find_bionemo_subpackages(temp_project_structure, directories) + + assert "bionemo-subpackage1" in found_imports + assert found_imports["bionemo-subpackage1"] == set() # No bionemo imports found + + +def test_find_bionemo_subpackages_nested_imports(temp_project_structure): + """Test `find_bionemo_subpackages` when imports are in nested directories.""" + subpackage_src = temp_project_structure / "bionemo-subpackage1" / "src" / "nested" + subpackage_src.mkdir(parents=True, exist_ok=True) + + # Create a Python file inside a nested directory + python_file = subpackage_src / "nested_example.py" + with open(python_file, "w") as f: + f.write("import bionemo.models\n") + + directories = ["bionemo-subpackage1"] + found_imports = find_bionemo_subpackages(temp_project_structure, directories) + + assert "bionemo-subpackage1" in found_imports + assert found_imports["bionemo-subpackage1"] == {"bionemo-models"} + + +def test_find_bionemo_subpackages_syntax_error(temp_project_structure): + """Test `find_bionemo_subpackages` when encountering a syntax error in a file.""" + subpackage_src = temp_project_structure / "bionemo-subpackage1" / "src" + subpackage_src.mkdir(parents=True, exist_ok=True) + + # Create a Python file with a syntax error + python_file = subpackage_src / "syntax_error.py" + with open(python_file, "w") as f: + f.write("import bionemo.analysis\nSyntax Error Here!!\n") + + directories = ["bionemo-subpackage1"] + found_imports = find_bionemo_subpackages(temp_project_structure, directories) + + assert "bionemo-subpackage1" in found_imports + assert found_imports["bionemo-subpackage1"] == {"bionemo-analysis"} # Syntax error shouldn't break parsing diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/api.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/api.py index e8eef729cd..cd8586b67b 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/api.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/api.py @@ -35,18 +35,6 @@ GeneformerModel = MegatronBioBertModel -class BERTMLMLossWithReductionNoForward(BERTMLMLossWithReduction): - def __init__( - self, - validation_step: bool = False, - val_drop_last: bool = True, - send_train_output: bool = False, - send_val_output: bool = False, - ) -> None: - """Same as BERTMLMLossWithReduction but set send_val_output=False by default since we do not use perplexity.""" - super().__init__(validation_step, val_drop_last, send_train_output, send_val_output) - - @dataclass class GeneformerConfig(BioBertConfig[GeneformerModel, MegatronLossType], iom.IOMixinWithGettersSetters): """A geneformer config. @@ -88,4 +76,4 @@ class GeneformerConfig(BioBertConfig[GeneformerModel, MegatronLossType], iom.IOM enable_autocast: bool = False model_cls: Type[GeneformerModel] = GeneformerModel - loss_reduction_class: Type[MegatronLossType] = BERTMLMLossWithReductionNoForward + loss_reduction_class: Type[MegatronLossType] = BERTMLMLossWithReduction diff --git a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py index 52cf8d77d7..9eaa638229 100644 --- a/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py +++ b/sub-packages/bionemo-geneformer/src/bionemo/geneformer/model/finetune_token_regressor.py @@ -144,10 +144,7 @@ def forward( loss_for_microbatch = loss_for_microbatch + rmse_loss # add in the RMSE loss after reducing the logit loss # average the losses across the data parallel group, but also return the unreduced loss reduced_loss: Tensor = average_losses_across_data_parallel_group([loss_for_microbatch]) - if (self.validation_step and self.send_val_output) or (not self.validation_step and self.send_train_output): - return loss_for_microbatch * cp_size, {"avg": reduced_loss, "batch": batch, "forward_out": forward_out} - else: - return loss_for_microbatch * cp_size, {"avg": reduced_loss} + return loss_for_microbatch * cp_size, {"avg": reduced_loss} class MegatronRegressionMLPHead(MegatronModule): diff --git a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py index 6ca0995971..95aa81612b 100644 --- a/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py +++ b/sub-packages/bionemo-geneformer/tests/bionemo/geneformer/scripts/test_train_geneformer.py @@ -181,6 +181,7 @@ def test_throws_tok_not_in_vocab_error(tmpdir, data_path): assert "not in the tokenizer vocab." in str(error_info.value) +@pytest.mark.slow # TODO: https://jirasw.nvidia.com/browse/BIONEMO-677, figure out why this is so slow. def test_pretrain_cli(tmpdir, data_path): result_dir = Path(tmpdir.mkdir("results")) open_port = find_free_network_port() diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py index baf5e72bde..eada4fdd3c 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py @@ -13,27 +13,25 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Callable, Dict, Generic, Iterable, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union +from typing import Any, Callable, Generic, Iterable, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union import lightning.pytorch as pl import torch.distributed +import torchmetrics.text from megatron.core import parallel_state from megatron.core.optimizer.optimizer_config import OptimizerConfig from nemo.lightning import io as nlio from nemo.lightning.megatron_parallel import ( - CallbackMethods, DataT, MegatronLossReduction, - MegatronStep, ReductionT, ) from nemo.lightning.pytorch.optim import MegatronOptimizerModule from torch import Tensor -from typing_extensions import override from bionemo.core.model.config import BionemoTrainableModelConfig from bionemo.llm.api import MegatronLossType, MegatronModelType -from bionemo.llm.model.loss import unreduced_token_loss_fn +from bionemo.llm.data.collate import MLM_LOSS_IGNORE_INDEX __all__: Sequence[str] = ( @@ -41,7 +39,6 @@ "batch_collator", "PassthroughLossReduction", "LightningPassthroughPredictionMixin", - "PerplexityLoggingCallback", "BionemoLightningModule", "default_megatron_optimizer", ) @@ -227,6 +224,8 @@ def __init__( # TODO: Add transformer_layer_spec when we update mcore optimizer: MegatronOptimizerModule, model_transform: Optional[Callable[[MegatronModelType], MegatronModelType]] = None, + log_train_ppl: bool = False, + log_val_ppl: bool = False, **model_construct_args, ) -> None: """Constructor. @@ -242,6 +241,8 @@ def __init__( model_construct_args: Optional. Any arguments necessary to construct the model in the `config`'s `configure_model` method. model_transform: Optional. The model transform function. + log_train_ppl (bool): Log training perplexity. + log_val_ppl (bool): Log validation perplexity. **model_construct_args: Optional. Arguments necessary for the supplied model configuration's `configure_model` method, which will make an instance of the model. """ @@ -258,6 +259,10 @@ def __init__( self._forward_step = forward_step self.model_transform = model_transform + # torchmetrics must init here for fiddle serialization + self.train_ppl = torchmetrics.text.Perplexity(ignore_index=MLM_LOSS_IGNORE_INDEX) if log_train_ppl else None + self.valid_ppl = torchmetrics.text.Perplexity(ignore_index=MLM_LOSS_IGNORE_INDEX) if log_val_ppl else None + def configure_model(self) -> None: """Updates internal state: instantiates the model from the object's config, assigns to `model` attribute. @@ -273,9 +278,14 @@ def configure_model(self) -> None: else self.config.configure_model() ) self.module = model + if self.module is None: raise ValueError("Invalid semantics: configure_model method **MUST** initialize the model.") + def is_on_logging_device(self): + """Return True if last stage of pipeline parallel and first tensor parallel rank.""" + return parallel_state.is_pipeline_last_stage() and parallel_state.get_tensor_model_parallel_rank() == 0 + def forward(self, *args, **kwargs) -> DataT: """Call the forward method of the underlying model, and return whatever it outputs.""" # safe to do because configure_model is idempotent @@ -304,11 +314,26 @@ def forward_step(self, batch) -> Tensor: def training_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: """In mcore the loss-function is part of the forward-pass when labels are provided.""" - return self.forward_step(batch) + outputs = self.forward_step(batch) + logits = outputs["token_logits"].detach().transpose(0, 1).clone() # [s, b, v] -> [b, s, v] + + if self.train_ppl is not None: + if self.is_on_logging_device(): + self.train_ppl(logits, batch["labels"]) + + self.log("train_ppl", self.train_ppl, on_step=True, on_epoch=False, prog_bar=True) + + return outputs def validation_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: """In mcore the loss-function is part of the forward-pass when labels are provided.""" - return self.forward_step(batch) + outputs = self.forward_step(batch) + logits = outputs["token_logits"].detach().transpose(0, 1).clone() # [s, b, v] -> [b, s, v] + + if self.valid_ppl is not None and self.is_on_logging_device(): + self.valid_ppl.update(logits, batch["labels"]) + + return outputs def predict_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: """Alias for forward_step.""" @@ -326,114 +351,19 @@ def validation_loss_reduction(self) -> MegatronLossType: # noqa: D102 def test_loss_reduction(self) -> MegatronLossType: # noqa: D102 return self.loss_reduction_class(validation_step=True) + def on_validation_epoch_end(self): # noqa: D102 + if self.valid_ppl is None: + return + + if self.trainer.sanity_checking: + self.valid_ppl.reset() # clean up sanity runs + return + + self.log("valid_ppl", self.valid_ppl, on_step=False, on_epoch=True, prog_bar=True) + def default_megatron_optimizer() -> MegatronOptimizerModule: """Default distributed optimizer uses Adam with a 1e-4 learning rate.""" return MegatronOptimizerModule( config=OptimizerConfig(lr=1e-4, optimizer="adam", use_distributed_optimizer=True), ) - - -class PerplexityLoggingCallback(pl.Callback, CallbackMethods): - """Megatron Callback to log perplexity in validation and optionally training. - - NeMo2.0 checks whether a callback is an instance of {LightningModule,LightningDataModule,Callback} but only megatron_hooks are useful. - """ - - def __init__(self, log_train: bool = False, log_val: bool = True): - """Initialize PerplexityLoggingCallback. - - Args: - log_train: whether to log train perplexity. Defaults to False. - log_val: whether to log validation perplexity. Defaults to True. - """ - super().__init__() - self.log_train = log_train - self.log_val = log_val - - def _pad_to_max_length( - self, - microbatch_outputs: List[Dict[str, Dict[str, Tensor]]], - key1: str, - key2: str, - pad_value: int = 0, - seq_dim: int = 1, - batch_dim: int = 0, - ) -> Tensor: - """Pad tensors to max length in microbatch_outputs.""" - assert seq_dim != batch_dim, "Forgot to set one of seq_dim, batch_dim, they are equal!" - max_sequence_length: int = max(output[key1][key2].shape[seq_dim] for output in microbatch_outputs) - - tensors: List[Tensor] = [] - for microbatch_output in microbatch_outputs: - tensor = microbatch_output[key1][key2] - assert ( - tensor.dim() >= 2 - ), f"Tensor in microbatch_outputs must have at least 2 dimensions, but got {tensor.dim()} dimensions" - pad_size = [(0, 0)] * tensor.dim() - pad_size[seq_dim] = (0, max_sequence_length - tensor.shape[seq_dim]) - # Flatten pad size list for F.pad - pad_size_flat = [item for sublist in reversed(pad_size) for item in sublist] - tensors.append( - torch.nn.functional.pad( # padding reverse in order - tensor, - pad_size_flat, - mode="constant", - value=pad_value, - ) - ) - - return torch.cat(tensors, dim=batch_dim) # concat on batch dim - - @override - def on_megatron_reduce_microbatches_end( - self, - step: MegatronStep, - microbatch_outputs: List[Any], - loss_reduction: MegatronLossReduction, - reduced: Tensor | dict[str, Tensor], - ) -> None: - """Log after MegatronReductionLoss.reduce is called. - - Expected microbatch_outputs to be a list of dicts with the following keys: - - batch: dict of tensors with the following keys: - - labels: [b s] - - loss_mask: [b s]; 1 means included 0 means ignored - - forward_out: dict of tensors with the following keys: - - token_logits: [b s vocab] - """ - if step.trainer.sanity_checking: # skip sanity check - return - - if step.trainer.training and not self.log_train: - return - - if not parallel_state.is_pipeline_last_stage(): - return - - assert step.num_microbatches is not None, "num_microbatches must be initialized to non-None" - assert step.num_microbatches > 0, "num_microbatches must be greater than 0" - assert ( - len(microbatch_outputs) == step.num_microbatches - ), "microbatch_outputs length does not match num_microbatches" - labels = self._pad_to_max_length(microbatch_outputs, "batch", "labels", pad_value=-100) - loss_mask = self._pad_to_max_length(microbatch_outputs, "batch", "loss_mask") - token_logits = self._pad_to_max_length( - microbatch_outputs, "forward_out", "token_logits", seq_dim=0, batch_dim=1 - ) - - unreduced_token_loss = unreduced_token_loss_fn( - token_logits.clone(), # [s,b] as expected unreduced_token_loss_fn has inplace operation on token_logits - labels.clone(), # [b,s] as expected - ) # [b s] is the return - - cp_size = parallel_state.get_context_parallel_world_size() - if cp_size == 1: - ppl = torch.exp((unreduced_token_loss * loss_mask).sum() / loss_mask.sum()) - else: - raise NotImplementedError("Context parallel perplexity logging is not supported yet") - - if self.log_val and not step.trainer.training: - step.pl_module.log("val_ppl", ppl, prog_bar=True, on_epoch=True) - elif self.log_train and step.trainer.training: - step.pl_module.log("train_ppl", ppl, prog_bar=True, batch_size=1, sync_dist=False) diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py b/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py index 425726da48..bf48a520c1 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/model/config.py @@ -45,6 +45,8 @@ "initial_ckpt_path_ignore_weights", "initial_ckpt_path", "model_cls", + "bf16", + "fp16", ] OVERRIDE_BIONEMO_CONFIG_DEFAULTS = deepcopy(_OVERRIDE_BIONEMO_CONFIG_DEFAULTS) # copy for export diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/model/loss.py b/sub-packages/bionemo-llm/src/bionemo/llm/model/loss.py index 3ceace7c25..c5d0dd470a 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/model/loss.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/model/loss.py @@ -143,26 +143,18 @@ def __init__( self, validation_step: bool = False, val_drop_last: bool = True, - send_train_output: bool = False, - send_val_output: bool = True, ) -> None: """Initializes the Model class. Args: validation_step (bool, optional): Whether this object is being applied to the validation step. Defaults to False. val_drop_last (bool, optional): Whether the last batch is configured to be dropped during validation. Defaults to True. - send_train_output (bool): Whether to return the model output in training. Defaults to False. - send_val_output (bool, optional): Whether to return the model output in validation. Defaults to True. - include_forward_output_for_metrics (bool): Some downstream metrics such as perplexity require this. It can be - expensive to return however, so disable this if performance is a top consideration. """ # TODO(@jomitchell): Track down how we handle test. This is a common pattern in NeMo2, but these parameters seem likely # to change in the future. super().__init__() self.validation_step = validation_step self.val_drop_last = val_drop_last - self.send_train_output = send_train_output - self.send_val_output = send_val_output def forward( self, batch: Dict[str, Tensor], forward_out: Dict[str, Tensor] @@ -182,20 +174,6 @@ def forward( if "labels" not in batch: raise ValueError("Labels not provided in the batch. These are required for this loss computation.") - train_step: bool = not self.validation_step - # Determine if we need to capture/send forward output for downstream metrics, such as perplexity logging - # this is expensive so only do if necessary. - send_forward_output: bool = (self.validation_step and self.send_val_output) or ( - train_step and self.send_train_output - ) - - if send_forward_output: - forward_out_report = { - k: v.detach().clone() if torch.is_tensor(v) else v for k, v in forward_out.items() - } # avoid impact from inplace operation on token_logits in unreduced_token_loss_fn - else: - forward_out_report = {} - # NOTE: token_logits is [sequence, batch] but labels and other fiels, including the loss are [batch, sequence] unreduced_token_loss = unreduced_token_loss_fn(forward_out["token_logits"], batch["labels"]) # [b s] @@ -249,14 +227,7 @@ def forward( # average the losses across the data parallel group, but also return the unreduced loss reduced_loss = average_losses_across_data_parallel_group([loss_for_microbatch]) - if send_forward_output: - return loss_for_microbatch * cp_size, { - "avg": reduced_loss, - "batch": batch, - "forward_out": forward_out_report, - } - else: - return loss_for_microbatch * cp_size, {"avg": reduced_loss} + return loss_for_microbatch * cp_size, {"avg": reduced_loss} def unreduced_token_loss_fn(logits: Tensor, labels: Tensor, cross_entropy_loss_fusion: bool = False) -> Tensor: diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py b/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py index a2065a2a02..33e604a57c 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/run/config_models.py @@ -311,7 +311,8 @@ class TrainingConfig(BaseModel): accelerator: str = "gpu" # NOTE: VERY important for distributed training performance. gc_interval: int = 0 - include_perplexity: bool = False + log_train_ppl: bool = False + log_val_ppl: bool = True enable_checkpointing: bool = True diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/train.py b/sub-packages/bionemo-llm/src/bionemo/llm/train.py index 094b763af6..71f6822137 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/train.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/train.py @@ -32,7 +32,7 @@ from pydantic import BaseModel from bionemo.core.utils.dtypes import get_autocast_dtype -from bionemo.llm.lightning import BionemoLightningModule, PerplexityLoggingCallback +from bionemo.llm.lightning import BionemoLightningModule from bionemo.llm.model.biobert.lightning import biobert_lightning_module from bionemo.llm.model.lr_scheduler import WarmupAnnealDecayHoldScheduler from bionemo.llm.run.config_models import ( @@ -132,9 +132,6 @@ def setup_trainer( LearningRateMonitor(), ] - if training_config.include_perplexity: - callbacks.append(PerplexityLoggingCallback()) - if training_config.gc_interval > 0: callbacks.append( nl_callbacks.GarbageCollectionCallback( @@ -252,7 +249,11 @@ def train( ) model: BionemoLightningModule = biobert_lightning_module( - config=bionemo_model_config, tokenizer=data.tokenizer, optimizer=optimizer + config=bionemo_model_config, + tokenizer=data.tokenizer, + optimizer=optimizer, + log_train_ppl=training_config.log_train_ppl, + log_val_ppl=training_config.log_val_ppl, ) trainer: nl.Trainer = setup_trainer(parallel_config, training_config, nsys_config=nsys_config) nemo_logger: nl.NeMoLogger = nemo_logger_factory(experiment_config, wandb_config=wandb_config) diff --git a/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py b/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py index 802cbeb94e..6e1a49b970 100644 --- a/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py +++ b/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py @@ -14,19 +14,14 @@ # limitations under the License. -from unittest import mock - import nemo.lightning as nl import pytest import torch -from nemo.lightning.megatron_parallel import MegatronLossReduction from torch import nn -from torchmetrics.text import Perplexity from bionemo.llm import lightning as bnptl -from bionemo.llm.lightning import PerplexityLoggingCallback, batch_collator, get_dtype_device +from bionemo.llm.lightning import batch_collator, get_dtype_device from bionemo.testing import megatron_parallel_state_utils -from bionemo.testing.lightning import get_random_microbatch def test_batch_collate_tuple(): @@ -184,148 +179,3 @@ def test_mixin_strategy_contract_get_loss_reduction(): mixin = bnptl.LightningPassthroughPredictionMixin() strategy_reduction_function = strategy._get_loss_reduction("predict") assert isinstance(strategy_reduction_function(mixin), bnptl.PassthroughLossReduction) - - -def test_perplexity_logging_callback_with_single_microbatch_golden_value_without_parallelism(seed: int = 42): - """Test PerplexityLoggingCallback with a single microbatch without parallelism""" - with megatron_parallel_state_utils.distributed_model_parallel_state(seed=seed): - # setup test input - microbatch_size, max_sequence_length, vocab_size = 1, 1024, 2 - microbatch_outputs = [get_random_microbatch(microbatch_size, max_sequence_length, vocab_size, seed)] - num_microbatches = len(microbatch_outputs) - - # setup mock objects - mock_megatron_step = mock.MagicMock() - mock_megatron_step.pl_module.log.return_value = None - mock_megatron_step.trainer.training = False - mock_megatron_step.trainer.sanity_checking = False - mock_megatron_step.num_microbatches = num_microbatches - - # setup callback - callback = PerplexityLoggingCallback(log_train=False, log_val=True) - callback.on_megatron_reduce_microbatches_end( - step=mock_megatron_step, - microbatch_outputs=microbatch_outputs, - loss_reduction=MegatronLossReduction(), # dummy - reduced=torch.empty(1), # dummy - ) - - # compare to torchmetric - metric = Perplexity(ignore_index=-100).to(torch.cuda.current_device()) - for microbatch_output in microbatch_outputs: - metric.update( - microbatch_output["forward_out"]["token_logits"].transpose(0, 1).contiguous(), - microbatch_output["batch"]["labels"], - ) - ppl_golden_value = metric.compute() - - val_ppl = mock_megatron_step.pl_module.log.call_args[0][1] - torch.testing.assert_close( - val_ppl, - torch.ones_like(val_ppl) * ppl_golden_value, - ) - - -def test_perplexity_logging_callback_with_variable_length_microbatches_golden_value_without_parallelism( - seed: int = 42, -): - """Test PerplexityLoggingCallback with variable-length microbatches without parallelism""" - with megatron_parallel_state_utils.distributed_model_parallel_state(seed=seed): - # setup test input - microbatch_size, max_sequence_length, vocab_size = 2, 1024, 2 - microbatch_outputs = [ - get_random_microbatch(microbatch_size, max_sequence_length // 2, vocab_size, seed), - get_random_microbatch(microbatch_size, max_sequence_length, vocab_size, seed), - ] - num_microbatches = len(microbatch_outputs) - - # setup mock objects - mock_megatron_step = mock.MagicMock() - mock_megatron_step.pl_module.log.return_value = None - mock_megatron_step.trainer.training = False - mock_megatron_step.trainer.sanity_checking = False - mock_megatron_step.num_microbatches = num_microbatches - - # setup callback - callback = PerplexityLoggingCallback(log_train=False, log_val=True) - callback.on_megatron_reduce_microbatches_end( - step=mock_megatron_step, - microbatch_outputs=microbatch_outputs, - loss_reduction=MegatronLossReduction(), - reduced=torch.empty(1), - ) - - # compare to torchmetric - metric = Perplexity(ignore_index=-100).to(torch.cuda.current_device()) - for microbatch_output in microbatch_outputs: - metric.update( - microbatch_output["forward_out"]["token_logits"].transpose(0, 1).contiguous(), - microbatch_output["batch"]["labels"], - ) - ppl_golden_value = metric.compute() - - val_ppl = mock_megatron_step.pl_module.log.call_args[0][1] - torch.testing.assert_close( - val_ppl, - torch.ones_like(val_ppl) * ppl_golden_value, - ) - - -@pytest.mark.skip(reason="tensor_parallel.vocab_parallel_cross_entropy requires tensor parallel group") -def test_perplexity_logging_callback_with_single_microbatch_only_log_at_pipeline_parallel_last_stage(seed: int = 42): - """Test PerplexityLoggingCallback only log at pipeline parallel last stage""" - # TODO(@sichu) investigate into non-mock solution - with ( - megatron_parallel_state_utils.distributed_model_parallel_state(), - mock.patch("megatron.core.parallel_state.get_pipeline_model_parallel_world_size", return_value=2), - ): - # setup test input - microbatch_size, max_sequence_length, vocab_size = 1, 1024, 2 - microbatch_outputs = [get_random_microbatch(microbatch_size, max_sequence_length, vocab_size, seed=seed)] - num_microbatches = len(microbatch_outputs) - - # setup mock objects - mock_megatron_step = mock.MagicMock() - mock_megatron_step.pl_module.log.return_value = None - mock_megatron_step.trainer.training = False - mock_megatron_step.trainer.sanity_checking = False - mock_megatron_step.num_microbatches = num_microbatches - - # setup callback - callback = PerplexityLoggingCallback(log_train=False, log_val=True) - - # compare to torchmetric - metric = Perplexity(ignore_index=-100).to(torch.cuda.current_device()) - for microbatch_output in microbatch_outputs: - metric.update( - microbatch_output["forward_out"]["token_logits"].transpose(0, 1).contiguous(), - microbatch_output["batch"]["labels"], - ) - ppl_golden_value = metric.compute() - - # check callback behavior - with mock.patch("megatron.core.parallel_state.is_pipeline_last_stage", return_value=True): - callback.on_megatron_reduce_microbatches_end( - step=mock_megatron_step, - microbatch_outputs=microbatch_outputs, - loss_reduction=MegatronLossReduction(), - reduced=torch.empty(1), - ) - mock_megatron_step.pl_module.log.assert_called_once() - - val_ppl = mock_megatron_step.pl_module.log.call_args[0][1] - torch.testing.assert_close( - val_ppl, - torch.tensor(ppl_golden_value, dtype=torch.float32, device=torch.cuda.current_device()), - msg="fail test on single microbatch in pipeline parallel", - ) - mock_megatron_step.pl_module.log.reset_mock() - - with mock.patch("megatron.core.parallel_state.is_pipeline_last_stage", return_value=False): - callback.on_megatron_reduce_microbatches_end( - step=mock_megatron_step, - microbatch_outputs=microbatch_outputs, - loss_reduction=MegatronLossReduction(), - reduced=torch.empty(1), - ) - mock_megatron_step.pl_module.log.assert_not_called() diff --git a/sub-packages/bionemo-moco/LICENSE b/sub-packages/bionemo-moco/LICENSE new file mode 120000 index 0000000000..61bc2cda7e --- /dev/null +++ b/sub-packages/bionemo-moco/LICENSE @@ -0,0 +1 @@ +../../LICENSE/license.txt \ No newline at end of file diff --git a/sub-packages/bionemo-moco/README.md b/sub-packages/bionemo-moco/README.md new file mode 100644 index 0000000000..e9af239aff --- /dev/null +++ b/sub-packages/bionemo-moco/README.md @@ -0,0 +1,35 @@ +# Modular Co-Design (MoCo) Interpolants + +## Description +MoCo enables abstracted interpolants for building and sampling from a variety of popular generative model frameworks. Specifically, MoCo supports interpolants for both continuous and discrete data types. + +### Continuous Data Interpolants +MoCo currently supports the following continuous data interpolants: +- DDPM (Denoising Diffusion Probabilistic Models) +- VDM (Variational Diffusion Models) +- CFM (Conditional Flow Matching) + +### Discrete Data Interpolants +MoCo also supports the following discrete data interpolants: +- D3PM (Discrete Denoising Diffusion Probabilistic Models) +- MDLM (Masked Diffusion Language Models) +- DFM (Discrete Flow Matching) + +### Useful Abstractions +MoCo also provides useful wrappers for customizable time distributions and inference time schedules. + +### Extendible +If the desired interpolant or sampling method is not already supported, MoCo was designed to be easily extended. + +## Installation + For Conda environment setup, please refer to the `environment` directory for specific instructions. + +Once your environment is set up, you can install this project by running the following command: + +```bash +pip install -e . +``` +This will install the project in editable mode, allowing you to make changes and see them reflected immediately. + +## Examples +Please see examples of all interpolants in the [examples directory](./examples). diff --git a/sub-packages/bionemo-moco/VERSION b/sub-packages/bionemo-moco/VERSION new file mode 100644 index 0000000000..8acdd82b76 --- /dev/null +++ b/sub-packages/bionemo-moco/VERSION @@ -0,0 +1 @@ +0.0.1 diff --git a/sub-packages/bionemo-moco/documentation.md b/sub-packages/bionemo-moco/documentation.md new file mode 100644 index 0000000000..1268834ea3 --- /dev/null +++ b/sub-packages/bionemo-moco/documentation.md @@ -0,0 +1,4620 @@ +# Table of Contents + +* [moco](#moco) +* [bionemo.moco.distributions](#mocodistributions) +* [bionemo.moco.distributions.prior.distribution](#mocodistributionspriordistribution) +* [bionemo.moco.distributions.prior.discrete.uniform](#mocodistributionspriordiscreteuniform) +* [bionemo.moco.distributions.prior.discrete.custom](#mocodistributionspriordiscretecustom) +* [bionemo.moco.distributions.prior.discrete](#mocodistributionspriordiscrete) +* [bionemo.moco.distributions.prior.discrete.mask](#mocodistributionspriordiscretemask) +* [bionemo.moco.distributions.prior.continuous.harmonic](#mocodistributionspriorcontinuousharmonic) +* [bionemo.moco.distributions.prior.continuous](#mocodistributionspriorcontinuous) +* [bionemo.moco.distributions.prior.continuous.gaussian](#mocodistributionspriorcontinuousgaussian) +* [bionemo.moco.distributions.prior.continuous.utils](#mocodistributionspriorcontinuousutils) +* [bionemo.moco.distributions.prior](#mocodistributionsprior) +* [bionemo.moco.distributions.time.distribution](#mocodistributionstimedistribution) +* [bionemo.moco.distributions.time.uniform](#mocodistributionstimeuniform) +* [bionemo.moco.distributions.time.logit\_normal](#mocodistributionstimelogit_normal) +* [bionemo.moco.distributions.time](#mocodistributionstime) +* [bionemo.moco.distributions.time.beta](#mocodistributionstimebeta) +* [bionemo.moco.distributions.time.utils](#mocodistributionstimeutils) +* [bionemo.moco.schedules.noise.continuous\_snr\_transforms](#mocoschedulesnoisecontinuous_snr_transforms) +* [bionemo.moco.schedules.noise.discrete\_noise\_schedules](#mocoschedulesnoisediscrete_noise_schedules) +* [bionemo.moco.schedules.noise](#mocoschedulesnoise) +* [bionemo.moco.schedules.noise.continuous\_noise\_transforms](#mocoschedulesnoisecontinuous_noise_transforms) +* [bionemo.moco.schedules](#mocoschedules) +* [bionemo.moco.schedules.utils](#mocoschedulesutils) +* [bionemo.moco.schedules.inference\_time\_schedules](#mocoschedulesinference_time_schedules) +* [bionemo.moco.interpolants.continuous\_time.discrete](#mocointerpolantscontinuous_timediscrete) +* [bionemo.moco.interpolants.continuous\_time.discrete.mdlm](#mocointerpolantscontinuous_timediscretemdlm) +* [bionemo.moco.interpolants.continuous\_time.discrete.discrete\_flow\_matching](#mocointerpolantscontinuous_timediscretediscrete_flow_matching) +* [bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.ot\_types](#mocointerpolantscontinuous_timecontinuousoptimal_transportot_types) +* [bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.ot\_sampler](#mocointerpolantscontinuous_timecontinuousoptimal_transportot_sampler) +* [bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.equivariant\_ot\_sampler](#mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_sampler) +* [bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.kabsch\_augmentation](#mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentation) +* [bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport](#mocointerpolantscontinuous_timecontinuousoptimal_transport) +* [bionemo.moco.interpolants.continuous\_time.continuous](#mocointerpolantscontinuous_timecontinuous) +* [bionemo.moco.interpolants.continuous\_time.continuous.vdm](#mocointerpolantscontinuous_timecontinuousvdm) +* [bionemo.moco.interpolants.continuous\_time.continuous.continuous\_flow\_matching](#mocointerpolantscontinuous_timecontinuouscontinuous_flow_matching) +* [bionemo.moco.interpolants.continuous\_time](#mocointerpolantscontinuous_time) +* [bionemo.moco.interpolants](#mocointerpolants) +* [bionemo.moco.interpolants.batch\_augmentation](#mocointerpolantsbatch_augmentation) +* [bionemo.moco.interpolants.discrete\_time.discrete.d3pm](#mocointerpolantsdiscrete_timediscreted3pm) +* [bionemo.moco.interpolants.discrete\_time.discrete](#mocointerpolantsdiscrete_timediscrete) +* [bionemo.moco.interpolants.discrete\_time.continuous.ddpm](#mocointerpolantsdiscrete_timecontinuousddpm) +* [bionemo.moco.interpolants.discrete\_time.continuous](#mocointerpolantsdiscrete_timecontinuous) +* [bionemo.moco.interpolants.discrete\_time](#mocointerpolantsdiscrete_time) +* [bionemo.moco.interpolants.discrete\_time.utils](#mocointerpolantsdiscrete_timeutils) +* [bionemo.moco.interpolants.base\_interpolant](#mocointerpolantsbase_interpolant) + +<a id="moco"></a> + +# moco + +<a id="mocodistributions"></a> + +# bionemo.moco.distributions + +<a id="mocodistributionspriordistribution"></a> + +# bionemo.moco.distributions.prior.distribution + +<a id="mocodistributionspriordistributionPriorDistribution"></a> + +## PriorDistribution Objects + +```python +class PriorDistribution(ABC) +``` + +An abstract base class representing a prior distribution. + +<a id="mocodistributionspriordistributionPriorDistributionsample"></a> + +#### sample + +```python +@abstractmethod +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu") -> Tensor +``` + +Generates a specified number of samples from the time distribution. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `mask` _Optional[Tensor], optional_ - A tensor indicating which samples should be masked. Defaults to None. +- `device` _str, optional_ - The device on which to generate the samples. Defaults to "cpu". + + +**Returns**: + +- `Float` - A tensor of samples. + +<a id="mocodistributionspriordistributionDiscretePriorDistribution"></a> + +## DiscretePriorDistribution Objects + +```python +class DiscretePriorDistribution(PriorDistribution) +``` + +An abstract base class representing a discrete prior distribution. + +<a id="mocodistributionspriordistributionDiscretePriorDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(num_classes: int, prior_dist: Tensor) +``` + +Initializes a DiscretePriorDistribution instance. + +**Arguments**: + +- `num_classes` _int_ - The number of classes in the discrete distribution. +- `prior_dist` _Tensor_ - The prior distribution over the classes. + + +**Returns**: + + None + +<a id="mocodistributionspriordistributionDiscretePriorDistributionget_num_classes"></a> + +#### get\_num\_classes + +```python +def get_num_classes() -> int +``` + +Getter for num_classes. + +<a id="mocodistributionspriordistributionDiscretePriorDistributionget_prior_dist"></a> + +#### get\_prior\_dist + +```python +def get_prior_dist() -> Tensor +``` + +Getter for prior_dist. + +<a id="mocodistributionspriordiscreteuniform"></a> + +# bionemo.moco.distributions.prior.discrete.uniform + +<a id="mocodistributionspriordiscreteuniformDiscreteUniformPrior"></a> + +## DiscreteUniformPrior Objects + +```python +class DiscreteUniformPrior(DiscretePriorDistribution) +``` + +A subclass representing a discrete uniform prior distribution. + +<a id="mocodistributionspriordiscreteuniformDiscreteUniformPrior__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(num_classes: int = 10) -> None +``` + +Initializes a discrete uniform prior distribution. + +**Arguments**: + +- `num_classes` _int_ - The number of classes in the discrete uniform distribution. Defaults to 10. + +<a id="mocodistributionspriordiscreteuniformDiscreteUniformPriorsample"></a> + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + +<a id="mocodistributionspriordiscretecustom"></a> + +# bionemo.moco.distributions.prior.discrete.custom + +<a id="mocodistributionspriordiscretecustomDiscreteCustomPrior"></a> + +## DiscreteCustomPrior Objects + +```python +class DiscreteCustomPrior(DiscretePriorDistribution) +``` + +A subclass representing a discrete custom prior distribution. + +This class allows for the creation of a prior distribution with a custom +probability mass function defined by the `prior_dist` tensor. For example if my data has 4 classes and I want [.3, .2, .4, .1] as the probabilities of the 4 classes. + +<a id="mocodistributionspriordiscretecustomDiscreteCustomPrior__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(prior_dist: Tensor, num_classes: int = 10) -> None +``` + +Initializes a DiscreteCustomPrior distribution. + +**Arguments**: + +- `prior_dist` - A tensor representing the probability mass function of the prior distribution. +- `num_classes` - The number of classes in the prior distribution. Defaults to 10. + + +**Notes**: + + The `prior_dist` tensor should have a sum close to 1.0, as it represents a probability mass function. + +<a id="mocodistributionspriordiscretecustomDiscreteCustomPriorsample"></a> + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Samples from the discrete custom prior distribution. + +**Arguments**: + +- `shape` - A tuple specifying the shape of the samples to generate. +- `mask` - An optional tensor mask to apply to the samples, broadcastable to the sample shape. Defaults to None. +- `device` - The device on which to generate the samples, specified as a string or a :class:`torch.device`. Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples drawn from the prior distribution. + +<a id="mocodistributionspriordiscrete"></a> + +# bionemo.moco.distributions.prior.discrete + +<a id="mocodistributionspriordiscretemask"></a> + +# bionemo.moco.distributions.prior.discrete.mask + +<a id="mocodistributionspriordiscretemaskDiscreteMaskedPrior"></a> + +## DiscreteMaskedPrior Objects + +```python +class DiscreteMaskedPrior(DiscretePriorDistribution) +``` + +A subclass representing a Discrete Masked prior distribution. + +<a id="mocodistributionspriordiscretemaskDiscreteMaskedPrior__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(num_classes: int = 10, + mask_dim: Optional[int] = None, + inclusive: bool = True) -> None +``` + +Discrete Masked prior distribution. + +Theres 3 ways I can think of defining the problem that are hard to mesh together. + +1. [..., M, ....] inclusive anywhere --> exisiting LLM tokenizer where the mask has a specific location not at the end +2. [......, M] inclusive on end --> mask_dim = None with inclusive set to True default stick on the end +3. [.....] + [M] exclusive --> the number of classes representes the number of data classes and one wishes to add a separate MASK dimension. +- Note the pad_sample function is provided to help add this extra external dimension. + +**Arguments**: + +- `num_classes` _int_ - The number of classes in the distribution. Defaults to 10. +- `mask_dim` _int_ - The index for the mask token. Defaults to num_classes - 1 if inclusive or num_classes if exclusive. +- `inclusive` _bool_ - Whether the mask is included in the specified number of classes. + If True, the mask is considered as one of the classes. + If False, the mask is considered as an additional class. Defaults to True. + +<a id="mocodistributionspriordiscretemaskDiscreteMaskedPriorsample"></a> + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + +<a id="mocodistributionspriordiscretemaskDiscreteMaskedPrioris_masked"></a> + +#### is\_masked + +```python +def is_masked(sample: Tensor) -> Tensor +``` + +Creates a mask for whether a state is masked. + +**Arguments**: + +- `sample` _Tensor_ - The sample to check. + + +**Returns**: + +- `Tensor` - A float tensor indicating whether the sample is masked. + +<a id="mocodistributionspriordiscretemaskDiscreteMaskedPriorpad_sample"></a> + +#### pad\_sample + +```python +def pad_sample(sample: Tensor) -> Tensor +``` + +Pads the input sample with zeros along the last dimension. + +**Arguments**: + +- `sample` _Tensor_ - The input sample to be padded. + + +**Returns**: + +- `Tensor` - The padded sample. + +<a id="mocodistributionspriorcontinuousharmonic"></a> + +# bionemo.moco.distributions.prior.continuous.harmonic + +<a id="mocodistributionspriorcontinuousharmonicLinearHarmonicPrior"></a> + +## LinearHarmonicPrior Objects + +```python +class LinearHarmonicPrior(PriorDistribution) +``` + +A subclass representing a Linear Harmonic prior distribution from Jit et al. https://arxiv.org/abs/2304.02198. + +<a id="mocodistributionspriorcontinuousharmonicLinearHarmonicPrior__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(distance: Float = 3.8, + length: Optional[int] = None, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None, + device: Union[str, torch.device] = "cpu") -> None +``` + +Linear Harmonic prior distribution. + +**Arguments**: + +- `distance` _Float_ - RMS distance between adjacent points in the line graph. +- `length` _Optional[int]_ - The number of points in a batch. +- `center` _bool_ - Whether to center the samples around the mean. Defaults to False. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocodistributionspriorcontinuousharmonicLinearHarmonicPriorsample"></a> + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples from the Harmonic prior distribution. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + +<a id="mocodistributionspriorcontinuous"></a> + +# bionemo.moco.distributions.prior.continuous + +<a id="mocodistributionspriorcontinuousgaussian"></a> + +# bionemo.moco.distributions.prior.continuous.gaussian + +<a id="mocodistributionspriorcontinuousgaussianGaussianPrior"></a> + +## GaussianPrior Objects + +```python +class GaussianPrior(PriorDistribution) +``` + +A subclass representing a Gaussian prior distribution. + +<a id="mocodistributionspriorcontinuousgaussianGaussianPrior__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(mean: Float = 0.0, + std: Float = 1.0, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None) -> None +``` + +Gaussian prior distribution. + +**Arguments**: + +- `mean` _Float_ - The mean of the Gaussian distribution. Defaults to 0.0. +- `std` _Float_ - The standard deviation of the Gaussian distribution. Defaults to 1.0. +- `center` _bool_ - Whether to center the samples around the mean. Defaults to False. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocodistributionspriorcontinuousgaussianGaussianPriorsample"></a> + +#### sample + +```python +def sample(shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Tensor +``` + +Generates a specified number of samples from the Gaussian prior distribution. + +**Arguments**: + +- `shape` _Tuple_ - The shape of the samples to generate. +- `device` _str_ - cpu or gpu. +- `mask` _Optional[Tensor]_ - An optional mask to apply to the samples. Defaults to None. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A tensor of samples. + +<a id="mocodistributionspriorcontinuousutils"></a> + +# bionemo.moco.distributions.prior.continuous.utils + +<a id="mocodistributionspriorcontinuousutilsremove_center_of_mass"></a> + +#### remove\_center\_of\_mass + +```python +def remove_center_of_mass(data: Tensor, + mask: Optional[Tensor] = None) -> Tensor +``` + +Calculates the center of mass (CoM) of the given data. + +**Arguments**: + +- `data` - The input data with shape (..., nodes, features). +- `mask` - An optional binary mask to apply to the data with shape (..., nodes) to mask out interaction from CoM calculation. Defaults to None. + + +**Returns**: + + The CoM of the data with shape (..., 1, features). + +<a id="mocodistributionsprior"></a> + +# bionemo.moco.distributions.prior + +<a id="mocodistributionstimedistribution"></a> + +# bionemo.moco.distributions.time.distribution + +<a id="mocodistributionstimedistributionTimeDistribution"></a> + +## TimeDistribution Objects + +```python +class TimeDistribution(ABC) +``` + +An abstract base class representing a time distribution. + +**Arguments**: + +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `min_t` _Optional[Float]_ - Min continuous time. +- `max_t` _Optional[Float]_ - Max continuous time. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocodistributionstimedistributionTimeDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(discrete_time: Bool = False, + nsteps: Optional[int] = None, + min_t: Optional[Float] = None, + max_t: Optional[Float] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a TimeDistribution object. + +<a id="mocodistributionstimedistributionTimeDistributionsample"></a> + +#### sample + +```python +@abstractmethod +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Float +``` + +Generates a specified number of samples from the time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A list or array of samples. + +<a id="mocodistributionstimedistributionMixTimeDistribution"></a> + +## MixTimeDistribution Objects + +```python +class MixTimeDistribution() +``` + +An abstract base class representing a mixed time distribution. + +uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) +beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) +mix_dist = MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=0.5) + +<a id="mocodistributionstimedistributionMixTimeDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(dist1: TimeDistribution, dist2: TimeDistribution, + mix_fraction: Float) +``` + +Initializes a MixTimeDistribution object. + +**Arguments**: + +- `dist1` _TimeDistribution_ - The first time distribution. +- `dist2` _TimeDistribution_ - The second time distribution. +- `mix_fraction` _Float_ - The fraction of samples to draw from dist1. Must be between 0 and 1. + +<a id="mocodistributionstimedistributionMixTimeDistributionsample"></a> + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) -> Float +``` + +Generates a specified number of samples from the mixed time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + +- `Float` - A list or array of samples. + +<a id="mocodistributionstimeuniform"></a> + +# bionemo.moco.distributions.time.uniform + +<a id="mocodistributionstimeuniformUniformTimeDistribution"></a> + +## UniformTimeDistribution Objects + +```python +class UniformTimeDistribution(TimeDistribution) +``` + +A class representing a uniform time distribution. + +<a id="mocodistributionstimeuniformUniformTimeDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a UniformTimeDistribution object. + +**Arguments**: + +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocodistributionstimeuniformUniformTimeDistributionsample"></a> + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + +<a id="mocodistributionstimeuniformSymmetricUniformTimeDistribution"></a> + +## SymmetricUniformTimeDistribution Objects + +```python +class SymmetricUniformTimeDistribution(TimeDistribution) +``` + +A class representing a uniform time distribution. + +<a id="mocodistributionstimeuniformSymmetricUniformTimeDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a UniformTimeDistribution object. + +**Arguments**: + +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocodistributionstimeuniformSymmetricUniformTimeDistributionsample"></a> + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + +<a id="mocodistributionstimelogit_normal"></a> + +# bionemo.moco.distributions.time.logit\_normal + +<a id="mocodistributionstimelogit_normalLogitNormalTimeDistribution"></a> + +## LogitNormalTimeDistribution Objects + +```python +class LogitNormalTimeDistribution(TimeDistribution) +``` + +A class representing a logit normal time distribution. + +<a id="mocodistributionstimelogit_normalLogitNormalTimeDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(p1: Float = 0.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a BetaTimeDistribution object. + +**Arguments**: + +- `p1` _Float_ - The first shape parameter of the logit normal distribution i.e. the mean. +- `p2` _Float_ - The second shape parameter of the logit normal distribution i.e. the std. +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocodistributionstimelogit_normalLogitNormalTimeDistributionsample"></a> + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + +<a id="mocodistributionstime"></a> + +# bionemo.moco.distributions.time + +<a id="mocodistributionstimebeta"></a> + +# bionemo.moco.distributions.time.beta + +<a id="mocodistributionstimebetaBetaTimeDistribution"></a> + +## BetaTimeDistribution Objects + +```python +class BetaTimeDistribution(TimeDistribution) +``` + +A class representing a beta time distribution. + +<a id="mocodistributionstimebetaBetaTimeDistribution__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(p1: Float = 2.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes a BetaTimeDistribution object. + +**Arguments**: + +- `p1` _Float_ - The first shape parameter of the beta distribution. +- `p2` _Float_ - The second shape parameter of the beta distribution. +- `min_t` _Float_ - The minimum time value. +- `max_t` _Float_ - The maximum time value. +- `discrete_time` _Bool_ - Whether the time is discrete. +- `nsteps` _Optional[int]_ - Number of nsteps for discretization. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocodistributionstimebetaBetaTimeDistributionsample"></a> + +#### sample + +```python +def sample(n_samples: int, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Generates a specified number of samples from the uniform time distribution. + +**Arguments**: + +- `n_samples` _int_ - The number of samples to generate. +- `device` _str_ - cpu or gpu. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + +**Returns**: + + A tensor of samples. + +<a id="mocodistributionstimeutils"></a> + +# bionemo.moco.distributions.time.utils + +<a id="mocodistributionstimeutilsfloat_time_to_index"></a> + +#### float\_time\_to\_index + +```python +def float_time_to_index(time: torch.Tensor, + num_time_steps: int) -> torch.Tensor +``` + +Convert a float time value to a time index. + +**Arguments**: + +- `time` _torch.Tensor_ - A tensor of float time values in the range [0, 1]. +- `num_time_steps` _int_ - The number of discrete time steps. + + +**Returns**: + +- `torch.Tensor` - A tensor of time indices corresponding to the input float time values. + +<a id="mocoschedulesnoisecontinuous_snr_transforms"></a> + +# bionemo.moco.schedules.noise.continuous\_snr\_transforms + +<a id="mocoschedulesnoisecontinuous_snr_transformslog"></a> + +#### log + +```python +def log(t, eps=1e-20) +``` + +Compute the natural logarithm of a tensor, clamping values to avoid numerical instability. + +**Arguments**: + +- `t` _Tensor_ - The input tensor. +- `eps` _float, optional_ - The minimum value to clamp the input tensor (default is 1e-20). + + +**Returns**: + +- `Tensor` - The natural logarithm of the input tensor. + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransform"></a> + +## ContinuousSNRTransform Objects + +```python +class ContinuousSNRTransform(ABC) +``` + +A base class for continuous SNR schedules. + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `direction` _TimeDirection_ - required this defines in which direction the scheduler was built + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformcalculate_log_snr"></a> + +#### calculate\_log\_snr + +```python +def calculate_log_snr(t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Public wrapper to generate the time schedule as a tensor. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps, with values ranging from 0 to 1. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". +- `synchronize` _optional[TimeDirection]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + +**Returns**: + +- `Tensor` - A tensor representing the log signal-to-noise (SNR) ratio for the given time steps. + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformlog_snr_to_alphas_sigmas"></a> + +#### log\_snr\_to\_alphas\_sigmas + +```python +def log_snr_to_alphas_sigmas(log_snr: Tensor) -> Tuple[Tensor, Tensor] +``` + +Converts log signal-to-noise ratio (SNR) to alpha and sigma values. + +**Arguments**: + +- `log_snr` _Tensor_ - The input log SNR tensor. + + +**Returns**: + + tuple[Tensor, Tensor]: A tuple containing the squared root of alpha and sigma values. + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformderivative"></a> + +#### derivative + +```python +def derivative(t: Tensor, func: Callable) -> Tensor +``` + +Compute derivative of a function, it supports bached single variable inputs. + +**Arguments**: + +- `t` _Tensor_ - time variable at which derivatives are taken +- `func` _Callable_ - function for derivative calculation + + +**Returns**: + +- `Tensor` - derivative that is detached from the computational graph + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformcalculate_general_sde_terms"></a> + +#### calculate\_general\_sde\_terms + +```python +def calculate_general_sde_terms(t) +``` + +Compute the general SDE terms for a given time step t. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time step. + + +**Returns**: + + tuple[Tensor, Tensor]: A tuple containing the drift term f_t and the diffusion term g_t_2. + + +**Notes**: + + This method computes the drift and diffusion terms of the general SDE, which can be used to simulate the stochastic process. + The drift term represents the deterministic part of the process, while the diffusion term represents the stochastic part. + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformcalculate_beta"></a> + +#### calculate\_beta + +```python +def calculate_beta(t) +``` + +Compute the drift coefficient for the OU process of the form $dx = -\frac{1}{2} \beta(t) x dt + sqrt(beta(t)) dw_t$. + +beta = d/dt log(alpha**2) = 2 * 1/alpha * d/dt(alpha) + +**Arguments**: + +- `t` _Union[float, Tensor]_ - t in [0, 1] + + +**Returns**: + +- `Tensor` - beta(t) + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformcalculate_alpha_log_snr"></a> + +#### calculate\_alpha\_log\_snr + +```python +def calculate_alpha_log_snr(log_snr: Tensor) -> Tensor +``` + +Compute alpha values based on the log SNR. + +**Arguments**: + +- `log_snr` _Tensor_ - The input tensor representing the log signal-to-noise ratio. + + +**Returns**: + +- `Tensor` - A tensor representing the alpha values for the given log SNR. + + +**Notes**: + + This method computes alpha values as the square root of the sigmoid of the log SNR. + +<a id="mocoschedulesnoisecontinuous_snr_transformsContinuousSNRTransformcalculate_alpha_t"></a> + +#### calculate\_alpha\_t + +```python +def calculate_alpha_t(t: Tensor) -> Tensor +``` + +Compute alpha values based on the log SNR schedule. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps. + + +**Returns**: + +- `Tensor` - A tensor representing the alpha values for the given time steps. + + +**Notes**: + + This method computes alpha values as the square root of the sigmoid of the log SNR. + +<a id="mocoschedulesnoisecontinuous_snr_transformsCosineSNRTransform"></a> + +## CosineSNRTransform Objects + +```python +class CosineSNRTransform(ContinuousSNRTransform) +``` + +A cosine SNR schedule. + +**Arguments**: + +- `nu` _Optional[Float]_ - Hyperparameter for the cosine schedule exponent (default is 1.0). +- `s` _Optional[Float]_ - Hyperparameter for the cosine schedule shift (default is 0.008). + +<a id="mocoschedulesnoisecontinuous_snr_transformsCosineSNRTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + +<a id="mocoschedulesnoisecontinuous_snr_transformsLinearSNRTransform"></a> + +## LinearSNRTransform Objects + +```python +class LinearSNRTransform(ContinuousSNRTransform) +``` + +A Linear SNR schedule. + +<a id="mocoschedulesnoisecontinuous_snr_transformsLinearSNRTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(min_value: Float = 1.0e-4) +``` + +Initialize the Linear SNR Transform. + +**Arguments**: + +- `min_value` _Float_ - min vaue of SNR defaults to 1.e-4. + +<a id="mocoschedulesnoisecontinuous_snr_transformsLinearLogInterpolatedSNRTransform"></a> + +## LinearLogInterpolatedSNRTransform Objects + +```python +class LinearLogInterpolatedSNRTransform(ContinuousSNRTransform) +``` + +A Linear Log space interpolated SNR schedule. + +<a id="mocoschedulesnoisecontinuous_snr_transformsLinearLogInterpolatedSNRTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(min_value: Float = -7.0, max_value=13.5) +``` + +Initialize the Linear log space interpolated SNR Schedule from Chroma. + +**Arguments**: + +- `min_value` _Float_ - The min log SNR value. +- `max_value` _Float_ - the max log SNR value. + +<a id="mocoschedulesnoisediscrete_noise_schedules"></a> + +# bionemo.moco.schedules.noise.discrete\_noise\_schedules + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteNoiseSchedule"></a> + +## DiscreteNoiseSchedule Objects + +```python +class DiscreteNoiseSchedule(ABC) +``` + +A base class for discrete noise schedules. + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteNoiseSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `nsteps` _int_ - number of discrete steps. +- `direction` _TimeDirection_ - required this defines in which direction the scheduler was built + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteNoiseSchedulegenerate_schedule"></a> + +#### generate\_schedule + +```python +def generate_schedule(nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Generate the noise schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). +- `synchronize` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteNoiseSchedulecalculate_derivative"></a> + +#### calculate\_derivative + +```python +def calculate_derivative( + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Calculate the time derivative of the schedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). +- `synchronize` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + + +**Returns**: + +- `Tensor` - A tensor representing the time derivative of the schedule. + + +**Raises**: + +- `NotImplementedError` - If the derivative calculation is not implemented for this schedule. + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteCosineNoiseSchedule"></a> + +## DiscreteCosineNoiseSchedule Objects + +```python +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule) +``` + +A cosine discrete noise schedule. + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteCosineNoiseSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of discrete steps. +- `nu` _Optional[Float]_ - Hyperparameter for the cosine schedule exponent (default is 1.0). +- `s` _Optional[Float]_ - Hyperparameter for the cosine schedule shift (default is 0.008). + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteLinearNoiseSchedule"></a> + +## DiscreteLinearNoiseSchedule Objects + +```python +class DiscreteLinearNoiseSchedule(DiscreteNoiseSchedule) +``` + +A linear discrete noise schedule. + +<a id="mocoschedulesnoisediscrete_noise_schedulesDiscreteLinearNoiseSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, beta_start: Float = 1e-4, beta_end: Float = 0.02) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `beta_start` _Optional[int]_ - starting beta value. Defaults to 1e-4. +- `beta_end` _Optional[int]_ - end beta value. Defaults to 0.02. + +<a id="mocoschedulesnoise"></a> + +# bionemo.moco.schedules.noise + +<a id="mocoschedulesnoisecontinuous_noise_transforms"></a> + +# bionemo.moco.schedules.noise.continuous\_noise\_transforms + +<a id="mocoschedulesnoisecontinuous_noise_transformsContinuousExpNoiseTransform"></a> + +## ContinuousExpNoiseTransform Objects + +```python +class ContinuousExpNoiseTransform(ABC) +``` + +A base class for continuous schedules. + +alpha = exp(- sigma) where 1 - alpha controls the masking fraction. + +<a id="mocoschedulesnoisecontinuous_noise_transformsContinuousExpNoiseTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + + direction : TimeDirection, required this defines in which direction the scheduler was built + +<a id="mocoschedulesnoisecontinuous_noise_transformsContinuousExpNoiseTransformcalculate_sigma"></a> + +#### calculate\_sigma + +```python +def calculate_sigma(t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Calculate the sigma for the given time steps. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps, with values ranging from 0 to 1. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". +- `synchronize` _optional[TimeDirection]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + +**Returns**: + +- `Tensor` - A tensor representing the sigma values for the given time steps. + + +**Raises**: + +- `ValueError` - If the input time steps exceed the maximum allowed value of 1. + +<a id="mocoschedulesnoisecontinuous_noise_transformsContinuousExpNoiseTransformsigma_to_alpha"></a> + +#### sigma\_to\_alpha + +```python +def sigma_to_alpha(sigma: Tensor) -> Tensor +``` + +Converts sigma to alpha values by alpha = exp(- sigma). + +**Arguments**: + +- `sigma` _Tensor_ - The input sigma tensor. + + +**Returns**: + +- `Tensor` - A tensor containing the alpha values. + +<a id="mocoschedulesnoisecontinuous_noise_transformsCosineExpNoiseTransform"></a> + +## CosineExpNoiseTransform Objects + +```python +class CosineExpNoiseTransform(ContinuousExpNoiseTransform) +``` + +A cosine Exponential noise schedule. + +<a id="mocoschedulesnoisecontinuous_noise_transformsCosineExpNoiseTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(eps: Float = 1.0e-3) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `eps` _Float_ - small number to prevent numerical issues. + +<a id="mocoschedulesnoisecontinuous_noise_transformsCosineExpNoiseTransformd_dt_sigma"></a> + +#### d\_dt\_sigma + +```python +def d_dt_sigma(t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor +``` + +Compute the derivative of sigma with respect to time. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". + + +**Returns**: + +- `Tensor` - A tensor representing the derivative of sigma with respect to time. + + +**Notes**: + + The derivative of sigma as a function of time is given by: + + d/dt sigma(t) = d/dt (-log(cos(t * pi / 2) + eps)) + + Using the chain rule, we get: + + d/dt sigma(t) = (-1 / (cos(t * pi / 2) + eps)) * (-sin(t * pi / 2) * pi / 2) + + This is the derivative that is computed and returned by this method. + +<a id="mocoschedulesnoisecontinuous_noise_transformsLogLinearExpNoiseTransform"></a> + +## LogLinearExpNoiseTransform Objects + +```python +class LogLinearExpNoiseTransform(ContinuousExpNoiseTransform) +``` + +A log linear exponential schedule. + +<a id="mocoschedulesnoisecontinuous_noise_transformsLogLinearExpNoiseTransform__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(eps: Float = 1.0e-3) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `eps` _Float_ - small value to prevent numerical issues. + +<a id="mocoschedulesnoisecontinuous_noise_transformsLogLinearExpNoiseTransformd_dt_sigma"></a> + +#### d\_dt\_sigma + +```python +def d_dt_sigma(t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor +``` + +Compute the derivative of sigma with respect to time. + +**Arguments**: + +- `t` _Tensor_ - The input tensor representing the time steps. +- `device` _Optional[str]_ - The device to place the schedule on. Defaults to "cpu". + + +**Returns**: + +- `Tensor` - A tensor representing the derivative of sigma with respect to time. + +<a id="mocoschedules"></a> + +# bionemo.moco.schedules + +<a id="mocoschedulesutils"></a> + +# bionemo.moco.schedules.utils + +<a id="mocoschedulesutilsTimeDirection"></a> + +## TimeDirection Objects + +```python +class TimeDirection(Enum) +``` + +Enum for the direction of the noise schedule. + +<a id="mocoschedulesutilsTimeDirectionUNIFIED"></a> + +#### UNIFIED + +Noise(0) --> Data(1) + +<a id="mocoschedulesutilsTimeDirectionDIFFUSION"></a> + +#### DIFFUSION + +Noise(1) --> Data(0) + +<a id="mocoschedulesinference_time_schedules"></a> + +# bionemo.moco.schedules.inference\_time\_schedules + +<a id="mocoschedulesinference_time_schedulesInferenceSchedule"></a> + +## InferenceSchedule Objects + +```python +class InferenceSchedule(ABC) +``` + +A base class for inference time schedules. + +<a id="mocoschedulesinference_time_schedulesInferenceSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the InferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesInferenceSchedulegenerate_schedule"></a> + +#### generate\_schedule + +```python +@abstractmethod +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optioanl[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesInferenceSchedulepad_time"></a> + +#### pad\_time + +```python +def pad_time(n_samples: int, + scalar_time: Float, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Creates a tensor of shape (n_samples,) filled with a scalar time value. + +**Arguments**: + +- `n_samples` _int_ - The desired dimension of the output tensor. +- `scalar_time` _Float_ - The scalar time value to fill the tensor with. + device (Optional[Union[str, torch.device]], optional): + The device to place the tensor on. Defaults to None, which uses the default device. + + +**Returns**: + +- `Tensor` - A tensor of shape (n_samples,) filled with the scalar time value. + +<a id="mocoschedulesinference_time_schedulesContinuousInferenceSchedule"></a> + +## ContinuousInferenceSchedule Objects + +```python +class ContinuousInferenceSchedule(InferenceSchedule) +``` + +A base class for continuous time inference schedules. + +<a id="mocoschedulesinference_time_schedulesContinuousInferenceSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the ContinuousInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `inclusive_end` _bool_ - If True, include the end value (1.0) in the schedule otherwise ends at 1.0-1/nsteps (default is False). +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesContinuousInferenceSchedulediscretize"></a> + +#### discretize + +```python +def discretize(nsteps: Optional[int] = None, + schedule: Optional[Tensor] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Discretize the time schedule into a list of time deltas. + +**Arguments**: + +- `nsteps` _Optioanl[int]_ - Number of time steps. If None, uses the value from initialization. +- `schedule` _Optional[Tensor]_ - Time scheudle if None will generate it with generate_schedule. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time deltas. + +<a id="mocoschedulesinference_time_schedulesDiscreteInferenceSchedule"></a> + +## DiscreteInferenceSchedule Objects + +```python +class DiscreteInferenceSchedule(InferenceSchedule) +``` + +A base class for discrete time inference schedules. + +<a id="mocoschedulesinference_time_schedulesDiscreteInferenceSchedulediscretize"></a> + +#### discretize + +```python +def discretize(nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Discretize the time schedule into a list of time deltas. + +**Arguments**: + +- `nsteps` _Optioanl[int]_ - Number of time steps. If None, uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time deltas. + +<a id="mocoschedulesinference_time_schedulesDiscreteLinearInferenceSchedule"></a> + +## DiscreteLinearInferenceSchedule Objects + +```python +class DiscreteLinearInferenceSchedule(DiscreteInferenceSchedule) +``` + +A linear time schedule for discrete time inference. + +<a id="mocoschedulesinference_time_schedulesDiscreteLinearInferenceSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the DiscreteLinearInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesDiscreteLinearInferenceSchedulegenerate_schedule"></a> + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the linear time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time steps. +- `Tensor` - A tensor of time steps. + +<a id="mocoschedulesinference_time_schedulesLinearInferenceSchedule"></a> + +## LinearInferenceSchedule Objects + +```python +class LinearInferenceSchedule(ContinuousInferenceSchedule) +``` + +A linear time schedule for continuous time inference. + +<a id="mocoschedulesinference_time_schedulesLinearInferenceSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the LinearInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `inclusive_end` _bool_ - If True, include the end value (1.0) in the schedule otherwise ends at 1.0-1/nsteps (default is False). +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesLinearInferenceSchedulegenerate_schedule"></a> + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the linear time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + +**Returns**: + +- `Tensor` - A tensor of time steps. + +<a id="mocoschedulesinference_time_schedulesPowerInferenceSchedule"></a> + +## PowerInferenceSchedule Objects + +```python +class PowerInferenceSchedule(ContinuousInferenceSchedule) +``` + +A power time schedule for inference, where time steps are generated by raising a uniform schedule to a specified power. + +<a id="mocoschedulesinference_time_schedulesPowerInferenceSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = 1.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the PowerInferenceSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `inclusive_end` _bool_ - If True, include the end value (1.0) in the schedule otherwise ends at <1.0 (default is False). +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `exponent` _Float_ - Power parameter defaults to 1.0. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesPowerInferenceSchedulegenerate_schedule"></a> + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the power time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + + + +**Returns**: + +- `Tensor` - A tensor of time steps. +- `Tensor` - A tensor of time steps. + +<a id="mocoschedulesinference_time_schedulesLogInferenceSchedule"></a> + +## LogInferenceSchedule Objects + +```python +class LogInferenceSchedule(ContinuousInferenceSchedule) +``` + +A log time schedule for inference, where time steps are generated by taking the logarithm of a uniform schedule. + +<a id="mocoschedulesinference_time_schedulesLogInferenceSchedule__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = -2.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu") +``` + +Initialize the LogInferenceSchedule. + +Returns a log space time schedule. + +Which for 100 steps with default parameters is: +tensor([0.0000, 0.0455, 0.0889, 0.1303, 0.1699, 0.2077, 0.2439, 0.2783, 0.3113, +0.3427, 0.3728, 0.4015, 0.4288, 0.4550, 0.4800, 0.5039, 0.5266, 0.5484, +0.5692, 0.5890, 0.6080, 0.6261, 0.6434, 0.6599, 0.6756, 0.6907, 0.7051, +0.7188, 0.7319, 0.7444, 0.7564, 0.7678, 0.7787, 0.7891, 0.7991, 0.8086, +0.8176, 0.8263, 0.8346, 0.8425, 0.8500, 0.8572, 0.8641, 0.8707, 0.8769, +0.8829, 0.8887, 0.8941, 0.8993, 0.9043, 0.9091, 0.9136, 0.9180, 0.9221, +0.9261, 0.9299, 0.9335, 0.9369, 0.9402, 0.9434, 0.9464, 0.9492, 0.9520, +0.9546, 0.9571, 0.9595, 0.9618, 0.9639, 0.9660, 0.9680, 0.9699, 0.9717, +0.9734, 0.9751, 0.9767, 0.9782, 0.9796, 0.9810, 0.9823, 0.9835, 0.9847, +0.9859, 0.9870, 0.9880, 0.9890, 0.9899, 0.9909, 0.9917, 0.9925, 0.9933, +0.9941, 0.9948, 0.9955, 0.9962, 0.9968, 0.9974, 0.9980, 0.9985, 0.9990, +0.9995]) + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `inclusive_end` _bool_ - If True, include the end value (1.0) in the schedule otherwise ends at <1.0 (default is False). +- `min_t` _Float_ - minimum time value defaults to 0. +- `padding` _Float_ - padding time value defaults to 0. +- `dilation` _Float_ - dilation time value defaults to 0 ie the number of replicates. +- `exponent` _Float_ - log space exponent parameter defaults to -2.0. The lower number the more aggressive the acceleration of 0 to 0.9 will be thus having more steps from 0.9 to 1.0. +- `direction` _Optional[str]_ - TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocoschedulesinference_time_schedulesLogInferenceSchedulegenerate_schedule"></a> + +#### generate\_schedule + +```python +def generate_schedule( + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None) -> Tensor +``` + +Generate the log time schedule as a tensor. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None uses the value from initialization. +- `device` _Optional[str]_ - Device to place the schedule on (default is "cpu"). + +<a id="mocointerpolantscontinuous_timediscrete"></a> + +# bionemo.moco.interpolants.continuous\_time.discrete + +<a id="mocointerpolantscontinuous_timediscretemdlm"></a> + +# bionemo.moco.interpolants.continuous\_time.discrete.mdlm + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLM"></a> + +## MDLM Objects + +```python +class MDLM(Interpolant) +``` + +A Masked discrete Diffusion Language Model (MDLM) interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.continuous_time.discrete.mdlm import MDLM +>>> from bionemo.bionemo.moco.schedules.noise.continuous_noise_transforms import CosineExpNoiseTransform +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import LinearTimeSchedule + + +mdlm = MDLM( + time_distribution = UniformTimeDistribution(discrete_time = False,...), + prior_distribution = DiscreteMaskedPrior(...), + noise_schedule = CosineExpNoiseTransform(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = mdlm.sample_time(batch_size) + xt = mdlm.interpolate(data, time) + + logits = model(xt, time) + loss = mdlm.loss(logits, data, xt, time) + loss.backward() + +# Generation +x_pred = mdlm.sample_prior(data.shape) +schedule = LinearTimeSchedule(...) +inference_time = schedule.generate_schedule() +dts = schedue.discreteize() +for t, dt in zip(inference_time, dts): + time = torch.full((batch_size,), t) + logits = model(x_pred, time) + x_pred = mdlm.step(logits, time, x_pred, dt) +return x_pred + +``` + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLM__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: DiscreteMaskedPrior, + noise_schedule: ContinuousExpNoiseTransform, + device: str = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Initialize the Masked Discrete Language Model (MDLM) interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution governing the time variable in the diffusion process. +- `prior_distribution` _DiscreteMaskedPrior_ - The prior distribution over the discrete token space, including masked tokens. +- `noise_schedule` _ContinuousExpNoiseTransform_ - The noise schedule defining the noise intensity as a function of time. +- `device` _str, optional_ - The device to use for computations. Defaults to "cpu". +- `rng_generator` _Optional[torch.Generator], optional_ - The random number generator for reproducibility. Defaults to None. + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMinterpolate"></a> + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMforward_process"></a> + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor) -> Tensor +``` + +Apply the forward process to the data at time t. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time + + +**Returns**: + +- `Tensor` - x(t) after applying the forward process + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMloss"></a> + +#### loss + +```python +def loss(logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + use_weight=True) +``` + +Calculate the cross-entropy loss between the model prediction and the target output. + +The loss is calculated between the batch x node x class logits and the target batch x node, +considering the current state of the discrete sequence `xt` at time `time`. + +If `use_weight` is True, the loss is weighted by the reduced form of the MDLM time weight for continuous NELBO, +as specified in equation 11 of https://arxiv.org/pdf/2406.07524. This weight is proportional to the derivative +of the noise schedule with respect to time, and is used to emphasize the importance of accurate predictions at +certain times in the diffusion process. + +**Arguments**: + +- `logits` _Tensor_ - The predicted output from the model, with shape batch x node x class. +- `target` _Tensor_ - The target output for the model prediction, with shape batch x node. +- `xt` _Tensor_ - The current state of the discrete sequence, with shape batch x node. +- `time` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `use_weight` _bool, optional_ - Whether to use the MDLM time weight for the loss. Defaults to True. + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMstep"></a> + +#### step + +```python +def step(logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + temperature: float = 1.0) -> Tensor +``` + +Perform a single step of MDLM DDPM step. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _Tensor_ - The time step increment. +- `temperature` _float_ - Softmax temperature defaults to 1.0. + + +**Returns**: + +- `Tensor` - The updated state. + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMget_num_steps_confidence"></a> + +#### get\_num\_steps\_confidence + +```python +def get_num_steps_confidence(xt: Tensor) +``` + +Calculate the maximum number of steps with confidence. + +This method computes the maximum count of occurrences where the input tensor `xt` matches the `mask_index` +along the last dimension (-1). The result is returned as a single float value. + +**Arguments**: + +- `xt` _Tensor_ - Input tensor to evaluate against the mask index. + + +**Returns**: + +- `float` - The maximum number of steps with confidence (i.e., matching the mask index). + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMstep_confidence"></a> + +#### step\_confidence + +```python +def step_confidence(logits: Tensor, + xt: Tensor, + curr_step: int, + num_steps: int, + logit_temperature: float = 1.0, + randomness: float = 1.0, + confidence_temperature: float = 1.0, + num_tokens_unmask: int = 1) -> Tensor +``` + +Update the input sequence xt by sampling from the predicted logits and adding Gumbel noise. + +Method taken from GenMol Lee et al. https://arxiv.org/abs/2501.06158 + +**Arguments**: + +- `logits` - Predicted logits +- `xt` - Input sequence +- `curr_step` - Current step +- `num_steps` - Total number of steps +- `logit_temperature` - Temperature for softmax over logits +- `randomness` - Scale for Gumbel noise +- `confidence_temperature` - Temperature for Gumbel confidence +- `num_tokens_unmask` - number of tokens to unmask each step + + +**Returns**: + + Updated input sequence xt unmasking num_tokens_unmask token each step. + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMstep_argmax"></a> + +#### step\_argmax + +```python +def step_argmax(model_out: Tensor) +``` + +Returns the index of the maximum value in the last dimension of the model output. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. + + +**Returns**: + +- `Tensor` - The index of the maximum value in the last dimension of the model output. + +<a id="mocointerpolantscontinuous_timediscretemdlmMDLMcalculate_score"></a> + +#### calculate\_score + +```python +def calculate_score(logits, x, t) +``` + +Returns score of the given sample x at time t with the corresponding model output logits. + +**Arguments**: + +- `logits` _Tensor_ - The output of the model. +- `x` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time. + + +**Returns**: + +- `Tensor` - The score defined in Appendix C.3 Equation 76 of MDLM. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matching"></a> + +# bionemo.moco.interpolants.continuous\_time.discrete.discrete\_flow\_matching + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcher"></a> + +## DiscreteFlowMatcher Objects + +```python +class DiscreteFlowMatcher(Interpolant) +``` + +A Discrete Flow Model (DFM) interpolant. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcher__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + device: str = "cpu", + eps: Float = 1e-5, + rng_generator: Optional[torch.Generator] = None) +``` + +Initialize the DFM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The time distribution for the diffusion process. +- `prior_distribution` _DiscretePriorDistribution_ - The prior distribution for the discrete masked tokens. +- `device` _str, optional_ - The device to use for computations. Defaults to "cpu". +- `eps` - small Float to prevent dividing by zero. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcherinterpolate"></a> + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time +- `noise` - tensor noise ids + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcherloss"></a> + +#### loss + +```python +def loss(logits: Tensor, + target: Tensor, + time: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + use_weight: Bool = False) +``` + +Calculate the cross-entropy loss between the model prediction and the target output. + +The loss is calculated between the batch x node x class logits and the target batch x node. +If using a masked prior please pass in the correct mask to calculate loss values on only masked states. +i.e. mask = data_mask * is_masked_state which is calculated with self.prior_dist.is_masked(xt)) + +If `use_weight` is True, the loss is weighted by 1/(1-t) defined in equation 24 in Appndix C. of https://arxiv.org/pdf/2402.04997 + +**Arguments**: + +- `logits` _Tensor_ - The predicted output from the model, with shape batch x node x class. +- `target` _Tensor_ - The target output for the model prediction, with shape batch x node. +- `time` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `use_weight` _bool, optional_ - Whether to use the DFM time weight for the loss. Defaults to True. + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcherstep"></a> + +#### step + +```python +def step(logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0) -> Tensor +``` + +Perform a single step of DFM euler updates. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _Tensor | float_ - The time step increment. +- `temperature` _Float, optional_ - The temperature for the softmax calculation. Defaults to 1.0. +- `stochasticity` _Float, optional_ - The stochasticity value for the step calculation. Defaults to 1.0. + + +**Returns**: + +- `Tensor` - The updated state. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcherstep_purity"></a> + +#### step\_purity + +```python +def step_purity(logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0) -> Tensor +``` + +Perform a single step of purity sampling. + +https://github.com/jasonkyuyim/multiflow/blob/6278899970523bad29953047e7a42b32a41dc813/multiflow/data/interpolant.py#L346 +Here's a high-level overview of what the function does: +TODO: check if the -1e9 and 1e-9 are small enough or using torch.inf would be better + +1. Preprocessing: +Checks if dt is a float and converts it to a tensor if necessary. +Pads t and dt to match the shape of xt. +Checks if the mask_index is valid (i.e., within the range of possible discrete values). +2. Masking: +Sets the logits corresponding to the mask_index to a low value (-1e9) to effectively mask out those values. +Computes the softmax probabilities of the logits. +Sets the probability of the mask_index to a small value (1e-9) to avoid numerical issues. +3.Purity sampling: +Computes the maximum log probabilities of the softmax distribution. +Computes the indices of the top-number_to_unmask samples with the highest log probabilities. +Uses these indices to sample new values from the original distribution. +4. Unmasking and updating: +Creates a mask to select the top-number_to_unmask samples. +Uses this mask to update the current state xt with the new samples. +5. Re-masking: +Generates a new mask to randomly re-mask some of the updated samples. +Applies this mask to the updated state xt. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _Tensor_ - The time step increment. +- `temperature` _Float, optional_ - The temperature for the softmax calculation. Defaults to 1.0. +- `stochasticity` _Float, optional_ - The stochasticity value for the step calculation. Defaults to 1.0. + + +**Returns**: + +- `Tensor` - The updated state. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcherstep_argmax"></a> + +#### step\_argmax + +```python +def step_argmax(model_out: Tensor) +``` + +Returns the index of the maximum value in the last dimension of the model output. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. + +<a id="mocointerpolantscontinuous_timediscretediscrete_flow_matchingDiscreteFlowMatcherstep_simple_sample"></a> + +#### step\_simple\_sample + +```python +def step_simple_sample(model_out: Tensor, + temperature: float = 1.0, + num_samples: int = 1) +``` + +Samples from the model output logits. Leads to more diversity than step_argmax. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `temperature` _Float, optional_ - The temperature for the softmax calculation. Defaults to 1.0. +- `num_samples` _int_ - Number of samples to return + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_types"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.ot\_types + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_typesOptimalTransportType"></a> + +## OptimalTransportType Objects + +```python +class OptimalTransportType(Enum) +``` + +An enumeration representing the type ofOptimal Transport that can be used in Continuous Flow Matching. + +- **EXACT**: Standard mini batch optimal transport defined in https://arxiv.org/pdf/2302.00482. +- **EQUIVARIANT**: Adding roto/translation optimization to mini batch OT see https://arxiv.org/pdf/2306.15030 https://arxiv.org/pdf/2312.07168 4.2. +- **KABSCH**: Simple Kabsch alignment between each data and noise point, No permuation # https://arxiv.org/pdf/2410.22388 Sec 3.2 + +These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_sampler"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.ot\_sampler + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_samplerOTSampler"></a> + +## OTSampler Objects + +```python +class OTSampler() +``` + +Sampler for Exact Mini-batch Optimal Transport Plan. + +OTSampler implements sampling coordinates according to an OT plan (wrt squared Euclidean cost) +with different implementations of the plan calculation. Code is adapted from https://github.com/atong01/conditional-flow-matching/blob/main/torchcfm/optimal_transport.py + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_samplerOTSampler__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(method: str = "exact", + device: Union[str, torch.device] = "cpu", + num_threads: int = 1) -> None +``` + +Initialize the OTSampler class. + +**Arguments**: + +- `method` _str_ - Choose which optimal transport solver you would like to use. Currently only support exact OT solvers (pot.emd). +- `device` _Union[str, torch.device], optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `num_threads` _Union[int, str], optional_ - Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + + +**Raises**: + +- `ValueError` - If the OT solver is not documented. +- `NotImplementedError` - If the OT solver is not implemented. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_samplerOTSamplerto_device"></a> + +#### to\_device + +```python +def to_device(device: str) +``` + +Moves all internal tensors to the specified device and updates the `self.device` attribute. + +**Arguments**: + +- `device` _str_ - The device to move the tensors to (e.g. "cpu", "cuda:0"). + + +**Notes**: + + This method is used to transfer the internal state of the OTSampler to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_samplerOTSamplersample_map"></a> + +#### sample\_map + +```python +def sample_map(pi: Tensor, + batch_size: int, + replace: Bool = False) -> Tuple[Tensor, Tensor] +``` + +Draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `pi` _Tensor_ - shape (bs, bs), the OT matrix between noise and data in minibatch. +- `batch_size` _int_ - The batch size of the minibatch. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the indices of noise and data samples from pi. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_samplerOTSamplerget_ot_matrix"></a> + +#### get\_ot\_matrix + +```python +def get_ot_matrix(x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None) -> Tensor +``` + +Compute the OT matrix between a source and a target minibatch. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + +**Returns**: + +- `p` _Tensor_ - shape (bs, bs), the OT matrix between noise and data in minibatch. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportot_samplerOTSamplerapply_ot"></a> + +#### apply\_ot + +```python +def apply_ot( + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False, + sort: Optional[Literal["noise", "x0", "data", "x1"]] = "x0" +) -> Tuple[Tensor, Tensor, Optional[Tensor]] +``` + +Sample indices for noise and data in minibatch according to OT plan. + +Compute the OT plan $\pi$ (wrt squared Euclidean cost) between a source and a target +minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. +- `sort` _str_ - Optional Literal string to sort either x1 or x0 based on the input. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors or 3 tensors if mask is used, represents the noise (plus mask) and data samples following OT plan pi. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_sampler"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.equivariant\_ot\_sampler + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSampler"></a> + +## EquivariantOTSampler Objects + +```python +class EquivariantOTSampler() +``` + +Sampler for Mini-batch Optimal Transport Plan with cost calculated after Kabsch alignment. + +EquivariantOTSampler implements sampling coordinates according to an OT plan +(wrt squared Euclidean cost after Kabsch alignment) with different implementations of the plan calculation. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSampler__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(method: str = "exact", + device: Union[str, torch.device] = "cpu", + num_threads: int = 1) -> None +``` + +Initialize the OTSampler class. + +**Arguments**: + +- `method` _str_ - Choose which optimal transport solver you would like to use. Currently only support exact OT solvers (pot.emd). +- `device` _Union[str, torch.device], optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `num_threads` _Union[int, str], optional_ - Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + + +**Raises**: + +- `ValueError` - If the OT solver is not documented. +- `NotImplementedError` - If the OT solver is not implemented. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSamplerto_device"></a> + +#### to\_device + +```python +def to_device(device: str) +``` + +Moves all internal tensors to the specified device and updates the `self.device` attribute. + +**Arguments**: + +- `device` _str_ - The device to move the tensors to (e.g. "cpu", "cuda:0"). + + +**Notes**: + + This method is used to transfer the internal state of the OTSampler to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSamplersample_map"></a> + +#### sample\_map + +```python +def sample_map(pi: Tensor, + batch_size: int, + replace: Bool = False) -> Tuple[Tensor, Tensor] +``` + +Draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `pi` _Tensor_ - shape (bs, bs), the OT matrix between noise and data in minibatch. +- `batch_size` _int_ - The batch size of the minibatch. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the indices of noise and data samples from pi. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSamplerkabsch_align"></a> + +#### kabsch\_align + +```python +def kabsch_align(target: Tensor, noise: Tensor) -> Tensor +``` + +Find the Rotation matrix (R) such that RMSD is minimized between target @ R.T and noise. + +**Arguments**: + +- `target` _Tensor_ - shape (N, *dim), data from source minibatch. +- `noise` _Tensor_ - shape (N, *dim), noise from source minibatch. + + +**Returns**: + +- `R` _Tensor_ - shape (*dim, *dim), the rotation matrix. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSamplerget_ot_matrix"></a> + +#### get\_ot\_matrix + +```python +def get_ot_matrix(x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None) -> Tuple[Tensor, Tensor] +``` + +Compute the OT matrix between a source and a target minibatch. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + +**Returns**: + +- `p` _Tensor_ - shape (bs, bs), the OT matrix between noise and data in minibatch. +- `Rs` _Tensor_ - shape (bs, bs, *dim, *dim), the rotation matrix between noise and data in minibatch. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportequivariant_ot_samplerEquivariantOTSamplerapply_ot"></a> + +#### apply\_ot + +```python +def apply_ot( + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False, + sort: Optional[Literal["noise", "x0", "data", "x1"]] = "x0" +) -> Tuple[Tensor, Tensor, Optional[Tensor]] +``` + +Sample indices for noise and data in minibatch according to OT plan. + +Compute the OT plan $\pi$ (wrt squared Euclidean cost after Kabsch alignment) between a source and a target +minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. +- `sort` _str_ - Optional Literal string to sort either x1 or x0 based on the input. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the noise and data samples following OT plan pi. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentation"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.kabsch\_augmentation + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentationKabschAugmentation"></a> + +## KabschAugmentation Objects + +```python +class KabschAugmentation() +``` + +Point-wise Kabsch alignment. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentationKabschAugmentation__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__() +``` + +Initialize the KabschAugmentation instance. + +**Notes**: + + - This implementation assumes no required initialization arguments. + - You can add instance variables (e.g., `self.variable_name`) as needed. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentationKabschAugmentationkabsch_align"></a> + +#### kabsch\_align + +```python +def kabsch_align(target: Tensor, noise: Tensor) +``` + +Find the Rotation matrix (R) such that RMSD is minimized between target @ R.T and noise. + +**Arguments**: + +- `target` _Tensor_ - shape (N, *dim), data from source minibatch. +- `noise` _Tensor_ - shape (N, *dim), noise from source minibatch. + + +**Returns**: + +- `R` _Tensor_ - shape (*dim, *dim), the rotation matrix. + Aliged Target (Tensor): target tensor rotated and shifted to reduced RMSD with noise + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentationKabschAugmentationbatch_kabsch_align"></a> + +#### batch\_kabsch\_align + +```python +def batch_kabsch_align(target: Tensor, noise: Tensor) +``` + +Find the Rotation matrix (R) such that RMSD is minimized between target @ R.T and noise. + +**Arguments**: + +- `target` _Tensor_ - shape (N, *dim), data from source minibatch. +- `noise` _Tensor_ - shape (N, *dim), noise from source minibatch. + + +**Returns**: + +- `R` _Tensor_ - shape (*dim, *dim), the rotation matrix. + Aliged Target (Tensor): target tensor rotated and shifted to reduced RMSD with noise + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transportkabsch_augmentationKabschAugmentationapply_ot"></a> + +#### apply\_ot + +```python +def apply_ot(x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + align_noise_to_data=True) -> Tuple[Tensor, Tensor] +``` + +Sample indices for noise and data in minibatch according to OT plan. + +Compute the OT plan $\pi$ (wrt squared Euclidean cost after Kabsch alignment) between a source and a target +minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. +- `replace` _bool_ - sampling w/ or w/o replacement from the OT plan, default to False. +- `align_noise_to_data` _bool_ - Direction of alignment default is True meaning it augments Noise to reduce error to Data. + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the noise and data samples following OT plan pi. + +<a id="mocointerpolantscontinuous_timecontinuousoptimal_transport"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport + +<a id="mocointerpolantscontinuous_timecontinuous"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous + +<a id="mocointerpolantscontinuous_timecontinuousvdm"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.vdm + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDM"></a> + +## VDM Objects + +```python +class VDM(Interpolant) +``` + +A Variational Diffusion Models (VDM) interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.discrete_time.continuous.vdm import VDM +>>> from bionemo.bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + + +vdm = VDM( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + noise_schedule = CosineSNRTransform(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = vdm.sample_time(batch_size) + noise = vdm.sample_prior(data.shape) + xt = vdm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = vdm.loss(x_pred, data, time) + loss.backward() + +# Generation +x_pred = vdm.sample_prior(data.shape) +for t in LinearInferenceSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = vdm.step(x_hat, time, x_pred) +return x_pred + +``` + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDM__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: ContinuousSNRTransform, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the DDPM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `noise_schedule` _ContinuousSNRTransform_ - The schedule of noise, defining the amount of noise added at each time step. +- `prediction_type` _PredictionType, optional_ - The type of prediction, either "data" or another type. Defaults to "data". +- `device` _str, optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMinterpolate"></a> + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor_ - noise from prior() + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMforward_process"></a> + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor, noise: Optional[Tensor] = None) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor, optional_ - noise from prior(). Defaults to None + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMprocess_data_prediction"></a> + +#### process\_data\_prediction + +```python +def process_data_prediction(model_output: Tensor, sample, t) +``` + +Converts the model output to a data prediction based on the prediction type. + +This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. +Given the model output and the sample, we convert the output to a data prediction based on the prediction type. +The conversion formulas are as follows: +- For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` +- For "data" prediction type: `pred_data = model_output` +- For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `sample` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The data prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not one of "noise", "data", or "v_prediction". + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMprocess_noise_prediction"></a> + +#### process\_noise\_prediction + +```python +def process_noise_prediction(model_output: Tensor, sample: Tensor, t: Tensor) +``` + +Do the same as process_data_prediction but take the model output and convert to nosie. + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `sample` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The input as noise if the prediction type is "noise". + + +**Raises**: + +- `ValueError` - If the prediction type is not "noise". + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMstep"></a> + +#### step + +```python +def step(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) +``` + +Do one step integration. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time step. +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool_ - Whether to center the data. Defaults to False. +- `temperature` _Float_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + +**Notes**: + + The temperature parameter controls the trade off between diversity and sample quality. + Decreasing the temperature sharpens the sampling distribtion to focus on more likely samples. + The impact of low temperature sampling must be ablated analytically. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMscore"></a> + +#### score + +```python +def score(x_hat: Tensor, xt: Tensor, t: Tensor) +``` + +Converts the data prediction to the estimated score function. + +**Arguments**: + +- `x_hat` _tensor_ - The predicted data point. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The estimated score function. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMstep_ddim"></a> + +#### step\_ddim + +```python +def step_ddim(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False) +``` + +Do one step of DDIM sampling. + +From the ddpm equations alpha_bar = alpha**2 and 1 - alpha**2 = sigma**2 + +**Arguments**: + +- `model_out` _Tensor_ - output of the model +- `t` _Tensor_ - current time step +- `xt` _Tensor_ - current data point +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - mask for the data point. Defaults to None. +- `eta` _Float, optional_ - DDIM sampling parameter. Defaults to 0.0. +- `center` _Bool, optional_ - whether to center the data point. Defaults to False. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMset_loss_weight_fn"></a> + +#### set\_loss\_weight\_fn + +```python +def set_loss_weight_fn(fn: Callable) +``` + +Sets the loss_weight attribute of the instance to the given function. + +**Arguments**: + +- `fn` - The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMloss_weight"></a> + +#### loss\_weight + +```python +def loss_weight(raw_loss: Tensor, + t: Tensor, + weight_type: str, + dt: Float = 0.001) -> Tensor +``` + +Calculates the weight for the loss based on the given weight type. + +This function computes the loss weight according to the specified `weight_type`. +The available weight types are: +- "ones": uniform weight of 1.0 +- "data_to_noise": derived from Equation (9) of https://arxiv.org/pdf/2202.00512 +- "variational_objective": based on the variational objective, see https://arxiv.org/pdf/2202.00512 + +**Arguments**: + +- `raw_loss` _Tensor_ - The raw loss calculated from the model prediction and target. +- `t` _Tensor_ - The time step. +- `weight_type` _str_ - The type of weight to use. Can be "ones", "data_to_noise", or "variational_objective". +- `dt` _Float, optional_ - The time step increment. Defaults to 0.001. + + +**Returns**: + +- `Tensor` - The weight for the loss. + + +**Raises**: + +- `ValueError` - If the weight type is not recognized. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMloss"></a> + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Tensor, + dt: Optional[Float] = 0.001, + mask: Optional[Tensor] = None, + weight_type: str = "ones") +``` + +Calculates the loss given the model prediction, target, and time. + +**Arguments**: + +- `model_pred` _Tensor_ - The predicted output from the model. +- `target` _Tensor_ - The target output for the model prediction. +- `t` _Tensor_ - The time at which the loss is calculated. +- `dt` _Optional[Float], optional_ - The time step increment. Defaults to 0.001. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `weight_type` _str, optional_ - The type of weight to use for the loss. Can be "ones", "data_to_noise", or "variational_objective". Defaults to "ones". + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMstep_hybrid_sde"></a> + +#### step\_hybrid\_sde + +```python +def step_hybrid_sde(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + equilibrium_rate: Float = 0.0) -> Tensor +``` + +Do one step integration of Hybrid Langevin-Reverse Time SDE. + +See section B.3 page 37 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. +and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time step. +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. +- `equilibrium_rate` _Float, optional_ - The rate of Langevin equilibration. Scales the amount of Langevin dynamics per unit time. Best values are in the range [1.0, 5.0]. Defaults to 0.0. + + +**Notes**: + + For all step functions that use the SDE formulation its important to note that we are moving backwards in time which corresponds to an apparent sign change. + A clear example can be seen in slide 29 https://ernestryu.com/courses/FM/diffusion1.pdf. + +<a id="mocointerpolantscontinuous_timecontinuousvdmVDMstep_ode"></a> + +#### step\_ode + +```python +def step_ode(model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) -> Tensor +``` + +Do one step integration of ODE. + +See section B page 36 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. +and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The current time step. +- `dt` _Tensor_ - The time step increment. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matching"></a> + +# bionemo.moco.interpolants.continuous\_time.continuous.continuous\_flow\_matching + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcher"></a> + +## ContinuousFlowMatcher Objects + +```python +class ContinuousFlowMatcher(Interpolant) +``` + +A Continuous Flow Matching interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + +flow_matcher = ContinuousFlowMatcher( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = flow_matcher.sample_time(batch_size) + noise = flow_matcher.sample_prior(data.shape) + data, time, noise = flow_matcher.apply_ot(noise, data) # Optional, only for OT + xt = flow_matcher.interpolate(data, time, noise) + flow = flow_matcher.calculate_target(data, noise) + + u_pred = model(xt, time) + loss = flow_matcher.loss(u_pred, flow) + loss.backward() + +# Generation +x_pred = flow_matcher.sample_prior(data.shape) +inference_sched = LinearInferenceSchedule(...) +for t in inference_sched.generate_schedule(): + time = inference_sched.pad_time(x_pred.shape[0], t) + u_hat = model(x_pred, time) + x_pred = flow_matcher.step(u_hat, x_pred, time) +return x_pred + +``` + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcher__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + sigma: Float = 0, + ot_type: Optional[Union[OptimalTransportType, str]] = None, + ot_num_threads: int = 1, + data_scale: Float = 1.0, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + eps: Float = 1e-5) +``` + +Initializes the Continuous Flow Matching interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `prediction_type` _PredictionType, optional_ - The type of prediction, either "flow" or another type. Defaults to PredictionType.DATA. +- `sigma` _Float, optional_ - The standard deviation of the Gaussian noise added to the interpolated data. Defaults to 0. +- `ot_type` _Optional[Union[OptimalTransportType, str]], optional_ - The type of optimal transport, if applicable. Defaults to None. +- `ot_num_threads` - Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. +- `data_scale` _Float, optional_ - The scale factor for the data. Defaults to 1.0. +- `device` _Union[str, torch.device], optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. +- `eps` - Small float to prevent divide by zero + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherapply_ot"></a> + +#### apply\_ot + +```python +def apply_ot(x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + **kwargs) -> tuple +``` + +Sample and apply the optimal transport plan between batched (and masked) x0 and x1. + +**Arguments**: + +- `x0` _Tensor_ - shape (bs, *dim), noise from source minibatch. +- `x1` _Tensor_ - shape (bs, *dim), data from source minibatch. +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. +- `**kwargs` - Additional keyword arguments to be passed to self.ot_sampler.apply_ot or handled within this method. + + + +**Returns**: + +- `Tuple` - tuple of 2 tensors, represents the noise and data samples following OT plan pi. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherundo_scale_data"></a> + +#### undo\_scale\_data + +```python +def undo_scale_data(data: Tensor) -> Tensor +``` + +Downscale the input data by the data scale factor. + +**Arguments**: + +- `data` _Tensor_ - The input data to downscale. + + +**Returns**: + + The downscaled data. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherscale_data"></a> + +#### scale\_data + +```python +def scale_data(data: Tensor) -> Tensor +``` + +Upscale the input data by the data scale factor. + +**Arguments**: + +- `data` _Tensor_ - The input data to upscale. + + +**Returns**: + + The upscaled data. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherinterpolate"></a> + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) -> Tensor +``` + +Get x_t with given time t from noise (x_0) and data (x_1). + +Currently, we use the linear interpolation as defined in: +1. Rectified flow: https://arxiv.org/abs/2209.03003. +2. Conditional flow matching: https://arxiv.org/abs/2210.02747 (called conditional optimal transport). + +**Arguments**: + +- `noise` _Tensor_ - noise from prior(), shape (batchsize, nodes, features) +- `t` _Tensor_ - time, shape (batchsize) +- `data` _Tensor_ - target, shape (batchsize, nodes, features) + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatchercalculate_target"></a> + +#### calculate\_target + +```python +def calculate_target(data: Tensor, + noise: Tensor, + mask: Optional[Tensor] = None) -> Tensor +``` + +Get the target vector field at time t. + +**Arguments**: + +- `noise` _Tensor_ - noise from prior(), shape (batchsize, nodes, features) +- `data` _Tensor_ - target, shape (batchsize, nodes, features) +- `mask` _Optional[Tensor], optional_ - mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + +**Returns**: + +- `Tensor` - The target vector field at time t. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherprocess_vector_field_prediction"></a> + +#### process\_vector\_field\_prediction + +```python +def process_vector_field_prediction(model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None) +``` + +Process the model output based on the prediction type to calculate vecotr field. + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the model output. Defaults to None. + + +**Returns**: + + The vector field prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not "flow" or "data". + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherprocess_data_prediction"></a> + +#### process\_data\_prediction + +```python +def process_data_prediction(model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None) +``` + +Process the model output based on the prediction type to generate clean data. + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `xt` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the model output. Defaults to None. + + +**Returns**: + + The data prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not "flow". + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherstep"></a> + +#### step + +```python +def step(model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + center: Bool = False) +``` + +Perform a single ODE step integration using Euler method. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model at the current time step. +- `xt` _Tensor_ - The current intermediate state. +- `dt` _Tensor_ - The time step size. +- `t` _Tensor, optional_ - The current time. Defaults to None. +- `mask` _Optional[Tensor], optional_ - A mask to apply to the model output. Defaults to None. +- `center` _Bool, optional_ - Whether to center the output. Defaults to False. + + +**Returns**: + +- `x_next` _Tensor_ - The updated state of the system after the single step, x_(t+dt). + + +**Notes**: + + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherstep_score_stochastic"></a> + +#### step\_score\_stochastic + +```python +def step_score_stochastic(model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Tensor, + mask: Optional[Tensor] = None, + gt_mode: str = "tan", + gt_p: Float = 1.0, + gt_clamp: Optional[Float] = None, + score_temperature: Float = 1.0, + noise_temperature: Float = 1.0, + t_lim_ode: Float = 0.99, + center: Bool = False) +``` + +Perform a single SDE step integration using a score-based Langevin update. + +d x_t = [v(x_t, t) + g(t) * s(x_t, t) * score_temperature] dt + \sqrt{2 * g(t) * noise_temperature} dw_t. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model at the current time step. +- `xt` _Tensor_ - The current intermediate state. +- `dt` _Tensor_ - The time step size. +- `t` _Tensor, optional_ - The current time. Defaults to None. +- `mask` _Optional[Tensor], optional_ - A mask to apply to the model output. Defaults to None. +- `gt_mode` _str, optional_ - The mode for the gt function. Defaults to "tan". +- `gt_p` _Float, optional_ - The parameter for the gt function. Defaults to 1.0. +- `gt_clamp` - (Float, optional): Upper limit of gt term. Defaults to None. +- `score_temperature` _Float, optional_ - The temperature for the score part of the step. Defaults to 1.0. +- `noise_temperature` _Float, optional_ - The temperature for the stochastic part of the step. Defaults to 1.0. +- `t_lim_ode` _Float, optional_ - The time limit for the ODE step. Defaults to 0.99. +- `center` _Bool, optional_ - Whether to center the output. Defaults to False. + + +**Returns**: + +- `x_next` _Tensor_ - The updated state of the system after the single step, x_(t+dt). + + +**Notes**: + + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherloss"></a> + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + xt: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + target_type: Union[PredictionType, str] = PredictionType.DATA) +``` + +Calculate the loss given the model prediction, data sample, time, and mask. + +If target_type is FLOW loss = ||v_hat - (x1-x0)||**2 +If target_type is DATA loss = ||x1_hat - x1||**2 * 1 / (1 - t)**2 as the target vector field = x1 - x0 = (1/(1-t)) * x1 - xt where xt = tx1 - (1-t)x0. +This functions supports any cominbation of prediction_type and target_type in {DATA, FLOW}. + +**Arguments**: + +- `model_pred` _Tensor_ - The predicted output from the model. +- `target` _Tensor_ - The target output for the model prediction. +- `t` _Optional[Tensor], optional_ - The time for the model prediction. Defaults to None. +- `xt` _Optional[Tensor], optional_ - The interpolated data. Defaults to None. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `target_type` _PredictionType, optional_ - The type of the target output. Defaults to PredictionType.DATA. + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatchervf_to_score"></a> + +#### vf\_to\_score + +```python +def vf_to_score(x_t: Tensor, v: Tensor, t: Tensor) -> Tensor +``` + +From Geffner et al. Computes score of noisy density given the vector field learned by flow matching. + +With our interpolation scheme these are related by + +v(x_t, t) = (1 / t) (x_t + scale_ref ** 2 * (1 - t) * s(x_t, t)), + +or equivalently, + +s(x_t, t) = (t * v(x_t, t) - x_t) / (scale_ref ** 2 * (1 - t)). + +with scale_ref = 1 + +**Arguments**: + +- `x_t` - Noisy sample, shape [*, dim] +- `v` - Vector field, shape [*, dim] +- `t` - Interpolation time, shape [*] (must be < 1) + + +**Returns**: + + Score of intermediate density, shape [*, dim]. + +<a id="mocointerpolantscontinuous_timecontinuouscontinuous_flow_matchingContinuousFlowMatcherget_gt"></a> + +#### get\_gt + +```python +def get_gt(t: Tensor, + mode: str = "tan", + param: float = 1.0, + clamp_val: Optional[float] = None, + eps: float = 1e-2) -> Tensor +``` + +From Geffner et al. Computes gt for different modes. + +**Arguments**: + +- `t` - times where we'll evaluate, covers [0, 1), shape [nsteps] +- `mode` - "us" or "tan" +- `param` - parameterized transformation +- `clamp_val` - value to clamp gt, no clamping if None +- `eps` - small value leave as it is + +<a id="mocointerpolantscontinuous_time"></a> + +# bionemo.moco.interpolants.continuous\_time + +<a id="mocointerpolants"></a> + +# bionemo.moco.interpolants + +<a id="mocointerpolantsbatch_augmentation"></a> + +# bionemo.moco.interpolants.batch\_augmentation + +<a id="mocointerpolantsbatch_augmentationBatchAugmentation"></a> + +## BatchAugmentation Objects + +```python +class BatchAugmentation() +``` + +Facilitates the creation of batch augmentation objects based on specified optimal transport types. + +**Arguments**: + +- `device` _str_ - The device to use for computations (e.g., 'cpu', 'cuda'). +- `num_threads` _int_ - The number of threads to utilize. + +<a id="mocointerpolantsbatch_augmentationBatchAugmentation__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(device, num_threads) +``` + +Initializes a BatchAugmentation instance. + +**Arguments**: + +- `device` _str_ - Device for computation. +- `num_threads` _int_ - Number of threads to use. + +<a id="mocointerpolantsbatch_augmentationBatchAugmentationcreate"></a> + +#### create + +```python +def create(method_type: OptimalTransportType) +``` + +Creates a batch augmentation object of the specified type. + +**Arguments**: + +- `method_type` _OptimalTransportType_ - The type of optimal transport method. + + +**Returns**: + + The augmentation object if the type is supported, otherwise **None**. + +<a id="mocointerpolantsdiscrete_timediscreted3pm"></a> + +# bionemo.moco.interpolants.discrete\_time.discrete.d3pm + +<a id="mocointerpolantsdiscrete_timediscreted3pmD3PM"></a> + +## D3PM Objects + +```python +class D3PM(Interpolant) +``` + +A Discrete Denoising Diffusion Probabilistic Model (D3PM) interpolant. + +<a id="mocointerpolantsdiscrete_timediscreted3pmD3PM__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + device: str = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the D3PM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `noise_schedule` _DiscreteNoiseSchedule_ - The schedule of noise, defining the amount of noise added at each time step. +- `device` _str, optional_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `last_time_idx` _int, optional_ - The last time index to consider in the interpolation process. Defaults to 0. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocointerpolantsdiscrete_timediscreted3pmD3PMinterpolate"></a> + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor) +``` + +Interpolate using discrete interpolation method. + +This method implements Equation 2 from the D3PM paper (https://arxiv.org/pdf/2107.03006), which +calculates the interpolated discrete state `xt` at time `t` given the input data and noise +via q(xt|x0) = Cat(xt; p = x0*Qt_bar). + +**Arguments**: + +- `data` _Tensor_ - The input data to be interpolated. +- `t` _Tensor_ - The time step at which to interpolate. + + +**Returns**: + +- `Tensor` - The interpolated discrete state `xt` at time `t`. + +<a id="mocointerpolantsdiscrete_timediscreted3pmD3PMforward_process"></a> + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor) -> Tensor +``` + +Apply the forward process to the data at time t. + +**Arguments**: + +- `data` _Tensor_ - target discrete ids +- `t` _Tensor_ - time + + +**Returns**: + +- `Tensor` - x(t) after applying the forward process + +<a id="mocointerpolantsdiscrete_timediscreted3pmD3PMstep"></a> + +#### step + +```python +def step(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + temperature: Float = 1.0, + model_out_is_logits: bool = True) +``` + +Perform a single step in the discrete interpolant method, transitioning from the current discrete state `xt` at time `t` to the next state. + +This step involves: + +1. Computing the predicted q-posterior logits using the model output `model_out` and the current state `xt` at time `t`. +2. Sampling the next state from the predicted q-posterior distribution using the Gumbel-Softmax trick. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model at the current time step, which is used to compute the predicted q-posterior logits. +- `t` _Tensor_ - The current time step, which is used to index into the transition matrices and compute the predicted q-posterior logits. +- `xt` _Tensor_ - The current discrete state at time `t`, which is used to compute the predicted q-posterior logits and sample the next state. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the next state, which can be used to mask out certain tokens or regions. Defaults to None. +- `temperature` _Float, optional_ - The temperature to use for the Gumbel-Softmax trick, which controls the randomness of the sampling process. Defaults to 1.0. +- `model_out_is_logits` _bool, optional_ - A flag indicating whether the model output is already in logits form. If True, the output is assumed to be logits; otherwise, it is converted to logits. Defaults to True. + + +**Returns**: + +- `Tensor` - The next discrete state at time `t-1`. + +<a id="mocointerpolantsdiscrete_timediscreted3pmD3PMloss"></a> + +#### loss + +```python +def loss(logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + vb_scale: Float = 0.0) +``` + +Calculate the cross-entropy loss between the model prediction and the target output. + +The loss is calculated between the batch x node x class logits and the target batch x node. If a mask is provided, the loss is +calculated only for the non-masked elements. Additionally, if vb_scale is greater than 0, the variational lower bound loss is +calculated and added to the total loss. + +**Arguments**: + +- `logits` _Tensor_ - The predicted output from the model, with shape batch x node x class. +- `target` _Tensor_ - The target output for the model prediction, with shape batch x node. +- `xt` _Tensor_ - The current data point. +- `time` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `vb_scale` _Float, optional_ - The scale factor for the variational lower bound loss. Defaults to 0.0. + + +**Returns**: + +- `Tensor` - The calculated loss tensor. If aggregate is True, the loss and variational lower bound loss are aggregated and + returned as a single tensor. Otherwise, the loss and variational lower bound loss are returned as separate tensors. + +<a id="mocointerpolantsdiscrete_timediscrete"></a> + +# bionemo.moco.interpolants.discrete\_time.discrete + +<a id="mocointerpolantsdiscrete_timecontinuousddpm"></a> + +# bionemo.moco.interpolants.discrete\_time.continuous.ddpm + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPM"></a> + +## DDPM Objects + +```python +class DDPM(Interpolant) +``` + +A Denoising Diffusion Probabilistic Model (DDPM) interpolant. + +------- + +**Examples**: + +```python +>>> import torch +>>> from bionemo.bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +>>> from bionemo.bionemo.moco.distributions.time.uniform import UniformTimeDistribution +>>> from bionemo.bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM +>>> from bionemo.bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule +>>> from bionemo.bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule + + +ddpm = DDPM( + time_distribution = UniformTimeDistribution(discrete_time = True,...), + prior_distribution = GaussianPrior(...), + noise_schedule = DiscreteCosineNoiseSchedule(...), + ) +model = Model(...) + +# Training +for epoch in range(1000): + data = data_loader.get(...) + time = ddpm.sample_time(batch_size) + noise = ddpm.sample_prior(data.shape) + xt = ddpm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = ddpm.loss(x_pred, data, time) + loss.backward() + +# Generation +x_pred = ddpm.sample_prior(data.shape) +for t in DiscreteLinearTimeSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = ddpm.step(x_hat, time, x_pred) +return x_pred + +``` + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPM__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the DDPM interpolant. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps, used to sample time points for the diffusion process. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable, used as the starting point for the diffusion process. +- `noise_schedule` _DiscreteNoiseSchedule_ - The schedule of noise, defining the amount of noise added at each time step. +- `prediction_type` _PredictionType_ - The type of prediction, either "data" or another type. Defaults to "data". +- `device` _str_ - The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". +- `last_time_idx` _int, optional_ - The last time index for discrete time. Set to 0 if discrete time is T-1, ..., 0 or 1 if T, ..., 1. Defaults to 0. +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMforward_data_schedule"></a> + +#### forward\_data\_schedule + +```python +@property +def forward_data_schedule() -> torch.Tensor +``` + +Returns the forward data schedule. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMforward_noise_schedule"></a> + +#### forward\_noise\_schedule + +```python +@property +def forward_noise_schedule() -> torch.Tensor +``` + +Returns the forward noise schedule. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMreverse_data_schedule"></a> + +#### reverse\_data\_schedule + +```python +@property +def reverse_data_schedule() -> torch.Tensor +``` + +Returns the reverse data schedule. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMreverse_noise_schedule"></a> + +#### reverse\_noise\_schedule + +```python +@property +def reverse_noise_schedule() -> torch.Tensor +``` + +Returns the reverse noise schedule. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMlog_var"></a> + +#### log\_var + +```python +@property +def log_var() -> torch.Tensor +``` + +Returns the log variance. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMalpha_bar"></a> + +#### alpha\_bar + +```python +@property +def alpha_bar() -> torch.Tensor +``` + +Returns the alpha bar values. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMalpha_bar_prev"></a> + +#### alpha\_bar\_prev + +```python +@property +def alpha_bar_prev() -> torch.Tensor +``` + +Returns the previous alpha bar values. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMinterpolate"></a> + +#### interpolate + +```python +def interpolate(data: Tensor, t: Tensor, noise: Tensor) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor_ - noise from prior() + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMforward_process"></a> + +#### forward\_process + +```python +def forward_process(data: Tensor, t: Tensor, noise: Optional[Tensor] = None) +``` + +Get x(t) with given time t from noise and data. + +**Arguments**: + +- `data` _Tensor_ - target +- `t` _Tensor_ - time +- `noise` _Tensor, optional_ - noise from prior(). Defaults to None. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMprocess_data_prediction"></a> + +#### process\_data\_prediction + +```python +def process_data_prediction(model_output: Tensor, sample: Tensor, t: Tensor) +``` + +Converts the model output to a data prediction based on the prediction type. + +This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. +Given the model output and the sample, we convert the output to a data prediction based on the prediction type. +The conversion formulas are as follows: +- For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` +- For "data" prediction type: `pred_data = model_output` +- For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + +**Arguments**: + +- `model_output` _Tensor_ - The output of the model. +- `sample` _Tensor_ - The input sample. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The data prediction based on the prediction type. + + +**Raises**: + +- `ValueError` - If the prediction type is not one of "noise", "data", or "v_prediction". + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMprocess_noise_prediction"></a> + +#### process\_noise\_prediction + +```python +def process_noise_prediction(model_output, sample, t) +``` + +Do the same as process_data_prediction but take the model output and convert to nosie. + +**Arguments**: + +- `model_output` - The output of the model. +- `sample` - The input sample. +- `t` - The time step. + + +**Returns**: + + The input as noise if the prediction type is "noise". + + +**Raises**: + +- `ValueError` - If the prediction type is not "noise". + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMcalculate_velocity"></a> + +#### calculate\_velocity + +```python +def calculate_velocity(data: Tensor, t: Tensor, noise: Tensor) -> Tensor +``` + +Calculate the velocity term given the data, time step, and noise. + +**Arguments**: + +- `data` _Tensor_ - The input data. +- `t` _Tensor_ - The current time step. +- `noise` _Tensor_ - The noise term. + + +**Returns**: + +- `Tensor` - The calculated velocity term. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMstep"></a> + +#### step + +```python +@torch.no_grad() +def step(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) +``` + +Do one step integration. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current data point. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + +**Notes**: + + The temperature parameter controls the level of randomness in the sampling process. A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) result in less random and more deterministic samples. This can be useful for tasks that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMstep_noise"></a> + +#### step\_noise + +```python +def step_noise(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0) +``` + +Do one step integration. + +**Arguments**: + +- `model_out` _Tensor_ - The output of the model. +- `t` _Tensor_ - The current time step. +- `xt` _Tensor_ - The current data point. +- `mask` _Optional[Tensor], optional_ - An optional mask to apply to the data. Defaults to None. +- `center` _bool, optional_ - Whether to center the data. Defaults to False. +- `temperature` _Float, optional_ - The temperature parameter for low temperature sampling. Defaults to 1.0. + + +**Notes**: + + The temperature parameter controls the level of randomness in the sampling process. + A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) + result in less random and more deterministic samples. This can be useful for tasks + that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMscore"></a> + +#### score + +```python +def score(x_hat: Tensor, xt: Tensor, t: Tensor) +``` + +Converts the data prediction to the estimated score function. + +**Arguments**: + +- `x_hat` _Tensor_ - The predicted data point. +- `xt` _Tensor_ - The current data point. +- `t` _Tensor_ - The time step. + + +**Returns**: + + The estimated score function. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMstep_ddim"></a> + +#### step\_ddim + +```python +def step_ddim(model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False) +``` + +Do one step of DDIM sampling. + +**Arguments**: + +- `model_out` _Tensor_ - output of the model +- `t` _Tensor_ - current time step +- `xt` _Tensor_ - current data point +- `mask` _Optional[Tensor], optional_ - mask for the data point. Defaults to None. +- `eta` _Float, optional_ - DDIM sampling parameter. Defaults to 0.0. +- `center` _Bool, optional_ - whether to center the data point. Defaults to False. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMset_loss_weight_fn"></a> + +#### set\_loss\_weight\_fn + +```python +def set_loss_weight_fn(fn) +``` + +Sets the loss_weight attribute of the instance to the given function. + +**Arguments**: + +- `fn` - The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMloss_weight"></a> + +#### loss\_weight + +```python +def loss_weight(raw_loss: Tensor, t: Optional[Tensor], + weight_type: str) -> Tensor +``` + +Calculates the weight for the loss based on the given weight type. + +These data_to_noise loss weights is derived in Equation (9) of https://arxiv.org/pdf/2202.00512. + +**Arguments**: + +- `raw_loss` _Tensor_ - The raw loss calculated from the model prediction and target. +- `t` _Tensor_ - The time step. +- `weight_type` _str_ - The type of weight to use. Can be "ones" or "data_to_noise" or "noise_to_data". + + +**Returns**: + +- `Tensor` - The weight for the loss. + + +**Raises**: + +- `ValueError` - If the weight type is not recognized. + +<a id="mocointerpolantsdiscrete_timecontinuousddpmDDPMloss"></a> + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + weight_type: Literal["ones", "data_to_noise", + "noise_to_data"] = "ones") +``` + +Calculate the loss given the model prediction, data sample, and time. + +The default weight_type is "ones" meaning no change / multiplying by all ones. +data_to_noise is available to scale the data MSE loss into the appropriate loss that is theoretically equivalent +to noise prediction. noise_to_data is provided for a similar reason for completeness. + +**Arguments**: + +- `model_pred` _Tensor_ - The predicted output from the model. +- `target` _Tensor_ - The target output for the model prediction. +- `t` _Tensor_ - The time at which the loss is calculated. +- `mask` _Optional[Tensor], optional_ - The mask for the data point. Defaults to None. +- `weight_type` _Literal["ones", "data_to_noise", "noise_to_data"]_ - The type of weight to use for the loss. Defaults to "ones". + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + +<a id="mocointerpolantsdiscrete_timecontinuous"></a> + +# bionemo.moco.interpolants.discrete\_time.continuous + +<a id="mocointerpolantsdiscrete_time"></a> + +# bionemo.moco.interpolants.discrete\_time + +<a id="mocointerpolantsdiscrete_timeutils"></a> + +# bionemo.moco.interpolants.discrete\_time.utils + +<a id="mocointerpolantsdiscrete_timeutilssafe_index"></a> + +#### safe\_index + +```python +def safe_index(tensor: Tensor, index: Tensor, device: torch.device) +``` + +Safely indexes a tensor using a given index and returns the result on a specified device. + +Note can implement forcing with return tensor[index.to(tensor.device)].to(device) but has costly migration. + +**Arguments**: + +- `tensor` _Tensor_ - The tensor to be indexed. +- `index` _Tensor_ - The index to use for indexing the tensor. +- `device` _torch.device_ - The device on which the result should be returned. + + +**Returns**: + +- `Tensor` - The indexed tensor on the specified device. + + +**Raises**: + +- `ValueError` - If tensor, index, and device are not all on the same device. + +<a id="mocointerpolantsbase_interpolant"></a> + +# bionemo.moco.interpolants.base\_interpolant + +<a id="mocointerpolantsbase_interpolantstring_to_enum"></a> + +#### string\_to\_enum + +```python +def string_to_enum(value: Union[str, AnyEnum], + enum_type: Type[AnyEnum]) -> AnyEnum +``` + +Converts a string to an enum value of the specified type. If the input is already an enum instance, it is returned as-is. + +**Arguments**: + +- `value` _Union[str, E]_ - The string to convert or an existing enum instance. +- `enum_type` _Type[E]_ - The enum type to convert to. + + +**Returns**: + +- `E` - The corresponding enum value. + + +**Raises**: + +- `ValueError` - If the string does not correspond to any enum member. + +<a id="mocointerpolantsbase_interpolantpad_like"></a> + +#### pad\_like + +```python +def pad_like(source: Tensor, target: Tensor) -> Tensor +``` + +Pads the dimensions of the source tensor to match the dimensions of the target tensor. + +**Arguments**: + +- `source` _Tensor_ - The tensor to be padded. +- `target` _Tensor_ - The tensor that the source tensor should match in dimensions. + + +**Returns**: + +- `Tensor` - The padded source tensor. + + +**Raises**: + +- `ValueError` - If the source tensor has more dimensions than the target tensor. + + +**Example**: + + >>> source = torch.tensor([1, 2, 3]) # shape: (3,) + >>> target = torch.tensor([[1, 2], [4, 5], [7, 8]]) # shape: (3, 2) + >>> padded_source = pad_like(source, target) # shape: (3, 1) + +<a id="mocointerpolantsbase_interpolantPredictionType"></a> + +## PredictionType Objects + +```python +class PredictionType(Enum) +``` + +An enumeration representing the type of prediction a Denoising Diffusion Probabilistic Model (DDPM) can be used for. + +DDPMs are versatile models that can be utilized for various prediction tasks, including: + +- **Data**: Predicting the original data distribution from a noisy input. +- **Noise**: Predicting the noise that was added to the original data to obtain the input. +- **Velocity**: Predicting the velocity or rate of change of the data, particularly useful for modeling temporal dynamics. + +These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + +<a id="mocointerpolantsbase_interpolantInterpolant"></a> + +## Interpolant Objects + +```python +class Interpolant(ABC) +``` + +An abstract base class representing an Interpolant. + +This class serves as a foundation for creating interpolants that can be used +in various applications, providing a basic structure and interface for +interpolation-related operations. + +<a id="mocointerpolantsbase_interpolantInterpolant__init__"></a> + +#### \_\_init\_\_ + +```python +def __init__(time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None) +``` + +Initializes the Interpolant class. + +**Arguments**: + +- `time_distribution` _TimeDistribution_ - The distribution of time steps. +- `prior_distribution` _PriorDistribution_ - The prior distribution of the variable. +- `device` _Union[str, torch.device], optional_ - The device on which to operate. Defaults to "cpu". +- `rng_generator` - An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + +<a id="mocointerpolantsbase_interpolantInterpolantinterpolate"></a> + +#### interpolate + +```python +@abstractmethod +def interpolate(*args, **kwargs) -> Tensor +``` + +Get x(t) with given time t from noise and data. + +Interpolate between x0 and x1 at the given time t. + +<a id="mocointerpolantsbase_interpolantInterpolantstep"></a> + +#### step + +```python +@abstractmethod +def step(*args, **kwargs) -> Tensor +``` + +Do one step integration. + +<a id="mocointerpolantsbase_interpolantInterpolantgeneral_step"></a> + +#### general\_step + +```python +def general_step(method_name: str, kwargs: dict) +``` + +Calls a step method of the class by its name, passing the provided keyword arguments. + +**Arguments**: + +- `method_name` _str_ - The name of the step method to call. +- `kwargs` _dict_ - Keyword arguments to pass to the step method. + + +**Returns**: + + The result of the step method call. + + +**Raises**: + +- `ValueError` - If the provided method name does not start with 'step'. +- `Exception` - If the step method call fails. The error message includes a list of available step methods. + + +**Notes**: + + This method allows for dynamic invocation of step methods, providing flexibility in the class's usage. + +<a id="mocointerpolantsbase_interpolantInterpolantsample_prior"></a> + +#### sample\_prior + +```python +def sample_prior(*args, **kwargs) -> Tensor +``` + +Sample from prior distribution. + +This method generates a sample from the prior distribution specified by the +`prior_distribution` attribute. + +**Returns**: + +- `Tensor` - The generated sample from the prior distribution. + +<a id="mocointerpolantsbase_interpolantInterpolantsample_time"></a> + +#### sample\_time + +```python +def sample_time(*args, **kwargs) -> Tensor +``` + +Sample from time distribution. + +<a id="mocointerpolantsbase_interpolantInterpolantto_device"></a> + +#### to\_device + +```python +def to_device(device: str) +``` + +Moves all internal tensors to the specified device and updates the `self.device` attribute. + +**Arguments**: + +- `device` _str_ - The device to move the tensors to (e.g. "cpu", "cuda:0"). + + +**Notes**: + + This method is used to transfer the internal state of the DDPM interpolant to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + +<a id="mocointerpolantsbase_interpolantInterpolantclean_mask_center"></a> + +#### clean\_mask\_center + +```python +def clean_mask_center(data: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False) -> Tensor +``` + +Returns a clean tensor that has been masked and/or centered based on the function arguments. + +**Arguments**: + +- `data` - The input data with shape (..., nodes, features). +- `mask` - An optional mask to apply to the data with shape (..., nodes). If provided, it is used to calculate the CoM. Defaults to None. +- `center` - A boolean indicating whether to center the data around the calculated CoM. Defaults to False. + + +**Returns**: + + The data with shape (..., nodes, features) either centered around the CoM if `center` is True or unchanged if `center` is False. diff --git a/sub-packages/bionemo-moco/environment/Instructions.md b/sub-packages/bionemo-moco/environment/Instructions.md new file mode 100644 index 0000000000..f565c2f23a --- /dev/null +++ b/sub-packages/bionemo-moco/environment/Instructions.md @@ -0,0 +1,8 @@ +Environment Setup +=============== + +from the bionemo-moco directory run + + bash environment/setup.sh + + This creates the conda environment, installs bionemo-moco and runs the tests. diff --git a/sub-packages/bionemo-moco/environment/moco_env.yaml b/sub-packages/bionemo-moco/environment/moco_env.yaml new file mode 100644 index 0000000000..0daadf6978 --- /dev/null +++ b/sub-packages/bionemo-moco/environment/moco_env.yaml @@ -0,0 +1,41 @@ +name: moco_bionemo +channels: + - conda-forge + - pytorch + - nvidia + +dependencies: + - python=3.10 + - pytorch=2.2.1 + - pytorch-cuda=12.1 + - torchvision=0.17.1 + - torchaudio=2.2.1 + + - pip: + - ruff==0.0.292 + - black==23.1.0 + - pre-commit==3.4.0 + - virtualenv==20.26.3 + - ipdb==0.13.11 + - click==8.1.7 + - tenacity==8.5.0 + - tach>=0.9.0 + - pytest-cov==4.1.0 + - pytest-timeout==2.2.0 + - pytest-dependency==0.5.1 + - testbook==0.4.2 + - requests_mock==1.11.0 + - awscli==1.33.33 + - nbval==0.11.0 + - onnx>=1.16.0 + - setuptools>=70.0.0 + - aiohttp>=3.9.4 + - jupyterlab>=3.6.8 + - jupyter_server>=2.14.1 # Fix for GHSA-hrw6-wg82-cm62 + - Werkzeug>=3.0.3 + - nltk>=3.9.1 + - numpy>=1.24.4,<2 + - jaxtyping==0.2.34 + - pot>=0.9.5 + - scikit-learn>=1.6.0 + - matplotlib>=3.3.2 diff --git a/sub-packages/bionemo-moco/environment/setup.sh b/sub-packages/bionemo-moco/environment/setup.sh new file mode 100644 index 0000000000..fc11ce8f51 --- /dev/null +++ b/sub-packages/bionemo-moco/environment/setup.sh @@ -0,0 +1,39 @@ +#!/bin/bash + +# Set the path to your Conda environment YAML file +ENV_YAML="environment/moco_env.yaml" + +# Extract the environment name from the YAML file +ENV_NAME=$(head -n 1 "$ENV_YAML" | cut -d':' -f2- | tr -d ' ') + +# Load Conda to enable command +source "$(conda info --base)/etc/profile.d/conda.sh" + +# Create the Conda environment from the YAML file +echo "Creating Conda environment $ENV_NAME from $ENV_YAML..." +conda env create -f "$ENV_YAML" + +# Activate the Conda environment +echo "Activating Conda environment $ENV_NAME..." +conda activate "$ENV_NAME" + +# Check if the environment was successfully activated +if [ "$CONDA_DEFAULT_ENV" == "$ENV_NAME" ]; then + echo "Conda environment $ENV_NAME activated successfully." + # Navigate to your project directory if needed + # cd /path/to/your/project # Uncomment and adjust this path as necessary + # Install your project in editable mode using pip + pip install pydoc-markdown>=4.8.2 + pip install pytest-cov==4.1.0 pytest-timeout==2.2.0 pytest-dependency==0.5.1 + pre-commit install + echo "Installing bionemo-moco in editable mode using pip..." + pip install -e . + echo "Setup complete." + # Run tests + echo "Running tests..." + pytest + echo "Tests complete. You can now work within the $ENV_NAME environment." +else + echo "Failed to activate Conda environment $ENV_NAME. Exiting..." + exit 1 +fi diff --git a/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb b/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb new file mode 100644 index 0000000000..f8cb5c1649 --- /dev/null +++ b/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb @@ -0,0 +1,1803 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![ Click here to deploy.](https://uohmivykqgnnbiouffke.supabase.co/storage/v1/object/public/landingpage/brevdeploynavy.svg)](https://console.brev.dev/launchable/deploy/now?launchableID=env-2rgiXa7D63Aq0bmKElJq2HpAY2x)\n", + "\n", + "NOTE: it takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits.\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Generative Models for Continuous Data via Continuous Interpolants" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import os\n", + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "\n", + "from sklearn.datasets import make_moons" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task Setup\n", + "\n", + "To demonstrate how Conditional Flow Matching works we use sklearn to sample from and create custom 2D distriubtions.\n", + "\n", + "To start we define our \"dataloader\" so to speak. This is the '''sample_moons''' function.\n", + "\n", + "Next we define a custom PriorDistribution to enable the conversion of 8 equidistance gaussians to the moon distribution above.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def sample_moons(n, normalize = False):\n", + " x1, _ = make_moons(n_samples=n, noise=0.08)\n", + " x1 = torch.Tensor(x1)\n", + " x1 = x1 * 3 - 1\n", + " if normalize:\n", + " x1 = (x1 - x1.mean(0))/x1.std(0) * 2\n", + " return x1" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.collections.PathCollection at 0x7c29ddf7ca90>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x1 = sample_moons(1000)\n", + "plt.scatter(x1[:, 0], x1[:, 1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model Creation\n", + "Here we define a simple 4 layer MLP and define our optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "dim = 2\n", + "hidden_size = 64\n", + "batch_size = 256\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(dim + 1, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, dim),\n", + " )\n", + "optimizer = torch.optim.Adam(model.parameters())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Continuous Flow Matching Interpolant\n", + "Here we import our desired interpolant objects.\n", + "\n", + "The continuous flow matcher and the desired time distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.interpolants import ContinuousFlowMatcher\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.distributions.prior import GaussianPrior\n", + "\n", + "uniform_time = UniformTimeDistribution()\n", + "simple_prior = GaussianPrior()\n", + "sigma = 0.1\n", + "cfm = ContinuousFlowMatcher(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior, \n", + " sigma=sigma, \n", + " prediction_type=\"velocity\")\n", + "# Place both the model and the interpolant on the same device\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "cfm = cfm.to_device(DEVICE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training Loop" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000: loss 3.094\n", + "10000: loss 2.881\n", + "15000: loss 3.287\n", + "20000: loss 2.997\n" + ] + } + ], + "source": [ + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = cfm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = cfm.sample_time(batch_size)\n", + " xt = cfm.interpolate(x1, t, x0)\n", + " ut = cfm.calculate_target(x1, x0)\n", + "\n", + " vt = model(torch.cat([xt, t[:, None]], dim=-1))\n", + " loss = cfm.loss(vt, ut, target_type=\"velocity\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 5000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setting Up Generation\n", + "Now we need to import the desired inference time schedule. This is what gives us the time values to iterate through to iteratively generate from our model.\n", + "\n", + "Here we show the output time schedule as well as the discretization between time points. We note that different inference time schedules may have different shapes resulting in non uniform dt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n", + " 0.0900, 0.1000, 0.1100, 0.1200, 0.1300, 0.1400, 0.1500, 0.1600, 0.1700,\n", + " 0.1800, 0.1900, 0.2000, 0.2100, 0.2200, 0.2300, 0.2400, 0.2500, 0.2600,\n", + " 0.2700, 0.2800, 0.2900, 0.3000, 0.3100, 0.3200, 0.3300, 0.3400, 0.3500,\n", + " 0.3600, 0.3700, 0.3800, 0.3900, 0.4000, 0.4100, 0.4200, 0.4300, 0.4400,\n", + " 0.4500, 0.4600, 0.4700, 0.4800, 0.4900, 0.5000, 0.5100, 0.5200, 0.5300,\n", + " 0.5400, 0.5500, 0.5600, 0.5700, 0.5800, 0.5900, 0.6000, 0.6100, 0.6200,\n", + " 0.6300, 0.6400, 0.6500, 0.6600, 0.6700, 0.6800, 0.6900, 0.7000, 0.7100,\n", + " 0.7200, 0.7300, 0.7400, 0.7500, 0.7600, 0.7700, 0.7800, 0.7900, 0.8000,\n", + " 0.8100, 0.8200, 0.8300, 0.8400, 0.8500, 0.8600, 0.8700, 0.8800, 0.8900,\n", + " 0.9000, 0.9100, 0.9200, 0.9300, 0.9400, 0.9500, 0.9600, 0.9700, 0.9800,\n", + " 0.9900], device='cuda:0'),\n", + " tensor([0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100,\n", + " 0.0100], device='cuda:0'))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "\n", + "inference_sched = LinearInferenceSchedule(nsteps = 100)\n", + "schedule = inference_sched.generate_schedule().to(DEVICE)\n", + "dts = inference_sched.discretize().to(DEVICE)\n", + "schedule, dts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sample from the trained model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = cfm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for dt, t in zip(dts, schedule):\n", + " full_t = inference_sched.pad_time(inf_size, t, DEVICE)\n", + " vt = model(torch.cat([sample, full_t[:, None]], dim=-1)) # calculate the vector field based on the definition of the model\n", + " sample = cfm.step(vt, sample, dt, full_t)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sample from underlying score model\n", + "\n", + "## low temperature sampling is a heuristic, unclear what effects it has on the final distribution. Intuitively, it cuts tails and focuses more on the mode, in practice who knows exactly what's the final effect.\n", + "\n", + "## gt_mode is a hyperparameter that must be experimentally chosen" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = cfm.sample_prior((inf_size, 2)).to(DEVICE)\n", + "trajectory_stoch = [sample]\n", + "vts = []\n", + "for dt, t in zip(dts, schedule):\n", + " time = inference_sched.pad_time(inf_size, t, DEVICE) #torch.full((inf_size,), t).to(DEVICE)\n", + " vt = model(torch.cat([sample, time[:, None]], dim=-1))\n", + " sample = cfm.step_score_stochastic(vt, sample, dt, time, noise_temperature=1.0, gt_mode = \"tan\")\n", + " trajectory_stoch.append(sample)\n", + " vts.append(vt)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "traj = torch.stack(trajectory_stoch).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(0)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(1)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.title(\"Stochastic score sampling Temperature = 1.0\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What happens if you just sample from a random model?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "fmodel = torch.nn.Sequential(\n", + " torch.nn.Linear(dim + 1, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, dim),\n", + " ).to(DEVICE)\n", + "inf_size = 1024\n", + "sample = cfm.sample_prior((inf_size, 2)).to(DEVICE)\n", + "trajectory2 = [sample]\n", + "for dt, t in zip(dts, schedule):\n", + " time = inference_sched.pad_time(inf_size, t, DEVICE) #torch.full((inf_size,), t).to(DEVICE)\n", + " vt = fmodel(torch.cat([sample, time[:, None]], dim=-1))\n", + " sample = cfm.step(vt, sample, dt, time)\n", + " trajectory2.append(sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_limit = 1024\n", + "traj = torch.stack(trajectory2).cpu().detach().numpy()\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(0)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(1)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's try a different Interpolant type\n", + "\n", + "## Let's create an architecture that has a formal time embedding as here we use more timesteps" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "from typing import List\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "class Network(nn.Module):\n", + " def __init__(\n", + " self, dim_in: int, dim_out: int, dim_hids: List[int],\n", + " ):\n", + " super().__init__()\n", + " self.layers = nn.ModuleList([\n", + " TimeLinear(dim_in, dim_hids[0]),\n", + " *[TimeLinear(dim_hids[i-1], dim_hids[i]) for i in range(1, len(dim_hids))],\n", + " TimeLinear(dim_hids[-1], dim_out)\n", + " ])\n", + "\n", + " def forward(self, x: torch.Tensor, t: torch.Tensor):\n", + " for i, layer in enumerate(self.layers):\n", + " x = layer(x, t)\n", + " if i < len(self.layers) - 1:\n", + " x = F.relu(x)\n", + " return x\n", + " \n", + "class TimeLinear(nn.Module):\n", + " def __init__(self, dim_in: int, dim_out: int):\n", + " super().__init__()\n", + " self.dim_in = dim_in\n", + " self.dim_out = dim_out\n", + "\n", + " self.time_embedding = TimeEmbedding(dim_out)\n", + " self.fc = nn.Linear(dim_in, dim_out)\n", + "\n", + " def forward(self, x: torch.Tensor, t: torch.Tensor):\n", + " x = self.fc(x)\n", + " alpha = self.time_embedding(t).view(-1, self.dim_out)\n", + " return alpha * x\n", + " \n", + "class TimeEmbedding(nn.Module):\n", + " # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py\n", + " def __init__(self, hidden_size, frequency_embedding_size=256):\n", + " super().__init__()\n", + " self.mlp = nn.Sequential(\n", + " nn.Linear(frequency_embedding_size, hidden_size, bias=True),\n", + " nn.SiLU(),\n", + " nn.Linear(hidden_size, hidden_size, bias=True),\n", + " )\n", + " self.frequency_embedding_size = frequency_embedding_size\n", + "\n", + " @staticmethod\n", + " def timestep_embedding(t, dim, max_period=10000):\n", + " \"\"\"\n", + " Create sinusoidal timestep embeddings.\n", + " :param t: a 1-D Tensor of N indices, one per batch element.\n", + " These may be fractional.\n", + " :param dim: the dimension of the output.\n", + " :param max_period: controls the minimum frequency of the embeddings.\n", + " :return: an (N, D) Tensor of positional embeddings.\n", + " \"\"\"\n", + " # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py\n", + " half = dim // 2\n", + " freqs = torch.exp(\n", + " -math.log(max_period)\n", + " * torch.arange(start=0, end=half, dtype=torch.float32)\n", + " / half\n", + " ).to(device=t.device)\n", + " args = t[:, None].float() * freqs[None]\n", + " embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\n", + " if dim % 2:\n", + " embedding = torch.cat(\n", + " [embedding, torch.zeros_like(embedding[:, :1])], dim=-1\n", + " )\n", + " return embedding\n", + "\n", + " def forward(self, t: torch.Tensor):\n", + " if t.ndim == 0:\n", + " t = t.unsqueeze(-1)\n", + " t_freq = self.timestep_embedding(t, self.frequency_embedding_size)\n", + " t_emb = self.mlp(t_freq)\n", + " return t_emb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DDPM Interpolant\n", + "### note DDPM must be used with a Gaussian Prior." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.interpolants import DDPM\n", + "from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule, DiscreteLinearNoiseSchedule\n", + "from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule\n", + "from bionemo.moco.distributions.prior import GaussianPrior\n", + "DEVICE = \"cuda:0\"\n", + "uniform_time = UniformTimeDistribution(discrete_time=True, nsteps = 1000)\n", + "simple_prior = GaussianPrior()\n", + "ddpm = DDPM(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior,\n", + " prediction_type = \"noise\",\n", + " noise_schedule = DiscreteLinearNoiseSchedule(nsteps = 1000),\n", + " device=DEVICE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 0.342\n", + "2000: loss 0.334\n", + "3000: loss 0.291\n", + "4000: loss 0.308\n", + "5000: loss 0.285\n", + "6000: loss 0.282\n", + "7000: loss 0.353\n", + "8000: loss 0.359\n", + "9000: loss 0.342\n", + "10000: loss 0.373\n", + "11000: loss 0.327\n", + "12000: loss 0.364\n", + "13000: loss 0.297\n", + "14000: loss 0.345\n", + "15000: loss 0.315\n", + "16000: loss 0.358\n", + "17000: loss 0.290\n", + "18000: loss 0.253\n", + "19000: loss 0.295\n", + "20000: loss 0.373\n" + ] + } + ], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "ddpm = ddpm.to_device(DEVICE)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = ddpm.sample_time(batch_size)\n", + " xt = ddpm.interpolate(x1, t, x0)\n", + "\n", + " eps = model(xt, t)\n", + " loss = ddpm.loss(eps, x0, t).mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Let's vizualize what the interpolation looks like during training for different times" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGzCAYAAAASZnxRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUVJJREFUeJzt3X10FdW5P/DvSSQBYhIJLybIi4BapAiIEqDQFigowi3Y/tSC9VZsi60Fry+9XsDWIguvlOpa6gVFpVZbFWhr9aJFWRcLavGCWl7UGLHCBUFIlNckBgiYc35/4MST5MyZvWf2ntkz8/2sxVLCOWcm58yZ/ey9n/3sRCqVSoGIiIgoADlBnwARERHFFwMRIiIiCgwDESIiIgoMAxEiIiIKDAMRIiIiCgwDESIiIgoMAxEiIiIKDAMRIiIiCgwDESIiIgoMAxGimJg2bRrOPvvsoE+DiKgZBiJEIZZIJIT+vPLKK0GfqnZLlizBlVdeiR49eiCRSGDatGm2jz1y5Aiuv/56dO7cGQUFBRg9ejQ2b96c8bHPP/88Bg8ejLZt26JHjx6YO3cuPv/8c02/BVH8nBb0CRCRe08++WSzv//hD3/AmjVrWv38/PPPx9KlS5FMJv08PV8tXLgQdXV1KC8vR1VVle3jkskkJk6ciLfffhu33XYbOnXqhIceegijRo3Cpk2bcO655zY99qWXXsLll1+OUaNGYdGiRXj33Xdx11134dNPP8WSJUv8+LWIIi/BTe+IomPmzJl48MEHEcev9UcffdQ0GnL66afjiiuuwBNPPNHqcX/605/wve99D3/+859xxRVXAAD279+P8847D5dddhmWLVvW9NivfvWraNOmDf7xj3/gtNNO9dt++ctf4u6770ZlZSX69u3ry+9GFGWcmiGKiZY5Irt27UIikcC9996LBx98EL1790b79u1xySWXYM+ePUilUpg/fz66deuGdu3aYfLkyTh06FCr133ppZfw9a9/HQUFBSgsLMTEiRPx3nvv+fibndKzZ08kEgnHxz3zzDM488wz8d3vfrfpZ507d8ZVV12FlStXoqGhAQBQWVmJyspKXH/99U1BCAD87Gc/QyqVwjPPPKP+lyCKIU7NEMXc008/jRMnTuDGG2/EoUOH8Jvf/AZXXXUVxowZg1deeQWzZs3C9u3bsWjRIvz7v/87fve73zU998knn8S1116LSy+9FAsXLsTRo0exZMkSjBw5Elu2bMmaHJtMJjMGNpkUFxejTZs2Xn9VAMCWLVswePBg5OQ074eVl5fj0UcfxT//+U9ccMEF2LJlCwDg4osvbva4rl27olu3bk3/TkTeMBAhirm9e/fiww8/RHFxMQCgsbERCxYswLFjx5pNSezfvx9PP/00lixZgvz8fHz22Wf4t3/7N/z4xz/Go48+2vR61157Lb7yla/g7rvvbvbzlnbv3o1evXoJneO6deswatQo979kmqqqKnzjG99o9fOysjIAwL59+3DBBRc05ZlYP2/52H379ik5H6K4YyBCFHNXXnllUxACAEOHDgUAXHPNNc2mJIYOHYrly5dj79696N27N9asWYMjR45g6tSpOHDgQNPjcnNzMXToUKxbty7rcUtLS7FmzRqhcxw4cKDMr5TVsWPHkJ+f3+rnbdu2bfr39P/aPba2tlbZORHFGQMRopjr0aNHs79bQUn37t0z/vzw4cMAgA8//BAAMGbMmIyvW1RUlPW4bdu2xdixY+VP2KN27do15YGkO378eNO/p//X7rHWvxORNwxEiGIuNzdX6ufWihxrKfCTTz6J0tLSVo9LH03JpLGxEfv37xc6x5KSEuTl5Qk91klZWVnG5b3Wz7p27dr0OOvnLYOyqqoqlJeXKzkforhjIEJErvTp0wcA0KVLF1cjG3v27AkkR2TQoEH4+9//jmQy2Sxh9Y033kD79u1x3nnnNT0OAP7xj380Czr27duHjz/+GNdff72S8yGKOwYiROTKpZdeiqKiItx9990YPXp0q1Ut+/fvR+fOnW2fH1SOyBVXXIFnnnkGzz77bFMdkQMHDuDPf/4zvv3tbzflhHz1q19F37598eijj+InP/lJ0wjRkiVLkEgkmp5LRN4wECEiV4qKirBkyRL867/+KwYPHowpU6agc+fO2L17N1atWoURI0Zg8eLFts9XnSPywgsv4O233wYAnDx5Eu+88w7uuusuAMCkSZMwYMAAAKcCkWHDhuG6665DZWVlU2XVxsZGzJs3r9lr3nPPPZg0aRIuueQSTJkyBRUVFVi8eDF+/OMf4/zzz1d27kRxxkCEiFy7+uqr0bVrV/z617/GPffcg4aGBpx11ln4+te/juuuu87Xc/nLX/6C3//+901/37JlS1Otj27dujUFIrm5uXjxxRdx22234b/+679w7NgxDBkyBE888QS+8pWvNHvNf/mXf8Gzzz6LefPm4cYbb0Tnzp1x++2341e/+pV/vxhRxLHEOxEREQWGJd6JiIgoMAxEiIiIKDAMRIiIiCgwDESIiIgoMAxEiIiIKDAMRIiIiCgwRtcRSSaT2LdvHwoLC5FIJII+HSIiIhKQSqVQV1eHrl27NttKIROjA5F9+/a12myKiIiIwmHPnj3o1q1b1scYHYgUFhYCOPWLOG0pTkRERGaora1F9+7dm9rxbIwORKzpmKKiIgYiREREISOSVsFkVSIiIgoMAxEiIiIKDAMRIiIiCgwDESIiIgoMAxEiIiIKDAMRIiIiCgwDESIiIgoMAxEiIiIKjNEFzYgoeI3JFN7ceQif1h1Hl8K2KO9Vgtwc7v1ERGowECEiW6srqjDvhUpU1Rxv+llZcVvM/XY/jO9fFuCZEVFUcGqGiDJaXVGFG57a3CwIAYDqmuO44anNWF1RFdCZEVGUMBAholYakynMe6ESqQz/Zv1s3guVaExmegQRkTgGIkTUyps7D7UaCUmXAlBVcxxv7jzk30kRUSQxECGiVj6tsw9C3DyOiMgOAxEiaqVLYVuljyMissNVM0SC4rSMtbxXCcqK26K65njGPJEEgNLiU+8BEZEXDESIBMRtGWtuTgJzv90PNzy1GQmgWTBihV5zv90vsoEYEfmHUzNEDuK6jHV8/zIsuWYwSoubT7+UFrfFkmsGRzIAIyL/cUSEKAunZawJnFrGOq5faSRHB8b3L8O4fqWxmZIiIv8xECHKQmYZ6/A+HZUf34S8lNychJbfjYgIYCBC1CRTox/kMta45aUQUTwxECGCfaM/ZUgPoeerXsZq5aW0nBKy8lKYoyHHhJElIsqMgQjFXrZG//6X/4kz2rdBzdGTvi1jjXteimocWSIyG1fNUKyJ7KliLV9t2eTrWsbK8urqxHXFE1GYMBChWBNp9A8fPYlbxp7r2zJWlldXgxv3EYUDp2Yo1kQb87M7FWD9rDG2eQYqcxBYXl2NoFc8EZEYBiIUazKNvt0yVtU5CCyvrgZHlojCgVMzFGtWo283dpHAqaDCrtHXkYNglVe3jt/yfACWVxfBkSWicGAgQrGWrdEHTg3f3zExc6OvMweB5dW98xpkEpE/ODVDsWc1+i2nVyzzV1UiJwetGn/dOQgsr+4NN+4jCgeOiBDhVKN/x8TzM/6b3TSLHzkIVl7K5EFnYXifjmw0JXFkich8HBEhwqlplvmr3s/4b3ZFxILMQWClUHEcWSIyGwMRIribZjlc3+D4ujpyEFgpVD4Q48Z9ROZiIEIE+WmWbCMo6ewSXd3iHjQMxIiihjkiRJCfZnEaQbF0KMjzdF7pWCmUJduJooiBCBHkl3oGUSwr7nvQMBAjiiYGIkSQLyIWRKJq3CuFxj0QI4oqBiJEX5BZ6hlEsaxOBflKHxc2cQ/EiKKKyapEaUSXegZSLEv0pSK6KpUl24miSeuIyIIFCzBkyBAUFhaiS5cuuPzyy/HBBx/oPCRRRo3JFDbsOIiVW/diw46DWfMIRIuI+V0s68BnzsuFZR4XNizZThRNWkdEXn31VcyYMQNDhgzB559/jttvvx2XXHIJKisrUVBQoPPQRE10Lvf0s1hW3EcEWLKdKJoSqVTKtxTz/fv3o0uXLnj11VfxjW98w/HxtbW1KC4uRk1NDYqKinw4Q4oau7obVlMVprobjckURi5ci+qa4xlXjgBAx4I8bJjzLeSdlhNI9VU/jsk6IkTmk2m/fc0RqampAQCUlGQeOm1oaEBDw5fDyrW1tb6cF4kLU2lxkeWetz/3Lo6dTKK0yOzfBcg+ImA5WH8C37xnHSYNLMPzb1f52lh7CRBkriuWbCeKFt9GRJLJJCZNmoQjR45g/fr1GR9z5513Yt68ea1+zhERPWSDirD1RDfsOIipSzcKP76kIA+XD+qKcf1KjW7YMn0OInSOAnkZeQrbdUVEzmRGRHwLRG644Qa89NJLWL9+Pbp165bxMZlGRLp3785ARAPZm7/pUxyZgqq/vrMPN63Y6ur1TG8IT3yexLAFL+NQ/Ump5yVwKpl2/awxygIta8rILjDKdkzTrysickcmEPGljsjMmTPx17/+FevWrbMNQgAgPz8fRUVFzf6QerJlsk2vaLm6ogojF67F1KUbcdOKrZi6dCNGLlyLXQeOun7NKsNLhm/66LB0EALoKfrlttCY6dcVEflDayCSSqUwc+ZMPPfcc1i7di169eql83AkwM3N30tFS5lls25kC6ruf/mfOKN9G09lNUxtCL0W7VJZ9MttoTFWSiUiQHOy6owZM7Bs2TKsXLkShYWFqK6uBgAUFxejXbt2Og9NNtxsd++2odE99+8UVCW++JNK+6+MTO+FSl4Sf70u0VW5xNftsmITKqWGKfmaKKq0BiJLliwBAIwaNarZzx9//HFMmzZN56HJhpubv5uGJtt29T99ajN+OOJsz0mhIkHV4aMnccvYc7HirT3SyZ0WHQ2hmyAtvdHsdHo+Sovy8Ultg1SAZeVrqCz6ZRUas1tWbHdM0etKV8l6JskSmUFrIOJjiRIS5CaokG1oRKZ/fvf6Lvzu9V2ebvyiAcLZnQqwftYYvLnzEKprjmH+qvdxuP6EcAOuukBYtiDthqc2Z0zQzNRontG+jdRoT8uiX6pGA2QLjVnHra49jpKCNo65Lj//89u4c5La4MDNZ0BEenDTu5hxUyZbdmdap5GKdHYJsiJkgiqrbPt3BnfD3d/p3+zc7egoGe4mR8cuD6bm6KkGvLh9m2Y/Lytui598oxfKspSet0vwdZucK1ruPv24t/xxq1DC7Se1ahOHmSRLZBZuehczbstkWw1Ny155aYYRDZmpDKtHP++FSozrVyrVI3c7JWD3u7R8LqC+ZLhsjo5IHky7Nrl48EeDcaC+odnIxn+MPz/jiIeu0QCnQmN2x3Xi5RrJxE2eFBHpw0AkhmSCipbPE6loKTuV4fbG72XvkfTf5eXKajy3dW+z3rnTe+GWbI6OaKOZk5PA5EFnNfs3axQonUhg46XBz3RMp+OKUBkcmJAkS0RfYiASU27LZNs1NOkO17vb/dXNjd9tUAV8+bsM79MRt0/sZ9zGdY3JFF7ffkDo8aLvnY7RAJFcE5npumxUBAdx3zyQyDQMRGJMJKiQ1ZhMYf6q91091+2NX8XeIzrei0xEp5MO1zdkrVbakuh7p3o0QHTliarRBRXBgdspPSLSg8mqpJSbnq+KpFArkJg86CyU9yrBmzsPaSui5oVI4u+kgWWYsWyL0Pso+96pHA2QqdDrNYBQmTgsm3xNRHoxECGlZHu+qm/8qleD6JBthcmDVw/G829XCS/HTQG4rP+p0SCRgMvNqqlMZFeeiBy3wxerf/wIDkRX+RCRfr5teueGzKY5ZAbZHW9VFpByWpXx0NUXYsKArp6Po0qm3Io3dx4Sfv9yEkB67CH6XlrvE5A5wVekIRb9nJdPH9Y05SVyXADaioxler8BsLIqkQYy7TdzREgpkfn3koI8/HLi+Sgtbqfsxi+yKmPm8i1YjAQmDDCjt5spL0VmRKnlAIjo8lsvCb6y55n+ONHjes33yYRVVInMxUCElBJZUvuf3+mv/OYvkpuSTAE/W7YZD+eYO/TuJZdCZvmt1wRft7kmIsdVnTjMKqpEZmOOCCkXxPy7zEiCyVUznXIpnMjsWJue4Du8T0dXxeTc5Jp4Oa4sVlElMh9HREgLFUtqZXQ6XXxjNJOrZjqNKIk2l34U45oypDvue/nDVj83aeUJq6gSmY+BCGnjV22O1RVVuPP596SeY3LVzGy5FHaNf0s6i3FlyrdIp6sqrRusokpkPgYiFGpu9y8xvWqm3YgSAKx4a09gxbic3u9bxp6HmWPOCXwkxMIqqkTmY44IhZab/Ut07KirS6ZciiCLcTm93wkAK97arfy4Xqiqm0JE+jAQodCSreJqUu6CF0EV45LJtzAFq6gSmY9TM+Q7kU3SRMjO65uUu+CV38nAQHjzLVTUTSEifRiIkK9UFpYSndefOfocjDinU+SqZvqVDGwJc75FEIEbEYlhIEK+UV1YSnQX1VvGnccGR4Gw71rrd+BGRGKYI0K+0FFYivP/4hqTKWzYcdDTjsR8v4lIB46IkC90FZbi/L8zldNhfL+JSDUGIuQLnYmOnP+3p2OfFb7fRKQSAxHyhe5ER87/t+Y0HSa6QV4mfL+JSBXmiJAvWFjKf2Gs+0FE8cMRkQhTVa9DBafN3ADxREfR38uk3z8IotNcr2/fH9v3iIiCx0AkolQmKKoimuiYLYAQ/b1M/P39JjrNtXjdjqb/9/M9Uhkoxj3oJAqzRCqVkl/H55Pa2loUFxejpqYGRUVFQZ9OaNglKFq3ZZ1lwEW4DTQACP1eL75ThZ8t29zquKb8/n5pTKYwcuFa27ofmfj1HqkMFBl0EplHpv1mIBIxVuNjlxtgFZ1aP2uMcT1GpwCquH0bHDl6MuNzrd/rF5edj3/74xbYlckw+ffXwXpPAUgFIzrfI5WBsulBN1FcybTfTFaNGBUJiiqKX8lyWuGRAmyDEOsxVTXHMXOFfRCS/ri4JGjabZCXTcv3SOX1oLKwnY4ieUTkP+aIRIzXeh1BDXPL7qTrlWkbs+nUsu7Hh598hsXrtjs+79O648qvB5WF7XQVySMif3FEJGK81Ouwhrlb3tyt4lerK6pcn5dTr9rvwMDEjdl0sup+TB50Fkac00noObsO1Cu/HlQWtgvrbsBE1BxHRCLG7cZkOotfifSq/QwM4l6vRPQaWf7mbuXXg8rCdmHeDZiIvsQRkYhxuzGZ6DD3E6/vlMoVEB1lESl41qF9m6y/l6i4b8wmco1MGdID1bUNtq/hNtdGZWE7FskjigYGIhFkl6BY3L4Nbh57Hsb1K231HNHh6/mr3sdNK7Zi6tKNGLlwbdbheZlkQpHGccF3L8DDGX6v0uK2eOjqC7M2SgCQkwAeupqrKAD7a6S0uC2WXDMYZ3dqL/Q6stMeKnfw5W7ARNHA5bsR1phMYfHaD/H467tw5NiXK04yJRtu2HEQU5dulHp9pyWSoq+5fPqwpmRCkWmc9DoknQrygQRw4LMG7DpQj/te/rBV5VbLQ1dfiAkDukr9jmHltfqsm89OBuuIEEWbTPvNHJEIW1NZjftf/lBo51WnvIFMnHIF3CQTiuzsaiVerq6owr8/83azBuiML6Zv0pf6lhblY2p5D5z8ImE26lU3ZRpmu83r3OYaiVK5gy93AyYKNwYiESWbfJptL5hssi2RdJtMKLKzq10hq5ovApBbxp6Hszu1x64DR7H8zd247+UPmx4T5d6y3fuSKfjMRuXeQNmO4fQ5i47scDdgovBijkhEuUk+HdevVLr4lSXT6IeuZEKR3JMVb+1Gm5wE7n/5n6iuVb8c2USqC3w55ZHoDuRWV1Rh5MK1mLp0o3BekomCKBBIFCYcEYkomeRTizVSsH7WmKZe6IG6hmaPsZNp9ENXr1o0yPrlygoty5FNpaPAV1DTHqpGdoLG/BUiZxwRiSg3tROsm/yayuqm4lfTRvRqyrvIxGlUQ0evWjTIOlTvXBI+SqXedRX4Si+GNrxPR+1BSFRKt+ssEEgUJRwRiShVyadrKqsd93hxGtVQ3atWWaAqSlU3o1LgKwql23UWCCSKGo6IRFS2GgvZpN/krZtpNh3at8lYlyTT+ajqVYvknnQsyBN6LdMbZRlRKfAVhdLtKjafJIoLBiIR5mbnVcundceFNqI7fPSk7zdTkUJW8yf3j0SjLCMqBb6iMLIjGiS9VFHFBFaKPQYiETe+fxnWzxqD5dOH4YEpg3DHxPOFntelsK3RPVOn3JMJA8oi0ShbRFdeBL3SRYUojOyIBkl/2PBRaFcDEanCHJEQc1NjoTGZwm/X7xQqVCU60hFUz9Qp98RqlFuuWigN2aoF2ZUXYS/w5UcNE91kc7TCthqISCWWeA8pmcapZcByuL4BM5ZtAZD5Jm/dDBuTKYxcuNYxaFk/a4zRjYJowGYiu2WsTuX1o+DFd6rwy5UVOFR/oulnYVr6an12gFiBwLB8n4hEyLTfDERCSKZxsgtYJg0sw/NvVzkGMnY30zg0hEGzAkG7PJ2gGy6ZAE82GMx03ZYUtMFdk/s37RcUhgAz0+/hxO3+PUQmMWavmddeew333HMPNm3ahKqqKjz33HO4/PLLdR4y8mSWBa6prLYtCvXoazvx4NWD0aEgL+uNPCrTG2Fk8jJWmRE52aklu0D7cP1JzFi2BUu+uEb9LBTmNuhJnyZ7qaIKf9jwkeNzTF4NRKSD1kCkvr4eAwcOxA9/+EN897vf1Xmo2BBtnDbuOOgYsMxfVSnUm7Zuphv/7yA27DgIIIXhvTthGHttWpmaLCxT9VS2QqpIoD372XdRc/Skb1VXvVZHTc/REglETF4NRKSD1kDksssuw2WXXabzELEj2uhs+L8DSnvTayqrm92MF6/bEar5+jAycRmrzIgcvvh/maJeIoG2XYE9HYXCVJaav6hnB+QkgGwrdXMSpx5HFCdGLd9taGhAbW1tsz/UnHijI3YTFglsWKo6GCYuY5WZLnJT1Mvr6I7KQmGqS81v+uhw1iAEOBWkbProsNR5EqUL4yaLRi3fXbBgAebNmxf0aRjNaVmglcA4vE9HLF633fH1nAIbkR7wnc+/h8K2bXDgswZjkwbDyMRlrDqmi9Ifq2p0R8V0leocHVOn2ig6wrrJolEjInPmzEFNTU3Tnz179gR9Sr4RjWJFq2cO691RSW9a5GZcXduA7//2jVBv1W4q0wqUyUwXuZlachoFEqUioFEdOJg41UbREeaRa6NGRPLz85Gfnx/0afjOTcEqkZUsKnrTbnpnLM6klkkFykRH5KwAV+axgPMoUArAGe3bZExWtXtNt1QHDrLvHZGosG+yaNSISBy5jWJblm5fPn0Y1s8a06zhV9GbdtM7C9NW7WGhctNAr+chWjrf7d432a7bh68ZjF9/9wLp13RDdY5OVPYCIvOEfZNFrSMin332GbZv/zJPYefOndi6dStKSkrQo0cPnYcOBa9RbPqyQDtee9OyparTz9/0rdrJHZnaMm7r0Dhdt37UttGRo8O6PKRD2POPtFZWfeWVVzB69OhWP7/22mvxxBNPOD4/6pVVN+w4iKlLNzo+LuhKi7KlqtPNHH0Obhl3Hnt5EaSzsqrq43t5LR0JgGGoCkvhYWJbwhLvIbFy617ctGKr4+MemDIIkwedpf+EsnBTqtoShqztdH42EmyQvhTUe7G6ogp3Pv8eqmsbmn5WWpSPOyd9tema5edEJjNxXzBjSrxTdmHKom85VN6pIB8///Pb+KTWecomTMmrfi5/C+tSOx2Cei9WV1Thp1+M9qWrrm3AT5/ajIe/uGZFpkGJgmLiUn8ZTFYNkIkFq7JJT5gccW4n3Dkpc+JdS6kv/vziuQqc+Dyp+zRd83P5W5iX2qkW1HvRmExh9rPvZn3M7GffZcI1BUq0tINpS/1lcGomYHYlpIFTDbzpF5DslE1JQRvc/Z0LjPud/Nzp1vRddf0U5Hvx+ocH8P3H3nB83NM/GooR53ZSemwiEW5GCk2ZRpRpvzkiErDx/ctw/Td6oeV1kpMArv9GL+Ma7JasZcQzR/cRevyh+pNG9vj9XP4W9qV2KgX5Xmz4vwNKH0ekktuRQlOW+stgIBKw1RVVePS1na32oEilgEdf22lcg51Jbk4CI87pLPUc02qM+Ln8LexL7VTy+71IH+bee/iY4LPMv5FTtKje58h0TFYNkO5qeH4O0cnUGzGxxoificNhSlLWzc/3wu3KL1XXqClD5mQ+1fscmY6BSIB0Xmx+r0JIz9oWZVKP38/y2yz1/SW/3otsuVjZdGjfBsN6e7/Rc4UUyYjbqCmnZgKk62ILahWClbVdUpAn9HiTevx+lt9mqe8v+fFeZBt5dLLguxd4/hy4QopkxW3UlIFIgHRcbEHPLY7vX4aNc76FkoI2to8xbVmyxc/lb2Feaqea7vfCaeQxk7Iv9rXxemzV30fRpZwUbmEr7eAVp2YCpGNY2oS5xbzTcnD3dy7IWBbe9B6/nzvdmrSrbtB0vheiI4ozR/fBuWcWKj22yu8jp3fiI+wFymQxEAmQjovNlLnFMG/u5WcVTVbs/JKu90J0RHHEOZ2VH1/V99EuxyVMVYtJTpjvobIYiARM9cVm0twie/xkgiCTg1V8H3WvriNzxeUeykDEACovNtNWZLDHT0ELcphbxffRhOlWCk4c7qFMVjVEbk4C5b1K0KWwLT6tO3VTcZOIxhUZRK0FlRys4vtoynQrkS4cETGEbCJatuJIcZpbJBIV1DC31++jSdOtRDpw0zsD2CWiWbfHlj020aCFlRwpisJ6Xbs9b2tjQKfpnThskkjhIdN+MxBRxOtNRnT3UdmghShKTF7CqjNAsr73QOYcF37vyTQy7TenZhTwcnOUSUQr71XC7HmKLZOXsOoOkDjdSlHGQMQjrzdHmUQ0Zs9TXJm8hNWvACkuSzkpfrhqxgMV5ZtlEtGYPU9xJROE+8nvLRWspZyTB52F4X06MgihSGAg4oGKm6PMngLMnqe4MjUINzVAIgoTBiIeqLg5ytQZiNtGSEQWU4NwUwMkojBhIOKBqpujU7Glcf1KsWHHQfz1nX2YMqR705x4OhYroygzNQh3cw/gDrrm42fkLyareqCynLpdItqayupWy3vPaN8GAHDk6MmmnzF7nqLM1N1IZe8BJi8/plP4GfmPdUQ80rm+36lmyM1jz8PZndoze55iw8RGQvQewBpA5uNnpA4LmvlMx81RttAZUVyYWFnV6R5w4vMkhi34Gw7Vn8j4fH6fg8d7rlosaOYzHev7WTOEKDMTdyPNdg9YXVGF2597F4fqT9o+n9/n4PGeGxwGIoqovjkyG58oXDLdA+yG+u3w+xwc3nODw1UzhjJ1uSIRiclW7MzOrgP12s6HsuM9NzgMRAxl6nJFIhLjNNSfyX0vf4jVFVWazoiy4T03OAxEDCVT6IyIzONmCN/aM4d1K/zn9Z7L2iPuMUdEExWZ/dxxkyi83AzhMyEyWG7vuSYuKw8TLt/VQPVFaeJyRSLKzloOalfsLJsHpgzC5EFnaTkvciZzz2XtkcxYR0SzbBcpL0pi4EgW2VUzluXTh3FEJARYe8Qe64holG20Y1y/0qxbglvzv+P6lfp2UbJR9BeHaMNN9ffFGuqf/Zd3ceSYfR2RdKVF+UyIDAnWHlGDgYgEu95Ndc1x3PDUZtw89jyjLko2iv5yuj44GmY2Xd+X8f3LUNi2Db7/2zeEHn/88yTWVFa3OiY7FeZh7RE1uGpGULaaANbPHv/fnUKv5cdFaTWKLQMjq1HkEkG1RK4ProYwl+7vy7DeHbMuDU1Xc/Rkq2OurqjCyIVrMXXpRty0YiumLt2IkQvXNj2GKzaCIZqQfKCugZ9JFgxEBIkMwaXvhpuN7i3B2Sj6T2aIlszix/cl29JQp2M6BUkLXqzMGqSQPk61RyzzV73PzyQLBiKCREcxzmjXRrggjlMvxy02iv7jEG14qfq+OHUqrHyR0mLnXrR1zI07DmYNklIAHnltJ0c+AyITYPIzscdARJDoENx1I84G4FwQR+dQMBtF/+ksD81hd71UfF9EOxXj+5dh/awxmDn6HKFjbvi/A9LVWQGOfPpJNMDkZ2KPgYgg0fK/M8ecm/GiLC1u25SsqHsomHsm+E9XeWhdo2b0Ja/fF9lORW5OAiPO6SR4du6TUTny6R8rwLxj4vlZH8fPJDMGIoJkyv9aF+Xy6cPwwJRBWD59GNbPGtOUBa976oR7JvhPR0l+Jhz7w8v3xW2nQvSYKlbXceTTH7k5CXQqzBd6LD+T5hiISLAbgksf7bBYW4JPHnQWhvfp2KwBUj110nLoHgD3qQmAzPXhhAnH/vESRLrtVIgeU2a1jR2OfPqHo9HusI6IpPH9yzCuX6mn9fwqL9ZstQ+4T43/VFwfAAsl+c3tHiNeOhWix5z77X644anNSADNAtOWf2/JqurJkU//WCNddmX9+ZlkxkDEBWu0wy1VF6tIAa31s8awCJLPnK4PkcJUTDj2n5sg0munQuSY2QKWSQPL8Ohrp+oXtQxSAI58+s0a6bILHAF+JpkwEAmAiovVaeg+vZw8e8zmEK3eySHeYMh2MlR0KkSOmS1gubBHB458GoS7psvzZdO7Bx98EPfccw+qq6sxcOBALFq0COXl5Y7PM3XTO1W8lJTesOMgpi7d6HgMbp5lDpkNEZ12bo3zZlqmsT5XIHOnQiY/yG0Zd5Z/N0/cPxOjNr374x//iFtvvRUPP/wwhg4divvvvx+XXnopPvjgA3Tp0kX34Y3mJZ+AQ/fhIjOClZuT4BBviKjqAXvpmHidLib1+JmI0z4iMnToUAwZMgSLFy8GACSTSXTv3h033ngjZs+enfW5UR8R8YIjIuHi9vPixoXh4aUHLDNaRmaJ+8iHHWNGRE6cOIFNmzZhzpw5TT/LycnB2LFjsWHDhlaPb2hoQENDQ9Pfa2trdZ6eJ0FffMzODhe3I1iqVuGQfm57wLKjZWQOdhTU0BqIHDhwAI2NjTjzzDOb/fzMM8/Etm3bWj1+wYIFmDdvns5TUsKEi49D9+r4EVR6ST7lEG+0cal2OImsWgwiGAm6k+yGUatm5syZg1tvvbXp77W1tejevXuAZ9SaSRcfs7O98yuo9DKCFcYbC4ljvlf4iI5iFea3wYH6Bt++t7L3M1PuLVoDkU6dOiE3NxeffPJJs59/8sknKC0tbfX4/Px85OeLlcgNQhBDqE4XCofu3fMzqHQ7gmXC6BvpxaXa4SM6ivX9x95o+pnu763s/cyke4vWEu95eXm46KKL8Le//a3pZ8lkEn/7298wfPhwnYfWQvceMS2JbniWrZw8ZRZECXXZEvDcayYeuDdU+LgZndL5vZW9n5l2b9E+NXPrrbfi2muvxcUXX4zy8nLcf//9qK+vx3XXXaf70Mr5OYRq0hRQFAU1Ly86gsUExvhgvlf4uBmdyvS9VTU1InM/K+9VYty9RXsg8r3vfQ/79+/Hr371K1RXV2PQoEFYvXp1qwRWP7n98P0aQmUjpF+Q8/IiyadMYIwX5nuFi1POl530723NsRPKpkZk7mcm3lt8SVadOXMmZs6c6cehHHmZF/NryazohfLE6zvRqTCfeSEuBDEvLxMAV9ccE3pNJjCayU1nh/le4ZFtFEvEmspqPP76LmUj3jL3MxOTo41aNaOb1+kOv4ZQRS+A+aveb/p/JjDKkQkqVQyfygTAqyuqmn222TCB0R/p10Cn0/OBFGxXQ7BCarRZ10LD50ncPPZcLH9zN6prG5yfmOa/t+5TOuItcz8TzWH0897iy14zbqmsrGrt3WE30iCzd4fubGPRKpzpWIFRnsgeIQA8f9YiVTOtnvCaymr87vVdjq/JvWb8k+n7ni79emCF1GjLdC2UFrXF1PIeOLtTe3Q6PR8//9NWfFLbYBsQdChog0P1Jx2PJVsVW3TPI7/2sZJpv2MTiKguia5z/bXThWKHjZO8bEElAM+NikgAfEb7Nsg/LUeqV5UQPD55YxdYpLOuhwevvhDzV72vpLND5hENMp0Cgh+OOBuPCXQ2fjC8Jy7rXya9VYBIx0nlRo12GIhksHLrXty0Yqvj4x6YMgiTB53l6Vgq2F0oIri/jJxMQSUAJSNobka3nJyen4t7rxzIIEQzpyAync6eLgVPdkQ9W0BQ3C5P6p4gOwIr2knWPbJvzF4zJglb0SC7LHoRTGCUk2lefsOOg0oyy3WtuhnXr3VBQFLLKWk8XQoQCkIAfj/DSHalSbbE48ZkSmrFjWwCq2iekUnJ0VoLmpkkjEWDxvcvw6u3jUZJQRup55kSTIWZqsxyHZ9FzbHPlRXNI3u6AgZ+P8PHzf3ArtCktegBgG17lE5XgcVs5+i32AQi2T58k4sGbfrosHBPy8RgKqxUjaBd1LMDdFxS7FXr5yZgKCnIC1Vnh8SoHlG3q7JsR3XVbtPEJhAB5Etsm0C2wTExmAojVSNomz46DMWdGADsVfvB6RpIZ10Pd03u3/T3lv8O8PsZVjpG1Mf3L8P6WWOwfPow/GB4T6HnRLUDEqtABGj+4T8wZRCWTx+G9bPGGBmEAOINTseCPGODqTBSNYKm48bBXrU/RIfQ06+HCQPC19khZ7pG1K2pkcsEr4uodkBik6yaLkxFg0RKCZcUtMGGOd9C3mmxiyu1UlF2W8eNg71q/4gkjbe8HkxKAiR1dJbh96tqt6lis3w3zPxY8032vNSMESkedEb7NsjLTeCTuhNZXysnASyeeiEmDOgq/0uQJzKVVSnadNWQitp9nnVEIkj3mm/SR+QGM65fKRav3Y77Xv6n7es8dPVgTBjAz5ooqqJ0n2cgElE6q7mSXjIVD6NyIyIieVG5zzMQITKQ6A0mKjciUofXBIUNK6sSb1wGEk2Sbvm4xmQKG3Yc5GcZUxwlo6hjIBJBvHFFBz/LaJHtINhttOZU9psdEQoTTs1EDLchjw5+ltEiG1TKbrTm9jhEOsi03yw8ESGNyRTmvVCZcZmozv0K4sKaIlm5dS827Dio9X3kZxktVlDZMqiwRjZWV1S1eo7MRmtejkMUNE7NRIjsDpEkzu9eJj/L6HAKKhM4FVSO61fabGRDdqM1t8chChpHRBTys8eciaodY6k5kV6m6s+en2V0uBnZAOQ3WnN7HApO0G2GKTgioogJ87Kqd4gksV7m7GffxZ3PV6K6Vt1nz88yOtwGlbJlvxm8hosJbYYpOCKigCnzsjp2iIw7kV7mkaMnmwUhgPfPnp9ldLgNKmU3WmPwGh6624ywjbQwEPHIpKRCXTtExpnb3qPXz97PzzJsN62w8RJUWhutiezmy+A1HHS3GasrqjBy4VpMXboRN63YiqlLN2LkwrVGJypzasYj05IKde4QGUdeeo9eP3u7z7KkIA/zJ/dX8llyeFg/K6i84anNSCDzfkPZgkrR3Xy9Hof84abNEK0L47buTNAYiHhk4rwstyFXx2meXoSXz358/zIkkyn8cmUFDtWfBAAcrD+B+asqkZMDTzeVF9/Zh58t29Lq56bftMLIawdBtCovOyLmE70fvFxZjeF9Ogp3FsK8aoqBiEemzsuK3rgou2y9TFFePvvVFVWYsWyL8h7Oi+9UYeby1kEIYP5NK6z86iCwI2I20fvBY6/vwmm5CTz62k6h779po/MymCPiEedlo892nr4oH2e0b6Pts9c1l7y6ogo/W7YZ2Z7GpZ56WB2EyYPOwvA+HbUFB34dh+Q5tRnplv69dRACZP7+mzg6L4ojIh5xXjYe7HqZayqrtX32Ono4VnAjysSbFpEXfu3DY3ccq8346VObHV9DtLMwvE9HY0fnRTAQUYDzsvGQabpL52evo4fjFNy0ZOJNK0y4+ZxZ/ErOdjrO+P5l+OGIs/G713d5Ppb1/ZetO2MSBiKKcF42vnR99jp6ODJBC6cUveGKJLP4taJE9Djj+pUqCUSs73+YR+eZI6IQ52XjS8dnryP/SCZoMfWmFQYqC1axzot3ftV7kjmOyPc729cv0/dfpu6MSTgiQmQoHT0ckeXIOQlg8dQLjb1pmU7lMkqOqqjh14oS2eM4fb+nf70XHn1tZ9NzW/57pu9/GEfnOSJCZDDVPZxsFVsti6cOxoQBXbO+Dnvp9lRtPmfK1hFR4NeKEtnjOH2/50zo5+r7H7bReY6IEBnOTQ8nW5KkXYKtaE+bvfTsVDR6YS5OZSLRKckPP6nDhh0HXY8guMnrcvp+h3GEQxYDEaIQkClQJxIouL25hbWEtJ9UJBmHuTiViUQrJC9etwOL1+1wHVi7Xbni9P2OeoFKTs0QRYjMcL7s8K1JGzyaTEWScZiLU5lIZEoyndvpL2486g4DEQmcFyeT6Q4UVOU+RJ2KxijMxalMZZePkYmX70tYV64EiVMzgjgvTibIlvuhezifvXRxXgvdhbk4lcnSpyRf334Ai9dtt32sl+/L+P5lGNP3TDy5YRc+OnQUPUva41+Hn42809j3z4SBiADOi5MJnIJh3YECe+lyvCQZhrk4lemsKUmd35dM39Xfrt/JjqsNhmcOOC9OJhDJ/dAdKHCDR3lellFyiF8v0e/BgboGoel4a+p+/gvv4adcdi2FIyIOmL1OQRNdyvnqbaO1Duezl+6/OCzdDIpocb/5q95v+rvddHymEZCWuOzaHkdEHHBenIImGgxv+uiw9ox99tL9p7I4FRPuvySykqbl25NpVMNutDITJnRnxhERB5wXp6DJBMOTB52lfSdo9tLDiQn3rdklFeckWgchQOtRDXzx/7LhHDuuzTEQccDsdQqabDDsR6AQ9QJLUcOEe3stvy8H6hqaTce01HJUQ2QkpCV2XJtjIOKA8+IUNDfBMAOFcMm2LFvFa7NcfHbp35eVW/cKPcftqEZpUT47ri0wEBHgtSYAkRdeg2GdjRx5p3vKhAn3cnRPxx//PIk1ldVsN9JoC0T+8z//E6tWrcLWrVuRl5eHI0eO6DqUL1ighoLkNhhmXoDZ/JgyYcK9nPJeJTijfRscOXrS9jEdC/JwUc8OyM1JCO1hk67m6MnYT4e1lEilUlrSpufOnYszzjgDH3/8MR577DFXgUhtbS2Ki4tRU1ODoqIi9SeZxqnXyBs6mUBmdMOukbMezRthsBqTKYxcuNZ2tMKacls/a4ynEawNOw5i6tKNjo9bPn1YrEdErO/Wmspq/O71XY6Pt+7/AHDDU5sBQDgYUfXZmkym/dYWiFieeOIJ3HzzzUYHIk5BBm/oFDZ+NXLknl8BgnUtOOUYxflaEKkD0lL6/R+A9POBaAd/Mu23UfMKDQ0NqK2tbfZHN6eKlS++U8XKqhQ63KDOfH5NmXBH2Oxk6oCkS7//j+tXivWzxmD59GF4YMogzBzdR+g1OB12ilGByIIFC1BcXNz0p3v37lqPJ1K+/Y6VFbyhU+gwL8B8ftYoYiG6zLK1ASLS7//phedGnNNZ6PlcxnuKVLLq7NmzsXDhwqyPef/999G3b19XJzNnzhzceuutTX+vra3VGoyI9BoP1p8Qei3e0MkkLMRnPr9rFLEQXWtObYCoNZXVzaZYWH9KjlQg8vOf/xzTpk3L+pjevXu7Ppn8/Hzk5+e7fr4slcEDb+hkEtU3Qi4BVi+IGkWsL9Ocqjbgd6/vQnmvkqaRJdafkiMViHTu3BmdO4sNOYWBaPBQUtAGh+tPMrKl0FB5I+SKMX1YoyhYKjuQtz/3Lo6dTKK0qG1TUMLPVoy2VTO7d+/GoUOH8Pzzz+Oee+7B3//+dwDAOeecg9NPP13oNXSvmhHNJr9j4vmYsWwLgMw39DjPsZK/ZEcmvAYRXDHmD444BcOpDXAr/TsW18/WiOW706ZNw+9///tWP1+3bh1GjRol9Bp+LN+1brRA9iCDvUIKmttr0O2NkEuAKQ7s2gDLj0acjX01x/FSRbXwazJQNyQQUcGUOiKWuEa25K9M19maymrfRyZYCIviwqkNEP0upIt7oC7TfnOvGYhnk6tK9GJAQ3Yy3RBLi9ri+OeNvm9axiXAFBdObYBT8ncm3MNHHAORL/iVTc4pHrJju+9IbfaGXtcNj0uAKU6ytQHZkr+dMFB3ZlRBs6hzquK6uqIqoDOjoHktrASov+FZvUC7MZYETgXRXDFGcWBXFM4JA3VnDER8IlLFlaXi40tFYSUvN7zGZAobdhzEyq17sWHHQTQmUywNTtTC+P5lTaXc77tqIEoK8hioK8CpGZ/I7P3B+cT48TKa4bWWjdN0IWshEH0pfQqnXV4ui5YpwEDEJ0z8IzuNyRQO1DW4eq7XG55tXsoX04XWahyWBic6peVigwevHoz5qxioe8FAxCdM/KNMRLcfTwA4o30b5J+Wg+raL4MWLzc8p+nClqtxOFJHcWc3enjHxPPRoSCfgbpLDER8wk2QqCW70YiWrNvZgu9eoHRkgtOFROKyjR7OWLYFS64ZjMmDzgrk3MKOyao+YeIfpZNZJZO+VXv6VuPD+3T0dL1wupBIDBcb6MVAxEd2y7/SGxqKB9FVMndMPB/rZ43Rcm24nS7MtMKGKMpkRg9JHqdmfMbEPwLERxk6FeZruzbcTBeyIB/FEUcP9eKIiA2dvT6Vw+sUTiYkL8tOF7IgX3YcKYouE76vUcYRkQzY6yPdTEleFq0TIrvCJm54z4g2U76vUcXdd1uwy4zmts6kmt3240Fca04bMfqxE29YN4PkPSMeTPq+hgF333WJvT7yk0lVS53qhOieI3czomBC4MJ7RjSIXEsmfV+jhoFIGtZVIL+FJXlZ5xy5aHXXls8xYSqE94zwk7mWwvJ9DRsmq6ZhZjQFIQzJy7p24nVTn8GkpFneM8wimzDs5lrKzUmgvFcJuhS2xad1p4JMJiZ7wxGRNF57fSYMFRO5le36tVbYqN7gS3ZEwbSpEK6mMIfsKJlIEHz7c+9iTN8zkXfal312U0bjooSBSBovmdG8OCnMRK5fHXPksiMKpk2FcDWFGdxM74kUFTxUfxLDFvwNd3+nP8b3L3N1HHLGqZk0bsuwmzRUTCRL5vod378M62eNwfLpw/DAlEFYPn2Yp8qvsiMKpk2FcOuG4Lktvy56jRyqP4EbntqMF9/ZxzLvmjAQaUG2DDv3IKAwc3P9qsxpkc09EQ1cdh046vqcZHHrhmC5Lb8uO132y5UVWsq8sxAep2YyksmMNm2omEiGH9evytyT8l4lKC3KR3VtQ9ZjrnhrN2aOOce3kQiupgiO21Eyp2m1dCmcmqZReT4Ap/QtDERsONVVsJg2VEwkw4T6IDK5J7k5CUwt74H7Xv4w63GDCP5F7xl+ikMCvduE4fQgOIjzYb7JlxiIeMSseQozU+qDyIwonN2pQOj4cQ/+Te9tqwqSvCQMW0Hw7c+9KzTiUVKQh8P1JzwnJpu2+itozBHxSFd9BSI/mFQfRDT3JGzBfxA5AKYn0K+uqMLIhWsxdelG3LRiK6Yu3YiRC9e6Oi+vCcPj+5dh45yxKCnIsz2G9T24a3J/18dJ5zavJaoYiHjErHkKM13Xr84bbZiCf5UNrijTE+jtgqSqmuP46VObMf+F96QDNq8Jw3mn5eDu7/RHAtm/BxMGqElM5pR+c5yaUYB7EFCYZbt+75h4Porb5WHl1r1Sw+c6b7S6iqupFlQOgMkJ9NmCJMtjr+/CY6/vkp5G8powLHofV5GYHLZRPd0YiCjCrHkKs0zX7+H6E5i/yl2Oge4brenBf5A5ACb3tkWKiFncBGxeE4ZF7+Nej8NCeM0xEFHIxKx5IlHp1+/qiirMWOa+N+/Hjdbk4D/IUQmTe9sywY/qgE00OdaP+3hYRvX8wkCEiJpR0Zv360ZravAf5KiE7iDQy2oX2eBHVcBm4goi00f1/MRAhIiaUdWbj/ONNshRCZ1BoNcGXaaIWDovAZvJ9TpMHtXzEwMRImpGZW/ey402zMW4gs4B0BEEqmjQswVJ2bgN2ER32D12MonSomCuMVNH9fzEQISImjX6B+qyl0+3iDYObm60Jg6lyzAhB0Blb1tl8q1dkJSJm4Ct5bUsssPuLX/cCiBc11iUJFKplLE77NTW1qK4uBg1NTUoKioK+nSIIilTo5+TAOzKOFiNw/pZY7Q0pHY9b+tIYSp9HfaAyrJhx0FMXbrR8XHLpw8TDjqtgGFNZTV+9/ou24BN5vPO9H7LCOM1ZiqZ9psjIkQxZtfoZwtCAH29+aiVvo5KDoCO5FtrpGx4n44o71XieRrJ7lqWEcZrLAoYiBDFlEhxqZYjI7oTTU0uxuVWFHIAvCTfiuT6eA3YRK5lUWG8xsKOgQhRTIkUl0qmgDsmno9OhfmOjYOK5FKTi3HFmdvkW5mpKS8Bm0yhNFE6rrEwJ2DrxECEKKZEb7SdCvMxedBZWR+jKhfC5GJcceYm+dbLKhvZBltH0KD6GotKvpAODESIYkpVo2/X4FibmD109YWYMKCr0LEu6tkha6IscGq66KKeHYRej9RxWhI8rl8pNuw4iE/rjqPT6fm48/n3XOX6uGmwRa/lOyaej5KCPMxf9T4O15/wbWm1ybVMTMBAhCimVNS6EJmbn7l8Cx5IAZ1Oz3fs4W766HDWIAQ4FaRs+ugw5+8DYJfLsaayGiMXrhWeHrHLw3DbYItey9NG9EJuTgLt8nJ9W1odtQRsHRiIEMWUiloXonkmNy7f0uxndj1c5oiYr2Uuh5fVKumfo9cGe8qQ7rjv5Q9b/TzTtexn1d8oJmCrxkCEKMa83pDdBgR2PVzmiISL19Uq6Z+j2wbbqXaI3bXs19JqBtfOGIgQxZyXG7LbgMCuhxt0afQghXFFhdvVKpk+RzcNttNozC1jz8PMMedk3ZxR9ygEg2tnDESIyPUN2Qoc3DRGmXq4JpRGD0JYV1S46cXbfY6yDbbTaEwCwIq3dmPmmHOkz1GlOAfXonKCPgEiCi8rcPCiZWNmTReVFjdvmEqL20ZydYHVq28ZzFnTV6srqgI6M2duevF2n6PVYNuFmAmcCs6sBltmKidI6d+Rlr9blINrGRwRISJPxvcvw0NXX4iZy7c4rnjJJFNjFqbS6F6mVMK+okK0t3/vFQNxoL4h6/sjOxoWptwLP5Njw4iBCBE1cduoThjQFYuRwM+WbZY+5uH6Exl/HobS6F6nVMK+okI0eBhxbieh15NpsMOWexGm4Npv2gKRXbt2Yf78+Vi7di2qq6vRtWtXXHPNNfjFL36BvLw8XYclIpe8NqoTBpTh4Ryx7d3TzV9ViUv7e+/x+53sqaJIVZh69XZU9/ZFG+ww5l6EIbgOgrZAZNu2bUgmk3jkkUdwzjnnoKKiAtOnT0d9fT3uvfdeXYclIhdUVX5s2YgcqGvA/FXvZ32Oih5/piCqpCAPd03ujwkD1A97q5pSCVuv3o7q3r5Igx3XxOYo0haIjB8/HuPHj2/6e+/evfHBBx9gyZIltoFIQ0MDGhoamv5eW1ur6/SI6Auq8xTSG5GVW/cKnYOXHr9dEHWo/gR+tmwzfvJxL8yZ4C2htiVVUyqiq47spq9MEkRvn7kX0eBrjkhNTQ1KSuyHyRYsWIB58+b5eEZEpDNPQXePX6Sg1iOv7cTAbmcI73cjQtWUSm5OAndMPB8/W7Yl6+NUTV9FEXMvws+35bvbt2/HokWL8JOf/MT2MXPmzEFNTU3Tnz179vh1ekSxpTNPwerx22m5JFOWaEGtX66sQKObJT02VAZYHQryHR9jwjJUk1mjMZMHnYXhfToyCAkZ6UBk9uzZSCQSWf9s27at2XP27t2L8ePH48orr8T06dNtXzs/Px9FRUXN/hCRXjpHLXJzEpg0MPvwuJd5fNHg6FD9SaUNuWzNi2zCmrDamExhw46DWLl1LzbsOKg00KN4kZ6a+fnPf45p06ZlfUzv3r2b/n/fvn0YPXo0vva1r+HRRx+VPkEi0kvn6oPVFVV49LWdtv9+/Td6eZrHlwmOVDbkKhMlw5iwGtZKsGQm6RGRzp07o2/fvln/WMtz9+7di1GjRuGiiy7C448/jpwcFnIlMo2uyo8iJbiff7vKU0+6vFcJSgrEygGobshFK8A6jRyoHF3xQ5grwZKZtCWrWkFIz549ce+992L//v1N/1ZaWqrrsETkgo7VB34U68rNSeCuyf0dC6mlN+Qq6404JUqKjByEaRlq2CvBkpm0BSJr1qzB9u3bsX37dnTr1q3Zv6VSnEskMo3q1Qd+5T5MGFCGn3zcC4/YTAEl8GVDrmNKwW7ZqkxtlrAsQ3UTXIZxV2Hyl7ZAZNq0aY65JERkFpW1IPzMfZgzoR8GdjsDv1xZgUP1J5t+nh5kqCra1lKmhhaA9MhBGJahygaXzCUhEdxrhoi08LsE94QBXXFp/7KMDbmuKQW7hnbKkO6upqVMLwEuE1zqCvwoepg9SkRaBLH9uV09CR1bxr/4ThV+apO0ed/LHwq9hmlLcp2IJtZe1LND1sAvBWD2s+/i9Q8PcNkvMRAhijPdtSBEV5bopjpf5cV39mHm8swJsjLvoElLckWIBpebPjrsWGjuyNGT+P5jb2DkwrVcaRNznJohiim/5u9NyH1Qma+yuqLKsSS7ExN3hhUlklgruscQwKkaYiBCFEt+z98HnfugKl/FyjWRoXtJruiqFD+XLcuM9HDZLzEQIYqZONaCUFWrQ3RvG8stY8/Dird2a1uSKzqq5eeyZcA58GtJRU0ZCi/miBDFjI7EzTBQka8ik1xaVtwWM8ecg/WzxmD59GF4YMogLJ8+DOtnjVEWhIhUOA2iEmq2XJJswpa8S2pwRIQoZsK6yZoKXvNVZKYc0kdYVPfyRUe1xvQ9M7DRL7tckmzClrxLajAQIYqZMG6yppKXfBWRKYecBLB4qrocm0y5HaKjWk9u2KW9zH62cx3XrxTj+pVi4/8dxIynN+PIsZMZnxfm5F3yjoEIUcz4XWgsSrLlmlgWT70QEwaoCULscjsm9Bfbr+ujQ0eFHqdi9MspD+XX/+8C3PDUqSXPXpJ3WTI+epgjQhQzQRQaixK7XJOy4rZ4+JrBmDCgq5LjZMvteOz1XUKv0bOkvdDjvI5+ieShqMjRWV1RhZEL12Lq0o24acVWTF26kXVIIiCRMngHutraWhQXF6OmpgZFRUVBnw5RpHAfEG+89syzPb8xmcLIhWuzTqvkJIBUKvOojDWq9epto/HNe9Y5jn6tnzXGdeDZmExhxK//hurahoz/3vIYbt83uyXn1jNZh8QsMu03p2aIYsqEQmNh5iXXxCkIFFkmbBXBzbYcOe+0HCXLlrNZvHa7bRACtM5DcfO+xXHJeZxwaoYoxuz2ZiF9RKYxRHM2fjjibMepDp1l9ldXVOG+l/8p9FgveShxXXIeFxwRISLyiWjP/t4rBgq93rh+pfjFxH6Oo1o6Rr9kq8x2Ksh3faw4LzmPAwYiREQ+Ee3ZIwHhlU2iUx2qy+zLVpn9+Z/fxp2T3OUfxX3JedRxaoaIyCeiPfYDnzUYv7JJdvShutZ9JVdrybndb5vAqcCNS87DiYEIEZFPZHr2OnM7VHA7+jDvhUo0JuUWa3LJebRxaoaIyCeyxeRMXtkku7Ed4K2Sq13J+PRNBFnsLJwYiBAR+cTNLsCqcztUSf9dZLlNKs0WmLEuTnhxaoaItGpMprBhx0Gs3LoXG3YclB6W94tf52n6lIsM63cpKciTep6XpNJMS86D2GGY1GFlVSLSxtReassh/MP1DZi/6n1fzzNK0wgnPk9i2IKXcag+86Z2FhWVXFtyqkKr45jkTKb9ZiBCRFqoLMmtstHOFBxlwtLhcuw+73QJqH8/N+w4iKlLNzo+bvn0YUZOcUUVS7wTUaCcCncB4iW5VY6qiDSW6efJ0uHi7JJJLbpGmFjsLPwYiBCRciLFrkRWT9gFDtbcv+yoil1wZMfLKo84Sk8mra45hkP1J1Byej5Ki/RNPbHYWfgxECEi5aprxXqf2R6neqMz2Uqg6dibFuf3Kh/ZJdFkHq6aISLlDn1mvxur6ONUb3TmJZhgb9pcLHYWfgxEiEg50eWc2R6neu7fTTDhtnR4WJYsR0WUlkTHEadmiGJM1xLS0uJ2nh+neu5fthKo2960qUuWo87kKrSUHQMRopjS2WBajX62qRWnkQbVc//ZqppmUurivVCZXEvyTK1CS9mxjghRDKms8SF7DOs4IsewXgPIXA7dzXnaBWB3TOyHDgV5rnvTLKxF9CUWNCMiW342mCpGXXSM3HiZkrKeW117HIc+a0BJQR5Ki9shmUrh+799w/H5LKxFccCCZkRkS2Y1itcGU8W8vY65f7dD+Nmqsp7Rro3Qa3ApMFFzDESIYsbvSpQq5u1NmPt3qsp65Fj2fVYsXApM1BwDEaKYYSVKeW6qsrbEwlpEmbGOCFHMWKtR7CY23NbOiDIvVVkBFtYiyoaBCFHMsBKlPNlpqpb5IqoLa7FgGkUJp2aIYshup1Q3tTPiQHaa6sGrByMnJ6GlsBYLplHUMBAhiilWohQnU5W1rLgthvXpqOV9ZME0iiJOzRDFmLUaZfKgszBcU+MZBenTWdkkoG9ay2k3YuDUbsScpqGwYSBCRCTAms4qK848TVOmeYM11bsRE5mCUzNERILSp7NaVlbVPa3ld/0XIr8wECEikhBUcTVT6r/o2rGZ4ouBCBFRCKjejdgNrtghHZgjQkQUAkHXf7FW7LTMU7FW7KyuqNJyXIo+BiJERCFhJcyWtkiYVV0wrSWu2CGdtE7NTJo0CVu3bsWnn36KDh06YOzYsVi4cCG6du2q87BERJEVRP0XP3dspvjROiIyevRo/OlPf8IHH3yAv/zlL9ixYweuuOIKnYckIoo8v+u/cMUO6aR1ROSWW25p+v+ePXti9uzZuPzyy3Hy5Em0adMmyzOJiMgUpqzYoWjybdXMoUOH8PTTT+NrX/uabRDS0NCAhoaGpr/X1tb6dXpERGTDhBU7FF3ak1VnzZqFgoICdOzYEbt378bKlSttH7tgwQIUFxc3/enevbvu0yMiIgdBr9ihaJMORGbPno1EIpH1z7Zt25oef9ttt2HLli34n//5H+Tm5uIHP/gBUqnMmdVz5sxBTU1N0589e/a4/82IiEiZoFbsUPQlUnZRgY39+/fj4MGDWR/Tu3dv5OXltfr5xx9/jO7du+N///d/MXz4cMdj1dbWori4GDU1NSgqKpI5TSIi0oCVVUmETPstnSPSuXNndO7c2dWJJZNJAGiWB0JEROERVIl7ii5tyapvvPEG3nrrLYwcORIdOnTAjh07cMcdd6BPnz5CoyFEREQUfdqSVdu3b49nn30W3/rWt/CVr3wFP/rRjzBgwAC8+uqryM/P13VYIiIiChFtIyIXXHAB1q5dq+vliYiIKAK41wwREREFhoEIERERBYaBCBEREQWGgQgREREFxre9ZoiIKB5Y9IxkMBAhIiJlVldUYd4LlaiqOd70s7Litpj77X4sA08ZcWqGiIiUWF1RhRue2twsCAGA6prjuOGpzVhdURXQmZHJGIgQEcVUYzKFDTsOYuXWvdiw4yAak1Jbj7V6rXkvVCLTK1g/m/dCpadjUDRxaoaIKIZUT6G8ufNQq5GQdCkAVTXH8ebOQ9yrhprhiAgRUczomEL5tM4+CHHzOIoPBiJERDGiawqlS2FbpY+j+GAgQkQUIzJTKDLKe5WgrLgt7BbpJnBq6qe8V4nU61L0MRAhIooRXVMouTkJzP12PwBoFYxYf5/77X6sJ0KtMBAhIooRnVMo4/uXYck1g1Fa3Py5pcVtseSawawjQhlx1QwRUYxYUyjVNccz5okkcCpwcDuFMr5/Gcb1K2VlVRLGQISIKEasKZQbntqMBNAsGFE1hZKbk+ASXRLGqRkiopjhFAqZhCMiREQxxCkUMgUDESKimOIUCpmAUzNEREQUGAYiREREFBgGIkRERBQYBiJEREQUGAYiREREFBgGIkRERBQYBiJEREQUGAYiREREFBgGIkRERBQYoyurplKntmOqra0N+EyIiIhIlNVuW+14NkYHInV1dQCA7t27B3wmREREJKuurg7FxcVZH5NIiYQrAUkmk9i3bx8KCwuRSJi9EVNtbS26d++OPXv2oKioKOjTiQW+5/7i++0/vuf+43uuRiqVQl1dHbp27YqcnOxZIEaPiOTk5KBbt25Bn4aUoqIiXrw+43vuL77f/uN77j++5945jYRYmKxKREREgWEgQkRERIFhIKJIfn4+5s6di/z8/KBPJTb4nvuL77f/+J77j++5/4xOViUiIqJo44gIERERBYaBCBEREQWGgQgREREFhoEIERERBYaBCBEREQWGgYhGDQ0NGDRoEBKJBLZu3Rr06UTWrl278KMf/Qi9evVCu3bt0KdPH8ydOxcnTpwI+tQi5cEHH8TZZ5+Ntm3bYujQoXjzzTeDPqXIWrBgAYYMGYLCwkJ06dIFl19+OT744IOgTys2fv3rXyORSODmm28O+lRigYGIRv/xH/+Brl27Bn0akbdt2zYkk0k88sgjeO+993Dffffh4Ycfxu233x70qUXGH//4R9x6662YO3cuNm/ejIEDB+LSSy/Fp59+GvSpRdKrr76KGTNmYOPGjVizZg1OnjyJSy65BPX19UGfWuS99dZbeOSRRzBgwICgTyU+UqTFiy++mOrbt2/qvffeSwFIbdmyJehTipXf/OY3qV69egV9GpFRXl6emjFjRtPfGxsbU127dk0tWLAgwLOKj08//TQFIPXqq68GfSqRVldXlzr33HNTa9asSX3zm99M3XTTTUGfUixwRESDTz75BNOnT8eTTz6J9u3bB306sVRTU4OSkpKgTyMSTpw4gU2bNmHs2LFNP8vJycHYsWOxYcOGAM8sPmpqagCA17RmM2bMwMSJE5td66Sf0bvvhlEqlcK0adPw05/+FBdffDF27doV9CnFzvbt27Fo0SLce++9QZ9KJBw4cACNjY0488wzm/38zDPPxLZt2wI6q/hIJpO4+eabMWLECPTv3z/o04msFStWYPPmzXjrrbeCPpXY4YiIoNmzZyORSGT9s23bNixatAh1dXWYM2dO0KcceqLvebq9e/di/PjxuPLKKzF9+vSAzpxInRkzZqCiogIrVqwI+lQia8+ePbjpppvw9NNPo23btkGfTuxwrxlB+/fvx8GDB7M+pnfv3rjqqqvwwgsvIJFINP28sbERubm5+P73v4/f//73uk81MkTf87y8PADAvn37MGrUKAwbNgxPPPEEcnIYZ6tw4sQJtG/fHs888wwuv/zypp9fe+21OHLkCFauXBncyUXczJkzsXLlSrz22mvo1atX0KcTWf/93/+N73znO8jNzW36WWNjIxKJBHJyctDQ0NDs30gtBiKK7d69G7W1tU1/37dvHy699FI888wzGDp0KLp16xbg2UXX3r17MXr0aFx00UV46qmneNNQbOjQoSgvL8eiRYsAnJou6NGjB2bOnInZs2cHfHbRk0qlcOONN+K5557DK6+8gnPPPTfoU4q0uro6fPTRR81+dt1116Fv376YNWsWp8Q0Y46IYj169Gj299NPPx0A0KdPHwYhmuzduxejRo1Cz549ce+992L//v1N/1ZaWhrgmUXHrbfeimuvvRYXX3wxysvLcf/996O+vh7XXXdd0KcWSTNmzMCyZcuwcuVKFBYWorq6GgBQXFyMdu3aBXx20VNYWNgq2CgoKEDHjh0ZhPiAgQiF3po1a7B9+3Zs3769VbDHAT81vve972H//v341a9+herqagwaNAirV69ulcBKaixZsgQAMGrUqGY/f/zxxzFt2jT/T4hII07NEBERUWCYzUdERESBYSBCREREgWEgQkRERIFhIEJERESBYSBCREREgWEgQkRERIFhIEJERESBYSBCREREgWEgQkRERIFhIEJERESBYSBCREREgfn/HYlzzw66R3sAAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGzCAYAAAASZnxRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAU1BJREFUeJzt3X94FNW9P/D3Js0PEpJA+JWggAGsSlNAqAhCLWBUlK/i/d7SK2pFr5dWDS3+qF/AR4pe2iIXb9FHKCC1UouAbW8pWGpaENCLgiiQakQtUBAMiUACCQZIaHa+f+DGTbK7c2bmzJwzs+/X8/A8mkx2z87uzvnMOZ/zOSHDMAwQERERKZCiugFERESUvBiIEBERkTIMRIiIiEgZBiJERESkDAMRIiIiUoaBCBERESnDQISIiIiUYSBCREREyjAQISIiImUYiBAlibvuugsXXXSR6mYQEbXCQITIx0KhkNC/LVu2qG6qp7Zu3dry2o8fP97u95WVlfjOd76DTp06ITc3FxMmTMA//vGPmI/1/PPP47LLLkNmZiYuvvhiPPvss243nyiphLjXDJF/rVixotX/v/jii9iwYQN+85vftPr5tddei/z8fITDYWRkZHjZRM+Fw2EMHToUe/fuRUNDA44dO4auXbu2/P7zzz/HkCFDUFdXh4cffhhpaWlYsGABDMNAeXk5unTp0nLs0qVLce+99+Jf//Vfcf311+N///d/8Zvf/AZPPvkkpk+fruLlEQWPQUSBUVpaaiT713rx4sVGly5djGnTphkAjGPHjrX6/bx58wwAxo4dO1p+9uGHHxqpqanGzJkzW352+vRpo0uXLsb48eNb/f3tt99uZGdnG7W1te6+EKIkwakZoiTRNkfk4MGDCIVCeOqpp7Bo0SL07dsXWVlZuO6663D48GEYhoE5c+bgwgsvRIcOHTBhwgTU1ta2e9xXX30V3/zmN5GdnY2cnByMHz8eH3zwgYev7Eu1tbV47LHH8J//+Z/o1KlTzGN+//vf44orrsAVV1zR8rNLL70U11xzDX7729+2/Gzz5s2oqanB/fff3+rvS0tL0dDQgPXr17vyGoiSDQMRoiT30ksv4Re/+AV+8IMf4OGHH8brr7+O73znO3jsscdQVlaG6dOn43vf+x5eeeUV/OhHP2r1t7/5zW8wfvx4dOzYEfPmzcOsWbOwZ88ejBo1CgcPHkz4vOFwGMePHxf6d+7cOaHXMmvWLBQUFOD73/9+3Od877338I1vfKPd74YNG4b9+/fj1KlTAIDdu3cDQLtjhw4dipSUlJbfE5EzX1HdACJSq7KyEnv37kVeXh4AoLm5GXPnzsWZM2fw7rvv4itfOX+ZOHbsGF566SUsXrwYGRkZ+Pzzz/HDH/4Q//Ef/4Hnnnuu5fEmT56MSy65BD/72c9a/bytQ4cOoaioSKiNmzdvxujRoxMe895772Hp0qX485//jNTU1JjH1NbWorGxEYWFhe1+F/nZkSNHcMkll6Cqqgqpqano3r17q+PS09PRpUsXHDlyRKjtRJQYAxGiJDdx4sSWIAQArrzySgDAHXfc0RKERH6+atUqVFZWom/fvtiwYQNOnjyJSZMmtVqZkpqaiiuvvBKbN29O+LwFBQXYsGGDUBsHDRpkeswPf/hD3HDDDbjuuuviHnPmzBkAiJmwm5mZ2eqYM2fOID09PebjZGZmthxHRM4wECFKcr179271/5GgpFevXjF/fuLECQDA3r17AQBjx46N+bi5ubkJnzczMxMlJSXWGxzDyy+/jLfeegsVFRUJj+vQoQMAoLGxsd3vzp492+qYDh06oKmpKebjnD17tuU4InKGgQhRkos3jRHv58YXK/7D4TCA83kiBQUF7Y6LHk2Jpbm5GceOHRNqY35+ftzRCQB45JFHMHHiRKSnp7fkppw8eRIAcPjwYTQ1NaFnz57Iz89HRkYGqqqq2j1G5Gc9e/YEcH6qprm5GUePHm01PdPU1ISampqW44jIGQYiRGRLv379AADdu3e3NbJx+PBhaTkihw8fxsqVK7Fy5cp2vxsyZAgGDRqE8vJypKSk4Otf/zrefffddse9/fbb6Nu3L3JycgAAgwcPBgC8++67uPHGG1uOe/fddxEOh1t+T0TOMBAhIluuv/565Obm4mc/+xnGjBmDtLS0Vr8/duwYunXrFvfvZeaIrFmzpt3PVq9ejZdffhkvvvgiLrzwwpaff/vb38aMGTPw7rvvtqyI+fjjj7Fp06ZWq4LGjh2L/Px8LF68uFUgsnjxYmRlZWH8+PFCbSeixBiIEJEtubm5WLx4Mb773e9iyJAhuPXWW9GtWzccOnQI69evx8iRI7Fw4cK4fy8zR+SWW25p97Py8nIAwA033NCqsur999+PZcuWYfz48fjRj36EtLQ0/PznP0ePHj3w8MMPtxzXoUMHzJkzB6WlpZg4cWJLZdUVK1bgpz/9KfLz86W0nSjZMRAhIttuu+029OzZE08++STmz5+PxsZGXHDBBfjmN7+Ju+++W3XzYsrJycGWLVvw4IMP4ic/+QnC4TBGjx6NBQsWtBvBuf/++5GWlob//u//xrp169CrVy8sWLAA06ZNU9R6ouDhXjNERESkDCurEhERkTIMRIiIiEgZBiJERESkDAMRIiIiUoaBCBERESnDQISIiIiU0bqOSDgcxpEjR5CTk4NQKKS6OURERCTAMAycOnUKPXv2REpK4jEPrQORI0eOtNsBlIiIiPzh8OHDrbZYiEXrQCSy+dThw4dNtxQnIiIiPdTX16NXr14t/XgiWgcikemY3NxcBiJEREQ+I5JWwWRVIiIiUoaBCBERESnDQISIiIiUYSBCREREyjAQISIiImUYiBAREZEyDESIiIhIGQYiREREpIzWBc2IKHiawwZ2HKjF0VNn0T0nE8OK8pGawr2kiJIVAxEi8kxZRRWeeGUPqurOtvysMC8Ts28agHHFhQpbRkSqcGqGiDxRVlGF+1bsahWEAEB13Vnct2IXyiqqFLWMiFRiIEJErmsOG3jilT0wYvwu8rMnXtmD5nCsI4goyBiIEJHrdhyobTcSEs0AUFV3FjsO1HrXKCLSAgMRInLd0VPxgxA7xxFRcDAQISLXdc/JlHocEQUHAxEict2wonwU5mUi3iLdEM6vnhlWlO9ls4hIAwxEiMh1qSkhzL5pAAC0C0Yi/z/7pgGsJ0KUhFwNRBYvXoyBAwciNzcXubm5GDFiBF599VU3n5KINDWuuBCL7xiCgrzW0y8FeZlYfMcQ1hEhSlIhwzBcWy/3yiuvIDU1FRdffDEMw8Cvf/1rzJ8/H7t378bXvvY107+vr69HXl4e6urqkJub61YzichDrKxKFHxW+m9XA5FY8vPzMX/+fNxzzz2mxzIQISIi8h8r/bdnJd6bm5vxu9/9Dg0NDRgxYkTMYxobG9HY2Njy//X19V41j4iIiBRwPVn1/fffR8eOHZGRkYF7770Xa9aswYABA2IeO3fuXOTl5bX869Wrl9vNIyIiIoVcn5ppamrCoUOHUFdXh9///vf45S9/iddffz1mMBJrRKRXr16cmiEiIvIRrXNESkpK0K9fPyxdutT0WOaIEBER+Y+V/tvzOiLhcLjVqAcRERElL1eTVWfOnIkbbrgBvXv3xqlTp7By5Ups2bIFf/nLX9x8WiIiIvIJVwORo0eP4s4770RVVRXy8vIwcOBA/OUvf8G1117r5tMSERGRT7gaiDz//PNuPjwRERH5HPeaISIiImUYiBAREZEyDESIiIhIGQYiREREpAwDESIiIlKGgQgREREpw0CEiIiIlGEgQkRERMowECEiIiJlGIgQERGRMgxEiIiISBkGIkRERKQMAxEiIiJShoEIERERKcNAhIiIiJRhIEJERETKMBAhIiIiZRiIEBERkTIMRIiIiEgZBiJERESkDAMRIiIiUoaBCBERESnDQISIiIiUYSBCREREynxFdQOIKLiawwZ2HKjF0VNn0T0nE8OK8pGaElLdLCLSCAMRInJFWUUVnnhlD6rqzrb8rDAvE7NvGoBxxYUKW0ZEOuHUDBFJV1ZRhftW7GoVhABAdd1Z3LdiF8oqqhS1jIh0w0CEiKRqDht44pU9MGL8LvKzJ17Zg+ZwrCOIKNkwECFKIs1hA9v212BteSW27a9xJRjYcaC23UhINANAVd1Z7DhQK/25ich/mCNClCS8ytk4eip+EGLnOCIKNo6IECWBeDkbVXVnce+KXXhm49+ljY50z8mUehwRBRsDEaKAS5SzEbFg416MfHKTlCTSYUX5KMzLRLxFuiGcH4kZVpTv+LmIyP8YiBAFnFnORkR1vZwVLakpIcy+aQAAtAtGIv8/+6YBrCdCRAAYiBAFntVcDBkrWsYVF2LxHUNQkNd6+qUgLxOL7xjCOiJE1ILJqkQBZyUXI3pFy4h+XRw977jiQlw7oICVVYkoIQYiFCgsKd5eJGejuu5swjyRaLJWtKSmhBwHNOQMvxOkOwYiFBgsKR5bJGfjvhW7hP+GK1qCgd8J8gPmiFAgsKR4Yi05G7kZCY/jipbg4HeC/IKBCPkeS4qLGVdciDdnXIMHS74a8/dc0RIc/E6Qn7gaiMydOxdXXHEFcnJy0L17d9xyyy34+OOP3XxKSkIsKS4uNSWEaSUXY8kdQ1DIFS2Bxe8E+YmrOSKvv/46SktLccUVV+Cf//wnHn30UVx33XXYs2cPsrOz3XxqSiJBKinuVWIhV7QEW5C+ExR8rgYiZWVlrf5/+fLl6N69O3bu3Imrr77azaemJBKUkuJeJxZyRUtwBeU7QcnB0xyRuro6AEB+fuxEuMbGRtTX17f6R7F5sYuqX5xoaDQ9RvcETCYWkkwss09+4tny3XA4jAceeAAjR45EcXFxzGPmzp2LJ554wqsm+RaX5H2pOWxgzvoPTY+bNV7fBEyzxMIQzicWXjugQNvXQHqJXrIdAlp9tpiUTLrxbESktLQUFRUVWL16ddxjZs6cibq6upZ/hw8f9qp5vsE759ZE91HpnJ3uQWvsYWIhuYFl9skvPBkRmTp1Kv70pz/hjTfewIUXXhj3uIyMDGRkJK5zkMx459yeLkl5TpJMdXkNFDxMSiY/cDUQMQwDP/jBD7BmzRps2bIFRUVFbj5d4Fm5c06WJEQdkvKcTpXp8BoouJiUTLpzdWqmtLQUK1aswMqVK5GTk4Pq6mpUV1fjzJkzbj5tYPHOuT3VSXkypspUvwYiIpVcDUQWL16Muro6jB49GoWFhS3/Xn75ZTefNrB459xeJCkPQLuO3O2kPFnVK1W+BiIi1VwNRAzDiPnvrrvucvNpA4t3zrGpSsqTmWTKxEIiSlbcfddHuCQvPhVJebKnyphYSETJiIGIz0TunNsmRxYkaR2RaF4n5bkxVcbEQiJKNgxEfIh3znqITJVV152NmScSwvkA0YupMq/2qCEiko2BiE/xzlk9XabKWGmXiPzM071miIJGdZJpslTa5d5KRMHFEREih1RNlSVLpV2O+BAFGwMR8iXdciJUTJUlQ6XdyIhP22Crqu4s7l2xCw+WfBVTx/b3daBFlOwYiJB2zIIM3iGfF/RKu4lGfCIWbPw7Vu34BI/f/LWkeu+JgoSBCGnFLMiId4ccyYlwmpeh20hLIkGvtCu6s3J1faOU956I1GAgQtowCzIW3XY55qz/0LWcCL+NtOi0fNgNVkdygpAPQ+b8dLNAYrhqhrTQHDbw+LoPEu7b8tjaCmkl1dvy4+qToO9RY2Ukx8l7T/5RVlGFUfM2YdKy7Zi2uhyTlm3HqHmbtPx+kjgGIqSFhZv2obq+Me7vDQC1DeeEHsvqnbSszetUUL182KlEy3LN9laKxY18GC4d1oMfbxZIDKdmSLmyiios2Ph3aY9nNSfC76tP/Fpp12wqLLpgnCjZ+TB+m64LqmRZqp6sOCJCSkUuMKLys9Ol7z4chNUnkeXDEwZfgBH9umh/MRa9u20Z8clNHGC4sfM078D1IXOna9IPAxFSSnRlBHC+o/nJhGIAcnMigr76RDdWp8LGFRfizRlj8WDJxTEfz418GD9P1wVREG4WKD4GIqSUlQvH7JsG4MaB8nMizHIR3LjbTmZ27m5TU0KYVvJVLLljCAo9yIex2kbmkbiLNwvBxhwRUkr0wvFgycUtHY3snAhdNq/zmqplkE7ubr3Kh7HSRuaRuC/oS9WTHQMRUsrsAgOcv6hPHdt6WF52SfVILkLbDqUgoB2Kys7T6d2tF+X0Rdt48HgDnt6417UCe3Rest4sJIuQYRjajiHW19cjLy8PdXV1yM3NVd0cckkkKRCIfYHx8mKuc7EkWW2LVzjOq/PdHDYwat4m07vbrdPHKjv3om00DCPusnMdXkfQcPTJP6z03wxESAuxLjBdstMxYXBPXDugQKuAQAVZF+BIBxsv/8GrzlOn4DMeszY+UPJVoWXnq6YM13LZt1/pfLNAX2IgQr4UucBs3FONNeWVrQqYJfNdj8wRjDf3Hsftz79tepwXnacbd7eyO6lEbWz8ZxjTVpebPsYztw7GhMEX2G4DkR9Z6b+ZI0LaSE0Joe5ME3715kHOuX9BZiGnsooqzPif94We14tlkLITT90IbBK1cdv+GqHH4EoOosQYiEThkJ9aQa2e6ORzJavqa7xRlXi86jxlJZ66uStzvDZyJQeRHAxEvsAkKPX8Xmo9FqefKxmFnBIFeG35sfNUFcByJQeRHCxoBpZy1kXQqieKfK7MCmHJKORkpXot4L/OU2X5b79vOkikg6QfEQnqdIAfBal6osjnasYf3sfj6/aguj7+aImM4X/RwK1ThzQ8+a9f913n6XYAaza15tdNB4l0kfSBSBCnA/wqSHPuIp+rk6fPATjX6udtcxpkDP+LBm6Lbh+Ckf27Ch0bj4o8KzcDWNGpNS+KrBEFVdJPzQRtOsDPIp0uIHdTOxXsfl7ibfrmZPhfdC+d4X2ddaRlFVUYNW8TJi3bjmmryzFp2XaMmrdJaGrTyV4tbu0VZHfKlvvOEFmT9CMiQZoOCIKglFp38nmJNQrnZPjfzqiK1ZENJ6tWnCb0upE0anfKlknvRNYlfUEzP5SbTkZ+Wkodq60AEn6uRMguhCXaSVrtTJ1UazVbVnzPyItQIlhZV2YQsG1/DSYt2256XHThN9Wl84l0woJmFnAJnp68nHN3EvQk6vzifa5EyR6FExlVsTOyYTfPSmRZ8fNvHsTzbx4UCigSvT6r77HVKVsmvRPZl/SBCBCc6QCyzsldtEinHfNzlZuBs/8Mo+70Oc+TchMFeHY7U7t5VlaWFYsWJov1+uy8x1anbJn0TmQfA5EvcAle8nGS1yDaaW+dPjbm52rDnmrtRuHsdqZ286ysJPTaHVWw+x5bXcHFpHci+5J+1Uy0yN3UhMEXYES/LgxCAswskABar1xpy0qnHetzpWMhLLudqd1VK1annqwWJnPyHltdwcWkdyL7OCJClvkpkTQep0PpMu6AdRuFs9uZ2s2zMht1iEf03Dt9j61M2QapBg6R1xiIkCVBWZ7oNJCQdQesUyEsJ52pWad97YACbNtf0y7gspPQK3ruvQwWmfROZB8DERIma4dTHUZUDh5vEDouXqcXxDtgp51pvE57w57qdst7o4PXWAFMLFbPqdfBIpPeyW90uBYDDERIkKzliTqMqJRVVGHBxr0JjzHr9Ly4A3bzIhHvsZ12pm07bdHgNRLAbNhTjV+9eVDKOY0Ei2YBzvHPG4UeT4Ru021E8ehwLY5I+oJmJMZOgae2dCj4ZFZ8K7pNIu1x68vs5kVC5LFlBEF2C53JfO1/fu8I7l+5O+ExKSFg4aTLcePAnpYem8ivvLgWa1PQ7I033sD8+fOxc+dOVFVVYc2aNbjlllvcfEpyidP5dl0KPonWrnig5KtCX0Q37oBlTYE5eWwZuSt2k0VlntPO2Rmmx4QN4P6Vu7HkixEhoiDT5VoczdXluw0NDRg0aBAWLVrk5tOQB5zOt1vplNwkGlBd1DVL+DFlLvt2uqxY1WPH4iR4TU0JYVhRPrrnZOLoqfOfCzvtslK34/F1H+DNfcd9vVkdN9wjM7pci6O5OiJyww034IYbbnDzKcgjTpMzdSn4pHu9B9GLxIINH2Nk/26WRgq8rv7p5FzLmp6x8j5W1zfi9l++7ej5VNJpzp/0pcu1OJpWBc0aGxtRX1/f6h/pwWqBp7Z0CQDc2jJe1p2o6Jd/4eb9mLRsO0bN2xR3O3q7jy3rAmT3XEemj9oGTZHpI9HXG90GO+w8nyoyzxkFmy7X4mhaBSJz585FXl5ey79evXqpbhJFcVIN1K0AwCqnAVUsZRVVGDVvEyYt245pq8stBwjRrH75rXQ0Xl+A7Jxr2dNH0W2wyo3pKjd4PeVG/qbLtTiaVoHIzJkzUVdX1/Lv8OHDqptEbYwrLsTW6WOxaspwPHPrYKyaMhxbp48VWtYpOwCwS2Z5ddl3omYXibasdDQqLkBWz7Ub89fjigvxi9uGwM5HS8V8uVU6zvmTvnS6FkdoVUckIyMDGRnmWe6klt0VFToVfJKxMsON7HM71UZFcztUVf+0cq7dmj66cWAhFuJy06W8sp7PSzrO+ZPedLoWA5oFIuRPVmpO6FTwyekSVSt3osOK8i2dI9Fqo9FEOhpVFyDRcy06LXTw+GnLbbhxYE8sSQlZPq9W2uUGs++XjnP+pD+drsWuBiKff/459u3b1/L/Bw4cQHl5OfLz89G7d283n5o8YidTX6f9VZwQvcPcsKcaD/223NI5ir5IvLnvOBZu3hfzuGiiHY1OF6C2hhXloyA3A9X1iaudrn7nEKaO7W+5zW1fe9fsDDz8u7/hs/r4G+/lZ6dhaJ/Olp5HFpHvVxC3GyBv6HItdrWy6pYtWzBmzJh2P588eTKWL19u+vesrKo3lZVSddgjQbTabCxWzlGkQqlZR9O2QqlfPbPx76Yl+IHEVXytiHyOgfhTYSqWwVr5fsV7DV5WLSaKZqX/djVZdfTo0TAMo90/kSCE9KYyU1/mKhUnRBJL48UFVs5RJLcj3lEGgrWz60Vds4WOk5XzEC+hNprXy2Ctfr9kJmATeY05ImSL18WxItwsf26VWfKngfPlw+Nx6xy1pcPokRUqch7GFRdi7KU9MHzua6htaGr3++jk47GX9sDOT064ej7tfL90nnIjSoSBCNmiIlNfxz0SEiV/3lhcgOffPGj6GIn259lxoBbVdWcwZ/2HCR9jxh/ej/m6/VhtU1XOw85PTsQMQiIinf/wuRtR23Cu5edunE+73y9d5vyJrGAgQraouGtVNQpjJt6d6I4DtUKBiGiJ80ROnj6HhZv2YVrJxa0eQ5fRIytULTMW7fyjgxDAnfPJlTCUTLQqaEb+oaI4ls71EmJtfCe7xLmZF9460JIz4PdqmypyHux26m6cTx2rXxK5hYEI2aKiOp/f7hJllzg3c/L0uZbqmUGotmm3iq9dVqvaRpN9PnWsfknkFgYiZJvXd61+vEuUXeLcTGQ0SOfRIytijTS5+VzxOn9R1XVnpGx+CHAlDCUP5oiQI15m6qvKHXDKjRLn8URGg0RHhY6fasTa8kqusPhCvOTjLtnpqEmQyBoxZ/2HrRJenSayqloJ47eVVuRvrhY0c4oFzSgWP64EEWW3SFrbomZmRdCA8zVOom/YvTqHunRyidrR9ndD+3TGt+ZvTng+Y/FjQbEgf7/IO1b6bwYi5EuqOzO3nl8kgGgrXmcnUjFU5HFk0qWTs9MOq+czwk+Vb1VWS6ZgYSBCSc3tIMXtzjRRuW4DQKesNJw8LVbHIlZb246ERHOz05Tdydl9n520I9b5zM9Oa7ekNxZZJendEgmC4+Uo+SmgIvUYiJASIh1DUIIEt+8YE70OqzkD0ef8+KlG0+JoQOJOszlsYPs/avDWvuOoPHkGPTt1wMj+XTG8b/xkUtmdnN33WUY72n6Gq+vP4sGXy03b/MytgzFh8AWmx6kiOi2oe0BFerDSfzNZ9Quqh/r9TqRjUBUkyCo45WVlV7MkRSsdQXS1zbXllUJ/Ey9ptqyiCjP+8H6rERkA+MWW/eiUlYYn/+/XY55jmcXonLzPMtrRtnrptv01Cdsbocuy8niCstKK/IeBCPSZt/YrkY4BgO+DBK8ru7pRrttJLZayiirc+8WUUSwnT5/DvSt2YUmM91JWJ+f0fXajs1VVkl42v9XpoeBI+joi8apYer3bpl+JVvB8fN0Hrlb59KKAVxDuGO3WYmkOG3h83R6h54j1Xsrq5Jy+z250tkEpPubHOj0UDEkdiPi9DLYORDuG6vpG02N0DxKCcMdot9PccaAW1fVi5y7Weymrk7PyPjeHjXbFxdzqbINQfCwoARX5T1JPzei6iZqfyLz7t/tYzWEDx0/FD3SiRYIEOzlBQ/t0TrhCwi9D8Il2DI43HWn1vYm1K6yMYnSiQd7B46fbJaVGplvdKoqnqviYTHY+G0ROJXUgEoShdtVk3v1beaxIILFxTzXWlFeaLp+MDhLs1pB44pU9CYMQwD93jFY7Tavvc6zjZXRyIvkYeVlpeHrj3xPmI7nV2bqR12OV08T7IARU5C9JHYgEYahdNdFEPcMw8Fl9o5RkvliBRCLRQcKGPdWWk2bjJeNG0+2OUaQzstJpDivKR0FuptD0TKKpDaednNnISuT/zZJZt04fG8jOVlbivQ4BFSWPpK4jYlbF0q0CPn5ZKizazkQFuAC0WjWT6BiRC6VIUNBWdP0NqzUkzOpOAOf3Idk28xqkf0WPlCu3VoGZrZqJiLVqRrZ4r/HWK3phwca9pn+vWy0MGdcEVkUlnbCOiCAVm6j5ZamwlXaKDrk7HQ5PlFwcz6zxl+GukUVITQlh2/4ayzlBIrvh1jQ0YecnJ7To2NyspTKuuBBL7hgSs44IAHTOSsPcOHVEZIs3svKn944I/b3IdKtXNwwyrgle1rghki2pAxHA2+QstwtuyWKnnSJD7k6H5UWCgra65mS0PL6dnCA/5RF50RlF3kOrlVXdEGv6QNZ0qxs3DLECGztThbEw8Z78LOkDEcCb5Cy/3LE4aafIvLLo3HOsi7adzj66wxHtpPZ+dgrb9tdgWFG+r/KIvOqMUlNCGNm/K0b27wrgy/fqT+8dUT7VKKO4mBs3DLECm04dvoIz58JSrgl+CpiJ2mIg8gW3k7P8csfiZTvjDX0nmv8XFavDMeukIhZu3o+Fm/ejMC8Ts8Zf5puqmSo6I6+nGs2mS5xOt7pxwxAvsDl55p8J/87Kd81qwOyXPDVKDgxEPOKXOxav2hmvA7t5UCGee+NAzLvRBRv3olNWGupOnzPNEzHQvsNJ1EnFUl13FqUrd+N7VxfhuTcOeJZHZFfXjhlSjzPj9VSjaNDjZLpVdiBuJ6+pLZHvmpWRIL/kqVHy0CPNPwn4ZYjfi3YmKqu/NEYQAnx5Nxpht9uPVwEzlkg71v2tCotu80HVTNHeTsI6Oa+rElvdimFccSG2Th+LVVOG45lbB2PVlOHYOn2s6XslOxC3k9fUlsh3TbQqaiQnpW2bqurO4t4Vu/DMxr2sJN1GrAq9JBdHRDzil42x3G6nSAcWj4HzG6s9WPJVrNpxKGFNi0RD6JGcoIWb9pou9YzcAXfOTsfW6WNbDWcP7dMZOz85gbXllVoMbx9vEKsuK3pctLZD+eGw4ekUnp3pEjvTrbIDcacjh1bKzZuNBEWWryf6ni3Y+Hes2vEJHr/5a/oE2Apx9MgbDEQ8omKpsB1ut1PGHeJFXbPw3xMH4fbn3457jEhHuPqdw8LPefTU2VYdW1lFFb41f7NWFyi3RrNiJ1qmCf2tjKlGL/OWZAfiTkc4rX7XEiXemy1fj6iub9RqFZ8qflnlGAScmvGQXzbGcrOdMjqm7jmZwnf18Z7PakAU3aHoumOzGxu6xXutJ88kLqkfIWOq0cv8Khkbv0UP5YcNAwW5GbamEh8s+SrGFRdanhqIBMwTBl+AEf2+XFJt9fwk84af3BDVWxwR8Zhf9nFwq51OOqbou1HRnXrjPZ+Vi3J0563zMmzZo1lOEi1lTjV6nV/lJNk15uhRVprlc1iQm4GpY/tLnRqwcn50WcWnil9WOQYFAxEF/LKPgxvtFF1C21bbjtTpELqVi3J05637BcpqJ5poGafdaTTZU40q8qvsBOLxhvLrvqhC2ykrLWZF2lgev/lr0oqdRdj57qlexaeKX1Y5BgUDEfKUyF37964uwrq/VSXsSJ3e/YtclFNCwMJJl7e62PvhAiXaiZrdbYu+hk4d0lpN1ciuSiyjNoidkT0rgbjISFmHtFQsumcIXvvoM/z23U/xeWP7OiKRMvmJEkvbjrwBwPZ/1GDb/hoABkb07Yrh/dpXuY0+j6JUr+JTxS+rHIMiqTe9UynZCwr9+b0jeGxtBWobvuzAojtBKxvu2R26jrdZX8QvbhuCGwe2foxt+2swadl209dnZ1M1Lz8TIhuk5XVIF3qtL/3HlUgJhbTck8WrVQ9WPxfNYQPb/1GDN/cdx5GTZ3BBpw64KqpMvujjPVjyVbzw1oF2Iy2dstLwZJx9f8oqqvD4uj2mq85EN/wM4rVM1YaoQWKl/2YgokCyLwmL9frzs9PxkwnF7Tp+EU4uhFbfC7cuUFba4fTCb7ajcOQ1vP7IGHxr/matLsZWXruXu9GuLa/EtNXlpsc9c+tgTBh8gbTHMxNvJ+TmsBF3+bqV8xPka5nIruJ+f41uYiCisWTfqlvH12+1Y5d9gbJyTmRc+K3cvdedafLlxVg02JIVRMkeKRN9PDMFuRl4c8Y1CYM1pyOKOn2XZQtyoOU2K/03c0Q8pPOKCy/o+voT5QLEClJk7ths5ZzISl60kucyYfAFnu1OLZPXScWyE2qHFeVbSm6Np7q+MeFrtLs6Ttfvsmx+WeXodwxEPKT7igu3+e31m90NybhAiZ6T7f+okXbht5qI58eLsddJxToXLGz7GmMF11a/b377Ljvhl1WOfsZAxEN+WHHhJj+9ftGqik4vUKKv1awqppULv527d79djFWsepA5UrbjQK3j0ZCItsX4ZEw1+Om7TPpjIOKhZF8S5pfX78Wwc+SudO9npwT/QiyVS+TCr/PduywiUxudstKk7+0ka/RIVgdekJvR8hplliz3y3eZ/IEl3j3kRgluP/HL67cy7GxHWUUVRs3bhEnLtmPh5v0Jj42ckxF9uwo9tuiF3y/bDbjJrTArXol1K2R14I/f/DWkpoSklyz3y3eZ/IGBiIdk7GPhB/H2xvDL63dz2Dne3i2xRJ+T4f26SL/wjysuxNbpY7FqynA8c+tgrJoyHFunj7WcbOv1FukizykytXHi9DnbwaTbIh29mSnfLEKnrPYbEHbKSmu1dFd2cO2X7zL5gydTM4sWLcL8+fNRXV2NQYMG4dlnn8WwYcO8eGrtyJxH1pHZHLRurz9W4p5bw85W925pe07cmE5xkvuhYmmj6HMmKtYVTdcchtSUEGaNH4D7Vyaugvqn96qw49ESvHOwNmFlVTeCa92+y+RfrgciL7/8Mh566CEsWbIEV155JZ5++mlcf/31+Pjjj9G9e3e3n15LMlch6FTVUHQOWpdVGPE6tVnjL0NhXqZpDQqrw86ie7dMHdMfI/t3bXdOdLrwq9giXfQ5yyqqMOdPHwg9ps45DJ2z002Pqao7i52fnMDI/l0xsn/86Tu3gmu3v8s6Xd/IPa4HIj//+c8xZcoU3H333QCAJUuWYP369fjVr36FGTNmtDq2sbERjY1fbu9eX1/vdvOUkbEKQadiO1YTPFWvwkjUqZWu3I2SAd0TBg12Rh9E7zYv7tFRet0HmVTUkBB9znDYQOnK3aajTm5slCebzFEMNzcOdOu7rNP1jdzlao5IU1MTdu7ciZKSki+fMCUFJSUl2LZtW7vj586di7y8vJZ/vXr1crN5vhYv1yByd1hWUeVpe9xO8JTJrFMzAGzYczTu33/v6iLLF8LmsIHjpxrNDwTQtWNGwt/LSIZ0QsV7Lfqcj62tEApCAP1zGGSOYvgtp8Ps+vbn96o8z00i97gaiBw/fhzNzc3o0aNHq5/36NED1dXV7Y6fOXMm6urqWv4dPnzYzeb5luwMeBn8VFfA7vb2wPmL9rq/VVk6t5FVMnPWfyh0/MO/Lfc8kLSiuu6M0HEy32vRx4reRDGe/Ox0X6wMMluZAgD52Wmorj8r1Bn7ZaWUyI3C1FW7MGnZdkxbXY5Jy7Zj1LxNWn9nKDGt6ohkZGQgIyPx3SDpWdXQ7boCMueKnXSQVs9tvCmgRD6rb3Qtz8Kpsooq4YBKZv6FzMd6bPxl2p3XWBLVe4mobTiHB18uByA2baHD1J4ZkRuFtjGXm7lJ5D5XA5GuXbsiNTUVn332Wauff/bZZygoKHDzqQNNx9EHN+egZc8Vy+jURM6t1VUyEbru1SEaVLmRfyHy+crPTkdNQ5PpYxXkdZDWLrfFS1CORbQzVp2fZcbOdUvX7wyJcXVqJj09HUOHDsVrr73W8rNwOIzXXnsNI0aMcPOpA03HqoZuzUG7kQsjMuRtRuTcOpkCsppn4XY9DytBlQH5+QYin685E4oDWWQrut7Lgu8MQn6c1TSqpmVls3vd0ikPjaxxvaDZQw89hGXLluHXv/41PvzwQ9x3331oaGhoWUVD1ula1VD2HLRbuTCJOjUzVs6tjBEpkceIrtTq1py5laCqc1Yarh0gf8TT7PN148BCW8GwiqJsVkVGMQryOqA2wahPrM7YD68vmtMbBR3y0Mga13NE/u3f/g3Hjh3Dj3/8Y1RXV2Pw4MEoKytrl8BK4nTeK0TmHLSbuTDxhrwL8zJx86BCPPfGgZbniLB6bmWMSJk9hlf1PKxc3CMVS90Y/jf7fFmttaLTElGRPCir07I6vT5RIrkxiehcG4Zi8yRZderUqZg6daoXT5U0dCpu1ZasOWi3c2ESdWqX9+7s+Nya5TUkIpJn4WU9D6sXdzfvSs0+X6LBsIqibPGIBgxWpmV1en1Wxbu+pYTaJ6pG+KE2DMWm1aoZskanDHg3KiB6kQsTr1OTcW7NRq6MGP8d+X/AfOTFy9VTkaBKdHpG9V2pWbCioihbPFYCBtGk8KF9OuNb8zdr8frsivUdPNHQiNKVuwHoNRJMzjAQ8TkdMuDdGv51cyWOCBnn1mzkCkDM380afxnyOqRjbXmltGF6J87vfXIZ7v+iE0gkeut5XemyBN5ORWKRadmdn5zQ4vU5Fes7uDglpOVIMNnHQIQccXP4V+dcGCvMRlfa3/U1Yc56ecP0XbMzsG1/jePRqs7ZYjV+br2itxajdInosgTeTkAkMi27trxS6Pnf3Hdc6/cpFp1GgkkOBiJkmxfD2zrnwliRaHQl+ndlFVUoXSlvmD4vKw0P/+5vrXajtTtaJdopL3/rIJ5+ba/j53OTLkvg7QZEZp2xaLsXbt7X8t86vk/x6DASTPIwECHbvBreTpY7INnD9AaAk6fPAWhd9tzuaJVo53byjJznc5OX036J8qecBESJOmM7idJ23yfukEtOMRAh27zOUQj6HZDdYfpFt12Ox9ZWtNpnpUduBs7+M/xFINL+ceyMVtldBaRjcqRX035m+VNuBUR2lsDaeZ/8uDyY9ON6QTMKLl2Gt4PCTmAX2fslOgjJz07HrVf0jhmERNip3LrjQC1uKC5o6bCs0LHqpdubwIlUBXZzV9zI6+uRK75/l5X3SbcdwMm/OCJCtjm9m+OQbmtWA7t4icInGppa5WgksnFPtelIU6y73lAIMKKeuFNWWsLAJ0K3qpdOpv0SfX6tTLO5mQc1rrgQOZlpuP2Xb1v6O7P3Saflz+R/DETINifD2xzSbc9KYCdS/l7EmvJKPDo+/h13vGAnUlTqnpEXoWRAAcJhA7c/b97Z6Tg6Zmfaz+zza3Wazc08qOOfN1r+G7P3SZflzxQMnJohR+wMb3NINzYrw/RONtSLVttwLu4wvNlGdyEAf66oxrCifAzv10XL/Y/cIPL5tTPNFgmIJgy+ACP6dZE2kmAl+BN9n3RZ/iyT3/bkCRKOiJBjVu7m/D6k6/Z0kugwvcwLfLzHsnrXq7rmixdTfaKf36e+PUjo8bwYIbKaZBx5n9xa7aMjjtCqxUCEpBAd3nZjSNerXBOvLlYigZ3MC3y8x7J616uy5ovV98buZ0b084uQed5M56w0RyNEoq9BdAVN9PlStdpHBT/vyRMUDETIU7KHdL0KDmRerEQ6ELPATqQjOL9aItSqmFnbYxJ1FnbuelXUfLH63jj5zIh+Ljd++JnpMU4G/q2+hnhBYpfsdEwY3BPXDihoeZ9Ez6fqETAZ/D5CGxQMRMhTMod0vbqTkXmxkhU4iSQKP37z1wAA963Y1dLWtsck6ixEhvRTQudX6bRtm1cJilbfG6efGdHP7wtvHjQ95uTpc7aSOe2+BpEgUZfVPl5h0q0emKxKnop0bk6TGkVWjTzxyh4pCWdWLlaJyE7SFUkUdlIrIzp5Np6wAZSujN12L5L/rLw3Mj4zkc+vLK9WVFk6N3ZfQ+S9+NN7RwAA/2dgz5gJsVY/6+OKC7F1+lismjIcz9w6GKumDMfW6WN9EYQAwUy69SOOiJCnZFW0lHUnIzJNIuNi5dYQsMhdrpPpkkjl1qmrdiNRXxnd9uawgYWb9uKFNw+2KvfuxpSZlfdGxmcm8vm994tRJqde3PYJXtz2ifC5sfMarIzCOVnt40dBS7r1KwYi5DkZQ7oyggPRC7SMi5WbQ8AiHYGTzqJzdkbCICS67XVnmjDjD+/HTNJ0I/nPynsj6+53XHEh7hl5EZ4XmH4RJXpurL4Gq9M4ydYxi0w/dslOx9A+nT1tV7Lh1Awp4XRI1+kF08o0iYzpJDeHgGNNgcicFhFt04Y91bhvxa64K0VkT5kB1t4bmZ1syYAC4TaKjG+Jnhsrr8HONI6sqVO/SFS7J6KmoQnfmr85aesbeYEjIqSMk7t0J8sHZe9yC5hPJ3XtKLbfh+hxEbFGdTplpQFAq4BAZOg/3jSVaOf3x/IjpitBZCf/WXlvZC45FX2sWeMvw5z1HwoVnxM5N1Zeg51ROK82A9RJvBHaaFzK6y6OiFArfqku6GSzMDvJp443SBM9jRZOd7xRnZOnz7UblTBLiC2rqMKoeZswadl2TFtdjknLtmPUvE0oq6gSukvOz05DbZvVM4nITP4TfW9kbjAn+lg3DuzZMvJ354g+Qq8n0bmx8hrsjsK5vRmgjsYVF+L1R8YgPzst5u/dGM2jL3FEhFr4rbqg3VwTJxdou0mfxxvE9vsQPc6s/HpbiRJiRfIIzO6S/2XwBZZyJmTnGIi+NyKfGdFCYaKfv+iRvxe3fWL6WszOjejzWp3GiX7N1w4o8LwejGo7PznRahfrtriU1z0MRAiAf6sL2gkODh5vEHrsWBdyu9NJspMA7ew1E+tCKjpNtXX62ISdX16HdOFARHaOQdtO9P8M7Jnw/U/0mbFTKEz08xcZWTJ739rWZbH6Gto+n9k0zomGJoyat8k3NyBu4VJedRiIkO+rC1oJDprDBlbtOGR6nOzOUnZJbCcXw+i/tTJNlajzaw4bwvuZyMwxsDuKF+szYzcYF/38paaEMGv8Zbh/5e6Ex81ZvwfXF5t/18yeVyTf4+ZBhShd6b8bEDck24ohnTBHhKQV7PKDHQdqUV1vPv1x6xW9pQZdTvITYuXtOLkYRv+t1bvAeDvEiqw+6JSVhiUSOzaZBeJkF8iLl2vVOds8GVnmdy1Rvsei2y7Hur9VeVIU0A+SbcWQTjgiQkk1JCn6Gi7qmiX9ue3ktMS74581/jJLO6oCsUddZN4Fxnt9nbLScPdVRZg6tn9L4OJ0o0LZo3hWV5gkan+iUZrGf4aFXp/sZN5YI1ksb95aMq4Y0gUDEdJySNKtHXVVv1YrOQWJpgpKV+7G964uwnNvHEi4o2pEvAupSEGn/Ow04YJOIq9PRlK07E7USjAeq/352Wn4yYRipKSEEk7vPFBysdDzyP78xZrG8eoGxKvdsWUIwv45fsRAhKTkL8i82Li5ekeH7ctFcgpE7vjX/a0Ki24bgjnrW5+rzllpMNC6jki8C6nIFvG1Defwrfmbhc9/otcnKyladicq2vEfPH4aT2/8e7v21zacw/0rdyMrPTXhe7ZqxyEU5Gbis3p1n78IL4Jyv63EA9TsIJ3sGIiQ4yFJmRcbt1fv+GX4VfSOv3N2OrZOH9vuohl5DJELqVcFnWROp8juREUC1B65GVi141DC0afTTc1xf2cAqK5vxIMlX8XTG/+u/PPndlDu15V4gL/3z/EjJqsSAPtFjHROGIzHDwWbrNzxx0ogjZdUGs+XBZ3SY/5exvmXmRQ9tE9nmPXVKSEITymJJBNPGtYb1fXOczcu6pqlxedPZoG3trzcHZv8jyMi1MLqkKTqhEEndB9+VZHL8s7B2oTVUZ2ef5nTKTs/OZFwIz4ACBvnjxNtq1l+gGiiqZnuOZkY0a+LtM+fk2lRt3IimAhLVjAQoVasDEmqTBiUQefhV69zWcoqqjDjf94XOtbuxnzHTwlWlz3ViLXllQk7Vbc+K4kC1G37ayw9Vltt3zMZnz8Z06JuBOXJtBKPnGMgQrapShhMhoJCXuayxJvLj8fq+Y/VWcaTEgLmrP+w5f+jO9XmsIHt/6jBtv01+PTEaVfaCsQPEIYV5X+xp078MuDxuJH/ITMHQ3ZQzu8yWcFAhGxTkTDo1YoCHXixlNDKnjV2zr/VIKftdEukU/3e1UV4+d1P223mJ7OtZlJTQvjJhGLTyqids9KQ8ZWUVoXzZC//1L0asurvsp+WDBMDEXJA9sXGLytavNIcNpDXIR3/b9ylqP28EfnZ6SjI6yDlohq5UL+577ilPWusnH+rG/PFEvnbpW8cEP4bNz8rNw7sie9/ejJue0IA7rqqCL27ZEl/z6LpnoOh8rvsxyXDyY6BCNnmxsWGBYXOS3QxdXrxtjJVEtEpKw1P/t+vWzr/djbmk8Htz8rMGwdg0IWd8djailbJvZH6LQs2/r3lZ7Les7b8kIOh4rvs5yXDySxkGIa266fq6+uRl5eHuro65ObmSntcDtvJ5cYdSDK/R2bTGb+47XLcOLCnK48dz0v3XImRF3e19DdryysxbXW5xWeyb+qY/hjZv6tnn5Xoz+jB4w1YsHFvu2MirZDdAW7bX4NJy7abHrdqynDlCdlefZebw0a7XYSjRUZot04fmzTXEpWs9N9JNyLCYTv53Mi613lFS1syL7Qi0xlTV+3GQoRw40Brn1c7UyWRi/dwG++F14mIF/fo6OlnJvIZjXSAsbiVr6E6B8MKr77Luk9XUXxJFYhw2M49fgocZJIV2FrJ2QgbwP0rd2FJirXPq9WpEqdz+SL72MikagWGig6Q+VTtWZmuSuYRVx0lTSCie5Y5+Y+swNZOzgZg/fNqNV/A6Vy+WWcpMzgpyM1QdvevKl+D+VStie8X1NBuCoej4mq5VuL9pz/9Ka666ipkZWWhU6dObj2NMJnlpYlklbCOVyJfhNXPq+iFeuqYflg1ZTi2Th/r+MKcqJz+L24bgsK8zHblxaOlhIAp3ywyfZ7Hb/6ashsIlTUzxhUXYuv0sVg1ZTieuXWwtPfNjyIjcPE+BSGcTyhesHGvlC0pSB7XRkSampowceJEjBgxAs8//7xbTyPMD1nm5B8yhuNlLG+18nkVzSt48NpLpHbqiXKIUlKQcOffhZOG4MaBhRjapzNm/OH9dnVE7KzmkU11vkayTou2JTJdFe+7xlFxtVwLRJ544gkAwPLly916CktY6Y9kkhHYyljeauXzqjKvIF5nGW96oe1QeSSYiVRWBQyM6NsVwwU29HMb8zX0kWi66tYrerdaWt0Wk1nV0SpHpLGxEY2NX1YjrK+vl/bYqu9aKFhkBLZORt/sfl6t5hV4kdQnuuoqNSWEkf27YmR/a8uIvcB8DX3E+zz96b0jQn/PUXHvaRWIzJ07t2UkRTbetZBMMgJbu6NvTj+voh2/7BVBZkGG3+9Cdd3RORlXiMT6PHFUXF+WCprNmDED8+bNS3jMhx9+iEsvvbTl/5cvX44HHngAJ0+eNH38WCMivXr1klrQjHVESJZIoikQO7A1WzUTqT+RKJjJy0pD5ldSUV3v7ec13oogqwW6+H2zTmbgwPP/JZHvGwueyWOloJmlQOTYsWOoqUm8FXbfvn2Rnp7e8v9WApG2WFmVdGf1Qt/2s3eioRGlX2yiFi+Y8fouW1aFSlnBjEpeXytkBg5BOP+yOb15IHGuVVbt1q0bunXr5qhxOgjCMDDpwcpwfLxO5ntXF2Hd36oS5hZ4+Xl1e0WQX1YoeD2aILPgYhDOvxuYy6Mn13JEDh06hNraWhw6dAjNzc0oLy8HAPTv3x8dO3Z062mJPCcS2CbqZJ574wAW3TYEnbPTtRil82JFkOoVCmYjHV5XYZYdONg5/8kyUqxrLk8ycy0Q+fGPf4xf//rXLf9/+eWXAwA2b96M0aNHu/W0RNoR6WTmrN+jzdy0lyuCVKxQMBvpUDGaIDtws3r+ky2XhKPienGtsury5cthGEa7fwxCKNn4raqvSIXKQkkrgrxeoRCvkm10ZU0V75fswM3K+Rc5J0Ruci0QIaLzdB4diCWy1B1Au2BEdOmwjGBGNtGy/NErlBKR+X7JDtxEz//QPp2lbFVA5AQDESKX6To6kEiiPWJE8iPMghkDwA3F5+fpverkREc6aj9vjHtMNJnvl1ngAJwvZx8OG0LnSzSY3PnJCV+N1lEwMRAhcpmOowMinG6oFi+YCX1xIn715kFMWrYdo+Zt8mT4X3QE49MTpz1/vxIFDhEnT5/D7c+/LXy+RIJJv43WUTBZqiPiNbfqiBB5LZnrF0RWY2zcU43n3zzY7vdenYNt+2swadl2oWO/f3URnnvjAABv369YSaNtWW1DotUwoudk1ZThTO4kS6z03xwRIfKA06kOP0tNCWFYUT7+XFEd8/de5SKITH9ErPtbFRbd5v37FRmFeuk/rkSnDmkxj7F6viIrRCYMvgAj2mwS6NfROgoWrfaaIQqyZK5foENdkcj0x71fjEwlUlV3Fp2z07F1+ljP36/UlBBSQiGcPHMu7jGyzhf34CIdMBAh8lCy1i/QJRdhXHEh/n3kRfhVjCmiWG2R/X6JFg0TPQ/VdWcct4nVRkk1BiJE5DqdVg5dO6BAKBCJ1xa7FUitFA0TPQ9z1n+IDumpcYMF0bYm82gdkDxVZXXFQIQoSai82EZyEcx2PvUiF8FJW+xWILVaMt6sjREnGprilpy32tZkHa1LtqqyOuKqGaIkEOtiW5CbgUnDeuOirtme7Syry8ohO22xu5ut3d2M4z2fyN9z510xPE/u4aoZImoRt4R3fSMWbNyLaavLPann4XTlUHPYwLb9NVhbXolt+2scrbCx2hbRqqyx2iSaqLtgw99bva5IG/OzY6+eafv3kaJjTtqaTHie9MGpGWqH86XBkehi25ZbO8tGs5uL4MbwuZW2OFn1I5p4unDzPizcvK/V6xpXXIgz58J48OVy07+PPI8OK5T8gOdJHwxEqBXOlwaL2cU2mls7y7ZlNRfhz+8dwf0rd7f7uYzASbQtTlb9WE3Abfu6CnKtJfrqskJJdzxP+uDUDLXgLpzBY/UiqtveIn9+rwpTV7UPQgBvh8+drPqxUkgNaP+6rBYd02mFks54nvTBQIQAcL40qOxeRHW4CyyrqML9K3ch0UfOq8DJSQVSkX1k2op+XVZ3Q2a1VDE8T/pgIEIArM2XBonMBEgdWb0bj+iek6n03EQCY1FuB05Wg4G24iXHmom8LivJtU7bmix4nvTBHBHJ/JroGYT5UqvnPhnyYRKV8I4lshT0RENTuyWnXp4bK7ktgDfD504rkEYnx7657xgWbt5v+pzRr8tKci2rpYrhedID64hI5OeOze+7cFo998lWP8DKrq7f+2LnWZXnZm15JaatLhc6tjBGDQ43ybjZiNQWMSuq5vR1+fXGyGs8T/JZ6b8ZiEji947NqwujG6yee7sFpvwu+mJ78PhprNpxCNX1rQO3WeMvw5z1Hyo5N9HtO36qEXPWfyj0d0s0+G7Z6ch0KvBGJJuV/ptTMxKYJXp6sSTSKb/uwmnn3PuxfoCMO7a2S1Wnju3f7jFVnZtYIzYpISRMVE0JAQsnXa68s7Y7EsppAaLzGIhI4MeOLRY/XhjtnHu/5cO4NeUXq4aGinMTb0TLLDd24aQhuHGg+iDEyh4ybSX7ZnNEAAMRKfzWsSXitwujnXPvp/oBTjs6q7w+NyKVX9uOjOiSdyVrJDRZN5sjimAgIoGfOjYRfrow2jn3Ou0Em4iKKT+vz43I6piwAcwafxm65mRoFRgHZSSUSDXWEZGAhXHUsXPu/VI/QEVtF6/PjeiIVtecDEwYfAFG9Oui/H2JCNJIKJFKDEQk8EvHFkR2z73TnWC9oKqj8/LciI5ode2YEfd38QqvuV2QLWgjoUSqcGpGEj8megaF3XOvez6Myo7Oq3NjNhUU8fBvy/H4zV9r917GS+S9eVAh1v2tytWaPn6Z4iPSHeuISMbCOOoE7dz7ubaLFfHqaUSLVVsjXiJvPG7U52AtEKLYWNCMPBW0AEAnydLRlVVU4fF1e1oVWGsrOvACkLAonchjyPqM+rmiMpFbWNCMPMOLsLuSZcpvXHEhcjLScPvzb8c9pm1yrtUgpO1jyFrJovsUH5HuGIiQbV7XuEhWydLRHW9oFDpORnKu7ARfPy15J9INAxGyJQhl7f0kGTo6L5NzuZKFSB9cvku2qKhxQcFmpSaM2bHxsKYPkX4YiJAtLOZEslmpCZPo2HhY04dITwxEyBYWcyI3WCmmFu/YwrxMfP/qIhRqXKyOiL7E5btkS7LUuCA1rCwJj3csl5UTqcPlu+S6yND4fSt2IYTYNS44BE52WUnOjXdsMiT4EgUBp2bINj/s10JERHrjiAg5kiw1LogiOOVDJBcDEXKMQ+CULFhJ2BkGcRSLa1MzBw8exD333IOioiJ06NAB/fr1w+zZs9HU1OTWUxIRuSZSSbht/ZxIJeGyiipFLfOHsooqjJq3CZOWbce01eWYtGw7Rs3bxPNG7gUiH330EcLhMJYuXYoPPvgACxYswJIlS/Doo4+69ZRElCSawwa27a/B2vJKbNtfg+awu4v/zCoJA+crCbvdDr9iEEeJuDY1M27cOIwbN67l//v27YuPP/4YixcvxlNPPeXW0xJRwKmYHrFSSdiP05RuTplwOwgy42mOSF1dHfLz45dWbmxsRGPjlxtf1dfXe9EssoBzvKSSqo0Wg1xJ2O3ALuhBHDnnWSCyb98+PPvsswlHQ+bOnYsnnnjCqyaRRUzUI5VU3lkHtZKwF4FdkIM4ksNyjsiMGTMQCoUS/vvoo49a/U1lZSXGjRuHiRMnYsqUKXEfe+bMmairq2v5d/jwYeuviFzBOV5STeVGi1Y25PMLr/JeghrEkTyWR0Qefvhh3HXXXQmP6du3b8t/HzlyBGPGjMFVV12F5557LuHfZWRkICMjw2qTyGUy7kQ5pUNOqbyzDmIlYa+mTCJBnNl2EH4K4kguy4FIt27d0K1bN6FjKysrMWbMGAwdOhQvvPACUlJYyNWPnF6wOKVDMqi+s45UEm77WS7w6WdZZmCX6EYjiEEcyeVajkhlZSVGjx6NPn364KmnnsKxY8dafldQUODW05ILnFywVCUXUvDocGcdpErCsgI7kRuNoAVxJJdrgciGDRuwb98+7Nu3DxdeeGGr32m84S/FYPeCxWV7JJMud9ZBqSQsI7CzcqMRpCCO5HJtruSuu+6CYRgx/5G/2E3UU5lcSMHEjRbliQR2ANp9t0UCOzvJrpEgbsLgCzCiXxcGIQSAe82QALt3oly2R27gnbU8TqZMWB+EZGEgQkLsXLBUJxdScAVlekQHsQK7oX06Y+cnJ7C2vDJuoMcbDZKFgQgJs3onqkNyIRGZiw7syiqq8K35m01XufFGg2ThelqyxMocr9M5aCLylpXChUEs8kZqMBAhVzG5kMgfrCaf8kaDZOHUDLmOyYVE+rOTfMr6ICQDAxHyBJMLifRmN/mUNxrkFAMRIiJylHzKGw1ygjkiRETE5FNShoEIEREx+ZSUYSBCREQAuMqN1GCOCBERtWDyKXmNgQgREbXC5FPyEgMRIiIfaQ4bHK2gQGEgQkTkE2UVVe2Kh8XaB4bIT5isSkTkA1b2gSHyEwYiRESas7oPDJGfMBAhItKclX1giPyGgQgRkebs7gND5AdMViUKCK6mCC4n+8AQ6Y6BCFEAcDVFsEX2gamuOxszTySE89VPuQ8M+RGnZoh8jqspgo/7wFCQMRAh8jGupkge3AeGgopTM0Q+ZmU1BUt2+x/3gaEgYiBC5GNcTZF8uA8MBQ2nZoh8jKspiMjvGIgQ+VhkNUW8gfkQzq+e4WoKItIVAxEiH+NqCiLyOwYiRD7H1RTB0hw2sG1/DdaWV2Lb/hqueKLAY7IqUQBwNUUwqChMx4q8pFrIMAxtw+36+nrk5eWhrq4Oubm5qptDROSaSGG6thfkSEjgxugWK/KSW6z035yaISJSTEVhOlbkJV0wECEiUsxKYToZWJGXdMJAhIhIMa8L03kd+BAlwkCEiEgxrwvTsSIv6YSBCBGRYl4XpmNFXtIJAxEiIsW8LkzHirykEwYiREQa8LIwHSvykk5YR4SISCNeFhhjHRFyi5X+29VA5Oabb0Z5eTmOHj2Kzp07o6SkBPPmzUPPnj2F/p6BCBGRu1hZldygTSCyYMECjBgxAoWFhaisrMSPfvQjAMBbb70l9PcMRIiIiPxHm0CkrXXr1uGWW25BY2Mj0tLSTI9nIEJEROQ/Vvpvzza9q62txUsvvYSrrroqbhDS2NiIxsbGlv+vr6/3qnlERESkgOurZqZPn47s7Gx06dIFhw4dwtq1a+MeO3fuXOTl5bX869Wrl9vNIyIiIoUsByIzZsxAKBRK+O+jjz5qOf6RRx7B7t278de//hWpqam48847EW82aObMmairq2v5d/jwYfuvjIiIiLRnOUfk2LFjqKmpSXhM3759kZ6e3u7nn376KXr16oW33noLI0aMMH0u5ogQERH5j6s5It26dUO3bt1sNSwcDgNAqzwQIiIiSl6uJau+/fbbeOeddzBq1Ch07twZ+/fvx6xZs9CvXz+h0RAiIiIKPteSVbOysvCHP/wB11xzDS655BLcc889GDhwIF5//XVkZGS49bRERETkI66NiHz961/Hpk2b3Hp4IiIiCgBuekdERETKMBAhIiIiZRiIEBERkTIMRIiIiEgZBiJERESkDAMRIiIiUoaBCBERESnDQISIiIiUYSBCREREyjAQISIiImVcK/FOROREc9jAjgO1OHrqLLrnZGJYUT5SU0Kqm0VEkjEQISLtlFVU4YlX9qCq7mzLzwrzMjH7pgEYV1yosGXWMJgiMsdAhIi0UlZRhftW7ILR5ufVdWdx34pdWHzHEF8EI0EJpojcxhwRItJGc9jAE6/saReEAGj52ROv7EFzONYR+ogEU9FBCPBlMFVWUaWoZUT6YSBCRNrYcaC2XecdzQBQVXcWOw7Uetcoi4ISTBF5hYEIEWnj6Kn4QUi0VyuqsG1/jZadeRCCKSIvMUeEiLTRPSdT6LgXt32CF7d9omXOhWgwJXocUdBxRISItDGsKB+FeZkQXVeiY86FaDAlehxR0DEQISJtpKaEMPumAQAgFIzomHNhFkyFcH71zLCifC+bRaQtBiJEpJVxxYVYfMcQFOSJjRjolnORKJiK/P/smwawngjRFxiIEJF2xhUXYuv0sVg1ZTjuHNFH6G90yrmIF0wV5GX6pg4KkVeYrEpEWkpNCWFEvy4AzienmtEt52JccSGuHVDAyqpEJhiIEJHWIjkX1XVnY9bmCOH8SIOOORfRwRQRxcapGSLSGnMuiIKNgQgRaY85F0TBxakZIvIF5lwQBRMDESLyDeZcEAUPp2aIiIhIGQYiREREpAwDESIiIlKGgQgREREpw0CEiIiIlGEgQkRERMowECEiIiJlGIgQERGRMgxEiIiISBmtK6saxvm9Nuvr6xW3hIiIiERF+u1IP56I1oHIqVOnAAC9evVS3BIiIiKy6tSpU8jLy0t4TMgQCVcUCYfDOHLkCHJychAK+Wtjq/r6evTq1QuHDx9Gbm6u6ua4iq81mPhagydZXifA16qaYRg4deoUevbsiZSUxFkgWo+IpKSk4MILL1TdDEdyc3O1+WC4ja81mPhagydZXifA16qS2UhIBJNViYiISBkGIkRERKQMAxGXZGRkYPbs2cjIyFDdFNfxtQYTX2vwJMvrBPha/UTrZFUiIiIKNo6IEBERkTIMRIiIiEgZBiJERESkDAMRIiIiUoaBCBERESnDQMQDN998M3r37o3MzEwUFhbiu9/9Lo4cOaK6WdIdPHgQ99xzD4qKitChQwf069cPs2fPRlNTk+qmueKnP/0prrrqKmRlZaFTp06qmyPVokWLcNFFFyEzMxNXXnklduzYobpJrnjjjTdw0003oWfPngiFQvjjH/+oukmumDt3Lq644grk5OSge/fuuOWWW/Dxxx+rbpYrFi9ejIEDB7ZUGR0xYgReffVV1c1y3ZNPPolQKIQHHnhAdVMsYyDigTFjxuC3v/0tPv74Y/zP//wP9u/fj29/+9uqmyXdRx99hHA4jKVLl+KDDz7AggULsGTJEjz66KOqm+aKpqYmTJw4Effdd5/qpkj18ssv46GHHsLs2bOxa9cuDBo0CNdffz2OHj2qumnSNTQ0YNCgQVi0aJHqprjq9ddfR2lpKbZv344NGzbg3LlzuO6669DQ0KC6adJdeOGFePLJJ7Fz5068++67GDt2LCZMmIAPPvhAddNc884772Dp0qUYOHCg6qbYY5Dn1q5da4RCIaOpqUl1U1z3X//1X0ZRUZHqZrjqhRdeMPLy8lQ3Q5phw4YZpaWlLf/f3Nxs9OzZ05g7d67CVrkPgLFmzRrVzfDE0aNHDQDG66+/rropnujcubPxy1/+UnUzXHHq1Cnj4osvNjZs2GB861vfMqZNm6a6SZZxRMRjtbW1eOmll3DVVVchLS1NdXNcV1dXh/z8fNXNIEFNTU3YuXMnSkpKWn6WkpKCkpISbNu2TWHLSKa6ujoACPx3s7m5GatXr0ZDQwNGjBihujmuKC0txfjx41t9Z/2GgYhHpk+fjuzsbHTp0gWHDh3C2rVrVTfJdfv27cOzzz6L73//+6qbQoKOHz+O5uZm9OjRo9XPe/TogerqakWtIpnC4TAeeOABjBw5EsXFxaqb44r3338fHTt2REZGBu69916sWbMGAwYMUN0s6VavXo1du3Zh7ty5qpviCAMRm2bMmIFQKJTw30cffdRy/COPPILdu3fjr3/9K1JTU3HnnXfC8El1fauvFQAqKysxbtw4TJw4EVOmTFHUcuvsvFYiPyktLUVFRQVWr16tuimuueSSS1BeXo63334b9913HyZPnow9e/aobpZUhw8fxrRp0/DSSy8hMzNTdXMc4V4zNh07dgw1NTUJj+nbty/S09Pb/fzTTz9Fr1698NZbb/liuNDqaz1y5AhGjx6N4cOHY/ny5UhJ8U+8a+d9Xb58OR544AGcPHnS5da5r6mpCVlZWfj973+PW265peXnkydPxsmTJwM9khcKhbBmzZpWrztopk6dirVr1+KNN95AUVGR6uZ4pqSkBP369cPSpUtVN0WaP/7xj/iXf/kXpKamtvysubkZoVAIKSkpaGxsbPU7nX1FdQP8qlu3bujWrZutvw2HwwCAxsZGmU1yjZXXWllZiTFjxmDo0KF44YUXfBWEAM7e1yBIT0/H0KFD8dprr7V0yOFwGK+99hqmTp2qtnFkm2EY+MEPfoA1a9Zgy5YtSRWEAOc/w3653oq65ppr8P7777f62d13341LL70U06dP900QAjAQcd3bb7+Nd955B6NGjULnzp2xf/9+zJo1C/369fPFaIgVlZWVGD16NPr06YOnnnoKx44da/ldQUGBwpa549ChQ6itrcWhQ4fQ3NyM8vJyAED//v3RsWNHtY1z4KGHHsLkyZPxjW98A8OGDcPTTz+NhoYG3H333aqbJt3nn3+Offv2tfz/gQMHUF5ejvz8fPTu3Vthy+QqLS3FypUrsXbtWuTk5LTk++Tl5aFDhw6KWyfXzJkzccMNN6B37944deoUVq5ciS1btuAvf/mL6qZJlZOT0y7HJ5KH6LvcH7WLdoLvvffeM8aMGWPk5+cbGRkZxkUXXWTce++9xqeffqq6adK98MILBoCY/4Jo8uTJMV/r5s2bVTfNsWeffdbo3bu3kZ6ebgwbNszYvn276ia5YvPmzTHfw8mTJ6tumlTxvpcvvPCC6qZJ9+///u9Gnz59jPT0dKNbt27GNddcY/z1r39V3SxP+HX5LnNEiIiISBl/TeATERFRoDAQISIiImUYiBAREZEyDESIiIhIGQYiREREpAwDESIiIlKGgQgREREpw0CEiIiIlGEgQkRERMowECEiIiJlGIgQERGRMv8fkOjHBhF8NrcAAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + "x1 = sample_moons(batch_size).to(DEVICE)\n", + "for t in range(0, 900, 100):\n", + " tt = ddpm.sample_time(batch_size)*0 + t\n", + " out = ddpm.interpolate(x1, tt, x0)\n", + " plt.scatter(out[:, 0].cpu().detach(), out[:, 1].cpu().detach())\n", + " plt.title(f\"Time = {t}\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the inference time schedule and sample from the model" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "schedule = DiscreteLinearInferenceSchedule(nsteps = 1000, direction = \"diffusion\").generate_schedule(device= DEVICE) \n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " vt = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step_noise(vt, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dreidenbach/mambaforge/envs/moco_bionemo/lib/python3.10/site-packages/IPython/core/pylabtools.py:170: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAHiCAYAAAA597/kAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/WmQJHl63gf+/Ah3j/vMqzKzKuvs6mu6p7tneog5MCAOgqAIHqJkswBNB7XcpXZXMtK4H7grma0+aG3N9EG7tlyzJQmBK9BkEkgjRYCDi+AAmJnGYLpn+u7quo+sysoz7svvYz/4UZFRkVlZ1dXT1d3+mJVlVmSEu0d4uD//932f93mFIAgCUqRIkSJFihSfKMRP+gBSpEiRIkWKFCkhp0iRIkWKFE8EUkJOkSJFihQpngCkhJwiRYoUKVI8AUgJOUWKFClSpHgCkBJyihQpUqRI8QQgJeQUKVKkSJHiCUBKyClSpEiRIsUTAPkoT/J9n62tLYrFIoIgfNzHlCJFihQpUnxmEAQBw+GQY8eOIYoHx8FHIuStrS1WV1cf28GlSJEiRYoUnzdsbGywsrJy4N+PRMjFYjHZWKlUejxHliJFihQpUnwOMBgMWF1dTbj0IByJkOM0dalUSgk5RYoUKVKkeAQ8qOSbirpSpEiRIkWKJwApIadIkSJFihRPAFJCTpEiRYoUKZ4ApIScIkWKFClSPAFICTlFihQpUqR4ApAScooUKVKkSPEEICXkFClSpEiR4glASsgpUqRIkSLFE4CUkFOkSJEiRYonACkhp0iRIkWKFE8AUkJOkSJFihQpngCkhJwiRYoUKVI8AUgJOUWKFClSpHgCkBJyihQpUqRI8QQgJeQUKVKkSJHiCUBKyClSpEiRIsUTgJSQU6RIkSJFiicAKSGneGj4vstotIvvu5/0oaRIkSLFZwYpIad4aOh6G11vouvtT/pQDkW6cEiRIsWnCfInfQApPn3I5er7fj6piBcOAIXCwid8NClSpEhxOFJCTvHQEEX5U0Fwn5aFQ4oUKVJAmrJO8SnDw6Sh44WDKKbrzhQpUjz5SAn5c4xPY43101K/TpEiRYqHRUrIn2M8iNwmCftJIe9crk4uN3fkNPSTctwpUqRI8SCkubzPMWbVWH3fRdfb5HL1faIoAF1v4vsuoiiTy9U/kVTwZP168lgPOpZU2JUiRYpPC1JC/hxjljhrksA0rcx43ETTygnhhST4ZBDcUcg2FXalSJHi04KUkFPswySB6XqbIHBpt68zN3eeQmFhX4T8SeMoZPuTVoQfJWpPkSJFillIa8gp9mFSmZzL1QkCGI/3GI12P+lDuw9Pkoo6rlWPRrup6CxFihSPhJSQUySYFkCJokw+P4coSsnfm83LjEbbCfl8UmKpJ02sNZk+fxjRWYoUKVLE+ORDixRPDGbVZOMIVNPKNJuX8TwLSVKj539yteSflFgrTkFrWhnT7B+Yip5Mnz8JEfsnhTRlnyLFoyO9YlIkiElF08qMRrvJTTWXq0dkbCJJGnNz5wE+kVryJEFOHvPk3x4nGcTEPx43EYTwsVkLgE+Le9mj4qifbapqT5Hi0ZEScor7oOttTLObCLh838XzLCxrxPLy+eTGHAu/fpLR0GE3/I+DDCYXKXGE/FHxaYwij/rZpqr2FCkeHZ+Ou0GKnwjim66mVcnl5pIWJ02rIkkq2axMt7tOEHiMx02y2Sqm2QV+ctHQQVH85N8eJxlMRr6FgpY8/qikGtfhg8CNtvnpiCIf5bP9NC48UqT4JJFeJSkSTNdB4wg5Tg9DSISbm2+iqoXouT9ZAdNkCj0IPOAeqU2njR+WEB7m+YdFjIdtJ2wl8xCEe+n+J5W4po/rKIuHWWYy8OlZeKRI8Uniybn6U/xEMYsEpm+68f9Ho11Ms0suN4dtj8lmqwiCdOSWo8dNOHF/9CSpzdpnXPcej5vMzZ3/SCQ7jcMixsO2M0v89aTWXR/luGZ9LrOyGSlSpLgf6dXxOcJBtpgPivBm3WQf5ub6uAnnKIrmOBK1rBHZbAZdbx+ZZI9CIIdFjIeR9azXTe53MNgEeCz91R91ITT5Po66ren3Fy/onsQFR4oUTxpSQv4cYX+v7GzSmK5x5nL1faYgR01dTt7AH3dt9yA/a+C+fTYaTx1ZjBVvdzDYpNO5Tq12hlJp+aGOLe6PfpT3Mxrt0ulcB4LksY9Cqh91ITT5OU+T6qzjmn7sMEX8ZwFPaqkhxacX6bfoc4TpyHLWTXq6xqnr7ftI4iiYJoOPKzI6rGYZ7zOXkx/hxhk88vF0OtcA4aFboXK5OrXameT3eHuPQqrxhK5QoHf0yVgHfU7Ti6pZxxUuKK5Rq52lVFq+bwH4WSOvJ7XUkOLTi8/GlZHiSDgKQcQDJer1M0m6epokjoLpG/jHFU0clE6fxMMKsCatQx/leGq1szOP47B9Qnh+piPyR1U3x1mOQmHpsZQWpr87s9LZoWuakBzD5ILgJ23k8pMg/rTFK8XjRkrIKfbBNPsIQvizUNBmksQkPgnDiFk17vj/s7Y9ObXqKMf1UUw+HvR5HbTPw7Z31BLBZKp8Wsl9FDwMwcxKZ2talUbjfHI+TLOLplV/omnrn2TU+lFV/SlSTCP91jxBeBIu6IeNbHW9zWi0c5+SefrG+DijieltP+gmPL3IOOz9wsd/Hj6OyGoyVV6rnaFQWHzg8R/0PifJ/Sjislkiu/gx1zUfuR7/IMw6/jhij//9JK+jj7oYeBKu/xSfLNKz/gQhvqAnRxw+7IV5kMjpUduTDrrJTAp2xuMmQeDuUzJrWpnhcBvbHjEYuI+1jjythn5Q9PWwquePO8o6KOo97IY8TZLxcU5mCeJU+SSJHubFfdDCZjxuYhgtjloHn/Wc+Jh2dy8kA0A+jva3WdkNUZTR9eZP3M70URdakyn/n7TRToonCykhP0HYH5U+HCHMuqjh4YwZZt3gDrrJTAp46vUztNvX96WEYzGYafYol49jGN0j9QIfBZOq5KO8v0cRV03+/DgxnWo+6Ias621arctYVp/l5VcT0omfe1Cq/DAv7un3mcvVcd2wb7tUWkWWtY/0GdwTCEofSx35oPP0SdV2H+Z7NqsFMXbIS2vSn1+khPwEYbLV5WFFRYdd1EftI511Izv8JhPe4eOU8OQMYNc1owWCRxAEBIF3pF7gh8GDbrwPijgP+ttPMrKaVLHXamfJ5eZm9kFrWpkggEymkPx/si5+0PuZzCZMt3/NMoKxrCGDwQayrFGrnX6k9zSdPclm5X37/jja347y+KPg40ojH9SCmKaqP99Iz/4TiEe5oRx0UR/UR/pR9zv5PE0r4/tulOoMSTkIQNMqiKKURMYfta53UDo+fn/T7/0nPYjiUaAoeTzPpVpdSyLdWX3Qptknn28kDmmj0S7jcTgPemHhuQNr+Qd5ccNssqnXz+z7+aDnz/r7ZJZmbu78vtc86UQ5jY/rezK5UErrxilipN+ATwkedAN60M3uqNHJwzgyTdbqAAyjjaqWEUWZIPDQtCKmOSSXq2Pb449c1wtJZ/u+wRbh3+6/aR72nh/35/Go6HbXse0BjmMk23ddk3b7apIyNs3+vjr5vc+7i2F0yefnKBQWZtbyD0NsRDJJ/LKssbDw3H3PPcpQjFlZmo8r2/CTWlDNau/6KJqMacRqdEjrxilSQv7U4HG6Lj2u/UzerEajXURRolhcSgRCoahrwO7uBWx7TLW69kiCl7jGmsvVI9Lxov/PJTfKWW1ND2pLeZjP46MI7Q7DrIjUsobY9ph+f4NMJj9zDnOhsECtdibJSIiivC8aPQp838Uw2vj+2qHPiaPeB7VSHZSledyLmsNMTx73vg5zKztsv/cWMN7M56d14xSzkBLypwTTyuInoSVnfzp0YR9hFQoLKEoe0+xhGB3a7auIonRfXfIobVWTzlfTKVDfd2m3rxME3sy2pultPWixcZCPd7gw2D7yoIqjQpa15D1pWpiajslZ00oIgpTsP1Yrx8cXp6rjY3zYaFQUZbLZg1P+8b5i4nhQK9Vh7m+Pupg8SPkfDzs56HgfZV8PwkHXxizyDQVtBw9ASevGKWYh/SZ8SvCwyuKPup+P+jrfd+l218lmq5TLq2QyOZaXX7nvdQ+KQHO5OpXKSQyji6aV79vPg2588bEcZE4xfcOfvqHHxzQYbDIet8lmK0dOCT+sacqkEnpp6cXkXAcBCAIThPTolqSTxxS/v0lVf6z6nV6QfJQ07UcRcz2M8v+j7utBmBRdTi5gJr+Ds1rxjlJiSnuQU0BKyE8EHuZi/KRaOg7CQcc+eZOqVE4cqNh9UKuXKMrIsoYkyQ809rhHLkfrpZ782/Ts58nPV9fb9Hq3EASQJPXIn/2DorXphUIs8Imj4Wnhz+Rjj3L+Z9WBp1X9sxYkD0P6j9v57CDl/+TCId7vx1mzhoP7hSftZk2z/0gL5idFZJjik0VKyE8AHjaVOh3FfJKYPvaDSGaWMQUcrdXrMBKaFTE/SkQ1vSCYjIImo/Rqde1In/1RhjuMRru0WpdR1TLF4tJMU4vJ99bpXMP3XWRZmzjmo38P7vUFy/cRXKGwgOuaDIfbZLNHH0gxjY+jtWnW9z0+z65r0u3eQlXDdrDHbcs6icn0vaZVk3M86QT3KO//UQaBpPhsIiXkJwBHuYgnicb33X1TdT4pzLqRTBNinHadZUxx0DYnCXzy53SbU7ytyRvnZH/udHp2Fg5aEOh6m8HgLs3mJVZXv5JE6d3u+qHvYzqKir2cJ2/wMdkPh9uJUtpxxsn+D7Z+FDCMLpJ0bzudzjUqlZOJIvswYn5Q+rndvk6vdytZGADY9ojNzTdZXn4FRSkcuO3pz/MoOGqf+GGLrOFwm7j/ff/i6vGPrJz8/OLnzUrrH+X7fdSaeIrPF9Kz/wTgsIt4Vv0zJCPh0G3+JGpSs24k04uLybTrYXOJp+uo8c/hcBvL6qGqlYSIgH0jIeMbpKaV9wm8wu0+fOYhJnPD6GGaXdrt68zNnX+o9xGrZ+PIezot3GpdZjxuoWlV6vXTyLKGouRpNi+jqkVse7jv+YqSJwgCqtU1XNdKvge+79FsXkaSMjQaTx26QDss1QugqkUqlZNUq2tJdmBz8022tt7CMDqcP//LM4nzYXyvZ31Ws87PZCkh/NxnR4/xVLL45/RrH0YZ7/surmviee7MQSSTOIyEjxJlT77neBHmuiaDweZMa9QUnw+kZ/oJwsGtE/ujpUmx0UH4SdSkDqrvaVqZ3d0LZLNVSqXlA40pZm1rOjJ2nDHd7i2KxWO4rp0IuyZHQsY2nqpaQRC4LyV7mDJ9OvPQal0mCCCfr1Ovn8GyhsnN/t4NVE6IO47Ops/JdIp+UqVdr58hm60n0a6iFCgUFtjefpednXeYn3+ecnl133vzPA/bHtDv351QZZcRBIkgsJMFyDRmidY6netcvfq7HD/+VVzXSPq6bXtIPj9Ht7ue1JmXl1/BMDqUSiszxWzTKviHEbsd5kE+Ge3Oih4nz9t03/SDdAkHIdQKrAPBTL1C2Ad/z3zloG0+KMqezoDE/yY/x3A7aU3584aUkJ8gTF/wkzW/8O9HV9f+JMRfB92A2+3r7Oy8g6pWkGVtX215lghnelsx4YWEFEYrvd4G+Xw9ulEu3BcJ+r6H77tJH/Tk4mVamT4dFYf7DMnPMLr4vkcuV6dUWj6wFWs02qbZvEQQePi+R7t9jeXlV7DtMYqSZ2PjdVS1uG/bQQAQWohms1UqlTU0rcRwuI2mldG0Ep7n4XlWEhmGEKhW13Acg3r9zL4FSDZbRdPCn+Hn4B5IXIVCOHXr6tXfpdm8hCznyOfnCAIPVS0mEX0QeAQBSb36/PlfTj6vWW1htdrZJMLr9W4n5/KgyO4oi8XJunassJ/EUXQFh+kSZkHTyqhq+cAaei4X9sF7nkmzeTnJmkx/rw9baMzSCcTPnTVHO60pf76QEvIThPiCj92Wpm86D3NzOYgsZ0XhD5sae9Br6vUz+L6778Y2eRMO/3+wwcLu7gUMo02jcT5xoBqP9wiC2Y5JuVw9ihRdDKObbHMyEpuMSqYJYbKXOjbbyGarUatTk3x+bh85x+dJVYt4nsP29nsEgYfrWkiSjK53AT95bri/VvT/BkASidn2CNPsRj3BVbLZCs3mRVzXTN5b/J5CBW87ImuBbLaa1I4na5qHuZWJoswzz/x1bt78Y+bnn2UwuIttj/c9P/5exMc1+RlNL25EMRxqEQrULqHrXXK56qHfv6MKmO71mLv3RaxHicYfVnFtmn0kKVT1H9SqNDd3nt3dC4zHu6hqEcsa4nnWfe5xh5VIZr3/+HOcRBoZf/6QEvIThPiCP6iF41Ev0Eliimus8fYeJbU9y3Jx+n0Ui0v7CHtWRDOLXHW9zXi8R79/B1UtUygskM/PYVk98vkwbTka7e7LJJhmn2y2imF0keVsklqdfG9xVBJjFiHEn3+7fR2A7e236fXWqVTWkkh/8nm6HrqRiaKArg/odG4k0Womk2V19SvJ5+95DpbVJ5+fSwg9jG7LbG+/S7m8gm2PqVTWMIwSqnpPlBYEHpubbybbqFTWopnHCwd+vtNp4cn/2/aYY8dexvddVLVMrXZm3+dzWHR5UGQaR3iVyuFR6cMImGK/7my2vq/sEG/nKIvIoyw4Z3UGTJY4prcRfx8No4sghM5q2awUfQ6Hu27Nev9pD3KKGOnZf8LwcfRRTgqmPM/EskY0Gk8B908NmsThN4rggfuDg3tR49/DQQr3FOO5XJ18fh7L6mNZ/YRcp9WscSbhnq1mg0bjqftaT+5FJOH79H0X2x4eeEOMW1hEUWZp6SVKpdWERCcRH4/rmiwtvUS7fYPh8C6SNM/i4heSY44jyni7sD8Sc12LfL5Bv3+XIPAQRZn5+Wej53VRlGJSax6PWwSBh2G07ysFTJ6/SeeoaZFcmG3Ypdu9RRBApXIcWdYSd7DJ2macMm42Lyd19IO+D7MivFnfpaOYs0w+bll9arV7/b2h2K57qKf25Dane4ZnPW/aZWs6CzA5ajTWRMRaCdPs02ic36d7OOx9zVrQpD3IKWKkhPyE4kE11+nnHKXdJY6Qs9lMkgI0zT5B4CVK4sPqjzEeJCp7+Pr1PcW4KMosLDxHPj+XbGNWL+rc3PkogmoiCAKFwmJEUvvTmhAqslW1jCTJ0bb2E+zkDXeypieKoanJQdD1NrY9pFxepV4/w/Xr32Fx8fl9kassq2xtvU2jcQ5VrSTvI+xlLTMYbNLvb1IsLrK3dwlNC2uY4Q2/mtR0LctC00pksxVMc4jjjGk2Lydp0niBEkfeQeASBKAoWQyjm6S34+hPlnOIohSl+kNV+qzaZrt9PRIbQT4/98jEcdB3aRYhTp6/bPZ+C9MHeWpP7u9BXtFhBmK/09vs7+/+7+i983hPvDf9Hg9bmE73ud+/vxSfR6SE/AThoN5LYOZovaOurCdvArH4Z1a0Oa2inY40D0qlH7S/g95bfOy5XP0+co+fNy0Kmn6vsTgmJJMhtdrp+9KMca9v/L4P79UVcF2T3d0LqGoR33eTiPmg1OXk5xPenEtsbPwAWdaoVE5gmj1++MP/J45joyhFnnnmK0k9WRAkfN/l9u3vYxhdWq2LBEGA5xkYxhKSFBKyYXQBgVyujuOM8H0f0+ziOENGoxYnT36DeIZys3kZXd9DVYsUCktJn7Kud3GcEY3G09j2mHy+HmUi5va9x/jzn2y/mRx+MR3lHXR+H/RZTWIWIcaY/G5MfocP2uckJvd3lMVq3HJWr5/ZV56YPo7J49b1ZtRL3iabrScir1nEPqs0cxSR5nRffprW/mwjPbNPECYv0umLehZpHpZunoXJ2u+kuvmgKUHxTSiOROMI7FGGKxwk6pp1g57lqzx549zdvUC9fmZCXBWwuflmstiIo5PQ2cojn19IRFGzEN9wh8NtdnbeSVK5giCRzVb2bXOWraRp9lhffy1KCXdoNj8E4Pr1f8dgsIksqywtvcBotIvrmozHLbLZMobhUiwuUygco1pdw7KGyShFXW/T728kNWxNK6HrHUajJjs77xIEPoIgsblZ5Pjxr6Dr4aLDsvr3kddkXTdULff2GX3EWYU4HRxO6RqxsvJlSqVlFhaee2A2Zvq8TVt0HrSIO4w4Z71mUqUc13Djfcx6bbwwe5BT3O7uhSQTMN1GNes44mtPVYv0ercAkg6A+LOcbI2bTp0fRtazPtejGuuk+HQjJeQnAOH82+tUq2tJDQ/2X3izSHPSsu+wHl8IbxBhDdW77/EH3Wg7nev4vocgiGSzmfsi6QftV9dDY4t48TAZaU2bOEwqokej3X03sckbZ9ziVK2usbn5JplMFkGQ9qXn47agWAV8kKtVfMONFzaKkqPX20BRsgemMuPj832X69f/kHb7KtXqafL5Orre49q1P8BxLObnX2B+/mnu3v0xICDLCtlsFUkK67bF4lKSRnYcI4lYAXq927TbV9G0KoPBXXZ2PsA0Q7OSavUkoiihqgW2t98im61Tq52h0Ti/T5RUKi0nxzoYbNJsXqbfv43ve5w8+dP76ujN5mU8zyIIgqidy03+FirfO/vMR6ZV7LFQTtfbeJ6FZQ1pNM4f+v2YlcJ90GJv8hwfZtIC9xPaQWYhs8ZgTmOW1kCWNZaXv7xPxQ8kC5J4v9Op80mSP2xgzMO81xSffqSE/ARgVp1uVt30YWpP00Qb9tiGqbXJiz72U85mw3F+s1J/kyYc0zeFWYQ+K/Ue35jiKGKyVnvvNfsV0ZpW5c6dFru7t1hdXeXUqSXK5RV0vUUmk018oLPZCoIg74vc4xumZQ0n3s1+68npWqZp9pORhtnsEMPoUSgsJs+ZPAfN5mWGw00Gg02KxQVEUeL8+V/Gtsfs7X1Iv38HEKjVTtHp3GB39z0qlZOcPPkz+3qlCwWNXu82H374ryJCblCpHCefn6NSOYEoSuTzDXZ23icW0tXrT1GrnaFWO4kkKUnNOd7mtFBO10NnsG73Jq7r4rpjgsDbt7AajXbp9zew7TFLS1+I1ONyQsat1pVkFGSM6XMbC+XizEU2u38gyGGLv2nl/mHPnSSzBy1EJ4V990o9+8kv3lf8OR6EycUjgKIUk+1Mtp0BSZ07Hjhx2ELjKNHyxyH2TPHkISXkJwDxqrxaXYvUmtV9ZAb3bh5HrT1NR57xz1gsNdlCYlmD5DUHpf50vX3ofqaPcdKVCvY7cE1GQpNq3skRiwC/9mv/I//sn/1D9vYcymWNv/23f4X/8D/89zHNLrKs4fsermsiyxq12v6hD/dq4/eIRxRlFCVPt7t+X5pf1+95Vy8vv4IkqQhCKAizrOE+sg9T+Ht4no8sq4iixhe+8CsAbG6+Rbt9g0wmG02GqtFu36Bef5pjx76YtINNHut43Ewi+Gr1DLY9oFo9ydLSF5Fljdu3/4xe7xbl8nHm55+lUjmRDKO4J9SrJjfzsC+2RSZTQNPKdLu3GA53IntOhWr1JSRJve8zGI12CAIP29aTSLvZvMx4vIcoSlQqYQZnMNhMyCMWp01+ppNlkFi45nkWnc4tVLV4SNnjnnL/cSmP4+9Y3Go0XdOO9zXtNha/T8PoUq+fwbbH+1rITLO7byzmrMXxvYX04YuGw6LlVIH9+UJKyE8AZFljYeG5JEU7GWnAbOeew6LiyRQikESbjcb5hAwmCXN5+cuHbnOyhWa6jjyrjj1JhpN1tUJBOzA9tz/9vsD6epN/9s/+IYWCTalUZ2PD4Nd+7X/mpZdepFQaR+1I84zHu3iedd/Qh+naeHzTG412EYTwJjyZugzrnpfQ9Rbt9nXy+TlUNWw58jwrsQKF0F97PG6iKHls20BVTW7f/kEUTX7AYLCJKMqsrf105FwlkMloSFImyUbEUfq9CM4hm62QyWjMzT2LJGXodtfxPBvT7JHPNzh37i8iCBKqWkTXm1jWCEUpsL39NqY5oFRaodE4gyDIiKKIZfXZ2HiD27e/DwQsLX0JRcmRyzWw7eE+ZX2hsMCpU38+UWnH35Mg8Mjn52k0nsIwunQ61xFFKanfalqVdvs64/Eevu8mWZbJz7vTuUardR3bHlAqHafROLNv8RfW1ZtUKicTMpxMgcclnVhw9bCYrlNPZ0Z836VSOZl8D+LvfKt1GdseJp9//N2aLK9MRr+PwzNgVnlk8meKzzZSQn4CcFCP5kGilgdFxWG/cVjDW15+5b6a2XT0OKumNrnNWAVbr59JjEXiG2pMpNPbOUgoNplCnEwjTtbKRqNdbt++xd6eQ6lUxzCyVKsa3e4m/b7A8eOnmJs7jyxr+1TjsXgm3u6sz2pWijx+7fLyK7Tb1/E8i1brMrXaGfL5OcbjUE27vv5dcrl5XFfH9310vY0gCHS7d3FdnWLxGLXaqYgsTfb2PuTFF3+VO3d+iOeZbG29Sz5fp1hcYnf3Q+bmAra338M0W8zPfwHX1Vlc/AILC8+xvf0umYxGr9elUGhQLp9IRg1WKmvY9hjT7KEoOUCIau0BxeJiZOE5ot+/S71+miAIyOfnkWUF2x5gWcNEoT4a7SbnLUyRyxHp3ssyxAQauqUFiSmJafYjbcIee3sXyOcXk9r+pDK5VjuLLGfp9+8wN/c043GTUmklEec1m5fZ2XmHxcUvUqmcuG9h2mxePlBwdRQ86JqJ9zUZpQaBR6WyhijKSYQ8fV1OKr4Pw8MYf0wfa5qq/nwhJeQnAA9KSz1Kv/GtW99jb+8CilJgefmVfc+bJMxZxDRN3vHPWUQ7TXCTopnpGt3kdsNpTdxnJhHfIBcWimhajr29Mbmchq63KZcV6nWZfL4ReUYX9r0+rj1P19snjS4m/xZHObGYKa6R6nqH8XgHVS2TyWhRXb8NSPR6dyiVjiGKYJoDPM+kUJjHsgSCIMB1DVzXZjS6jSyL3L37I5aXX+bGjT9G0wpUKmtsbLzFrVt/wPXrWUInskUymSzl8jLt9rVkoSEIEmfO/Bzb2+9SLC6xvv4aw+EmYW36NLlcHVUtUiotYZojisUGS0svYttjOp2rDAabmGYfVS2Ry82xuvpqRNJnEl1B3Mcdfx5h6aCN768li63RaJd2+zqG0SWfbyDLWtLzHVp/Dshm53BdnV5vHccZ7fu8YzONSmWN4XAb0+yyvv59hCilEXt4+76dtJvF3y3fd5MpVIcJrh4VD8pCxd/XWaMnJ8tCsUK9Wl1LPuM4mj/s+n4Ysk7x2Uf6DXgCcFBaKk7VxeP44P7hCAcJPzStjOOMD+3bnCSmuL1p2hLzoBX7pLhscjuTBD9d9558zrTT17SRw0svnee/+C/+M37jN/4R3e4mgpDn7/yd/z2vvvpLBwrLpq0Pfd9lb+9Dms2LzM09MzPaiGuunc4tPM+KSLpCuXycXK7GeNyk271DsbiA7ztkMgrd7k1yuQauq1MqrdJonGU02ubWre9Rrz/D8vIrrK5+hcFgB9seMxrtUSwuMBzuoGklbLvPcLiLKEpY1phstk4mU6Hdvo4oZtjYeIPl5S9SLC5j22Oy2Qrd7jqZTI5jx75MoVDHMDrk8/MRse5hmm3G4y1yuXlOnvxplpdfxXG+h6pWCQKfIPDodteTCDNejMVCPwhryMPhLr5/z4fbdU3u3Plh8rxa7cy+zz6cDGXjOGMWFp6jWFxKVOyzEC8GisVFdncvUC6v0O2uk82WsaxhknmZzHjY9jDZ7uPGLPHkUaPSycXo1tbbWFaPbvdmstCYrKNPPn8SB7X5zSLnlLw/+0jP6hOAg24Asfq6UjmZtMfEAw/ii37yIoZ7hhvF4hLz889TLC4l24sV1apanlL6Tu77HlEeZkoQk3fs8zxJhtPTeaaj6LCe/XRCnJM170lDkP/yv/wHfO1rX2Nnp8f8fJHz58/vO974+MKfrX1TsuL9CIKELO9viYLQsnNz88cUi0s4jomi5BkOe0iSimH0WF39EpKksrf3Ie32FSRJQ5Zz+L6LJCk4joFl9VHVpxNltiAEOM4ARZnD8wxMs00QOMzNPY1l6TSbl3Bdl/n5p2m3r9FuX0LXm4xGO6hqiaWlF7lz5we4rsPdu2+wtPRFarWzCIKM55l0u9d5/vlvkcnk6XRu0e/f4eTJn+HUqZ8FZPb23o3ee5vhMCTX4XCHRuM8tj1kb+8iECr5TbOL590T+hUK4RAP0+xMqJHbGEYXw+jQ691CUUoYRndfViIsY1xFEIbo+h71+tmZmZHJRVk2W6Xfv4uqFqPUfA5Nq+0j+/j5ilIkCDhyr/1hOIjQJjUVsbnHg2Y8xwtSCL/fx469dF+EfBRB1uRifNbzJ495snUvPqaDji/FpxPpmfwEMXlRz7qwqtU1dL2VDKW/1xPsks8v3BfVAvsi3FmRiq536XZvRTfabiLqiSPpSfvIg0wJ7vU0hz8dZ4SqViK/5cn2pjCimRWNw/29mnHNcPIm9Mor30wWEp3OtX2EPE28sXFKLDTL5eqcOPFVJh2n4qh+PG4mIq56/Wwk4spz+fLvYRgtVLXI6dN/nvn5Z8nnF1HVfNTq1MQ0d/A8D8sKI7dm8zKl0hK53CKWNaDfX8d1LYrFFUql1cglTMEwOqhqk7t3R4xGe1QqJzGMAbKcp1hcQNfD89Hp3GZt7ZvEDl2aVuby5d+l39+g1brB6dM/QxAEjEZ73L37Y5555q9y8uTX8H2bev00ELZ7jUZbFIsrKEoRQQjo9zcQRRFVLeI4ZiRmWku+e2GaXE5qp7oeCrxqtdP4vk2nc41CoZ4s5iAUJJ4790vs7l4AQuOWeJE1OchkclEWG7bEArVwOEMFw7g3XWry+bFGIUZ8vA8bMU4T3uSCc1JT4fsum5tvoKrlmYvle21vW1jWgFrtDAsLz1GpnIiuzYNFmdOY3P6s9qdJQ5EQYeueZfV4mBnUKT4dSAn5E8SsdotJhDaH4eABQQj7HuN5rftn9U6mf8PfZ6XiCoUFqtU1Op0bURrznvPXpLgFQuJSlDz9/kYi1JmMXgRBIJuNBVpe0sMZ19PiGb9he9L+Wm68jVm9mvG+J72lY+KYbleZvIHFit74Rjap2I7TtKPRLr3ebe7c+UEUyS1Rq50kCELP6Q8//Bd0uzfQ9Sat1lUWFp5FUfJUKmvkcnUymSwXL/42pjnGdQ00rYgkZbl58zuE9eVrSFIBUZSpVleo158in69x8+afIAgCpdIKoiizs/MOnc5FKpVTFArHGI3u4rrP4jgGe3vvUygss7n51kQ/bgfH6SMIIkEQ9gUHgY/r6jSbF7h1q0a9fjpShfeZn38W2x7jOCaG0aLXu42qllHVEiBgWUN6vXUGg7usrX0zIZJwYRQkEXOManUtitxtDGOYkO5kileWNYIgHJdoWT1UtYIgkMxVjv95noUkaWQyoR4hbidqt68zHG4lC8qFhef2Ka7DxZuPLCsTqvjZHtgHYZogJ6P2WFEfO2uF11l9Jpne++6GmgPDaO+7jh5mbvkkZrU/zTIUiY9x8r2k+GwgJeRPELECNf591t/hXg9vmC7dP681jvZ839138cdTegyjTa12JomWi8UlDKNNEAhJD2kc0cTbm4yM+/0NLKuHohTuE3rFKejYmjLeXxCAbQ8QRTlJ53Y616IhB7V97VL3vIPvmUeEbUUtKpWTM1Wwk4j9p+NIfzTaJgggm63iOGO2t99N/mbbI27f/lNsW0fX29Rqp/E8h9FoKxJ2uRQKS2SzVXR9hzt3Xuf48a8kPse63olqpg6ynGVx8ctIkki7fZUgEBkO7yLLKqXSCTxPR5ZVms2LGEYHEFDVAkEAy8t/DlXNc/z4N9jaeovRaJutrXcolZZRlDLD4SZBsECnc5X5+edwHINSaZW5uWexrGGy2KnXz7Gz8w7b2++gaSVcV2cwGNBuz5PLVcnn5xEEkVbrA4rF41Sra+RyDcrlFXZ338eyxjjOOPkMt7Z+DIjJAipu72o2L7C3d4Fq9SSCEJZSBEFgONwmn59LlNbZbA1NK9HpXEcQRFzXoVY7ia632N39MLGYzOXqZLNVut315NzU62eiBZW3j+AAut1b6PougqCwsvKliZYsNyF81zUfaMAxveiNv4Ph+38fVS0li7jDOg/i162uvpq4qj3uNqVZwjK4t/A4bLJWik8vUkL+iPgoQotYgXrY36drxDGZxRGKafajUYW9hKhHo23a7Wt4Xii2iXtGYwKUJBVdb2NZQ2RZu69uNbkQiI0c4oELwL7a2eQxGkZYcywUFvH9PIqSw7ZHDIfblEqrlEqrWNYwWWBMp7Z932V7+122tt5C0yr7IuJpQxEI68AXL/4rYjvQhYXnosWJRbt9nW73Fo5jsr39Nisrr3Ljxh8iijKKkqVYPIaqlrDtUWT+8DS+b7Gw8AK+b7G7exHb7jMeN7l163tsb7+LYfTZ3X2XTCaPqhaQJJkgIEpFFxFFlUbjeer1U9EM3wJBsEImU0SWs+ztXcDzDObnz1OpLFEozAMuohiQyzXQtAqCIFIqLdLvb1IoLGPbIyQpRyajMT//NFev/j6u6yRp41brKpbVQ9ebNBpPA+B5Fr7vs7z8ZRQlnDaVzZaRJBVVLXDz5ndpta6h63vs7l5AklS2tt5ib+9yFH21sO0RzeZVOp1rdLs3MIwetdo5fN9jMNgmlyuzs/MBilIkl2sgSVJiOgNw9+6PUJRSdG4COp0bjMc75PNLKEo473myvztcrJXJ5cKhF/H5dl0Tz7MRBIVa7WTyHZ9cFJpm91Bf64Mw6eamqqUkIn5QGjh+nW2P99mIToocPypm9Uungq7PPtIz+xExLQh5nBeL65psbLxOJqMl249Ts5PKzElrSyAhUEGQkok+cT3PNPusrn4lMVqYjnrh3s3Adc1k4IFtD5M02eTQhvg953J1Go3zDIfbdDo30PU2vd4tJCmHaTY5ceIblMur2PYwGRsYGz/Erkjt9nVGoy0Ggy1UtbyP8KfTk2Ea8wq63tk3snBu7nwU7dp4no2u7+K6Re7c+SGSpCGKGU6c+ClarStAuLgI1b0tVLVEEHgsLLzA3NyzUa2uz6VL/4pu9ybl8onIICJAVYuoahbfDygUlhkOdyPzD5VstoFh7CHLKuXyKo3GOW7f/h6qWsayPDwPer11ms2riKLEsWOvksvVozS0Radzg0JhmSCwGI2a6HoTVS1hGB0cx8B19ei4R4CP4xiMRruMRjuUSscRBAFdb1KpHKdWO0O5vIbrmuh6izt3foRpdrBtI3LuykURpo3rGsjyYpQ1aKHrLTzPolo9y9JSjdXVV9jdvYBtD3GccBG2tfUmtdo5CoUFFKVAo/FUQtKOYwIupjlEFCWWl79EEAToegtNKyHLGoYR2npa1oilpRdpNM5E6evtZMEjy2FkPKmJmNW+NssJ7jBMZ6COSnazWv6mh2k8Kg4TnqWOXZ99pIT8ERGnjKe9gR8H2u3rSb22Vju9ryUk3vesKDs28JgcKj/tqTtpsHDQMbfb12m1LqMoJQqF+SStraoVfN+9z5ayUFhI+kwta4jnGUiSgmX1cF0T1zUZDnfR9TayrLC09EWazcuoapHNzR/T661TKCxRqayQy9WS6Hk6PXlP8GIhihmOH/+pfZ+BouTQ9XBs4fz8M+ztXWJh4flIRJRnd/ciipIHoFxeiZy1AhSlQj4/P9HWtcPNm9/DMHqARDZbo1hcYjRqMh7vMhjsMTd3muXlL9Pr3aLbvcVgsI6m5ZHlHHfu/ABZLrG6+jLF4gqNRiGaZTyk272D74eR7NzceRqNs9y69QM2Nv4MyxowGNxClvPY9hjPMwgCm3r9HHNzz1AuL1MqHaPVClPHYXo4zIZYlkmhMMfKypdxHIMgCOv743GTwWCDra03cF2TUmmFUmmFXG4BQQhHT5bLJ6J0fZNm8yKSpFCprFEuH4+cusLWJ8No8tRTfwnT7NHp3GRr68eUSqHH+GCwiaIUcByLIHAYj7tUKiuIokguN8fe3gV6vTu4rs7p0z9PPj8XCeQGmGaf3d0L3Ljxh1Ed+QuJKQmQ1E4Pcsg6zAluFtFNv/aomI5eJ/UQD0pVPyjSnW4RnFyUQloz/qwjJeSPiFlmGY8L9foZXNeMWoIqSV9oHGEehDh9rOvVRC0LD7eyjoUumlYlCMK6XrN5GQBBEBIv5ekowTA65HINFhdfRBRlPM+i378bmVXcwLaHuK6OLCtJRFyrncVxLERRo1RawnWdfZOvptOT8e+jURvbDmt4k2Kxra236XavUSgsJHXS69f/LY3GeSqV4wSBTa/XigwwgihFWmdh4dlEmDMcbnPjxh8yGt1lcfEF8vkFarVTtFo3GI93EQSZVusitt3l6af/GnNzT3Hnzp+ytfU2ptml232XVusSgiAxHt/lzJmfR9fDSU2dzg1Go0183yefb+B5NqPRHpubP8S2Q9FUmOoVKRQWUNUiS0svUigs0G6vY9tDBEHixImfirILG6ysfInNzbei9qYPMc0etdpJWq2rdLs3WFj4AkEgRgsXkaWlLxIEAZXKCjs7HyDLGpKkYJo9XNdCFEUWFl6gVFpMsg+qWqTTuUUQeKyvf59stsHi4rMoSolstobrWuTzDVzXoVJZ5e7dH+F5DsXiYtIzXS4fJ5MpkstVk8VkLlfn1q2wD9p1HVzXJgiCxNsd2JeWPmwU4UHEddQI81FSw3GW5yh40HFM6zPi56Vq6s8HUkJ+DPi4LpbYEanTuZaIqkKbwbdRlFI0t3bM6uqrM5yEQrX1rFaKyZvNtE/wZLuFbQ+TvszxuIlhhJFKLOKaTqnFvsfz888m9W1NK5PJ5BkMNjCMLsvLLyEIEpY1RBAEdnbei+rgOr5v02pdQ5YzyLKa+AdPEn+s5O711jGMJq5rYVnj5DjC/eWiWuQC+XwdURTZ3X2fweAu1eopcrkFdL3Pzs57SFIG33c5ceKnE0tJXW/iOGOKxVUUpY6qqtRqZxgMdggCm2LxBIIgoml1hsO7XLny+4iiQKGwzMLC82QyBXq9O1QqpymVjlEoLHDjxh8xHG5TKCwSBB6qWsN1dURR4dixL3L79p/h+zayrFAqnaTXu8ZotEs2W0fXm5w8+TOIosLu7jvR+7/DsWMvUyjMk8mo6Ho3GjDh4bqbDIfhexUEEc9zGI+bHDv2ItXqSSCIlOw30PUOqpqNhGdE6vYzrKx8mUbjKVzXwHEMPM+k17tDrXaS7e0B7fYtbLtLrXaWWu005fIqvd46pjnCtoeUyyucPfsLmOaI5eWXse1QPCaKMseOvcTu7oV9LVKxfqBSWSWfb5DL1aIZ1xVyuTk0rZoMIAnbyGabjxx0LT4owpzVZvQwxB1/bx50L3jQcRzUIpji84GUkJ9wTPYiA5FC9gIgc+vW9zCMFgCnT/9s8pppleh0K0X8HNg/+jGuvwaBG7VazO27IUyP+ZvEdD0ujgT6/Y1IZX0b02xTra6hKIUo0mnheSam2cPzHBYWvkC1ejwSDdXwPPe+G2Rc2x6Pm5w790sMhzusrr4K3IvSx+N25F41YDyu4nkBlcpJVLWA69qoahbPsykUllHVQkRON7HtEcvLryAIMsPhNpbVxTQH7Ozcptu9zfLyl9C0Ont772PbOs3mB1G9tYltj1lYeIFy+RiynMH3bbLZGo3GU/R6txkOt6PPXoha1iza7Wuoap733vsXGEaTTmcdz7MYjfbIZDR838IwmkBAs3mZ1dVXMYwuspyn11snCHwqlRPRe/colVY4efKbXL/+RwSBR71+Gt8/webmFhsbGQaDD3nhha/R7a5Hn81ulMXIk8s1MIxelLm4Go20lBLdwsbG69G56DM//zSt1hVEUaJaDVXUmUwW2zbY2PghghAuBmu109j2gHb7OsXiEoPBBq5rs739NrKsMR6HteQgCOj1bqMoWer1M8zNPctwuB09VkiyFoPB3aiOPqJWOzszfX0QHkSU005xDyLC6Uj3qCnlWe2Ij3K8KT6bSAn5CUfci2zbY2RZY3v7XSyrj+NsIcs5isWlhKxjTK6yB4NNILxpTE9mmvYJnqyFTZJuSOSt5AY9y5QhFtaEIrTQGSsk4pvYdh/fh0wmH91QdbLZWhTZ5+l0bqAoBRSlQCaTx7b7XLr0W6ysvBqJ0vbfIE2zjyTJKEohquHvYZp9XNfk7t036HbXcZwhklQABDzPxXEG5HJz9Pt38X2P4XATxzFZWnqJbLYatRNtYhinKRaXWFoKRyXu7FzANEdkMhUsa4TnGShKFd8XUJQco9EmrmsgCCAIMo5jIwg2IBIEDuvr30VVK1Qqa6hqlWJxGd+3GY2uEFuIyrJIEPjk83MMh1uRGG8pMesI/atV3nrrnzIcbqKqFYKggSDcQVXL2PaI8XiX1dWfot+/m7Q8BYHHr//6P+Df/JsfEAQG9brAV7/67/P1rz+P7/vkcg3y+Qa63kVVS1Srq3iexebmG9y69ScYRg9db1GrhZF+aCm6wvXr38G2TXK5Cp3OLVx3jKZVuXbtdxiNWuTzdcrlFcbjPXZ2PmA0arK09AUcxwY8JCmL6xoUClW63Rv0+5toWo1G4xlOnPgGoihz586fRqrvcOZwLF7c38seD1IxaTYvsbr6lUe21zyozegoz5+85h6EeNEYjshsHng9xc9NldWfL6Rn+QnHJInqeptMJkcQBGSzoc3k3Nyz+1ovJi9gXY8VrH2Wl19FFOV9k5kmfYIhHCuoqsXkphZvT1HyjMctgsCN2ntiR66wkBeT/8bG6/R6G5hmi3r9PI4zBgQcx2Rh4TkEQaRWO81otBOJh9qYZp9sthY5bXn4vouiVMjl/GRhAPtbrVzXxHFM+v0tBoMNBEGgUjmBrocORjE5yrJMpbKCZY3xvGIUkdvMzT3PYBC+VtNK5POLLCw8j6JojEZ7DAabkYLZYzC4iygGqGoWyxpEi6MBlcoqrjtKosbQn3oD3/fY2/sAy+pGi6g8oijjOAaOM8LzdILASyYwLS6+QC63iCQpZDJFxuMdFCVHvX6evb33GAxuI0lZrl//bTKZArY9olhcBgIsa8xwuIMkSZRKa5TLK1E0vkmtdprXX/9XvP76d8hmM+TzZVS1y5/92b/k5MkKjUYOUZSjDMkVSqU1lpa+QD5fw/d9LKsf9UMHdLs3mJ9/nuPHQ8Jvt68xGNwhm32VTEZFkiTa7Wu4roVtDzl79hcihbUQOXH1uXPnz1DVEpXKSebnn6ZaXaPbXWc8bqLrewiCSC73XCJk7PXuMBxuouu9RDg4KdyLa7axpiIIfNrt64dOgzqM4B42In3UCDYWKIbuZNJ9hiKTqepUWf35Q0rITzgmBVqxijmbrUbCHnmf3WDYgrWTrLxzuTqqGnpLh8KwMs3mJWQ5i22PIlIIo8/d3Qvs7LxDobBMJqMAJD3NhtHD9y36/S1838Nx9Khvs0a/v4HrmgBRq5FFoRASzPz8M8kN17LGlMsrOI5BpbLGeNxkZ+dddL2FLGssL3+Jvb1LqGqR5eUvMhhsJaMjB4PNqK81jyBISQo7jO7XIvOJMPIWxSyiaJLNapRKa2hanXr9LFtb79FuX0eSYmcplaWll/A8F8vqsrPzDnNzz7O5+WeR+KpNNjuHbXdZWPgSrdYlFhaeJZPJIUkqrmsBCqIoIYoivh/Q7a4jiiqG0afbvYGmlSiVTpDJ5HEcHU2rRcRboNE4S7G4Sqk0j6bVyeef58c//keIooIkqQyHWzSbH0YCumOsrPwUltUlk8kiyyqynMf3TUajuwwGG8zPv4hpnota1cbcvv197t69gu87wBzjcYYggG63i2UpHDv2Cs3mlch1zCYIPCRJQxBC9bvjGCwuvkixWMfzoFRaQlHyuK7JYHAHXe9gmi1qtZfI5+cpFhfp9+9Ehixhy1k2W2Vu7jy7uxfI5+eQpCyCQKSqf4sg8KlWT6DrLZaXX476od8km51DUcosLn6RWu3UvuzIJKkC7O6+h6LkkSQl6ZU/KJo8yDrzJxmBxsfdaJzf5043S8yVKqs/f0gJ+VOA2NYwHNU3F7lvnUYUZQyjHfnahgiCALhniVksLmFZg8S7ejzeYzwOa9IxOYXuWFuRotvC9yU8z4rqnm1UtUi/v4VptnEcg0Jhnmy2hq63aTY/pFhcRpbzdLtXOXXqZxEEKfGONowuilJiNAoNNlZXv4xp9iIvZY9icZVCYS6JkE2zh2F0CQKPZvMyxeISrmtGUSVRK02bavU4jUZY3zTNPvm8lHg1dzpX8TyTbLaC6+aBOuXyMVZWvhx5TW/Q692kXj9HNltlY+N15ubOc/fuDxgOd5FlFU0r47o6ptnj6tXfQhQlFKXIM8/8FWx7RLt9E1EUo9YiF8/zAAcAQfBwHAdJcqNZyltRSj6L541RlCL1+jPMz5/Ftk0kSeatt34Nyxogywrl8hqCkEn6tBcWXqBYXKZcfoXt7XcZjZrRQmuXTCYX1bk/IJstAyLt9mV838f3ryNJIkHQRxBq3LwZUCiUOHv2p8lk4rGCOZaWvkijcR5JUtD1u9Rqp6lWV9H1PoPBLpIkkc0Wabev0+vdplA4hu8HBEE4qvL48Z9iONzCcXRMs4PneZERiRJlCZQkhR6qtF263dvoepPjx7+GqpYQBIFW6zKbm2+TyeSoVFYoFJai2vNm4rse6hOayfc9triMB2ZMznc+SOcQCxwf1nrzcWC61WraUGRWu1Oatv78ID3DjwkPGhTxqCgUFhKCim9M8YSlXC4cLhFHwLY93GdsH7cNBUGQCLVAxDDalMsrkTFEno2N1+l0bjIY3KFYXCWbrdPp3KLVuorrGtTrZxkONzHNAZlMqKTWtBLt9g0ymTyaVqXdvpJYWJ49+0sAbG+/y87OOwiCxPr691CUInt7JVQ1j2EMqNdPUakcj4h3MYq+QzVur3ebTCaPZfXxvLAHuV4/jWUNse1R1E7UpN2+jqJkMc0hhcJ8FCmPEQQfzyNKIV/FMHbJ548hSQq3b3+f8bgVqaFvRWnnIY3GCppWYX7+OTKZAoLg8cEH/wJVtRgM1iPC6nHr1nfp99cpFleQJJl+vx31XVtY1g8TdynftzHNAaqaQ5YVgiCg3b6O79t0u9fp9Z6lWj3N1taPov7sHTStyt27P0RR8lSroYLZNDv0enfodm/Qbl9BUcpYVgfTHFKrPYMoSnQ6F8nn52g0nmJu7gV2d99jbu4kL7+c5bd+6116vS6lksLf+Bt/jePH55OU73i8TS43l1iy5nLzSd1+PO4xHG7SaJxFUQoMh1uYZodCYQlZVtnbe59O5yqjUVi+GI/3IoFXgV5vnV7vDvX6GRqN87iuzfr69xBFgbm5pwiCAM+z6fXu4jgj7t79McPhJr1eaDpj213y+UUANjbeoN2+gudZUZ19N7kGYsSENd0uNIlpgWMQuEfqHf44MR21z+pxTtPWnx+khPyYMBrtsrn5I1S19Mj1pYPMC2Kjj/G4Sa+3HtViT0WpVy2JdDWtuq8fMqzFrRMEHpY1otE4T7W6hufZdDo3yOfnsKx+oqzWtFAgFNplhnU9WVZoNi8jy2FKMBxO0KfX2yCXq5HNVqjV1hgOdymVjuH794bdh25cZXw/dLYql09SKi1x9+6PcZwx9foZBoPtyOZyPTIRGSZkXKmcQJY1BoO70WJhkXJ5leXlL2EYXVqtKwwGd8lkCphmN0pZy2SzdSQpg+MMsO0yo1FIJJXKGs3mJtlsDQjbllx3hG0b6HqHVutDJEnh2LGXkGUFXW9z6tTPs7v7Lt3uDa5d+z2azUtYVhvLMoEdKpVlJEkhCJxkqlIuN48oiphmH9NsoSgrlMunGY+3qNeX6XZvRIsdJ2qVURBFgXx+KTLB8LEsB0E4Sb1+kn5fpdu9wd7eh9i2jiDcQdPqjMfbOI7OcLiLZZm02x/iujqFwgKVygl6vZv8zM/8RV588Zt0On3q9SVkeZsPP/xXUR+yTyZTZDDYZDgMDT1CO9EhlcpxRFFCECQGgx0KhWPcufMDgiBgdfXPUS4vsrv7Hjs7b6PrbRYXX0BRCpRKy7iuSb+/yWh0B13fo9F4OvJiN3EcD8vqoWlFBgObSmUFz1tEUTSC4BWKxRN0OleRpAyqWogyLAUUJY9h9BkMtqK5w+HQkLCsspNE0PE1M4tkJ6+v6XTwUd29Piqmr/FpoeU00rT15wspIT9GTPrhPgoOWg2bZj9JrWlaFVUtJq5V8b5kWeXmzT9GFBU8z6RWOxORr0smk8PzLJrNUOAlCCK93m263Tu4bhhNato8ruuiaeHUG8cZcerUN9nb+xDHGeM4FtlsDdsekcstJG09w+EOb775a9RqZyOnp1JSM9S0MppWw/McJCmTkHMQuFH/r0Wt9hTt9jWCwEPTKkhSBssakcspCamPRrt4nsvGxg/pdm8iyznOnPk54klTvm/R63Xo9TbI5xciD2U78nC+GUX9Yd+v7zsMh3cJApFW60MajWeYm3s2mnwVKsmvX/8O9fqZaOrRPDs7Irbdj9LTAQsL5xmNwtYqSRJxXWvCnSpA00QMY4xh7OG6DkGwg2l+B1lWqVZFNK3McCjjOOPoPIu4rkGr9SGyXKJWO4XnWVGU7xIEPpY1xrbHWNYgmtrkIUkqvd4dLMtC00pksw2azQ8Bn3x+kXx+ORJm2WSzLcrlOTqdDv3+FsPhJqXSKp43jsoEHTKZAppWjHq8exSLi4xG28iyxvr6gO3tt1HVMIPQaJyjWj2FZQ3IZit4nouilKMpYWEtN5udx7L05HX5/CLD4SY7OxepVsNFSiaTQxRNgiCg0TjPsWMvc/XqH0Tf0TvoepdKJRysUS4vR9mRVer1M/syQHGZZn8ttr0vcp62t5zVDvhxp4inr/HYFzsWWk7vN21/+nwhJeTHhOne32nxyVEu8oMGKcT2nILgEJvvQ+heFP/94sXfYmfnPVS1RLG4yN27b7C3dxHHGZHJFJDlUCw0HrdwXQPf99D1JpmMiiiqBIGA7zuRClQkkwmNSIrFY9HQepXt7bfJ5Rp0OldxnDHLy1+m2bxEs3kRXW9z7NiXsKwxg8EuH3zwP7O8/FVE0ce2dUCIatJ7OI5OEARsb7+PYQwpFBbY27uEIKgUi/PRaMMSvd46ur4HSCwsPIdh9Gi1LuO6BplMLmrFqdJsfohlmbiuxXi8TTbbQBSlyMJzgGn2qNefQhRbOI5FpXKSZvMatt1nb+89jh//BoYxSFqMQvV3h3Pn/lLUN61Fpike4NPrbSKKCo6zxWAgIYoSvm8iihKW1WNvr43nOZEPs4Rl6YhikNSIq9WnKJePUyodp9NZp9+/hWEYmGaLajVDo/Ecur6NZfXZ3HydXu8urdZlQEAQFECgUnkKywozIL4f+lbncnU8z6FUWkWSZFxXj/QDHfr9DarVs5w9+5f54IP/BdfNc/PmOsViHlXN47ojisVjOM6AwWATx9FZWHiehYXnGI32GA53GI93UdVSVNd+DsvqR215C1FZZIAkZQgCL9IZzLO19UP29i5Sr5/m1KlfYDDYxDS7+P4q2WzYQ1ytrmEY3SibE6Ao+eh5bTY3f0Sj8RTV6ilGoy3K5ePMzz+XmOQEgZu0rcWdCHE7VBB4yUQq4EB7y8ko9ONOEU9HvNNirukacorPF9Iz/phwUO3H992kBgyHX+TxNqYNPPYPTbCi6UShaCoc+H6DTucqtj3i2LEX0fVulCIMo8dMphCNRByj650oJahRqZwkn69TqayytfU+giBiWSNc14yMIrq0WpcIggDHMRkOd7BtE8fpY1kDQMA0e9EUoTLd7jVKpcUoxXuTbLbG8eNfw7ZvUirFhOFGhhQSg8EGIckEyfi7UmkxEomVcF2DTucmlcoqjcbTzM8/i6IUGY22EAQ/UoUvUC6vks1W2N4Gy+pFrUMVCoVjkTK5QL9/h17vNqXSMarV08hygevX/xBJ0hiPdwgCh8FgA13voaolJCnD3t5Fms3LbG+/SyaTTSJBSVJQFI9icRlJygICUME0m7iuiCgKuC5R9GyiaRqKUsTzbMbjDsPh91CUUuRQ1kPXhwiCjyxncF2TTucijmOg601se0Ro5bkL+NHQkBqDwc3IWtWKlNt5ZDnL/Px5arVTkQq6Tz7fIJutIkkq9foJRqMdLl++yTvvXGA89pib8zl79hTnzp0DAiQpF/XI7iEIWRYWnqdSCVXbspyjXn+K5eWX2d5+l9u3f8h43GIwuEuhsAQISJJCp9Nhc7PLiRN1VDVUlguCEPWkj8lkchQKdSxLj9qrQtOUZvMyilJkONykUFil1wtV20EgoChFstlqNEWrzO7uhWTkY2ypGTtteZ5LtbrG9va7eJ6NZfWp1c5QKCwmpH2Qp/XHkSKejtYn7wHTzlyH1cBTfPaREvLHhFhUFa7UXSRpttXfQa+d/An3askbG6+jqqH1Ybd7K/EXNowOpdIxMpkCpVKOYvEYuVyNXK7GYBDO+y0UGgSBj+8HUc3OjZy/LiU13Xy+ge9DGAmGVogLC89gmoPIi3qQqIY7nev4vsPc3DNks1Xa7Wv0+5ssLb2I55kcO/Yy7fZVhsMtPM/j9Ok/j+OMkWWZ0WiPINgiCCCTUaNZtB1UNY+m2YxGm1FfcTgk4vTpn6fbXcd1dY4d+yK+7+M4JsXiMsPhWwhCDs8zyGbrKEqJfv8mmlan0fgCrjtMZkY7jkUmk2UwuI2q5gA/Mu0os7PzPp3OHQRBplhc5M6dP41U7Ba12irV6hkMI4y+bHtMu72OphVYXHyO0aiNaerIskAQKJRKc5jmAM8zcF0vyk7sES5ixsAuudx8NCrRQdNqaFqRTCbH3btv47o6jmNRLM5TLp+M3MB0crlFstk5crkG3e5tNK2CLGuUyysMh5u4royiVKJzcRNdz1EsrpDJaGhag+vXL/DBB+8xHktoWgloc/XqdZaXz1KphKMXQ/V+h2bzA1RVpV4/j++7yLKK7zv8+Me/Trt9keFwB1nWUNUiw+EWoihx9eo6P/jBNTzPxXX/iJ//+Rc5cWIR3/cxjDb5fJ3l5S9Rq52JzqeZtPDV66cTf/KtrS1AiCZIncOyBqysfIlK5UTkrHYdCKKZzwKCIOH7LpubP46yP+3EbSwsPSxE9ebdfa2BD+pHPqw16qhtU0eJuieJOd72YS1cKT6bSM/2x4TYvUoQBERRe+BoxvjiPswKcNJJyzC6kcK6w6lT30RViyhKfl+7kGF06XZvR6nfHURRplI5ge9bqGoNy+rQ79/FdcOoxbYNNM3H80xu3PhOVBN1Mc02p0//PI3GOQaDDYLAj9LZC1HEkqfbvYOm1fB9F8sasbz8Ku32jSiC6aOqRS5d+jaKkkUURVS1RL9/J7FZtKx2lE43yefnyeWqZDIGrdYWnc516vXTBIHPcLiZiNpqtTO0WtcYDnfZ3f2A8XibcnkNXW+zufl2dJNbpF4/iW2PqFZPYZptbt/+HpZlI8siuVydwWCT8+dfZnf3PTxvjOtq0QQlCwBZFpHlPIPBXWx7yHC4E9l9jhiPQwGT7weIInheQCajoGlFPM/AtgNkOYOud7Asg2w2j6ZpBIEQ1TP9aPShia47dLubgInvy2halnDUYwFJUlEUgVJpnmLxGHfv/iipu8/PP0u9fgrX1aP09kVs20AQAnw/oNm8gGkO0PUWnY6H5znU61lMMwCywAjDsLFtnX7/Dp4XTtEKPa+bgIxl9TGMHv3+BnCX8XgPw+hErWM1MpkCd+9e4MMPLwAKklSlUOjy/e+/zn/yn/wqimKiKHmOH/8Gnmdz584bE8rzcKLYqVN/nqWlLJlMlkxG486dH7Cy8ucwjA7D4V00rYRlDXFdE1Utkc/PMzd3Puk0CCP7NrY9QFWLUVbgTJQtund9xYvkuDXwMGI9aPoSkCwMwuh74cBtPEzU/TC+2Ck+e0gJ+TFi+sKeZcd30MUfX9yqWkaSwsdnXYyiKCWCqW73JqXSCr7vsbT0Int7F7hz5w06navMzT2Hru9G82e75PP1yDVpQKPxNLlcjeFwk2JxORmZZ9td2u1x1OvZQpJUNK2K41h0OjcpFpfodm9gWf2oLaYVqZFtxuNtMpkcrmvR7V7HcQxEMcNgsEE2O89odAfTHGDbg6gP9zy53ByuawCgKBUUxWBu7hkKhWPJqL8wohzQbF7i5Mlv4nkepdJSEhGJooSuN5HlDIbRI5czEcUAELBtPWpv8VDVIs3mJYbDbQaDO0iSSrX6AplMjmbzEqPRHrrexPN8BEGMxEMCqhqqX8OFi4Ftj3BdB0lSAQ1ZDuu6kgSZTBbH8SIhF4iiAmgIgoBljQmCMbousLDwLK6rAwH9/h2CICxDhH3MPqKoksmoyHKO8Xg30g+IFIvz+L7Pzs5bDIctisU69fp56vVn2N29iGH06ffX2du7gCjKkePXIuPxLqbZQ1FyZLPzSJJEEIxQlCK6blMoyGQyLrY9wLJCw5i4ZOH7Fo4zioxkfCBDvX6aUmmVu3fD6VS12mkAHEfBcVwWFzUkqU8269HpWOzsfMjCQo16/TyKonHlyh8jSRkWFp7nxImvJ3O6ZTlU2TcaZ9ndvUijcR5BEFld/TI3bgwYj9uRFazA8vIrico6VObfiqZOlQE/irjPMBrtsr39FqXScTKZsE1qejrbYRHsQdOX7iF44DaOQqyTQ15mEXhqo/n5QHpmHyMe1FM4+ZzQUWm4b8qSYbQpFMIB8fEEnINqT6bZp1I5jmWNkGWVdvs6rmtFUVcQKYJhby8crZfJ5Fhf/x6VyiqZjMb8/LOUSitcvfr79HqhcrlWO0ulcoJKZZXbt49RLC4hCALb228xHG5hGINImW2Qyy0wHG6RyZRwnC7jcYfFxWPUamfxfZt2ex3XHRMEAf3+dVzXwDR7aFqJXK6BIIiMxzvMzz9DLjeHKErMzz9HLtcgCDxEUaZaPc4Xv/gfs7n5NrXaKTY334nqw1kajTlu3PhjOp2rBIEQ9fsWGI3uoiihx3c46tFGklQEQWE83sWyRvh+gO/bDIeb+D4YRovxuIOiZJBlGUnSyGRUfD8bjSKUUNUsiqJEimoQxRy+b+C6fqTetjCMQWSsIjIchsehqjkyGRXX7QE+MGY43ELTchhGP1qQ2NE/Bcjg+2DbeUTRAuyobayA49iMx9cwjBHgUyotkMtV2Nt7j1brMo5jYFmjqHUqrHE7jh65i2kYRpdarcazz77M9etvAG0KBVhdXQC6GEYGxxkzN/dMdH430fUOvi9E5zI0PSkWF5EkmV7vFo6jYxgdPM+mWMyhqjL9vkU+n8H3PbJZEUHQ0XUf2+4BEplMFlWtJeKs8Pz1uHjxtxFFMbqGJAQhYG7uaW7deg3bNlEUO7o2KtFkq1A5XS6vAOHglY2NNyLlcoBp9jGMUE9RKkHsiT59LR0Wwc6avnTQwvugbRyEye1MDnlZWHjuwPtGfG9J8dlESsiPEQdd2LP6H8NpNqEpRWh2sE3oITwkk9GSObDTBA/hiLxK5SSSpKGqAlev/lva7cvUameZm3sG0+xRrZ5ke/vNaIRjDlnOoapZXDesvY5GuziOQa12kt3dD6JoNXTnMs0WCwvPUi6vAuFNyTT7UfuSRCaTo9e7gSjKqOooUv6GrTbhkIoWtq1TKi0zHG7R7V7H8wJGox0EQSab9RkMbtPr3cI0R6ytfZVCYY52+0YUgZr4vpkIqI4f/3MEgcelS/9rtO0hV658G0EQovm5Fvl8LRJAdRDFDNXqSQyjTb9/F8MI23ps20QQ5KjnU0yU0JlMFk2r4LpmRMYKIEYR9haSlCeTySYjLn1fRlEyjMcBghASx2DQIwjGFAqriCJY1hAISxa+70UtSA6e52NZnaiVaQhYyfdElnNR2tmOIlVYXCxFxiedaHshKQaBQzgF6hKe50RivJCoJSm08pQkmXx+iWJxBRAYjXbo9TZYWcmTy51B13cQBJFCIRcdVz9xTMvlGozHOwhCeN6CwKFQmKdcDheBqpqPiMFHENQoIg84f/4sH354g/HYQtMyPP308xw7dgrfd2g2P0RRClSroSGM65q8885v4Lo2nmfgeT6iKLG09IXIuCXLnTs/jMxhTBRFiwR/SqKy3tr6MYPBcRYWnsO2x1GJSCKTyTMcblOtriX6i4MGTxwUwR5URpo1NS3+fdJ560GR7KTVbTwgJhZrTuNB/copPhtICfkx4qALe9aottj/OZut0umEdVDHGZPL1ZAkdV+P8WQbVAhhn/La90MlqetaGEZob9nvr1MoLJHLzaOqOXQ9tKTUtArt9iU0rcJ3v7vEd7/b4NSpM6ys/AaqWkTTSlFafJGXXvpbLCw8R7d7i1yuFglO/gK93gaWFUaVlcoLdLvXkOUsw+EOV658m2y2ThC4yLJGt3uDbvc24BPO6tXJ5+fwPJdO5ybg0u3eilp0+shygVyugWV5bG39OKrlmhQKDRzHRNc7tNs36HSuoaolyuUVfD9gPN5LItVwJOIeohhOZDLNHrKcQxD8ZICFJGUACVlWAZUgcHAcHTDR9dBi1LJMbHsA7CFJCrKs4nkOvg+6vpOci+GwSRCMABdZFshkihhGC8vqRXaSBpnMCEkq4nl7eF4Qjc30om1IgArkaDZ75HLgeSDL0GoNaDRC8pUkJcqguPi+hCRptNtXMIwBophBFGUymTzZbCi+ymSy+L4FaARB2DKnqqWo/7mAJNUQhAyqmouGVsyTzzdQlCLN5od0OqEft6LkUZQsCwtfxDDabGz8GcXiMppWRxDkSDS3i+vqrKzUOHfupxiNXIpFlWPHVpibO8/29gW63StIUj4h09Goyd7eBWq1kzQaTzEY7KBpZer1cxQKi3S7oRtaPAv85Mmv4/s+mlZiPG4iSRlMc4jn3USSZBqN8+Tz84iihOtajEZhrf/Eia8B7LuGHkaMFZYM2Hf9wuwZ4w8TycbtjEHgRuM77w3GmN5u3K9smn0KhUebaJXiyUdKyB8TJlfX4WCHanIBx/2TxeISmhYOf5AkDccZI0nqfaKOWW1Q8YVar5+h3w+dmzqda3iejSRlUJQcilKIDBuq3L79GqY5QBBElpdf5nvfW+Hv/J0vIIoevv8Cf/NvvsErr/yIcnkVQRDx/VBoZJp9MpksOzsfIEkqsqxy/PhXuHHjDxEEkeHwNkEgks/PIQgijuOwvf0Ox49/NTJtULDtEZmMiqaVqFROs7r6FSxrgCiKlMur1GpnMIwWnc4G+XwZRSmzuflG5AS2QD7fwLIcdH2P0agZEdogMsqwcJwunudHQh4hEvZ0yWTK5PM1XNePBiGcZTzei1LZBratRyrhEo7TIwhkJEnFtnvYth31HbuAjeeZeJ5KSJ76xJkWorGCMhCOX3ScsN9ZFJ3oOSaOAxBOkAIjejysQ4d1yCDy7AbfJ2qbCkkZTCCL7wd4nkGhUEcQMriuQb+/RxAYgBKlyAv4fli/LpVWo/pxh35/G00r0WicwXVtDKOf9Oc6joFpDul01llb+yqyrDIa7UbfA4+lpWeRpAyj0Tbd7k1Ms0cQBAyH20BAJqNSrz8FyNFCQKFWE5FlGVWt4jgOtdpJisVF5ufPs739AabZxbZHhLV+E1UtMj/fQJLC/vF2+1o0WcvAsvqAyPb2uywufoHt7fewrD6l0nEqldUk0xH7QccTyjY330RVi4noK249DFsFr1Grnd03QWryup3MZk1GyLB/pnFo83or2dbDCrim69kxHnXecopPN1JCfkw4aKUcr67DOmk4uWg83k0cvXS9HaUWV/fVo+K2h8lIeVb9S9fbOI6OLCtRnc+nWFzBcSxarUs4jomq1qJhBH0UJU8mU+S119SIjCUEweXWra/ycz/X5sSJb2BZQ9rtK4mJQ7N5lW53HUUpUKutYZo9TLOLroeDGFS1QiaTp1Ra5Nat70XkehNVLRAEOoXCEpKUoVRawnFG7Oy8F41ENMnlFshmq+zuXiCbrZDNNqKRjPMoSpm5ufO027doty+h633G4xaOM8D3RcCPfg/wvBG+r5HPL2NZLSSpFKXrNRxnE9MMTUXK5VWCQIomHDmEoxFHGMYQ8CPnKA1ZdgkCGcdxks9aEHLkclXG47uAjCTl8bzQ6hJEQMJ1HTQtj6pW8DwTSRLxvEwUYUk4TmviWxOnq0Ug7HMejzto2j1CzmYBchSLC4xGLUajPebnn0dVc5F3uoAgZCJlsorvE9U7sziOjufZgEY+v4jnjWk2r0XGJz1kWYvevw640dCMaywtvYgkyUktX5IUxuM229tvJPXshYUv0Outo2llFKXE4uJLtFpXsCyT0WgPz7Oo1c6Tyai021fY3t5kNNI5dqwL3EUQAhYWXowIc49W6wbnzv0C43HYSWDbY6rVs4iiim3r+L5LrXaKvb2r9Ps3EYQMa2vfQJJC/UQ2W8E0+/tSu6urX4m8w919vtWDQdhSV6m4TCMUV94j68lBELOel8mEM7enZ48fVXg1WaOeNgOavAekiuvPB1JCfkw4aEWrKHm63fV9tR9RlJJ5wPHjs1Jpkx69072R8SCL0KKwRj4/x87Oh1Ek2sB1BziOTqt1kUbjWVT1KZaWXmI02uH48Vf55jd9/qf/SYpIWWZ19Y8YDrfJZPLY9gDDaHP79p8xGNxlNNokCAQajfORoOqpSAGrIorgugaDwW2CwIlck7rUaqfIZutkMnl83yCbLeA44aSmfv8PyWQKZDIa1epZ9vbep9m8SK12DkEI6Pfv4nkeipLFMDpsbr7GxsaPuHDh57hy5W+xtvZdnn76exSL82haaIk5Ggn4foBhNCMiNvE8h2bzCkEgA25ibhJGoi6+7+C6YzxPJI56PS8TpbdVXDdME4eTnAIyGSny9C4jSdmo9i9jmi3C9LeCbQ+xrC6SpCY2oKFxiEAYGUvRWfS4Bx9J0igWq5w8WWQ8HqJpEASQz0uUSuE4wuFwB7Do9dYpl49Hk7fqUYrWRdNy5HJzkZVkaLs5GGxF5YYwKg77v32CQKBWW8N1bQaDLbLZOXxfR5KytFpXMYx29P0KGI22EQSJ2Pgjn5+L5hY3I01BngsX/jmG0SWXqyMIQvQ96jEcyrz22r/k9u2LeF6431OnjvHssz+NZXUoFBbo9+8wGNzhxo0/oV4/S6VynIWFZ1lYeAbLGkaiujKe5zEabTIY3KVeP0cmkwdAEMIpZ65rcvv2BQyjha63qNfPIggx6S0l11VIeNWZpBkurGeT9f0QyOfnkOXVKOoOe6MfhTwPaq9K258+X0gJ+TFhekUbY7r2E6+eQ1Ld2WftN0nqcX3J88zEGzq+KJvNy9G4uxFLSy8zP/8sw+E2sizR691BVTvkcjVGo+1oPF0Vz3MZDu/gOBb9/g6/8As5/rv/7vf54z+2aDT+BWfO/Da6Pk+z+SGynMX37Whogst43EKSZHZ332Y4DOfvLi9/lUJhHAl/RGx7iGn2UNUKtdp5hsPtyKEpQyZTYG/vCrXaqciTeYBl9alUztDpXKNYXCGbraKqJQyjy87Oe1SrJykUQtOHbneDt9/+Kf6X/+X/hyC4vP763+Vb3/oP+PrXb0bbGuI4OoLgY9sa+XweWS7Sal0hJEENUSwjCD6+b+K6NnGLkeP0iOu3YXpajtrDhgTBGEFQyWZLGEYb2x5HIxR9XLcP+AQBhBGyjus6hMQbLgY87150HUIEVGQ5O6G6DuF5Bp3OXUKzC8jnAXIIgoCuD7BtB1HUIrGbg+eZgIDnOdj2CFHMIAiV6LskEQQW43GXIHDodG5j2z08z0NVwwxJubyIptUwjDZBAIqioCj1aFyiim2bhHV/k+FwEwjQtFo0IazIeNzGccaYZiikGww2cV0Dw9hD0yqUy8ep1Z7i1q0LvP/+VWRZoFTKEAQ2d+5ssrw8RNO28LzQ8tSy+mQyKoqSQ9MqFIvLSUkmnGQ2otO5BUisrv4Ux49/lVyuHmkoQiOQXm+dTCaPKIYZg/G4uc8UJEb8/2mLWmAfWR/WajTLKnfyXvAgHKTUTuchf76REvJjwnRDP4QKaUUJB0HEkXB88YX9saEYqde7xfLyl/fZ902KtsJ2nV5y4Q+HW4xGLSRJShYA4eD60EDCde1ISBUQuoXt0u3eJAhCP+WFhRdpt2/w1FOv8cwzKqNRwGDwZfL5BVZWvkKnc4vFxVc4ceKnuHNnjsHgLq7rkskUcd0xo9EezeaH+L7FaNRiMNiIBGkNTp/+eWq10+ztXaDVuki9/nyU+hQwjC6ZjIJlechyAU3LMR7v4fseqlqlVgs9jQuFBQRBierh4RSrO3d+GkEI08iC4LK+/lVefvnH2PYgSbmGUaeIaa6iqiNCAgTwCAIjSm0D+MhyHtd1gVjpHKacBSHAMNpIkoTjBMCYIBAJidZhNGohCBmCYMTbb/8M6+s/y9raa5w//68JW5eCaJ/TZJyJ9uHhugMmyTiETqej4/ugqnGq2iAI1EiFbBEEYaTteQ6yrEZpfwdZzkZTvzLs7LyPKAqAQrk8Ty7XQFVdBgMHWc6Ry4UZBV3vRjVgISLp7ET7VihQy2QKZLM1JCkTqa53EQSJYnGJYvEYg0HoLjYatYBtgkBEFLOR8KrOeLxLq3Ub2w5w3QaC4OK6NqJo4Dih8M1x9EhfcZpSaZlsts5gcIdW6zKVynFqtTNYVp/bt1+j3b6GppVZWXmZVusKd+68Qa12Ispi2AAUi0vU62fY3HwTCJLv0/S1OkubEf+crBFP/32SSKctMKfr0YfhoBZJ1zUj8WV533Gk/cefD6Rn+DHioIb+aXXkaLRLq3Ulmg5VQxSlfduZvOhDv2IT33ejVKvHYHAXSZKxLJ12+3r0exhhVKtrOI5OrbbG3btv4nk2QSARTk6aQ9NKUW9pOGDC93VeffXvRO5ex7DtMb5voCh5fN+jUlmiUjmB55moah1FyST2hqG71A5B4KEoBSqVVQqFRQqFBu22iiTlaLUuAiKSpFEqrZLJhGMNQyIpY5qbiKLM/Px5QEbTSmhaWH/d3v4xqlpFFAOef/46P/iBnJDy2toPIuOKIfdIEMJU7QjTjMVSEiBHgh4XyERtTEqUUnYJo2g/eq2F54X15FYrdt8ymJsTCAnVIAgsLl/+S/zmb/7rKGL/P/Ef/8d/k5Mnf5P9qehJSIQkPfvv43FYM5YkIhU35HJS9DqPILgnHFOUQtJqFtpGBjiOhWluIAhhej1s7ypSLC4iCCq5XBnHMbEsk8FgC0kKHbFKpWMsL7+MopTwPJ+dnTfpdG4jSRK5XJ0ggH5/i8FgD1H0IsONZ9D1cIjHYLCOrnejIQ81crkKmUwBw2hRLi9TKpVw3dA8xnVz5HI6vi+Ry7mR7WUGUcxEfc23KZdXozGcOru771Mur9Lp3KJQOIbnueTzi+zsfMjW1uv4vs/x41/jzJmfB8AwumSz1UiDUMUwushyNnHkmr7GJsWW09fdtLFPjKOqqB9kuTm97/jxdvs6nmfRbl9PBF9p//HnBykhP0ZM13oO86aN7fzy+XkajfNJ+i0IvH1tFq5rsrv7PplMHs8zo9prPqqxylHPcejFnMvV6PXucPv2DxJ1tOfZDAa3IuesPq6rk82O0PUW7fYlQOSNN/4RtdopVLVApbKG647J5eZxnBHHjr1Ev3+XTucKut5nNBokbUuWNUAQMuTzeebmnkdRqrRaV+l0rhEEYJrt6KYe9j7v7LxDPt/AdR0sa49e7yaCEKBpx5GkLIPBBoPBJqpapdu9geMYDAZ3GY+7PP307/Krv7rHjRtf4uTJ1zl//t/h+6Hb1TQcZ0AY9YZp6TByFaLfLXxfRRDyiKKPLHtRpBxHtGEUa5phlCoIYQvScBhQLMZRrc/6+s/si9ivX/8qJ0/+64l9TUfI5qHfnbAOCoYBmUy4z1zOi7YXb8tDFEtoWhHXdbHtPlDA80Y4zgjIIMtZCoUKtq1jmuHQhXx+HtMcIEkarjuKMiqZxH6yWj3HeLxNv3+Tvb2LhGMoc4xGNpqm4rotBEFFkhSKxTl834zmEl/Csgw8b4QsFygW51lYeJ6dnQuIosBgcJfl5bN87Wtf5zvfeR3XbSGKPk8/vUqjsUAmU2I0Chdk/f4Gvm+jqjUWF59nMLiN6xrcuPEn+L5Jvf40r7zytxmPmzSblygUVhDFcKF3+/b3mJ//ApbVZzC4w9LSy5G/9m4yS3l39wLV6hq2PUbTyrTb15N+61iPAaDrrX0+19OCq8NaniZxGJHGfxOEe9u/NxjDpNNZR9NKqGoxSq3vJ+4Un12khPwTwHjcxDDCC06WwyETKytfTmrEzeZlNK0cmT6EkU28Qt/efhfT7JHPL0UuWC6DQTgFJzSlAElSCQKXVus6d+++we3b3yOTCaOjXK6GqlawrB65XAXHyVIqHY8UwFlsO3SX6nSuk88vkM8vcu7cL3Hjxh+hKCWCwEeSBGRZQxCG+L6PbffJZHKR3eaQTmeTbvcWxeISpdIJ8vkFwtSqRz6/gKrWaTb/Kbrej2rqIo5j0ulcp1CYo9O5yYkToWdxNltjPN7Dcca4roNtm+h6E01r8Oyz3+Gpp/4NgiDheWPCiHcWfMIWozjV7EU/QwSBjuuOcd0h4SCNSfK8F8HGi6IgIKoV30uBr639Ca+//vcSUl5d/U603wyTZh8xLl/+y6yv/wxra3/C+fPfvu/vcbuTLINth6QctkT5hA5eNiDh+040JamH4zioqo0s53EcA0EARVGxbRtBCFPukmSQyQzwPIdMJs/i4nNIkorn2Zhmj273Fpb1W5TLx7BtA1UtMx63abfbeF6b4RBOnVqk0aiRyxXQtAZBQGRGoqMoWQQhTzZbZXn5VUyzg20P6PU6DAZbVCpNXnrpeU6cWKTZvIEgDCmVSpGyvR3NW1bI5+fxfQvTbLG5+SMMY4Dn2TQaWSzLIQishJR6vXWefvqXKRaXaDYvsrv7Ibq+Ry43j+97GEYXXW/Tal1ElhUcx6DTuYaut8hmq2xvv4dpdhPLz9AhS6BWOxMZo7j7ouppcp2eozzL5/owk6BQ9R1+j0JXNaLveBVBkPE8m37/TuQRriUdGik++0jP8scMXW9jGB1McxD1G8vJBTw3d57bt3/A7u57FIvLzM8/G6XcuslFmM/PUSwuA0E0tF5ibu5Z+v27LC29wHC4Q7W6xubmm+ztvU+vt46qFslmG2hahVOn/jx7excxzS6mqaNpBZaWnsN1DY4dCygUjjEY3MF1XRxnhOsavPfe/0y7fQVZzrK5mWc02sa2bWx7FA0Z2IsUvscYjZoMh3ejOnGWxcUv4/s2d+++gWkOsKwu5fIailLBssb4vsfVq7/IlSuv8Nxzlzhz5l8hSZu8+eavUa2eolBYxfdNHMdAljORSlZCFH0KhQXG461oAtRBqWEm/jZZp5Wjx33CFp894mj4HiQUJY9tW3heGHmHCx4i4s5Er/c4f/7bfOtbv8z6+jdZW/su58//DuGghoDp+vDly3+N3/zN/zVKb/89vvWtX+b8+W/fR9K6HkbGkgSVSpZ7CwmfMHUtAmLUlxsvNMTEYazROIckZQjHNup43oDxuIdl9ZEkmXL5eFQmCdurYlJ2XTOa4JXDNH22tnQ0LVwciKLI1au7FApFcrkyoS3rGM8zUBQNRckhilKUIcklAj9ByOA4Bq3WNQQhgyxLrK2dA/xISBZOarLtIZ7nsrj4IqF/uoKqVqKF3jU2N99AVQuMx3sMBjucOPFVVDVsaYtrtoPBJqNRG8/zsKxw8ZHNVpiffz4ytlmnVFplbu483e46ptllNNqm0XjqvozW5JCIGAeR60E+14dFzoPBJltbb7O4+IXEMlfTypFTXzjbOXYiAw5Nqaf47CE9qx8zcrk6tdrpZIZxWKN191nmmWaXSmWNubnzAPsUoPFNotO5zni8Q612KpptPIjU1w1se8zS0os0m1dYXv4Kvu8QBE4yq1jTynieHhlrZLl7901UNYskhXXIsJYcmlV0OreiecUqqlrA86Df30RRsrjuGFlW8DwBTavR74c3N0UpomlFFhefoVZb48qVb9Pp3CYIzGRKkKZVMIw277//DX7jN/4/iKLL974n87f/9pjz53+f4XCbfv821eqZSIVsRtGWge+H9oz5fAHD6HCPqCQOjpInIXGvnuxPPBaqnu8ZfSjYdpgGz+dhNCLKWkCxCGEkfe+SOX/+21PR7qRhyD2sr39jSpD2M0CW3/zNfz5B0n+V8+d/h1wuICR+CKPiSYjEC4oQGWx7GNloZiI1vMBw2EPTcvi+i2layLJOJlOm19ug07kVKeizFAoLNBpPI8uhs1WncyPyBL9nSpLJgG0HjEZdZFlEUQoMh5uRj7pOEPiMx3t0u5epVH6BTudGVL8NrT5Hoz1cN6wFO84IQZDQ9RaDwVYyIEUQNATh37G6+tN4nkGptEi3ew1JUggHbRSSFLaiFCkWF1CUHBcv/haLi8+zuPgiOzvvsLX1FoIAqlqiWDxGo3Gefj/sCqjVzqIoBebmzqOqRcbjZuKHPR3dHrVWO8vnGg5PVxtGF8vqYVlDFKWArjcnHgvnNq+u/rmkbDU5WSo8n92HOsYUny6khPwxYXo1a1m9xO0nbNVwkaQAWdY4ceLr9/UhT/YlVqsno5SxQDx8IZ7w5LpWss18vo4giFQqJxiPW5hmj17vNqPRNrncPKIYjj4MzTJsDKOTmCDkcvMYRjtKrXucOfPzzM8/w3vv/SaKogJCUsf2fY/RKBy/J4oZisVj1GqnEQSfTucqth0qly3LAkKTf8vawDBaXLnyEoLg4vsyouhy8eJzrKz8Bo5jI4oCvn8LRdGi6G0QKYxtfN/EMNyoJxguX/73WF//RU6e/D5PPfXPj3BGponbJUwJT0bIRvKbIGQpFIyp13gcHpkTHdv+yHdt7Qe8/vrfjTyoZTKZMevrPzVF0j8dRdlx/VmasWUnOu4i2Ww1fBfuCMexEQQvinZ7gI+u65Ha2sF1RURxxGDg4PtDfF+iXD5GNjtHELgMhwG93h7Z7ALZ7AjLIiIDUFUfSQJBsBmPw7LLsWNfxHFGiKKEIChoWolsdp6Nje+jqhUkSSGe5JXJ5JEkGdvuI0kiopjB910UJexLD1PtDrZtsLPzLgsLz9BsXqLbvUU2G9aTw+eEZQ7DCK+PS5d+l8HgDs3mJZaXX2Zu7hkajacRBAHD6GPbQwyjTa12hnBQyVpi3FEqLSPLGrrepN0e7rPFnIUHCaseZlhFXJuu188kZKso+cRKN5erI8vavkg93n8YLc+l9eTPMFJC/pgweRGHCK/60BD/TUql1X1TXWIbvk7nOtlsPYmWwx7MYaSsDYcWhAYERCPrtGjIezhOb3n5ZYbDHVZXX2Vz8y16vdBko1Z7lkxGRNcHUbruHJKUxbK66HoXSerTaoVK62JxBdc1uXbtjxgO79Dr7aKqWYrFYzjOGFnOEgThYsK2TUajHbrd2+RyDebmzjE//yz9/gamqWPbLqbZx3UFFKXMuXPv8frrIRn7vsyJE98lCBwEIUimNfm+gyBI5HIN6vWz0WPQ79/E9wdcvvyX+c3f/DdRdPl/4Fvf0mfWZQ+q2+5//HdnPi+0o7wfD6oF7z+2OD39L/n61//vvPbafwV4vPbaf83Xv/7fJmQcqsb/hGmzkPsRG4z42HYHzwsXPCASBD6ue88bWxDEaFxinPqsAz7jsRERqYxh9NjcvMrOTujL7XmwvLzGsWOrrK9vkM3CcAhnztQolxcBF0EQGA63yWZr0TAKGdd12dz8UVQbdRDFPL7vIIoB2WwF2zawbYPl5VcZj7cRBBFBkJCkAEHQyGZreJ5Lr3cLQQgol0/jeQa63mRn530qlVWKxRVMMxRcDYebOI6VGNjs7V0km61w7Ngr5PNzKEorSonPJQRnmv19xh2HGfdM42HHIR5m5CHLGgsLzyWvjwVmltUn9qwuFLR925g1xjXFZxPp2f2YMH0RT9rhiaJIOJVGZnJ6TKhcDqc8hRfmvXRY7Kdr26Notm0BwwhVtJ3OzShyaDAc7uB5FtevfwfbHtHrXScIBFz3Dp5noyhFOp3rCIKPooQtQKFlZCmysaxTLM5z8+Yfsb39FpY1wvNMBKGOZQ3IZFTK5TU0rcYf/mGBN99cYnHxt3n22T9GUbJkMrkokhIAnSBQGY/3gIBS6QRf+tKPgL/Jzs5f5emnP6Ra/TYgIYpKNN5PJQg8PM+JXKTuYhjdaMhDGOVOK5zX1795HznOJsZv3/f417/+/+C11/4vD6zvHrbNSRx0bI6T2/e44+SmatB/QJg+j6PwSfW4QBjNy8AY8PA8Y+rvAaAiCFqU6g0Ff44Ttt2FQyYUZFnG98VI+NSl1xujquFWLAv29tY5fvwsJ09WCAKR48cLOE4Hw9hFEFQEwYumUlmoaokgsCMzEYXxeBgRdD+q84YGHYbRxDQd+v07uK6F7ztRy1MQqf9FRDH0QTfNLvW6RKl0ktFoi8FgA9Nssbz8FfL5RQqFY4iiTKdznVrtJOfO/RKj0S7d7m1arStks1UKhcXkums2Lyfai0plbV96Ou5FftDQhsPGqMbX+MPWdietdcMec6hU1mZGv2k/8ucH6Zn9GDC9enZdk/G4iaKEk25OnvzZfXXieHUem/qH5h5mQsYxMYczk7vkcvOMx3uUyysMhzuUSiuoajkZNddu70bpuGsEgU+5vIJljRFFn2437BsdDHaiFplldH0naotRoolRJppWpV4/j2X1I9tCB0EQ6Pdv43kB3/62yD/+x/+3iGR+hV/5lb/J3/gbWTxPjxYYcSvJPcXxYHAbTavzzDP/ji9/+QKG0Wc8tgA5ctxyopGSxWhaT4t4uMNkxDitcF5b++595+AgYpx+/Nq1X7zvecBM4j3KQuCgY5v1+L0atEpIqCFphu81JuRsUksNXcV8JlPrIeLnegSBRKEwj+d5kdGHCYwZjSyy2TK+H46bDNPZ95Td4ePhT9PcAlw0rUImo+G6IpZlA2ZUn51DlnMYRod+fysSBA4JAhFZziDLKplMnlptLfIkz2EYXcrlE2xv/xgQ6PfvkM8vIIpq1M5XpFwOLUlNc4CmFXjqqb9Dq3Uhck3z8X2bEye+xpUrv5dcZ4Igsbj4QmQOs588B4NNLlz4IXt7e6ysPMUXv/j1Q9uYHoTJ61pR8jSbl6hU1g60vTwM8f5kWeX69X+Hqub31YunRz6m/cifD6SE/BgRX7DhBJh1arUzlErLtNvXabUu025fpVY7lfjqNpuXsawBo9EOZ878At3uOqPRJuEEodD0o14/Q6GwQLt9neFwC8PoMhhsEgQ+u7sXOHHia/fVmkIzEYvxuI0oChQKx4AttrYu0evdTurL4KEoFRxngKIUWVh4Adc1aTbfZjRqRj3CjSi9KOA4o6i/9Rrvvfez+8jp5s2X+OCD/yYi/37U1jENkcuXf4nr17/ECy/c4uzZf0kYtYXjAj0vTGWDzPvvf4Vbt74SRai/zyQh369wvj91fFRiPHv2d9nZ+SKhDWb4vIOI9ygLgYOObf/j35s65sk2qWkhl4HnyYCFJIW2nQcL2cLHdb1HLldG10eEQrMAMDAMF1UtJ4tBxwm9vGMluaIQOZnZyLIWaQDCBRkQuWoVyOUWkGU1GaEYR8JhGSOD61o4zhjft8lmC3jeSWQ5T7N5EQii4RM2ut5C02rRRDINRamRy9UYj8PF4ni8w8rKq9y58wa5XOj9/qMf/eOo/11gbu6ZpJ1wfv4ZBoPtfannX//1/4F/8S/+v4xGNplMlv/oP/p7/N2/+38mnEO8ndjWHnUYxCQpjsfNaPDK5ch0pxo952ikGS8ctrffZTDYQFFKLCy8kKiwy+VVMhkt2VZqo/n5QErIjxHxBRuLT3x/DQiHjocqyXtj4nS9HfUOX8Y0e2xuvsny8iuMRruUyyt0u+vs7r6LrrcoFBbIZMI6GASRarvN0tKL+/Y/edEaRpdm8yKiGI5bNIxTVCprXL/+b9ncfIvBYAvPsymXQ2OMpaUXUZQiopjBskJrxw8++FkuXHiap556i9On/zW+b2KaA0RR4tSpH/L66//HfeQUBGMGg018PxYfFQj7gQFkbt36VX7jN34NQXD50z+V+c//c5ennvo9DKNFECgIgo4gKLz11sv7FMjnzv0OL730T/aR2P0K5/tx7txvAwEvvfRPDyDG78583UHEe5SFwGHHdpRjng0rsoaM1eKHwcW221GKP27zmvir6+P7w+Tv8/MCw2HoSBYEoZpcVedx3QFB4GKaOuXyGpXKCv3+JpKUo92+giRpmOaYIPAIghyiqKBpDcbjTTwv1A00m5cYDPYQBB/D6BEEDqoatvXE14FljchmK0hSIbFX1bQ5fN/BMHq89dY/xnFM5uefTVoHB4MNKpU1er2b3LgROs41Gs9j2x00rczy8iu8//67/Pqv/w8UCgGLi1UGgzH/5J/8Q37u536RZ545z3jcZDTa2mdb+6CU8OT1FRN/PH4xbmO835f68G1ms1XK5VUqlZMUCgvs7l7AsnrA6j4BVzpg4vOBlJAfI+IaseNsJ5EIhEKOev0M29tvoapF4nmtQQCrq1+h19ugXF7FNPsUiwvIcqj+laQsqlokk8nS621EqcYMuVydavUEtj2OJiOZSQtVPHpubu48o9Ee4/Eu7fYNcrkamUyepaUvJa5IluUxGGwTBB6XLv0bVLWEplUpFOa5fPkv8d//938fUXT5wz/86/zKr9zi+ef/BNf18H2Tc+f+Od/61oD19Z/l1Kkf8cwz3wcqgMPFiz8X1V9/wPnzv8fly7/I7dt/nm73zL7I8/33T7G8vI3nmYnxxoULP8N3v/sPCNOv4ed39eovcfXqvzezZvugWm8QyLz00j/d95pJYvyDP/jv74uGf/EX/z7f+tYv8847fyvyj5792sOO4dERtzZNwk4eHwyCSPUMudxB23CnfsZw8LxOFAVnEMVwvnPoQKZEz8lgWc1of+GwDMex8DwXCCJf8zHZbINKZRXHqeD7YNtDdH2PIAgioxowzRGWZZLJaFGdWItmUZtRjVkhlztFqbSKquYwjB6+79BuX6RYXKLbvYogKGSzRSqVU5hmH11vUaudQVHyaFoZXe+i6+FIS1nORR0ILlev/hmKMqRWK+N5IrJcp9drc/v2LdbW5pKhFfFUq6OkhCdJURRlFhaew3VNZFmjWl27j3yntzmLoEPF9zeSxyZV2BDWwOv1M9E94R7SnuTPJtIz+RgRi7QkKUM+v7Dvwg7TWnUsaxi1ZPQiMw2JUmkZ1zUiF685hsNtBoMtVDXL/PyzWNYQTSsxHN6lUFhC18NpTqGq1cOyRqiqwNWrfxApU9+jVjuJ54W9pd3uv2Nx8UXG4yatVmj4kc3W8f1QtR22XKhY1kY0EH7Em2/++4kSOkxJf5lz536LUEAU1utCcvpdAFxX4PLlX+Ltt/+3XL36y0l0+41v/L/4/vf/bkJ6wETk+RquG7pKAfzRH/1XvPZaSMb3osHQQ3pWzXZaZHXu3G/z0ku/fqRab/z6TufUlNr5u8nfr1z5qwiCy9WrfyXZ9lHFY4+OWerq8PFOJ0wrT9pshkMoZuFB/dkOvu8BCplMAU0r4/teIsC7Z/UpoOsdHMcmm1WTHvdwZvEIxxkSDgIxCD3DXVw3rHGHP0UkSUWWSyiKiCAo+L5POId5TC63RC5X4vbt1xKnuGLxGIIA2WwDRTGQpHD2s+cZqGohGsmYode7hSyHH4BpjikWcziOwY0bf0yp5FEuyzjOIJoiNqJaVajXVfb2PiSbrTE3dz6p08L+GeT3JrKFWojptPYkIS4sPDfTtWs6zRzOUL6elLJg9jzkhYXnANjdvRC5iJH4Wqc15c82UkJ+zDioRWFy5Fu7fZ1MJotljZJU1aSAI7w5utFAhDDlnc1WaTSeotm8TLP5AcXiChBe0MvLr0Sm9Daj0R6j0Ta7u+8hyzlGox1c18C2xwyHO3S7NyInoAzjcThIPrzJjRGEIJrGM+Ls2Tf44z/+30wQ1fe51wc7iZBAYmKK/3/P43k/OZ49+zvUajdZW3udF154C9NU8X2da9f+RkTGsYFHTMbhPmbVbCeJF+Dq1b/M1at/ZUZL0f7XTR6vIITv59y53+GLX7yX2j5s246TT6Lho5L/40AmE/YGx4Ts38fd4SCKgyFzTzAWO4rZkYjOIAhcJCkcxhE6lbmMxwEwxHGGVColRDGMpA1jgGGMEAQZVVUQhByC4CEI2chopk/8XfA8NzreDIoiUSotAiK63qFQCNvmQp9tm2PHXqTXu0M2u4RltdB1N5kKpapFNG2eQuEY/f5GNO4yQz6/GEXgKq3WFRxnRLEo8hf+wl/ke9/7HUajNoVCjl/91f+AEyfm6XZvEffHT6uXJ+cP63o7sdWcjI5932V7+116vXWWl79EpXJipmvX5GOj0S79/gbjcZNKZe2+MzOLYOMouV4/c9/f05ryZxMpIT9mzFrxxpFzfKHFYxVlWUv+TbZcyLJGubxKq3U5igK0faPdwr7kIpbVj9x7elQqxyODhhqqWoxmFr9KoTDHxsaPUJQie3vvIQhCRNRtJEnm4sVfZH396xw//l2effbf4vsCjmPw7LN/wn/6n/7vuHz5C5w4EadiXe75KifvGLifwGISPXv2j9jaeiGJtl966X/k/PnfBmQsq4DvjwCPGzdeiYwz7pFx/P9z5/7NvjpwjLjWG974Q1vJuKXo61//b7l27S9y9uzvzyTIt9/+z5JjDI+byEEL1ta+zfLynxAE+7cd9xBPRsNHEXo9LsgyUQtTSMz3E/KDTEtcQkV37N0dkvJo1EJRstj2OCLcUDg2HofPkqRQ7LW9PWBpqQo4DIcOphkew8JCEU0LsG0T37cj57DQBU2SVERRwHFsJElAVbORgC+IrDUvYprLCEJANruUDFixrBGSpNBuX6ZaPUuxuIKu70SWoBkUJYfjDCkWlwjHPeaRpFBhLoqrNBpnOH7867z88tfpdnVWV8+xtnaMcnmF0WgvGToR7i9clE3PNA9d9s4mf4sRz14OHcDOUKmcmOnaNdnaZBhtxuMmoQ3s/bfdWQQbW+fOmjyV1pQ/mxCCYLYedhKDwYByuUy/36dUKv0kjutTick0lq63GQw2sKwRq6tfeWANaNb/Z6XL4sfjVqpu93Z0g3PZ2nqDfn8jUkUrLC9/GVGUqFRW2dn5IFJYN5EkmcFgmzfeeJ7f+I1/mpDJt771N3j++T/GdZ3oxhlOaQqC6alKGcKbepbwxju+r2771FO/z9e//nucO/fbXLr0F7h27cusrPxuRMb3497rQxJ+5pl/Tqm0eah4Kn7dO+/8rSS9HAQyX//6f5sQZ/i+fnlmqnsa8fP/+l//Zc6d+zbXrv1l3nvvb3H9+l8lJub4+ATB5ZVX/t/8pb/096Ma8uFCr4OO/WFrz/GYxiA4LF0Ns2vRB0HjnjPYvXNtmrHqOvxpWTA3V6Hf72GaYfocwp/5fIYwo+ECIqKYo1RapFBYYDDYYjwekc1myeUa2HYPWc6jKLnIP3tApXKKhYVQuLW19SNUtUw4anSXanUFVa0zHt8lCASq1TMREYejSHO5KqXScfL5sCOgUGgkRAok0e5otE2rdZ1+f51KZY1a7Qzj8R6CIHHixFcRRZnd3Qv7HL4gJMHJDJbvu/T7d+h0brG6+iqKUpj5qU6af8TdF5Y1ZG7u/H33g8nnx/uJ0+C53NxM8k3ryJ8eHJVD07P4GDFtFtBsXkLX27Tb15O6UIzpFW54w9jZ14pRKi1j2yNu3/5Tlpdfiez+QhHKYLDBeNwiCDyGw23a7Utsb7+DbetoWolMpkCz+SGOM+TuXRkQqFaP4zgGur6Lrve5cePPTaVbv8FLL71LPi9EHsQDwhv7tElFqKCOU2mG4XP+/O9NKJD/lC9+8U3y+SqyvMiXv/wuZ8/+FrbdOuCTk46sYJ5GLLKaJMX90brPa6/9X/cR3/Tfq9Wb9HpryeewsfFNzp37NmfPhscQEnKIkIxDwZks65jmo6mnH7X2nM8fdQ9HJWMI68X3E7hth/9iEVm4ABgwHt+bhBU/L5/3iev9oCKKEr3eHsPhHpmMhiCYaFodURTxfZdCYYETJ76RaB7C6U9jZDlDLjdHJqNFphljTHMIiMhyBU3LUyod48SJr7K5+WNKpWWCIMzSLCw8hyAI7O5eJJ+fjxzF6hQKC2hamWbzEqIoYFkjisUlVLXIzs47FIvL0fe4y3i8h22PGY+b9HrrBEGYMp4cCpPL1ZEkFUmSMM3+gYQ8eY2XSsuMRrvY9ohm8zLZbDX5+0EisOmI/WFGPKb4dCIl5MeI6frx6upXkl7iByG+YTiOQa93k+XlVymVltncfJOdnXejVJ1JqbRCLlfHcXQMY4TnhXU833cj5yQZ3wdVLVCtnmI43KHdvoJh9KN6so1ldREEm3Pnfsyf/unfTsjp9OkfIoourkukqgXwEYQCQRC3L8U1XonBILS5DP2KG5w//3sJqXheDUlaoFg8lrRr3Y9woQDOIyuVJ1/3i7/495PHw1Q2gMjm5lfY2vrSgWnm5577zX0R9fHj3wXg2rW/zGuv/TfcE5l5LC39mO3trwAeP/zhf82xYz/i+ecfvmb8k6w9Hw0xGWeS30slke1tB88Lo+BCAUBF04yEpJ1kcqVEuFAL092hoEuI0stFVDWLqjaAANd1GQzucvPmdyKCazAa7XDr1h/9/9n78yDJ7uu+E/3c/ea+1F7VS/VeaAAEsXABKZAQoYWSzMWmx8LMvPesoWyHHePlyfKL8fOTLE9I4/efI8bzZsJjh+iQJdPgzIgSCS0USZAAIQIgCGJtNKq7q7uru/Yl98y7L++Pe29WZlZWdXWjAYJCn4iK2jLvvXnz5v3+zjnf8/2iqmkKhSNxlSbD+PgHKJdP4XkmrmtRKBylVDoCEIPlKUyzzvb2OdLpUURRYmvrXKyBbtDpbJPJjAHEHIstMplxXNdCFCMHrFRqJP5/pOg1Pf0AENk8Rn7iq2Sz46jqjrlDRJi8Qi433deagr0z13R6hE5nC8PYiNXyJA4d+nC3HTWsLJ30tZPfD2LxeCd+cuMOIN/GGMx6E93aJPYrMVlWg1SqSBD4yLLa/fvMzENAJERw9ep3mZ7+EJqWo15fxHU7sV1gk3p9iR/84EHOn7+LU6de4qGHXkJRzuM4TXzfxPMMJCnyepXlNIqS5wMfeIa/83f+IW+9dS+zs89y993fwjRDwjCI+4AAKru7Gj7QiG/GArI8iSxLRP3liGHruh7t9jaGEdn7ua7FhQv/NVevfoTZ2ad6wCe45Wxxr+fNzT3J6dNf4+LFz5Bk+EmZuXesKcmoZ2efZHz8Ra5ff5QjR57m1KmoXP2Hf/h1+hnfElFvewdIr19/9JYAeXBRoCgG3/jGv7lNo1NvJ3q9oUOmphQikLaADOBSLkezy74f9bJLJYmdXnsE5oKQQpazRKSxTKy1bSEIIrIs4zgWjnOZIAhjI4rI4zmTGccwUrhuh5GRs6iqTqEwE8/rVwGHfH6c9fU3CcMAVc2jKBrt9mpsShKxvwUBDKOGLKs0GkuYZpVabRFVTeP7LpoWeY6Pj9+DqmbY2DhHrXYtdpq6ytTUBykWZ6lULtNoXKPT2eD48U+h66W4bbSJbTepVq+Sy03SaCwBdHu+CXAPksbGxuZIpUo0GkvxgnaHJDmsL7yXxeNej78TP9lxB5DfxdivxJR4opZKs123FwBVzXLs2KPMz3+9ayIhSQph6FMun0XTFC5d+g7f//5pvvSlfxOLbvxdguBX+MAHnkUUFSRJQlEysQVijVZrOc4G4NCh3+PQoQ4g4DgampaLR0kKGMYWipLG951uL3F3hNh2A8eR2WFgSyiKRKezwfz8z7K4+CkUpc2zz/5/YvD8Jzz++Gc5e/a7BIG3K1tcWHiUI0ee3GfONgLjp5/+V93y8WCWOTHxBhcvfo4dtnY/UzsBbjNWoTx1aqdEreuwstJb1t4hmWUya30M7iSbvlEMVgB6S/TN5kycofu3aXTqds1GB/FXAtIGifVlZEepAIX474nRRRRhaCGKeSILxjq+H4nG5HITiGKWMGzhuiFhaOE4HTQthaoeRlXTsWlEA9v+AaKo0mhcQ1XzyLKGJGW5fPnbZLNTFItHqFTeIgjcrthIvb6Iro+wsfEGvu+QyUywuXkO06zh+wHt9jrF4izV6lXS6aicffHiN1hff40wDNjenmd0NOo/R+5qZURRQpa1brXLsuqx9vUUul4gDMOY5LVMsXiEmZmPkE6PxVWvHdJYL5DmclP4vnXD3u9eFo934q9m3AHkdzEGS0yDji+mWcG2G4yOzu36oI6P302rtYam5djYeBNFSVOtztNoXMG2TebnH+kDtUuXHuLuu78V2xVqeF6dbHYUWdYQhADfj1TD5ud/nsXFjzM7+13uuusZQEbTShjGGmGo4jhtohtvMjIz2JuMvHvDsNnzNwnf95mf/1meeOJrPcDm92SWv8QHP/gSltXZlS0eOfI0ohiRihYXPxMzounOAe+QsqLsNQHlXoaz62Z6WNs+pdJVUqlKd1tzc09iWTu90EuXPsO1az/N0aPf5d57n+xhcPfuQ2Js7ByJmcN9932pC+L7xWAm/4UvfJZTp55kdjZ6bvRakizef9vl6zfeiLL73v3dShbfHyLRe534NfuAiKpKuK4Sj+iJRAz8yCDDttfi56ZIGOC2bSBJNr4foCgKQZCKxUR0isXDtNuriKKM7xt4HjhOG983yWTGGR09ExMNDer1y6TT4zhOpOyVz49Sq12PhUccFKWAbV9H17PIsobrOui6wsbGEsvL6+TzM1SrF5iefoB6fZHIBUoilSrheRZTUx/EcSKaua4XuHjxG7EKnU82O04mMxprduvoeolicZZC4TDp9CjQq8bnIwi7vZJ1vcTo6F1dPfu9yJ0HiTvkrr86cefdexdjGJErGYsIQ59UaoRMZmzoh1QUZTStyPLyCxjGFqXSERqNdVZXf4TvOxw54vLcc/99F5w0LUBVs7H1XZMgCGg214n8kMsEQcgbbzzaJ1H5+OOfZ27ua9j26sCRW0QymD79xgYikB7yN48gcAcy3x12chjKHDv2NJYV3bCTbHFh4VEOH36a06cj8Lhw4TP80R/tsKEvXvxcnFX+dB/IT0y8yqOP/o99IDYI8rXaSWq1k93tJKAIdMvTguDx0ku/hqJ8ti+DVRQD102jKEZfr/m++76EPtwgqC8GKwDXrz/aQxj7aXrL4mEooSjGjTe6T1y71r+/a9durazeHwE7LlSJ9raH45hE7/9+sp4uqlrEcay4ZZKnWCwxNfURNjffoF6/jiQpmOY2htFG03RKpUgeVlVLFArjpFLj2HYDy+rgeSbp9Ajb22+i6wWKxWNsbr6FaW7R6WySy82QzaooSopMZhTHMel01mLDDQdZTuF5NqKo0GxuIYois7OfwHVtLKtOOl2kUlkgl5vqMrSjsvbrRGYtM3Q69a4feeRtriAIemz1WNs1qjTY903MIwyj0i1vJ/saVkXbz8DiDrnrr07cAeQfYwx+OAfHHZIxCU2LLBMbjWVarVU0LQeodDobsWa2xNzcn3atBMHnu9/9x9x11xLHj/8hhtEmCFqxRnU0SyyK0q4b9+LiJ7pjSbtLnm2iyyX5SuQcTfrnkhNhEJPZ2e/wwgs7Kl2RqEaa2dmnd2WWc3NPcvTok93ZWt+HpaWfZqc3GcXLL3+RBx74Ul/2OmzWuBdQq9UTPf3k6Bhfe+2L3Yz4tdf6Z5KfffZf8PTT/4pTp/6sjyg2KLO5snIwoNtZHOywsyFaCNTrx9kR9Ii+P/vsbzAz8+I+Hs7D95k8RlE6t1RWv3G4Q/5mxn8X2Rmdgp155wBRzJBKlYEqsqwThg7l8ikkSUaSpNhcJCCfP06zuYrnSdj2CqOjZ3HdDqOjZ2k0Vmg2lzCMTTKZCTodC1FUabXWYl3qdcLQR5Yz+L6NaTawrCq+7wJ+PLtfIJ+fJgwlDh/+EJ1O1JMOghTV6tVY3zsibEWytEtMTz/QnQfO52dw3Q7r62/gum2CwOfYsU8SBF5s8+jiOG1kWUfXC0N7vL22j83mEqbZYGTk5K7q2WBper9e8h1y11+duAPIP8bo7Q/1RvLBarXWqNevUiweQ9MKtFrXMc3ImN7zLPL5I4Shi2HUEAQf1812b8Ki6HPp0kOcOfMk2WyRdtuJTR8ADIJA5ejR7/H97//9XaIWe5OsPKJeaoYwtNhvtCYBh14QvlEZNpUCw9gZtTl58ru89NKv9T1GECKw3Zk1Hg5gsNMnfuqp3477yd0zH48y+bu2H4YyKysfBULW1yO27WOP/SZwMNvHYdF7vAk7G+D553+jqxRWLF6lXj9GVB7v74cfhPQ2OAf+8MO/g+eluyS1dy76SWA77Y3oWoHoOo8EaXQ8z8D3Va5c+Q7l8iyKksV12+h6jvX1V3FdD9OMKjQbG2+QThdZXPwenmfieTayHBG+II0oRv3sdtslDCUkSWFm5iHCMBrBMs1tlpd/SL1+LRY90ZEkBd/vsLV1Hk3LEwQesqyRTo+wsrKCphVRlBTZ7CSGsU27vY7jtNG0ArOzj7Cx8SYjIye4evVp2u0N2u0NRFEmDH0qlXmy2Slyucl9/ZVhZyzSsurYdgugWxUbluXu10u+Q+76qxN3APk9EEnJKcmIkxVzpDFNbBSxQT5/jCBwse0O9fo1yuVj5HKHEQQN06xw+vQrvPBCBMZR1vwqophoB2sEgQi04r363HXXn/Pf/Df/Ddevf4JDh77J3NxfADcayQkJw8au19CbwQF94HAwkpIEiKTTiRqYPQBkUaZ8//2RUUTUI96ZJX7llS/uqVedAHcYSpTLF6hWz7DDmk4WFRFDWFWbOE6BpE986dIvdAH5VmelB4830gb/hb7fJybOUa+fHAr2BxmRGnyM56V57LFfZ784GPFrp6qwf/RaSKrs3FoEVDWDquZwnDZBIOJ5VUBFkjbQ9Ujvul6/hiTJ+L6HJGXQ9RSZzCSNxnUkScLzfLLZiVh73SQMA2ZnfwZJkmKDlU4MipdJpwsIgoIkKWxsnKNSmUfXi4yOnqFUmkVVM1hWC0VJEwQux48/ytraa2SzkzhOJ5aZ3YinEkJMsxa7UJWQJDlWNssDHmtrr5FOl0mlioyNnSWVKpPLTd0wW03GIre25tG0HO32Rl/pOgnPs6hUFiiVZnGcThewB5UA34m405t+9+POWf4xRxB4eJ6F73u0Wmusr7/GxsablEpHcV2D0dEzXVWfVCpLEBxhefl5DGMD8EmlRpGkyAHqwQdfpFT6Lc6fv4dTp17k7rufxXFcbLvNuXOP8vLLvwIEXXKU73ucPv1VTp/+Kjs31BSzs9/rloSTkZxh0Vsi7ZWUPH36azcEkN7n7wBCQuXeubk/9thvMjPz4i4Q3CFdAYhcuPB55uc/0yVrJTHYx263k5ud0H0u7Kh0nTz5F5w//8skzOpTp/6875hnZ3fIWDcTg9n16dN/zsbGg93f77//S9x//5eGgv1BMvNhxLgwjCoKw/rcBx81uxmBkd4ISchdjhOJichyBkGQCcPEPSpAklQURWN09CSSlKLZXMSyOqRSI4giuK6F74tMTz+EpmUwzQqbmxfRNA3X7bCx8Ra2HYFrJjOOoug0GkvIchoIyOcPI0kSudwRRkfn0PUsipKhXl/EspqEoc2VK88QuUT55HITpFJjRNKhW2QyY7huh0uX/oy77/5bsRVqCkmKDB62ts7jeSanTv0Ck5P3ddtPBwlZ1snlprokr167xSQqlQWq1UsYxjaZTEQY26/XfDvjTm/63Y870pk/5mg2V1haeg4QyOcPsbz8Aq5r4boG+fwMx449iuuaWFaNpaUXSaWK1OvXWF19uWupmKh1JY5RgqDQaFyjXD5OvX6d55+/hz/4g//Ut9+9bsDz859ncfFTNJvjnD//y+zoSfe7HfWbSfRLSp469SdcvPj5fTPkwRLrrYz6fPnLf9ztDQuCx0c+8m959NEoK3zmmd/m8uVfpFS6xIULO69jsCddLl/g537u/9VD3sqwsvIQlcppZmef5m/9rce7j+0F+iQOQurqfc29gHszkpv7PTZZ2AhCZ1eZ+tKlz7CysjsL/sY3/g0/+ME/6i6aPvKRf9vXL397kYyKJQusFBH46qRSk3Q6S/EokEwqVSKXm0RRdDStxNraD/D9AE0r4HmR85iiKJRKpxEEEU3LEYYegiDHJK8mmpahUDhKJjNOVMERyGRGUJQ0xeIxlpefw/ddVDXX7e1WKgt4nkWpdJxUqkCnU0UQAgqFQ5TLp1HVDNvbl5AkhUZjhcuX/5xy+TRnzvw1Dh/+MK3WOoXCIa5de45GY4mTJ3+GcvnEDeUuB2M/RykYniHfiI3dO73Ry005aCTHlJTHhx3Xnbi5uCOd+RMVUbaWy01x111/nevXn6dSmWd7ez7W+m2wvPwDgiAgkxkjlRqhWDyEZbUYGbmHVCpNpbKAbTcQBJn19VcJwwDDqBGGLouLn6QfiIKhWWsEkn+0ixkNO25HCXAm40PJNnsZ1A888CUeeGB4tpfE7VCqeuCB3+Xixc/tyhyfeea34z5tyObmA5w9+xWq1ZOsr3+QfuIRjI6+1d1vr5Y2+Jw//8vMz//n2ybUMSix2Sv7eSNRkL3kOQcXNsPY4xDsyoJ3iF+7R8ZuPnSiW0mk5iZJeXzfILo2VCJ3KhffN2m3rxFdi9E173k2jtMmDEMqlctYloEoCgRBFc+zEQQVUDGMGr7vMjKSIpMZY23tVUxzG1nWGB8/g6YV8X0Lz3ORJAVFyca93BrV6gKiqJJOO7RaK3hem1ZrA1FUUdU0QeDgum1SqVHCUEDTsgiCRKNxlSAISKWKqGqOVmuF1177fWy7xfj4HI3GMhMTd6MoGoax3W03Ad1JiRuBYq8a17BecK+4UK9E514mNtA/vZGM9d1MhtvrcjVsBPNOvHNx50z/mCObneDw4Ye7PwNMT9/P1tZ5giDAstp4nk0qVcIwqshyCllOU6lcxLJayLLKoUMPo2l5QKBeX6TT2cK2G11RgxMnXuAv//JXe/YqDr0BD44T9WeUURb89NO/NfR1zMy8wOHDz6EoxlApy8G4HS5Jw3q6lgWXL/8iO4IgIdXqSR599H8cANzodU1MnBvy2qP+8s0uFG7Ukx32/7frpzxspOrkyScRBGL2OCSLppdf/mJ3AZAQzMJQ4pFHfudtLTo0rRiXcF1kWUfTRnAc8H0XScojSR5hmMf324himiAwkaTIftR1W7TbPpKk4rouYBMEBURRJJXKoKoavu8QBHYsDJJjc3OeZnONIIhGmLa25uOxI5nR0TO0WpEOtaLoZLOHgJDR0btIpUbpdNYRhICxsXsQBIWRkVMYxiaGIaDrUS84DEM6nXVUtYCm5RkdPcHExL1cu/Z9XNdAVdOEYUgQWLRabdrtLTqd84ShSxB4FAqHabc3qNevds8N7AbF3uwXhrOkb9THHVZWHja9cTOxl8vVnXjn4w4gvweid66w3d5gY+N1VDVDJjPB9PR9iKLMwoLLzMxH4kzBJJebxnUvE+lY2wSBS6u1hOd1CAIbVS2QShXxPIczZyLjh5df/iKCQJ/vb28MguTZs19hdfXBmGwU3bzX1z/IE098nUce+Z2YuRwB2yOP/GuAbhn7RuDydghSg9vpfa6uw4kTf8bm5gP09oEHlbGScnwETFCtHh+oCtxc5jgMWIGhRLfec/N2KwXDesdJViSK/Y9N/j5orrGx0W98crNh29skKm2eZ+N5LqIoIAgCQRBZOvq+E/sXNxEEGc9L/JJlRFHCdR2CoEanA41GhXZb4vTp4xQKWWq1JYJAQlUDms0ruG4bCFCUNKlUiVJplk5nExAIQwHXteh0NtH1DOPj9wA+nU4yFhUJ35hmhVSqzNbWPNXqRUZGTpPJjNNoXMPzTKrVRSDKUBOr1HR6FF0vks2Ox+dTptlcpN1eJQh8UqkSAIaxhetaGEaNQuEIipIZCmxJfxjYZT4DdMepEl/0YVnuXraNyWP3Y3rvFaIok8/P7Cp932oJ/E4cPO6c1R9zDA78R4zUPMXiYXR9BNuO3J4ajUVct0UqVcY067Fer8pTT5W5evUMs7NP8eCDqxjGNkEgk0rp1GpXsSwDx6kcyJFoUAwjIWoBFAr9Yzmum94FqF/+8h/HW4qQ4JVXvgiwZ9Z4My5JN5N9/vzP/yayTNcPuZclPTf3ZN88ca/HMUQSmhMT5w48qpXEILC+/PIXu330YUS3y5cfjQliB68UDDsHve/ZzEz/iNO99/5u36IpYagPEuIuXtwhxN1aeAO/WwSBjiSJ+L6B77eJyto+0bx3IiSjI8syqprHcVbodOgaWei6z8rKJXT9CKnUOL4fzRFHLksqspyKWzIyYSgxMnIGy6qhaSnCcAzft8hmJ9C0Ms3mMp5nYhg10ukClcoVDGMDTSsBIa3WdYLAIQgCfN/EtjvYdp1c7ihB4LG8/EOy2WkMY40zZ/4GkqRhmlXK5RPMzHyIYnGWVKoUg3ak0OW6a11ryULhyFAAS8rbIyMnh/aS2+0NOp0NNK2wp+PTOznylFhWbmycIwwDBEHsI5bdidsfdwD5xxjJh0zXo5V1u72OadbIZEYRRRnXtajXrxOGIZbVIp22GRs7w5UrT6NpZV588X7+t//tt+Ob+S/y+OP/FR/4wGuAiqLouK5Bp7NFxFqWmJ//xaGgNkxneVAEY9hYziCgttuTfa9va+uuA5dj9wPcW8k+H3vsN7tAPBiDINirh10uX9nzebreT+zqJXQNbnPQhCIiG+0W65idPVilYPAc9JLskq9B0tmpU/0LrMXFnwbYZb5x+92mAsDA9xPfbIjU3qSe3yWiCoaI49gkzHrfjxykUqnkZx1N83FdH8taRVEivXXb7uB5LdptB1F0cZwSmlbAdU1kOUepdIJMZhLX7WBZzZgQNUatdh1F0ZFljWx2FEnSuxUqXS+haYfxfQfHaeA4DVqtJq7bwXU7sdKXGesGRFzYpMebZJCGUekq70X79DGMylAAk2WdsbE5DKNCEHhUqwtEEp47ICuKEedhe/sCnc4WExP37Eniejtym8O2kU6PxMIrG7Tb64yO3oUgSHfK2O9g3AHkW4y3O6O3o+5j4/tu9wOtaVkkSaNQOMS5c18hCEIMY5N0uoTvu1y8+Besr7+EYTQ4d+7nB8qdDzM3938hCFlsW8Hz2oDJ/PzneOWVv8OFC39tFzju1cMcBJgwFG4o8pHNrvf93kv0utH4U+8xRPvJ7OFf7PPVr/4nHKd402NWSexVCThIiToB4f3MIpJt9BLOHnjgS9x775f6HKWgX0N7djYC1WHM7QhM/fgc7CbZ7fdaYfeCZS9C3K2FiCCkiBzCJPqlVKM+fpIdRzPKUakaohK3JEXgJggRCCdgLEmgKGa8bQ9BiPyWNa2EKEb61NHc7wyyHJmgrK+/iqLkEISQYnEWw9jGsmpkMlMIgoQghKRSI5RKpwlDG89zUNUUxWI045/JjCCKkT57EPhkMhNoWo5sdpLV1Zeo1a6SyYyQySRZ7BpbW2+RShXpdLZi5TwfQRApFo8iSdq+ANarbV0uRxlz8vgkU/Y8i0ZjqXvPiAwudkrHtzKetNu7fbgJRiYzRrWqksvNkMtNMTZ2h+T1TsadM3uL8XZm9ILAY23tVarVy+h6iWp1ga2t85w69YvMzDxIOj3C8vIPMM06iqITBB7p9ASO06bVWsE0mwhCyMmTP+Q73/lvd91Uw9DDcRr4vs38/C/yxBN/zI6kZT9o7dXDTADmlVe+yIULn+fSpV+6IQAkN/mkRDroMzw7+/TQTHgQcHtnmnv9ixN5yUi4Y+e1CEJ/9nkQcOnd982oicH+to/JNmdnvzuUcNZbUh7U0E4Y0oOZrq5HrOidrDICpt73a37+MywsRMA+qMwVMeKDvvf405/+dR555He6Zf23lx0HhGEn/lklEQYRBCHux3vxV8iOzGpIouwlSSl8v0067eO6ETBrWgTMQWABOQqFQ9TrSzHoe4RhiCxL+L4Tkx0NXNfCNBsYRhNJUllefo5MZhxZ1slkRhgdnWN9/TUymQmmpu6m2VylXr+KLGcxzU2azTU2N99gfPxecrmxuFQ9jqbl0PVRRkfPUC7PUSgcxnEMZFlje3shNpgoMjp6knY7h2nWuqA59Gz1lKeH6V0nMajkV6ks4Ps2lcpCH3v6ZqQze/vCSYWu3d5g0AQjiWx2gqmp+6lULuB51tCy+Z24fXHnzN5i7PUhOMh8YBB41OuLtFor6HqRQuFQ/KGIREIihuYKtdpldL1ItXoZUVxEkmQajdWYnJLn5Mn/k7/390Tm588yPf0XzM39GdFNWyIMQVWLA2AHyY05EfsYzISr1RPdfuLNko6GEbV6RT1gOLFpvxJyr3/x17/+HzCMcXZEPcIbimrsFW9nDnqvczIMqPdjmvdqiSf62sNkLi1r0L0Keu0ke92deoE9eZ29sqHJex/NcEcZ8vr6g0OlR28tHCIjEo8wFAAfQUjH2ZfDjme2SFS+tnGcOqKYRRQDCgWTnZ50KnYbC3CcNEHg4fsutdo1fN9DFEV0vYDjGDSba6hqFkVJEQSREUartUYQ+HH7xqJavYhtN1CUDLbdwfcdBEHCNDeBMhDi+15sRGHF2XWdbHYKSUohigpBYFGvL+E4TSqVBer1q4iixMTEvchyVP627XoXjBPSViLmkVgyVqsLpFIlxsfvueGCXhTleFExShiGXS/n5N5z0D5yEHhsbJzDNCvdcaYkO89mJ/dcFLiuyfb2RSAavRpGQLsTtyfuAPItxl4fgmGZcwLEnmdRry9SLM4yM/MhdL1EKlVE1yM2tG23WVn5IalUiXr9CkHg0mgs0+nUCAIz7qnVARFJquM4BrOz/4mjRz1c1yTKOGRUVUcUdQRBHtLbFBk0MOjPhP8aFy9+jrNnv0I+v7rLqCAB1sFeam/m2wtCvZnjYF96MBvfr4Q8N/ckKyv/IWZFR1nizMwPeOSRf91HcBoWw/q+b4fdPGgWkSxubnabR4/2anVH+tqXLn1mKCjPzHyXMOxV+vo6DzzwJWZnn+Tb3+4lqYU899y/6G5jkFGdyWz0SJHurpjcHh/lNonZhCynkaQ0tl1nZ/5YYdCQJJMZR5KE2OJQ6nlcB8eBIAgJAh9ZzgIBnucjyyKOYyBJkRcyCEiSSqk0HYOtgq5HY0eu20IURSRJodNZJTK4mKVSuYhhNAARXR9FkkTa7S1SqXEymSlct4GiaKhqFs9rYxjbFAqHYsZxjaWlVSYmPghEIj/1+iKVygKZzDj1+hKWVSefP9wFwlRqBNOsAFHpfNiCvt3e6Mrojo3NdcliQRCph0WLhMk+8ByWCAz+rd3eoFpdiBnhW4yNzQHs+xyISGeJjG9CRLsT70zcAeTbGL0krd4PWgLSjtOhUrkYjxUcYmTkZJdQEYY+llWjWDyC79uMjJym3V6nXr8GrOP7AbqeR1FkBEHGcULCsIXjBOwI+UfsZscx0DQBx2n2gV21eoJLl35pKCDulDWjsmgkHxmViAdLupYFQbAzVjPov7tXtrkfo7gXuIdJZcKOycMge3q/GCz/Jj3atzMHPTfXbxaRLG4Gt9lszvDv/t2POHXqz/j4x/uP9dKlz/Daa79KJrNGpzNBUoLutWbsjVOnnuQLX/gs168/yokT0bEuLv40rjsI7AJrax/lmWd+m09+8je7QJ60EaJ9wY5ITNjXTng7M9H9EQAZgkDA8yrsALDBTlk7AejIAcr3tfjz4BNd0w6goChpRDFahClKpO6Vzcq0WquYZoNcboJcbiL2H3aoVFw0TWd09G7y+cl4UaBQKBzj8uU/Jwx9lpdfQpLU2IO8hiCE6HqORmOdIAip1S4jy1Ksaa2hKKtkMiVApNFYRlUzLCx8G8dpdsGqWr3E1tYFDGODtbXXcd1OLHiyEC/IDYrFWTKZMWC4MpdhVNjenmdj442uEEguN4WuFzDNGr5v47omo6Nndj2v3V6n1VojkxnbU15T0/IYRo1OZ7PLDB/czuBzZFlnZuah6F19FzS0389x54zeYgxbSSbepun0WBdoEwk6XS/R6WyzuvoKrdYa6fQYkqRw4sTPAmBZ1VjZp0QQuKyvv0ahMEu1ukAYOpw79ymWln6G++67wsc+dpHFxe8SBCGRWUR0s5LlTKxuJOB5IAgpoNWnCDWMyDNY1twh4uyMOA2WXntnXHfbOA7Ptg46e7zfONR+7OmbiYMcy37Z4qBZxOXLj/JLv/Tru2adE9coz4NPfjJZUCQKWr0RZdsnTjy9i82dxKlTT3Lq1JMsLvaW23+Nkye/FgP7JMl7d+XKL3T3F0W/dveO4EvY/d/tUE/rD6+HkZxcUzKCoMblbCv+u0W7vYooasiyGo9BtdkBbBHbNoAQQbAQRQtFURHFMK5SuIShF+vCu4RhFcPwEUUF06zG0puncN23aLdXEQQZWIv7wClGR88wNnY/lrVNNnuY7e1zdDorOI5BGPo0GstASCbzIXzfIwgc1tev0ums4jgG6XQZ06xRLB5DEGQ2N4nlQFOYZj3u+15iZOQUsqyTz88MPVuWVWdx8Vmy2TFGR88giiqpVKlLHNO0HK5rkkoVd7lJpdMjdDpbGMYGtt1AFGV0vUCns4WuR5yLbHYC04wMLGy7GQuqyIyOznWPaVgrznHarKy8xNTUB2k0lneRv+7E7Ys7gHyLsZ9CTvI9We2aZo1y+WT8AQ8xjAqiqCIIApXKAuXyMRzHRFHSpNMj1GqLNJsr8cUf8OabP8fv/d7/iih6fOc7Mqb5z5iZsYlucEm/TcTzJKIs18L3Ibrh7cReILQjg5lEcgPdKckm0o7ALvJQkqENkrf2Ij7dvvGatxf7Hctex7/bc3jH49iydrb57/7dj+gFol6AvHZt0Oc5YHLyVR599H/sHk9SWh8GzBFw7jCuFxZ6vZ6jfR4//ufdfQ1yCECkULhCo9Fv93g71NOS4w1DSKV62dZKfC4cwtBFUcZiZS6BqKccEgRCDMRSrOjlABKu2+puxfMcLGsTSZoinZ5G09LYdotGYxnXtUini4hiBsepEwRJH9klDEWy2REEITKyMM06tr1JGAoIgk+l8haaliIIIi3sdnuTTGaaUulYzKBeZ3PzLVKpPNnsOLOzH6Nev4ymZTGMKuWyF9ulXsP3XZrN1XgOOsu1a68jSSqalqXT2SKdHtmVmQJcufIdVld/yOTkA0xM3N2toCWe6JKkcfjw3V0eSi/BShTl7jxzKlXqzkOHYcTMTrLmnceUMc0qtt3clfUOAu3S0g9YXn6OTmeb0dFTQ8lfd+L2xB1AvsXYTyEnucB1vRD3jGqYZpXR0ZM0Gvfiug4zM/fHTjYO29sLjI/fBUiMjp6kWDyMLKdRVY1OZ5vf//1xBMEjCKLM5bXXjjIz48Q3rQSUfaDac4Q2vU49e/V4h0WxeJl7730C10339XQTMYlB8tC99z6JovQD/V794nc79psdHoy9XaKi44d+W8kzZ77ChQtRaf/553+D6ekXuffe6DWeOvVnsZ9yP0DCYIkZQOwD4ySS92xmZmfxkzCuk9bCTqsi+jmTWSefv8709It9+0qO+eTJr3PffZFASNJm6J0rfzvqab3nTxAYGOFy+x4bqW2BIIgk/jbNpoMkAfhkMi0gTVS2DolK3AqiCKKYwvdtFEUj0sn2cF2LMLSx7Q6aJiJJckzoUul0mtTrVzGMTSRJodlcxrKa8XMDgiCk0bgaj1WBJKmkUiOUy8c5dernEUWFSuUK4KBpZXK5CZrNbTStiCwrHDv2CEEQsLb2AltbbxH1shXCcJR2ewNNy+D7DpKkxyQwuTt/3Fthm539BJZVZ2rqXlzXZGnpBQ4f/uiuxw7Tvg4Cr8u+TshlyRzx9vYFqtUFDh9+GFGUkaRonCmXm+q+H/tNjJRKszQa15mcvBddL3bnrQ9idHEnbi7unL1bjP2Yjb3Z88jISQyjQrF4NGZKjlOrLdJubzE5eS9LS98nk5kil5vCdTucO/d/xEpEaUZHj+N5Hvfc8xbf+tbf7Lt5SlI0LmJZDoKgEQTNgaMQuj/dqDc4MfFG37jSpz/9T4cSsQaJQCsrj3YBqDfbtKzdJKS3N+f69uIgjkyDmeiw4+/NTAXB7xNKiRZKX+w6Kw3rdyf7SPrBr70WKZk99FAEkL0GE/0s8P73zHUzJP39KBJgDuh0pjCMMf7wD7/OF77w2b7F0qCSV29PupcYd6sLp8TuESKOgSDs92iTyHhCJAzBNKM2SBhGM8itFuRyiZiIEM8G+7FrU5ZIt32JqMesIEk6nifEQBxxMsDFtn1kOfJWjtosSfk7wLbbmGYNQRBxXRtNy6MoGqmUztTUA7G2dYlcboogCHCcJrpeZHn5JdbXX8HzLKamHqBeX6ZcnmV09DSu61AoTJPPHyKTGYvBagZBkBgZOUmjsdy9J+wmf/ocOvRhFCXDxsb5WMHP59ixT3Yz3nR6pEvw6s2So2y4f3QpmSPe3j5Po7HC1NT9FItHgd1ELoi0tZvNlV297WLxKKdP/2IfOaxXXdDzrJg1PtInXHIHqG8+7pyldyB6s+eNjXPU61cBmJq6D9+PZorBp1ZbjD1iRVKpElev/iWXLz9FEDhkMlO0WqtkMtN86EOv80/+yb/k9ddPc+LE9zl69FkcxwA6PPXUv+DSpV/k1Kk/64LATjb8febm/mzf3mBiNJCM1AwaDfSXZiMA2A9kB0Fn8Ib/kxK9KldJtnjt2oe7mWkYShSLC32exgsLn+fy5b3Vwnqz9aQfDHR7wuD3CaPs9Z4NVwXr1+DuXTANLpZ6X+OpU0/elIXkftELwIM62kMeTVQuV/qe73kgy5FaF4jIcgFBEBEEAceJSteu28FxTILAQVFEBEFDkkIkKYeu5/E8gzCUcV0X37dIpYpMTt7D5uZ5qtWraFqeMHQoFg/hujamWcF1TdLpAiMjJ0mlJpmYuDtW6LKo1a7Sbq+gqjlUNYUkaZTLZ/H9DtnsIZrN6zQa1xFFidHRE2QyE10wrlYvY1lNisXD1GqLZDJjfSNLvRW2Xia1qmZotZYJQ592ewPTrPX1bgez5L3mmbPZCXR9hGZzLe5zH931TiRZd+LwNJhsDP7ee5xh6NPpbNNsLhEE/apkd/yUbz7uAPI7FEnZWlFSWFYTw9hgYeEptrfPx6YPGUqlY2xvvxU7NYEghAiCiO/7dDpblEqH6XRWaTavcfToG0xPtxFFiU6nBVg89dRvd8eAovJoxFDuz4b/q6G9wQS0q9XjfTd+1013X8PO9nfAei8G9LC43Tf8dzsGgaw/M/XJ51e6i45GYziD/SCRqHAlwh/PPvsbPPLI7/SNm83MPN0F02GqYC+//EXa7SlWVz9Cb+//3Yzh7QGJqH882AzXSaXGsKyozRIEUXYsy9F3RQHL8sjlfCQJJCmLosj4vojntVAUHccRcBwT14UwtNF1mUxmhE7HxnEcwlDEsjqEIVy//jydzgaW1cF122haHkEQGRu7G9tu0Ghc59ChnwICms2rhKHP1NRDOE4zXhDImGYdzzPodDbQ9SJBIDMxcYZK5WpcPo8U7aLP/jqmWafRuEYQBPHMdLFLuMpmJ4aCVMKkliSVM2c+gyjKdDpbPezqnVGl3u97VeyS8rjndchkxrr61J3OVp/q1l4OT8Oy3ATAw9CjXr+OLGsEgU8Yhl0C2bBjvBM3jjuAfJuiVwGnUlmg1VrFtpuoao5MZpxmc52xsbswjCqdzhZinEKoapYwDNnamkdVc5TLx9neXogvcgHbrtLp1DDNaI758uW/waVLH2d29s+5dKnfZvDSpV8Yklk93BXWeOWVLxKGAisrH+6b9YXdWe+ORV/Etk5cgR577Dd/4rLdg8RBes2D/dhEAjNhPu8nRTmMnJXEzMx3gV8jeS8Fwcd1012wl2UjJoLRVfLqXSxELPnIyCIKicTJamPj3q7m9V6v+50NP/4aDBPT3CYBakmKStWdTpRde150bLpu4Xkyohg9xnE6SJKMZVlUKjXSaQiCDpkMuK6E69p4no/jmEiSHZtGRNe4oqSRJI1sdpwg8MlmJ5BlnXZ7ienpB2MW8VW2tt5EFNdZXv4ephnN/Pq+Qyo1gihqbG2dRxQ1dD3NpUsWplmjUDiELGfQtByCAIIQqYjl8zPoeplsdhxBkPqy4+SeoaoZtrbmMYwKqVQB142yetuOKgJh6OO6JpqWpVJZ6JPOBIaOIfXej0RRZmbmI13ATjLbJJvtnQYZNoY1TFchCDwEIXKFipyxQgRB6LK/E2vJhJh2Jw4Wd87ULcReI0+JKXikuysRBFG5qdlcRRCg3d6mUDiC51mk06McO/YInufQbC5x/fpzKEqWkZEzsSGEiG1XaDZX8DwTzzOYn/85nnjiD+Ls9x9w9uxX+ohDp059i5mZ13jhhd1CHisrH+bChc8DfgwcO6XNU6f+hHL5SjfrnZ//DE8//a/o71NGrkBPPfXbfTrTg3EzJKr3WtzoWHvL8L161Lq+/xjVfmCcbDeZa05Kz7393r3kNYeJnOz0+aP3rVfzenb2nV1I7TXzvXfsZPC6DoYROT1FDO3kPyZhKOH7Jr4fLTh8H7a2oiw66Vt3OpDJuLhuBwiQZRXXNZAkBVXNY9ttJEliYuJustkpms0V2u0t2u1tHKeNolRYXX0Jw9hEllOoajqW9NzE9/3YhS1S6/J9F1FUUZQ8ltWk2byG4zTIZCbQ9TLl8nFEUaZev0oqVY4tHC/gOB1On/40QBcALavG1tZbrK+/ShgGTEzcR6k0S622iOO0qVQuMj5+F+XyKRqNZVIpoU86E4YTsnrvR4IAul7q3rN6SWLJY6vVS7EbVqkv296rX53sM9LqLiFJEqlUuduH7nS2uq26O8peB487gHwL0TuEn0qVCAIvdmnaGcgXRYWtrXksqw5Eq9xSaQbT3KJUOsbExL2USsdZX3+N69efo9PZZGrqIcbHz9BoLNNsLrO5eRHDWI/7bMKuXnA+v84jj/x/uXTp5zl16hs89tjvAPRpFANdmcSdbDe66fcaH/RmW1HJOwHjnfGcJOu6kXDE7QbhYQB/u0H/RttLFhq9vd/Bxx2UENVrKJFsa2bmxdgkI+T++7/UBc/BGe9EOOTSpc90CWS7e8qw876J3TnpXkBOjuHkybejyHX7Q5aJmdZJT1okuk35NBo7gK1pEREsKmcnz47Gpmy7hSSpSJJGLjdCoXAcw9jEdQ1UtYBhbGMYG4RhxPD2PAvHqdNserhum2LxGJKkY9sNBEFkZOQEmhZVr5aXf8CpU7/I+PgckqSxufkmjtMknZ6gUnmL2dlHMc0qllVHVXNoWg7HabO8/CJhGMSiJhP4vk0YRs5OU1Mf7IqAZDJj1OtX40XGFp3OJhsb0OlskssdQpK0XRkygK4XaDZXgH5968TDOEoidoC7F7wjU5sihcKRXWYYw1jdycwz+LFHdJ5q9WqsMHgVECgWZ/tGse6Quw4Wd87OAaP3okrGCRISRNKXOXTo4e7w/eLis6ysPI+m5UmlpigUptnYmCedLuP7NpqWo1JZYG3tVSyrSjo9jqblsawWprlNvX6Fen2RRLsWwiG94KeYm/s2jz32P5GMPl248De6oLm+/mBy9PH3HcGPvQwVehW7BMGPfZBP9tzs+3Wm3+mb+bCsa9hjBsHxZgD7oJndrQD/4LaHGUpA/whS4lsMw8vkvdtIFkaPP/5ZLl9+tGvr+NprX2Rh4fN9z9vrGN6eItfti3Q6ypKhN0sOAZt6PSJ6JYAtSRFgJ2YUEas7he9Hvr1BECKK0d8dp4XrWuRy04RhgGFsIwgynufSaq0Qhh6+b6PrecrlOXS9hOua8UhUwMbG66TTZVZXf4Rp1jhy5OOUyyexrDrt9ha53BS12iKdzgbN5grp9CjV6mUymXEMYwtFyVAqHcf3bXK5Sdrt9T5GegLKEGXO+fxhbLvF2bP3sbb2GqqawjQbXaa2LOt9oiDZ7EQsi3mpO3udgGGvLaSul/qAO50e6YK1IEQKf2Nju72bh/Wre7PsqNy+jWnWmJ6+Pz6+ie5IVOJqN9i3vhO7486Z4WD0/KRMk5RuGo1rrK/PUyodiscUXsNxLJaWngeiPpHjGNh2B1FUePPNv6RcPsHo6Gk8z2Vz8xyiqFIozJDNTmNZNZrNZYLAJ5+fIQhcVDVHrbaA40Rgu1MWfYzjx5/jrru+Tyo1QRCEvPzygywufpLr1x8mMR7YAeJ+0YhHHvmdoWpXu40IJD796X8K0KczvQPKxgHKkoNiEQd7T95O3Hzp9N05Dhie8UbiFLsZ1UlGPlgm79WuTh7/6KO/3pcBJ1n0YHl92DEMW1jNz3+mKxizXw+6N5IqQiKreivnPJ3u/S1LMk8fhj7pNF2QTYA4IYHl8xKS5BNJYBaw7Qa+L2OaW9i2gSSBYSjYdgvPM9D1MoqixEIgIa3WNgCe10ZRMl1teMdpIMsy7bZHOj1GPp+iWDzC1avPsLr6ErZdRxRlNK2ErpeZnLyPQuEQQeCTy03Q6WxTLB5FFGVMs0ajsYwk7WSOq6uvoKpZ2u2Nrn1jKjXSnaM+evTjsbCHiiQpcfVN7ma+vd/L5VO0WmvxwqHOyspLTE7e0+1JZ7NTWFajm0hEI19ROTsipA33bh5GGEt64YZRoVSajauB1biffhjot5g1zTqCAIqSwnXN7sLiTvTHHUCGruh6sTjbFXIHuqSI5IKHxDrxZa5f/z7N5jKRPKCLYdTZ3v4zLKuBqqaZmvoggiDjuh2+9rWAixf/b9x//2UefzzF9vY8tdoCgiBw/PjPIklJebtJp7MeMxad7jyyZW2RgGtUFv0mIKNpo4yO3sVf/uUxnnjif6XfDQh2gHiHwRuZMrw49DwM9iLPnPl63414cfGnOXv2K5w//8sIwo4Yxn5M6vcKOL5XYljGC+xSOoOd83TvvU92570ta7gy2rDoLa/vdwy9z3/qqd/mjTf+a+r1E92/HcR3OYnb+976gAak8P0tJCkCY4j6yGNjGSLABkgRhtGscBCkUJQMiqIRhgKpVAFBkHBdB0kKSaUihzVJUvF9lzAUCEMPRUnF4LiCYdTxfYsgcOh0NikUTuE4HURRpNVapVa7FveRc4iihCTJzM19lmx2guXlH8RkzQlyuUkKhcMx+P6IIHApl0+TzU50e8G23e6Wpx2nQ7E4Gy8cLDY2lrqWkNnsZLf0nPSGW601bLtOuXyKbHYiHpnKxX1cl2vXmhw58tG++eReNnVS+k6y7EEFsL2iF2wlSWN6+n42Nl4HoN1ep9PZIpUqEYZet8xer1+Ne+ORZsKd3vLuuAPI3QgxzVpXWCCZ+2u11rqr1pGRk2xsnEMQRGZmPkS5fBrHMVAUnUplgUZjGd836HQsNjbeQBTTvPDCSX7/9/8XBMHj6adlTpx4nhMnFqjVrtLprOM4TXw/wHHa1GrLdDpL+L6GooRoWgnf99C0HEEgIkkBngdB0AJsDGOLjY3XOHfuF3qAdEckInEEevrp32Jj44PdvnGiOjWo0zxYEk9Kp4NWhb096L3MEIbF/kIRw2MvktjN9pCHeQzfaB/vROxFDLsZhazBbSTZ9EFjmLIawP/xfzzR1d/uj+Adbk9oREpeQd9fq1UT2wbT7FAqSfi+3+0Xj4yAJMkxQWuDMIx65pHoVzQ6KAgwPn6KXG6SjY03UdWIgJTPz6JpuS6L2XU7eJ6L5zn4vkOjsYphrCOKCu32Nr5v4Dgd8vlDAGxvZ1FVjenpj+K6AefPfxlZziJJOo5j4Dgmspwml5vE993u5AVAux0RNgGKxUMoShrXbbO1tUGpdJzx8bsBaDaXulaRSX+5t/ScgKnnWZhmJe7pRlyVbHaCfH6aK1e+QxAENBqrzM1FY5FJJTBqs23sGmXq7RXvVzlMhEiSzLdcPsnhwx/rvtadmemp7kJAlnVkWWNt7VVKpdk7veUhcecsEK0UTbNGqTSLZTW6YwERU9qj1dqgWr1Ku73B9vZbGEYNSZLQtBLN5nUymXFGR09Tq11B0wpEpa4OjrPMpUv/bRfIRNHnjTdO8alP/RSdzjaGscXW1sXYzUbBMFax7TqynI/LbRUkSSWfnyKVKiGKEvX6dWxbINGwNs06J068wAsv/KM+cQiQYrJWROzqBVRFMfbUmR4GDP1ksn5CWG9vcjAGQaLXIepm4mb7uXuZMwwe2yAov1sxLHO9FYWsyKBh79hPDzvyod7JuhcXPxODMfSqvEUhvsNKa/aufZpmxKL2fUilQlzXp1Tqf1Y0Z2wQhgmYq0iSRBj6OE4D225Qr6tUKhex7TapVBlBEGm1XuTo0U8Shj6SpCHLPoZRQxCySJKKouh4noksZ9G0Io3GIqOjd5FOj1KvX8OyNrAsyGYn2d5eQJI0PM+l09nAMKrk84cpFA5RqVwglYq06QUBpqcfpFicpVq9zPLy89TrkzhOh2ZzCV0vUCodjzPcNJKkd3u1sqzj+zZLSy+QShVJp8f6SF2RNG+FVKqEJGmkUgVMs8HY2BzN5gq+b3f1rA1jm62tt4jc5Zp9rOpeIlgvCxx2C3skxhXl8rE4udiKt+/1kc4GRUra7Q0ymdH4/ti5IxwyEHcAGbCsBpH2bqNbOoo+vJHWrW23cN0mqjrHoUMfZXX1ZTzPptmM/E7T6VGy2el49X2EMIT19VewbYOTJ3/ICy/IiGKkRX3ffVdjEfwylrWFqmZxnBapVJEgEACVYvEYqqr3zPdFbFDLaqAoad544zGuXPkos7NPcfbsdzh79rs8/vgXWFz8OIpi7CJrDQLtfspdw4BhMHN+5JHfwbLSHD789J7l6mEgcKt9xVuJ/Uhe71YMLgwEIWIHDx7PzZ6TQVIWRBKZN6okJDHsbwsLg4YXkFRbzp79yr4mHG/fPznZ187xBUH0pSiDfeWdCIJa7LMMkCUM3W6WCh6iqAKRJGSkne1Rr19FkiLSl66nsawmmlYklcojyxq23UJVMxSLRzDNLcIwGpty3Q6mKeE4TVKpMWq1S5hmHdOsIYoSY2MfoF6/RDo9geu2se02hw59qNsCM4wKEJVp0+kRqtXLKEqaRuMamcwo4+P3YhhVNjffwPMMRkfPkstFgD0ycpKlpRdiu8g6ul7Csmrd0nIqVaLT2WRra55SaTbWz87GWvqjmOZ2LG1ZQhCkeFZaolQ6hmU1u+24BJgTacwoEx8bKuyR3DMFQUIQJEyzSrN5nVRq57HJfHTv4sHzLHzf685Hwx3hkN543wNyZNlm4boWrrvWdUARBCke0jfI52eo1Qyy2XE8z2Fq6gMsLb1IGIaxEbpILjfOyMgpMplJPM9gddXF91ucPftN/vbf/lUuXryfdBqeeuohRPE0hcJXMM0GjcYSQeDieTYXLvwSCwsf5r77rnL27DfRtDyZTLSCjXpFHd588zG+/OUvx9ntP46z2z9hbu6rzM19dcgrVAB3F9DejKvP2zUdgHeP0HUz8W70s/fa/tthbA8jht17760rol269Bnq9eP0gzEkIiXnz/8y8/P/eSjx6/b5J0dhWTuzxbIcfU+IXMMjJDKhsOO2jkouV8RxTHK5UYrFo2xvXyQIQmy7AYgEQeRz3Om4iKJGJKQiYZp1RHGZVKoE+DhOB0XJkM9PUygcicFXxjDW8TwL267HLk45trbeQNNyaFqJXG4aRUmxuvoyU1P30W5HMpO23WB0dK6r9+w4bVqtVUqlk+Ry02xvX6TZXEPTIv9m3/cQRYlr176P7zt4nt2j1U03g9X1EpKksr19ke3ttxgbO4skaV32dEISG2RHG0YF225SqSzsUu1Kvu9VSu4VN9G0HKZZZ2Livi5Ra3PzTVqtZcbHP4Ci7FyY9fpVgsDv7vNOZtwf73tANowK9foipllBUbKEIfH8YNQTOnz4nlhFK4XjGAiCgO97XdnLbDYxGx/nyJGfioXWr5HJjOG6Bp7nctddf4Lvt/mDP/gKoujzh38o8c/+2YeYnPz3tNubALz66if48pe/hCh6fP/7Mr/yK5t84APfIZ+/h42NeSRJx/dbXLnysRsyZKPIEJUBPQaddhKATZS7DhI3U1IdloHdSv/4dsZeZezbDcr79apvVwwjht3MfnvnoGFn5ApgevoFcrl1wlDokwJ96aUvsrCwM7dsWVFWPXgt7ic+cpBzkbQ1gmBnvjj5W5I592fMApIk4vsS4CHLOoIgoCgSllVjeXkjNkCwkSQJkPB9D9veBMRYuWuSbHYS1zWxrBqdjo0sp7CsOrKs4Xk2jcYKxWJkElEoHKbVWiGyPDUxzWrM8/Aol0/gOA3a7W22ts6xsvIiU1P3x1yTNGEYGc50Opusr7+GomTI5SapVBZwHBNVzZDJTOE4FqYZqfq126toWp7x8XtotyNNakVJHJ3GuqOYrmuwvX2ZMIwsGKvVyzhOh8nJD8Ra3TsgmmSvg6pdsLcM52DPN+kzm2aNVKqI65pdreyNjTcxzTpB4PVl2eXyqa54Uu/C4E4fOYr3/RmINFxPEgSz3V5MEERSdZOT93UdUzKZsS5hIZ0uc/HiX2DbTTwvsnwbHT2FKKpUKueoVi8wOnoXhw9/jM3Nc9TrSywt/VK3bC2KPufP38vc3GF8PxIjWFr6GQTBjy0WfS5f/jgf/vBbtFqbeJ6FJAkoihaXj//Jvtnt/Pxfj8uIzzA396d7vvYLF6I51Zth0b7X4t0AwIPGzQL+rZat9yKGDdvv4EJksNx98uTX+kD1yJHn+PSnf707AtdrnDGoFrZjIxmN2c3MPL3rOHp5AwdZ/OzM5kb946htBI6zM38cqXKJRCX2kCCQSMC13a6jqjKiqOC6bTzPigE6jyQpBEGA5yU9awlRFLHtFkeOfAxB0FlZeQFNy8QlVRFZjjQAGo3LmOYGmcwkul7m9Omf59q156lULtBq2bhuG0EQuXz5zxHFaH+ZzBialicIQhRFi8ca3Vib2o2VsUKq1etsbb2OqhZJp4vddpnv++i6iu/7jIycQhTlWOpzk0xmBFXNded9RVEml5umUrkYl+xB0/KxZreAaVZotyMiW6ezgShKuzLm6P3am2iVTKOUyyfJ52fi9ynaxtbWfBfYowVCmULhCLncVB+45/MzXfGkBIx7naPe78D8/n3lcYii3L248vmZ7jxgossKYFk1ZDnFwsIPkCSF5eUfUq3O4/sW+fxRTHOb5eUfMT5+F7Kso6pFstlxNK1ModDGcVp84AMXeeYZOQZdCUGoYppNstkxHCdDOi3Q6yQkSU1Ms4JliVhWQjgzmZv7Cx5//PNcu/Ypjh59ZkgZ8fM88cRX4zLiP+Lxx78wtJS9Xx/57Uav6EES7wRQvhsZ77D93G5lsOT33u3eaJ97jTQNi15QHix3R9fbbqnV2dkd0F9e/jhrax/apRY2GK+99qvdY0viZkl8qVQEuILQq8AVRQLO8W/drzA0kOUUnucAPrYtkEqV4/9H4BwEPr5v4PsBoqggCHq88IZWa4uFhW+TzY7ieTtym0GwhmFscfjwwwBUKhexrCaO0yGTKSOKAmHoxgIlNo5TR5aztNub5HISMzMf5vDhj6DreS5ffoowDGg213DdTnx/qVAqnUAUfYLARdfTZDLTlEqHaTZXSaePxfceOe67yriuGbOqN2Limd7NVFOpEkeO/BSZTFS1azaXUJQsltUgDKMycSpVJJUaIZMZ68t0k0hUCHtFPBKQjmwaBxn4dEVIKpWFLhNckmTK5ZPd5yfbHuwX9/aWq9VL3fGt92vW/P56tTeIBJx7L4gk1tZeY339VQRBxXE6+L6Dro8xPn4vnc4qqdQInc4G+fwRfN/BNKsIQkQCabe3OH78K/zSL53hT//0/44g+Pzpn/4/GB19iocfPkexOEMYFul1ErIsMdbvdVCUDKZZj2XtJrnnnu8xN/c0oigSBArz85/uZsQvv/zfkWQsEdB+fCggJ0Std8IZqLfc+E7Fu0HS2msf73Tv+UZErIOS6IbFYLn7vvu+xEMPfWlPfkCtdoK1tY90f+9l1veCO8DCwmdYWPhcN4O+1chk+n83zR0w3gFqH0UZxfNcBCFEkvKIYhvHCQAP02zHCw4p1qQO8H0T8JEkPW492SQey7Vam06njiSFiOJG1/pQEGS2tt5C0woxmaqJ47S5fv0FRkZOIIoq2ewMipLFMNIUi4eZnf0ErdY1Tp58DNtu4/suhcIhBEGh0bhCrbaArudR1TSWVUVRJtD1EqKodk1nXNfE920mJu4lnR5lZuZBPM8mnz/ElStPMzp6Ct+PtLsjvXuLjY3XGR+/G9Os4ThNWq1N8nkJWdbihUzkyJTNju3yPE4iKWP7vsXW1nw3g2631whDuoA5GL3E2F57RsPY7u4ncZlKpUp97O1sdiJWD4tW8e9n28Y7gDwkeleNjtNmdfVHNBpLeJ5DGEY9o4gtaFOrXWF6+kHS6dHuKEEuN4NpVvF9G9tuxx9Km0bD6ZatBcHj6tVH+exnBWy7yb33XuCb35R6MpVnMYw6Fy/+Na5c+Xhcfv4ampbH81wkSSAIYH7+033Emt7Yj7A1N9dvaPDss7/BzMyLtyVLzmR+MgwmelnPg3ErgD+sTz2sd/5OLCaGzVL3MqCT3u6wcndijtEbSWm7fzY44OTJr3fBtrdk3aubnWTQg2Nut3odpFKRpGayrWQ7rtsCJMJQIgwNQEPTFGx7CzAIQxUIcJwqoKCqOoIgI8t5gsBmxxLSBzxct4MkZTDNDkHgk06PoShpgsCh0bhMEITkchM4jkGjcYV2exlBiBS0Ir/lN5BlDcuqoqo5rlx5mkiSss3IyBksq8rW1gVMs8r4+AMUi9M4jkW7vcGRIz9Fq7VOu71Bq7Uea0IHWFaL0dFTWFZk27i29iq2XafVWsfzDCqVi/i+TTo9QbO5zvLyj4icsdKAT6FwBFnWY/WxNqIoY1m1PfvEw0rQul6IFyW5bnl8MBIQ9rzo9QBdFnaS2CT96ujx/eztZIEw6A/9fos7gHyDWFl5iUuX/qw73pDLTaPreTKZh+KMOhp8z+cnuXjxLygWj1IszqLrBRYXv8v29ps4TgtBEDhy5Fv85V/+ag/oPsPq6o8IQ6jXx5ib+wZB4PDAA7/L3Xc/w8LCf8WXv/wfe8rPn417wgq+7wDhUKef6Oa4W2lrMHZbNd6+svWPC4QPqhj2Th3fIDCGAxW+vcD4dhxP7zYGGdC9WetByt0rK/3ZbwK6Dz20o7N96tSTnDnzFS5c+OXu38JQ5ujRp2/7+R0++uQTERZFHAcURSAIduweFSWL61qAhyTJZDKTyLKOKErx58dHFHUcp4nrWshylKFms0WCwEdRVAqFIyiKjq6XEYSQev06ipLC8yyCAFRVQZJEGo010ulpfN8hm53C80zS6SK2baDrI0CIrpfjvm4aTUuRTo/iOIuEYUClcokwDGk0lrHtGvn8EZrN61hWg/X115AkDcPYxLYtRFFEVTM4TosgCAkCj0xmhEbjOvX6VTQtzdGjjwBRiyyaTS6Ry03tGkPaKyKmOd0+bypV7FP76o2EJJZIf0bPH+ma7SQAnmTbifph8tykGtm7QHi/ZcZJ3AHkgei9QADy+Wmmpz+MaW7juh2KxePMzDyE65oUCodYWfkRjtPiBz/4IxynRbO5TKl0lImJe4ksFF0i8/WAu+/+Vt/40PHj36HdzvL665/kv/yX/717A3zggd9DVQssLn5iF2CCFutK13HdNIrS6esBAl3xjvHxc/vOie42q3j6XT3Xtzv2KpPf7oz0ZsHmRiXuwf8Ny7R7mdGJjOZ+McgRWFnZ3ffdr0IweG2cOfN17r9/xxXMsqJjisB4x5MbBOQhd5XbN6+chELU3nGJJgksXFcCOkSAnCYMQyBEFFPIcgpBELv9W10vkc2OoappHCdLp1MhDIUYsDWCwMDzLDQtQzY7RTY7hm0bGEYFWVbJZCax7Sr5/CGq1cuY5jb5/BFkWcG2a2Qyk7Ra0aiTKEqkUkVkWWVq6gFSqTxhGFKpXESWNTqdKs3mOqqaRtNyyHI0Py3LKRqNJVKpIvX6VURRZWzsJLncTNes4fDhD+E4BqlUifHxu6hU5ikUjnPq1C+yuPg96vUltrcvkMsdolg8eiCDB8OoYFk10umxrm52p7M11Ns4kdBM/N+LxSNYVivWr67tYlEnZhRJphwE3i6i2Ps57gDyQPT2LyDSii0UDpFOj9Fur3D48EcplyOd33Z7A88zWFx8lkbjGuXyHKlUnkplgVrtGkHgoKoqpung+xa+L8Q61LC4+ClAZG7uW1y9+lMDwPtTnD37DDMz3yIM/7sBha3/k6TXnABvr3PTysqHuwYQ0Xf2nBO9HfPFNxu348a8F8D6fvR1u7LNgwL5O1WCTrY9yIxWlBsz4octtm7mvNzo2tD1qIc8qJMO/q5Ky17zyrd2LYjsAHHvOJ9LVIL2ARVNK+I4bSBElhVUVcV1TSRJJgxDUqkSjqPgOBEhTNfHABfbbhEEBq5r4ThtfP9FRkeP4zizcfnaRVXH4uy7jesaiKIYZ7Z1BEEim51ielohlRpB07K021vUaldwHINC4RDj4/dw6dI3aTSuY9u1OIsPyeUOx8A0jSxrXL78bSyriaKkaLerCILPzMxD5PMzsatUKdbszlCtXkIQZAqFI2Qyo9Rqi6hqFl13gAKO04oNbUREUd5XR3rQ3amXFDaowhVJaCZz0T6GUSeVihylisUjbG3NY9uNLuD2P97bkyj2fo07gDwQgxdjuXySTmcLz1tFEKQ+1qGqZmKZvIhpHfVnGmxsvE4+P40kKaTTIzQa60ATELlw4W/xxBP/Jb45/T9j4/inY+nL5Ob5XYKgyunTX+Xxxz/P4uIndilsJWxsQfBw3TSf/vSvAzv2iTtexnT1p1955Yt9N8Dbn7XsH7dDSOIg4He7SFd7qV31bv9mwfhGutmD/9P1/vLxQVsLc3O79a73ir2O50az5ydPJj3kHTIiSLsqLcMY/cAtXgsBg5rXUchEhit5VDXXBTlZzpDJjGLbHVRVQRAizsbW1jyCoGLbNWQ5jSyrdDrb+L5FGAYIQlTubbeX0PUo265WI2MEz3O7mgVJ5joychpFSWNZNVQ1Tau1SRCElMvHyGQmWVp6Dt+38X0Hy2pRqy1QqVxkdPQsuj6C71uk0wU6nXWKxSNMTX2QSuUSrmsgCAqWVcdxWiwv/5B8fgZdLxCG9JR/o+y+UDjSPSOiKFMqzXbVvCCS2VTVNM3mSrcsPMhoHuwv7/SQs11DDBj0XS6xtvYygiB055ElSUNRUtTrVwiCWWCn1xwRvrZIp8diWdL3X794WNwB5IEYvBgT1nXyv6hPUotZmi5ra69TqVwiCEJqtcs0GtfodKoxCztHEFhoWhrH8fF9h6WlTw3cnH6Gz33uX6Oqv8LFix9kdva7gMg3vvFv4p8TgY9+ZvROhrxTah60T+y3XZS6c8cvvPBrPYSu26eydKO4HaNWw0aqbhTvpnnEQeJmnbFupbWQWDcmZeq9FikH8Zve63h7s+hhkq1JDDv+/sWlz9NP/1Z3m7cWHmACeYLAiUHKjN3SWjGjWkDT8phmNS6ZRsI5vl/CcUIiuU0ZQRDQtAhwLatJs7mOaTYxjE08z0WWFdrtEoXCIba336JYnCWfnySXm+5mqq7bpFKpIssyuj5COl3CcSwKhRlarTUajSV834vJZSGR93JINlvG9x1WVn5EPn8Yx2nHtovr8QJgkatXn+mSs7a25hFFmULhcFyipzvStLLyErbdRJZVCoXD6HqBRmMJw9jCcTqUyye7+tat1tquni9EWWylsoCm5bquTb096OR+6XkWxeKxPuJXwp6O3LT8rhgJRJVHx+lw8uRsPBd+J+AOIB8okhLP2tqrrK+/Si43QyYzxubmed5888vU6ysIQkg6PYpttwlDu7tKDwIRQQjwPJf5+U+zvX24r+d76tRLCAKcOvUnHD/+VRYWPsMf/MF/7mbQ0F9y3u8GOEjwKhav0Ggci+ebd7JlQfC4dOkX3jY43mzcjp71rSp+/bhBeFgcNLv+cbQWYHjferCqchAFt72Ov3dxubHxQZ544utvc2Ho4zh1fD8b/y5gWa34ZzM2M1ghWqAmPWiBMHQIghBZlkilplAUHUlS0PU89foikqQSBAKynEGSBMJQxDS38H0Hw6jh+wGjo6dQ1TT5/FHW119GEMRYHrNFuXySRuM6kqTQam0QBBH7OQh8Zmc/RRjaNBrrjI6eQJazQIhhbCCKKpOT93LlyneRJJ2RkVN4no1lVQCJdHoUiLL0yNM4es2yfBjH6aBpWVqtTcIwRFUzVCoLGMY2rmvT6WwgSTsfik5ns9vLTcrZyexxYsKR9J7TaXlXVh3JcNajsy4Icek+YU5H42Kua3Sz41ZrGRBYW3uVTCZ6He9XIldv3AHkA0RSovZ9m+3tS6yvv8GZM79EpXIRXS+gaZFNmigKFApH6HTWkOU0EGDbdQyjyfz8p3jiiT8kkSi8667v8sAD/5GzZ7+J7wfxSlngypWf6gNVoA80P/3pX9/zhjUIePfe+0Q3C94hfCULgT9nff3Bd5XQ9W4Cy62UrW8lix5mIDHIrL7Rvg4St+IG9XZiWN8a+svMEXchg6J0cN3Mvq2PweNProVh1qBv53WGoYPvd5DlNL4fkSl3WjhO/HNk2+g4Jq5roSgZgiDSpI/EQzyy2SIgUCrN0mpt4fttJEkml5silRohDF2azeU4Y3aoVq+Szx/GspoEgY8kqeh6AVXNYRg1wjBkc/MNcrkZ0ukRbLvFyMhpdL2IomiMjMyxuvoy7fYbFItHsawGR458DNtuYVkNgsBlZubDqGqWZnM57hFnSKVKsQXjNmEoMzFxV7csvLX1Fo7TwvM61GqLjIycjMc4X0EQBLa23kKSJMbGzgJg282uSUUyKxyR3yZ3ge/wOWGBVKqEadYwjA1SqVIXlBPBkFYrmkXO52dIp8cZGTlJo7HcNbh4v8cdQD5AJIPxW1sLXLv2fTzPiIG4wMjIXchy1GOKVqM2pdIpgsCNta9lwtDfVa6dmFjj4YcvEgSH4uH+RQCOHPkLnnvuHwwF0VsxgZiZebH7O7Dv/5Iy+Tt5479VYLkV4lTynFvxS74ZQNd1cN3ImWjY9m41O7/R8/bbx43K9EmmOzPz3aEjUIOKXouLj1KtniARnUlIg72Wn72tj4O8/uQ66LUGffsLQ48wDPA8nwR8EyAWhHx8PNkYhH3ARhQlVDWLKGq0WqtEGtVtRHEZVS1imtt4XkAuV2Jk5CzHj3+KS5f+hErlGlHZO1LTu3btGUBCUTQOHXoIXR/D81pIkkYmM9Ed9QEZw9gEAiYnP4gsq3FJdx3bbsXZZxlZ1kmlSqRSRYCeUvAkrdYK1eoV1tdfw7KadDqriKJCsXioS7bStCyua6DrUXndshpYVoN2ex1BiNTMtrcvMDZ2lomJe8hkxro607AzKzzIrB7k2UD/HLEoyrGRR38LMPl7p7NOoXCEQuEwnmd3BUWy2fdgGetdDiEMb7yebzabFAoFGo0G+Xz+3Tiu91Qk1P5Ll77JK698CdOss7b291he/nmOH/8e99zzXTzPoF5fQZIiwXfTrPCjH32IS5c+yuzsMwSB3ZW0DEOZf/yP/yUPPvgCjcYardZKLEqQIggE3nrrZ1hc/ClmZ58CGMgoEw3f2xe9ZKswlN9zuta3g8V8M+A2+Jyb/d+t7u9GsZ+05kH2mcTg+/2FL3y2W5JOttubISeWmwlrfyf6GdaC4PGRj/xbHn3012/q2KLFwe2smqjsSGvaROVpD00rk8lMY1nbqGqOhFth240Y9IS4lKqgKGkcp4MoEmfBMun0JCMjxygWT+D7LS5efIowdOIZ3xkKhSlsu00uFyl3ZbNjdDrbCIJIuXyaVmuJZnOJbHYqrq6VmZ7+EJ7XxjDqKEqGbHaU8fG72Nq6yPT0/eTzM1y79v1Y7zlAljVmZh4iCDzeeuvrGMZ2XCKOpConJ+9hauqDAGxsnOvaLmYyE11fZMdpMzv7CPX6MpZV4/Dhj3ZNIQbHPm9GwtLzLCqVBUqlWRyns+t5ybxyolu9F6nsr2IcFEP/6p6B2xiJes3a2sukUgVeeeVh/uN//Jex6tZH+B/+B4mf+Zk6Yfg9RFHCdR3Onftpfu/3/n8Igsdzz/19/vbf/hUef/xvcv36o5w+/QpHjnyXRkOj0djE9+tAiO+rgM/Zs09x9uw3CAITGCS63F4whndW1/rdiIOUid8NjeuD/C85hpsZq+rd5u14DYMuTYl9Y2/0KnqdOBGRsPr9kiMw682QD5LhDmP291ZN5uc/E08KwAMP/G6fe1RC6LvxOYgkM6NRKAVFKeB5duzm1IxVq2yy2ZFY8lGl01klnT4SZ81CLGNpIIoZMpnIhEIQRLa2zuM4HSRJQxBCHMciDOvx4+XYrKKDYWxRqZxHktL4vkkqVY6tCFMUiycYGTmJbXeQZZmLF59CFBUOH/44qVSJhYVvxWQuCdc1cZxWnBFfJZOZoFw+QaNxnTAMSKdH0fU8hcJMrCQYsLLyEpbViFXDGlSrV7j77r/BlSvfQlEyhGHEttb1PJIk9QFhL0lraekFNC0H3Li/GwQe1659n1rtMs3mytCxql7fgN640zveiTuAfMAQRZkjRz6OYdT4kz/5YCwIHzk3Xbv2GKOjr6FpeWq1SziOxdWrj/bJZC4t/Ryf/vQ/44Mf/AGyLOH7Pp4XoqopbDu6gUR9ZJMgiEps8/N/7cBjSW9nhOknUSDkVvScD8o03mv7tyN6j+FWR6febuzoWUcgKsvDdcwHFb36pVmF7vz7IMFwLy3uxcX9x96eeuq3+7Lwixf7dbEPTuiLXKCSLNl1DcAmsvyTSadzeJ7H9vYFVLVIspgwzSQLhTC0UZQ0oiiQzY7H5hQOlmVRq11H09KIYjRmFclURlMXspxBUVK4bicelboMBNTrV5iauo9sdoaxsVNYVp319TdiKc06kiR3e7idzia6XsT3/a5DlShm4jJvlMlms+NYVp25uc/ieZFIiOt2WF19hWZzKSZ15eLSOLz++pfjkvwaul5kfv7rTE09wPj43V1zit5MNSGAQX9pei83qGi+2Md1DSyrTrW6sKc8557v2j5OU++XeH++6luMYvEoJ048xuc/r/G1r0mIYkAQSJw58wpra2+wufkmvu8QBA733HOeb33rb3ZB7vDh7+B5IZ7XwPNSiGKAJKVIpcrkchPIssb29mUcJxK8v5mZ3bc737s/2Uol6sH9+OKgY0sHAbgbuSrtt/13Km50PHs95yAjS8P2cerUkzz88O/w/PORgMzzz/8GR4/ur2M+O9vroQ0PPPClm1747VeJeeONz8RgnAApQLDLWeoghLkokkzeIcqYRaLSdRvPE/H9EEGQCQI7Vt2KxC/CUCQMhfj/DpJUxnVtLGsbULFtg1RKRRQVdL0QzzI3UNU05fIZLGuLra03iPrKdTStRBg6CILK/PyTsZaBiOu2uXr1acbG7iKbncBx2rRa6xSLMxQKx7DtKvX6NTQtE49ZhkxO3k8mU8Y0qwSBh6JkqNUWmZr6ILpe4NVX/4CNjXNAgKoWSKdHKBQOYdst7r77C6yuvoyuP8Tm5gUUJU+hcAhNy9FsrmCaNcLQ7yp5jYycBNilzjVol5jMQet6gfHxuxkdPROd/QFd6qRcDTtynEDfmNX72VQiiTuAfBOR2Iz97M+e40tfusQPflDm1KmXeOCBVVZWzlOrLSLLMuXyHB/96Fv83b/7jzl37hTHjj3H2bNP47qRN6vn1RGE6NR7XsjY2Cnq9UU8zyDR4d1983pszxvg7Sg57022+vGCcRL7geQ7Wfp9LwD2XnEzQD6Yme+lY75fKX12ducasay9SXN7bWOvSoxlDap+JSF2naVuPkSSz9KgmIjjNACNSDgkhW03UdUMltVEFIX4M9qOJS8lOp01LKveLUnLsoSmZXGcDp7XQZJkHMfENNcxzTphCK7bRpZTaFqedHoEWVYQRQlBkMnnp1la+iGO08S2o7Go5eUf0Ols0Gxu47p1DCMS8Ig8myUMo8H1639JOj1ONjuGIIhxvxtkWScIPCyrjus2yeePUCodo16/xujoSSYnP4Bttzl9+hepVBYYHfWx7Sa23WFp6QUsq46q5pAklWLxMFtb84yMnOzaOCbzwwnIJqNLggCNxhL1+iLZ7CSqmmVsbA5Z3v0BMYwK1eoCENLpbMWa2/nuNhOhpU5na1/G9V/1LPqv3it6h8OyGjSbS3zwg6/zcz/3ASxLxnHOIgghQSDGYwLjaFqeBx/8JidOfJVsdhRBmMZ1ze4qUZJUQMKytlheriIICkEQ9bwitaNnB25eT+15TD+JJefbFe9kufdWiF43Op63A+a3cyGQqGwNu2ZuVGm4VUb6fpWYHeeoCJRnZl7gkUf+dV8PGW6mbO0O/J5obRN/NwEVx7GIfIZdNC2LoqRjSUwXQRBjZS4QBBXQ0bQU5fIZMpkRNjaiMabIXUlmfX0eRZHIZCaYnv4w29vzZDIjqGqW6ekPIUk6jlPFMGpkMkUKhaPk81NUKldx3Raua7K8/Cy6PkqxeIzR0VMcPfoxTLPKq6/+HvX6FVqtFbLZn419jSMGdqu1iq4XmJi4G00rMD19H7XaEq5r0GisIklpyuVjWFaDkZGTsXdylGnbdjSn7TgtVDVHtbpIOh2NUrluG00rIkkRTCTZrChGkyOGUcfzDDY2Xmdt7VXS6TJAl1TWG+n0CMXiLKZZQ1FSBIGHphW6YGwYW12QH2Rc94LwX/Us+g4g32Sk0yNMTT2AadZIpUrYdpMwDCmVZqlWL9BqbdBqXcM0G4RhiKJoSJKMqmZoNJbiEYscqdQ4QeDgOFuEoU0YakTZgYgsa8zN/QWPP/7XWVz8JLOz39k3431n53tlokWCeRu3+d6J263i9XZmn2/ndm+0z9nZiLS1svLOzITvdV73qsQM2kIexEDjJo6GCJB7r2EFQdARxRDHaROGdRQlhaYV4hEohyDwMM1G3MsFRRFjA4gU7fYWmpYjkxmjUDjCtWvfw3EamKaB57n4vtlVqJqaeqBrBtFur5NKbTM6ehdnz34BWdao11dwXScmcYYUCoeYnDxLGAaYZhXHMTh69BO4rhOPSAlcv/4cJ048hq4XWVp6nlLpJIqSZmzsNIXCUUZGTtNoLCKKKqbZYHX1FYrFo2xtzdNur8bkNZljxz6BJGlx1rpIEPg4TodUqkwQ+LGrlRx/j8ahgsBDECQEQcBxDHS9iCAoqGoKTcv1ZdRJiKKMLOuEoc/y8g9oNlfJ52e6lo2+78Vz0p1dMpq9IJwYXfxVnVu+A8g3iMESiSjKscXiUTzPola7zNbWRcbHz5LNTmMYW2xvX8f3fQRBQBQlqtUlwtDB8ywivV0d06zjeSYgxISsx5id/R5zc3+E5wWAzdzcXzA39614lrn3qDQEQSMMHRJP13dOOCIhyPxkRa/K1OCc7bAS683E7crKb2Y7t4th3bvPhLR1O4huw0iFg57Mw67Pgx5Pf9zs6F9i05iEAMiEoYHnJapd0ec1cnyKmNGu6+H7FmDj+zKgUSrlkKQsprmE63ZQlAyWVUWWlVi4I0W7vRGTqtLoeoFsdorV1R+haZGC2NTUA4yMnELXC1y79hySpKBp2XhO2SefP4Ek6Wxvn6fV2qBUOorrWoyMnODatWep1a7j+x10vcDY2F1YVh3LqiJJowSBQLO5TKdTRRSleL45Km0vLn4PVc2ysvISvu+RTpcpFg8zMnK6m/0m0pcQ3fs2N88hy2nq9cVuElKvX6VYPEYqVUKWNTQtR7l8AlWNXt+wDDYxkuh0KqyuvkStdg1FyeJ5Dq5r0umsoWm57jZ6o3fuOTGnqFQWbuha9ZMYf7VezTsQw0okCUhbVp1XXvk9Go0VGo3LFIvHSaenGBsTYqZknlrtMq5bJcp+ZWRZAUSCwCUMHebnPxcrePm88MI/4ZFHficW7Ni5ie0msriEYaTD+85HwA7J5r0T+4HZoMpUwtS9WUC72ez5nRitutH23w4JbL/93My2es/3oJvTfmTDW+/P3+zoXwTGphmRwnw/IJfrzZYDIPJJFkUVVU1jWTaqqiFJ+VjgJ0DTioQh2HYd225iWe24/1oEPKamJlFVHUGIpGoNo0axeIJK5QKmWUEUD6HrRVqtDcbG5vjRj/4DYQiqmmF09CyNxlU8z4kVvlJUq5dJp8fodDbQ9TKNxiL1+jXGx++lXH6AQ4ceiLNVEU0rYVktNjffwHUNSqVjMWk0Tzo9gWluUSweZXt7gYmJDyCKKqlUAc+LXK0qlQVMsxpX/Vq4bpuNjXNx6Tqa+mi3NymXZ5EkrQuElcoFgiAgnR6hVrsW21VO9jg57UhwGsZ27HrnACKalkJRUlQqC4ShT622SC4X3WN7wbyXrZ1Oj9BqrXWVwPaybPxJ7TX/5BzpjyGSi0rXS10yQ2LEHYY+q6uvoKppFEUllzsc+5IWyeUmsawWlcqbBIFMBJwekqTheTa+bxOG0ap8cfGRnlnO8IaWifGRkWTG707c3nL12y0R3+hGPuiONMjUvdH2erd1u72Pb2cMOw9RafXmGNg3s7/ktS0u7mS+g6peL730RV5++VdZWfkwibLXj3u+3bJ25phFEdptyGZFomqTiKrm8X0X32/E87mRJ3EYhmQyJTwvJAgcTDNiVEcmFCGeZ6KqacJQiMu+bTKZcer1yEWqVltgbOzu2LYxExtfVHnppX+PYVTifZeQZYV0ehLHadJqXWN9/RUMo4qiZAGRVuscnc4WQWCjaTmOHn0Y06zS6WxRLh9HkiTCUKHd3kQQBAyjQbl8FNtuYxgV8vlDrK29gmnWyGQmyGYnYjnP1zGMCo4T9ZI7nTy23cQwqmhaGgBF0djevoDjtAkCl1xupiuFKcsZdL2EaTa4cuWbCILIiRM/Ty7Xy57eirW2JWy7jet2SKXypFLj2Ha7K7c5NnaGSmWBYnF21/vXy9KOFg31fd/vdnuDzc1zCILM0aMfH0o0ey/GHUDeJ9rtDarVS5TLpxBFmXZ7g+3teVqtDVy3Q7F4FNtuMjHxEFtbr7G29hquazI9/UFMs4brOrz55ieZn/+nzM4+y9zcHxJJ+4Eg5ACR2dnvxSYSybjHbv3q/W9it6rclSwU3t14OxKVB41BktuRI/1ewL1l1EHS0Dt1TMPiVnSwbwSsvfKd70QM+jO/8MKvcebMV7pymmEos7Dw+V3PG0Y23K+t8PZCZ3DB6vsRECfnN/ouoesjCEKAKOrYdg2waLXWkGUFy2oDNoahoSg6vu+haTkajQ2CwEIQJBQlRxhG7OtOZwNNK9BuR/PMllUllxvHsrYZH78HVY2IWOl0kVRqFNd9hcjBaQFBUDl06CPU65fpdKoYxhphGOC6JqIoIEka+fwk4+N3cerUz+P7NtevP4+m5WKlsTHC0EOWU0RewzaGsY1pNhkdvSvmrZSo1xep15dIp8sx72UxHrUMmZl5EF3Ps7b2KmNjp5HlNEHgUa1eQVGyyHIW17Wo1a6wtPQDyuVjiKJEOl1mZORkd3SqVJpFVbN9vWBdL8TJTZFjxz6FJKWZnLybWu0qtdoVTLPBD3/4vzM6epZ0enGXsIhhVNjeno/vtx8glRrd07IxCDxarTU2Nt5A0/JksxP7+j+/l+IOIN8ggiCazUsyZE0rUK1eBQIsq8HY2F2YZhUQaDRW8H2LZ57561y69LcwzUt8+9v/IL5x/fd92W4YmqRSU8zN/WmPLOHO2MfBGdODYKywm2E6LH78YPxObXs/kttgGbVXeGJwe7cKyrf63IPP2N6+GHacNypv92bE4HPhwi93qzyl0gVqtdP0tzlCzpz52q73YVhb4ValSPtj90aSxU4YgudFlYRIHc9EFMVYjAdAxvOS3rJIwp9I9AFsu4PneQhCQC43RRg6uK5Lu72NKKqEYRiTlRxSqTEkScK2DUyzha6XCQILz3MIAjfmoFyl1VqhWDyG51mMj99NEIRoWo5a7QqVygUkqQA4SJLG4cMfQ5I0Ll/+DpZViccnRba2zpHJjOP7kQ2iIIhIUhrHWabT2YxFUaqxypgSl3SrtFpLrK6+RC43iaKkEEU1toe8zvT0/XiejaZlKRSOxMzuIuvrb3QlMCHEtht4ns3Zs5+jUlkgn5/py0iz2Qna7Q3q9asoisb09IcYG5sDQJI0TLPNysqX48XKOqXSZ/reu6RSqWkRkcu2W0iSvKf+deQ81SCfP0Q6Pdadqf5JiDuAvEck/Q9FyVCtLsS9FCNmMs7FfqLH2Nx8k8jmrYHnWbz22sf58pf/3/EN62dIsobd2a6HaS4BCo899pv7mkAMi73JMiFRhmBza2Ss3vGQ91bcTA90GMnNsobLRu6Vnd2MOcVBjvmdzrpvpUe+3//2Ot87Sl/JefRjtyafWu3MkGcI3H//l/r+Mjg73/s+JKXlJINO3KROnrx145N0GgwDbBtkGbJZAA/XNdH1YrxPGVnOEoYynteMn6kShh6iKBEEAmHo4vsuqlqk09lgcvJeOp0avu8SBBa+b2NZrW4mrKpFVlaej40fpmk0tigWZ1lffxPTrBCGkMlEY5JBEDGxFSWLJEmYZgXPcyiVRnBdg05ni0ZjGcuq02xeR1HSTE9/gI2NN/F9F9Osks0exjSbSJKIKEp4nsPW1nkEAXzfpVA4gixr+L5DrXYN13Votze6WvqRZWQHQfC5cGGNkZGT5POHcN1I/lOW04yP383S0vP4vkUuN0OxOIvnWWxsLHVFSyYm7ukjh3mehSTpKIrcJzaSz8+Qz18jm51CUVQKheNUKgt9z4/4OjVyuSlyuanY3arWx/zu7Ren0yOMjs4xOjq3y9/5vR4/OUf6LkdyESRzx4qSxrZbNJvLpNNjhKFPsXgYWc4QGZrniOwTH+7JHiLbt51s93vd7d/IV3a/G8/+ZJlo1boTB82Yk/jJAeObkZ5MHjMIJgcRnrjVjPd2lef3AsdbBdRhzx1cOOz33N4RJV03Biw+kypPQCazzqFDL3L//TuqXsl1ryidLhgPvg8JGEcZ9I5W9ksv7Vg+3opEbDoN6XSG6DNiJ68cy4oqXODi+1HPNAiUWMoWRFGLSZQOQeAjyzqeZxKGHtvbl8jnjyDLCr4vUCyeQNM02u0tWq0VdL2DomhkMiNYVpPV1RdptVbQtAL1+iKZzCiKMkImM4aulwCJ1dUfUq3Oo+tFNG2UmZkPEQQO1649R7u9Sa0WCXFMTNwbK/3N0GqtEQQevt9BUVI4Th1ZnsT3TWq1xe7jSqWjpNNjbG8vIElb+L4Vs8VT8fd0LDTioKoFPM/DsmpoWhHHaeO6bZaXX8R1LarVK3ieE9tJNqjVrhCGQixkEgFkvX6N5eWXCEMfWVbIZMZ3ZbaiqJLJjJBKjWBZVUwzi2FU+ohcyfdmc4XFxe9158WDwGN9/TWy2cl4rDTyHdiL7PVejzuAHEfiVJKs3iL2YSc21RZot9cwjDaua+C6y0iSwPz8nyKKIpXKpe4Y0+zsd+KeMCTyfadO/Qkf/vBXOXny28CtSV32Anh/duHz9NP/CtDiHnXIjkIR3BwYv/vxbvRqB0drBudd320t6fdC3IoxxmDPN5kVTqo7itIPzp/5zN/fs12QOEglGtiDvfz+snhkZLFj+XhrErGRaUSKIIhGmaLoJUiqsZqWgiTJiKKCJEEYCjHpyQFkJElB18sYxhqWZSKK67TbW6hqHkFwCQKdWu06iqIgSdHccKFwhCAIaTZXCUOBYlElk5lEkjRc1+b69WfZ2HiDo0c/Qbu9jG23cByDkZE8b7319XiCY4TNzfMxucnH9wPC8CU8z0EUZYLAod3eIpud5Nixn0ZR0mxvX0KWFcbH7yOdLuG6FisrP6JQmAJOEgQh7fZGvBgQAYmRkROUSkdptTaxrDq23UEQZBQlxZtvfhVBkJBlDVnOYFl12u3IStJ1HWZm7qdQOEo6PUK7vcGFC1+n0ViJ+7gfoFic7QJsQtSKZEdPMz4+h++78eKk0DfPnICzadbwfQdZTlEsHmNr602Wlp6jUDiGomhAxMr+SekZD8b7GpB7qfGVygLb2xcwjG1GRk6xvX2B5eUXEEUNw9hgZWUJTSuSyx0imx1nefkHjI6epdm8TrN5HcNo4roWc3NPMj39A1ZXP9LdT6czycmTv9/9/WalLgcB/JFHfqevVLi+fh9PPPF/8vjjX2Bu7qvv6Dl7O3G7RTj22u6NYtA04Xbv791kWb9b+xocJesFw97qTm/rZfCaHrzuXTfNpz8dWTXOz3+GhYUdsO83wIjAeMddavfn5mDmKiFBsD3wN53EHUqWUyiKDij4fismbqWASHfe90MgIAjc+MvH91vYdtTzjQSAypjmJr7vI4oqspzCcQyuXn0mJob5BEGIIIjIcgrft5DlFJGFIriuzfT0Q9TrSwRBwMbGq3ieTaFwifHxu0ilytRql7GsGqL4GpIkxdnkNNnsOKnUCGNjpwGZK1e+S622QBCEuK4V2z9uYhjrbG3lGR8/i64XGR09QzY7A/jIcgZZTiHLGWZm7qdeX2J9/TUymRHW11/HsiKhkhMnfpYwDFDVLI7TwjCqmOY2ltVmZmanTDwycoZUaoJ0ukgmM9L1ak4A++rVZ1he/j6WVUeWNUZHTyLLOpbVGDrPPDJyklrtCtnsZJc4C5DPT6MoKWy7Tak0e5NX93sn3reAnHgch2FCGMihqjkcpxXP30UkinR6Ih5XcshkJpicvJfNzTdR1QyaluXQob/Oq6/+AY3GaiwsANnset++VlY+yvz8Z7o3ipuVuhx2I3v88c/y9NO/xfr6B0nK4ouLP/WeBmS4dQD5cc4E70V8Osjz3uke8rsFyoOjTZcvP8rs7O7Z7v0Eava67nsXnAnY33vvkyjKZ7l8+VFk2cDz0siywfPP/8a+z7+5zFkBBFS1HI8l6ThOorJlEBG8nDhTlgkCKZ4bziKKkQuTIAik02OxqIdIu30dQVCQ5RRg43kWoihiGNvxPtKkUllc18R1DUyzQiYzRrE4i+t6gI9ltSmXT7G5+UZM/uoQZa8qsiyjqnkUJUU2O04mM0a1eo1UqsDhwx9H1wvoeoH19ddi8lNkDtNsXkFVs+Ry4wiCT7N5nY2NEMNYJ5WKeq6pVBnHMdC0HNevf5/p6YcIw2jca3X1JWZnf5qkWtFqbZJKFZDlLJ7XRlUziOIUnmdw/vwfMz19P6qaodlcpVSaxTAqZDLjMWt7gXL5ZFxufp0/+qOACxce5Rd+weUf/sMSQeD1lal7fZRNs0Y+P029vkwY+gSBQzo9gSBEzl7lcuTFPExg5Cch3reAnNiFJSYPjtMinS5z/fqzSJKOrpfJ5w9jmhVc1+Dw4YfJZMZ4660/RtPyhGHAkSMPo+tFZmYewrYb/PCHD3D58seZmLjAxYuwM8rk963mb1bqctiNLHlObwlwdva7t3Am5PgrIYFFZu7vxV7y7QKe3tLrXhKN7ySYJ3G7hDpuNygP683Pzg7vvd8M8W1urr9dkFzDe1WM5uae3FXKnp5+cZfc562ZqyTcChHfN/F9gSCoxyShqM2jKBmy2ZmYyBV22b6+bxMEEoqSIp8/iixLsVpWDUlSkCQFRVFxXQ/H6VAqHcM0K7HEpEChcIxOZ50gsONkYARRBMta4fr17+G6DoqiMT5+D5nMCGNjZ0inp1AUOe6TikhSlkxmHEVJo6oq2ewUrtumVDpKpxNlsYqSZWzsLKqaQ9eLJGOVYShg2w22ts5jmh1SqRqqmkdVUzFwTtFoXEWSUrGJhoVltZBllfvv/9tcufJdOp1Nms0lJCkyzZDlNMXiIWq1JdrtNWy7juO0qFQuxWpfGoXCIUyz1iViiaLM88/P8bu/+ysIgsdf/qXM8eMVPvrRcwDdPnCzucLS0vOYZp1cboJGYwXb7uC6LQQhajO89dYfcfToJ5Bl7SdaVvN9C8jJCkxVM1QqC6RSJVQ1x9jYPVhWg2LxMPX6Eu32Bp5nkU4/RKVyge3ti6hqhomJu2k0rmMY24yNneaP/sjl937vH3VvDGfPfoXz53+ZpNQ2mAUPmrL3l9sSqzi7+9hhAH7rGtYZot6ZyY7pvB4fq4+mjWPbG7d0Xk1zuAHAj9MhSdcje7+EsZtkWS+99GsoymeHziLfbOwnLnKQx78TcdBS/n52lgnY33PPk4ThDpieOvXkrp7yQV5zb7sg2fbNVIx6e9dJ3Jq5ik90zTv4fuQGJQhloE20INVRlDymWUOWFTzPJ50uI0kKhtFAECxAjU0hlJhbYtFqbSDLWgxUEUPb910kSSGTmezaHRpGhU5ngyAIaDavMDp6F6nUKIXCLLXaJVzXiT2FdSBiDqdSJcbH76dWu0wuN46q5mm315iaehhBCBkZOUmzuYLrtllff4V2ew1VzTE5+QFyuUNcuPBVVlZeRpKUWCBFQ5YNVDUipkpShjDcih2sVLa3z2MYW/i+DQRsbV1hZOQ0rmshSSmmpk4SGXC0sKw6EN1Ps9kpxsbuwvMsOp1tJClLELQxzSqeZ6GqWTqdLUZGTnL58se7vvGi6PPsswof/rDX1ave2DjHxsZrbGycZ3z8LNvbF/B9l0ZjEcOok89PE4YhrmvQbm8xM/MgltUgnZa5o9T1ExQJPf7q1We6JZTDhz9CLjfFkSMPxyLno/i+g223UBQN1/VJpwsIgkK1epnJyQficsomL78807dKz+dXDwSWe5fbgr7H7NUfe/sa1olWdZIV+7Hm9o3DjAW8egF4Lzeeg2Rxb6e8ux/49M689gpYJNnUICDfiIG81/8G/77Xa3g3SWS34rU8+Njk514wHSZPequGEPstLA9S9r+1hamEIERmB1FGrKGqIq6bxfNCdH2CMDSxbQPbDhBFAV0/hCjqpNMhtt1GVcX4/lDF932iHnVAENj4voOmBQSBQLV6Gdtu4LoW2exErFbVRlVz+L5Jp7ONKF6mWDxCJjPJ6upLcT+0iWVVSaXKNJuLsUFDlUOHHqRev9adZ9b1DOPjd1OvL8XgqpDPHyIMvXhKZJ1U6gqVyqXYyUqiUJhGFHVSqSyKopPNzlAoHKVUOoLrOoRhNCfdbF4nDCPDiUrlPIuLKarVeURRw/PaeJ6DaW6Syx1BUVJ0OttMTNxDsTjLxsa5uCxfR1F0VDVHGAZsbl6kVrvE1NT93H9/jj/4g1NdUH7wwTVUNUu1ukC7vcH169/n+vXvoShZVDUbVwQyTE19lDCMWO/F4lFWV19kbu6XYlOMqMRtWTXgJ8sV6n0HyIP9iCCw8Tyjq6Wa2H8lnp/p9AgjIyeo15eQZZmJiQdotdYJQwvPM0inZ1hff4MHHnD55jflnlX6XzI3903m5p5iv/Lv3uU2F8gwP/9pnnji/3obzFLYPfrU6fk5GzM0I0MLIL657B+WdTNWeDeOd1LBa5CVHs3MRr/PzDzdfdxBTBZ6j+tWgPWdAOO9QPcgPsW3eo4He8rD5rkPsu3exWZC8BqMg2xndjYqbx/g0o3DJwxb9E4kmKZNxLgOCcM2ilJGkhxEUYuVr+oIQojj2EhSgCSVUJSodxl9iUiSFBOWtnAcF0Vpo2kZFCWDqqYIAp/JyXuwrBb1+nUcx8c0q2xtvUW7vUYYClhWhWx2sstjyeUOMTV1L63WKtvb51lc/A4gcvjwx8lmZzh58jFarXV0PY9tNxAECUnS0LQSjtOh0biC4zRIpUYJw4AwFPH9ANuudDP41dUf0mxeZ2TkBKKoUCjMkM3OkM9Ps7FxnlbrGr5vUC6fpFQ6QRA4hKFArXYVx2nHymHPkUoVu7PIul6I56trKEoWRUmhKBm2tuZpNK5j2w3m5kJ+/dd/yLlzp/nAB65y//0TVKsqrdYS+fwxwhBSqTL5/HGOHfskS0vP4ThtPM9AVYuUy8dw3Q6Tk/eRSpVj0thWLHc8tqea13s13neA3GyucOXKd1CUNJnMKOn0OEeOROSIbHaiK/Bx+fI3aTRWu294sXiY1dUfks3OIIrryHIJz/O4cOFPqdevcPasyz/6R+u89NIkstxgcfGnAJe5uT9nv9O8f7nNYHHxEzfRH4tUe6LxjPgv8ghhGOD7TfrHoZKwCIL+50Rlu1uPRNghCHbkCqOFzrtbut6rJPrII7+DZaW7pdd3ev+9v7+d6N2W6+6WyXynZUl7t3WQee7B/Q8uCBYXb5WM1R+9bRJJupnX3ft5sOMvCVDxPA9JMmL9gUZsV2gSVZJkfF9Gli1cV4y5KCGSJCEIkYKfJMk4Th3LAtftkM1OYBhVdD3EMGrdOWZJ0pGkLL5fx7bb3ZnnQ4c+FptJLKFpGfL5GRzHZHNznk6ngm3XEASR2dlPUKstout5giDSy9/YeI21tR8xNjbH6OjPkCwYrl79Nr7v4rodTLOOphViYlaGavUKzeZK3OsuxFKZaTqdKq7bQlWLaFqWZnOF8fGzpNOjyLLO6OgpLl36FmtrP4oVC0NarVU2N8+TTpeZmnoI09xGljWy2Uny+RkUJRWPNa1TrV7m4Yfn+djH5tG0Iq6bI5Uq4DgdtrbO8Sd/Aq+++lkeecTh7FmNYvEES0vP02xeY3LyPsbGzjA6ehrbbvWVp3W9EBPtfrLifQfIid5qRPefA8CyasiyjizrZLM61eplTLNOJjOCIMiYZo1Wa50gcNnaegPTrCGKCoYRjVDYtoGmZXnwwR9Sr0/w+7//n4beZAQhTxg2u8eSZAe985iDqluzs9/mhRf+cffGpygGX/7yHwPwwAO/2/P4XvennYzY8xpIUhFdL8V9nl7JzHdGzzq5OfaC8Y8r9jrHbwccb8U28Vb3t1+J/GZ1q4cdw62C9uA890EXNr37ujUyVn/0VmqSa+1gEqSReMnu8IHIkUhRxhFFnSAQcJw6YWh2nyOKKp4XxopeTvy3HL7v47rJzLKEZbURRRPXNZFlBV2v02qtoutFFEXHMLZjcFXI5Q7hODUgzfr6qxjGBrZtsbj4NJ5nUa9fwXVt0ukRyuXjhGHA5ctP025vY9t1NC2P55m025txvzrP5OS9pNMjnD//NTzPjMU9AjzPIQzbTEzcg2VFmX80gy3Ec8GzQLSoiBYSeQA2Nl5lY+M1CoUjzM19Dttu0ems4zjtuHeuIggKjtNBllXa7VWazRVGR3cU3PL5GdLpURqNpS4JK50ew7ab2HaTTkdDUbL88R+7/M//8z9HEDyeeUZG0/4LP/uzrdhgo0i5fBdHj348TqLMWHBkoivVOWxs6r0e7ztATjw0R0aSebc6y8s/YHZ2Mh6QL8QrzgKFwiGCAAzDR5aJWYv3s7r6AvX6FWq164RhpPVq2w0cp8OlS7+4x01GQlHysSau3e0dJ6SqvbKDublv8vjjn+sTXkji4sXP9Tyv9y7U+7OH77eAFP03oMgTNvrbzZtT9IJMVFba/ZibKWvfyojQjUCut88ZhvItZ2DvlXg3jDlu5s+uRpcAAQAASURBVBgOOs+9Fwfi1shYuyMB4uRaO9g1t59gTvT5se0W2WwKUQzjedsgBmWJMAyJMmqLJNMOAjsenbSAFKqaioU/OoiiQuTBLGAYWwSBhyiqsUqYTLE4jSzr1Os1IKRabcV9UzXuO0esad93yGanyOcPc/3696hWFzDNNXK5w7Raq6hqFtPcQtfHcByTy5e/jWXVcF0L33cRBBFdV3AcEUEIqdWuoOsRWa1UmiWXOxx7G+doNleRZR1RVLusbV0vsL29gO9HI0u12lJsnxgQBCG+byOKISdP/gzb2xdi4A9xnCZray/jeRbXr38/vl82yecPo2l5arUrbG+/RRj6TE9/BMva5vXXP97H+/j3//5+guBFPvaxKcBnbOxElwtkWXUWF5/l+PFHCQK/y7Ter2T9XrRofG8cxbsQvSc/UXEJAo+FhW+xufkmnueSzY4ShsRi6kfpdDZoNJa7xt3F4hGCwKVavYBpNnCcNuBjGDUkKcR1w9i96Z/03WR2bkjPx2pa8PLLvxofWaTm9corX9wFFpEogcjddz/D3Nw3+cY3/jU7rGiAYI+sYjDrdeK+8A7wKkoJzwsIw1tX8rrdYHAz2ztIxrnX7OywGHYTvxWG8o9T9WtYJv52QHtwPOxmX5uu7z8jPEjGmp3d2cfNHHPve3eQikxCRgwCyGT2elSAZW3HgOnTPw7oIIppPM+kt+wtSWKsAiYhCMRZZfT4VKqMouRQFJlm0yQMhbh03CSfn0aSMrTb68hyClGU0LQMhcLR2PKxjmU1URQd225Rq10gsoUciXX2XWq1yxSLs4iiQiYzSjQTvUkuNxXP/0bg22isIstZdD2PKKZRlDQQcPjwx8jnDyOKCpZVZ339dZrN66hqkXQ6T7O5iuuaWFak2GVZdba2zlOtXqXdXiWXO0QuN4UoShQKR1hefpH5+T/F9y3y+cOMjJym09niypXvxjrUUbZumhXy+aO4rkE+H/lFO06TVGqSs2fP8a1v/U2SSZXl5VP81m/N8c//+f/CJz6xSL2+iKrmGRubY3PzTVZXf4jjNDl06MPA3plxggVB4L3niF/vG0A2jEp3ZZpENFfooigZFEVja+siYRgwM/MgABsb56nXr3L8+M9RLs9SKs3y+utfptPZwrKapFLjWFYLz2vQatlIUsjc3Ff7bjLALpWtjY17Y6/YnRhWZovAUsf3o1JZklHshHjArGJQTlNDknLIcoBpJn2WxMbxZrWv9453ShjjoMBwoz5nLzkrDN8emN6KFOX/n70/D5PrvM570d+ea+4ZDaAxNIAG0CAAggM4ieIgkdREU5ItD7Q12Jbi2M5jO851co6T2Dk+se49OSc3TnLz2E5iW4ntxKZl2bJEDRRnERxAigIEEgAbQANojD3XPOx53z++vWvq6gkACdjxeh49Iqqrdu3aVft7v7XWu953ubhWutdXwq5uZ1FDZ1es5c51ubJ0NCXw9tuP8eyzv1MfobrSjYQAwsX/Xqm0ZtKLv0/A4veBRhBE0wnRsVIEgRHqXzsEgRyWq1Ucx8bzZlHVHJqWwTRLKEo81DtIIkkKpjlPEAg2tyyLDLyraxOVyiyOY6JpCfr7d1OpTFKrZdG0GLFYN/H4GJVKFlXVqFbnQ2DcErbdZkgkesjnL5FOb0ZVDYRlpEQmsyEUNxEkNkXRWbv2FubnTxCPd+N5HkEQ0Nu7ia1bH2Rm5jgXLrweXt8ebLuA41h0d28iFkuSTG5Aln1KpWkOH/7vaFqaSmUG286TSPSFJhZTJJODIQnrZk6degrbtlFVnVRqI4oiUSxeDG0TUzz4YD/F4hd45pl/yqVLOwgCBVl2OX58Fx/6UC5UICszOzvG8PD9AAwP34/ve0tmxtXqfEigg2TyxiJ+/Z0H5Gg3FJUwIqUYCDCMbhKJ/lDizsB1a0gS2HYlLMFYdHdvwTCSbN58L9XqPEJWz8Ywuslk1qIoElNT5xgb+zATE/e1mEUAPPXU77SUXZpLzuEZIsBQalHzAhgb++gCA4rHH/84hw9/niCA22770ipKsNHiIXb6pjnV9nh0HtdW+3o55vJqF11nFad3pX3OlcbVsK2vRH7zasF2qWg/zkpY1EudaxRLlaXbwR983nzznzAy8jX27fujFY1RrXbT15w9y7LIklcWLtF9KipOLlHFSZISBEGApgXh71NGUeLE4124bhXHERtiWU5i2zk8z6Ranaa/fxdB4NHfv4NEogfbNrGsHFNTR5FlBdsuI0l+qMyVADwuX34DSdKIxwfYsGEXly93EQQS6fQgqpqmVpsjEiSSJI1SaZKZmXeYmTlOPN7L2rV7wvEjh1qtiKYZxGL9dHdvJps9iWnm2bDhThKJXo4dy9LVtZl1624JHaWqFAr5kPyaQ5ZjDAzsRZY1+vqGqVazzM2dwLLyYQ9bCKDUatlQYSyFbQsDizNnnsNxKriuFZbdC+G8sxTaNHYzOBjnnnvOk0r9Of/pP/1rZNnD91X27TuDLGvIshpWKqvE4z3cdNOPtH5jTf4EzXaQiUQfpdJkXSXtRilXw/8CgBxlxiDKEs0ZsmDi5clk1uI4FqOjPxQKuo8wPz/Oli0PUSicx/McpqePoqo6s7NvYxg9aFqc3t6d2HaFEyd+iCee+Iu2styzgL1gQWovOXd3nyGfH+HUqUdbesLPPffbdY/k5lLfyuaOo2y3/b9BAHKVzozr1feSVxtXU1K9EvC5Wt3q5riWJforBVJFAc+7OqLYSs5lpa5Yy12TxWaEm9/zyJHW9s34+GOMj38CTVtZz3+pc2juX4tjf4CNG19gZORJfL+9vL3QejQ6T8+DZLL5/mj8t5hllvE8UBQdWVbJZDai62nm50/jeTUURVThhG61hu97WFYRz3MoFi8Sj/cRi2WoVqcxjC6CwKFUmgJE1phK9TI/f5JC4QJBIJNKreXyZQlJkpBlla6uYTQtQ6VyCUkS2t+OU0KWu3FdO5TRNEgme0in11MuT+I4FQwjycDATczPj5PLnUFRjNBcxyEIXKam3mZu7hTVag7LKtDdvT0cq4pRrU5x/Phb9PZup6dnC93dw/i+j+OYxOM9qKrB7OwxXNfm/PnX6O3dxsDAKBcvvlnn72hanLm5E/i+Tzwu1lVd78HzKsiywfr1t7F27Rzd3f+Fo0dHufPOHHfccZ5kchvxeA/xeC+O0zzG2Yj5+XGy2VP4vks6vY5Eog/XNblw4fVQs/zGi7/zgByVI5rdQyJJtnJ5mni8h1otRzLZj2F00de3A6Dux+k4FebnT+K6NhMTzzIzcxyRXaeYmTmC59U4f/4jLYB76NDn60Su0dGn+NznfpaTJ/ehaeW2DFlmzZpjFArD9dcePvx5gPB5DZeblTFQJQR5S6EBuu0gW73CK3l941r3ZleqRX2jxLuVGS8W17K6sHrxGnlJ1vXKjCQW9q+Begn+h3/44+zc2a4u1grGUXk76ksXCtDVUZVRuEAJic0KoCJJKr7vYll5wMW2s8TjSYIgIB7vJXJJcpwK1eo8xeKF0IvZQVGSKIqG45hUqzNUq3OYZi6cDLmJRKIHyypRKJynVsvjeRaVyhx9fb0kEj14nhvq71tUq+MEgUsQeNRqcyET26S7exhFEURTWVapVKYRPs4qFy68Whfz8H037BkX8f2AanU67PX2MD9/Ate1sO0qsqwSj/eQTA7Q27sVy6qgqmKG2vMcLKvI+fOvkM2eCQ0xcphmniAg1P0OiMW6icX6Qp9jP3Tcy7Nz5w8zMFDm0UdPYJqzmKZFNnuKdHqQgYHR+niTIMqpda0JTROOUPF4D+XyFPn8BOfOvYxQYtzEhg133zC94yj+zgNyZN3ViQYfgXV392YmJ39Ab++2ltf19Y3guiap1BreeuvPyGbPAB5r1uwjCHxmZ9/B9z02bPgWQfCz0Ss5efKTTeVnne3bn2Tr1i8DVYaG3mgpOYNgS0evPXHikwSBRMPlRoDyyhmoVqhApNE5C4bl+8RR2nDj6VkvFSsdeVlNRn4lJhIridW85lqDr6I0RqaW8z2+kjI1rBw0Afbt+yPGxz9Bo3rkLcq6Xs5IYjGb0mhjGpXgJycfZN++pc8rGtuLStsLy9viuLKcxPdlfL/c9D4etm0j7jUxoWHbVXzfIjJsMIwU8XgXjmNhWSIjFJKbEAQuhcK5UJLTIggcbFtC19eSzZ7D9y00LRX2n0v1cm+5PEelMkNX18aw7G2GZeIkiqJSKJxFkghNLwzy+dNUqzOhkEeG3t4RPK+CaeawrCKFwgW6uzeFDnjHyefPU63O09u7lURiILSlVLh48TXi8R5GRh7G82yy2dOYZgHDEKQrYeVYZH7+VMjWTqLrQnXLNGthyT9JLNZNInEXtp1lZuZoqD72PFu2PMTs7HFKpUlsu4CmxSkWN2PblboYSLTWV6vzZLPj+L5LPN4XijzNhaXxPPF4N1u2fIBMZujvWdbXK5rdQ5rD910uXTqKaebJ5SZafDSr1XlqtSzT00fRtASxWAZNW0si0cv09DsUChcZG/sYExP76e09QTa7A9G7iXb33ySVWh+KyGtAJixlC7JLFN3dp8nntxCVl8vlwVBNSoDyffd9cYUZRhxdT4ajVT6g0yhZ2+F/JxFA3QmQI+/ZFcsdrTquZak1Ol5zdDr2cuCxknNaSuFqJb3g1fQ53+3MfLXzy6uNlbgvNeuLb978Qj0bj5ydtm3rLIG5FEmsvc3TsCmNQJllRqziSJJCEJTD5woQjjZ5htH+fBfQQvZzgYgNLMsahcJkOI9MyK4WVouWVcN1XRKJAXRdKHj5/hySVCGR6COVGqBWyyPLwkjCcUyCQEJRElhWhVrtJI5joSgyiYQUKoClqFSmqFTWIkkyrlujUDgXOkGNh2V5H8+z8Ty7rs9vWZXQTKKfZLKPvr4Rdu16DNd1icV6uHz5e2haklotSyazGfApFi8Rj3eRyWxAUSIhogBJUqjVcqHWtMns7Dvh4yrZ7BlUNRZa1V7GMDL093+I3t6dvPDCIG+8MUAs5uL7/YyOfp+77z6GqqokEmuo1bIoSoK//usyr7++n23bXuXOO8+RTg/R37+dQuEC8XhPqMzVWON7e0eoVGap1ebJ589iGBkGB/cQj/cxMvIwup6qu/3B37Osr1s0jz9FO6kgcEOJzJGW5wgC2FmeeaaXw4dvZffuETZs+BLl8gy1Wo633/4ATzzxJ03ZrIjGDe9TqcyGdm0yshxjbOxunnjiq21lNNGDEiFz+fLdS4iFLBYq3d2bqdXmkGUpZHtGkn7R1t4HSgte11D3ah2XitjHyzFXVxvtALiSTPS9sDJcLBYT1Fjpa2OxG6f8/V6cx0oEP5r1xSMt7Ice+rWO59ic9S5l4dje5olsSpsnHhbXu5YRZedGPzL6zUWZcSLR6dM6WNYcjaqSh++Xw2wZQA/nmDOYpo8sV9D1DJlMP5qWIpc7h2kWCQIXSZKo1QqhEEeaIPDQNJVYrJ+enk2Uy9M4Tg3bruJ5VmgJ24fvB5hmkdnZt0gkBiiVpnAcC12PE4sNIEkBqdRgCMIlMpl1FItT2HaNVGqAnp5hPM/DdStUq1kiF7yBgT3Uanls22Ru7ihBIBGPZ4jHB+jt3cbs7HF83w4FTOYpFC6QyWyiVDpPLncW1zXRtDiyrNLbO8KRI+/n0KFNbN/+JoODk7z++l7+7b/9h01yth5PPvkBfvVX/zUf+lAeSbLZuPE+3nhjL1/84ueQZZdnnvkUrvsr/OiPJjh79iVisV5isRQjIx9uyXKjCuf8PHR3D9dJXbFYF65r4bpW/XP+Pcv6XY5OA9/l8jRzc2N4noeiqKEp9yC9vQKEU6mGqbbo6Vwkl7vIv/t3W/nylx9Bkjy+/vUP8I/+0XluueUVYrFUCxO1YbXos2PH1+s3/DvvPMDExIcYGXmNkZG/ZmLilzqU0SLVIAGg7ebty4eOYfRimmUsq4IAVwORBVvLvFbFMLqw7XLLYhSBcRTV6mIL0rWJlYLyamOxDDqasR0ZWb6kerWx2GdbLjO/FpWE62FwsRhotspmtoL2pUsPdmRVd8q2O5HExPEWtnna+9eLf9cBCzer7devnSDZHCqt8rON11hWDUmaAtRw9EhklEICs4jjlNG0VGgWUQ1LyF6oR50iCAIsq4RlFfA8l0SiB8epAhKOY1OpTCLLCqnUGmRZQ9eTYUk6hqrKpNNr0bQuHKdMV9cGisVJSqXJUNKzj127PsX586+EJLQzVKvTlEoXcV2TWKyPWq2MJEm4bg3Ps1FVlampQ+TzF6lW85RKsySTAyiKTj5/mkplFt8HXY8jywaxWJqjRx/iP/2nzyBJLq+88guo6i9x6tRgy/oZacwfP76bhx4S8sayrPDWWzvrDGuhJ7Af1/0epZJw47v11s/juibT00fp6Rlmfn6cWm2eeLwPSQLHqdHdvVl8G3IrAN9I5Wr4OwrI7czqKEyziOPU8Dyzbpod/T0CcBD9lWz2LF/+8jxf/vLP0/ixeFy48Ah33HGEanWOm246ymuvqU0LgShZRb3h1sXkl3j88Y+jaRWaTQ4AWktqXl0ic2WhIElKOKoVLSgJFCUWjmYsFRKyLCS2gmDhCt0ssiDLC/58XaO9R7kS04TFZmwff7yzBeP1kvy8VmB5pWC8knGupa53J2Z1+/OHhl4gCBqgrWlVnnrqdxb0nDtl2x/5yK8tANbGJqBzm2f56kpj92maglUtSe2b0HYwbuZadPqxRMtrDdN00bRkWCkzcJwasiyj66JMnkh0E4ulw2TCwPcDNE2QSk2zEjpCqfT3bwvL3EKIJJ+/gOeZBEEc0xQjQMnkOvr7d4ajm27oHzxOLJamVjPC59Vw3SqmmefcuQM4jgBd3zfR9WSYdWfxPAdVjeE4JqCgKElKpWnERqOA45TwPBfbNkilbsM089h2BcepEAQGmcwAiqJx5MjWFlAdH7+TnTu/x3e/+9mW9VNY176N7zsIqV+fzZufx/fvqjtC3XtvjYGBWzhy5L8iSTqXL79OrVZAkgLK5WmCwKNUukh393C43lvMzo4xMDDaggc3Spm6Of5WAXLzTLHwvOy8u+nErE6lBtmw4U5KpcnQ1qwY7jKj2eRT9PZur6t3KYrC0aN7WnbdQaBgGA7/83/+A4aHn+Pmm1/nM5/5NOPj+9G0alhifqFt195YTA4d+jwnT34S8cMTi8bQ0Bv1heuttz5d91A+cOA3GBp6Y5nszUCU2Txad/dOSPIQG4Tm+cnWUPH9asgEbWVDRSMh7yUordSJqD1r+tSnlhataA8xZuO3LPKdANkwGsA/NPTCu2pEca3jWpharJZ41g7KS/12t29vzNSXSus4cOA3OvacVzLHLJ63uAXjakbtKhVBeosIgpXKUmpezfdMeyUq2sGaiHtPQZJUFMVA0wyq1Xlc1wNsFCWFrifCUrRJb++m0KLRpFbLI0k+kqSHus+96HqCcnkSw1jLtm0f4dKlV7FtYbMoy0EIin3hmKcwk5CkAM+zSSbX4nkemmYgSR6SJKOqGrq+Dk2LE493E48PUCpdolwWmbcgjZkh0JZxXZd4vItkso/u7tuYmvoByeQ6KpVZJEl4E5dKWSTJQlEM1qy5iT17xvjrv35fHZR37z7GPfecw7I+z4kT+9A0E89LsmvXce68cxrf72F+/hSJRDcf+ECaVOoPef31Xm6//TIf/rDN1NRYKEYCut7F9PQhdD3D+vW3IMs6sqzUmd+VyixB4LYkYDdq/K0C5CjzjS5wpTJb16ZujsWY1ZnMUJ2Fp+vJuma1EPwQyFOpzFIqXUJV49x+e5KvfrVBrrrzzpf5ylceDReHH+enf/pn2bfvBXbs+JvQMSkAKvVFvJENRxmw1ALQjpOoL1xjY4+FYLyaUSc93EXn6o9oWn+oH+sg3Gk8FidpLc60TiQaixO8OzKZKyFSdXrf9o3OUqIV7XHq1GMho1fEUhrKzcAfBKsH/iiuZ//4Stjf72WcOPFJ2hnQzb/7lcwxRxFZMF7NZ4gqQZK0EuGQpcxZmjXiNUDGtgvYthcyt/2wx5pE03R8P0BRVNLpLVQqc6TTmygWz4cOUmnS6X4MI4GqGhhGBsdxmJ09RrWaJ5VaTz5voyhaOIMcYJqlkLUtE4ulSac3kEqtwXEcSqXLQICq6iSTg6TTm5AkMUMdBC7l8qWQgFbBNPMYRjfCttFDVYUzleuaxOO9lMuXSSYHMc0sllUmCIR6l2B8T4XqXH3cddcRfuM3/gtvvbWVbdsOctNNr1Eslrn55uOMjPxNmEAI5Sxd/wAzM8coFi9TrXZhGN3ceutrDA0dD9frfSQSa4jFepFlnVotF4o89WFZZfr7d4ajXLMoilYX/7iResWLxd8KQG72MI7YdLOzY+EQfRpVjXXMljsxqyOwzufPMT9/CsNIk8kM1b8wMea0lnR6PT/2Yyq2/UdMTDzAjh2HeOWVZL1sIhaOD/Dgg5ep1dZQLF7E82yeeurX60xPUFrIWSBGnDrt9hfrgS0dZRwnQaO3laCvbwuua5LLXQr1qzv3tVp7Xp0XlsUzg+sb7VnTYqIVsLQCFfiMjHy94yIfi10d8L+bIUkNxu9igLta6cmVeEFfy2i/viL8jhuk1c4xX63pxvKeyqIy1ZoVRy2rThEJjojnC4vDDIqSCDNXC8sKWLt2H6oaw/NMSqULpNMbcF0TkFFVYVIRCWxUqzlyuXHK5RybN7+PeFyUvDOZrThOnmLxEp5XpVwWgK1paWq1AoXChfpaF493sWbN3lBRzKK7Wxg9ZLNnSSTWIMvHsW2TIHCJx3uQJAlJCkJf4xjV6nw9E00m12KaBRxHfJ7Bwb2hXrXJ7OxJPM/hoYf6eOCBC6FgR5UgAE2L0dOzhSAQmt3d3RsAH9938H0x45zLnWX9+rvp6tqI5znMz59k3bo7SKfXMTb2V1QqObZt+2DoidzN/Pw4llUmmz3FwMBu+vt3tih13cjxtwKQIzY0BPT370JVYySTA1hWnlotF9LvF/YEIvBtD993643/SmW2BdBVVWjElkqXcV2bO+44ziOPZFGUONPTl/n2tx+tl1127vwBlpVFlmVisR6OHLm3I9OzmZwlnJseYnj42foiMzb2GNns1isYdRIZedOVYnb2ZDho7wAqipIM5w6rNBYQHUkyCIIIkK+9BeNycaWlUOhsSrDS47crUO3f/6X639rfZzXA/15G8/jNtR4jezdisfNrv747d36dNWuOcujQFzh06At1e9F2vsDY2GOMj3+grnvdKZbiGCwF1vF4w3wi+vfCiLyTo4gIlM3/jqYbfDQtHSpfNZ7nuiZdXX2AGBfyvCLT08dYu3Y3plnENEsYRoGurk34vh2+xsN1a1Srs3iehSQZZDKDeJ7okxpGhq6u9RSLdqgAdhnf95GkSRKJHiRJJpUaJAhckknhblcqXcYwhGBJLNaFbVepVKaRpBiGkaGvb5Te3h1hq+8opllDVXUsq0y1micILOLxPjzPDBnMWpgZz5JI9GEYNq4rrChjsX7Wrt2NLMtUqzNks6ICEI930d29k3J5jt7eLViWECGRJA3hrzzD1NQb2HYVSVIwjDS6nkBRFCxLnG82e5o33riVkyfXsmdPjptvfgPTnEdVDS5ciDM0tL8uINJM4L3RQgqC5aUUisUiXV1dFAoFMpnMe3FeLRFlyNAA3ShjFmo4JQYGRle8CyqXpykWL2JZJbq6NpLPTxCPCxco33cZG/sGudwZNC3Bd7+7gbGxW9m27VWGhv6QN9/cz8WLH+Kee0rE4/87tdosut6Ppul89au/zosv/mRTlista/nXWhZV2bnzb7j11qU0qg2WZk7HkOVYvf+rqsmQsKUBEkHghvOIFa4HEEdxrUqpVwJGp049xqVLi42/tIZY2BcnJ60krkU/d7HjLXXc1WhtX22GvBTILXVuzdcXCC1JG3HffV8MN7lCNCT6d3S/NLcRIhLiu2e7GW10l7tvdCQpHo4ygSTJ+L6Pqgo+h9gcy/T330Qq1UupJABMkiR6e7dgmkUqlRlisR7i8QyKYqCqCXQ9Ho7rQLF4CfBIJPpD9rVNItGPJEnEYgOUSudxXZ9EIkMi0Uss1kNX1xbK5cuYZhFV1QGFYvEsvb2jqKpOLNZHJrOBYvEiJ09+jWo1y+DgXrZu/RAXLhxgfv4MritERiqVuRA4BbnMtmt0d28gHu+hWp3H8zySyR4kSSWdXs/atbezdu0uPM/hnXe+SrF4AdMsYtvV+obg+PGHOXXqLjZvfpFt2/4K160gvAOEMIosJ4nH0/T372DdutvIZDZx7twB5uaOceTIffzhH/5emCwp/D//z7e5556jKEqcIPAIAo81a0bRtCT9/aOLJmor4ShdSawUQ2/MbUKHiMossqxSLk9jmjk8zyWfP4NhiAuYSsUW9bhsfry5lF0uT2NZRUAAdaUyiyzLuK7L4cP7+PVfvy/8kn+SX/iF73Pbba/wwQ+Kwfq5uSS2fRnLmiKV6mPLlpd54YXP1LPc++//t4yOfntJ1SJhw9ggGPX0nFlm8VhqMZABM5xBFkQu140s44SfqSCyeTREQK69ocR7FVcHbitjq7WXS1ebkV5rMF7qfRbLAldrZHGtgHipiN6j3YilXev97bcfD/9bPNZ+v1y61GgjRATES5eWn4O+svBZeP9F3JFWP/JoxjUIrHCcUEZRBpFlDc8TBMtyeRrbzmHbVYLARVGSeJ5PEPgYRgYB3kKWU5YtDGMdmmaTTA7ieTa2LTJpITnZHfJq5lCUCobRjarWkGWDcnmWfP4CtVoJTYuRy51BVQ0SiXV0d28lFuvHNGe5cOFVMpn1eJ5Jd/c2PM+nWs1y6NAfYdtlXNciHk/X++yO46CqCp7nIkk+llUIR7dMEok14ebfxbKK6HqSbHacQuEic3On0DSdzZs/SKFwmmz2PIcP38WXvvRvw5bgj/L449Ps3v0MkiQRBCIBMYxEqECmcunS60xP/yB0kZrl+PE9SJJoJ8qyy8sv63zsY1ux7SozM2+hKDqFwiVGRj7U0sJs16WIOErRb+m9JoH9rQDk9jGm5vGkWq0Lw+iqZ8vNz40ucvPFbj5G9Ld1626jVLrEmTMvEgQ2ly//gFzuLM8/fy+y7OP7Yj5ubGw3t9/+BrOzR1HVGF1dG6lW5wAXTTN45JEsqvqPOXZsF1u3vsptt73Om2/+ZCgespBBOjb2WJNspiC1ZLPbFrg+tUanPlUk7hFZwjWrbZXrz3Kc2oJXiliq//XuxNWWWlfy2mY/32jRbs6eFlORuhZxPXySlwLHxa73e3GeS33XzS2JTvai8fg8+fxI/ZFKZV39v6N+8+KthsYI4WqkPBePTpWpAHH/NevGOwgLxlTT8zR83wpLtCkcp4Ln+Xieh+/LOI4d6kzXsKwKhhHHdW1s2w7XtRog4fs+1eocvl8jnz8PBLhuN6nUWjTNoFi8TK2WQ9cNqtUChuGhKDq+L7SsJakHCCgUzofjQQGKcpJqNYttF8nlziLLErFYT2j8MIbve8iyYIkXi5cBcb6+X8O2A3Q9GY5ZerhuLlTK2haer8nAwB4URWF+foJKJYvn2SiKTjY7Rrk8Qz5/nuPHf7YOqJLkcuHCB3j44UmOHfsIBw92s3nzs9x113ESia6wAnARRdGxrAq6bjAy8n1efVWtH2Pjxmc4c6ZCItHD1q2PYFlFurrWY1mts+bteAG0ZMjvddzwgBwBbSzWg64nmZ4+Sl/fSN25SVVjdaPpZiZdOwgnEn31Y7UDt6rGmJ4+zuTkIXS9C8sSgu23336Rr31NDkFZ5b77XFTVIAh8LKtCJrOJjRv38+KLmzl9+i62bHmVm29+ma1b/wLfd3HdDBMT9y66W1+otSsvcH1aWUS79mZNxIXONYtcYSBBay/6vYmVZo9XMno1MbFQCWr79icX2AqePn2tsqfOcSP1d98NBvVKe7MrKZ+Pjj7Jffd9kbfffpxkco677/7/ANStGSOda7GBbBXg6XSciFzZMHTxr/EmLLrHRBVq4VRCM4DLOI6JJMkEASiKFpZ71bAXW6NSmSMIAmRZJx4foFyewvd9arVcqDVQxXFKVKtSKASytj4nXKvlUNUh4vGe0JQij++DLEusXbuPS5feCBXBxCYgFusJM1uVWq2E61oYRi/9/aNYVjZ8ThrPMzHNMkHgYFlVfN8NpTsTNJjkConEWmxbMLL7+kYYHNzLxMQL4VpZpVo9SrF4hlism97enczNvUMuN4HrVvG8MsPDz3Pw4C838TVe4PDh+/jd3xXtidde+yXm5n4fTdvM+95X4qGHZjDNPJZV4sKFV3n/+4+TTP5Tjh/fw6ZNz3HTTe8QBHeEjlcKo6M/xIULB1EUqz7+1IwtNwoD+4YH5Gp1HtPMkUgMMD8/ztTUoZAQsbE+Xywy5RyxWFcLkasZnCMXkMnJ77Nu3e11x6cIqLu6hnBdi1gsxcWLZWKxKg8/nGNw8AiHDg3xyCNJNm70OXFCJp+fJQg8ZmaO8+ab+/njP/734Q/pcX76p7/AzTdnsW0b05xn48ZvEgQ/35FZvdCa0VtFma2T7nRUPoOVgXH0vPcejKPoNHvc/thKDCOi10axGEO6k63gcqzcdtC5Eu3raxXX2l/6WsZq2M3N1YtIoSuSv5Qkt54VN7tOqWqV115r9I8jAZ5O4TjJBZvdqOx9+PDnVwnIKpGRRGvZunGvVcJbKJrfF/PL0ey/AG5JkrDtPKDgOAGSFAv/LbTnFSWGYSTwPA/bzhOPZzCMbhzHxrJyeJ6P44i54q6ujaxZcxOFwnlyudOhfvV5YrEMQs/apFyewXW7ECVvJSSWecRi3ZjmPMnkYHjuM9h2mUSiF8PIYFlzdeEQVY2TyXQxM3MMx7GAAEWJoSgBnifWH98X2XLk6uS6JoXCWYIgoFYrkM0ep1yepVYrkskMYNsu+fxZfN8kFhvAdSVGR7/DZz7zGc6du5+hoefYufPrPPfcf65PtYDHs8/+IrLs8u1vq+Tz/xf79x+lq2s9fX3bKJcvc++9J9i///uhjeRadD3FunW3sHHjXVSr82EbQanjQjO2RK3Qvy9ZLxPNoCqk3HoAWsrPpllAkgjLDGrHxrzrmly8+D1qtXlqtRzd3ZtbVLri8V4ymRq9vdsol2fo79/JunW3MDwc8PnPp1DVGPPzH2Bq6ghBIBOL9XL58vc5ceLmlhv/9dd/jFtuOQBU8Dxn0TlKaGULa1q1hayy9MhTElnWUBQZxynTGF9aTibzxorVgFb7Yr8cKC7GkF7MVnAxULsa/+ZrHVeioNX8unfrPDqB61Kvffvt1upF5Hu82Caq2XVq8+Y3Ot5L7bFws9uIlW7wGqEjytBRdr5wTLB5ftn3wXWhFbj98H0NhFgIBIGFLOv4vmglOU4Rz+vB96FWKxCP92IYSXzfRlFkDCOF61bwvADbrmDbVarVOWRZR5I0LGseVdXRtASqGkeWtdDdqJf+/p04ThlVTdUBuFabDXvPoOsJurqGKBTOUC5Ph+VghyCwUNUkmpYI55AT+L5UF1UCcN0axeJFwEWSEszNnaBcngqfa2Ga5dAoo4LrVgkCD9+voaoJFCVBEOSBGiMjX+Xmm1+lWp0GPLZseY4DB362adTUr/eI33xzkKGh7+G6uxkY2EUs1hOqmcXDVuQAiqKSSq0NR8lmyOfP0dOzBRCkuObsuD1b/vuS9SIRlaEjVnV39xb6+kYwzUL9IjbX/mdnx+puI/F4NyBAe35+HOE1qtVNJKKIxbrCuT1Bili//jbi8T6SyQFMMxfO2wmVncHBvYCH5zkoisTw8EscPPgr0dkyNvYRDh26k23b/gaoLdu7aia1NKt2Lb2DN/H9Cr4v0foVLmaruJLy9bXvI19J5na1feXofZYajVrKVrD9ONf6HK80VsOYbo/VbCJW29tvlyGFxcVTonPoRLoaHn6yLqcZkba2bXtxwesXm0luv886bXajTHmpzLpzROCjIkl6KLqzMESJOHymCo2ecpSde8iyhu9ngBxi3rYZ4B1KpRni8T40rYtYLEMs1o9t1xC2qjL9/dsol7PoepJYLIOuJ+nrGwVgdvYoruugKAHxeJpaLYbjeFSrWQqFi+HokxizsqwKluXR3y8sH3W9C8cRLlGWVaWnZyPxeC/FohBJ0nWLWKwLz6uhKAk8z6RYdHHdElHPXIxZquh6Atf18P0KmpbAcWr4vo/vS1hWGUXpQlGSuK6D604xNvZQ+N29xJ49LyKqBUn27j3I5z//c1y48CHWrdvEn/zJXfWR0717T9dVyzKZIQqFC1Sr0+TzE6HsZx5N68Yw0mEmXESSJEyziKa1jtE2E4UTiQFUNUYqdX123Tc8IENjDjkSDDfNArVajiBw6yXqSJnL8yzy+fNkMkM0O3kI0fGTdHVtJJebaFH4EobVm7GsUsu8mq4nQwGSeSqVGdatu40NG+5AlmXK5TkKhYvs2/cahw49ycmTjxIZq58+/T5GRp7knXd+hCee+KsVE4hWLoAQAWdAKwAvxpZeSUrQCsaVSsMP9kpMJW6EzLL5eppmZ5LXUvHcc7/NiRMfY9u2b/HAA7/5bp/uknG11281mfNy4N/8eHtPfinxlOgztGevQ0MvLnreK/nMi9k9Nn//a9a8Ua+KrLxcHRElG4RJMbvvUKkQ9oLFrHI8Tr1sHQStojqqmsHzHIJAGMhIkkMQRJtkk0ZJ3MXzSlQqDrFYP7LsE4/3omlxkkkpZFZXSCS6se0K2ewZgkBoTiuKiiwbGIYWCnToKIqEqq7BtotMTb1DKtVHX982arUspllAlktcvjyHqsZxHAPTzCFJMrqeDhOQOOn0esrlSRynhqI4dHVtplyewTRzuG40pRH9v0J392ZisTTl8mVcV0GSZMrlaG5axvcdFKWGpnVz7Nh+Dh36HCdPfrz+3f3UT32aHTv+Glk2CAKT7du/xi23vExX1yYymVsYG7uVu+/O87GPrQU+hyTJ9PRsY3BwD5qWIJVaz9TUEWy7wPz8GOvX7yWR6EPT4mQym+jrG0FVY3VToXbxqOvdS/5bAciRv6XrbqBWy1EoXAgFQXT6+8XuUJCoTCqVeTQthqIYddD1fZdcbqIOukHgtTT2XddEkhTWrbuF+XlhbK0oKtPTx7h48TUsqwo4qGqSLVvuD/Wun+L11/dw9OiPMjh4nJMnH2sqjz6HqqpMTDywyvGL957t3ClMU4Bx1Eep1RYTSHjv4mrZwN/97m+H/UevheS1WDS8dQNmZm4DuO6gvJKINJhXEtci0+/Uk18uFqtetIP7oUOfXxEzejm7R9NsrYqsbHMjA2mi8rJoBwkZWtNs1XmPjtdZ2U4O/YW7cd0ykqTh+y6eF51AxAOREeVsORx5CqjVKszPn6S3dwTDSIdiGQLIi8XLdZAXxjKQyaynWp0LR4HOE4t10dPThWXN4fslSqUarmvieRa6LkYgZVmpS2iKcas0rmuRz18mHq/S17cdVRWjUpIkU63OUSpdxrJmw3OOoeuJELAVXNcOBUeyeF5EYrMBG1nOEAQ1HAfefvv9PPHEV4iSheYN3Y4dXw1Z6DUSiX6SyfXYtsktt7zO/v2HWLfuNnbs+AKKYjA/P46mxcnlzmIYad5550O88MJH2LTpWR59VPTVi8VLSJJET88WbLuCrqfqHKL6t7SIiNR7HX8rAFmWVTKZobqgR6Uyi22X6OraVC8n+74gCth2EUlSSCYHgIaAiJjzM9i4cTemWSAynhDGEuNYVoFqdZ58/gy+79PbO4KuxzDNAq5rEgQO2ewZHKfMn/7pBZ555qMcPtxwIPnQh/4zvt/Nli2vMDJykCDQGB5+kYMHf2WRvrBBI3NtlrBsleRbuuS9lJbulUdUeosW9tX33FYWKx3FaY/FgGSx1x079hivvSbANVJDW04G89Spj9Fw8Qk4c+ajNzQgv1fzzu2xWE9+uehUvcjnt9YX5iBQOXnykyuqLi1lQHF1UVjyr0Gw2L0RowHkPmDhujW6ujZimhVct4RhpLGsIp7nIO5/P3ydHCpziRK2adrMzb1DKrUeWVaRZZ2eno1UKrN1opLj2GFGKeZ+y2Uxiuk4NrZt4jg2kCAIalSredLpAQyjD8vK4rom6fRQXckrFhtgZuYItl1EUYyQiFZFlnUURSGRGAxFmhr2rrZtI0lxfN/BtkvUavNhzzsWjnRZ4ecq1tez8+ffF14fqX6dRJviYP3aCDKaFh5PZWDgJgwjRaUyz8zMSQYHd1GtzlGr5bGsAs8/v5bf+q1Ph2vyTzI8/N+57baNXLz4PXQ9FbpkiTZnJ8GPdgGq66HmdcMDcrugR3f3MJqWJB7vqStzVauzxGI9dHdvQdNSJJMDdb3riFUYBBCLpevHLZenyefP0t29BcPoCi3FNDKZIUyzFO5EZTQtgfDU9Jic/D5f/vJW/sN/+E2i/lBEMnDdFD/1U79PEHiYZj+l0kVGR7/Kffd9kVOnPsr27d9uW1ACWnWmY2haGscp1h+JSnHgcfDgP+G++77IQw81g4LLysebVhLClSYC+SgD8P2VOzE1/30lPeTlnrdScFnqfM6e/QANQo4A5cUyuUgnevv2bzE1dRsRKG/d+u2O77fYhuLdZFm3H7s5U3s3QlGW1ndericfxWLfUfOIGsC2bd9AliVOnXp0RdWlpYiTVx6dXCUaFayoV+x5nQwomsmVKuCEzOMpPK8akrlMZDkii0UbawNV1RAaz0ls28TzbExTxfOEIQQ4lMuzaJqCpsXDmV6DeLwPy8pjmll0XcO2bYLAZH7+WPhZUuHIZpShV4CARKIbXU+FhK0kudwYxeIksmyQTPYxOXk0BH6bRGKAIJgmkehFUXRsu4hlFRBg6hAEAdXqJYQDXRxVTWHbQm0LnAWqhM3R23uBT3ziX7N793O4LmhaGknycBzhRmcYSZJJMVHj+xbF4oVQ8/sSyeRaenqGeeedtfUesyx7nD17P553Cs8zUZQeZFkNe8ei6jo9fRSAwcE9qGqMcnmaS5dexzC6rlvGfMMDcvsssSAkFEmn15HJDNV3O9HcsabFUFWR2XqeSa1WwHFq5PPnkGWF3t6RcCxhHuHoopJOr+PSpe+HPYc76OkZRpIUgsBDUVQKhSwzM29x5MiDfOtbP0qzl7EgZqjs3j2GbZvk82eRZZUg0Bkb++E6c3pq6vY2O8V20wcHx4nKQCImJlqBpLMlY4AorUWKXB5Xrrwl3ifKjpfyQl5J2W81RKJOcS0AxjQbZdXoWt5zzxcXAEj7OUQbn2gzde+9v7ngucupX11LgFyKYR4E725WrGmLA/JiJfLV9LtbS84epdJGduz49qJGLFE0V4/Cs1n5m3aM5VpG4p6PxUTZOrom6fo+XwDr/HxAPB71kqMKlo3nSQirVPB9C9+vIsBKASQUBQwjTsTK1jQJSJBMdhOLZZieHsNxIuGQrrDPq4UJQxnf90gmB4nHuykUzpPPX6QhFGQhy8KIx7IK1Gp5dD2NrscplyfD3nGZQuE8nmdiGH14nkOhcDa0a4yHkx06tp3HsixsW4gO6Xo3fX3byOXOYJpVdN3Ati0qlQs0CG0aExMfbPmexRoqevR79/4l5849jK5n2LHjW0hSmXi8D9cN8LwqsVgv+fwZenq209W1kbVr9yL8m200LUNf3wg/9EMx/uIvlLp85v79U6iqQX//Lrq7N4fXXVz/6emjHDv2l8Tjvdh2mY0b76ZSmUXTUsTjfdetl3zDA3IzJb1cnqZWm6dazVGpzNbLCs1zx83MazFPViCfP0ehcB7DyLBmzU1MTx9HVTUUJYbrmsiySlfXeubnTzA3dwzPs4jHezCMLjZvvo+ZmWMcPnwvf/AHv0O0qEuSTxDI3Hzzy3z4w29w++1jTE/XsG2hBKMoKSYm7ltxD3ls7GMLStMN5SKRpUlSJ0tGBQHAGgKUl/SLWybE4hGLib5xZNIO760v8mpjqcU/InLdc88XmZ3dA0isX//Gil7/0EO/2VaRWFlEm5VrVUa+nrPFKxH7gKubhW78zn2CQGF6+hamp29vcUprv2/aiVwAkiQqSTfd9BdkMpfr99JKqzXL8zeimeLFjqExN+e2/K1ajUiRUsjOFpW3SFseJAyjG8sqo6o6ut6NkKEs4fsByWQXyeQgxeJlDKMPSZrDdX08bwZZjpNIdIXlXYl0epDe3m0hYSuOridxHJkgcAGNeLwXRYmFrOcKqtqPJGlUq3NkMkPh+SlIkoZhRGpiHpqWJJHoQdMS6HqKQuEStj2PKMvLYTZfRdfFyFYQyEC2acP0IqOjzzM8/AYHD6r171l8v2k0rcx3v/svkSSX55//SX7+52Hv3udR1RTJpIbneWQy6xkefhBdT6KqMdLpdVhWiXJ5lqmpp8jn7+BjH/sY//E/vsTTT5cZHn6Jvr6TnDt3O93dW8LfBySTa0ilBikWL6KqOoaRRtPiXLggSuXp9PqOlr7vVdzwgBz1hy9d+h7p9Do0LYlhuC3ELGiUtl3XZGrqLdasuQnHqYSELKhWc2haPBQXOYLjVFi/fn8olp6iViuSSKwhmVyHrgtB93x+AssqUqvlGR//RMuQ+saN43zsY/+Z0dFvIkk6s7MKpplFkjRkWcbzanU/5EjwYyW+u+0s0YaYvthRNh9DVfuQJCWcCXQQN0h0o195b9k0CVWEWstxntdQIrpWsdpSeHsslV23mwwASJLL+PgnWkhd0TksVy5fzbm9m6zy6y3DuZLnXxlAR7s+IVU7Pb2H3t6zHZ+5UOUOIlOX48d/og7O0b20snNYSftnqb8H6HqjatBaPZDRtG48T1TGVNUIXZpK2HYJVdWRZYl4PBX2fYUBheuWmZw8TBC4aFqGrq7hkMGsoqoKhtGNolQoFmcwjDKFwmWq1RkcpxbOF2dQlDiK4hGLddHVtTFcE+WQ7HoWzzPxPBdNi9WzbkGWSiNJAbqewbZLaJrO/LxwyGtU4VQ8z6ZanSUe78cwUrz11v289toP1yscBw/+Ez73uc+h6627elHt+w5PPfV/tyQuR4/uYPv2rxCPywSBjmGkSCT6SafXUS5PUatlGR/PsWbNKHNzx5maehuQ6OkZ5r77cgwMfJVLlw6Tz/dhWSX6+i5TLl9iy5YP1ME2lVrL4OA+MpkNKIqBLCstRODrFTcMIC9mCgGEzOrz5PMTdHcPE4/3oChGS1mhXJ5mbm6McnkO08yRy4mRANetYlk1Zmd/QKUyQzw+QK02F4JwjlRqlLm5E9Rq82FJRgBooXCecnkKzxPgf9NNR3jhhc/UQfnBB//fDA8/Rbls4roekqQRBAVAwvO0JtWh5e0Ul2KJPvTQby46n+y6JXS9FyHA3ixC0HnRqFYboxrLLVARGDeXq5vB+GrB5lr5+C517HbvY2hlc7aXrZvfu9P5XS8ZzOXO61rHtf5ul/tOF/NF7kTqirKuaLPb+roGCU+Q91ZrLBEgREAamfDK+BlpksleKhUTSTLrYOy6UCpBMimjKDESiR4sKxe206Rw9MknCGwkyaBWKxMEE0iSGop9gLBPVPA8G8PoCXu9Xfh+gVptHs9zGBi4CduuYdtVVLWMLBv4fhXHqYTZLriugywbOM5ZFCVAVWPIcoCmCbKWpiXxPBNNkzDNAkFQwvNMZDmOZeVx3Sq1Whax4a8BGooiBIokScZxqkhSkaNHH+RP/uS/036/XbjwMIoSa1nnLlz4KLt3vxCSX3+1/re5uWHGxh5j375X8P0quh5HlhVmZo5Tq83iuj5BYFKtzoVmFh7z86eZmjpOpXKJmZl3MM15hMNWjEuX3gBchofvBwRWpFKD9PeP4nmi359KrbshbBlvGEBuN39ojoGBUarVeXxfEAvS6XUt5hBRFl0onCceHwiZ1iqqqrNx491ks6eYnX0by8rh+zXWrr2VIHDxfZ/Tp5/GMDJ1TVjHcchm30TXe5iZOY6ixIjH+7n55pf4xV/8p5w+fTcbNz7L9u0voGmZ+tC+mDGEiKw1MXF/y4/PccQwbyfW9HIs0cXnk21se5qFi8bC0ls0qhEB7EqArxmMr2W2txqi1tUAUKN33Owg5C0Yz1mN0tTfxbhS68VrpQrW/vsfGfn6AlLX6dMP4ji0VDyikramVTl9+hEuX76LRkupc1VqeZOJiNshZo9XYkohyxJB4KOqNum0AGHfF+IgQ0PxMFP2MM1sWF42Q7DrBuLhHLAJ1DBNm3R6Ez092xGbe4tSKZoUsXAcH9eNiJ8+nmeSTg8iywrl8hSDg/sIAptc7jyuW8W2y5hmCQiw7SqJRA+KopJOD+L7onIoSVZo6yiUtuLxPqrVKhGnRFV1XHeeSENcUdL4vo3niSTANJ26ktjp03d33Fxt334YVVV49tkfryc1O3cewfd9Rkef4/HHf4TDhz/HiROf5OTJRzhx4qP84i/+U/bvf52enu309m5HVePUajPIMpRK2XCT04+ixKhWc0xPv0E83o+iqMTj3axbdwuua1MoXKRQuESlkmV6+iiOU6FYvMzAwE6y2bN0d28IGezXHw6v2xm0Z8SxWBeVyiyxWNeC56pqjI0b7+LSpTcZGBhF11MUi5fIZk/R27udTGYoJGcNIUkKmzffy/j4d+jt3UJf33b6+kaYmRkjCBySyfW4bpmBgd1cvnwYy8oTi/Wwfv0tVKtZZmaOE4v1UqlMUShcxPddkskBurs3c8str/DBD4rH83kZSTJIJvsplSaRZUHxj1R9NK3YRF5QGR5+aUFpeseOr9VN2JdniUqI3btHazm6HYwXL1U3l9Fae8KR8MGNF9d2nEcI4TeTuhplbTGfPDPTzmRfOhRFkJ6WyqivxWbmvczOr/S9hM/0BxgaWii8YpqCTd0J3Dr9/iMntOb55vY55ai/HN1TADt2PMng4NGOvefFWkOdw2Ns7BM88cTfLPt83y9SrbqIsnQPAwPdmOYMUAvBWiGR6AlBzml5Heh4XoCmGfXxIMEsLiFJAbYtwFIQtxxk2cO2q2haAk3rwjDSOE6VZHIAxzGZnHwDWY7hONWwahY5wIWfynOw7VodpINACn2HpdDRSUKWNaKxJt+XsawKkpTBMBIMDd2JbRe4cOE1BFFN+Cq7rk+lMsPWrQd55ZVfrH9Pu3Y9zZ13PsG+fceo1fL8g39Q4cyZ97Nx47Ps3v0Stp3C8yz27HlpAefm3LkHefDB8zhOBdsukMmIduL8/DgzM2+TzZ5E0xL4fg3fr+E4JvG4z/Dwg4DCrbd+hmz2LBcuvExPz3YmJw8zP38Cx7Go1WaYnn6beLybeLynPgZ7LT2QrySu2zu3Z8TNetSRbFkzaOdyE2EpeoLBwT3h3706uSuVGqRSmaVSmSGfv8DAwG6SyTXEYl2MjX0DyypiGCkgIB7vQ9dTbNp0T0jbDzCMLiYn38Y08+Tz51i7dh9DQwGua+M4JWy7jCQp4ZA54cC7IITpehpJ8vG8JK5rMTb2sbrTTKNc/TWeeurft+weT558rMXZaenSWuQqE6fZUnE1EfWzFo5ptD4Qkboi0H4vSUWrsRBcaoxmfPwD5PNbm663UBOSJBfXbUiPiUU+Yny2MtlXAkye18pA7pTVR9WIG8n5KYprVQpv7dcvFF5Zzvay/fc/OtpqKnHu3MIy9fDwiwvaPb29ZxbdUHVqDQ0PP1nfoLb/npYX9okIWh5gI0Q/ZAyD0D4xhqJEkwsGsiwA2PfFjLG47wTRS5K6iMaDXNcimz0LyASBgyTF0fU4mqZSKhWQZRnfl0il1mEYaWZnx9D1FKZZwDQLqKoKxAiCqIQvxhljsW4cx0KSgrpRRATYspzAMFKhuIdFZHgBDrLcja53MTi4g7Vrd3PmzPM02gMqqqrheQ6u67Jz59f53Oc+z4ULH+TWWy+wfv0f4PseQZDBcYrccsvrjI4+Hc4596KqOo7j4Pu1BZWS3bvH6O7ezOzsCS5d+h653ASWVcZ1hfZ3pTJLIrGGTGYjmcwmjh9/mEOHNrBv32kee0yiWs0iyzI33/xp5uZOcO7c8/h+QG/vCInEGvr6ttUnc2Znx+rr3fUUCLlugNxuGlEoXACEXGW0U2kG7Uh/uqdnmGLxErZdplrNoeupOrkrHu9hauowyaQYiYpK3aoaI5kcYP36O9i8+V5su1LXr3acGtnsaUqlOSwrz8WLryLLOvn8afr7R0MB9yySBOn0WubmTgCQTA6EpRIxnC/m41zGxj7Giy/+Vn2Rby5XDw9/l4MHf5Vm95nV9bk8WsF45TPIEcgKFmSktbt4vJvKXO3gFM3+rvS1S0XnWcfWMmZUro7FYGQkKmtHC0yDyR4ZIaxGbnO1cS0qAKsB1SstT3d6/VISmpcutfbo2/++3G8+UteC1jL1Pfd8kSBozX5XKgqynGRnextH9DaXOnYQmkNIoQmEj6bFw/VAiBEFgYbjWNi2mNeFHoS7WpQpewSBjOtWERtuFVkWYhqC9RwQi2kkEuupVrMIn2WZWCyGpsUBH9e18H0x9SFJCr6vIUnRuiCIH5JkhG06G0WJk0x2hWuXeA9VlRGjl3boGdzox3teBddVyOcvksudxTRNQEfX16DrCXTdwPPcMHGpsGPHX7F//2ts2nQf588buK6N52mATLk8jSTJKIqG41RCX+USUVKwY8fXAIk77vgLNm8+Rrl8O+XyFLZtMTNzAkVRGRzcQyzWgyRpDAyM0t09zPHjj/Av/sVDyLLHV75yN4ODb/PhDxeZnT2GaZaZn38H0ywjKhAWg4M3k0oJ8ahSaZJ4vJdkcs3/utKZzeNKs7NjTE39AEmSQ5afOK12+8TBwT2Uy9Nks+PkcqfxfR/H6a+PO9VqOdLpIZLJNQwMjIZ95QtIkszmze9nzZrdqGoM265Qrc4zPf0WhcIFCoWz1GrzaFqC3t5tuG6NdHoDmcxGisVLzMy8ha5nkGUVx6nhug7JZD+GkeGNN27mnXf2sWHD04BVF/Jo7WN9F9AYHf1ak0+riKtTForM0VfGqG6W+xOOMtdPEnM1WfdqzOXbs6Dt279Bb+8ZJKmK6yYWODwNDz/JPfd8MVTyEt9b9H2MjXX2VL6SuNYktk6vuVp50auJdgnN9t/0cn9fLNqB3HUTPPror9X/vhpRkMUkOxebpR4d/TaPP/6J8Lf3fMdjJ5PrAOjt3UahcBZQ0bQ4rlvBshxUVQ45LjYCXBVcVw3doKBRGq4BOrKso6pJgkBCUXrQdZ1UapAg8EgkBrDtclhSVrCsMuXyDLquhpUaM/SH9/D9KrHYAEFgUauVkSQHy/KAEq4rSrySBKoqSsa2LUanFuojgDDTcbGsPJblhAAaoCgSuq7heTVkWQ2FQKp4XkChMMnExKvIMsTjvcRiGSqVC2HvGbq6hkmn+yiX56lUFN5++wM88cSf1b/ru+76SwqF85RKkyiKGgqgJEMyHCQS/RhGmr6+XSQSfRw4kKjPH8uyz9GjO/nUpy4gSRK53GnOnXsF8OjuHgYcdN2gVsui6xn6+0dQFOPvSV1R9PWNhDKWdr1nG4Fwe/kgUutS1RiSpDA4uAdZVikWL1GrzZNMrqk/Nj19lNOnn8U0i6xZs4dNm7pCQD9Fd/cWBgdvRvRODGq1STZteoBC4Syzs8cBKZy3K9PbO4ppZgEQw+jCQeV737udP/iD/2/4I/q5cHcXCXl4DA7+gAcf/CKjo99B9H9dHCfVwvzdubOzyfrKIypj15Z8VrQ4B0FDFjMIbgyd6qVidX2/9plW4Zm7XPn5gQd+k/XrhfnAtm2NRb0d3NuzvmsVN2IpeyXRvAHYu/dJNK0VGJs/1/btywNn88YrAsuV+Fe3l7uX2sC1S3ZCY95+oQCOw+jo1xkd/XrHz6/rvVhWmXR6LYXCOUDDsvL4voWqJvA8B+G/20W5PAVYOI6NpqVw3ajSJdEoX5v4vornWSQS/cTjXcTjfVQqU5hmDt8XUyC+H+B5NcrlaYKgSq0WR5J0JMlFuFG5eJ4XCnykse0qQRBDVR1cVwckfD+yk4yHJfSo16zTqLp54eMJZFlUj1Q1wLZFNu37YiSqWs2jaSmCoIIsi7Xo2LGHuXDhEbZv/x779h1A08T1EGNfMtXqLJaVDUU4urh8+SMt99qZM/ewfftf43kyQvMhhuMUCQKJixdfY2DgJtLpDdh2AdPM8r73beOv/7ohCnLTTe/guipBEIT/c4jFuuqkr+npEySTfUCAaRbrmHG94/qfAYK0tWXLA0xPH6VWmyedXrfoxRE7sVgdkBd7XiQQ4jhVyuWLaJpBLjeBYaSpVObqEptBEJBIZLCsHKXSOXK5M5RKlygWL3Lo0F2cPPkBbrllgjvuOIzjmGQy6ymVZggCn5Mnb6fh1elSqQwSMRNBCeUyn6K7ewuHD9/NiRP7FvTBbr31S0A8vJECoNjx8ywdS4NxFM1ZQDMw38ixnHHAcnHp0p1MTHQmGkXRzLJuPnZ7iXNubhunTj22JCi/2yVuWF6kZTm/5HeLE7AcD2Kpv3faeA0PP9lRKzv6vkZGGt9X8zhUpI538GBrVaP9c0etk2icbzXXRZbT4abapVSaQVUlbLtMMrmWeLyXcnkmJGMZ1GrzRHKanmej6zEggSCAirWiweOoIkkxgsAmCKhnnyBh2/MhqPnYtoss6yG7W0FVkzhOEccphBwRG9vWkSQxNhUEJp4nk0iswbbdUMKziu/PI5KSZOhf7IWeynFKpcuAjapqyLKBaVbD6qUcfhaTcnmOQ4fu4MyZ97F9+5uMjj7JsWMf4s///AkkyeXll3+OT3/6p7j11oMAKIqG2LgUAAfbrrBx43727j3Jiy+q9fV0y5aXw3vewTDWIkrzKo5TwnVtstmzSJLC/PxJJClgdFTht3+7yNGjO7j99inuvjvH+Pgsk5OHSCYH6e/fxcDATWzb9hDnzh0gk1mP79sEQRCKTc3/vblEc8iySjI5EH5RS0ekwhUEbt0golSaDGeGBREMQFFURkY+RD5/Bl3vpadnmMhaUfSNJymVpuju3oZtVxkffwrfD7DtGm+9dT//9b/+O2TZ5bnnVH71V3+Lu+46Siy2KWRhT3PTTcd47rmfrP+IUqn5pt6xF/aOA44ceZA//uPfXzCu0cgU1JARGREwOqFkMxO6k8Rfp8cWhu+vzhHoekc7KGaz2xgbe2xFM93g1RfnZqJRMwADi/r5RiXOQ4c+z8mTn+T06UdbREXa+6nt3sBXWuJerifcLJV5JWXq9tdeK8LZ1RxjMcIVtGplt1/jxx//OEAbb8CrH6d53rzTZqT536tpjQjpS0F60vUuqtUSAJKkADKmmUdUxKJ+bHRveuEaZxIZT4hlOLp/VUyzhmk6mGY+1FzQcV07tDuMiGB+WObWCAIZXTewrIAgiMhYwhZRJBz9FIuXkWUfTUsBVSzLChnSDrKs0d+/E1nWqVSmUFUNSZJIpfoxzQKZzBCKopHNng39j8W5ep7J22/fy5/92X8PN0Aqn/70Zzl79s627/JeHnlkjmo1G7K/A6rVPLY9z9GjD/H00x/jjjum+Jf/8vc4dmw3w8MvMDJynFIpRhAoKIqGaVpIkk9//yj5/Lmwn34CRRHlvXz+BLfd5vKjP5ognV5HPl/BsopUKrOYZjG8Fi5BELBr1w/X7XslSa1XZG+EuGEAGRoOG8tdHFlW6esbYX5+HM+zOHPmefL5C2Qy60mlBuuvF7N7kE4P4fse5869QizWRTq9jsuXj1Aq/QDHqWGaOaam3qZQOA/IJJODHD++G0lqZL9Hjoxw880H6O3t54UX1nPq1KfZufMQ/+gf/TPefnsnu3a9hec5nDjxaFufzOWdd3a2/EAdJ8FHPvJrNMQHorKVYC02dKmbw6cB1p2Ad2lAbs8GolhtuXq1CkxXI6kIDVA8fPjznDjxSU6derSFmd4e7QAe9fGjxRlaAXhk5Gst3037Aj48/CTj4yvz/F2NN/By0QncOm2kribjbX7tlZC9rmWpfaXViE7kMMFSbtVIbi5xd4p28F1ta0T0WkUmKWaIxWa5VitQLmdxXQfQURShyCV6xaCqYi5ZgHmNiAGtaQZBIIVZsRiPsm0ZxzFR1RSxWAZd95GkeOiLXEXc7yZiPKoWErQ8IIGuCyJrrZbHtiuoqhaaQeQQGg2xcH108H2PUmkyZIaLjYCupwEFWTZw3RqJRDfCcKehlR8EFU6c2N/yfZw7dx/Dw89w8OAvN7Glx+np2czw8AcoFC5y6dJBVFXjjTce4Ykn/gRZdnnpJZV//s9/l0996t8RBA6VioaiGGGCNYtpllAUPSydKyiKiqLE6Opaj2WVyGbPUqlk2bDhfaTT60Ktin5eemkz3//+EDfddJSenrMUixcxzQI9PaLteSP0jZvjxjkTaDGJWG4erDEmVUTX0xhGKvwRNY4FUKnMhKVgmJ5+G8sqkU6LckW1Ksy5fd9F12Nh9ujj+w579pzg5ZebRyxewjTzPPdcP7/3e19EklyeeeZH+dmf/TkeeuhXAEgk1vP4459kYuL+lj7Z8PDzLUo0Aqg1RL9GyNiJEG4u4Sdg4WxwsMTfPAxjE5Z1gc4Z9nuvwNQ8OrWS5y8Wo6NPrrh03UzckaRq6IEsXqeqVQ4ciBjw4jhi56wuuYCv1PP3SryB22OpbNUwbpx+87U+j6WqEUC9otF+jYeGXkTTWpnW69e/Tjo9yZ49X+q4IeoEvu2/r8OHl/di1vUE6fRaisVpHMcNBTRKofqTi6p2EYv1EQQutl3GcSxct4KqphD3rwYID+IgEAphihIL+6wBqhrHdWs4zhxB4IZgLocqWzFMU5jRuG4xZGlHa4ePpmWQZS2svAUhgLuY5jSCeNYbjjiJTX6kzR8ELo5TQ5YNMpl+qlUPkKhU5sLsv3ndMdi+/U0OHmzcPxs2PMvevS8C4h7cuvV1brvtLIXCGuJx0RcXrUKP+flP16uLsuzx+uvd9PcfJ5HoIQgCFMXAtl0sKwc4HDv2US5ceIStW1/lllteQZZlEol+ggBmZ9+hWp3h9Omn2bDhDrq7N/Otb8X4rd96EFl2efLJh0il/pKurtMoSoyZmbfYtetHbigwhhsMkIE66SoS/Fgsmo0kNm68m6Gh/eRyE3ieyeTkD5BlNfTVLOD7Pt3dm1mz5iYuXz5MsXiRRGIAw0iTSm1AURQ8L0DXE/i+TG/vCHfd9Tbl8k9x+vT72Lz5ZUZHX8I0kxw7trvlxj19+l42b/5DAKrV04yOnmZ09Gst59rO7gR46qn/m+Hhlxkd/TbC6aU7tERr3FSLR6e/eVjWJZrtE9/NiGQ1212HmjPua2lI0UnNrFP2HWW1UbkzImuparWFSR2BMkjcc88XFzCwm2Olnr9X4g28Wn3slRzvWoHlyk0ZVnas5WJ0dGE14siRzzM+/smWEnWna9xcRbl8eT+gsGbN0ZbvIDqHzuXx6PclfhcnTizvxWzbBebnq4iys4IQ+agR3cOum8e2ZSRJDkFaALVQvYpCx7Jq6LpCEDhoWgrbVkPv4TWUShcIAh/XNRESuXoInhqqmglVuyKgFOYQYvTKp1bLEgTguj5i7Cnimrg4Tj6cjY6hqgkUJfIzLiJK2i75PASBjaJYqGoaVVVxmozkZDnJrl1f59Of/inOnbufrVtfZWTkOziOzejoNxgdfZpYrBdJ2oLvO8iyysDAXhynSnf3Fj75ySG++U21TsQaGXkDxynh+11YVokgqIXkt8i68a+QJJdXXvkFurt/g1tvfZ1aLcerr+7g2LEfZtu219i5E6an30JVYxw40EVkxyhJLm+80c2jj5axrBqqmqBWy9VdoG6UuCEAuVkARMTyK3kkdWaaORKJAVzXDJmILrZdwraLrFlzM7qeIZebIB7vYe3afQSBxOXLb5BMrqFWm0OSZCyryIEDGzly5APs2PEm8fgxbDvPjh2vsH3718JSSZp0epDt29/g+ed/smk3/jcr+oyjo99ZpDT2SUZHv4PnCRsxx8kjMtwEqxcAWb6HfC1iMcUvUbF4d0hDi42sRLEYCEX9x2ef/Z2WHmMmc5ZCYWRBXxhaSV7RY8t5/kbgtVJv4HczVtpXXsn3dKXf5VKvWwzkm60yG9+VtAA8H3zw1xZc46iKsrxdaefNXbORS9SDXa4aU6lYBIFQ0UomhTBGc3VKVdN4no+qyvh+gGEMYFnTtN6nNuBi2y7gUS5HoC1RqUyHZC05VN8qI9YEGV3PhAIZHrFYL7FYmmp1DjGjnMR1A2q1HO1SoA27xwBJkjGMNJKkoaoatVoJ4dQkzstx5gAZRUmiKBKq2k2t1pDqVRQFVY2zZ88z7N9/CFlOUK0msSyhOCZJKpoWw/NMXFfGtivkcidJJPpIJnt56KE5/tW/+iMOHuzi/e93GBx8k1xOIZsdx/McxsYeZWLiPoaHn+XQoS8QTU5Iks/Xv/4zyLJKPn+OP/7j/x+y7PLKKz/P9u1/zn337aZSmeXOOy1+7/ca4kB33jmLaRbYuPGe0EO6p27fe6PEDXEm7apdzX3kdonNyIYRIBbrIpc7S6FwCV1PYtsluruH6esbqYNwrZZFURTi8V4SiT5SqQH6+0epVmeo1eYwjB5eemmY3/u9z4a7r59HVX+R3bsPYBi9gB+ODYCup7j99u/xmc98hvHxuxgefmYVjF9xY7Tvzs+ff5g9e17EdX0cp0DjZm32NNY6PPbeR7uC10qev5oMazl3pU4jK+3RCUxh4UI/MHCMYnG43nd8+eX/o/7cdmIW8K4zp5f6TEvFtQDVK3G1WioTXykYR/9ufn57lUHTYHx8aV/kKFZmV7r47LLjJJs2AhABQKf3jIxaoo2psFmMRhAtIIYkJQgCB8sqI+aG52gF40gOt7niFSlogVAV7CKdHgj1rJ3wb3Ecp4IQGAnwPBfPc4nH1+B5Jr7vhWQyk1YiaHShxcZBkoIwO5ao1XI4jkMQuMhydzj764Xz00KRLFqjRehomoGmpVAUlWp1lkjPX9dTIWFKlNZd18X3S1y48AqqmiAW68Z1LUyzxO7dB9i48SJdXVvw/XWUShfxPJ1jxx7iiSf+MkxcfqXl2geBzLlzW/iP//G32LnzW3Wujyy7HD68gaNH/5r+/h3cfXecL37x+7z2WpK77y7z6U+vx3X76O/fSaFwEdPM1fvIN0rcEIDcLgDSfIHaS9jV6jwzM8coFi8yOHgzc3PvkM+fo69vlLVrb62rcymKirBozKGqCZLJAUyzgKKI4wt3E4dEYpB33tnd1MtwOXPmPnbvfoFYLI1tl5AkqFbnmJz8AbqeZmTkECMjf35Fn7V9d75t25t0dW1hfv4kzaVmQTp5P8PDBxgdfTIkhzQP7hvhfwdEknvXOjqBaTsJbDkQWWmGtZgW9GoytE4s58gsYu/eJ5mZ+SKnTn2ULVu+zfr1b4QLvSABTU/fwl/91dcXkLzaS6ZXIw7SKa5WVrP9Gq0WXK/munc672tRHWmuMsRiohx9+rQA6PbKSPN7LmdX2hydRrDa782dO7/Orbd+qeOmOxoblGXh6iRKuRq63oVt5xGqV3M0yJjNpMsEut6NrhvEYgMUi6dDJS+h1BWtA4qiE4/3kM9PhtmxBxghkaz53vex7RKKIod9ajPkzUSa1Fb4vtGXJQHxkCAYoCg6llUmCAJ0PUks1o1wS8oDAZblo6pd9UxSlpP4vkK1Oo2uO3ieGxLVRL9Z11Ok02tDv3mbQuE0tm2iqnE0TaevbweZzAZsu4okyWhagnL5EolEL+vX38rk5NtMTHywaXMUbSpkGm52grgnJIwb41JDQ9/h4sXD1GqzJBID3HHHPPv3K2zceBe2XaZUmgIgmexf4Bh4I8QNAcidBEAAXNdkevoI+fxF0un1lMvTxGJdCDsyh2p1no0b34empclk1iPLKq5rMjHxMkHg4zgWllXANHPMzo6xefO9JBIDxGKiVNHVtYFXXhkhm22Ase+r3HLLOSRJxfcdVDWJLOtUq7mQORntOiPf4YjZSPhYHDFL3Hl8qX13vm3bi9RqXTRuFjhx4id44oknwt3hP+ZnfuYL3HLLQQqFCwSBGKxvgDFcORgvbiqxUkLW1eperwaIlnpuLAaXLi0U8ogAuWGH6TI1dTv33PNFRka+xuzsbgqFLUQ3eDvJq71k2s7Cbn7/xYB1OcC9Vj3f1YLrtXjfa9meWKyi0swJWO59l7IrXSoi1vXCkcTO0ax41xAVyYQMaRPBC0kSBBqy7KEoaSxrhoiZrWkywqIxh6YlsO0KkcwlJJAkYR0YTZI0QDVA0wRT27YNQA2zYYlGJS3SQpCJxVI4jhael+g1G0YfipIiCCyCwAu9z4XlYyYzhG1XsO1S06e1cd0iiUQftl0JJYI/2ER6+yaSZKBpmdBbWbQPZVmIkFiWicjkzbAfXqNUukw+f55c7gyVyiyWZRGPx5AkDcsqoWmFFta8uOaNezJaq9///ie5//5vc/78B9izZ5xbbnkLWdaJxdYgyxq2XSGV2kA2exrPc3HdKqpqoKoGGzfuvqHK1XCDAHKn8H2XCxcOMj19DNc1yWYnCAIP266wdeuDyLKCYaSJxbq56aZPMj19lFLpMhcuHKRQmEBRdDZsuB1ZVpicPMLY2NdQVYNEoh/Ps6jVBGP6538+RaT7umfPy+zf/xfs3HmEfD6H5wnmZDo9hCg5FfA8C0WJAQqeF+1aRRhGH93dW5iZ+QGgEASipNQejd25hiSlwrnpCBhjXL780RYQGB+/i507v0MQRDfJtXJmWvw4qyFkXanS19WCcfuivJSNZft8siB4NWwZo7/t2/cl9u37Ur1kCq0l08WY044jXJ+uJRFqpbGS8aSr2Si9m6Ab/c5WMwO8XCxv1NIa7frny488QSLR+jmSSYjFtLB/CmJkKE4slsKy7DpTWGTOAa5rYRgpXNdAliXi8X5qtRkMI4Usx/G8aljpU2h4nQPYVKt5ZDkCb5OxsY+F1+5Fbr75IJoWQ3guO1hWAUWRUVWjPscsSRq6nsCyxByuaZYwjF7Wrt1DqTRFuZwNzzX64j0sq4ZhOEiSxIkTn2hKGAQPBmBi4iGGh19k165ncJzZsNzthRl1LVRirDEzM46qxkNGdwVN06nVstRqYqTqxImPc+DAvyQy53nssT9j06YjHD++hz17TrJ+/e384AebWLv262za9A3S6fXcd98pNC1NpZJHUeJ4XolYbD1r1uwNk7mpkFjWTTK5BsNIMT8/zsDA6A0FyjfOmbRFtTqPYaQZHLyZRKKPeLyHEyeexDTzJJP9bN78fqrV+bpJRLk8HXomB9h2hU2bbkHTkmzefC8XLhwklzvL0aNfYdu2RzDNAoXCWf7bf/sxAIRROBQK/ezd+wyWlQpVdiQcpxoaX7hhKUrMAY+N/XBYUm5o3FrWFNmsUOdRFBXHCRA72yijbQ3BfLRoVdqyGBr6FkHw002jBN/GsmZpuMtEO+FOK3FUGpNplHg6kb1WroH9tyWW0jVuB2sRAozXrTvIhg2vtrB2m8vSK2FOR65PUab8dymuNVGvmREfBELdbCknqHc7rlQNbiF5LipRA7h4XoVSyUIQsaLHhV2hpmmoqgBsVU2Tz08gNvkBsgy2baJpOpIUJx7vp1yeA6INeRXf1wCLsbFP8sQTX61fO13/GXbtehrPE/3mIHBx3Ri6roefsYxpToauTxK2XcTzXJLJbmq1HMXieXxfyATLsoLvRwmFjWUVkOUU588/3DYi9rOcOPGJ8Bx+mccf/wlGR79KVLnzfZOTJ3+YM2fuDjdc32F+/hSZzEa6uoaBAN+XqFankSSV8fGGsIgse8jyWh577DB33vk/WLv2Vnp75/jYx6ocO/YD8vk+Uqn1xGJdKEqSeHyANWt2AipdXeuAgMHBPeh6Ct+3SaXWMTAwyvz8eNjSvDEUuqK4YQE58kfesuUBZFmlXJ5m+/aPUihcZN26W+oKXbOzk8zMHGdu7gTJ5CCuW0HXk1iWKLEIvVfBCHScMuPj3wJU5uffplb7YMt7nju3h7Nnf4p9+16lVLqMYWRIJPp4++0HGRu7lYGBrzM6+ufhjvor4Q/wV1sWEMfJIUkpPM9DAK3Qhx0b+/CCDECUn9uBOmDHji/z+OM1JiY+yPDwd5tGo3rQtASuG40DdIoIfHWi/pI4j/ZseGkwvh6ZXqdYLRgslh01C4xcvHgXlcq6lr9Hm7JOsRrmdKfzXa7U3uk574Vd45W8x0o+y2rjyJFmBu1CQHy3f4tLVVY6h4TozbZfjNZ7SoBZ872XCAUtdGTZIAgEIzyXO4NlZRH93BhBINyQPE8ilUrhujUMI4FlVcPjxIh81ycm7m+rpt3J1q1/TkOb2kewtj2EPK84QqO6F0OWhZ9xPn8W2zaJNv2ybIRqYKJnqygJwGJ4+CVefvkf1N9XkNuaxUHuZ3T0y01yplUOHPiX9Rbc449/kltv/T6ZzDr6+3cDPrncOLKcRJI8RkZe45VXfr5elr777jKOU8UwUiQSa0OATWCaZarVWfr6dnL8+BNkMl309u5E1xNUKjNIkkxX16ZQBbIPSVLp6Rlmfn6cnp5hbLvy9z3kTtHOpIZm4Y8Cvu+SzY7T2zvCli0PcOnSm5w//wqJxBpkWSGXO4ttF+np2Up390aKxcv09++kWp3n4sU3mZk5QjzeiyxruK6HaU7h+xL33/8djhy5j2brvcOHN7Bp02lkWaKrawPHj3+U3/3d/z38cTzO44+bC4y02xeQIKiFfQ8fUBgbe2QRo/NIx3ZhBiuA5Zvh34WtGvgkEt0Ui0WW7xsraJqK4zR6R6uNGynTW25Rjm7+Zs3qTud/4sQnaVxvUbKenLybqak7VkTaWozF3RyrIUUt9nneq1iNdeO7URo/deoxxsc/Uf/3YoD4bl6flTlGid6luO8COlen2iPiewhSl6qK8rRhdGNZOTwvCCtpZaKNuZhF1oAkiUQXQSBsC6vVKRq/W4VIb2DhZuK7oYOTE44wVRAymxHXRSiG6Xo/tp0jHu8mHu/Bccp4noSuJ/A8CUXRse3m6p2CbVdw3RIjI3/K449XOX/+A2za9Azgc/Jko62zY8f3FrQBmsV4JibuZ9++V/E8m1LpPIXCBTxPVPJkGXbs+Caf+cynuXjxo+zfP8nu3RPMzh4lFuvHtgtcvnyIIAgolyeJxbopFi/ieQ6+76MoaijCUgnVyzxqtRzJ5ACp1CCzs2Nks6cAGBzcU5/aWU6I6r2K638GtI49xWJd9R0MUM9yIcB1Tc6e/S4XLhykWLyAqiaQJKjVZlCUBLKsoaoGvb1b6v2TsbG/ZmbmKKoap6dnU+iU4nD8+Ic4d+5uPvShCzz99Eai+cWNG1/EdS1isW6Ghu7kK1+5qU6rFz+m9y+xo47AVULslhNIksqFCx9pA/APMjr6jfD5RthLsvG8bNuVEVKaoidi4nmVULQ+2v02hxweLwJqF8fxwvPRud4jU52iUz9xKY3txRbl1pu/AartANHeR+7uPks+P4Io7QmxkCNHPs+5c8KkYHZ2LwD79v1RXQN7pVrVV8ueXi5Wc+yrBbN3EwybpTCvjfvZlcVyfWdJEkAm5ClXGh7iPk2h6wkcp4KipAEV13WRZQVFMRD3rViKbbsSjh5pVCrCHlCQtpo31A3CVetm4hV27Hga141aVs3/79M8kywERVxMU4w7GUas3k8GH1mOhecUET+j9/fD9/0bRkf/qn4ejXN4lZGR5/nmN3+z5V5rljMdHn4R3w8oFM7XyWSxWArXNSmXZwCPkZG/Yc+eF8lk1nH+vI3r2phmBVVNUCxeRFEM5uffYe3afaxZs5dNm97PmjV7qNVm0bQMhpFCVWNks2fp7d1S163o6RmmWp2r40uz+5+qxq47MN8QgNw89tS+g4ker9Vy1Go5stlxXLdKPN5Hb+8WLlz4HpZVIh7XQ3/LGK7r0Ns7zKVLb2LbJTKZjeFsnEStNsPBgzfzh3/4L+sMvgcfPAG8xvDwAd73vgvk8zKgc+7cq2zebBMEj7X8mJpl/lpFTCI0cev/NowYo6NHeOWVZhnOA0S7bEXpwTDSJJM62axJVIqKXi/k84RogNC3nadzTziGYaTCmccqrSxswbi8dmSwlcVKyozLaSivBAwWznZ31pBu30itWXOMfF4wrCNQFiNODWYnUBcOaQWPxuzy1epVd8pSl2JtX8n73EjVjihisYXz4UEgLWkecn1CD5nQpeWfuiB8oFQX/rCsqbrTkaKkKZVmQn/hKBw8T8JxXMDBskqoanRve4i1xaGxdLtNm4lIkjPyVjYIAi3sxRr4fpmGMUUVkAiCKq5rAhk0LUFU6hYKXsIxSlQDAly3WSehsQa1E/KOHXuMbHZry7SCYK+nwvXzKd5++4c4f/5h7rxzjv37vxfOPEefTQrfr0oudy4cUTVJJtfgeQ6OU6RWy2JZFfL5syST61izZg9B4DI+/izg0ds7ShD4rFu3D8sqEYt1AaLiKmQ7x+nrG6mTgWdmxli//haA69pTviEAuXnsqa9vpOX/fd9tov5Dd/cmXFfYh01OHiGXO0UQCNZiLneKYvE8QeBhGElc1w+H9mcplSZxXRPXdRkb+0zTohvw4os7+d/+t2/woQ8NUSoFOE6JXO4S+fwJ1q59hfvu6+fUqY+GdoqNheLkSTGfevLkJ9ix42vcdtsfMTr6JJKUJAhcNC2OZZns2PF1fuZnbE6fvpvh4ZfZufPZ0Jc0QJIkXLdKsXiZBrPRYmzsh8If+avs2vUUoNMQj2+5euH/zNCnNDKoECUt8fzoNYs5SV37WK3udXOsFjyGhl4gCDprSDe/bycJ05MnP0FUHVm//nUmJ28PATdqYwD4nD//YB08oufPzDRml6Ms+kpiqXGlxWaM30tN6+ZzuZoecqeNViQEEs17L2ceci1i9YxuB9vOcnVKeFGWGiA2zDqO4yAIX833pI/v+0hSut5j1vUY8fiaOjB5noUsxzHNHAJ8o6qcT2NDb+P7avjvSOAjIoPKYT9YCi0IPRRFRdf7ESxsBdcth6NY0Qx18+YeorWkXXmwMQcukpIdO77RNMudQNfTHDv24zzxxP9AklxefVXll3/5X7F163h4jjJi3ZJDZ6kAx8kTi/XT07MplBO9jKalsKwi8/PnqdWKWFaetWtvE2cmqdRqcySTa6lU5ujq2ohpFkgkVEqlSXK5s/i+R7k8w/nzr1AuT6JpKRKJftav338V3/HVxw0ByM2hqrF6ZgyinB0EXpgFd5NIDKDrl5DlDK5bxTDSZDIbUVWdanWOWi0fflFn0DSDWm2OajVPEHhoWgpN09i06UVefvkf0qzoc+jQEHfddZy5uXcoFKY5evR+Jibe3+KvOjV1O0NDhxgd/Wpb+RNOnnysaSH5bmhhFkOSSniezS23HOT97x+nUslSKkmoahrDSIaWkVGpWbi5jI//KE888actYwWC2KUgdr4xfD/q78Tqrw2CMtFXKkTqHdoz7sYuOvr34l7K0QLq+2LMY6nnwLU1r1gsa4yivWfciQnd3u+NxagvwNGC3A7QYnFpzZBBrh/3U5/6OC+//H8wM3NL/Tnj448tkN+8FjreV6rctRjAd3rucq9rfv3VZO2dNmgTE48xPi6+n+7us1fEdF5trN7VCUBFqG5F1rDNYhtRRNapnapQMuIelZseE5KZIjTEfRvZMfoEQQlJSqDrSTxPwvdNwEPTxGxv5AglXheVxpvv9SizbbC+hWjHGiTJw/PEZj0IJFRVD/+7jKomwpEqFduuoGkJFEXGdT1cN9d0fAHM7dWpU6daRzZ7es40XV8Jw0hy6dKHW55z/Pgoe/f2EI93MTt7Es/LLbi+qmqg673oujARSqfXE4/3kM2ewXUtpqeP4Hk+6fQGTLPI0NA9KIpKd/fGugBItTpPrZbD8zw8z0OSxEYmk9mIYaRYv/7W695HvuEAuT0iE4lYrLsunZnJDDE7+w4XLnyPIPDR9QyJRC/J5HqCwGduboxyWZAgDh16P2+9tZWdOw/xvveNUavl2bHjr7nvvv+LAwf+eX3x3bjxGbLZk1SrOd555wM88cSftfS2ImLCxMT9jI5+k+Hh74YyfdEsq9y0kLwYjk354eiA0LzVdQPopVicCDNjE9et4nkSqppBliUUJcb4+F1ti9P9dYKXJMURN34EpFVkORGakgdEN7nnFRBg3bp4GEYSTUuEm5Vy6BjTvrgIsY/IQCLy312OPdzpOe1614tFp2N1ek4stnjPuDlDXazf2/x4ZGAvrDBFRKpQxeIQJ078BM2zytAoT//VX32d5u8evLoQSTTOcz2cmZxVtDjbv6+VELyu1Wdq/37uueeLLSXO5ZnOIjrZKC6V/V7ZiJOCkIUUjkyN3mrzZjZSkIKFI4XNClMaDXtVQfrUtC5SqXUEgUutNodl5QEZWVaxrAqCJV0knV6P6zp4XjVU9goQ93fzMaPoZOHqhr1jJwR4AA3fjyPLWlgmt0IimYMsK0iSjCRpi/bO29tA27d/m6mp2zt8jwaaphMEHjt3HuLFFz9bf87mzS+RTq+jp2eEajVPsZhrYmhXcJwUO3e+TVfXEQYH99LdvRnXtchkNuC6Nb73vVs5cmQbO3Yc4s47j6DrcSYmLHbv/nEkSaGvb6Qux5xMDmBZBVy3gqYlGRzcy8DADorFKYLAo1i8dF0tGW94QI4uTD5/lu7uLQBYVoWZmWPk86dJJPrQtATxeC/VapZc7lxopG0zPv5Jfv/3/ylCo1olmfwX3HTTs0iSwsMPf5Fdu6Y5c+YeNm58ll27nqZcTiPLMDHxoZZeYXOPUdPKRH2bxx//YQ4f/umQuRvp3r6Eosh4noSmafi+AHzbrlCr1VBVlXR6A44jhuwtax6QcF0HWY5h2zk2b36a1177paYf9SvIcioc3aqFs8uNEIpiPaEFW/M4lI+mdeE4jXKbbVdJpfool/Phjb8QjJtDkoSH8lJkq+Vef61jJT3jxbyJF3u8uaw9PNxqRtH+HlGm/Oqr/4LJybtpSPlVV6zv/G6BtXeFVdX3evPQ/j24boJPferjXLq0coWt9mz3ppv+guPHfwJJ8hbNflc/4gQi02y+QJVlnr8QCEXEwl5ulN2K6QfPc/H9CobRG5aJbUQv2UPcnw6eB4XCFIaRrjOSoxAb8ioN6c2IXBr1YxOI7FkL2dbRPS/GmzQtjqIYSJKMbbshiUycmwB+aGThUYiSdac20I4dXwMCbrvtSy3ZccTUXrfuv/L445Ncvvwh9uw5xcjId6lU1lGrHcS2K4yN/RhPPPHlpkqVx8GDCqr6Szz88CyZzCZUVbQjjx37MP/+3/8Csuzy/POfBv4Zt99+EMsqcuTInzI6+nG6ujaSSKih0mOGTGYDnmeRz18iHk8zPX2ccvkyhcJ5+vtHFlWOfC/ihgfkRkhUKrPk8xP4vs2GDXcCMv39O1AUncuX3yIIaiEL2aJYnOTgwb76jSc0qu9n+/ZvoigJ4vFuPvzhLIryPNPTx6nVkqiqgeNUGRl5hQMHfqYDKHs4TkR8EExD8EJAjkLoxxqGmONTVTH/7Lomudw4hpFEVROk02uYnj5O4yvwQu3Y9l7nd9m37w0UpTe8USwW9rKc0NItejyOuBntFjAGQocsK+zPVFksfF9o9Cph5bZTxhdl0O91tC+qq/Ewbn88l9vGqVOP1SU2l3t9FBG4T03dUWdou+4idX1WT6y6WkKXoqwMnK+VdOly0f55hodbr++2bQKE9+4VWe5TT/3Osj3e1o2Zx/HjP0EzY35i4sH680SmlVzQprj6snj7dAM07rd2IqWEqsZxnEieVSMIbHzfpFyep1othg5ONUTFLYbwSZYRmWsN04ysHqOwkSQt7DkXkeUkqiqFNorQqJoJFrXoS8cQm/Ukqir4Lo5TCAmkNo1ed0Syag9RnpflFL5fqpPK2kedbrvtSy3nKcsKx48/zKlT+xke/i6PPvp/0NW1AdP0mZ8/ge9LBEGtrR3Y0K1+/fVPcv58jttvv8R9912kVitw6NCdLRaLb7+9lb17n8PzXPr7RykUJjHNfDg6e4pqNYckBdRqeWq1LNlsJUzqkqxdu5dMZsN1nU2+oQC50zwyNByghITmOI5TZXBwH5nMRrLZCQqFs+RyJ7DtGpXKFJIk5tFGRl7npZd+tj62NDLyGm++eRsnT/4cO3Z8n1TqJLFYN+DXs89Eoofdu5/ns5/9LGfO3EMu18/x4z9O9MPQtCrNN9rCEth97Nr1HRSlh2RyAEXRcZwC5fIMkqRRrZaQ5TKeZyGEQRrD+83RYE5KWJYOFGjs0jsxpptX30bpunV2UcbzalQq5+ufZzGiSjIJlUrnknP0WDMYt/eZVyvmsNjzF9M2Xk49q1NfWZIWkogi+8W3326Q8hZ7fXssBtqLzSq/26NQzXGlmfKVxmrmrk0TRkYa1zcCY1hdj3eh+lp7NavKE098vf54c+bc3KZYLmq1RoVoIZciet/miO4rFQF+ETi6IVPbDs8xmn6ohmStiHTl1z+D8GrXwtdEx2xeK0Q/VJYlgkAN54crNMadBJ9E02LIskatVgxBWcJxKnieg6KIHrZhdJPJbGB29p2QYNVgPDe0DMTaI0kpdL0L03SJSvdLtwM03nnno/zpn/43IkElw/gHPPDAWUxznq6u9QSBQrF4jq1bX+DgwV9sej8xw3z06MMcP+7yzDMqicSfs2XL/2Djxufw/eYpmFeoVC4DGjMz7+B5LpaVZffuH8XzPAYHd6MoQpRlauoY09Nv4Tg2iUQ//f07cd2lK4bvdtxQgFwuTzM3Nxbu3GIMDIyiqrF6CcH3xa5HqLBImGYJ2xY7HVWNEY/34ThlYrEu1q3bz9atsGHDH3DgQJxt217BNBP8yZ9EPwgVSfoZ7rrrOMlkD5ZVIZnsJZHowfNctm//Jtu2fZmnnvo39dKJJHk4ThpIErEXF5bAniUIylSrNr7vhM4p2fCGdgkCM1TcUZCk6PJHpaCoH6nTKCt54U65SoP5GwGyUAzS9RSOY9IwIDcRO+wEshzgedEN2ixooNePvzDETZhMNh7ppD+8EpBdTSxmXtEc0XmsxJ94794nF2S+kWdx6whTg5TXTMxa7D2aAbcdtJebVV4pGF+P/vP1iCCQWvreq+nxjo42NleVyjomJ+8iAl8xZpOkeZoimoVtPuZyPeeID9D879bfZMQMjhzXJBr3VLsSn0NrxunSuA9p+1sA2Hhes1uURET6EiGAVJajHreF79uIef7oWM3zxdFjEaiLNSGd3ojnVVBV0bMWCmMRYSzSVBB+yCKDd9E0Fc8r0dxH17RKfWMUBCrZ7LamETaVM2fe3/LdnjhxCzt3fq0+j93Xt4NC4TSS1HxNYNeuZ4jFujhy5I66CdBbbw2zc2eanTu/zq/+ai/vvLOH7dvfYHj4VUzTw/eFKIjn1ZAkAc6KouC6Nj09W6lW58lk1pHLncKyijhOhsnJH5BM9gPXb/TphgJkgGo1R7F4BMPIIMtqXU0lypwHB/cwOztGqXSZUmmKfP4c3d3b6e3djuu6uG6FVGo969ffBTj09pbZuvUrlEqX+epX/0XLD+Ls2fu5774JDCNFV9d6NC1OLNZDoXApZDHbHQD3BRq9mhSjo99qK4F9k2ju1/MsHKeMJCmkUgPEYoJFCGUsq4hhZIhm/Bq61hHt3yAqKQv2dJSONme/OqnUJuLxDKaZC63FBONaUVKsWbOXXO4snmfWz6kR7Rl2jEbfaWHD2PfFwhSVsP33dqT5mkWUoTZGmFpJeVGvOALdqNQZZbudAPehhxrZ1mI96r+P1mi/jpr28bB/37nHuxRwRvaYIDLvffu+xPbtT/LKK79dB+OIAd1+zOWy8SAQ1QZFWYoPEbm/0fRei5EuZBSlB8/L0xhXWuz5NRZmxM0n4YTH00NFPlE+VxQF3xcjTbFYL4qihzPEEQg3gF+0nRSCQKdSySPLEpIksm1dX4PjFMKMWsZ1HSRJQ5Z1VDUVgrMgujXc1BoTCs0jbPv2vca+feO8/HIzce9pbDuPpnVRq+W4dOl7AExMtAL3wMAl7r33JIcP31OX0xwZeQNFUUmn17N373M88MC5ECdGmZo6jm0HoeRoH77vUKnMMzPzNqOjCQwjjWnm8H2XgYHdpNNiPGrdultwXevvS9YgytW+72IYaXp6tmJZFRynguuamGahruSVSg0yMDAaPv/7OE6FeDxJb+8Opqd/QDq9joGBm5AkGc/zSKf7kGWFdHqQm28+wfPPN34Qmze/hOOUUZQhNmzYg+NYnD37LIXCRSIw7ERaeOqpf8POnYfZt+9lHCfOrl3PMTr6dNOniYf9GgPTLCHLwvzcdefQNAPHiaFpRlgeETeJqiZCj9PmHXXE6ox2ye0aug7l8gVqtVgIlEH99Z7nUCica7pRI7JHO+Aq9WMtNWcZudtEfePFxqBulFiuZ9teum4uO0dg0VzqfPPNf8LIyNcAlgTc5XrP71ZIEhjGu59ZL6emttJo37hEWWsnGct24Gye+W+33OzpOVP/PhwnSTP/Y+3aH/Dgg/9ny+jbctl4M09icUBWaZ1maJ7VVWnNfKVQUyF6TqcSqWgvNdjTzaGHn8klqpYFgUMyuQZdF9yYSiVLtTqD75uYZpZEogdV7Qr179vfz6JcnkTXNRynhu+b4WRILCyvR1rcgl0eBBKe51OtztAsydva9xWPNV/X228/yu7dz/LZz15gfPwuVLXMxMQHAYXR0WfwfRdVTTM29ii53Eid9+P7Kjt2fJ/t20/wz/6ZyZtvrmPz5pcYGRnDdddjmnlARten2LLlg9i2SSazhampQ0iSSi43zvnzL2HbZRRFo1qd5rbbfo5Eopdi8SLxeA+SJPDBda3rbjRxQwCyMIkYo1KZRpKkUI2lzOTkERynxsaNd9cB2/ddZFmlr2+E06fjeJ5HpZJl3boUGzfeS0/PNvL5i1Qqp7Htcui3OYNhdHHHHT/gF37hnzE2toebbjrKTTcdwbYtTLOILCvYdokgCMKeSuMGGx19jtHRbzA29kNNC4PKF77wjxge/jKJxDp836ZWu4z4kZoEgRICrofn+ThOEVBR1RiKooafM9KwlVAUDcdp7IYlKYaiSCHJojkrVhGkrWjQ38HzAiQpiTDrjq5qjWp1msauOOpTt6uJGciyHpqLRySvzjv2d2POeLVxreZgoVGSPnXqsZay81e+8jdEIylRqRPEvHG7XWMnstdK3KGWiquRxXw3etTLqal1+vdSr+2k0NXMdm6XsVxq5n8pgl/735rBuNPfOzGuk0moVhug3Pl36zI29nBdVre5bxqPD1CrRfchCDC1abSlFkrgynI34ndnhzyTKKJsX0GSEmiaHupL15BljaGh28nnzyJJgrDlOAXEvayjqkFov7gwbLuK7xvhWiPWiFisB9e1wyxYVJEymSEcp0StNksrca2zm1rjur4canZXGR19Cscx28x5fpjR0e9w5sxH+eM//q/IsrhW99xzmgcffJ69e3MMDNzH2rWz3Hzzd5mePkq12ke1ehzPc9H1BAMDt4TOTWvo6toPONRqOQqFi1hWEc/zUVWdrq5h8vmzJBLdGEaGIOCGMpq4IQC5Wp3H86yQ/u/heSa+7xOP96BpwqQ7Hu9BmF6rxGJdjI8/jW1nKZUuks+fIwg8Rkc/jmnmmZp6M9zt+UxPH6Ncvkg8PoCiGOzde4E77vgeo6M/TLH4CPPzY0iSRC53DlmWUZR4qFqTwLYdFCWGqnZhWc4CLeRvfvMLPPjgJLt3v4DnRYo50Q+1fWcryFu+r4SfUajQSFICSTIwzQgMhZh8ENihJm07OEZ9KCEQIERCPFy3k/dys2m5SudxjehYBo0S2bXXvb4a5a72WGpetrm/G/WPFxPFaO5Hg8jaLl++s8XsoHH9RTYiSS7btn2Dnp4z9cX/2Wd/p4XAtRp3qKU+45UC60oZ1is9j+UeX4mgSHs0b1yaSV2dIlrsO838f+Qjv1bPqIeGXgTE9zEy8sKyphErM5VYvhokMvi/6lD6dprAWEHcY6I3K/yJ2y+chqomw/HFRrUrCtHWqiF81IW8paZ5OE6ZIPBCEpOF69bwPBdJEhfesubbetHRHLUDuPi+FRpJNADfNPMoikqUkStKhoGBHczNjVOrNU9uCBtIcS0/ycTEw6E0sB9uUA6we/eLOE4M19WQJKXFnAd8Dh/+WW6++TVOnhQcAMGY9tm6FfbvP4Sm9VOpZFFViWJxEtd18P35cJZaIh7vZXb2BxhGF0Hg0t29mURiEE1LIstq2Bs3SSS66mThcnkeWQ4oFi9TqcwyOvpD4ePX12jihgDkRKKPSmWWIPCZnx9DyF3OIcs65fIsqlrEMNIkEgMkEn1MTv6AyckfcO7cyxw4sIPx8TvYt+80P/MzPwh3hia2XWP9+tvIZk8jyzGOHLmP8+cfYteuI9x77wlct8bo6KOcO9eLZeUIApli8TyFwjksqxQCrJgRNIw4kmQwPPxSuDCIMtj09C088cRXVyHzJ4XsxeZd52ZKpVnE/HAkBq/SIEtEpatIkMBCWKPpBIHcpP/ayU5RZN8Nx5koi44kNe3wnEw6l9dWH9fTsnGxvmSnaD7Pxuui/lezGIhPV9cZCoWR+iIS9Sjb3y/6HVyrDPVa2yO2H3s1z7+WsVJiXhTN2vGRXG1zRttp7Kb5+1jq3lzu7yuJiYmHFil9t087RG2n6B5OhfrSjRBZauf7WbCyNSCO71cxTaGHLctxXNejWp1B05LUanlEtUsCUnhelDELMqmiaEiSH274oxKzjywb6Hoa0ywi1j473CAEeJ7L5ctHQ4JoFBqp1LrQh77C6OjXGR19JlxjbHbtepq+vmE8bxDD6EWWoVSaC0WV/nF4DJkTJz7O2bNPEY+bNKpSMpZ1lrm541SrWTKZTThOEdMshCqICtVqGU2LUa3O0NOzid7eLdxyy09TrWZJJvuAQWq1PPH4AKpaQVEUenpGKJUukEj0ksudY2bmbeLxXlRVZ8OGu0I50v/FSV2yrDIwMEqxeCm00RIzY7Ozx4jHB+jr20Zv7zZisa669eL58y9x4MAW/viP/4hI+KOn5/d56KGTuK6Fbecpl6fIZNZz/PiH+R//498iyy4vvfSz9PX9LrffvhbHMUkkeshk1iLLGsXieYTdY+QBCuCHLGmL0dFv8/jjP86LL/4609P7OrI2xU0QIyJrtUZ0o0WPKxQK52j0iKEhDl+/OrSSsTRACYE4Os+lhoEjEQFRgpVlLZTUjErZrSSPzhH1mZdOu5p7zNG/rwSUrxTU2/uSp0+vTH5RvK7Bxm29njIPP/z/AlhQhl6sD7pcrAYMV5qJrvR47cdcLm4UY4pm0J2YeBBNqzIx8YH63wAOHfoCS/kqv1sxPPwcBw/+4yVL340WmABakR13Wh863YtRT1lUsHRdDnXrLSRJx/OCcOwJgsBF12PYtjiOJAUYRgZVjaGqOrVaoUlwRA8JXB6aliCd3kw8nqFWm6dQmMTzrJCbkMHzath2Fs+Lxq804vH1pNMbsawivi8y5ciZDoRGtuv66HqSIHCQZQPLyjM6+lV27PgaJ09GLSCfN954nDVrplomWorFGpEb1fT0cSRJRtcNTp36MY4f383atX/D6Oiz9PUJntD27R+jp2crXV2bwtagRk/PZiqVGbLZczhOnpmZt/B9i7m5GJIEAwN7CAIPWdbwfbee9F2vuCEAGRqgLJycepEkiampt6nV5snnVWq1HI5T4/TpZ5ifH0dRDCYmPlhv/Muyy9jYLfz0T5fwfYdCYRrTzJLNnuHYsZ8gmkWWZY+JiQcoFF7A8+xwN+jR3b0VRYmRTK7B9y0qlTzgIssGx49/kImJB9m27RX27fsukiTx53/+Fx1uQAlZTrcAuqL0Ivq8JuAwNvZxJiYeCHtN36BxU2p0CsPoD83LxfHF/9pX3gjQl2LbqAhPZbvt9VEpbbH5u6jMtbLMuV0oZDW9xU7PXwoQ2jPIxQhVy2WaDcZ1s6GE+O/77vtiSym60+tWK/e42PlHj8Hij1+LcBzQOv/crnlcazCPADbSHI8MDYaG3giNQkRcyfdxNee0eOk7hqIYYYsqGk0wwlbT4jryrfdztKEGMcvsIctxwMD3AxRFjD0JD2SJIHCJxQaxrGw4ZinjODUkSULTdBxHyHFG1q5C8MgJW3YKqpogk1lPrTaPYaRR1XhYwvUpFi9iWQKUfb8a6kIUaUj2FonabuBRKJwJtR4UTDMXTozAbbf9UdP3JXPkyP18/ON/WQfjIFDw/VkUpQtZnsGyCgSBy1NP/RteeOFXwud8lp/+6Z9ly5Yp1q3bT7WaY2zs64yMfIh0eh3l8iSKoqPrKXp7N3Hx4hTJ5CCp1FpSqQGmpo6QSg3R3b05JKldX6cnuIEAGSCTGUJVY+i6KDtLUox8/gzp9DoMIx0+ZzMDA7uIxXooFuO8+KJaV2p59NE+pqYOUCxOYllZyuV5arUsGzZ8hyBoCITs3v0Oly8fxLarRFqtudxZIKCrax21WgHXtdH1bk6d+ihPPPEfwv7QL/NLv/TPefjhV0mnf4W33tqGppU4dOgLHDr0BQYHj+I4fQwPf6vubiJJQdgT8sKS2t906DW1ZqnNIx57976G6OMo4e5zMdm+djDWEDexMCWXJBVNSxMEQUgma4SiZELta5uFsbCXBUIsYTHBkPZ/tz9+LRfp9l7wYoSqpUB5+/YnueeeL/Laa79Bo1wtTnhmZk/nF3V4v+HhKyNwtcdKzSGWenyp8Lwr6zGvVuhlqb9dTWtDcDkaFY0DB36D9etfb3nO+vUH31MLx8VL32Z4rVvnBH0/AsX2MBAKXtEIYsPKtfmYQRALxyR9GmuHRkMitxjOImvIsui5y3KSWCyNosTqpVmRqYv7u1i8gCQF+L6HphkEQReaJjznk8m1yHIQjjtexLIKOI6MYXSF0p0OkZmFJGmoahrHmSMIath2DN936mAcXa/mLFmWXUxT5pFH/gvPPPPzgMfTT/9DhoZeZ/9+Md515Mi9vPDCr9CsxnbhwkN0dR0gCGQmJ4/geSaqKhKranU+/J8QZVIUFcPIsHnzvczNncDzbCRJCk0oNl13Ywm4wQA5EgApFi9Rrc5jWVlSqbXE473Mz58mmz1NPn+awcHbGBq6g899TiWROMHTT5e5554yd9wxy+XLWfL5c2iajutWSCTWsm/fa/j+jzAxcT+33XaJhx7ayuRkgp6eQTzPZWrqEH19O7GsMqYpbMcURSORSHPhQqt7yZEj29i16xmGh/+SYvFunnjiq/XzP3nyE+Gu/Rd4/PFPsWvX07huvm6lmM2OsLDE+WKoxlNBZNCtIx6S9BPs3PlVIMDzFCRJp6FlbdDqe9ys4BWJDqQRN7CFbc+yMNN1CIJOhLDFoxMYg3is05jIu6Fn3RzNWeVSfcl2IGgmgD3wwG+yefMbPPXU75DPj9Sfsxxwtb/f1UhRrkbtarXvdbWxVOXiSgD2ajZlDZJXVNHwKBQ2tjwnnZ5q+ffqLRevZTRGr0QspQZlEQRSeJ+rQCl8PCJjKUQCQw2Vv+i+V4nFevA8OzSlUFDVNPF4F7ZdIpXqJ5lcQ6FwGd93m3SzRQ85CBQqlRy6LiQ0fd/D90s4Tg3HsYjFUqiqiqKkkKQqsiyTSHSFZhdi4y8IqX4o8yt61IbRjeMUcJwUmmbUSa2Dg+/U10zfV7n11nO8/fZomGAp4Vjhw/zoj2bwfZennmrdiAWBwgMPeHiexcWLL6KqaSwrRzq9PrRoTAABvb07GBq6jenpUXp6hslkhojHhQ+9ZZXo6xtB11N/z7JeKmxb/BB0PY2qath2iWp1hnJ5EjhMPJ5m3brbuPvuY9x6a5Eg8Bke/hizs2MYRgpF0dm4cYRc7hQzMyfZu/clFCXGqVM/wre/XWP//hiKkiCfP0EQSFQqc/i+Qyo1SHf3RsrlWVzXob//ywRBwy5saOjbzM4eZmzsMV588TdpJQA1qwHdz+jo37SMSi0cB3gRTdNRlARB4OP76oLZyLNn72Lnzi+Hxy+3zYDGaPQ821fnKLPV6STN2RyC1LUypY9mGUFoZL8R6Mry4qDRSYYz+vtirlDXctSq+Xhvv91ZUeuhh1qdnPbta+jxnjr1GEeOfAHgiv2Pl+of36jqXKvtdb/bMTr6ZN13NwK7SmV9y3NuvbXxvUWbXGFSIErcDz30m+/BmTbrBkRKWwJQGyFKxuLxaAzKIQhAlpP4fqRFEDT9TyLyTk+lButWgp7n4Hk1NC2N5wkRD8NII8s+sqxSq+UxzWo9O5dlCd+P+sgCRH2/QrXqoyg6mmagaSkiz3bHkUmn1+N5JtVqFklSsSw3VPaKiKGRCYUCJDCMJIlEkkKhSDyeYWjoTjTN4KWXNnPgwK/XAfYnf/JFHnpojmQyx7e+pdRbkT/0Q4Ns2nQvhcJ5br75FE8/3Shpf+pTX+eRR/JcvOhQLs+iKDmCIKBYvMDWrQ+FtoxvhQ5Oa9iy5QGAUKVrCFlWyWZPoaqx616qjuKGBORUapD1629H19MkEt309GzDskoMDIwyM3OUdHqIrq6NVCqzaFoC3/fp7R2mUpmjt3cT2exJ+vq2k8lsJp8/i+87TEz8JP/zf/4nZFloof7yL7/Dbbe9jm2XAR/LyuM4Vfr7d7Bp0wO89db/ZGbmKFu2vMNnP2ty5sz9bN36Etu2PcnY2KNh6TliRUchhT8WleHh5xHU/1aA3b79W/T2jtd7TY6TCHs6gny1OjeaqFcdZb3NoKog+ldqhzJ3ZD7RPKPcHu0KQeLfYqFogHLzf3cC1ViskVFL0uKAtFRJ+93wXF5MUWspb2UB1CIi/+PoWO261e1xIxCjVhLvldb21cZDD/0mQ0NvMDHxINnsNk6derQ+RtPdfabluYL81dC5PnDgN1iz5o369/XufTfRgaOGfcThaO4P14iIoKJSFk1gmCFxM7o3I3EOAXS6nsYw0iiKhiyrOI44ju8H+L4bzg97SFKcRKIHx5kNDWVUYrE+XNetM7yDIIGiaBhGF55noyg2jiM8k+PxBMKNzsYwVBKJQQqFSVRVyGqKSmQiPLYHxOul4d7eEWRZwXVNJOkynlfDsnJs3PgIU1MP1TNhRfn/s/fn4XHd2X0n/Ln7rX3DDpIAd5AiRYrapVZLanW3W+3udi92LLfj2G47mUnGnsnY72TiJHYmk56ZJ5lJJuNMknkT2+POayey47Z739RaWntrX0lwBwmA2FF71d3v+8fv3kIBBEiQoiTKj8/z8CFQqOVW3bq/8zvnfJeAVGovqvocU1MvcuONW5Flhc9+9iyjo09z4UIB329x003n+PVf/0eMj9/Irbcu8NGPLhKGRQYGDpFIFEgkSrRaywwP38LIyN3U6xeYmnqednuZs2cfR9eTzM0dRddTDAzc2PFIuB4q4ziuy4QsyyqDg4dRVZMw9PB9F00zCUMYGDhEMtkLQKUygee12bLl1s7suVa7wPDwrQjyPJhmHl1PcuHCpzu7LknyePvt/Rw69CSKotPTcwOWVabVmief38ny8gSmWSCV6iEIAj73uRTV6p+xvHyeel1fQ3PwyeXO0t8/zuDgSSxLYnT0McbGvgcYjI4+vSrBHjnye2sQ2T6SpKAoSTyv3AUQuVR7TcyHNS2D6wqwmDiV3fNewalWVS2aGXcn3W4wyUaVcXeyjg3URYKO29KxfGY8Jw4CVulfx5FIrP79nbR1NwuCulxcSlGrWzAk5hifO3c/a+lQ3Spf6+lWrz3u6z0pX6kb1Wbi3aTBdSOv49ZnGCpUKtt5+OFvdDAaa1vckuSvUlh7d86NgiQp0WY1NqBYq+QFMVZBlkXFu9rNrXtDHM+HxT9dT+M4DRynhaIYqKq4RlVVQlWNKLm7SJIdaTjHlavboTWthIfvi+NIJnvwfRtFaWLbNRqNSSRJw3UddN2kVjuP7/uoqoLnudj2MrZdJt7waFqGXG6AbHYLudxWKpUJGo2Z6Pk9PM+j0VjgyJELfPWrCrIc4PsyH/2oySOPpPj3//5fda7J++//IefO/YggsCiV9qAoBrfc8gq33voSw8N3oOtZRKs9IJMRHZJUqoTrNjl37hlyuS2k04M4To0gcBkf/zaNxgVMM09Pz551jYze77h+jmRNxKjrVmsJ08xRrZ5nevpVhoYOY5o5Go05NC2FYeRIJktYVpWFhXEkCUol8WEvL5+JjCd0tm17hCBY8TneuvUHuK5PMpnB95ssLr6NJCksLZ0EoNGYIZcbiRJPi2SyiK4n8bwGO3e+sIrm8IlP/AZjY99hRUErToopDhx4nIce+gITE/d0aV1rxEk1mRwgne6h1arSaFQAGBv7bnS/FXDRygxKJ24JqaqJaeZwnAaybOC6bTyvTNzS8v1FfN/k0rSo7lhbFccX7QodI5kUFW+clMPw2i9mV7JAXm01FwO5zpx5kB07vntRIl3LMb7zzi+zlg4ldH83r1t9qfe1kUNUHO92Mr/cnP+d0tfW+/1avad4E/vEE/+Y2dnDxHZ93XKccYs7TtqblTR9J7NnAaqKrQw3YkGIsZPQJ+imOMbXu5gdK0oiAohaJBJ5NM2k3a4CMoaRJgyF7HA2OxzNoJVIU6GJ6051PZcUbaBjdkXsCmXRas3hefWIj5yLaEt2BEqVsG2xAYg1ESTJjjjPOpqWRFVTGEYCXU+jaUlSqT5mZl7EdRukUlkkSSaXG0TXM9x55zH+wT/4v3n55UEOHDhFf7/NmTM/1cWa8Zmc/AluvfU1Go0FEokSyWSJMJSirp9LX98BpqdfpFyeIJcbJpnsR9cTLC6eoFw+z9JSD6aZY2DgZnzfRtNSVCpnSCb7OXPmcQYGBGDzemlXw3WckGEF5AUwM/MGk5NPIcsKpplnefkU1eo5crkRlpZORSYKDqqq099/I7Zdx/NakXB6yG23vUYm83/y6qvD9Pd/g+3bv8bSkkwY7sayarRaZTQtQSLRR612ClU1I2k1OwJ7lWm1ljHNLIcPP0UYPsSZM7d10RwkZFlDVc3Ii9RDURRkWY8Wha9H7yoGZwiDckWBMHRoNKYQyVCLqAhhNFeOW8vx/EnMoDQthWnmCQIfXRcXg+s2oudMRjSLeEe9GY5L7Opy+Vhb8V5NbITAfq/i5MlP89xz/whJ8pibu5mhoRdWJcK1LW3PS3a0rwFuuUXMKEVlduW61d2t4cs5RL0XlfV6ftfv9uuv3aBcTTXdnTDvu++frMJrdI97ulvcw8MXS5qut1m4EivIlYiFNrpV+wTDwfNkwnBx1b3F/FZGVfVI2rJbSEQl7nz5fhtdz5LNFkkm+1lePh0BpAwURcey2siykIv0/SCyIBSbATEzjnXZE4i1yUTXhZ6+WDdidHYdVQ1JJnvQ9SFarSq+X8N1xXxbiCaF6HqaWq2CqNYTFIu7cJwGrltnefkErlvH8xyy2WF0vUBf335UVaOn5wBBYKOqSQ4e/AtuvjlHMtmHLPdw002T/MmfHOq0sm+9dYFEooimJaM2e5t0ug9NK9JoTDE9/RKWVcO2l3DdEqlUniAI0fUCy8vHEKyZraiq6CBMTDyLYeSo16fQ9SyVyhTp9GA0Y+6/Lirl9/8INhmDgzdSrZ4nmx1E11P4vocsmxhGjkSiQLu9jGFkSaV6abfLZLODtFojKIpGPj9CobCHBx+8l7Nnn+b06RoTEzInTnye6elPcNNNU+zc+aeIGYzNyZM/w0svDXHkyDkOHnycbHaYen2Wen0xUnsZ5dChJ9mz50+6jjBEkgLC0ERUsSqSZCJJ8qr7xBWvJKUIQ4t228Gy4osn1kle2SlrmoLrxpQCHUUxENq0BolEkUrlXHRB1fE8G0lSkOVEROBvRc/bYuOI5TXXozxdXcSLW+wQtbaN3Z2MNlOZXW0VfKl29uVcmdZraa9FVCsK3HPPlzl58kG2b7+4yt7s8V3qWK7GwvJazIDf6/b61UirPvroP+1UvXHCvJxUZnzbWjvRtUBFy9qsFWQ3ehpW3Nq6w4sS2sWdKiGFmUaSNIS0bfxcJolED57XxvOcSP9exvMCKpUpPE9YHeq6Qa02i6YZ+H4Ty9Ko1QSFc+XfChMjDEWlHoY6sS9yMtkbCSKJ9cL3PVqtRRRF+CvbdhhtnENef/3DnD59J7t3P8+2bX9CGNoYRol6/QKe5+J5dRTFoNWqYprLqGqKwcGbMc0MjlPF81qoqk61eh5ZVsjltrFr18c4e/Zx7r77bf71vy7xwgsldux4mpGR79Ns2jQa0xQKu1laOo4sq4yMfBjTzFGpnEaWxWanp2eMMAyp16cJAjfqZlr4vkWtNomup5EkaLXm2br1bjQthaYlWVw8jqoaq4q/9zM+MAm5UNjBrl0fx/dtpqdfQopW8qWlU6iqju97JJNFANrtJcIQtmy5Gd8/hGVVKRRGcd02AwP7OXfuKU6f/iL/8T/+P8iyx6OPqvzyLx/nxhuf4FvfUvm93/slZNnj299W+a3fsrn33nPoeppEIoMs67RaS1G7SMTqttYTGEYSWTbQNJMgCPD9PL7fjFpJMqpqIkkBslzEdVsRH85E1zORTmuAJIWoahJNy6CqUqSJK5HLDVGrzXSMt8V7N1FVjTAk2vFWWEm0lxP0CDdxn41ipcUdq3R1L26XUuy6EvrOpUBem4n1ktTlXJlicNf0tFCFEjPk1eIgK5ZzHrOzF1fZl3sfmz2W9WIjfe74/+sBmPVuHkf82XdzUlcc2S7fcrnUdyreJG4OYLmWF7cRT+5S+gGtCNgZj4gSpNMD2HY9cqMz0TTBxIiv1TCU0TQd264iWs+gqmbUaYtn1WtHUCIMI0Mms5V2exHLqqCqiQgp7UfP7UZrSYDrzhMEHpIEb775Uf7oj/6/SJLHk0/+Eg89dIGxsW9Sr8dqg0JsxPcD0ulhXNeJREYGSSZ7cZwyimLQaMwRhj6JxCBbt96BLMtks6PIsszP/VyJhx4KmZ42sO37OXXqu8iygePUKZXGaDZnCQIP267heS5h2GbLlrvYvv0eyuUJbLuGqqYilHiSpaWT1Grn2bHjY+Tz28lkhujr2x8hrE+jqnmKxV3XDbDrA5OQ45myoDWJHVulco5abZLFxePIsoxt1ygURrHtGv39N6LraTzPotGYYWbmVYIgYHn5LJ7XYnxcCJwLkJfPD3/4myQSeY4d29N1u8drr21j166vYtt1FEUnCNwINSgThirj45/j4Yf/tNPW+uIXf5a77jqKbbfxvBammUNRirTbAYoiSP+C0uUg9KtjJKWEafZSq80Shg6JRH/kkNKMjCMCFMWk1apGLlIWtl0gk+kjkbAjgwmrYzKhqgaQ6PJBvVRcrZ+eBySwrHanGo49k2PAVzcveaO4Uh7r1Sz0ax+zGVem3bu/iaaxSh+5G1ldqey4ZJW9mSoz5k5fiUPU9ZBsr0V7+3L3vdR3Yi1yOgwVNK11FS3mjWOz5hMiBEfYNItYVhPBH97ouorpUN0Rv1kDTRO4EDGOKpDPDxGGEq5bx3VtwtDBNDMR40GNNsEh9foiuq7jODFfOWDFwjWOWA+bqGr3IlDWirsZuNG4T0f4wgs+89mz92zQMYhpXV3vxloikRghl9tKEATRzNtnYeE1Wq3FDir82LG/oKdnjH/7b2/h1VcPcd99y/zGb5xE05IsLBwjnR6iVruAsM+8EU27A00zqdWmWVo6EfkWNAgCj0JhlGSyhGlmKZfPYhg5PM9icbFEOj2ApiUIw5BUSnjTAyQSheumXQ0foIQcRyJR6PwsgBASpdIO6vVZDCNDIlHAtqu022VUVVzFhpFFlgUnbX7+NWZmXmVkROe55/4OIEAeU1O7+bf/9n/n/vt/t/OFC0OVPXteido5HsXiDtLpESYnn0KShKj5+fOrHaAef/wfkMv9ETfd9By2XUWWRZUqSYKSYBgqQaBF3qQ64uKwkCSddrseEf4DgsCOduoKoEdVd0xhEu0v37fwvAa23cZ1W0iSjq6nCAIN00xhmikqlRDPW+bdCaFf6/srAK84GUsSnds3ExMT11a4YSPbv+7YSESkG2C11m93rX8ybGzFeLlYu0FY71ji+2w2uV+LVvOVJMqN/nalSl6X22StfW8ryGmRlO+558u4bmrVuXrllS9t+ju10aZws+YTkmSSSBSiNSluFa+6BysgzXg8FW/GV7TtTbMPoZ9fRdfTFApDeJ5Nu11FVc1Ic7lGbL8o1pYkti1Ef4RDXRbfryNJiWg96bwrAFy3Tr0uR8YRVrRmeIShieuGgLBtDIIYAW6SSGTZu/dVnnlmZW0cHX2mc9yKkiEIPBQlRRi2CQIf1xXSxFNTz1KrnUNRVFqtedrtCopiUq/PUKtN8fu/fy/f/OaHgZBjx3JYVplf+IXnmZx8BtsWjJB6fZaZmRcpFvdQKu1DVRM4ToNa7QKTk0/g+zbbtt0ZsXBKaFqqU/WWSrsxzRyWVcXzLJaXT1Es7iKTGaTVWohsG9//djV8wBJyq7WEZZU7AuDtdpktW26Jfu8jDL1INq2fZnOOdnuZMIRkskihUKRWm0SWdZLJXm644Yc89NDP8MQTv7XKKMKyZB566GeYnv44Bw+e4uDBH9NotPB9n2JxD55nE4YurltBllX273+DZ5+NaQ0Ks7MH+Hf/7n/n7/ydv8/tt7+KZQnRkvHxT3Lq1N1s3/4Eu3d/B1BJJAqkUiUcp4bj1FDVBJKUjy66kHZ7EU1LoesmqVQPpplnaekciUQGVVXIZLawvHw6ajuZ6HoORclgWWXabSuyZdscUOvqIhawF78p0SY5pkTFv19ucb4a8Mw7lV/cKNYCrIaGfrxqgyZQqiuLfrcV4zu1XLxUXEmyHR//NKdOvb/c6KvZHFzJGGNsbHVXQdOEuUS8MQ5DteMMdSXfqauNMGzTanlcLNATz5jjyjR2fVof1xGGse59QBCE1GoLCKtFHcPIYllCkMPzGriujDBGCKLkKXyMdT1Hs+kQhite3iJcYnc32xaFStzeN80ijtMmDKt4npDPDMMK4BIEbdLpQT70oXFM87c4fvwA27Y9ya5dj+P7RTRNIQw1ZLlFOt2PbVcAMT6zrBqOUyeb3U6hsINMZpjl5RORBnYLy1ri5ZdvpBuJ/uyzW/nZn61j2zbV6kQkDmWyvDyBoHYl0PUkg4OHSKX6SCQKUadA6dCYuhNsOt0fcbo7nzJAJ2FfL+1q+IAl5GSyRBB4nQ+3t3eMRmMOgFJpF5ZVJZkskU73k0gUWFgYp1qdwHWbPPXUdp588uc4cuQexsb+nPHxP2ds7BuAHan4CJeYkZEfMDb2Pe69d4JCYQfz8wu0WmXA4dSp75PLDeM4TYIgwDCSHDr0Ir/4i1/i+9//tVWJ/fXXR9i580/xPJujRz/OV77y/yJcqf4WDz30Wfbte4RkskAq1YckyZFMXUCxuDsCH5RRFCGFZ1llFEUnDCU0TUWWNRKJIo5Tj6gVfqQV6yMQlMK4XIgMxAjtlR27qvZEre31xO1jKsSlhO+TrF1Q4tZ0PENeq9h1qdgceObiuNIFdC2FZb2qrBtgBXDhwq0A7Nz5rY5q16lTK8jq2Irx4vf0/kg1vv32p/kv/2VjxPZGcbnNzTsB1r0bdKdumdSTJz/duYZFxO1a+aLv1Ho0pmsjqymkK1cScHzNmazMjx1WknKs3LU2UejoukoYutEIqh4xS4q4bjMCeAZ4XuwKJxJUMpmN0NQqjlMnCEISiV7Ao9WajJ4/fl2AFrYtfJctS3xuQlCkQczwWFkzbBYWjuH7FiMjZ0il/ltefvnDSBIcOfICqmpiWRWazSaGYeJ50G4LCeJK5SymmUVRZCxrgf37P4dplmg0FgiCKVzXoVg8w4ULB4mTcjZ7jKWl03heI2Ku6CSTPRhGAtPMUa+fJwwVPK/Jli13USzuwPcdhodv3pBbLDStFzDNAsXi7s7t10tlHMcHKiHLsoosq7RaC51d0Nrfg8DrnJRCYZQg8HnuuT384i+WUJQQ39/PH/5hgr6+cSqViQ1eyeXFF2/n3Ll72LGjj507v4rrepGcpo3jNKKkZ+F5M+zePYFt13n44f/SWah3736DVKpIq1Xn9Ok71yScDzM29r3oWOdwnBae1yIIJJaXTyN8TyUURcF1awQBNBrzEcrSJZFI0GgsYNs1XLcdWaulAAvLsqM2ceypHIO7VnxYVVVGlrM4znpJVyaRyNNux37J4jYRcast1q0V4BEBABEOQvHseD2BkI3iytTJri7WVuF79nydI0d+/yJDiBXnp/i9CmH+QuFMJ7F1V2YHD168gG+24n83QE9nz14aPd792nFcDuH8To/x3W6jx3KmF39Pxc/xd2q98wJco7mzTiqVw7J0fL/FSqXcZMXjPD7G9cR4RKKU5YAwBN8XXsdhGKKqaXQ9GTEoQJbT+H4VWU6h6xnCMECSgojS5ESP0ZHlENuurXmdGHTW3VIX13kYSpFRROylrBHrZbuumDO/+ean+aM/+s3oO/bzKMqvceedR6PNQ0C5PIcs+yiKGVXKHp5nYZqiihVtbcEkcRwL122Szc7Qrcmdy81Qr08iSTqmmY0KrBLt9gKua0X8f3DdNrIsYZpZEok81eoUYejRbC7Q2zu2Kil3V8Nxcr5ekNXdsVnFiOsmxNC+gOdZ1GrTkdcmmGaOIPBYWBin0ZhhaekUtdokmmbw/e+3kWUf35eQZZ/vfa9GqbSHYnEPExNCLCReeCcm7mN8/NP8wR/83zz22Bf4D//hX/PWWx9FUQwcp4FlCT9RzxNOIa5r4fsuR448z3/1X/0GH/7wf+LjH//3nDlzO6+8cheGkeaWWy6sanuOjv4IXU9Hs20Fy6qgKAlkWcb3PYLAwXGWabdnaDQWI0S2GSGy3ciKzMZxmkiSmPEoioZlOQSBQxComGYKScqiKOkoWcdfTg/fFztgWRbABsuCZlMIfkCbdnuW1UCQACF6EouSuKwVyNc0osVi83PjOGLwzO23/+4VL4iWtfLvUvc5dWp15XvihFicJyY+veq+McBq714hkxk/plzeycmTK/cV3Yr1X2+9in+jMM2Vf9ciRkYeX/VdW2+u/V5Qmt7Ja7zzilqOrmnYs2dFsWvteXnllS/xxBP/E3GL+3Ln6tIRYlk1VDXWClBZvUGIpS/jTbCCJOVY2SynUZQ0QQDt9jSxn3Ai0YthmCSTPUCALOv4fpswDCOdaYNWa45mc4p2e4EgCDDNAiDTaExH1oggrt2NIollNSIt61jVTwBHV/jQ4n1NTDyALK98hmfO3A2EaJqJJIXY9izt9hKyHGKavUiSQjotVLSCIKBSmaRavYBwnROfxd69r3adM5l8PsvXvvbbvPXWffT1HaS39wbC0KHVWmJh4Q2Wl0+j6wmy2S0kEj0MD99COj1IqbQLSVIJQ59Wa2nVO4wlMhuNuc4G4XpqVcfxgaqQYaVKXl4+RRD4SJKMYWRYWjpFIlEgDP0oQWeIPZX3758nCPZ1VGBuvXWOVmuRnTvvY2BgiFgCM95Jr2fwsH//91CUANPMkEz2kEj0sLDwFm+99RFOnryN0dEfcfDgf8S2a/zhH/5ehxrwy7/8t3nggdf5jd/4Mi+/vIXR0ce5+eYJSqUPk0r1Mzn5FEEQ4LouqqqjqnLUrhKCIGEIup5GtKXlCBzmIdCYOpIkI8tyZ7YtQB4BmcwAhlHF91VUFSyrjWXZgEBrCgSlQrO5OomK6mg9dGhMazAQSXl1Qo7nxlfrtbtZ8Ex3bIa7Gt9no8p3vfb4wYPf5OBB0d585ZUvceLEZzl9+ic5deqnOjaNcUt47QbCsmB4+HHCcKXiHx5+Yt1ju5pW6eWq1StFbF/t63THtUzwV1ONHzr0+5w69VPE51YAvJIXIaPXdmLEjHnFiemddWccfN/B911WI5yFHaHAcnS3p/VI0lJUxpIURihgi/j7mUrlcV2PVquC7/tomnAkEnaGM7huA8OQWaE3auh6JmptN+mmM0qSiiSlCYIG4+M/0fW9+37EGFm7yV59rGIjobBz5/M8/fSvdtbSm2+eoVDYQbtdo1abjsBnKslkkUZjCbExmMW2mxQKw5HTUj6S+xQWknfc8TaJxG9y9OhBCoU8f/Znn42e/zMkEv+UT37SRddztNtVJEnh5Zdv4VvfepBbbplh//7BztrfanmrRpdrQ6g3ngQkenrGAGg05q4r+czr4yiuMJLJEsXiLprNBXzfolI5Rz4/Agjt6unp1/jGN07x6qs7GBursn37n/ClL/2Q06fv4KMfNXnggYBjxy7w0ks387WvfZ5YTu+ee/5Z5wLuvnC3bn0C13XIZAYoFkf58Y+P8Prr25Gku/jRj34janf9GvCzTE3duiqZHz9+gIMHH+WmmzxuuOERms1FUqkeVFWnUjmFEGhP4PsWltVEVVV0PQNoOA5oWhLbbiDLKmG44q2qqh6ynCAI2gSBgmFo6HoWy1qIENvlCOncRFFMDCOF7yeRpCSeV8Mw0ti2jOeV0bQVxaxgvW4acrTzjCU0V39tUiloRSNl14Vc7t046+8s4kS1FiV9qQV4varq7NnVdpzdCf1yvszdSXlt+/Rys97L+Quvff3NSnheDxSqq4mNfLB37tyYntRNY+o2pJAkn/7+17jvvn/yjuf9kqSjKOB5EmLslIzMH2IvYBnQkWU16u55UcXr4PsqYSihqjlMM4uqJpEkP9IVgGQyy8DArZTLJyPFrAbN5jKx45uihGhakuXlWdaCy0Sh0mJ8/MENPNnXj/Hxz3H+/MfYtu0x9u//Abfe+gKl0v/G+PhBbrjhKLffPo7nebTbc5EOhAwIMSNZFh7EmpYmCDwsq8bS0jjCk1mjVNpOtTqFpul86EOnueGGJ/jqV39zlefAK68Mc9NN/wXDyBCGPidPfp5/82/+W2TZ5+tfV9C0r/HJT84hywqpVO+q0eXaZCvyxu4ODqnRmCP2hb5eWtcfyITc3fuv12ciFRaBsDt37hn+4388zT//578RSbAd4W/9rWMcOfIEDz7YYnT0XiQpg67nOXHiFrq9N11XrFLiwv0sU1OfZPfuF9m585GIJF/mkUd6+cpX/ueuRXml3TU19QD79x/l6ae7W4ZP0mrNs7Qko2kmvu+xtHSOxcXjeJ4b6cYaQBZJakYJNySbHcSyTGI9WRFa1FIS8xfTlDpJ2TAKJBJ9tNspwMdx2tEsSMX3Y/cXDUkKO6YTup5nenoKTRML3Ir371pBkW6/ZY/VSVnMu5NJsaNOJq/xyb6GEScqAbjaDLf04qpq9+7vMjt782UT+uWS4tpE/07UueLYaCa9VokK3lkFfDWqWu9GrE3K683z18bFhhTiHFyLZCwSLfh+XCGD7/soio6ipKLqWejYC8UsYbEoZs42rit8kNPpHrLZYWy7TBj6GEYOVTXwfZicfJp6fQ4xevI7xYQsJ6P2doKLJ5EysVrXxMS9mwZQik3jnyNJHs8++7f5xV/8m+Ryz3H48JN86EOnUBSNJ5/cw2uvjTA6+hTbt/8ximLg+27kOuUCIboekM9vpVgcRZYNZFnD85q8/vq9vPbaCPv2HeX++6fwfYuBgW8RBF/sJOVUSuWP/uhvcuDACQYG/g0vvtjfWbNl2efo0YN86lOvks1u6Wj7wwqIC1iFLUqn+1cBvGLGzvUSH8iEDKLVsLx8Ck1L4DhNenoKWFaVMPR5883dq0TKT568idtue5kg8Jibe4tG4zymWWLXrucJgo91La6PRs+uc9NNL3HvvRcwjCSet49GYxFFSa4ix8cc5vj3Xbte5qab3uYXf/GXOXXqdrZvf5YjR16k2RRmFZqWJJEokUjkmJ8/SRBYaJpEGOooSoiqFiIjbxdJqkT0JzlKwgqKIkUtLtH+CsMMhpFAVQsoio4kBaRSBYrFXUxOPo/rakhSmyDwkGU1QoeLC6XdrqJpLoODAywvz+I4YoETCTW2Z4zBKBKyLBGGOYKgymrPU7iWsptXEpsBRa1HjxIOQGIRevPNFc5xvKCvbSV3i0OMjn6Tvr4XVlVj3c+x2Rbx2kS/WQ7z5ehe8e9rRwfvpBLezGOvJQf6SkVirjb27Pk6EHLkyB9cIyS8g+/HIxEJcV0EOE6ciBMoioKmpXHdBrZdRVXjlrOMLAtese8LtoSup3AcoWEgnKNEUvG8VgT6SiHLAqwpSVpE9awRt69B4EuEBaJQFrwYQPkMoiXdrb0tYu2m8eTJQ+zY8Z9wnAaaluG558b43d/9+9F9fo6HHlriwIFHSKX6aLWWCII24NBuL5LPb430sfM4To0f/ajEv/7X/xOS5PGjH6mY5v/M7t0nuOGG7/CLv/hLTE19nN7ePh5++G8gSR4/+IHK3r0HGRo6GSVjsb7ff7/E1q13AmBZZSyrSjptXkRp6k7Q6/3temlbv/9HsMnoRk+vfHCiVZNMFjpD+76+G/jc58p897tC5D0IFMbG3qTdrtBuV3Hdl0inB6hUzrFnzxv8wi+c4NSpWxkZ+WHnojTNAn19e6NKfCAikC+xvHyaQ4cmePLJlQr4nnv+Ga6rMTr6BDt3/ohKJckNN0xw441PUCjswLIK1GozCJtFNdot6yiKShDIyLIZ8fUa6LqGJCloWoIgEBeIYeTRdZOYLxiG5xEJE/L5IWy7iec55PPbop2gS602ha7n0HWPVguCoB7NqDRsu40kEYHSZEwzSV9fb+RnaiGSbLe/sgMY6Hoe32/gOCsz2G6N3OslLifTGd8HLuYcw2c6ylyxmf2dd36Ze+/97VVo7Djpnjp1P+fO3bZqpny51nN8fHGiP3364lnv5UBNmxXuiDse71X1+l4Jk2wUse/25Z6je1wgLFH/4Ope8KJYT8c6TnIWIvElok28jOf5qGqKfL4fx2kQhj6uG+K6darVCUxzANetoGmiXWvbdSyrHq0NTqRXHzvMCQ60qMLjYyGqGOUIuV1fs8F8kn37Hou4yjIxojqOizeNPyAMWzSbM5w//wQvvHD3qoR97tw9HD78GM3mArKsEKO0ZVnDcWosLZ3AMLKYZpHx8btWtaaPHj3ATTc9TbU6wc03v8ynPhXy8MN/u3MfgOPHH+T48Z/kgQf+DYrSz8/+7EE+//l0p1va7W3c3UWNW9TrAbkajTkWF8cxjByZzOD7rtr1gUnIa1sQ8QcXK7DEiTqbHcb351Y91rLqNBrzkeh4jlZrHlnWcN0KY2MT3HDD41jWbHTvFKlUD4lECVU1OHTorxMEITMzr5JM9jI6qpFK/S5PP51gy5bvRUlcXAS+T+Q4ZZBKDdBsLtBsLtGNVKzXp6MLzEVRZFy3iqYl0HWdMFQwjCSJRE9EzG+TzQ7ieU1c146EQ3Rct4KupzHNEpZVwXUbNJsLqKqJ77s0GkuRSXi+I7AuuMEBhiFj20LWz3UtXLcOKBHdIbZV0yNwyUqybbfL0fuMNW/N6N9a6lQ3xcN5V8Q7LhebRemuZ+qgKMKjOpYRfO65f9TRqI4VvDSt2UnCa8cWl7NgjI8vTspjY9+8SEd5vfbyO7GjvJTu9bXmH280n363z71lrTYqudRndrW89yuPbtlKDUUxURSDMGwQhi6apmEYOvn8CM3mAo3GAooi6E2u6+A4UzhOE1VNoutplpZOIfj/sX0rHWEhRUlgWcuITpqK7wuUdKt1IXr9lVnSgQNPRn7tUtQ6jzfWsVOViJXk/cBFwMN2u8Xo6KOrbGi3b38WoRYo4zjNaEQnhJkMI0c6PYhplkgk8uzb9zqPPPIzncfu2fMCjlNH1zOMjz/II498lEzGiZLxaiCm5yX4r//rrzM2FtJq7e4k3+4EHOtTxC3qWFBKllUajTkajVmazQUMI0O7XWZ5+Sy2XXvfqVAfmIQc72xiL2RdT9FsLmCauYs+wJdeGuxqWXtMTNzJ9u1/jKYl6enZhaIo1Gqz0QmQkWUFVU3i+xKpVIFksg9F0VFVHcdp0N9/I6aZRZIkPM/irrv+jIGBR6jVpgiCtfMaC89TCYI2rivAFLKcJJMZJgydyFO0FlksCvqUpiXIZgdR1TS+b9HffyNzc2+Sy+1ncPBm5ube4sKFF8nnRyKJzCyOUyeX0+nrO0ilcg5Z1qjVZqJZeiECkrTwPJHU6/WZiPcXe7TGu2oh6RcEZWL09GpRgLjv2UQk7lSE8pYjZPVardxYAD+k1RKLZCyj2WpdesYcL+DdloyXWsg3myw2Wpw3NnW42Mwe6FTT3WpQ8dgi5rtOTd3Nn/3Z1zh06Pc33b6+GvOMq0l2m5ET3ezzbEY+c+1t75WN5OUcxN493vsKl1boP6dIJIao1xdRVRVNy2GaGSyrSRjW0PVsBBYdIt4g2/YS7XYLXVdxXdElE9Wzx0q1rWEYWQzDoFDYS602SatVAeTI9SlkfPxTTEzc1UFSK4ow4JGkBLqeizAlDisCJbGk5+oYG/t2lLzFOjA+/lkmJj7Czp0/Zmzsj1eNc/bs+SaOk0UwMXw8r4Kq5iL2RYswDGi35zHNPIcPP80v//KvRM5RL7Nv34uk0yMcPfog//bf/k5nTvyRj/wu09OjHD/+mc75uuGGcTKZQQxDUF7jCjiubFutJRYXx7HtKoODN0eFW2FVqzoGBDebFrqeQdNSJBLF932e/IFJyHHEu52FhWMdhFx//4FV93nwwTy///tqdFJVDh+eRtMSpFIltm37MI3GJIpiEoYh7fZShGr2I25wimQyj+97WFaVt976KsL4IY9hZJifHycIhNl1Oj2I73s0m7GXMYBOIpEimezHtuuRGo6NbZdJJot4nk2rJUwlNC2LYeQoFHZgmllsu4ZhZGi1FtH1BLqeQsxvFSQJajXxPmy7iqJoLC2djvh8PrCM53nk88Nks0NoWpYLF15AljU0LYOiLOE4DWQ5TRjWaLWEm4vjQE+PQeyzLKJ7pyyzQocII6CYqJLF7rVbmo/O/To/dVV7l1oo43bj2gX13VjI44SyERp6PTP71dX0auxAd8zM3A4INa/NqmR1x5Um4/j3a/0ZvdfeyNcqNuOtfWWmEZuJJOIa8Vm5bnw8r0WjAWJ0JkeALwtoI8vQbApw1tmzTzA0dBhVTVCv2wh9eDlycNNwnDa+302bamPbMpqWQlFMJEmKRH4cwjDN8eMf5+GH/39dSOovcODAk4jNo0QymafVmuscp4h44702KcemEz7j45/n4Ye/Gj3vr/PQQ3XGxr6x6vPzfcF7XsFhPMXY2HcIgha6nqJQ2MHCwpsoSpI77zzGrbe+QRC4OE4bx7GYn/9rkRSoAG3Zts7P/dwXGB//DFNTH2f37pf48IerjI7+Av39hwAxO47b1a3WEqaZwzBytFplms0FNE046c3NvUUiUSCbHe4YFTWb8yiKSirVf5GYyPsRH5iEvBYZl8+PUi5PUCrtuui+P/ETNb7ylXleeKHEbbctsXdvL6dO3UqpdAPZ7FZct0I2O4LnWSQSxUgHtR9Z1jFNgWi07RaWVUaSZObnj9HXt5epqRdQVYNy+TTJZIlcbiuKojAx0YrE3U3S6S0MDOxH01KEoY+iaDhOI9qFJZEkmVZrEbBw3QBd7yef345h5FlaOhqhp0u0WhVc9xit1gKpVB/Z7PAqMXhZNqhUzuA4DqqqoOt5DCNBItFDobCHMHTIZkdYWHiDWm2KWk3YNwZBm4UFUakKEQKYmmqxZUtcuobETlYrLeo4YvRofNGunZddbPcWO0DBxYulZa38PeZBb2ZBvRYRJ5a1aOiTJz+N66a4884v43nJVYm6u5qO/14u7+T06Z+MPq8Vv2sINqWS1R3XykFpo+fZrPHDpVrc12t0v+8whERi/ft1A/Y+8YnfvIZHkEaYMnSHE3WbRPi+SJ6CnhiDIz08z46sA+uAj6blUFUFz/MRVoguqpokDPMdRDY4NBpTUcWZiyiJYlN9+vTta1ry9zI29i3E9exSqZxHURJRWzuOGMQZC5U4F/1tYuK+Nc97f1Q9rwZ1XqyI9lkOHnyMVKoPx6kRhsI7Ppkssrw8gevWEbrbFlu3fp8gGOt0OLdvfwpFSXDbbW9yxx1H8TybZnMbnud3xpTdoh+Li+MkEiVSqV5ct0Eq1YuqmlSrk5w//xTZ7NbOY4SSo9dJ0u93MobrOCGvBXF1t6wtSzifrK2M40gmS3z+80v89b9u4nklzp0b5Z57/iHZ7BZ0PcX4eEAQBORyWyiXz0f+xkvIskyptJeenj20WgtksyM0GjMEgcv8/AlarUVsuxK1SFwymQGCwEVRVGQ5h6LIEd9uCVUVbaWhoUM0m1Xm5t4kkchSLN5Is7kULR5C3adanSCb3YoAX7g0GjM4ThPPE7rUolWskc9vwXVt2u0lbLuGaeYJgjK53CiJRK4jsu66dcrls1Srp6nX53DdJrKcQNfTOI6MooiduxALkEkmHcRFLuanYdjt3Sp4hSLEBV+pCASvJNGhO4lYrZudTEKttr7JRLu9kojf7SS82WTSDfIKQ3VVhbt790pVpWkt2u0UIyOPs23bE5G2ddy6jkPutMDfSTJ7N1vK72RmfKWyn9eDOtjVmJhsLhxWJyWBmhYhWsKKkiCT6ScIAhynieu2iP2DLauOEOxp4PugaUqElm4Tb4I9z0XXDXxfx/cbkbWgMIsQ3GUTz2vi+zajo4/w/PO/tqYl73SOR1UT0WPXRrzZXrGG7N7AiOf99c7z7tz5Ipo2gKIIVyeRuAMmJh64aEZ/5MiLlMtn6eu7AVnWyeW20m4vU6lcIAhkFEUjDGVGR/8Tv/Ir45w4cRM7drzA9u1fRVVz0VorzCp0Pcnk5FOYZobt2+9dNbKMpUJTqV56evZ18ofnWaTTQ+h6Nlqjy9TrM9h2tcNfvh7i+jiKdaLVWqLRmOnokgIdacx4Ad9o+N7dvqjXZ/C8Jul0X/SltRkaOkK9foFGY4RGYx7Pa0WtX2Hy7boumpamVpvGspaYmnqOsbHPIssymcwAy8uncJwG8/NvoShJMpkBVLWKbbdwnBrNZgZF0alWJ1EUjVptilZrgbfeupeJifvYtk3m8OHnonlyk+XlM+h6ElmGdHoQ265HuzgFy6qzvDxBMilm26lUL57ndjSsBVBBJpXqjZDbMDf3FktLQskskcijaUmy2SFU1eDChTcIApFQRcKPPzU9qoxhBbjVnYyFZGajIebBiiKS6cXt0tWIpGx2/fO7sQjJ6rgUQOhSSeFK5qrxc4i2dAzQ8nn99S+tojPFi/daf+RYcGRpaR/l8l7iWeJjj/3v/PCH/yc33vifeeCB397cAV3hMW/0Xq+lFvWljmNtXM/V9bsH5lrbKQqR5SSKIkU8ZA1dT6JpCZaWTuG6dsTRjUdDFrYtKkZVNVAUIwJoGWhaFtetRTPfEF3PoigZFEVspoW6l3CGUhQFx7EYG/tGtHm8n337jrFv38u0WrGphYxlzaEo6Uu8H1E5r1fpPvTQ5zqt6N27v44k5TDNEsLUokwQ+NGMfgXstXfvm5hmKRJEMtiz5yfxPJsLF17GMJJIEiiKkOaUZY3du7/Ozp1fxfcFLiOZLKIogtZlmhkMo4CuZ/C8NgsL451WczJZirqNGWAFd1SrTQNQLO7sJOxkshfPs2i3l2g2F953dHUc7/8RbBDJZIl6fYZWa75T+S0vnyQIfFKp/g2H73Fl7XkWlcpZstmtFIu7o9msaHmn04PRTOFNZFkjm90a+SwHERqwh3Z7nkxmAE3TyOd3oCgGrtug1SqjaUkcp0673SAIKnheG1k2ER7Got3TaCwi2r8qqlrgzJkP85Wv/GH0Jf0lVPVvcuDAD5FliVSqD5AZHr4TSQqZnHwGyypjGCkUJU02249pFnDdGnNz0yiKmClnMv04jkBM1+tTGEYeVTWpVCZotS6QTA5QLO5DUTSEafcZkskiPT021WoLVRV81WLRjHRnPWzbQtcT0Y439muNd/sO7bZI5oqyuh0tIm55rZbVXP880bUZELHZVu61npnGz5VINKMqV9jWxYpeceLVNC7SPo7nz6dOfZbVc3ei5AxPPfWPAC6blK+Eg/t+J7krAZW9X8Iha+O9MDER4UWa8i7gEAQpVDVFoyEUpRKJPJ7XQpZ1ZFn4oCuKhK6nSaf7qNXmkGUT00yTSvWzsFAH2niejyxLuK6PJNUJAjeyIkyTShWjtcDHtqUIwf8DcrkRPE9BkkzCMO6Ercx6LxUXV7oP8IlP/A8cOvQ8nmfj+y6Os0gQOFHFLRgXY2Nf5557vszJkw+ye/cP2b//hyQSIySTAwwMHKa3dx/V6hTZ7BZ6e8cIQ5kgcCkWd1Ovi+RZr09imiUkCXbv/gkMo8jp0z+g3S5j2xWWlk5Ga91ktL7lI+MKFddtR2uySG+xXKZh5CI6lghhFVnH9+1Vif39jOs2IYNIru32MkHgkU73d2yzLrWbiWfNAgQhWjnF4s6LWuC1modh5Ekk8hhGisHBI6hqgmx2K77fplw+he+79PbuY2joVgwjw8JCi0xmEICenoO0WlPMzLyG57Vx3VpETdJotRZR1SSyrJDJDOK67YtceI4fP8KePd8gmexDVTVU1Yja5MM4TisSCVBRFGF8nsttp9mcRlEMCoUdqKqOYcTatm2azVnS6X7CMERRDHRdbDxSqT5ct0mrtUgQhGSzAyQSOWT5bERzEohp264CbkSZaLNiIBEiQCseoKBpHsLQYi0AS9g2rsyfLVYAIxfPlpPJlRmyJL03oKTLvYbrCpWzlVk5nfO1Irm5Wvt4LeBLRPcsWfx+4sSDFyXkjar+K31v73ay24xS12bj/aDBxXHtwVyXihj8CODgeTUgiaalSCZ7aDbnCENIpYqoqky1Ok25vEi1OkMiUUTTEphmMVLliq1OvSjpyoShcINTFAPDiM1jVBzH7npdm1rtArKsRDRGnW5r1ctpqa+lNY2OPgkEUZW50t7yvNWiIuPjn45AkR6zszczPPwCt9zyKoODtwIyFy68Sj6/hVSqj507P8709Au4rkUm0x8VJyGDg7dRKo3iOE127/44rdYSYShx4cLzVCqT1GrzLCwcpadnjESiwMDAgQ6+yDRzkTCJ15HLBDHuLJcnxNmJKLQxuCsWXXm/JTSv24Tcai1h29WIliQOM25LXGoXo+spFhaOMTh4GM+z1yWKg0jqO3bcj+/7GEYqcgoRu6dyeYJnnhnjzTf3cP/9Knv3CtOK/v5DLC2dJJ3uj+bFbXp7D6BpZ6KkOBe5NQnTi3x+NLJNkxkbe4knn/ylLorNYwCkUgV6evbi+z5h6FMun8Y0c+RyI2Qyg8zMvIimJRCSlyaGkcNxmuRyWztzkYWFt1DVBL4fIstCojOVKiFJPq3WAopidj4zVU0AErncIIqiRi19wUP0fRfPCyIuLqx8PWJlroB8HsplUVkDZDKwwosMCEMPWVaQ5Tyet9T1+IvjvV6QL1WpxaYQ8N+vSq4rP0tdPwckk4scOvQfVgG+4m7C4OCPmZm5o+vZJXbs+O4q9ayrrfrXUwV7NyvQd9M44v2onK/GxOTqYvXoxnVdXHeedtug2VwknteK6zVDjL0IAg/ft3AcC9+fjEBhsWiHgizrKEoCw0iSSg0gyzKtVo1q9SRB4ERr2AoVUWhlgyQpkZmF6N7E7ehYAOeee77MAw/8zqpjv3gD831W5swysYOUYIOA4zQAa53RwP3ceusruG4zAl0VqdenyGa3UatNMTn5LOn0ANVqgSAISCRK5PMjaFqSMPRYWDiOqmr09++lXD5BuTxJtXoWXc8TBBZ9ffuIHf8sq9pxemq1Fmi3yx3DCYEVWsQwMh3JTFlW6e0d6xRr6wtQvXdx3SbkZLLUceTo1h+N+WbdH1j3h1guT2BZZarVqQ1BX0A06HfIZPpIJnvI50eZnn6BSmWC7343zb/6V7+DJHk8+qjK3r0Nbr/9DWZmXkPTMjhOlVarGc2YKwhgRi1CCkpomkk63U8y2RO1oKb40IfO4Pt/m/HxQ+zY8SwHD75ANjtCPr8TWRYgECHy0aZWm6FUSuJ5DsXiLlKpYfr6xpidfZPz55/CdVskEj2YZgbHaZHJDOO6TfL5EarVcwwP30wshyeQlCG12oWI/1yKEv5WNC3J3NybOI4V2T1KaJrQ3FXVJLbtMDOzFJ2DOPkqtFo+liWq3ExGA1Q0Tcd1PSRJIjYPX4n11bxarZUK+VL85Eu1cq+Fp/BGphDAqp+7wVutVg/PPfePGBl54SJ3q7vu+l8BePbZf0Cr1cP+/Q9z772/HQnHXP441r7HOMbHVyuLbYZWdSVc7e64HlrMl4v4mIPg+tZQj8FOwnJRIZXqJwwd2u0Gvu/gOHPEcpeqqhOGHmHYxPf1KCEbgISuJ6IWdRbfbxEEHo7ToNGYiuiIKdLpfnxfotW6gGnmyWYHO90xQXUSiXpi4n66BXCeeuofMTz8wkWblfU3MD5iAyE2947T6vpb+qLRwK5dz+M4DaanXyKd7iWbHWZ4+HaazQUWF09hWXXy+Z309x9icfEUum4gSaKrpihmNE+XyWQG6enZw7lzz0Wfi0dv70F830XTFMrlCdrtJSCkWNxNbMW4tHQq0kIQXdO1xVn3743G3CoBqvc6rtuEHKtuxRFXuiL5rv7AKpVzTEw8yejohzs0qPXoUGuj+76yrDI4eIRkspdXXml2vkyy7PODHzQoFL5Ho3GBTGYrtl2nVptmaekUnmcBEr5vE4YOimJSKu3mzTfvZ3z8MDfc8Db33OOgKCr33nuWu+8+QbO5SBDksKwms7OvkUz20GrNoapZXLdOqzVDvT5LLjeAYeTJ53dTqZyn1ZrFcZqRHzK020ukUkWSyR5Ms4ii6BhGnlRqiKGhQ1Qq59iy5TZmZ9/k9OkfoigmzeYCum6iKAqNxgU0LYFhpFhYqET2cRYigWrMzTUxjBWv40oFJMknlQJdB1WFatUll5Mj1KiCJMXt2hggtjbEhdZsrrS7Jeny1dLl/natgEsxDaqbqxzHF77wGZ555h8zO3sY8V5j/1xpVUVw/vx9PPDAb1619SGs/3lcypBio+fY7GtdSVwPCOvu15fly4vOXF2sNVnZbKwwDVYigaoaJJNFMpleZFnBNOu02xXC0I5eSyUIPDxPJG8x8xXjESEGkiGd7sN12zQa5Qix3YqoUAapVBFZ1mi1ZhAbgBDDSKPrSWZn3wCcTpta05rEyTgWwLmc0cTq9nbsix6y1qpxbOw7qyprz5P5+td/mwMHTvKRj0yiaSat1jzt9hLl8mk8r00q1R/NzXMR+nqKfH5r1A1IU6lcoFI5g6YlMYwklmVSKIzy8su38fDDW3ngAZWf/ukUrVYBYBXGKJksYVnVVaqO68WlJDbfq7huE/LaiHcxAhlXJnb1ANFirtenKJcnKBZ3XrIy7o611Klsdphy+Sx3393k299WWfFPXmR5+TSSBIaRo16/QBA40Y7VIJ0epFqdotkUdl/Hj3+G/+v/+k1k2ef73/8skvS/ceDAo9Trs2haqjNvFrxgM3o+SCYdcrkteF4zUtYJ0DSTWu0chpGNQFqj1Otz2HYr4tmVolbMcqQ4lqDZnKVevwAE6HoBw8iSz4/ieW0qlXM0Ghfw/RBNM1BVg0xmGMtqdyhbYkFxURSRdGMAV6y6FXOGfX/lZ0HDaOH7HrquEAQKnhfToLo1r8X/3YCuzaCtLxebNZp4J3Hw4Dc7WtdrgUHdFcHOnU+8sxfaINb6LHcbUrzXNoqXmitv9DlfqXHElUT8Pby2sZlkHCdMWJnRrj0ZApMgSQGOY1Gvz0SgRpVMppdmU8ZxBN1Q4DqEDrRhJHFdK9Ku9nAcC1k2otmxhusGkWqeRGxo0WjMRQYXLo7TYmHhJK7bJAgu1vDev/9POHr0Zztdn41Abo8++k8jYKLfQVuPjT0WvWZ9zb1FBd7tqvXww18DAp5/XmZg4D9w330CuCUsJoX5hbBlzOH7NopiYJpZ5uffJp3up91Ok073RO35ZcLQp1jcyfT0r/I7v/MpZDng935PRtPafOELooiLrRWTScFDTqfFly3+f71YK7H5fsQHJiHHbWnLqnDhwgtoWoJicScAg4OHqFbP0d9/wzsynG61ljCMDD/90zbF4qs88YTExz6WYMeOrzM355HJDDIycidBIKpIRTFQFJWenkPI8vMYho7rOrz++ugq6c633trDrl1/HsnblVFVocGdSPTgOHV8XwjKa5oAag0O3kQQhGiasF8MAp8gCNB1HcMoYBh5FhaOYRgG2exWdD2NZVUjfesMjlPHssosL5+mUjnP0NBNQMC2bffRbv8FrVaZIBCI6nZbod1uoKqgqikUpYYkGfi+hKouIkTpRdK0rJVEallCfEFUuV4EChMLk+f50VzMJww1fF8AxoT2tQo0CIIVZa4YIPZOZ4obJeXNOAZdCqjU/fj1gEGWxbp+vNcySV5KWexq4t1QP3s/Xvf9j7h9G1eMsamCz4rIhsBfCCe3Kq6bRAAkU+h6KrJaXcJxYgc1wS/2PJlMZhjPc3GcZsSqqNJsVvB94QIl2rA6qprEsuqR4YRgRwRBC8dRo1HaxfzgbHb6siC3GKC14u7mMzHxEQ4efBrf9zl69CcvCQx75ZVfiX4SO6Y//uMP8eqr5zl06DT33TdFPj/C8vIZarVpdP0ompaMlAtLtNsVqtWpDgMmn9/C4uJxHEdU1G+/fQPdVozf+c4iX/jCVuBiR6fNxNU85lrHByYhxzPk+flxarXpTjUMRJVnmhMnvsPAgJBTu5r+fzzUlySFj31sibvvLrO4eIxWa5FkssTQ0M1UKpMkEkVyuQBF0bHtNmHYoq/vRmZnX0KW2+zY8TRB8IVOUu7t/WoE5HAJQ40wBFXN0G4vYpoFEokcmpbCcaqdFo0kyVhWFU1L0W4v4/s2tq1h21WCwI1ETpL09R2hXB6PBOhTZDJb8H0X27apVifQtCQgk0r1AyGFwk6q1QkkSY4SbxvXbROGGYKgRRBIaJqPaWYJwwwLC/VO9dHfvxVoc/LkYicZZ7MyK9ZtYgEKglaH77f6KyYE78VnLdqMriuq8Lh9/U5aj+9kDroe33nt8548+Wlef/1XkGXo73+TiYn7O+C2GGjV7QoVm1FczpbxSswYLuezfLnYiLP8fqKfrybiY47HIhspc13biCvRtUAABfE9F5Vs7EIXO6VJkhZZKdYi6coePM+N+MM+tdoFPE9HoKkNYq35ILBptRZx3Tbg0WioKIqKbVcjJoToPAlP9SSe145uj0GZHpLkoyiiK7eWHxwn4ZVEmkQgsFfa7WJMEoveiKQ8OvoYrttkfPwnePjhr12R0MrZs/s4e3YP3/72T+A4/wcf+YiNYWSxrCXq9WmSyV4MI8fu3R+lUtlLOt3L7OybtFpl5ubGqdenIoxODzfdNMmf/MlNKEqA7yt88pM9nde5GpOI99tYAj5ACTnetezYMQCE5PMCZdxqLaEoWkSP8mk2F0mnB1aJjW82Ykk1SRLgJs+bJZHoRZJUdu/+OO12BUmSqNenoiQWIEkulco5BgdvYmjoNhYWjvLRjy6xd+8TPPNMglLpYbZte5ww1Egm+7CsKpIU0mhMdQQDDhz4G/T07GZ29k1su0WjMU2tdp52exnDyKIoCcLQx/djZa/zeJ7F6Oj9KEpItXoeSZJxnAYLC8eQJLkzSy4Wd5PJDOF5TUwzh+dZUYs4pFAYJZvdRaVyklZrAcsyEN6pAbLsk04Xo0+mDujk8wlkOc3evR5BYCJJHqoaRo5RAQLclULTjKgb0GRFkk+85upzCs3magrV+nPny8fVVKNXkoRiFa84hLm9Txj+99EtfgdodfDgNzcEYL2X3OKr2ZBsFNdjwn7vj2OjL6eH2IyarLRw4zmMSxj6qGqBTGYsAmLVsW3BI3bdJr7voaoGqppFUXTabYFkDsM2rqsRb2Itq4ammSiKThhKhKFPGMoI20Y7wnGEXcepRsIkDuCzb9/jPPTQQ0xM3MHo6OPs3/8EQWCy0mKP1fpW3ucKQEsk5Xvu+TJjY98GlIsq7lde+dJF1fKRI7/PiRM/xQoye6XSfu65NHv3vkR//404jrCINc0ixeJOCoUdlEp7opm6w+TkC4RhQKm0m+3bH0BVEwwNTfIv/sUPOHHiCJ/8ZA+f+Uxi0yjp9xtNvVFcP0eyyfA8m3S6l3p9BsuqMTv7Kp7nRXaFTjS4L1/1bidO/NXqJK3WHK1WGUVRaTaXyGT6mJ8f58KFVyiXzwEuhcIuSqXdOE6bUmkHnmcxOfkMo6N/zL59eS5ceI3FRTWiLKXJ54dZWjpHEDgoikY+vx1NMyPrNR3fX8C2ayiKhqZlKRR2o2lJlpePk8/vwrKWabXKeJ7F4uJbBIFDozGDqqaAkHZ7OQKO9LO8fBzft1hYeJNksh9dT3UoVa7bjriQPpqWQpYVksleMpl+Wq06YWhRr88jEmoCRTHJZrewsHACSVJJJrWI4iVM0DUtge87hKEVtdr6qNdnEBd7gtW85NXRrWX97swCL44rpeCcO3c/q0VSwi6pzJVFJgZarQVgTU/fx8GDm6tsr0Xye6/pStdjwn7ncTF/fqPvsKgsDVQ1E9EI42o5EW00ZZrNRTyviedBGApBHwGi1NH1DIah024LxLKiGASBHnGI1YgOlEeSFAwjhefZkcWgaEe7brz5jSN2cPJQ1TyKksDzWpEZxLdJJov4fiLSzxb3Hx//yah9vZJQN+Juj48/yPLyts73OwxVTpz47EXVcvz4J55YAUPG18vWrd9naekYAwM3cvr053n++RK3377ATTf1dt5FTH9VFIVsdphUqpdcbgvz82+jaRl+9meL9PenUdWV+28GJb3e/eIkvdbS972MD0RCDgKPubm3aDbnSSSK5PPbI3GPKZaXJ2i15unp2YdhZEiletH19FXPAeJEblkVwhByuS3U6zOYZhpVTbCwcDTit1Wp16dpNsvIcoJUqkizmeHRR3t49tm/wYEDR7n77nEajXl838X3rUg+LxPNhm0SiRyGkaXdrkTcuRBdz5NI1DGMEWq1GYLAi5S3lrGsV2g0ZoEAVdVptSpI0lna7SqK0ojkNUts2XIHzeYii4tn8H2PdLqPbds+RLl8FoDh4SOUy6e5cOElUqleMplBkskBZmdfoFa7gG03UBQD8JBlDVmWI9nNlyIepI+uZ2k2HXy/ThCEqGqRIIjR1nVct9klEgKalsN1l7s+aQXRSnc7utbvhkDIlcZGc+jYqnElYrs6mZWqQukArdYCsC6lCnWlVoaXi/eD37329/f7PF6bEPNZ8V2Nfb91xHlfm6gBbDxPJ5Eo4rrNDgMjDP0u5DPIcorV5i2iyq3Xl/C8BrJs0tOzn2ZzNsKYBBiGgaIIOU7hqSyhqnpkp+qz2pdcj45PmEmIa1KKkrYDSLRa8axZxPj4p3j44a+v235eS32KQV5CJAf27PkWYShx8uRPdmRnn3jiH3c99ntADIYUlfa99/5LxsYeo1DYx5kzX+S3futOZNnn619X6O8/zk//9Byx331PzxiGkWN5+TSyLABtiqKTTveQywmziBg7tNk58Hr3i5N0s7nQGaG91y3sD0RCjs0flpfPEoanKBZ3sn37vREHb452e4FMZkvHseOdfohB4LG0dBrHqfPSSzfz1FM38hM/keH2219jcvJZ2u0lwtDG81o0m/O4bpVWK+SJJ4b45//8/4Msezz9tIph/GP27p0mmSxgWXUajenoIgXDyJPJDJBM9mDbgo8YBC6eZ0fi6ztoNOZYXj6BomjIshoBn6ooioq4iEMcpxEhE9NoWoZcbiummWNu7g3a7YVIIERifv4kYWiRz49SLI6wsHCUMJRw3TaGUeLMme9Src7Qas3i+2AYAen0MK5r4fuNaFYurOFk2Yz4zXaEALVpNgWqW8iFpjAME+FoEyIM1yvRpxuTdlUMI4dtL5JIrF3cupGrm4t3ew4aA6pef/1LACiKzezszVSru4gT8513fnldM4q1gJnVgv1XNw++1Mz7r+Jahsdq4wgdsQGLK8sE3clQlkNct00i0U+7vUAYStFcd+U7Lq4ZITajKFkUBXy/iedVor+7uG6VZDKPJEG7XQZ0PK+B76v4voVtN1EUg0Sil1rt7Jpj7nZpk6PNbjz/Jvrbaoemzep8d4O8Yh/wQuEMo6NPdI1xFGZnb+Lhh7/Bz/3cz3DgwKOMjf2Ahx76GSYnH2DbtifZu/dhDKOXUmkPX/96zypw1hNPSHz2sxa12iTF4m6y2eEOdSkMfdLpAdLpgQ7bZm21u5n1f708sdbA6P0Ad30gErJAJJcoFMQswfetSGKy0ZGFbDRm6enZTbtdfsdWWuIEz/P972f5Z//sXmTZ56tfVfg//o9pDhw4QrU6TaMxhSRpJBI5xsZ+mpmZH/PKK1uIPZhl2efUqdu5886TJJMFpqaewveF2paiKFFi3InrttE0g+XlE7huHV3PoKoZms2ZaHfsIssaW7bcjmXVkSSFVmuRVmsJSQrIZoex7Rqp1BAHD/4Mvu/h+3akRtNDNrsVx3E4efJrqGqSvXt/knJ5kmx2G74vlMbm51+LqnGXRKIH2xY0CddtYdsNgsCOrB/FfCoM3WiGrkXvV0KSdMJQLEx9fWNIUhBxH/0okYvqQFFSUZtOgOc0LR/NoLv1r9Xo3+U1sVd/Ty6+bbOCIptJ4DGgamWevHrTMDT0wqrf1xNVWCvYfzWeyVcb18rj+ErlPT/Y1bJC7IImpHi1yOghjvhnGTAIAoUw9HGcGpqWwHFcFCWD7zeJFe8EoFKI6ciy0Ji27dUUq1pthnS6D9PM4/suhpHDdZskkz0IxPaKEpfQqe5+fJyMkx2jhSBYK+cqI65J0d3ZrM73WkERkNG0Vqc1/b3v/UsqlV3Eyf/JJ/9HDh9+krfe+jznz9+LolQ5e/ZWwrDBvn2PMzv7Olu3PkIQ/J1OUr7zzjq2HX/uIiyrGhUXQp9CYIfUjirXteAOdyfpS9Gj3s34QCTkuCrs7d1PMinmC4XCKBMTT6JpSZJJ4XRkWfWoPfTONEmTyRKKYvLWW2Ordm7PP58jCO7jxz8usH37U9x55zipVA8LC2+gKCZ7977C97//OWKD7cOHz5NKFahWJ7FtJ0JLNpDlkHR6iEZjFkVJ4DgtcrlRyuVTVKvTBIFLuXwKw0jS07MfSQpYXj4V8QnbmKZAaMuyiaqqGMYWBgcPMzf3NpqWotWaw/cdSqUdJJNFqtUL+H6AovgsLByn3S5jWWVUVWFh4Vgkn9lG04SIgJC2E5W9JCn4fhvDSNNs2oQhaFoymne3CAJRHeq6aMMJCdFlUqlC5/PU9TyOU43ul6HdFvMuy7qAqDiEqthKFXFliXijuFwr9WoThZgnr16U1hPquBpxj7XI7BjotlnE9kZxtZX0ZpDrm7F7/OAm5YAVaVg50m0GAeCyAANZTpNKlXBd4d4mNOhFJa2qwtVJlhNREnUxzQKGkaTZnI24yTaqquK6seRlAk1L4LoWrutH146YHZtmCk3L0m7XabeXse1FVryQQyAVPYeKricIAh9VTeA4y9Hxauh6Dk1LEwQW7fYcAGNj311lLyoSr4iYunTkyO93EveKXrsf0bjEBvSVV34lSsgipqdv4ZFHfocf/vC/6UJrCz7zL/3Sr7Jt23keeGCRw4drPPJIiwMHTvKpT2kYRh5YYb4IXerejo9Bt1DU+80dvpbxgXgH3f3+fH4EIHJOURkauiUixxPRhZRrslMaG/sU99zzON/+ttJJyppm8ff+3iej3+/kf/lf/owDBx6JKr0UH/7wcQqFr3D69B3ceONJdu9+kTBMRgYS50ileggCkZhlOcS2m/j+Ioqi4zhVHKeO49SAMKI15THNPJXKGarVC9h2BVVNYJppisXtgIwsmyiKSq02iec5FAp7SSRKZLNbcJw2jYbg8RnGjdTrk0BAu70YAUIkNC2BpiUj0wwZSQpot8uEoUIYeuh6Gs/TCMMwokSl0HWDnp7dlMvTVCoTgI8k+eh6IRojXIjUg4QhRRAEGEY+kgSM23VxW81mdTJ+/2KzreS1KkfdRhNrY20yWluJdIuIdPsxx8hsgNdf/5VItnO189R6x3o1tosbJd2rVeP6y9VGF5aFkqSjaeno+hSJWIQSKeUlsawFgqAJBLRaVUBDlpMRc6FFDLry/RpBoEXI6KCjNW+aBSxrCU0zo+s6wPcDPM/G8xaAgFSqRKVyHkVRUFU9el6hK61peiRbK9znROu8FFXqNXxf2KkGgYfrtqJEH1fT2ip7USHk0Y2ZEMyChx76DPfc8+XODHmtoMgKqnpFAezYsXu7dOAF1kKSPObnf4pE4iuUSts5cqTMkSOnIkR6hlptkiAQspeJRIFWaxFJUjqF1qWEoj7I8YFIyBv1+/v6biCV6iMM/YiSxDUzm9b1NH/9rw/iOH/E669v50MfsnjySX1Vxfzqq1v40Id2kM1uJZcbIJHIMzoKxeIMy8sLzM1lSSQKeJ7F0NBhfN8jn99GtXoOWTaoVM4RBG4EoJJQFJNcbpRSaS+yHDI19QKKIpS3BJ2oF9uuk8+Pkkz20dOzD9NMs7BwgjAUu0jDSKCqeqSB3curr/4hqVSRWm0WWTbwPI++voOYZg5dzyFJUgRSq1CrTaOqiYj6RSRy7+A4FoqiYJpZZFmOJDZdVFWP+I8WqmpGyVa0wHzfJwaXqKqG7zuR73TMRY4Ryu9+Ml7tSrV+bGRev15yWVo6GP0knjSXO8tHP/obm6pcL+U4ND29unqOHaY2dp7amP/5TpLiB7uifSexVvIyTcwJFt9tj5UxRTyDtWg0zmLb2UghS+A7RPL1o+pVYuU7bqDrRTzPjUCPAb5voSg6pdJ2FhfFBsD320iSHs1IZwlDG8sqs7joIcsSppknmSwRhk40ppIIwzBqp8drQRLLiiVxQ1Y2EUSV/EqbW/gue7zyyq9Gt3TPm+OLJ2Bi4j4+8YnfZHj4BSYmPsro6FMRaCtugXd/lhCGCrt3f4/p6QOrKuQwVDl8+DzZ7BYMI0+zudCxy00kCiQShagwEJ+3JIkCYW33U9BIxf/vV5v5WsYHIiF3Rzc0Heh4Jff13XDNB/H9/Qf44her/NzPNfD9gErlHH/xF/d0kvI997gMDNwYtW89VNWk2Zxhbu7liP+n02otAhCGIYlEkUrlPK7bwDTN6GJxO0YRYegjywa53BCVyhT1+hyaZqDrGbLZbXheu6O6k0z2MDp6F47TwvMcWq0lEokc2ewwjcYis7OvoesZkskBFhePRf6rEqaZo9mcRZaFiH2tNo/vWwSBG7m2uBhGEVk2sO1lXLeF79fxfQkwSaf7CIKQxcVTCKtHLTJW17FtB+HxqkYITAlJEheJrqejln0sPBBXylerF3z5iFupcTK+VJLZCNSymVlzb+9bV9RG3shxaG31vNphCgQ3dfXtlwLgvF/xQRQaEdGdjHXExjFOpEL2ckUeM54ri4TtuktAGk1Lo6qpqCJtE4Y+nlcn3oBKUjpCO4eRIMYi4OA4HpWKiqKkOvfXNBMhualF+AwF224QhkJ8RJISkXubjec1Vs22E4neaKRU6xLpAZAJAh1dT+M44vjHxz/DuXMPYBhtFhYOsjpWz53janhs7FvceOOPIy50JjrmIGpvx+yDgL17v8F99/0OAwPPMTHxYVIpBcPYzg03HOOee2YwjB6CwGN+/mhHJtSyKqTTA/T3H+hwhWODobXr+/WgrnUt4wOXkFutJRqNGRYWjkUJTKGnZ98qvdJrFapqsn37vbRaS+h6ir/5N8cZGnqdp57S+YmfyPDQQ7eysDDeoWPJssKFCz+m1aphWctY1jJBAK3WHP39N9FsLkTOIxIjIx8il9vK4uKJjkpNIiE4wo5jY1mLaJpBb+9+NC2DqiZYXj6BLGuk08OEYcC5cz9GVcWFLssSc3NvYFkNFhffZmnpFIXCNjQt3dGn7um5AV03qdfP4ThtPM+OwGFa5Ew1RCKRQ1F0FhdPYBgZcjmJZnORZnM+ohwIxxrbbuI4QmxEOFsVIwqahGkWMM00mtZCVcG2BT9ZVSUkKdUBpKwIKmiseL5e27hUMuhOGpcCtax9jrViB4cO/cFVvf7aGB292G0qblUL15xvdF6r+/a1AJzx8U9z6tTF8+ZLWU9udOxXm1g/OEl4o3DW/B503W5wMc4hBJq4bh3XrQF6VAHHfGANRRGbT9sWNKREIsPKJsDHdR3CsI0sK/i+E9EPPWRZjjjJQaQPL2PbFqoadOR2hXXqSkL2POE+t16IqjMkkchy9OinePjh319Vva68X5l77vkyc3MHkCS46aY/iDZ+GqqaJZ/fFhUVAb7vcOzYJ6LrIg6Zm276A6DN2NjX2L//Efbu/RQ7dyaYn58kCAR9c3n5BMvLp9A00VEUm36vM4qEjVW0rgd1rWsZH7iEbJo5FhaOoWkJFMUglRKG1LWaECyPh/7XKrpP+PDwLXzxi3N85jOzSFIFWJFq87wWx49/G89zSaf7o2ozZGHhaATcqiLLGo5TxzByFAq7cN06YShmyZZVRVU1UqkhZDmMvJx7OyC28+efxLZbKIpGqzWLZYnZs+fVyed3Re0qH1VVyWa3EgQe/f2HsO0ajcYcpdIYo6N3U6tNYllNwtDF9z0qlbNY1jK2vdThRi8tnaLVmscw0gwP3021OoFlDRKGQlJzcfE0vi+QnjFPGcRmSbSmLVS1h1RKjRDbFo7TQJIS5PO9aFqW5eXjeJ6OqsqRVragT4lYzy3n2sbaJDQ6unnz+u628/Dwiqb0tUhCa6UxN9Ku7r69e4bc3Xq/EoWw7s+ju73/fifW66/S7la2gtUUvZWkLXyJ4ypagBZFd2vFDc2yml2PFwlbkhK021WgFsmyKhiGkL2VZYHx0LQUhpFClk16e/dGlfBpGg2LeBz01lsPcPbsXYyOPrbmuxwQhk0cxyebHeb06bvXme/69Pe/xn33/ZOOQUQ3yAsU8vkRRkbuYm7uLRqNWTwvxcTER7qeK2Dv3rgTFONU+unruyEywTGRJJ2BgYOcO/c0qprpAOFkWcWyyrTb5feND/x+xQcuIbdaS4RhgKIY9Pcf6JDCl5dPsp7X5bUOwfF9C2H64CEckBROn36cdnsZSZIYG/sU5fIkb789gWn2oSghhcJuyuUTJJN9FIvb6e3dQ6s1SzY7F/mbtgmCAM+r4brJyGYsE7V6LdLpYTStjG03qFanyee3IMsa/f2HkSSVIPBJpYqoaoogmCOVGuxYNWYyA+za9QCua7G4KOzOSqW9pNN9CJBXGssqo2lJ2u0lfN+OlINK1OsXsO0mxeIekskc7XaLVktQy5rNRcLQxvddarUZVFVHljWElF8bz3NwnEq0kRCgk3x+F5IU4jhVwlDMo5vNCmKRulhL972MKzGvv1Kj+8uhleOqVtOauG6qU91upF299vZ47nu1CmHdQK7Y6GO941z7Xt7NJBkfS4w0f/9n27FzWXesz5dPJoexrDK+H7unyZEpjRlRCJtRpRon8SDi/FtrXsPHti9EP2dRFA3fD2g2FzDNYqSDUKfZnEUkY6G49fDDfxphDP5uB2Ow2kLx29h2jW3bHuHpp7+0Zr6rRMn4O4yP/9Q6etWPEYYuhlFC1+P3EjI6+hjPP/93O9+/W2/9L0CKXG4LpdLOqJhYiHQJbLLZHmq1WdrtMun0MK+8cjP/+T/v46Mf1fnwh88hSRLp9MBfmnb0ZuIDlZA9z2JhYZww9FeBt5LJEsXi7s7P72bEFl0APT17UVUTw8hSr0/i+xbF4k5qtVmWlsYZGDgMvMbIyMdx3QqKouI4NQYHbyWdHmD//i8wOHhLxKWTyedH6OnZh+M08Dwb121QLp9jx477MYwkjtNkYeEEmcwA/f0HI4DYNJIEAwMHGRg4SC63henpV/B9i3ZbEOkTiQLJZA9LS6fxfRfHaUS0JwPLqkSymKPU6+dR1TSZjEYuN0K9PsP8/FHC0CWRyNNszqCqojNRLO7CcRosL09j2y2y2UFU1UTTDOIZm6oaOI7SdXvIwsKbZDJbkSQBQnFdG0myIhRrCs+TCYLGOp/8WtDI9R0btY3j6E4uK1XtyqIYV7djY9/EvwKNlM3ySTcba5Pge63K1e2Z/f5Ht050dxiIKjgWC5HxvDrCzzh+XHwSfVRVijyPuxNvEIntuJ37XuxB3CAIMoRhC2jRajnRdWxGrXHRSp+YuO8ijAGwDmjxEfbs+RYPPfQzTEzci6YJJ6rt259l795HAOMivWqBV/guzeYSi4tH8TybIABVTUTiHz/FuXMPcODAMQ4ceBXbzpDN9nP48C8zMfEYfX03YtsVIETTctRqFyiXz/DCCzfx5S9/Aln2+cM/VPgn/+QR7rrrFNu23dEpsv4y0JouFx+od7i0dCrinPWQTJZWtamz2eF37XW7hciBiEYkQGXC4GIZTUuTz2/HcRoYRjbSmJ5H1/PUaqcplfaQzW5DksRsZmbmDRKJNJqWiBR4bFzXwrKWaDSWSCZ7I51Zl9nZ12i1FgkCn0JhhC1bbmPLltsplycIwwDHaeA4bQYHj7CwMI4kQSYzRCrVh6rq5PMjVKtTVKvnUFWdTKafRmOeZnMWwyjS17eP2dmX0bQUqpoimSzQ13cjrVbMJ9bJZkeo1ydpNObwPJta7RyWVSMMxftxnCayrBEEAZqmoKoGvu9Ec7MwUhWr47oGirKApiUiPnQFYUJhEIZGtPDGfMxVZ+GantN3Cjy61GPffHN9Y4mNoruq7dbFjqvbK0nIl0Jx/2WLixPWuxmX2xA6XfcJsO0lZDmm4qwwCoRlax7xne9GMocRklgk9+PHP8fDD//RRUh6oYEdo7kDgqCJ43ikUgPR6zYv2pRpWosnnvifiNHNK4n128iyztjYDzl48NHIo91GVbPoem9kYPMozz//653H1mrDfO97/5xdu14ilTqKaSYxjByZTB+uO0KhMM4XvpAkn99NrXYHCwtHOXr0E3ztawUOHBjj7rtfo9mc5/nnb+DUqe3s3Vtmy5YJHn/cR5Jiy1qfF1/s54YbfsiFCwau22Lr1jtXAbv+sibnD9S7KpV2df63rOp71qaOW+L5/HaATjKen3+bubk3UVUdSTIYHb2bWM5ybu5oxE82KRT20Nu7D1VNcOHCy3iex/LyUVQ109GfLpX20G4vMzX1Eul0H319t6FpBoqSoa9vDydOfAvDKLBz53309t5As7lAGPoMDd2E4zQxjDSTk8/jum3m5t7ENHMMDh4mlerBsqp4Xpt2u0ouJzYNMzM/AFz6+w+jqoIrbRhCC7bZnGdy8ulI5lMjlepFkiQMQyDBq9UpZNmgVNpFLjeCoijMzx9F1zOYZh7TLJDNDmLbTTQthW2Xcd0WkpQBFDwvnrHZQFwNOxhGGlku0mjMREbta0PwKNdvHV55XG1ld6kq0bKEcMilxD9AcI6np2MecSy20C02oqBprc5xXgmNaSOFsPcueV2buNSmaSOa2rsXl0rGFwvZyLJJMlmg0WghvqtiV+X7RBWuUPYSbWZRdQsktUi2Z8/euaYy/UjkshSra2md1jeENJtTyLLQuh4b+160KfsYmtbs0p0WUpcrnZMgus6saF4tWA+eF6BpoGlpxsa+zT33/C889dQ/BHyOHv1ZJMnn+ecV0unf4KabniedHmTLllvI53eiKAqGUSCZzDE19SrPPz/Gv/gX/wOy7PPNbz7Af/ff/Q6el+Lf/JvfRpY9vvnNj/F3/s4y+/a9xTPPqB0Gyx13lBkauhnbrlEun2Vg4MZOdxREEXY9mEFc6/hAHb2qmvT3HwAgmVTfsza1CIl2u4xtVyLXFodyeYJK5TTtdpV8foT+/v1s334fllVhYuJpLGsZw8iRyw3j+w612jSt1gKtlnBsSiRCZmcnGBi4iUJhpGOg0W5XaDaF2YSQz0tRKu0im91KqbSXdrtMu72E47To67uBZLLE5OTzUbVtI0kSti1kNlOpfsrlCc6efYxWaymiFSxQq53FdR10PU+xuJNMZgummaVSOc/S0glMs0hPz15arWUcp0mjMcWWLR8iCHy2b9eYn3+D5eWzFIs7o6q5TTY7FPGgTXQ9RRAEyLIUzaRzVKvnCcOQdnseyzLWtCFDGo0FTDMXKQhFn/oqw4lYNemdJ+N3M1aMKIKOYEistKVpTRYWDnZQ0nEyWXHEuYm40jp58kGGh1/YdKLZqH28Nnnt2fN1jhz5/XWf93Kdg/ea0rTR829We/nKYj13p9Wx2Y2NoiSimXGb1QYkTVqtBiv83m5/5fi1XXbseILnn/9vukYPj7GyKRCUJxCCO7ZdBSyCoEoQpBEiH49x+PALfOMbv7OGOre299+90/M6t7XbTcbHf4qJib9LpbJ7VQcnDIWwx4kTN3PkyLNkMkO0WsvkciNUKpOUSgbVaota7SxHjz7YSbLConELmpbpVMOS5HHq1C38tb/2rxke/n85ffoubrjhbT73ObE5n519DZAi7Esz0mAQ670olE6haSlct0mxuOtd7ZS+F/GBSsjdIcvqe/bhx/OLWMhcUUwmJ5/FtsvYdpW+vv0Ui7vwfYfXX/9jNC2BLIekUn309OzB84TZeCrVTyYzwNLSaQwjSb0uEvvS0jiW1Y/n2R3z7VxuF55XJ5HoR5YF9zEIYHn5DLIsk0r109fXSzJZYmFhvAOiSiTy9PUdQJLkDkdbUbQIDDZJT88+du36JO12nXp9Ct9vMTn5HNnsFnp79yBJCrIslMN6e/dx/Pg3abeXSSRKTE09Q0/PQVS1QKGwi1rtAtXqGSRJjURDJHxfQpY16vUpFCWN4zSQZZUgsEkksmhakmpVJBxF0SInGo9YPMGyFimXHQxjBdDTagnvZBGbk9W8ntC5zz77D5mZub1rRrxa6CMWW4DVjjizs4d5+OFv8NBDn9m0CcXl5DoBTpz4dEd1aaOkfKnYDH3q3f7Mr/WsXMTlk/HFVfl3WA/Y5boNXLca/RYgTChsVs+h5XUfCyp79nyTL37xi5w5cwejoz+86DyFYQNFyeJ5FrqewXUNwrAG2Ahtaw9NS7N798s8+6zKamey1W5MK6EhywZB4ETuT3+26nsTfy/F/yo7djxLsbgzEuYos7x8mlxuW8chr9Va4PDhM11qhyp7975GT88Yjz22Ytu4deujuG6Lffu+w6FDT5PJDON5N6KqctQ5rDIz8yIC3T1KEHgsLIyjaYnOZxkEHs3mwgd+1vyBPfL30mA61k7tVolpt/fjeS6GUWBg4CC2XeP117+Cbdfo6bkB1xV2i65r02hM02wuks1ui8QAavi+Tz6/nVJpN5IkfIxLpR1omsn+/T+NbdfRtASWVaPdrhIEQtM2CPJIkmgX63qaWm2a5eVTNBrz2HYNw8iyZcttZDKDLC+fwnFatNvL5PO7ogq/RbO5wC23fInTp59AURTm5t5mcvIZFCXB4OAhhod7KZfPUKlMU69P4zg2jtNCUaDZXKCv70ZUVae//zC+3450sg0qlbP4voWqCgk/VdXxfTPS6h7BsirIso7rWpG0oB+J69vRRS8qX00Tvsjx7HR9OuXG1Kh2G4KomFCUaw88ulSVaJqrW9YAMzO3AUTJWGhfiwhWJZP1vGPjhH21rlBAV0s8XpSF9vbp09dOUORKwV7vNHm/H7Pyy1flsSlKd2UcR8wRTkQJs8zqZKwikraP4OQr7Nnz5+zZ83D0t7W4CgNVTROGLYLAQZbDSCnMj66XkGZzjv37H+Hnf/5neemlv8Hx4z9JPBaZmxObvZ//+b/Ovn3fxfNaSJJwYFOUJJOTH1v1Xg8ceIrt2z0yGZOlpSW2bn2Uffu+h+/fTqk0ytTUUxQKO0kmS9h2k8XFcWy7yd13n+Rf/asf8dhjLiMjj3Pw4OsMDan8/b//u7zxxg527nyGD3+4gWneTRC0mZl5jeXlE7TbcwwMHCaV6seyllhcPIEsq/j+fczNvcX8/Jv09OwjkeiJgKwvR/7rdNg3H8T4YB41mzeifrdeL5NZQJICgkDCtquUy2fwPA9VFTaI7fYyum5iGClUdWdEOXobSVJpNmcjzt05SqV9EeI4IJvdQqEwgixr9PTsji6sCywuHieZFFZlup5icfEYS0slBgcPA2AYWZrNRRynGSE1wXWb1GqzuG6L+fk3sO0aup6iWj1DrXaOuGVWLO5GURQsq8709HPU6xNks9sjgRAiY/MldL2PbHaYQmGMhYWXkWWTnTsfoNlcRlV1arXz+L4dzY1zaJqCoiQJggphGBDLm+q6SSJRIAgCfL+NqmoEgVAtSiSKLC1NEwR2Jwl7nkiqFyt6dSfjiwE3ssy7FpdrW+7atdKyXqlK6PpdLIrDwy+QSs2temy3nvC1qv7i5PXSSyuSmxtpb78XcbnkbVliQyXLl07WV0o9e6dx6ao8PseXQ+C1CUOLi7+zMqqawPPKXc8Xb+BUNC2D68533T8gCFxkWYk0qQNWrglxnQRBA8sKuP32cW644Vd44427eeKJf8Dc3OFO2/n06du54YbHKJW24ji1SFKzyp49r/LMMytV7D33fJ/77psikchRq02yuHgSzwtptRYi57cQyyoTBD6u22Bp6VRHTGj//u+zd6/D0tJpNG2YubnXue22Fvfdd45MZhvVapsgCEkm+ykWd6IoBun0cFTsHKJU2h2xQXSq1Sl0PUmjsUgyuYCmmSwtnYqKAR9VNd6xudD7GR/YhPxeS6Z1v56gXx2PaA0y7XYZWdbo7d1Hq7VAuXwKVRUkd5F4hFataAd5mGaBdruC77eZnn6RRKKIaRZQVR/fD+nvv4Fmc5Genl0EgUcikaNU2kGptItKZYJWq4yuJztKNqmUsGkrFLYRBBIQcPbskzSbM+RyI0iSSiIhnJs8z2Zh4RggEOLC7BwURaZY3IHnOaRSBWq1C5HLUwLLylAo7OC22/4Wc3NHWVo6iu9bzMy8haJIzM29ie/7eF7QoVXJchpVlTCMBKaZpFqdpl4/j65nSaX6o92ugqLoqKqBpiUpFPZgWWXCUKJWC2m3QVUhmxWCCQLRvTnIcfd8egPBolWxGVcjWL9tCaxK0HECfPXVL3H8+EoC3Lv3G/T1vRXxzFsR2MbrtI+7n2f//j/pVH9XUh1vdNxjY99kdPSb/OhH/5QzZx5kx47vXnPbx81ohl8u4vMQb6jef+7xSly6KpcRLe/uneBGQLAQscH0uu7jRH7IbrTh+zg7djzPnj3/BZDwvAYnTjwUtbB/xNjYo8iyhOuG0XOsJz8rI0kyntfCcWqMjf054F602XPdCrI8SDJZxLaraFofd911DNP8Hzh27Ab27HmZ3bsfYW5OZdu2e1EUnaGhW2k0ZgkCh+Xls+i6HuFjBO+60ZgFAmRZwbKqNJszkS98Bde1cRyhbWCaWSRpJ2fO/ID+/hsZGbmXUml3JDsqY1llJEllZORDhCE8+eQIP/yhzQ03NPipnxJVfTzyKhRG6enZ+4HmLUvhRvpqXVGr1cjlclSrVbLZ7HtxXNdVBIEXuSOJ6vjcuaeZmHgCSZLJ5bazvHySZLKErqc5f/55bHuZMPRIpYZRVZ1CYXu0i/So1xeoVidoNKYJAgldT1Aq7SSXG2F5+Sz5/Fb6+w9jGElApVAYiVxbClQqEywtncRx6mzbdg+yrFKvzyBJIaZZBKBWm0JVTSxrmTBUGRo6RLV6jqWlsx3+cbV6HlnWSSTyuK5Do3EBx6mSz29n796fxHFs2u0FKpUJ2u0a9foUudwQptmD57WZnHwOVU0iSUJXO5PZQhDYNBrzLC+foVDYFrXIl1EU0SL1vCazs2+jqkkSiXzEUa5F72sSWVZIJErU6/OR1CeI/WKIWGwUuhGpscH7ykK0uoXdbK4kh5X58/rRbq+fSNZLBN/73r/kxz/+9U4rb8+eb61KumvnsmJxXb2AWxb88If/kpdfXnme3bu/xYkTK88jQnQx7rzzy9x7729vePySBIax4Z9XHUv3YnytkcmbbUOvhxjfyGEqDCGReOfHdv1FCvF9jjeY4vu79hz98i//TcbGvsWrr97Lww8/3HXufpabbnqSMJQiXYT1YPhxqxu6pWkFWOvDjI4+G83AxTWcTvdHSn87MAydqakXIo5xiuXlk4ShS3//AbZsuRVdz1OpTDA19Ry2XSWV6ieX28rQ0C0YRoHx8a+iqgn6+w+gqslo1p3lzJlHKJdPk8lsQ9dN8vkRZNmgVpugp+cgAwM30GjMEQQ+kiSRy41QKIziuk2ef/4gP//zfR2Q2L//92/wy7+8BxCU2FJpF6p6neze1sRmc+gHtkJ+t6N7Rt1qLbG8fIp4wRdfvNvRdYNabZZksg/LWsR129HcuAUEzM29TjY7TH//IQqFnSwsHKNYHCUIXGy7hqomIjQyyHKSoaGbCUMi2tQbhKHL+fMaO3c+EFGQIJHoIZMZ6krQx/F9D0VRSacHETrTDer1ORKJPLKs4roWqVQPtdr56MIQvEHHaWJZF5AkCV3PARJLS2fI57dhmgVKJZ10eoiZmRdQlBTl8mmWl0913J18P0CSAsLQYdu2u5mcfJ52e5lMZks0AxZ+rqqaxPdDDCOFopiYZiYSkhfuNLncdlqt2aiSzyHLHp7XjsT84yoiTsDxDDZghd8JYuFZAXylUps/15ut6iwLhocfJwxX2pZheGmjh7Vt1TjhxEjs9Y0k4o2FeL9nzjy4KiFfbcX47iCTV2Kzx3UlSO3rQxBkvVhPz/pKotn1s4KQ5GxedI7Gxw+za9efMzFxx5pzdztjY3+GULfbqKbyWH2NyIDJ2Njj3Hjji5FHsnCXEsDNArKs0GxeYG5ujna7GulouwSB0Moul89hGDny+e3k8zs6G3whTCLTaMxFRYPYPCuKhqomyGQGKZdPU63OEIYKsiza8cvLpzDNPIqSIJPpizTy66hqEkURqn+VyjmSyR6eftrsctvz+P73G/z0T1/AcVrXdTK+kvirhLxBdM+MTTOHYeRIJAoAOE4dXU/Qai3iOFUURWP79vtpt8tAQCKRY3b2NRynRqXiIEk+mpYgl9uC4zQplfbTas1SLO7FcWosL5/FdRsUi3vZskW0glQ1SaMxjW3XOH36UZJJUQGHYYBp5unpEb7Hu3c/2BEISaV6SSaLzM8fR1UXcRyb48e/S7u9iKomqddnqNdnUFVxUZtmMTLACOjt3U8utwNVlXGcNu32MrXaeRqNBcRFreL7VkduM5cbQdezNBozGEaGen0BXc+xdesdZDJDSJJCEIS0WkKAxPcdJEkkUt/3CYIg4g4WKRZHEPZyNbLZAVKpARYXjyJ29RIrlnZxEtYQi2E3KvadLI5En+3GCSBOILt3rxhAxF7GJ06sGD0sL+9kfPzTl0103c8Tz3K7DSuiIwIkduz47qaO/3Kz7cshk99LrvJGSfiD4xT1zr9vImJlO1Eprz1HIyOP4brV6Pa/u+bcBazw+GPnNA/RNdKQ5WxEvQoRCZ/odWwcp81Kd8kgDCUqFbGOqKpJMtnD0aM/wYkTR9ix4xn2758nmdxKLrcV122zsPA2qVQP27bdzbFj8wSBj6KYBIFNEPh4XgNFkVlaOk1v736SyR5mZt5EkiCREL7SzaYAuhlGHl03se0myWQvhcIdlEpCn//ChVc71fKHP+zy7/7dCmL7xhvPMj9fpdWaJQi8Dqbmgxx/lZA3iO6ZsaA6qR3kXhiCpiXQ9Sye59BuLzMz8wau20LTkth2A0nSkGU9Qko3KRTELKWnZzenTz+K51k4To1ksg/XbVOvX2Bp6W2y2X6y2VEMI0Nv7x6Wlk4zNHQEXU9Qr89j23VSqR5su46iqJhmnu3b72VhYZxEokCzuUCjMUUiIUwgyuWz2HaFkZGPkEr1oSgGkqRgGHmKxb0UCnuZn3+VZLIPTTNpNi9QrZ7D930qlTNks1sjA/UWkiSRSPSgqkk0zaCnZx+pVA8LC8dotcZJJksMD9/ByMhdnDjxXVRV+DwHgYvr2ui6Gc2YKwBR27qJYRQwTdGu9n2PZLIQfdYxIMplpfWmsDKri63wmtTrAvzlupDLadF9Q67Ea/lyyTiOWEc6ThYPPfQZXnnlS5w48VlOnvzJS1KK1nseEEIhG8XQ0Audn69ktr329S81A33vhTY2jus3Cb8b0e2xLGwNH3roi5w7dzcjI49Hc18YG/vGmnO3dpPmR9xkDcPIYRh9hGGTWi0WG1Ei8KioiMfHH4ye63FuvPEZhB5+gOe5hKHMSy/dwle+8v8gSR7PPPO3+OIXH+KBB6bZuvU2lpfPMDv7GrXaBZLJAiCRTvdTKOzENHPU6zNks1uiVrpCozGNpiXw/RaaphEEHu22KBh0PYFt1ymVdiO80w1UVTAzWq0lZFkikRBgr09+0uLP/9zhT//0KP39f8Ho6HNUq5/HNAudYumDHn+VkDeIbvWvODl7nsXy8qmIGmCQyfRjmmmOHXsN120TBC7Z7EjEQ1bJ5bZSKOwmkchy5syjWFaNZnOWfH4H9foFwhDa7QVMM0863U+5fB7P8/E8gZbO5bbh+y6uK6hKjlPDMHJoWoJSaReO0+xsGGy7Sru9jO8L0FgYhrRas2iaDmQpl4/Tai2SyQxRLO4lDH1832Jo6Cb6+vYwP/92hNhsomkZDENDUXQcR7wvSdLI53fheW2azVlqtTqt1iK6no8oEzJh6JPPb8XzLCyrTK02ieu2URQNz1vCMNLk8wOoajoSQKlHiMxxgkBwtVutRVqtWgSYi5HVQvdXSHPGLWuddLoP1w2Znm52eMtBAI2GSzqtrHte14vNKGFdqnoeG/vmptvBpimkNc+dW61zvZoqFQN9BD1pPYOItdXsZl9/I2Tyu93O/qvYKFaScXxOt29/nk984n8kDB1kOUsYSoRhrevcxejrOMQGNAx9FEXDsupYVpMTJz7PuXMfYuvWHzI29rWIdqdy8uTP8PDDf9zZfL322ve4/favcuONj+J5GmEYcurU6hb5hQufYPv2KQqFERYWjuM4TWZmXiGZLEYqfD24bgXHqVAs7qDRmMYwCqRSJZLJHkwzRyq1FcM4TSKRo90u02gs4boNwENRNLZsEZXx4uIpFhefJ5fbQiLRQ6m0q+MA9bGPqdx1l8z3vvdjbLvB7OzLbNly5wcayNUd7yI55C9PdIubx4kPIJnsAWRMs0gut4tt2z5MX99eVDURzVhGyOVGcF0LSVLw/Ta6niOfH+Kmm36JUmk3jmPRaMzRbM6hKCqFwlaKxV1kMsM4jpinzMy8QqUyQYwkTCTyOE5zlWCJSNQCaJXPj+J5DqqaIpcboadnL2EoYZp5QKKvby+pVC/1+jQTEz/qmGW020KbOghsZBkMo0gikUW4N9Ui4FqGRKIYPccwqVQfQ0O3ks/vQlUNzp59mmp1kmZzgVZrEVXVSaX6URSdMJQiB6sUjlOP9LuFYcbCwglc16FWm8WylpAkE9NMI2ZkALGk/ScmAADOAElEQVQ/qpAplSSZRmMG255DUQQaG0TCEwhdn4tViTYO07z4X3dcbpY5Ovp4Z/Fa2w62rJV/4+NC5/rll3+dr371G/zZn32Nkyc/zcjIyuO7ucIbtZYffvgb/PjHv87DD3+D8fFPX/L1NxPv9PHXW7Tb4vOOFd+uXbw7NUz3Of3P//lPOHbsU4BwT1OUWC42jm6XKCGjKcLD9+uAzfj4x/lP/+mPePbZX+Xhh/+M8fFPRY/xOH36jq7NH4yPf5yvfOU/cPz4p8hmh5Flg717XyQMVWRZ3O+uuyyKxR0kEiUymQHS6QE0LdEBXmWz2/B9MZrLZrexZ89PcvDgX+PAgb9GNjtEvX6Bcvk4igKGkaGnZzeapmOaGUyzSDo9jCyrOE4Lx6nTbM4hyzq9vWM4jjDtMM0CnmdRq82ye/fH2b79IwwN3Y2mpSiXJ96V8/Jex19VyFcQ6XQ/w8O302wuIEkiUWcygySTPRhGhuHhWyiXJyJUoIUs50ilssiygSyrFAqjWFYZ08xTr88iSQqmmcVxAkyzj0bjAq5r099/gKWlU9h2BU1LMzp6L55nk0r1kE4PdJJwpXKOZlPMuRVFRVVN2u0yU1MvIEka6fQgPT27WVo6QSpVRJIkVDXJ4uIpstkhFMWgXD5DGMrU65M4TiPaaSo0GvOATLG4HVVN4/tNdD2J57UolfYhyzK6niYIPCqVKRRFYWbmOEEwHnkpZ+nrO4hpZkilhokNJoJAwvdrpNNizuy6LRqNCrIs5l6GkUVVDQwjyfLyGURLT7SvBT0qS7tdZ2mphmkKnrKqigpWlsX/K7yBd2ZIcamqeW3C3qgdbFl0ZDNHRh6/SDTk1KlPc+rUT7Fr19e5554v47rJTjLcSPRivWp2dPQJ9uz5OhBy8OAfMDr6zSuiDP1lMqWIUfPx96DZvDKQ36Xj8iOQq5nFX3xO72Js7E/wvCbj43+NiYl7IrrT11mdkBWEYIh3mee7j7GxR4DYJvHXuVgo5nYOHvwR6XQPd901TqHwv3Lu3Ec5fPgc99/vRrr0dUZH70WSFKrVMziOTT6/G9PMY1kVLKvK9PTL5PNbGRi4kf7+A+RyW6lWz5FKDeF5LQYHb2R6+jVsu0EmM0RPz0EUJWRu7g12734wwsiM0du7t1N0rIBrTyJJMDh4hK1b7wBWENZ/GeKvEvIVxFoTi2SyRBB4FArbI+ELYajdblci0XaFbHYbQeCzc+cDTE6+iGVVOX/+RZLJHLKsEoYhsqxFO04jUvKq0ts7xunTj1KpnANgz55PUC5PEARex/VkcvJ5ZmZeoa/vAJnMELncFiqVc8zOvgEEFIu7IxAWLCwcZ3DwMMvLp2m352m1FiI3KVhYOIbrNnHdGo3GDENDd0ZI8EpU/e9gauppQIlctiap1S7QbC5iGBkajTmKxZ1omk6rVabVmkeWZcIwpNGYQ1ESpFK9tNtlqtVzyLJMItETJf9CxKd0URQNWZbo7z+A7zs0GjP4voZpJmm1GiSTKVotn6WlKoqyouRVr4OuC3qMLHfTnK4+IV9JMo5jvXbwyZOrnZ/uvPPLXW1pmbhJFSfm7tntRov5em4+3VSZgwf/YNX72Mg+cb1NxWYSyDsFXb3b4LE4EcddDWXz04t3HHGlC8EVzeIvBtz9sOv5/iRqL/8ae/Z8gyNHfq/rOS/eIBhGHwcOnOT551d3PAwjwbFjD3L+/D3cc8//xvz8vlWUvS1bvk+7vUQqlUdVe7jtttd58ME2/f2HCMMS1eoZEokeHKdFOj2AbZcJwzLbtt1BsbiDanWKM2cewXWrNJtmRychmx2mXD5LMpkjkdhJNruFxcWTqKqJ6zZoNCYjfYYc1eoUiqLS07M3qtZXjw5j/4JuiczY3+AvQ/xVQr7CiNHXkiR2bUtLpyJVKxPDyOC6TbZtu5Pz5yGZ7KVen8V1G5hmDtuuMjPzGooi5svbt38E0xQJeHDwEI4jjL5tu0q9PoNhpGm3F7DtKo5TJ58fod1e7lTFMbBsYWE8OrbFjuKX6zbRtEQ0A/bw/RZzc28QBAHN5iIQ4rpNGo05MpmtmGaKhYUK7fY88/Ovkk4P4PserdYikgT5/Hay2UF6e8dw3SavvfbHSJKK51mRuHwF3w9IpXrIZreg61lkWaZWq+I4Der1GdptIQpgGCnS6X7q9QtoWpZcbphGYymymHQwjCLJZInFxTOEoYvQ8W5Rq9UAF02jk5DjpNzTMwxUWUG/xnO2uJrYXHJeLxHHC/zV8GHXOj95XnIVCGxtlbKZ2e3aanZtNbSeu1T83rqr9W5g2mbjnfohvxfgsbg6fueUqRSr6UmXjyef/IfRT2Kj9eqrX2Jk5JudY7nUZm51h+I7wHo65J/ixInP8NBDn43uEydkk/Hxj/Paa/81up7iQx/6Br/wC7/AyZM3Mzr6GGNj3+Htt3+eP/qjrxB/5371V3+dO+/8FqdP38GOHc9y8OCz6HoGwyiRSORJJEps334fL7xwiL/4i3PcfvsAhw8/GRUEwlrWNHuZmXmJ4eGbUVWTRmMWx2nS27uXdnuZSuUc1epkZMOqRFXuaSYnn2Vx8Thh6GLbbQYGDpBMDhCGLkEgd/zu12pAfNDNIy4Xf5WQrzCEPeECvm9HDkvJCCXYG+m41tH1NAMDB5mdfQNJUrCsCkHgYRhpcrmt9PYeIJHIkckMYhhpJEmlVNrFwsI4y8unOHXqUVqtefr6DjEwcCOzs+M0GnOoagrDyHDhwsvoejrSju1hcfFt5uffQtdzpNP9JBJFksk8qVQ/g4OHmJ5+mYGBm6jVZqI5diZCZC+RyQwThjA0dBjT7GF29qVoBm1TqZxFkiQGB4+gqgb5/FZkWUXTUmzdeifz82+RSBSxrCpBEFAuJyPJuwzLy+O4ro3nOdh2NbogBbI6mSxF4vsN8vkR+voOMD8/TrM5SxD4TE//GElSkSQfWdZJJnM4Th3HaRAECu2221ng2m2RnHO5PiQpRbNZwXVriGR8ZdSUtckmCIhUzDan9tUdcdt0Ld94584nOpXo+PinL1LzGh19YlMV5Npqtru62kgSc221vmvX17nllt9f1V6P491COr8X4LFEYkV+U9BsrvaZrsDzErHZuHDh9lW3+f7qjUG7vfHxrNeh2EiHfGLiIxw+/AKWNQNIjI9/jIcf/lrncW+8cQ8PPfQFHnzwH3Ps2AN873v/J5OTd0Z/FZuFH//48/zar/19stkh3nrrY2Qy/dx++9tIkoTnWQSBy5/+aZPf+q0eZDnPn/6pyt/7e69w330naLfLHf0Ay2py/vyP6e/fT6GwE8ep4Xk2QeAxNfUijlOjUNjJ0NBNzMy8imnmSCSKFArbSSb76O8/QBiGuG6DxcUF+vsPkU734zgNTp36AaqaQFV1ms0FUqneD7yBxKXiL+e7ehdDllV6e8dYWBjHMMC264Shz/T0i+h6NvIDzeC6gm5gWXXy+VEymUFU1WT79gSJRKlDo4qTsaqaHei+rqdotUJarTkSiRL5/DDN5jzC+WiO2LYtDH0ymSFsu4ZtV2i3F2i3F0gkekgkimSzQ5w58wRh6CBJOsXiCEtLZ5FliWSyj4GBwwSBT6u1iO/7HDjwOYrFHRhGimp1EuEYVaRSOY8sK3iehWGkKJX20moJq0TPa7Ft252Uy2ci9PU5dD0bSWXOYFnLFIu7KZV2sWvXJ1hYOEa9PsXCwnGazVmSyR4ajRLl8glsW3C2RQsrIJksksn8/9n77zA77jO/F/xUrpNzRzS6kRoNEIEAc5JIUXmUbHksTrBnPHdmHa7H47tjP+u71368fu7Yz3qfx+Ha966962t5vPaMaXuSRImiRqJEkaIEkmIOaAANoIFG5z45VK7aP6rq9OlGAwQpacaW+n0ePN3oc06dOlV16v297/sNI1iWiSiGvsyhF3WH1dULOE7Yqh4dzeN5nagTEALoQm/Z9xaeF7a8Byus+Gb6Xm7qprn5uphvvLh4/Wx2MDHHlRHwnlueMzNP8Gf/7GdYWAg5zYPV8WBivdH8eic3qR+XZOWPx6Xp+vjR7PutybTGES42YkevkEN+8mQ4PtiKbbj1CCvnz/Hqq7+8beH2XB+MCQHz8w+zlcPuc+XKh9C0Io8//m+2nPc4ZFlndvYz/It/8b8gih7f+tbPkUr9Mx54YI5UqoJtd3n22RDY5fvhzxdeKHP69AsUi9Nks6MMDR3hypVncZw25859hZGRE1hWm0plGtPsUq2+Rbe73MfXqGqaev1KxAhxSKWKDA0dpV6/TL1+lWx2DN93cV2Tubk/pla7RDo9hiyrEcW0+hOdmH+yPs2fUMRJOTbHXl19i2bzatQettC0HOPjd6LreXQ9G4mlh+2WQUNt1zUxjCq9XqE/L0mlKoyO7mFo6Gg0Lx6i212nXp+PklOX4eHj6HqeK1eeQ5aT7N//CIqS4OLFb9FsXqbdXiGRKLC+foHV1ddIpUbYt+8hLKuLKIIkpSiXDzE6ejutVuhE5fs2jcYi9fpFgiBgdPQEipIkCHxmZ7+MIAik0xV6vTqpVJN8fi+qmo7Q4xbV6hxra2/hOB1SqRHiVpquF9C0LOXyMTqda7TbC6ytnY242tBqrdLtrtNsLkTiKfsIggDPs1HVNJ7nYZpVgsBH03LIssroaBFN24dlhaIlkhRE83srEtxXkaRSJNQfa/2++90wBoXFyXSrF/NmBRk7Sb2bJGcchw49cR1taTAGK6Pf/d0/ivcGCFue75aQTROmp59genrnRBzH9aYXm23yW9XL/mGFO36SwGPbY3OxESblhx76rf7iKAYdvp+YmfkSMzNf4umn/1cuXPgEhw59jZmZrzJ4TW9W0nGIyHKLc+dODHQkBu0/RW6//bd57bUPDCRcj3Pnbudzn1NwXZdWa5ETJ87xta99sv+cqaln6HY3GBu7g71772Nl5S2SyUrErFhFlrN4XhtZDhHYKysv0+ut8+abEpnMFIIgoChJhoZO4XkdZDlNo3Gl7xVvmlVMs8Ha2tsMD9+GIIhIkkSzOU+pdJggUOl217CsxnWYnp+E2E3I7zPiiyEGLoSzlwyO04tmvt2+ckwsw6nruS2vbbUWGfxSDSIKVTVNr7eOoqTIZkMBjU5nHUEQkCQtkunMIIpSHzAV8ojbgISqZuh0VnBdi0Qih6KkMM1mNDMeI5eboNNZ5cqV72CabdrtRfbuvR9FSbO4+H1830WSJBQlDQSkUsPk81MEgU8iUSSXmyCdHqbTWeXcua/geQ7j4/fi+y6iCI3GFTwPNC2JIIhcvvwNWq0rdLttPM9E10uIotCnL8lyknR6hErlKKlUkXZ7Bd8P58dQQlF0JEmLkOBFkskOopjBdS1kWYk4yDqKIiNJSVw3FkSIvWjjinm7KfxmJBKbNJnt88fBZCyK4c9brSLfT2W0/bU/CiDUjUwvblSl3ug9f5jq0zRhauqJ/gKg13t3V6f/XuJGi43epoz0+/6cs7Of7puRrKzcwcTE2/i+zfz8g/3zMz39Jc6f/zTx9b22diTiMG+Cux555J9jWSp7936bffu+gSTJfPvbv9BPuB/9aBZdL3Lt2hksq8X995/nH//jJ/nud2XGx5/i4MFn0PVTtNtrvPji/5tMZhLb7jA+fieO00XTsly69C08z0IUE4CEYTRotVYAgUxmL7bdYN++B/F9l/Pnn8R1e2Qyo7TbyziOwfLyD0gkShhGjSDw6XTWCAKHdHqUbDZkZ4SqhD8Z3OPB2E3IP2TEohyyrDI0dFu/hTJ4scRAsJguBWHyHUzAsLMYSfzTMOqRTrZJIlGg0wlpU8PDx+l0VlhcfJlOZx1dL1IqTaNpaXy/hKqm2L//Q6hqmk5nBVXNkM2O47om1eocrhsaN4Syd+G+drtr+L5PobAPUMjlxkkkKgwN3YbnOQRByAleXn6N119/noWFl0inE+zff5Jm8xK12hVEUWVk5Bi6XmZ9/U0Mo4rr2qiqhqqWKZcPRyvhNwENUSTiNw4RBB6t1jK+76KqKYLARVUzFIsHqFYvRA4wApKkkEgUUZQEltXpezOLooDvK2zqX8cVYWwO7xGqfIW8zMGIk3J8nuKEAVurHO8m3czBKtL3b72SBjh9+t9ukdA8fvyLvPnm5uz3hwVC7dQm32mGPD//3sBXt7Jg2Mk44r9FV6cfJnaaA7+X83+j2D57f/nln+fcuU9vOT/xtRM/L150AUxPf4VTp74Y7VusoGcxM/M1/tpf+9tcvHg/J09e5NSpJIKQR5Jkkskyvd46p0+/wF13qSwuziKKJ8jlpjCMVSyrh2FskMvtBQQOHPgIq6vvoKopGo2rgIAsK5TLhxkePsXIyFESiQKSFPq5Lyy8gChK1OuXEMWQ1hh22MZQFB1F0SIb2wKC4PcFmSqVmZ+4VnUcP5mf6k8ofD9MTMXiwS3iIdsjTqpxqzqmS8XowZ1iMDmHFoyhPFz8t3r9MkHgsbb2Np7nROjGNqqawjBqtNsrtFoLVCrHsKx2tF8CudxebLvH5cvfQlFSFIsHSacrnD37R7huh2x2lHR6hFLpEKnUKOn0EILgRYnYQ9MyGEadVusa//E//l1effVM1FbWePDBee6++z4ymT1ks2PIchpRFLlyZQNRFMlmp5CkTUvKUEQ+RWhuodPrVel0lpmff416/U0UpUAqlcHzupHal4lltWi1riIICVRVj6T3Oriug+eF+ykIcsQDTwMevm8Roq4FNk3e7esP+pZzu3WeHAOENs/PzVuQ7ze5xFXWxYub8+Df+70/AvwtQCjYavlomuF+zs19msXFd6+kd0ocg/v8XsBXt4qcjo9p/Dv8t2wesXO8107F++1sbH/d9tl7EPjXnZ+Pf/w3eeih3+LChU8gii7Ly3f0Hy8ULm2jSoVuU7ZtcOTIUxw58seAz8bGw+zd+yCjoydYWnqTbncFxzEjtkePUmkqEv+4HcOokUqN4/s90ukhrl17EUXR2Lfvw3iewdraLJ4X0hnL5ZCCubj4CkePfi6SzA11DEyzzuXLz6CqoQVrKKi0h16vFnkiH4t0GIZ+opMx7CbkHyrCyncDQZBueKEMukaFSTa863U6q30HqcH29+Bz4//bdofl5VfJZvdESanN8PCxyFlpJAIxgSRJbGzMIUkyrusgSSqNxiWSyRye55DJjKLr+chE3KTVWiSdHuHSpWexbQNZTrFnz340LR9xgHu024t4XvilWVp6DVXV0bQcc3Pv8NprL+B5PpDHcSxefvn7zMyc5sCBO1hZmcWyLtPphPrbul5kePgUvt9maek1wCMIQNfTUWW+gSA0WFh4g1arju+D43SoVBLIso6mlSLKVxXT7KDrOpKkYBjtSB+7CcgEgQUEaJqG63p4nkdYEQeEVXH8/xzQZtObNrZ53GwTx0ljEOAVJ5AfZ2UXexdfuPBpfu/3/oi5uc/2H9vOOx5MgLEKWPz36ekvcfr0v31f1fR7AV/davIeXMAMHsv/VuLdkuetLTwk4nHIe6F4Db43sOPrwnb4h5ia+haw1dQkRufHbe0YwLX1/MUGLR6xAYXrGjQaC5w//ykuX/4gJ0/O8alPvUSrtUCvV6PTWUMU6xhGDUVJIcuJvgvT0NBRDGODQuEA8/PPsdnV+Vlsu4ckKTQa17CsJvX6eZaWXozueXD69C/T7a4zNnYaw2hhWRsIgkqpdJBEIk86PUSvt44sK1hWi16vjuNYlEoHUdX0D3GW/9uO3YT8Q0RMgQqCrdXuYKU86Bq1XVSkWDzY/337c5PJEuvrswSBR7e7Qau1gGk2EAQJQQgwzVAzNrQsDM0YlpZeJVQQ0xkePkSrlScIAoJARFFShK1pCUEQI+ESgStXnqXTWYnoTBrtdijhqWlpQCCVGiUIQlWufH4PltWl1Vrk6tU36HY9Uqkstq2TSCgYRp2NjRVGRobpdK5Gn6cWcYmhVnsnQqX7EahLjlxnPHS9gGGYrK3V+5WpYUCjYZDPC7huj1rtMq7bRZJkUqkcsqzjum1su40kqRhGAzBR1TyimEZRfDzPZtPVJga0QJiMRUBCUTQcZ/N528Fd8e9xgo6rZUEIW9etFvyobcJjitJW/rTP4cNfxnFSOybA6zmrn97R6OJWEs/8/CNblMNultRvNXnHrfwYzb79sR9tbPXHfre4leR5awsP7z0+//r3np7+0o6v297V2D6vfuqpf7rldYcOPUmxOBc9/lU25TdFNK1EEBjYdpfZ2Y/x+OP/EUFw+e53Zcrlf8fMzBxvvvlBXn/9IIcPv8y+ff856uqtYdtdpqYeQRRVCoVDrK+/0wda5fP7WF5+A9tu02pdo1Q6gKqmsKwmmcwYEPRVtSqVGXzfZWLCYG3tLVzX6hcYtdpl9uy5h3Z7hY2Nc8zPf5sg8NjYmOWee/7qT2xS3k3IP0QMoq19372u4oWwTd3trvcBXYOvjRW34tjuMBUELoIgMzFxD8lkCU3LAES8501zCQhnzNnsOIIAmcwYjtOjUNiHJKnIskartYiqJpHlUE1rePg2bNsgkxmhXr/ST8aiKNNoXEFVM5RKUzQa1zCMNTStQCYzjuvOs7r6BprWw/eTXLsGuq7TbjcYGlJIpQTq9YtoWpFicZqFhTksS0NVZYJgBV3Po6pJQKRev4Qs6yhKqOTVbL6D44CmiXQ6KoIg0O0a5PNpZFlBVdNIkhK5wMh4XoBtd5Ck0D4ubEMH2HYd27YBGUmS8Lz45mwRXvKxx3KY7DwvrpDN6JxtJg64Xnax292somOA1486Fhe3Jte4+jh1KqTR7JQAb8xZ3UwE75Z4Bh8PAvmWaVe3ipz+k5sTvzck3a0kz/dG2RJu+fnz848Qdoxk4m5OrOZ2s9dtT9Db3294+G0cJ754Ny9SQcggy3I00zd55ZVf6b+XKLqcPXsS2+7wT//pryOKLk8//Ri//MtN7rjjeSC0Z+z11igUpqjVzlOrXcCyOuh6CDKVZR3ftxFFDdPsous5fD/s2FUqx+n11mm1FsnnJ6lUZmi1QhGkbHaCQmEfFy58DdNskEpV2LfvgyiKzurqG6yuvsn6+tssLLzAgQOP3uTY//cbuwn5h4ztaGvYCugyzSaCEP6M29VxxG3rfH4q8iAtkUyW6HRW8TyLIIByOeQoDw8f20KZGmyPxwuDRKLA0NBR2u3lyKaxQiYzysbGORynS6NxlU5nmXR6NNLlvhvb7rC2dpZOZ5Vm80pUvTYjjnABVU1i210gYG3t7chY4iSjo3exvn4bX/ziv8I018lmJe677wSi2MTzEmSzYzz//Hd4+eXvUauBqgo88MBh7rzzATwvFB1xnC6qmmJ09CSynGFlZQ5FgfBL79FoiNTraU6ePIQkGaTTw9FMKuREy7KILKs4TiuqWjWCoEe3C67bJQggn5eR5Ryu2+R6O8YQ2OX7BttFIG6WODxv08wCiPb5+vhhkNHbb66HD395AJRzfXUEt4ai3uTKhjf/Z575+/3Xbj7+3oU7blV287/VuJXk+d4oW8EtP19Rumwqy0lsbBx5X59hsK2tKAbPPfc/Rwuvv8Fjj/1ZZmb+EFFMkkqVid3eZmc/zfnzn+lvI6Q2fYtXX53ewj+en7+P++9/m9HRO/F9F8vqcuXKd2m3l9nYeIdEooDnWX1dhrGxO5FlhV5vFdtuMTFxL5qWw/dtVlbe6KsLGkYd224iyzrl8jSe5yCKOp5n94WI8vkpisUDWFabRKJAoTD1vo7Pfw+xm5B/RCGK8o6ybtvR0tdHyKGVpM1TUatdoNerk0wW+ok8TN4XUJQ0jtNB0/L91+h6ru+HLIoyjtNFllUymdH+YkHTsnS7a7TbS7hury9Nd/781zl37g/JZPaSy40yPHyCubmnabev4nk25fI0zeYi3e4yi4svMTJykpGR4yQSBX71Vx/krrummZ9/lWIxg6aFEpmpVIFarclLLz1HIhGQz+dR1Rbz82+Qz4tkMiEVShDkaL60QLl8iPHxozSbBisr5yPbSY1HHrmPI0fuY2npFWy7g+P08P0AQdCQJA1JkrAsOZqbB1Srvb6sZmjF6JJOB6hqCduuRUc4gaLIeJ6P73cIk3E8X1MIE3WPG1VZ2eymEtSNKDs/rETku93Mb5YAC4XLN2w3K0p3QLhCYmXlFI8//uX+/v0ohDtuthDZ/tiPW9f6VuNWk+d7XXjcyvPDEUTMEYZabTp65NbkVLcfw7B9/c+38I+feeZ/AXxOnDiD7/vYdgdRlJmf//BAJ8bnzjtf5a67XsW2Ozz11Gf6SfmeexqMjt7O4cOfxLI6XL78bUQx7G4lEiUKhX10u6v0el1C8Og+ALrdGrKsYNtdisWD6HoO2+7heTbLyy+jaTny+Sm+970jPP74ER55BE6cqFKpTEdjtnDUd/Ton2V4+ASl0kHy+clbPv7/vcVuQv4xx83I64P2iTH6GqBYPEQ+726hRIURzoB838P33T4Xb3X1Lebnv002O8HExH0UCvtYWztHs3kl4gXLKIrO0NBtJJMlDKOJqqZotRYjipCIpmVIJIYZGTlJu71Iu3213w5OJguENmshAtt1TRYXXyKRKHD8+F1MT8+gqknW189FM3CZy5e/TSrloGkJul0Vy8phmiuYZgdNC0UIEokcvp8in9/DxMT9uK5BPn+Qc+e+gWWJlMt78f0VFha+h6Kk6HZb/XZ1WBn7yHKGVErC81wcR8eyqug6OI6MJLlRa9lE18vIchLTbEer+Q6O0yD2VgYRRcniOCab3GWLzZlg7M0cxru1Xn8UEpHxzTW2bny3972VdnPYwvTYrMg2b/rxfm93nXrqqX/6nlDFN1qIbH/soYd+qw9C+mHpXD8qnvb7XxTcfGZ9s/27ftSwiXa78aIoXEDe6HiHjk6/0U/0Kyu38/jjf4Sm/Rp33fWDaNGukEhstsdBZHz8Erqe5847X+eXfulXuXTpLo4fv8gddyyQSBxCVbPIso4kJaO5cRPLarGxcQHPM3FdG0nSqdfnKJcPI8spIKDZXECWNYaGjjExcW+kdHgAWdZ58kmdv/JXSkiSz7/8lyJ/8AcP8cgjy7Tby1EnTCefnySfn9wy4vtJjN2E/GOM7ajp7TFoKzb4nHi2vP1vcfJeX5/FMKpkMqOIYgjqymYnyGbH6HbX8X2X9fW3aTYvMzFxP5XKbf3qWRAkOp1FFhZewDQbLC+/jqLINJtX6HZXyWSGyedDpLWm5UkkCtHKNkOns8bly98il9uHqiaQJI319VkKhak+Wd8wath2mz17Zmi3NTodH8uS8Lw22WyKUukQnreM5zn4vkciUUTTypjmBppWQVF0EgmZvXuPk0yWuXDhHL4fkMvpKEqSRMKl263ieTa6nqdY3IfnWTSb1/A8A9cNucOxBnU43xWRZR3L6hAEFr3eGkFgE86c49mzjChmUVUF224QJuNB5NF7k1m6lUrzVhSv3ouZw/ZFwCuv/Mp1SWDz5h8m5bh9vd0x6rHHwjbm9gTqOKmbgsGeeeb/MdAS93nllU2lse37d+HCJ37oRUv8vj9uw4rrQ4p+CoDM7OzHmJ//4A27Ajfbv7g63zQcCYj589PTXx54bojgDpP7R9m37zmuXv3gDQBgYdfjmWf+PisrtxOea5dz505w7Ng3kCSVN998hG9/+zfYXKB5fOlLP8vJk010/WOsrPjcdttz3HXX66TTx0gmi6ysvIlpNuh0rpJIDKMoCp3OeqQVkCWXK/Q7dIqSjtggTYLAI5Eo9e93kiSjqmnS6WHOnPGRJB/PExFFnyef3GBi4o8jtb4kudxeDKNOIlHoy4X+pCl0xbGbkH/EMZiEb4SwHox4jlwsHiSbHY+S6SxB4G553WClnUgUaDQu9+fWyWQJXS/Q69VoNl9HVXOR0UUD3xcQBAHLavdRw6GPsU2jMY9phjrWY2OnoscSgMjevfeTSJQiOc8yoQtVB8+zse025fIh6vV5qtVZNjbeYXj4BJ7n0mwuYNtdhocP8cADP8OTT36b5eUWY2Myd931MY4efRDbbnDlynMRanOFWm0eVU1SqUwTBKAoaXzfIp0eJpeboFZbYGPjLKnUMJIk4/s2rmthGDUsq0symUeWVXTdZ2KiwqVL6yiKi6ZBJiNFjlotHKcXqY/lMYwNNoVDwpurJIkIgo5tx4j5QbTW9UYVgwpM28Uf3q0F+sO6Ju0U2xcB589/7rokMLhfitLrV8I7VfQgDLQzvZtWs5u2g/HNHUDk/PnPMTv76R3b4YcOfY2VlTved3s8rjprtf0/ksT+7rG9CpYAm9nZT/D44390w2Nzo27JTq3mp5/+X3nuub9LfBxPn/7iwPupzM5+eCC5/3UeffT/2KLENTX1A+JuTrwPgwutWPoSHObm7hg4v+EIQxRdnnjiCK+++gCi6OH7n6NY/N+Zmgpd5paWXkYQVARBolicpFg8TLcbIq/z+f3RYlZAltNMT38c2+4yNHSs3wEc7PrFPz/0IZH/7X8jej+JvXu/TbO5QC63l8nJD0Rz6fhe95Op0BXHbkL+Ecd26tLgz8Hw/VArdm3tbSyrTTa7h05nNTJICMERxeJBOp3VLS1tUZSjqrjY5yovLv6ARuMyruvQbM6TyewhlQrNI0ZHT0Wox7B1XSyG29jYOIcsJ3GcLr4fqn+NjJyg1Vqg0bga6VSHGTwIArrdVbLZUUyziaomaLWuoes5SqUZUqkKnU7IGQxtH0Mg2Mc+9imOHbuLVssjkTAYHR1GVZP0essUi/vodut0OkvoehLLMrFtk3J5mkIhBLKtrb1JJrMHxzGo1zuIooiul+h01uj1usiygG2H7XdFSWCaqySTCY4f349h9PD9OoqSJZ0ewnWdiLcd6umGc6xOdDYcFCUXHXuDsIV9c+EQ09yKsO71dk7KN0oMsYhHbIV44MD7F40YfL842dZqB7hw4Wd2TFI32q+dKvrBv8WV705JbyvlyidMXsJ1tJ3ti5Tx8Rffl6719vY8bOfcvt/jeLNzL7M5toj57O8+ntipW3KjqvnRR//elmMC8cjgu8zM/CGvvPI/MIiIdpwEjz32eebnP8DMzBscO/Y8nY4Yfb7PcuXKRwdGEN/nttu+gec5gM3U1NOcObNZIQuCh+/L+L6/BdD1gx8Mcc8971CpzCBJSRynFVWveQyjxv79H6XXWyeVGsOyGnS7yxw9+llUNd2nJyWT8jY9hs0C5TOfgf/yX1r8/u9f4K67ajz6aIAsn2B6+uNR8XDzTuNPUvxkf7o/hRhMwjebH/d6VZaXX6FanYsELuqYZgPDaET2ZAXq9XmCwGN9/WzfCWq75GavV0VREmhajqGhcQqFqWi1OoGipPpzF9Osk0xW+q5SoihRKEwCIc+5WJyiVDpIq7VIp7NMMjmEqib6LfHl5VdRlCSpVPj58vmpyAryNVZX38Iw1pHldAQiiw0dIJ8XSaUcTLOD71fodFZpt1cwjND4QZJUfN8mlQrb1cnkEAcPPsqVK2cQBGg2TWx7ClnuEOritvE8O+JJByhKAl3PoOt5DKOO55mkUkOkUh6djobv25imgSDYSJJMr7cafantCJVtAgqCoOB5Hr4fzqVdN55VbZ0dxxFTouK2+HsVuTh//tP84R9uWiF+/vOf2dGAYruZw7tJWg5KY8YSnLeSpG5U0Q9W04OiE9u3tz3pwM4Jcvti4P3MbePWeEwVEgSX6emvUChcuuXE/v7a3GEVuV0H/d3GEzsd2+2c4Z0WTDvN3MNzGobvy0xPv8T+/c9w6tQZVDWF72soSoqnnvotnnvub/VnyI899gVmZr4SCfnY0ft8m8ce+3NcvfoImuYBRQ4ceBHP6/L66w8RMhBkpqdfARz27Lk78jxexvdDMGoI5KqSTo8wMnIUSdKiEdr4e+oW/uzPZvn8509Geg5Ht2g5/CSaSNwodhPyjzgGaVCdzuoW0Y/BFZ6qppDlZF/hKwg86vUFwCOZLJFOj6DrOarVucgzWdqx0o7FScrlQySTFQqFTZCYqqb6M974ub7v9nWxDaNNqXSYcvkIjmPQ61WpVGaw7Tbp9EgkvGHS6azgeTaVymEymfH+51xfn6VancUwGnieyejo/khSUqHbXUPT8mSzeyJfZKPvf7y4+BKaliSRKGFZXcbH78U0N5AkHVEU2di4iGHUeeWVZ7hw4TLXromMjgbMzJRIp2UEQUEQHARBJAhcTLNJJjNOKhVSxkILyByyLGJZNp4XAmVc18bzIAhCJKiiyIhiEbCR5TS2Hc6nBMFjE3V949nx+7XUA1he3lpVLS4+fENHqPcrafleY6fkOPi3d6tmQ0GLoM+VfrfKd7s61fz8IyhK913n1GGS2px7BoG8hRJ2KwCvrcfxevrX1gh5baqaxXVtgsCLWqh2/zXxDHgQkDUY78YZ3mnBdP3M/ZNbuhC33/49Dh36EooyhKqqgITr9rhw4XM899zfIuQzh5XvysrPcOzY07hum81r2uPIkW9w+vTLFAoT5PNTmGadF144tmU/dL3E/v13IooyhcIUoiijaRk2Ns7RaFxEURJ4nkGorX+sf4/rdFZv2i3cXvneiKny0xS7CfnHFLEuc7e7viMYoVqdo9NZYmjoeJTczuG6Br7v9i/6hYUzjI7ejutaW+Q0t8+YY3GSrSAwndXVt6jVLvSRinGiDmfKPWy7SSKRR9dztFrX8H23/4WoVudwnB6t1gKdzhqdzgq93gS5XEg5MM06hcIUrmvRbl+j0bhGqzVPIlFmZOQYoZynja6XmZy8jZdeuoDnhYuBcnka2+6hKInIGKJGpXKMxcXnCYIKrdY13n77Sa5cOYeuC0xOprEsm9XVJZLJ/SSTKWQ5g2U1CAIb2zZpNOYplQ5Qq13EsjrYtomqpkkmh/F9D8tqEc62JBSlAniIYmgIUq9fptVawvPCUtT3B5Owj6pWsO0q4dfFBkRSKZ9mM6yMRTH2S46Ry++uFPJ+6UXbX1erHejPaAcjFpuIk9aN5pbvJW5UzW5vH8fJ8d2oOoPVXxibrdPtkqDxPm9vjRcKl/nYx/6v1yG5IdzG2NgLfOAD//CGyOatKOQvb6uURcJk7AECtt1i08ozXoltVszxzH5QHe1Wxgs7LVpmZz9NrbZ/y3w4nLmf7v//5MnfxnVtFMVDURKEFEqT2dlTDCLpg0DiIx9Jk89P0GwuIwgBjmMhCEFEP3QxzRadziKqmuGtt4713yPkID+EptVptRaw7Q6pVBmAVGqI48cfwzRb4ZGIRHt2MsjZqcq9FYzNT1vsJuQfU2zKanrR/7eCERKJQr81HQKuAnq90IShXp/HNBusrLyG73sMD4cr1jgZe54V0ZFKN52vxBJ1tt1haeklfN9lePgYvu+SyxmEfr9hMgb6q9Rud52VldcZGpphePgEongOz/NoNK5Ere8ylcoMyWSJpaVXaDSu0mhcptdbJ50ejcRNljHNBo5jRYuPZdLpMSYnH2Bp6WUSiSKW1WJl5Q16vQ1eeeXf4DghAERV09GNg4jDCKKYoNWy8H2JSuUooeFDmVptnlbrWoS6TpNKDeN5FrZtIEkyQZCMKhqHRCJPEDiRKYhFMpnDttt4noWiJBAECVEUoxuvArgIQhpZ1hDF4ejGE1bPopgmlzPY2s6Won8G4Vdr0Fkq2PLc9yYyEcagpOXa2jHOnfscFy78zI7ymNvFJhSlt2ObFrguYYS+u5/k0KEnefTRv/eu+/V+qvbrZ87x8Yuruk0q1va27aZ6mUi9fpDFxbu3JOxBYNnS0j08/viXr0OIx8d/EIU8uHDZDIHtjmAxVW529uPR+z7D/PwHdgDF7axJHcfOi5ZEBBL7fQQhdmr6GqdO/f+47bavMz7+GleufICDB3/AzMzXcV0H3w9n9uXyETQtz/T0i5w589f7x+HP//mvc+rUd+h0QjtGxzFJpUQ8z8W2O5FxjEO7vQosMzX1DM88s2nJeNttZ5HlfZGSVjgSC+1ZZTQtR6k0veU+1D9K79Jq3l41/zTNim8UP52f+k8gBmU1d7rAstnxPtgqNFaQ2bPnrn5FHSfTXG6CXi+kMnW763S7a1tcTwbbQtsv/ljhq1a7yMbGWRQl0Zf5tKwWul4glargOD0SiWJfJSwEgInRHDlNLjeOLGv0ehs0m1dpt5f7ibtevxS5UY2gaVnK5aPk85MRhzlEOQWBi67nGR09Rbe7wdDQbQiCQLVqMjFxH9XqLLo+hKJ0KRSm8X2TSuUYr7wyi+976DpUqx65XIJCYR+aliGZLNFur+H7l6KbTAfTbJLNjqKqKarVuWiBoeE4bURRI50exra72HYXSUoBPu12qIqmaRlSKR3DqOF5WqSBHSp/GYZHEHjIsoTrqiiKhusGiKJC6NkchiDoBEHsuxybWZiAjKKoEe95M2Zmvn7LbdbtVeiN9I7j7Wxs7O9Xf4Lg4TjJHWlRg0jso0f/M1eufIBudxQIWFk5DcSt6hvv2/up9neaOW+nYu2E/nac5HW+v4Po74ce+i02FyJx+zjoI5e3I84XF+9mZeUOBhcugpAmCGwkScPzYvORwYWXECXNP4ze9zf6C4XBY/DeFyo6kqSzsPCxLa+rVJa4//5z9HoJjh//NidOfBtJ0iOrUtC0HIIgoCgphodP8PDDLyIIf4lLl+7j8OE3+OAHL2GaYacok6nQ6zUJAgtNiztmIpnMGIlEEdNs8+CD51CUv87Vqx/mox/NcOrUFRTlKJXKTF+zP76nhQv6RWCrhv+txPaEvZ1x8tMYuwn5xxg3WiEOWi8mkyWq1QuAj+OY5HITdLvrpNPDfQJ9DOgyjGrkF3q97/LgyjT2Oi6VQrSyLOsUCvtwHAPfdyIRjdBMXJY3BUPiFlImM8rU1MMkEgVUNYUgSIyP30G1Oocsp+h0Fgcq/xJBECCKXZLJcQ4f/iSCIOC6FrncHlqta5FLzAfxfZdq9UI0F8/Qbi9Sr19mePgk+bwZtX8FggD27p3myJHbuXjxdTodA0hy6tQnOHHig6RSwxhGg2SyzNLSSyhKCD4L2+AaiqJTLh+MXK3aKIoGaOzZcw+12jlsuxdV++1IZCT0fG405kmnK1FFLGIYTTzPwXVDJa8gCBdIsqzTai1HTlKbN+sgiJOwQ5hcXGLgWohObWy/EoD3Z2wQ6x3fCLl7I2DV1iS4ldb0zjtfYLMVG1J8XnnlV3ZMZoPxfqr97a8JP+NWKla8ne3JfmrqmS1OR4Pob8dJ9gVHNiOmK11fBQ+qZMULlyCwEYQcnhe2qAUhFS20rBtSrdbWjm2Zoe+07zcaL2yGief5TEx8myD4vwy0ql/B9x3y+f2oapYgMHEcJxL2KJJOlxEEhXx+klSqTK+3wUMPXeQjH6khihp7936ETmcNQVglkSiSSnWiytil212LFukehtFAklREUeL48We45543mZ7+FPn8EQyjQau1SK02h2U1GR+/h2x2nFZrkcXFF9G07LtWxHEFrOu5fmEwGKGGwk2Mxn8KYjch/ylEr1elVrsACIiizMTEvSwsnMHzbNbW3kYQhH71vLT0A/L5fUxOPkC5PANsVsI3avFUq3PUahfwfZdMZrT/uKqmqNfnI6/RKvn8VH9VG3s763rYSg/9lt0+B3B5+TU8z8b3TUZGTiLLOqXSQVKpCqur7zA39xq1mogozpHN9lDVFI5jUC7P9JO9YVRZX38H2+72Z9mhDeQ82ewkiUSBVmuFRKLA5OSDKEqK/fuPs74+y8TEvRw6dDvV6iWCQCSRyLG4+FJUGegkEiEQznE6+H6ApmXwfZ92ew3Pc8jlRggCA9/3kCQVQVAJgtAr2fdlqtWLaFoaTQtpUobRQhR1bLuF4yT6iT1Edefo9Wr4voWiFHCcJiFP2WQrqCdM1J7XQZbTXE+pCW9I78fY4PTpL3L69Bf7vsl79z7Bs89uRe4eOBAij2W5x/z8I4yPf5vPf/4zXL0avga2WvhtrypBoNsd40bJbDBuFS29E/d2cBs7bfe9or9jOtUrr/wKa2vHaDT2Mdi+H6zgd67ubYKgTcw9D0Vk3JsueAa1w2NQW7zvsbb4jcYLW8NmZuZxfu7nfObnH+Lw4Ve5++5XUZQhBMGP+P/nCT3EcxjGBsnkEMlknhAVHS4EFSXJyMhxHMdgZeUVyuVjbGy8hapmSCaHowV5BlEUEUWF1dXXyWYn8bwekhSyKUZG7ubgwQ9TrV7ENKtUq3N9k5y4qIhleROJErqe25GmGUens8rGxiyxe5ppthCEAN/3sawW2ew4mcx4v1P309i6/un6tP+NRGi9eKj/uyjKTE4+SKu1iKalMc0OhcIUvV41Akd5UTt2axvnRqCIuN2taZkd7RxXV9+KEo3Rv+BDENoKltVGVZNsbJxFEBSOHftz1OvzeJ7dB5KJYqgdbdtdRFHmiSee4D/9pz+i0XBIJHR+6Zc+zUc+8gDd7gblcjhfWl5+mVptHstq02otAAGjo3fS6230JStbrTcjK0gJz7PZs+cums0FoIAst1haehNdT+E4HbrdFTwvvPEUi/vxfQlVVTHNGp5nI4o+rdYqQeChqkp0k7Ai040hRkdPYBjrNBqr+L4VSQLKpFLDrKy8jm13iGlVjtNDEAJsuxfZRUIikUNRdFzXwvfTeJ5FeNMfVPyInaVcLGuJWKJzO+jr/Rob9HowOfkEsQ3k6Oi3CYLN7Zw8GSaG2CM5CEJ61aOP/mZ/u/E2W63xgQpZIJVaJpdbYHn5Tga1r2/Ujr4VsNiNOgE7oa0Ht3Mj9Hf83J10u6+nDoVV8EMP/dYtgKtS0XlTo5+9/nsNLnhiqtW7cb63z8tfffVXrvs8249f6OstIAgyhcIhBEFC0zJ0OksIgkQmsxdRFPF9E0kK0cmSJFOvz7O09AqiqNHrteh21+h0rlGtzmFZDURRo1z2SKXG8H2LVKqMZXURRR0QSKfHAI9K5TZGR4+zuPgyyWQZ02yhaWkymVEymVG63XUEQSCZLDM0dGxLhy18LPxcg0qEEJpJ+L5HPj+JpuXQtAz1+hVUNUUqtQlQ/WkFe+0m5D+F2AneH7ZOdTzPQVFUbLtLNjvOwYMfBa4XFxmsaLc/Fs+Ot/MAYzvH8fE7qdfnKZUObmkjra+fpdfbwHWzfTelen0+2j8JTSsiSU1838W2u1hWh7m5S/z+7/8BQSCwb1+etbUOX//6f+bAgSz5vI4oSphmE0lKUCzuQ5J0yuXDtNtLZLOjCIJIt7sWvYcSrfyzGEaDjY1zkdtUi7W1KolEkb17H6RYPMTVq8/Q660gSRqNxhKCIBJaXwqoagrXdRGEgGRyBFWVCAKfXm8VXc+QTIYo6xDMVSWdHseyGriuRb1+FcPYwLIagBJVxWliD2nXtfC8HoKQQNe1CFwWm1bELTiNTXRu/Hef7Y5ScUxOPsGf+TOfYWHhYSYnn2FqaueEtj0xDXoKSxIcPryZXMbHn+HQoSf45jf/KYPWflevPsyhQzsDi55++gIXLnyCQ4e+xqOP/r0dkxlcr219q5zendXAuA5tfSvc4FjRapNne+Pn7tRKvvFxVUkkihjGEpsLp7CzsX3hFG7vK8zOfuqmnO9NuVIAkXPnPreldX0zje/vf18mkfi/8elPewhC2OUKAr9v6tBqFSgW9zM6epyNjUvUahciBLWB4zRJpYr0eqsIgkQiMYTnmZHAThbT7EYCRJNIkkoqNYpltchkximVZggCn3b7GqqaZmTkJIIg9WmTQeAiivqWuXF8HxqskLcn12LxIIZRjfSwZTzPIZMJZ+GpVGXLdn6SFbluFLsJ+U85BpNmWDmH1W18McYCINtbN7H7U7F46JbaOtspCDFyexAUNjFxL9XqHIXCFJXK4QH92EbUkspimk0Mo87Gxlksq8XCgkGz6VIoDCMILuPjGkHQpFZb5/jxL6DrWSyrHfkyqwwNZQltJacJvZevMjR0lEQiRGZL0jTt9gqiCOXyYXK5cVzXZn39TbrddTzPYHn5JbrdKpXKUUyzRbe7Qru9jCCIFAqHyWRGosraixCkEqurbyEICslkkV6vgSTJCIJMNjuKKOr0ek0Mo0o2myGdHsfzfILAJxQM8SOupUQyWcB1bQQBVLWAJBn4Pniehed1I6WyLEFg4bomoqgjCDKe1xg4GwnC1vXmvGx6+gmmp5+Irolbu3bCxUCYjIMgFBtZXt5aXfZ6Ywy2a5vNzYXgdqnORx/9e1tQ1TvNeXdKvLcKXtqJslWrHdhSPYaf6+bbmZ39dDQj3uTZ7vTcTQrUVi/p7c/ZWpHbUTIenGWKWxDuIVr7OQCeeuqfoyit67YbRtghmZl5YgsQbetn05if/9CW47dd4/vs2dv45CdfYnj4EEtLryBJOs3mVXQ9z/j4nWhantXVd1hbe4tebyPq3qQRBBXXdUilCth2D8NoIIpKRHFaRpI0dD1HEEA6PUq7vUSns0IyWSSVKiMIEuXyEcbH7+wrZtVqc/i+twVY2j9KAzPk2Gp2p/vOoI1s/NP3XUyz3t/GT1tlHMduQv5TjJ04xYOV83Zi/fXz4pvLQ21fnW6/yOMqW1UzfWnNOFHHYDBdz/UFQpaWXolAXiKSpJNKJZiYyCIISVZWOgwNZdnY6FGpZNi//2EqlcMAWFYLz7OiRUc5+ltIN0qnh9G0PLncBKFHq4sgSFhWi3p9gVQqj6blMIw6vd46s7NfIpudiIwmymQywySTQyQSRTqdZSqVI8iyQj6/n4WF5yMFtCqqWkBRhKgFbSJJKvn8PlqtLisrF5EkC13PI4oijmMiyyoQumq5roskBShKClVNRnM3HdftIssJyuW9UZWfj2bjKpZVBxSCQIzAK0nARFWLZDKjNJuLEVis10/AohgmVq+fC+KW986RSEC7Hc7j5uY2lb8Gk2WtdojN2XBAq3XwPWlmD1aPN1KX2p5oFaW3o0PUTjPV7bPYwd9v1B7fSm0Kk7Ki9K57XigzCbEQRijcwZb2+M6VfXgC4iSsKN0tc+rHHvssIG6bJ8cI8cFkK0V/Dzh9+t9umddvfjY3cmb6m8SdjGJxLkJ++9HoIaRBrq2dxXUN1tfPRt8TAU3Lc/XqcwwNncRxLFqtxUgSd41WaxVRpK/kBwKW1UDX83ieS7l8BFXNoGlJNG2Yy5e/juN0SadHKJenEQSQpNBpKcaZxHGriOrtQK+dknY6vSnt+9NYFQ/GbkL+U4ywjRy2om6kwhX/3J5cQxvF+k0v4Hdr/cSSmjHIYvDLEr+f65qRiXgHxzFQlCSl0kEEQUAQJKanD/Krv/oL/Jt/87tcubJOoaDy+c//IsPDOhsb50ilhhAEiXb7Ko7Tw3EMgsBDFCXy+X0Ui4cIAg9dz5JMlkkkCtRqF2k2l2m3V1DVLIqiUyjsRxQVdD0fGUV0uHTpmyQS+Wj17qFpGZrNBRRFY3T0Dvbv/whzc0+SzY5jGA06nVW63RUkSUFVM8zOXuTs2VfI5Rw8D8bH9zE2JuF5PqIokkiUCK0uQ+RxIpFHEAJ0PY2q5mm3lzGMKvW6he8bURtORZZ1NG0vnmfQaFwhROrKka72HnzfJQgcwiSpkkpBtWr3E2UmA+HNXGOTy7xzZDLhTHppaeucMnZZOnToyYi+FCblQ4e+dsNtvVvcaNY9WEkPgqxuxHW+0Sx2EG19M7T2dseqmPo0Pv7iTYFl3e7IlgR8I+oYXF9dD8p0hgsCaRvKW9oh2W4aktwYiR6e27GxF1haugdBiNHum/HNbz5Ir7fBww/PE1LrXJLJIolEhcuXn8W2a316omm2gQYhYFSMEmms/jcMeGhaEU1L02xejRbJw0hSSAtMJApMT3+8X8kOxo9TSeunSR7zZrGbkP8UY3s7Z3sMXqTbk2tYiYU/45XmzV6/PbbPoOP2UYxu1PUc3e46nc4KCwvfR5YTALhuj3x+AtvukM3uQRRlfu3X/iaPPPJ55uZepFBQGRnJ47o2hnEVXc9SKh3sUx0UJeRaxnaQhcIUq6tv0OvVCAKPlZW3MIzViJsdkEqVGR09TSYzjiAIrK6+Qau1imXVkCSJVGqYQuEQiiLTbi+zvn6WIHDZt+9hkskKlnUvvV4DEFhffwvTbJJKDdNsrvPqq29hGALFooIkOWxsXCaTSSNJIqnUSNT6XsZ1OwSBh2F0EQST4eET5HITGEYDw9gglPH0SCSyfXMQSZKitncIzJFlPWox2xHHGWJalCiqlEqbYhdhEoilQTVEUcX3Gze4isLyevucMnZZilvQg7Ph9xs7SUQOtnw//vHfvK6KjqvhwQS98yz25mjrnfbjmWf+PqurtzMoJDL42rgqjZNqKrW6Zd8E4XrqWBzbq+vBBHzo0GuIosCZM5uv3QSWPcvMzFdvuN/hY5szidnZP8fjj/9XNtv10sDj4Xu/9dbDvPXWhygU/in33HMW284QBOA4PXQ9iSQJDA+f5Pz5J7HtdrQ4TaLrI+Rye7HtOrncXnK5PVhWh253nXZ7MZrhWoDCxsY72HaTXG4Sy+qxsHCGXG6CVmsB33eRZf2nEvX8Jx27R/dPMd7LqnD7c39Y4MN2w4l0Wt/SIoewahYEiWx2D5nMKPX6FdrtJZaX30SSJAyjjiSpVCozHDwIIyMyQRCqkFWrc/R6a7RaS4yM3I4s68Q2kCMjt2OaTXq9dRzHBAIEQcAw6jhOC1FMRBV4KHYgSQkEQWZ19TXa7UV6vQ3K5Rlsu0EyWSKVqlAqTaIoSVqtRURRwXV9VlbeZGPjPJ7nRP7RI2Qyo7iuxcrKJXTdQdeLWFaHdDqcx5pmk0plItLkVnHdFkFg4/sBQeDgOBa12iWy2QlSqSKqmmB1dR7bFhCEIpmMhCAoETjORFG0iI5lIMtJIB4TZLEsA0FwCAIRCM0zVDUTKYWF6Hqw8f2bOU+FOt03m1Nunw3fStwMNT0oERleJ9cn27jd2m6P9n+PaVMf//hvvmfe8vaIX7PdWjAO04SpqRAst7z8MFNTzwL+lrbxqVNf5NSpL+7grPTt695vfPwFJia+z9TUM/h+igsX7r8O3R0fM1CYmfm9HfZaJjxf8flUmZ9/aEu7fqt+evy7iCB4PP98mmPHViKkchDR+3QqleOsrb1Dt7uKJIViNkEgkkqVSSbzJJMFLKtJt6vRaMxHegfjaFoOUVRZXX0F02xSLE6zf/+HaTYXWVz8PgcOfAwIWFub7duz7laxP97YTcj/ncYP2+KJZTfjf4Pzm7ia1fUC+XwuasFmsO0unmcxPn4K17VxXZNG43JflSzebrxvCwtnIhpXsy8lqigeV648T6Ewha4XUNVQpCSZLGNZHURRptdrksvtxfMsRFGN9LRXSCTKNJtXyWbHo1Z2kpWVVyN+8+vIcsh9TqVykY74CrKsomk5PC9svafTe3DdNqlUHdjAcbo4jsbSkkciAUePHkOWjeg4pCkUDkRo02Vc1wDCqt1xDNLpcV555fu88cYFMpmAublr7N8/wr59J3BdI6JfiXS7DYLAj5x2gkgprU2YhBVAJ06sQQCimCacX5vcbIYcxma1deM55XuLm6Gmd5K8HGz5bn/PpaV7Bv4ncfXqA32E8a0l4rB1Pzv76I50qJ0Se+yOFQRw6NATHDr0BMlk+Lmmp79EONP94pbtbP/MR4/+5+j9w6T40EP/iJmZrzI7+yl+53d+Z2Ce/Jktr48FVB566Le2LYIyhLx0OfpMISsgtED8G/3tTU9/mdOnfxdNS/HNb/6PLC7eySZ4rU6tNoeu53HdJul0Hsvq0m5fwfN8Wq0lVDWDIHjYdod2exlNyxLbYZpmB8NokkpVou5Rj3Z7nnr9EiAyOnqKF188zpe/vEi5/Bqf/ezzqGoKEJFllZGRk7dwvnbjh4ndhPxTGrFudaezjGHU+wkVNqtnXd+0gBRFmaGh2yiXDyOKMrncXtrtJUyz2TfDiBcIsVLY+Pid2Ha3n6QrlRkuX/4Oq6uvYZp1Jibui7Y1Qa12GUVJUK9fjtpjQ+Tze8jn97K+fp5UqoIoyuTze6nX59i//1GuXHkez7OillqaS5e+T6vVplDwUBQF3/dRlAyh9rSE63Zpt69SqdyGrudpt4c4d+4Frl618Lws998/TLdbo9ttIssitt0hkxnvq3Xpeo50egLfNzCMNZaWLrK+/ialEsiyjGG4LCysUCzuIZks4zgmjtPGsjqEYhPh/C90iIoTaUCYdCUgBOlYVjMSeLje9hFAELIEQW/L62I07w9becLNhUp2tln0+mCuG/kix7G0dNcOJg6bcX1l7jE7++gNFwg3S+xhh2dzu4PV9OnTWxHXW/c7nONu5S5/OXreB3c8NtuBZltn2jqKouE4PuE5i0FgHjMzX97hnMmoap65uXtZWjoVtbE9HEcnCGQ6nUVkOUens4Ys65hmh1ZrgV6viixrvP32J7l8+QHuuOMq5fJZZDkRjZ82CAIf37fpdFYirX0XWU4higFnzhzjH/yDQ4jifnz/YQqFf8JnPxu20IeGjt50PLYbP5rYTcg/xTFogBEDOHq99WiuXInmoSaG0UTX86TTw1SrcwRByEU0jCqCAPX6fD+h93pV2u1lGo3LW1ymQtnMOfL5CUyzTj4/BYSuUc3mIqurb0QqQkMsL7+CJCmYZoog2Es6HfITK5UjzM9/l1JphnZ7iWSyGC0GdJ544v9gdvYFVNXDMDSOHJlibCyHpuVwXY9kMk+hsJ90ehRJSmHbcOzYXoaHAxxHZWmpx/z8y1y44JBOw759eTKZUJELRHq9NXQ9j65naDarBAFYVhdJgmSSvhC/bbt0uw7ptBg58ISgMEFIIEkJZFmN5n/dqJLbTMiSpGPbbRwnRgyrhMCgEPEdG1skEnksS8bztvOf35+/8PZQlG4/MW2XfNye9BcX7+5Laz733N+9TtP5+thO+9mMG1XmN1sg3IogSRC8uxra9oXGIFDLcZI3PDZxR2CrmYewhYoVuo5VMM0NTLMJuGhaGscJxxGD52zw80xOfofnn//LAx2P72CaG6TTFXxfwPfDrku7fRXP6xEEEq+//jC/8zv/EUFw+d73ZFqtv8w997yG7zv4vkcuN8rU1IeQZSXSFiixuvoqjmPwne+cRhQ9fF9CFF0uXboHTTvLsWM/23ec2zWA+PHG7hH9KY7tBhhxDBL7QxGAGouLL6HrhehGYjA+fieJRGFLQo95irncBPn8PjqdVWy7DYQgspWVVymXj1Auz1AqHexX6ZbVwbK6BIEfUTBCV6YgEJEkmZGRE9h2j253lYWF5xBFFUVJEwQO5fJtnD//Dc6e/QHpdIDva3Q6Am++eYVy+U40DQRBRNfzJBJlXLdHo3EBw2ig6zlUVcI0aywvv0ZYSWdxnDZXr9Y5fLhIPl/GMFqoaobwRhugKGnS6WHq9XUcJ6Qe5XICiYSLooR0pERihHZ7idBYIhXpgmcwzSq6ngUqtFoSltUjCAISiZDfDKG0p6KkI8tOO/oXJnfwIh3iWBlMIqRUhcpiP2zEHN84IQHXST4OJpCdzB+2c5efe+7/TqOxl2537Kbt9OuT5qM70qri196oTazrm21rCM9HnEgHjSs2Q7shUnz7+w0em1j1a5MXHVfIPkEQq5qFrmyeZ0ba52HJHi7StgLjBulVZ878T/zCL/xFHn74n3Pu3MMcPPg1Zma+gu8X8bzQtU2SErRa85jmBpbVYXb2I3zrW3+bQW3vc+cOMz39B2Qyw2hahqGh26hUDjM0dBv5/CSdziqKouL7HrfffonHHz/RX1yeOHEZz3NYW3s7ovyl+h0z2J0n/zhiNyH/lMf2WXQ6PUyns9r3co7VvCyrRRD4OI4RiYU0+wk9Tt6hYUZAaGMok0jkkWWNUulg5AgTJgxBYAulolKZYXn5NUyzgaYVKJX2R/zhOleuPMuePfeTyQyzvn4exzEQBB9VzaOqSRynS6vVpt0GWU6jqh7ZrEqz2aHXa5JICKTT48hysr9AcJwwCXpeqKDVbF4il/PxPAHLMvA8hV7PIpU6Rj6vksuBaTYAgU5nA1XVWVl5Dc+rMzycwTDa2HaAokC5nCKXGyaZLFIqzeB5DtXqhQjQVsPzPCyrSyYzTjY7hWGsEUqjmpjmOiCiaano5u2zmWRlRFElCAKCIBQDCWfSsR1kBt+/kUDFrce7zYjfTWM7brsOVnyLi/ciCLGV4Ff6qOrt1e312/oWsJW/HARC326xVtvPjdrEg1zrwYS5k3xm+DmVLfsdOlwNtpEV5uc/ct3i4/pj5jEy8hqHDn2tD/A6fvw5fN/E85wIMd/DcaqEFo6f5fHH/2jL6+Ptv/zyzzM7+3EEwWV5+XYOHLjE6dMv4ftGlMzD8YeiFHnnnU/wH/7D/94/HpsLj+cAn2x2ItIFkJiff5ZMZoxi8QC6nkPXCxQKU/z6r+fwvN/jpZfKnDw5z8/8jEe322Zu7uvoep5er0oqVeJGNM3d+OFjNyHvxnWxvZWdSBTI56dIJAoIgoBptvrKOjEgDDbFAlzXpNtdJZEoMTZ2R78S1rQC6fQQipLC913W1t6m3b5GuXwUVU3R7a5QKh1gbOw0rmuyvv4OrdYS+fwEipJi374P4Ps+vd4apllHlhUsq0kmk8CyNJpNh3RaIQh6pNOgaaFf6+TkB2i1rtJuL+K6oeOVadbo9Wp4noEkKVGC89B1n04HPE+nVBrBca4R2syVAAfHMSOv59ATNputcOzYGL1eF1E0yWaHogXHKoIgRHrDNrYdA9bWEAQJ2+6QSJQQxWT0eaqE7WkNyzKAjehsZJFlMTpmXl+cwXFiw4cwKYcAsOt1smNQlCgqKIoeCZbYbM51NTbdqW40I35vGtuDsb3qLRQubQNB+Vva0+G2HtmRPnTu3OcALwKubVbwO7WJb7YPgy3oMOLFz9bPFW5HIOxACExNPcOZM7/OdonM7cfs0KGntlS68HlmZp6IxDnUCNAHYPPKK3+pv73tfGbft7bs98LCIzz44CyWBc3mIpKk9v3Jz527Y0tSHx5+jUce+X9x552vks0eZWLibiYnP8DVq8/T6cSiNKERTaNxGYDJyQf4a3/tLs6f/xobG+9Qq4Xa1bKs4Hk2iqL3fd1329Y/ntg9mrtxXQy2sn3fjb6woQOVYVQJkcaV/px5uxpYSD2S+9q0sSuMIITVczJZotVapNer4zgWGxsXqNXOAaGCVyJRIpsdjyQ3NUyzhW33EASYnLyfjY1zmGaTcnmaxcVXKZVaPPjgcc6efRnf7+G6MseP30EqJZPJ7KVY3I+qprHtXrSoULh69VlMM5TQLJWSeF6eq1fnMM2AZjPNBz7wC8zM3Me1ay/SaFzqA7FKpbDdt75+FllWIyF9kaEhnU5nnaGhYxEa3WZt7XV8PzT5KJdn6PU2olaziCCI9HrriKKPadYIk6SKpg3h+90o4Tokk2lEUY2kPkUcx8C2e+h6LlIVc3HdLqE94PZkLCNJGSQJHMeJEoHKpgKYHf3cFB7ZSS4z/P07zMx8Zcfr5WZz6xu1irfzfGPDhRtta2sVGvQT19jYD6IK3BtoE8Om5eK7mXekCRctzR33P9xGj9BwYmeQ3fZjNj//6LbW+wc5cuSP8bzQUzu27Jyd/XSfOgb0q/eYSgVb3bgmJr6NbVsYRjNyWSqRzU4gywn27v02QfCX+s99+OF/wP33XwUy5HJ7keUEnc5aXwoXfBqNK7RaS7iuTa+3wfLyK6yvn6NQmGJ5+RVs2yCZLNJqLaNpBZrNBfL5qT5lEXbb1j/q2E3IP6Vxq+CMwdZUuDIOvZlDi8b5PsJ68HlxpTyoMBbyjcOqLLSfnMPz7Iifq0ciGjae5/QdY4LAi1yXwPc9bLvL6OgJRkdvp16fx7Z7eJ6JaTY5deo29uyp4Dg5hob2MDq6l5WVF0gmC4yOnmR19W0k6V4kSUGWNQxjgyAIIo9oi6mpEvv2rWBZOhMTp7jjjg/R623QbC6hKDnW119FUTLoeo58fpJy+SjV6izN5gKJRAFJ0kgkCjSblxEEkXZ7PbJwVMhkxhFFBVlWyWbHKBYPsrz8Bq6rR8IOWUwzpEaJoo+q5hBFDUlSIq5pWKGFQg4uspxAEMIK2XHqbE+qA2cPz7PxvJj7GvJfRTGL78d/u55WtT0pbv4eo4M37RhvFu/eKt6M4F3G39vVueIE/9BD/wjYru6lRvtnDGhQ/0McJxMtLJ6Mthr6CVtW5xb0w51oERHSoHZyddpEVJe2iIbs2/c8ohhqp/t+j8uXf565uftZXx/dMh6Ynv5K1Cr/UH+bP//zP8fi4sc4ePAFpqefotEwkSQtSpahIUOjcZkjR94eWBR8n7vvPovva7zxxgMsLn6a++5r8PnPqxhGE8fpUKtdod1ewzRrSJISKeTNs77+dmSwUosAaBC7ng3KZ+5karMbP3zsJuSfsogpSSGvOGyd7eSvPCjVOSiXl04P0+tVt7S6Yv3r7dsYTNSua+I4oV2jqqbo9UI5ztDSbQxZTmDbrYjyVEFVU1y+/Bzt9iqVSo5G4yqO06HZvEomM47jtJGkUFe6UJjAtnsMDU0gSQojIzOkUgUc5wi+b/Lmm/8VXc+jaQlMM5wf53J7I07zKIZRR1EyTE4WIwT0NZ599v9JLreHVGoUx+lQKBzCcTpoWibSrfYIgnA2Z9stdD2L6/aQ5Szd7hqSJJNIFIAAWRYjF55etJC5hOeFtnmVynEsq8nKypuYZhXbdtA0GdftYlk9RFEFHLLZ8WjW3MBxOoSJKZwj3jhMNqlHmxnH93tsik/Azq3uncIHkuh6BtPsEALJbhw3axVvV9E6ffp3bridMKl+iIce+kc4jo6i9Ha0W5yd/XQk7PFdZma+dh3V6ed+7gscPvx14sr53LnPsrj4ScbGvsbMzH+96WeZnf3stmp2pxZ+6G9+5MiT/PzP/wKXLt3L1NQzHD78JKKYxHV7nD37SR5//Ld3HAmMjV0cQJn/TR577Gd58MHzVCqhCMj6eiFyGwt4662HuXjxAe67r8rJkx10PcepUy9z4sSL5HKjeJ7MmTOn+N3f/f8gCC5PPSWTSHyN/fvPIwgytt2hXD6A61oEgYemhbz+bncFy+pgmg1Ms4ZllSiXp5me/ji53CRAX1Bot139o4/dI/pTFtXqHLXaBfL5fWQyo1tWuYNJOJbOjA3Jtz8nlr6MvZfjRBzPlmGzUk6nh3FdE8tqk0yWqFbnEASBYvEA6XToGuP7LgsLL5BIFCIryFnW19+i211DEEQEQYhQyAGmWSOfn0QQJEqlKUyzg6rqXL16BtNs0u2ukE4PUy7PcPXqs3Q6q5hmM5Kv9PtWc6a5gSyH823PM4mlOlutK9h2h1ZrCVnWEUUFx+lGov0myWSR9fWzJBJDpFJDiKJEs7lANjuOabZQ1SSalkIQAjzPodNZJ7S/2zzWoighywmuXfsenc5aBDTzkWUV02zheaGCWah77eF5PqbZjIBoIrHsZlitaYhiEs/bqj0MPqKYQJJUPM/F9+OKR2JTLSqJJOl4Xjf6W6jbHP6MgV2xnrYPWLiuhiyruANrgZ08jTfb1de3iq+fPX8LScrgeW0GY3tSfeyxzzEz86XrruvrKVN/dosKliC4XL58H4cP/yHgMzv7eR5//L9Gj/+lm9o3hp/n/i3V7OHDX97h+QG+72Dbbaan/yvT078fn21CR6UR5uc/0N+OKLocPvxNhoaW2b//ec6evW3bzPhDpNNNggAMYwNRDHCcBq+//mF+93f/vwiCy7PPyvydvyNy4MAqvV4o5WqaLXQ9z9WrW9/r+ec1jhzJRoYSoe+6JMk0m0s4To9cbpxK5Rj5/B7S6T2srLyIJKWYmLib0dHTkW7B6m51/GOM3YT8UxZxAi2VDiLLW0n+g+pdvV61j4YetIC8kf52nKh1vYCuF7YogMFW7e14HwqFcB7V6axG9Cqf5eVX2dg4R7O5gKYVUdUM5fJBDKPO1NSDLC+/SRC4UauxhW0blMsHaTYXmJ7+OFeufJ90epgg8HBdg4mJB1hdfQvH6fVvQtnsOMnkEN3uCsXiNL4fsLDwLBMTD1Io7Gfv3vuZnX2CtbV3WFl5i3S6gqKkkOXQ7KHXW8e223S7ayhKAtvuEbdxQ2WwCUxzg1xuL53OGu32GkFgk8mM4vsO7fYqudxeJEmi01mOXm8CKr4vRspoKQQhnDX6vo8oCvi+jSSFALNe7xrhTFNCEFQuXfpZzp49ytTUNwYShRstPoYik4twrhpqZMvEM9EwCXqEtwNlR1WszQgTtiQpuG4KMJmd/fM8/vjvDoCYNqu+7fKSg7Hdh1iWSxFyvNt/zvVUqA9GCVlgdvZT/f28/nkP7TA7fo64ozA//8BNecmDMTv7aWq1fVsWFze2cnyUqalvMTPzNQRBIwgCRDEgmx2lVDrAsWNnOXNG7lOLHn74j5mZ+Qb1+mUM40Nb9vfEiUtoWg7f9/F9B0HQyOWmmJ9/cEuivXDhTo4dexrDWMVxrOg60Tl5co7vfnfzve6/P7xOK5XbqNUuEtqgHog02WvYdptCYR+almPfvgeo1c4iSQqOY/YtEjc2ZkkkSruz4x9T7Cbkn7KQZX1Li3kwYjT0dnGQQQBHXPH6vhtRmTbdpwbt2Qa9TWFrxR3vQ+zpHGpi67Rai0iSTq12GfBRlCzgsbp6lmJxP6a5Sb0KaUQhzafTSWEY1QhM1cPzLDQtQyKRj6qFHJ43hiwnyWb3IkkagqBQKOyjUjnM3Nw38TyfRuMyvu/S6WTodqt0u8soSgoYJZUaQpJU6vU50ulxXLeLKOoUi9NIkkK9fgXLahIEoW6273soSppDhz7G+fNP0uutousZqtW5SHDFIJ2eZGjoNiRpDtOsY1ntiB7jkUqNkUpVkCQNy+pEs7+4ihYRBJXQMcrnnXce4fHH/1WUEH89qva+iiSl0LRspBQWyn6G1ZrLJkBpq23h7OznePzx/zJQaW6vHHVUtRjJj5ZxXYOFhQ9uqR5DCdDNNvXHP/6bt3h1xkpWmzE19Z1tSfU7gBTRhX6/v5/bBUnixcRmFf5dZma+DiSYnX2UWm3/tuc/G71jjD4PouOxWXnDjWlbMGjl+Bv8wi/8Anff/Uo0YjAQRZV8/iAPPvgmmcw/5OrVhzl58hIHDlzENEsYRpWZmW/wF//iX2Rx8ZMcPPgi9903SyZzGN/v4Xmh05rjdLn99nm+971w331f5ujRd5DlJKKYRNMyeJ5DMlnkk5+0GBn5z7z66hgf+Uia06cXaTazrKy8GjmZmYiiGrmYQSYzhmW1WF19C9+3CQKfTGYP4+N39YGYjcbViOlQ3U3KP4bYTci7sSUGE2tcDe/kUxoDs8KZ9AUmJu69Lplvb4cbxga9XqE/k04mSxSLh3Bdk2vXXopMFxQqlSN0OisIgszi4hkEwY9a4TUEQURVU+h6HoDV1TfIZEb77eBwPryHkZGTXLnyPVzXIJEokkzmqdcX6PU2kOUUgtCI2s0qyWSFXm8DEFhcfJEg8PD98GZULh9CUTK4bo+1tYu4bg/HsXEck2JxImppqwwPHyObncKyalhWi6WlF0kkCvR6DfL5PUiSTDI5Dgg4joEkqbRa1/A8g1LpEBsbc306TGgQEIqZCIJMu71Cr7eG63YJVcMaiKKE5+mAeZ3B/fz8h5iZ+WNEMYumpWm3l6OzEFbAYTgDf4uToMK1ax+9aeUoywqapuF5vahqg/37vxcpSg1SkW40Z71RBFhWdWBfBFR1mJmZp6Kk+mEOHnyFgwe/SmhS8eCW/XSc1EDyfZ6ZmW8B6hawFUhcvPhnePzx/9BPsIcOfYXTp7/Ibbc9iyxPIElgWVbU/vfelbYVLwi2WzleufJB7r13FkUJjUkURcEwVvF9i7vvfpXbb/8Ovg+yXGbv3mOMjp5mZeV19u2r0+n8ExyngWkOY9stFEVHUTJ0u6sYxgbHjv0xv/IrDc6fv51Dh17hzjsFPC/N0NBRNjbm8H2TIPBwnA7Hj3+T++/fQ6m0D0HIs7raJJvdgyzrTE5+IGJO1Egmy+TzE5w//ySO0yWTmWB4+DYmJz9INjve1w3I5/eSSJR2W9Y/pthNyLsBXA/GCik5cp/KtD3CZHqQ9fVZOp0lzp9/koMHP7olmQ+2tMPt18nlrC2VdTY7TqNxhV5vjVrtEjMzn45oT6N0uxu47klEETwPLKuBYTQolWZoNq9F822BVmsF06xTKu1H07L9FptttzCMDfbufYher8rGxhyqmkXTMjhOF1VNEgQexeIUuh4KjcTtZRBJJvPUalep1y9GLXgLWVbQ9Ww025bI58dptxcoFA5QKEywthbOfguFg5H3s0UyOUY+fwBFSWEYSxQK+1hbe4tGYwlBkHAcIzKusIAU6XSFdLpCozGP69r9att1bYKgi+tKEdgr5N9OTT3HmTO/vq3ac/C8Jt2ujetutqPDebI1cCYFZDmP7/vIssyBA2f47nd/tb8tRbH6DkgzM08QBB5BICKKCoIQtujvv/9tguAv8s1v/k1WVk4S86PDOevOVoTbI2zvWoCMrg+hqmH73nE6zMw8wZEjz5BIZOn1wgr2+nb0t5mZeZqjR59BlhUggW17hDxri3AkAHNz9/VbuILgUixeYmbmKTRtJJrVtgh1wkOXpRtRprYnakGQ+x2CIJA5cOAFHKeH59mkUqFKmyxnSSbHkCSRavUamlYkmawwMfEgGxtv024v0+ksEQQ2rusATqTq5qNpGVZXX0dRkiQSBe688zXuvfcN0ukRksnjJJN5FhdfJpnM4ThyNIY5QxAoZLPzdDrXyGanIjCWQjY73mc4CIKEomgsLr6E74OipJicvK8vl9nrVWm1rmEYDQqFqetGXbvxo4vdhLwbwFZA161YO8Zm5clkKVpVmywsvEAyWSLWuq5UZvpUiXZ7GcPYoNNZixJC0E/4hlGn0biKZdWpVufYs6dEMlkmmSz3tyHLGi+//H8CIQJZUXR0PYsgiBH96BqGUWNk5CSJRB7H6eJ5HqOjp0kkwpn20NBRMpkRLCt0rWo2wxYc+Ni2wdDQbRw9+mnOn/8aExP3UKtdodd7EUGQGR09Qat1DUXJYRgbJJM5FCWJ74Oq5lAUjWvXXo0AXRkSiTKaZuL7HolEiW53LaKRCFSrF3Fdm0ymgm33yGb30G7HtpcCw8PHCAKfZnMF225GCPEMvt/FNB1CS8bwhg0BMzN/zF/4C7/EpUv3MjHxNDMzf0SYfFNks3toNldwHAdBUCKfZpNBwJbrOhQKEziOy8zMk/zCL/wiFy/eg6oaPPvs/7ylfX3vvZcRBBdJkgGBcvkwmpbm9OkXkaR/xb//9/9m25w1rphjFLdCLGayGWECl+V0tPjyMYwGvq9FiyOiis8mrux3FiRR8X3wPBlJEkgk8ti2iedZA/KU7X4yDilJP0BR8pFmuUecuMPZvM7MzDd47LGf5cqVh5mc/Hq/2t6eqIeG3ubcuZ/pfyLLatNuL6JpKTStGEmhbiCKCt3uegS2S0S65O2o5SxFiV1AllXy+SkUJUkqNcSVK99BUTR0PUMmM0q3WyWV2kciUUQURSzLiK6T8Lq8cOFrOE4bQRBx3SySlCCbHUOSNPL5vahqGk3LsLDwQuQ9LmHbDXq9Gvn8HlzX2uLFvr5+NtKdl0ilyj+029xu7By7CXk3gK1J+L182WRZZ3r6kywsnMF1zcgerkAqpfTnTPEK27ZD2lMmE1KNVDVFp7NKoTDFgQMfwnU9MpkhYt9kQYBkstKX88zl9tFsXkNVh/A8pz9TLpePIcsJUqkh0ulhUqkK8/PPsbExi22HoiLN5lXy+X0oSopqdQ7DqGFZHYLAH6ATmfzgB/8nnc4aYcs0iWHUUNUUhcJe4pZ2JjPMyMgpkslhlpdfoVp9h4WF58hm96JpWdrtFRKJNLKcIpcbj4AxFpnMGN3uIt3uGu22iK4XkSQF2w5pK5bVIp0exnFMXNdAVdPoegpdLyNJAr7v4jhXIkS0QJjcBMBhZuarHD78NXy/iygOk04n0LQigiCTThdptVwURY8ST4AkpUmnx3CcJqKYJpkcwvcdmk2Do0e/yunTz/P7v/+3rmuF33PPvyLUMg6wLJPl5RUSCQ3X7fLQQ+fIZv8ur746yZ49g4CtDHECDit0h03gVgrocvbso8zPfyziCf9B9HyNeCY9O/sJ5uc/EAGmnkIUNW677bvMzDzJ7OwnB+hOTwIOqlrEtht4nnMdUvuhh34L182zf//zzMw8hePE3QmBmAImCBlyuXFsu82JE89w9Og3EUUPURzm3LlPMD9/moce+kd4Xo69e7+zBT0dHqsHOHLkSQRB4u23H+Hs2RNMT7/CBz+4gCyrFIuHkWWFjY13aDav0uksI8spJEkhmSzgOBqSlKBcPk67vcDY2L0YRpV8fipybQqFdly3S69XI5EoEAQelcpt1OtzJBI5VDXF0NBREokSqpqKFn8FNjZmmZx8CMtqR6Oni+Tz+6hUjuL7kE5XtrArRFFmYuJeqtU5CoWpvoPbbvzoYzch7wbww/krh/OoB1ldfQvDqFIsHoz4xJtJfnz8LvL5qb6NoiTJVKtzWFYTRUkhSTrpdJFKZYZOZ5V2e5Fer4miJHFdM0paGY4d+1kUJcXw8DFarUUEQWJ09BiHD3+ManWOUukgvV6VIAgrskSiwOrqm33hjUQi11c3ymQgkcjj+x7dbrWvKAY2yWQeTStE+6vS67XI5fZg2y0ymT3s3XsvGxtnWVpqoqoZstmw7V2vz9NsXkLXb2d4+CiW5WAYa4BPp7MY0Vc08vn9qGoSVc3Q61VZXn41Qmx3WFl5Bdt20PUkmcw4iUQoFBIEAbKcoNmcx3VB11N4noFlxfKfKkGQpFyepFCY4erV5wkCF9t2kGUZz2ujKBJBoKKqWYLAQ5YVHKdFu+2RzY5Ei4Asnudz9OjZPngolIR8hWSyTCJR4NKleRYWruD7KySTUKmoiKLI5OR/YmSkETlWxWpZHoqSwnE6BIETtUHjhNzdNo/9HweAZBaQZHb2Ezz++O9Fj/8NfvEXf5Hp6SfxPIPZ2c/w+ON/0K/if/7nf57Tp59HEDxEUQd6zM9//Do+9Gc/+4/Q9TTNph+9D4CEKCbx/RAVXSzuo9dbp1a7jO9b+D5cvvxx/v2//3cDNKzPc/TotxBFkTNn/nr/79PTL6MoOrOzn+Lf/bvfQhBcvvGNP49l/VUeeGCNoaF9kb566NltGHUEwUeSEqTTozQacwSBT602iywnuHTpaXS9RBBI0TVrkUwOkUqVUNXQ7zte8E5OfoBCYR+iqNFqXcUwNqhW36FUmkYQBHq9NebmvkkqVSaf34MohniFbHYCy2r2xXYGrRYHwaCqmn5f94ndePfYTci78b5i+8xZFGWGh4/tqP4V+hhPIooytdoc+fwUul6g3V7u06MajSv4vksqVWF9fZYLF57C83oYxoOoagrPC/Wgi8WDjI7ePqCPncEw6mSz4yQShSiZLyOKEtPTn8CyQjEPy2rSbi/T69WoVA6zumphmvVIEEGP+KMtWq3LJJMVqtWLaFqOQuEQ3e4qtt2kUNjLnj33MDx8jMXFl1lefh1RlCiXj5JKlVCUFKHYv8q+fQ+zvPwyGxsXMM0qudwBWq1LyHKafH4/2WxYCatqikZjnlRqOKqATSyrQ2gekCU0wTBptVZIJPKMjp5AVTOsrr4RUawyBMEGqppAlpO4bhfbNllaehHPM3FdC0mScZzQqi+sgEZJJvORsthiNGMOOdOynEKWZXS9wEMPXaBU+he8+GI+Es/4Os1mkl6vy8svXyab1UilAnzfZn3dRpLMqB0+aEUIYOK6KoIg4fsWlhWC0+I29o2tEXVEUb9OinJu7m4OHfpDwL0O0Hb16ge5444zkeyqiixr7N//Hc6c+Wtb5sC23SGVyqIoKk5fETO8FsOEZ0RoeZtEIg+E/PUrV7bLYn6AO+54jRMnvgt8gStXPsh993W55x6BIPgYTz1175bnX7hwNx/5SJ377vt11tdnuXjxGySTQ7iuheO0sW0Dw6iRy00iyxqVygwXLnwN8HFdg1xuCte1UNUko6N3IggwMXEvFy8+g+sarK6+gq4/wtDQcbrdDWq1C7Tby0iSRjgTf5D19fM0m1dZWvoBhw9/ij17JkgkCn2NgPj33fiTj92EvBvvOXzfZX19NkIjuzuisG8cQT+ZhpJ9JVzXjMAqRYCIu3uNdHoY2+4iy1ofua0oOuvrs33/5RC4VWN19S3W1t5AllNA6DecTo8wMjIcUTaWaDavYBg1FhZeYmXldZrNS+zd+0H27r2PcvkwGxuzBIGI73tYVgtdLyPLMuPjp+n1alHrucc77/wh7fYK7fY1JiYeYHLyAQDW189RLh9iZuZnkCSF1dU3SCSK+L6NadawbSuqzEdR1RSua9LprJNI5MlkhimXp2k0rhIEdtRqHqbVusbGxnkMox6hxYewrCaiKCAIIqOjt2MYVWQ5Rb1+CUEIqNev4HkWul5EVdMIAshyil5vGUUJQU7hAupEhO59jVZrEU3LYdtLhEIjAoqS44EH3mZs7Hm63WVs28D3A2w7STJpoCgqQSBQq6Xp9TpUKqF71qa4iEpMZQoBW+E82fNsCoUZXLdHu73G/v0vXAecmp39LPPzH2Rq6rvs3/8MZ8781S184lBqU2J6+sUtlemBAy+SzU5Qr18mmSzT661zzz1voGl/mYsX72Lv3u9y8ODXCALodjfI5Sao1Zy+aIogCChK2LkIxWhMTLONKIpoWobbbnubZ54ZpEs9jWXVSadHOXXqBU6deoHR0RPMzPwiy8uvc+DA93n22V8eqJx/wN69D+L7Ho3GZVZWXkMQ5KgzkUeSVFzXRpI0xsdDHEM2uwdVzZFKhQArRVEYG7uHIJBxnCbr6+fIZveQTJYoFA4jCFLkOb4HgIMHP0q1eplsdgzf9xkbO0WjcTkSurFIJsPvYzzKibtYu/EnH7tHfTfec4Qt4RBZGv5/feCxG4vOD2pcx+G6JouLLyGKUt+MQtMyJJMjJJPDHD36OdrtFVQ1iWmGvOPYhSqcR++JKi8Xz3ORJCgUJjGMGuvrs0Ao7VkqHWRu7o+x7S7N5jyCEFAs7iefn0TTMrzzzh9Qr18CBHS9iK4XEMWAdHoEw2iRSlVwXZOlpVciJTKBbHYPvu9TrZ7rz4NDBSuT8+efottdY3T0TkxznUrlOFevPkulcoR0eox6/TLdbi2S/jxEIlFhdfVNUqlSZJxxBFFU8bxQ+N91HbrdBmtrb1Ms7iOZLJDLTUbzx1UkScHzDAyjE9n8hd7NjtMlkSii69nIsKOJbfeo1y/SaCwyMXEf7fZKpBXew/c9Wq0FgkDA91dpNlVsu4Xr+hFntUgQiBQKAbIczl0FwWdoCMBBUTQkqYDjtPG8xsDZt0ilxrDtTjQnLRMEYcU+Pf1VHnvsc1EC/jagbOEYP/bYF3jssT/H/Pz9EYDrWWRZQxQl7r13llLpt3j55THGxr7K6dOzeF4aRdExzRqaliWdLvGxj9Wp1f4F7XYVwwgNKhzHpNfbIJMp024LyLJIMjlENjuM57nkcpNcvnwJ37cJPbXTnDz5HH/lr/xPzM3dw+jokxw8+DSimEHX06RSZWy7je97XLnyXebmvs6+fUv8hb/QZWPjz3P77Vc5ebKGYTRYWXmDtbVzOI6FqoZUPt+3GR4+Tbt9Fds2WVx8MUI65zlw4CPYdjsyFVEpFqcjet0C3W4NTUuSze5B05IcPPgo9fo83e4ayWSBVGqoj9sQBAHDqJPL7UXTMhQKk1hWG8dZptdbo91eoVCYotNZ3XVz+lOI3aO9G+85dkJh+757S+jsOOKZdViZha3Zdns5kqhU0bQEiqLRbq8gijIrK29g2+0ITFXuv18qNdRf1RcKBwgCl0xmtA8wu3jxLJZVYXx8nKGhYa5c+R6iqJBOj1IuH2Zy8gGuXPke7fYiipJifPweJibuAaDTWWFp6XU6naWIRzxMt7uG5zl97nOjcYmVlZcol49FiS/DtWs/YHHx+5HP7B4U5TCaliWb/dl+da4oCSyrge9bDA+foNG4RLe7Sq+3jqalsawGoc+xTCo1jOc5CIKMJEkEgcvp07/M/PxzdDor1OtXUBQ1oi+FEqC6niOX20OjcQ1ZlslmJ0kksoiiwvr62agNv8bCwvNks2NkMsMUCgeYnf0qjtPDthsEASQSIWpcknQsqxZVcxojIyU2Nqq4boCiCExMTJNItFDVHNnsMNXqBXq9RnS2Qy1twzDI5/dgGE2q1avouoogyIiiwMzMlyI3KZ1vfOOfb2sL38fHP/53mJn5fUJHrGIfWCYIPo88ssbevf+Rdvsatl0imSwgCD5BEEquqmqOVmuJTqeO64a6zbZt9sclluUjSRLZ7Bil0mEMYx1J0lldfSMaQegRgjn0DX744UU+9anvsbR0gU5nD54Xjhmy2Tyu26PTWafdXqHZXCQILGZmvkKxOIeq6sjyJLncGKbZJJsdxXGOkkyWMM06ggCqqiOKMu32lT64MJW6B88zaLWukUwOIYo+qVSFXG6CVmuFy5efQlEKCIKIYWywtvY2vV41WsjqlMuHCS1E833Wg+N00bQcrdY16vXLqGoGXS+Qz09imq0IA7Dr5vQnHbsJeTduKbbPjAe/qNt5yzd6fdjmDnnK8fPS6WHa7WWWl1/DMKoois7w8ElSqSEgrJYbjXmy2TFMM5wHA31HKNc1MYwaxeIBKpUZarU5AAqFffz+73+F3/7t/0yjYTE0pPCFLzzMnXfuBwI0LU8yWaBanaPX26BYPEyxuJ/JyQcwzXDevLZ2Fsdpo2k5er00i4uLiGKHsbHQxKJcPkgQ+LTbq9h2G1EEQSAyvtAYHT3F0NBtdDprNBrz2LbB4uIZQKBY3EepdJhW6wrr628RBGBZNbLZMYIAksky9frFiI8qkM/viwwsLIJA5NKl7+D7NqlUJdK4dtB1HceR0LQUQ0MnkSQI5TeFKFEYyHKC8fG7KBQOsrDwHKqaQVFSzMx8jqWlH6AoGkGQQBBUVFXCdQ1SqTLN5hq2beB5VWR5jFJpD6qqY9su+fwIw8OHqNUu43m9iGKV6J97SSrgeU18v0a93ovazQGOo5LN7kEQVEKaVhpVTXLo0Bmef/5XB9rCz7NphmFjWU10PUxAmpYhnR4mlxvHNKskEjnS6WESiSLLy2+gKFrfMUxRNGRZQ1WTdLtVQn3pUQxjHds2aLdXSaeHGB+/n+XlV5FlDd8PPa1lOUGpNI2qphkZORWh73Pkchr1+mUEQYk00E0sq4nvC9GiQQQkut11DCNUWOt2Nzh8+GdYX5dJJocIgnAOL8sJNC1Dr7dGpXIMXV+m0Zin3V7i7bf/K+XyIXK5vaTTmy3lVKqILCexrDqSpOE4Lisrb5FIhKj9bHYiSvhNGo15isWDpNPDWFabQmGKajVs3YuiRKVyGFnW0fUcptncnSP/KcRuQt6Nd40bJdM4bqUyDtvcHoKwtWUdz5MFATQtTzY7RjY7TrF4ACDyVpaQ5SSSZLC6+jqjo3cgCDK9XqiBLYpifz9DE3h4440z/N7v/Q6mqTAzk8O26zz11FMcPPiXmJo6hiiGs85w/qqyZ89dZDKjmGaTjY1ZarVLqGqSXO4UX/7yc3zxi/8SSWozNeVz332f5BOf+CSLi69QrZ5jY+MsnmeTz0+QSg0hy2nS6SF0PQTJdLvrdLur6HqoghZWmQUSiWKk1uVi2wa6XsY0m2haDsOooShJgqBNOj2CoiQRRQHb7mLbHdrtazSbV1HVDMXiQSyrHnGfMxFlzKfbraKqGRKJAoaxTqu1HHUS9jE0dIxW6zLV6iU0zeLCha/T661hWV0URSGfH8NxOjQai9HCx4rOv9cfD5w//zHOn7+TQ4fOcNddb2DbXVzXo9e7iG0bhLQsN5LYTNPrrRIEIrKs4Lo2mpYlkcghCBKdTljJBoHPbbd9k1/6pV/m/Pm7mJp6huPHn0OSSgiCEHVQMmhaIuLY2nS7y5HfdB3f9+l01gl5zQk8z8b3XRQlRT4/Sa9Xp9utYZrtSFLVQNPCylFVExGyvsDrrz/Ia69NMjb2NQ4d+gMkSaVanUMUw85Jo3GZbjc0UwntEOvR/vVwXRtRVBBFEd/3+9WoJEkoioLrmqytnWVk5Dj1+kU2Ni5FCXEmEq3pkcmMcO7cV6nXL2NZbVQ1iSxnmZ7+OK5r4ftuf/GZTo/hujaKkkQQPPbteyjaV4lG4yLr66ORFrVNu70caQLUcF2TRKJAsXigbxajqqk+W2G3Xf0nH7tHfDfeNW6UTN9L7GRKEVfd8Zc/toQcpFzEc+fYAQrCJF6pzJBIFPouUkHgsbLyOpqWJZWqsLR0GUHosW9fBVEMyOcTXL7cxvcn2bcv5GCWSgcHPF9D/W1VzRAEkMvtIZmssLjY5Itf/PcoikehMES3u8FXvvI0R48eRFU7JBJDDA9rKEoC33dZWXmTVGqIYvEgoiixtvYmQSDjeQ4LC99jbe0tFCVNJjNKJjMUcZ03SKf3RIpf+wDI5/dj2z1kWUIUdRRFp9W6QiYzSru9RqNxBVFM4Loe4+PH8H2PILBZWXmbdnuNZnMBCMhkxigWw+palpMkk8PIcpKxsROsr78Z2WB2EUURUZRQVR3HMWm3l5ia+jiu+23a7bWoDV5AUVIoisRbb32C3/7tf4IguHzve38V+GUeeOAiqVSRtbVzBIGA4wj4fg/XNRkbu53FxZcACUWR8X0RVU2QTA7jeTaqmsG2N1CUENh09Og3OHIktEoMwUr7keWQwxwmuHAuLkkyplmLPq9D6NzVQxR1VFUlCCTa7QVkOUcikUaSdMIOSeiLbdtdBMEnk5kgmcxRLO7n6adH+Gf/7C9Eil6/yM///J/n5MnvR2ONUNCjXr9Ct1tHUURUNU+sLa6qmWjmrOD7m5SqIBCZmLg/WmSFHZ5m8xqm2abVukIyWabRuILr9sjl9kbXxxiFwl4EQUGWddLpCgsLL1CpzJBMhqj+VmuFYnEKx7GQ5TTJZB7b7pFODyMIIqIYdghWV18nmRyO9N5tut010ulRZDnEBciyjusaVKsX+m5tN9K8340fX+wm5N3YMQZb1DdyeIojNImYo1g8uMU7+d22PWjVODx8bMt77hSpVIVUqtKX84tFR1zXoNer4boWsuyi6zmmpk7hOEm63Sa5XJKNDZNUKsGhQ/ehqmlc18A0m32Qme+7USUbop6DIMA0m8zPv4VpGmSzI3S7Cooi02is0OulyOVURkdvj8BkMu32KpnMCKlUJVI+6tDtrgAe3e4att1GUTLk8xPkcpNIUhpZTpJKjWIYGxG9y2Lv3ofwfY9kMvS/TaUqtNvXIqBVODsNxSt8XNei01mmXD5Or7dCIpGL5pFhtdbpLGEYk1HFngcCDGOdRuMaQ0PHaTQu43kWhtFgaupDXLz4NOvr71CrXUHXf8Dw8O1I0jk6nQ0cp0MyWUJVE1y+/AFE0eurXl269AHuvvtNVHUvo6Mn6PXWkOUUi4svoigqtdpFZDnkTQeBiCSJBIHN4uILGEab0PpRRpIcdL2I6xoIgojnhX69YedBoVa7TDIZulelUiXS6TGWl39Ar7eB5wWkUjl0PU+3u04QSGSz47zxxs/x1lvTHD9+nmPHQsWrZnOZZDJPs7kUdUKGGR19AFEU+N73Mn15TVF0WVz8JHfc8Rq23aZYPEg+v59q9ULUCndR1TSSJALpyJnJxbZ7eF6INBdFCV1PYtsGmcwwmpbD8yxyuT3oeoZOZx1NS0bI+AKeFyrdlcsH6fXWI6c0hfn5ZygWD+O6PYrFQ5GZSWjNqWk5XNfA9x1arWu0Wgv9jtP6+iy+75NKFREEiV6vRqk0TSo11EdUhz7d8wwPH2N19S0KhanrxlS78eOP3aO8GzvGoJTmjfSst0aw41+3J1/fdyOrRZdksnKdVeP294n3o9tdRxBA1wusrLzO8vJrjI7ezsjISQBsu4PrGgRBjsXFH7B3b5kvfOGTfPWrX6LZrAM6n//8ZxgelvsqRLGTVbxPhhEK6MecYNNsUC5ngDSrq22GhzM0Gk1yOZliMceBA6f6yHDLajMxcR+rq2+h63larWt0OuuoajpqbYZAsHL5SMQdDlhdfSVCUa9QLM6gKGny+QkSiQqFwh6azWU0LYVptnFdD9cNLSR1vcjU1D4Mo87KyquYZgfHaUVqZSOMj9+H43So1S4jywp79txNvX45WvxIEcUsg6omGRo6hmE0yeVCucRSaR+mWY/m0gbgkU6PYNsdTLNGKjVMpTLD6dPzfP3rUn/OOz7+NarV87TbS4yP38n4+D1YVpggXNcERGy7jeuquK6BoqSw7WbkRBXOeFU1bCunUkMkEikMo0W7fQ1Ny1MqHWVj4x1yufHIHUymXr9Mp7NMIlGmUAg53CDQ7W70FzDnzn2Cf/kv/zai6PHUUxK/8Rttjh9/BlkWIsS3QCZTJJPZS6Wyn2vXXmRmpsnXv/45Yjel06cXEISAXq9FtXoe02yQz09QLB6g1VqkUNhP6PJVx/cdZFml2bwa+UVLkY61gu9bdDpVSqXD/TluyDM3WFm5iKZlqFSO4nkusW/3wYMfZWnpNRYXn8e2e7iuwfDwib56nShK5HLjgIiuZ/B9H0EQyOUmSCbLVKsXAcjnJ5mcfIh6fZ5ksoQgSP3FrWk2+/aoocpcKHCTSBS2eJvvxo8/dhPybuwYg1XxjVbK2/+u67nr6BKDPsmxnaPnWVhWm3J5BtNs3hAQFifq2BA99mRdWXmT1dU3gQBFSVGpzOD7Lrnc3j4qttG4whe+8CscP36MWq1JOh0wPj6BYVT7gJXYbD2sjlfRtByZzGjfXlIUZQ4fPshv/EaHf/2v/wmt1hL5vMSnPnWKZLIVJS0rmg/KrK6+hWnWcV2LdnspqupUJEml3V5kZOQksqyysvJOVF2Fkp0Q8qkPHPgIvd4aqVSeTmcNSQpvmqGQhhe5VCXw/RBJ22xeIZUaIQhC56UQpFTBdY1IL1kkkahE4LWz0cLIIZ0eZmHhDJnMOJbVRtOSBIFPKjWErucYG3uAtbWXabUWI/512OYN294qipLh5Mnv8Wu/doE33zzM1NTTzMx8HVlOIYoKplml0bhCJjOG4/SoVG6LZrvhzLvRWCSXm4ioaxpnzhxnfv6D3HHHMuXytwGP/fs/zOXLT9PthqInGxtv0W4v4Xk2ipIgCEJKl2k20PUiudwBOp0ler31CJEOiUSRc+fu2FLtvvPOMT74wUWKxQN0Ouv4vkWlcpSRkdtpNq9h2x0+8IEOkvSPeOGFAvv3f4/Dh8/R6wlIEhhGDXDQtCKFwj5GRk6STg9RKh2i12vS7S5Sq12KHLZcJCmBJIUYCE3LoKopRFFFlhNYVhPDqEde2wkUJUkutyfqCoCmpbCsbmQ9WqfTWWbv3rDDEyfQfH4S2w613VdX34kAjvuYnPwAup6jWj0HCIyOnsS2u/0xTbxA7nbXsawm+fxUtEDOUa3ORYA0+q5tu9Xyn0zsHtnd2DEGE2Sns7ojv3h7Fb3T87a3u+NqNJGQtiA5d2pT93pVTLMeOdSEl6qu5xgZOU4qNRwZJVh0OqsAlMszfbWhfH4SSdL48If/Kuvrs3S7ayQSRVKpcFHQ6az2tx1+XmmLIEIsFej7Lr/yK1/gwQfv5ty5p9G0LrrejWaPAktLP2B09A5KpUPk81Osrr5FvX6RZLJCNjtOpTLDxYvfQpY1NjbOEwQChrFOEIAkxdW4x+jonSQSWSyrhe8L0ax4GUGQSCaLVKs+6fQQqpoBDBYXf0C3u0QiUaJUOkIuN47jWJhmC9/v0euFHGfDqDI7+0eoao5K5QiSpKGqWVQ1i20bjI6eolI5xtDQ4civOk+pdJAgsKKuhEY8xw19pH2Wln6ApuncccdLHDr0BL3eKoqSIpudiIxClgmCAMOo0uttUKudI5kcxjAamGabIHBpt6+RyYzx8st38vjj/xhRdDlzRuaXful/4MiRpzDNVtTil/F9j2ZzHtsOFcAsq0cikSI09shEAhdtXNfE930sK1wUeZ7DkSOv8cd//Gf77fXjxy+QyYzTbF6OQFeQSJQQRQXbbgMi2ewYH/94l337fodOZ51WS0HTipTLMW7BwfNsXNcmkSiTyYyTTod+275vousbKIqMbeuoajZa5I1SKh3D90Nw3PDwMZrNa+TzUxhGvX/9y7JOobAPXc8xO/tV6vWL5PN72L//kf7j8cLXsppIkhYlVo8gCEcn+fy+yBBillZrCUGA5eU3KBaniN3Y4oVuSPtq9Ec3MabDNJvoeo5er9r/fu1Wyz/+2E3Iu7Fj3GiGPBjb/77T83aiSFUqM9fNirfPj3u9ar+1HFeztdocmhaK5heL+yKgmRRJb873NbRjPez4/QYlPePtxBXBoOfzYAt7EEgWSnHW2bcvh2EE+L4YoXprdDprkYZ3jYMHPxqpb62RzycYHj4Wvf9tVKuzNBrzOI6BIAikUuVIdKRGEAQ0GlfY2JhFFGUSiSaGEaJyQ5cnm3z+IILgY5ptisXDZLP7uXz5mxw69ElarUUkSY8WOjkWF88jyxq53F46nUUcx0TXhygWJ+l0qiSTeSQpgW23ME2LXG4KUVRoNK7iuhdZXX0bXS+Rz0/g+yKVymFarSWq1bN0u+s4jkG7bURCKBrp9Ci53DiiqNDprOG6DpIkMzR0HMvqEgQBkqShaXk0LU23u4Yoyrhuh9nZ2xm0Qzx37iT79v0nqtVLgBftpxnxq3Vct4Hn+Yiijywn6fU2eO65Sebnf4aTJy9z/PjTkZ+0j+c57N//e/zar9VYWvo4t9++yIc/LKDrFWw7BPN5XgJBCBAEgUSiRCJRIp0eZ2npJZLJUvReckSnGkeWZSyrEyXvgExmJKrYQ0EVx+mQSOSpVI6Tzxvs3Xt/JItp4vs9Op1VVFVndfUtUqkyqpomn5+MHJzWCQKvj2UIt3kNx+khSUmSyWJkhNKM9qmEYdRZXz/L5ORDVCqHSSRCv3FRlCmVDuL7Lq3WMu32AoZRIJ0eZWNjFstqMT5+d791PvjdiLEg4f8vENL0DrLd43w3fvSxm5B3Y8e40Qz53fjIN+Mh7/S6VmuRWm2ubz5QLB4CYGNjlkSi1E9q4TZCys3g7Cu+kcQz7MGZdaMx39//uCoOK4RgS8KNASy+76KqGdrtZSyrGd3wqlSrs/R6DSyriSCIlMvHkCSVvXvvRRRlHMeg0ZhncfEHjI/fCdD/GbfwJyc/QLF4iHp9HtNsIEkqxeIBRPEwQRBQr1+k3V4kkxlFFKWo+i1iGFXOnv0jJEmnUjmKothRq7ZJOj3MysrL+L7P2tqbKEqs1pSKaD1lKpXDUUWZZmnpVdrtawhCwNTUQyhKkosXn2Z19VWuXTMxzVZEt0owNnYaUdRptxcAP5I1DUFS7fYKrVaDXq+JJMmk06Ok00ORmISLquro+hDZ7BiqmooMC5yI/mQhCCKSpKMoOQ4deoFvfevn+kl5//7vE1pCdhFFhXJ5AlVNsLr6Dori4vs+oiiSTg/Raq3w/e/fxn/4D/8aUXT55jdlfvM3PY4e/QaSlIoWI00OHfoyp0+/wPHjv0A2e4Dh4WNUKkdptRZZWXkZx3FIJLIUi/tJpSp0u6vU6/O026ukUqHbWLe7ge/b6HqFcvko6+vvUCweoFDYG3U9Qpqa5xmsr58lCBwmJu5hZuYztForXLr0DRzHoFw+Qrl8mPHxOzHNZrSAWyWdDiVeFxbO4Hk2oihTLO6P+OktVDXV7/AMLiIbjfmoFZ5mdPT2Ld+5wS6P64bt6pj3H8673X7re5NtsIkFSSZL5PP7+hX8rg/yjz92E/Ju7Bg3qoq3J+pbmS3dSPt68/nxTUDov8ayWv33ixcEobhClUxmNHKTkre8d9xyC+eIbn+7ocXcXJQMpP6NaXX1LVZWXuX/396bB8dVnnnb1+l936XWakm2jHdjwGwJGMjLJCQTQj6yTZIJlYQMWViGSU3CCxmyDclkMlUzhFQqmUyWd6jhmySTTAKTj2wvARMwOxgw2GDZkiVrbfW+L6fP98dZ1N2SbBlbRsbPVaWy1X369DmnW+d+7ue5798vl5vWbkoZTdv4AJVKFp+vBwhzxhl/TqGQIJE4oE27xqnXi7z66m/p6NiMLNdIp234fF2G85V6HHFSqWGsVg/lclprZek09q8KdhQZHHwrdrubePwVenrOJRQaJJkcJpudYGZmP2DBZvPS1XUWxWKSiYlnyGYnqFaLeDxtmM3qYKZWy2viEAVNwlINpB0dZzI5+bxWzRukWEwwPv4cAwM7aGtbx+HDT6MoMlarWn1eLqe1oAKlUgq73Y0khVBdm7y43R1aAZzaCtXRsYmenjczMvIQXm+vZtwQwmRy0Nl5FpVKAafTRyZzGF2aVB0Qebngghcxmz/H0ND5bNz4MqtXv0g260aWa7hcAbzeHq11qqz1/Nowm82kUhPkclMcOHCtUXxlMtV49tlutm3zkM0e1qZ0zdhsFvL5FK++ei/r17+bQKCPcHhQ88bOoaqIZahWVZej6ek9JBKvaAM0Fz5frzZYidHVtZ3+/ouoVguYTFaq1Trp9EEUBbLZCcxmO253B5VKlnB4PeHwoGZU4tP0yjfQ23u+Nv0OqdQwtVqFeHw/weCAVuGP1juepL19nVGApbcA6ng8URwOP1ar28iGW/8WC4U4kiThckWM16symgni8SFDla7171z/OzWZLJTLaQqF+JI6KATHhwjIggVZLNttDdStAXohGrWvVUGD/YRCa43tQ6G1TRkvQHf3eU3vo0pItlEup5v2m8tNkc/HaGtbbwRlYJ7aUCg0SCy2j1IppYmJWKjVSlgsLmw21ZCiWExqVo9ZTCY7U1MvEgj0UCrVsFgcrFv355qiWJqxsYex2wNMTSkEAn1YrTay2UlDmEQfFNTrMoVCgkpFHWAEgwMUCgn8/h7K5TyVSpahod/jdrcTDK5GlmV8vm5isVcYHd1FKDRIT8922ts3adOXZYrFNPW6Qih0Bl6vmlkVi9O4XB1kMqOYTE7a2tYSiWymo2MjiqIwO/sS1WqGWq1AoRAnnR6jo2MLweAaEolDAAwMXEQ+n2Bk5CGtj7aE1boaj6eDvr4LARPj409Qq5WxWl2EQmuw2fw4nWHS6UN0dGzBYrFgsahFV6qSlp9QaB2JxH6tWryA0xkEzFQqWVyuDq6+2oHLNYnHs46pqXczPv40udw4DkeAWi2Pz9dPNJrG4WjHZKqRy80iy1XsdjebNr3Crl2Whgz7T2SzE5TLasW11eomEllPLqeaYySTB7HZ3GQyhzGZTHi97VQqRTKZcTyeDlQt71FNTMSJ2WzXdK17URQZm81HvS5rA5I6LlcAgGx2nHR6GI8nysDAW7FanQQCPRw8+Efq9SqBwCo6OrZisThIJkeMjoFQaC2x2D4KhVkcjoBRtQ+q6pvJZDe+2zqNgbcxC15IvMflCmutfGajv9/j0aVNZ0kmR5qWeGBurVhfxlmsg0Jw4hEBWXBMtAbqpah0NW6j/uGrmXBj0ZYqfDA3JbbQaLzxfXUta3WtrWZk0o3H17g/jydKrVYimRzB4fCRSOzXXHWsmjFDlVIpZay9qkYWdTKZCRSlrgVpi+H7XK2eQy43hdcbRZLMtLdv0gqR1BaearWEyxXSitgS+Hw9WCwOcrkZZmdfxufroavrbIaH1Slki8VBZ+fZmM02hod3amuRYSKRM1i9+i3EYvsoFpPIcoVyOUWhMIXLFSGTGdGy/yql0phRcFStqgOLQiFBoTCDzeYjGFyDJJmoVnPazT+suWnZtGlPHz5fD7VawfgMDh9+EqgjyzW6us6hViuSy00iSSba2jYCkjYLoBYArVnzVmZnh5icfJpkchi3u514fB/B4BnU62Xsdg+h0HocjoBWkV7RBmfqerrJZCYcXoPbHcBm8yDLCiaThNMZxONp19bUFYrFJG53hAsvfBG3+0vs338eZ5zxLFu3HqJQkAAJm81HKLSGaPRMQqEB0ulxPJ5O3O5OzGYLfn8P6fRharUKkiRTKMywfv2VeDxRLBa7Np1r0cw82sjnJ6nXVStMhyOgre16iUTCuFwh7HYPweBaOjq2YDZbyednsVqd1GoVAoE+PJ6OedKU+iBSV8fSuw4cjqBmkzl/5qmxDsJicWCzuRkbe0KroO+Y97eoDoCaB7fd3dsZH3+aYLCfQiHO7Ow+SqUMXV1nG9ao5XKaUGiQSGSDWDs+SYiALJjHQgVWi01J6wFQX6M9WlvEQo5Pi/2xL+S53KqbvVCB2EIUCnEymTHMZgtms51QaC35fAyXK6QVASlUKjkqFS+RiNpjqqt5FQpx8vkYFouN6ek9hMODRrW27qBTqRTIZEZJJkcwm1UvYHXttEalksXpDGE2W6jXLTgcYfL5WYrFJNVqCUmy4HCoCmPx+BCplCr2v2rVm3E4PBw48CAmEwQC/chymdHRxwAzkqRgMnmRpKyWyVhxOr1a8VieXG4Cu93J8PBOoE44vIFIZA1udwednZtxu6MUi6/i9bZTrcpMTT2HJNmMdiu3u03zUC6SyUzi8bSzfv27KJczDA39AUmyMzu7B5CZnn5WqwyfwO2OUCzGcTrbNJ3lNIXCDC5XG9Vqkc7OrVoVthtFUb83lUoOn6+XtrYN1Gp5pqZe1Hp6TdrnUsDj6aa39xwkyU4mc5BKJUulUuDcc3dzwQX7kSSZctmMxWKjXi9itTpQlKq27i3hdOZwOPzY7W6czoAmCVogFFqNLJcwmx3UahX6+i7CZvNw8OCDWpuVB7vdT7mcx+n009W1jUolQyo1Qqk0TSRyAS5XmDPOeAdWqxubzc3k5G7N3OMQIGlZddJQv1KLrcaN77H+uMOB9r088pptvV4jHh/SrnWSVGoYSTITjW5pKFCc6/93OIJNf0uVSl5zp8rjcqnFbCAZf2PFYoJs9rChfS04OYiALJhH4zS0+vuRp6RbX7OYuIf+XOPzS9ln47rz0TJyfWCg71sfHLhcYaNgrDGT1m9SejsIqBlFpZLVfIs92GweAPbu/W9NU9pi3EB9vm5NLaxEPu/BYlEMKdBiMallGhnsdi+yXKWtbT3p9CjFYozh4Z3k81O4XG0MDz+M0xkgGt0CoFngTfHcc3drr9vA5s3vo1hMalW0ZsxmG+VynJmZPaTTh6lWM0QimzQTihKh0BpisVeo1apUKmkCgRqKotDWto62to3k8zFisb2YTDYymUNUqzkCgQE8HrUXdmjoAWKxF7QiLDtQw+UKMT29B7PZRj4/iSxXyGSmsNudmM3qmvHU1EtYrS48nk6CwQFqtTxWq5tU6hCh0DqsVgceTxfB4P9ibOwJYrF95HJTBIMDdHdfTDY7qTkmTWK3e7Baa5rusod6XcbjCaIonZhMPchyhUhkPT5fL3v33ofZbAPU/lybzYPb3U6lkiUQ6CMa3UZX11ZyuRgWixO/36tt00Zb23rGx5/BYrGRSh0il4vh80UpFvNYLFamp3fjdquFana7n2CwTxMJyWrna8fjiRIOn2H0o+v+xpIkk0odMr4H5XKWRGKIel3GbLbR1XW2VhMRNoqsdHvRhQa4ej1FPj+Doih0dm6jXpcJhQaMv6eF+v8b/wZb2xEbOxEAw9xF7We3zFu/FiwP4goL5rFQ0DtaBnqkQOlw+LUeV/9rOo7Wm0ljxXfruplawKW2ajROXzdODS4kcFIqpTVziaS2bXOLh5pNVZEk2dCtbi2w0dW+9JtrsZjUzALylMtZzGYryeQIq1e/hcnJ3VoQeJZMZopcbgqz2U46fRi73UMyOUIqNUqhMIuioJlYvILD4aev7yKSyUOUy0lMJjvB4CDlco5yuaBVoXdoIiQu2ts3ARIWix23ux273UOplCQW20c8foB0+pBmqNCFy+VDUSxkMqPkcuOYTKr7kPo6P5HIepLJEWq1Eg6Hn0BggEOHMng8EUDG5QqRzU6Ryx1GneYuIkkKHk8nZrMds9mKyWTV1lEPGsV1sdhLeL2dmM0245p3dJyJwxHE7Q5RKuXwejsMgZVMZlxbGjAjy6pyVbGYwuOJan24g+Ryo0iSFZPJrgmb1HE43IyPP0M6fYjJyWfxersxm60oimy4fiWTw8hyRav8d+F2RykUcng8PdTravWzxWKnXM4TjW4ilTqM1WqnXFYrpmu1Ena7l0BgwBCsefXV36JLWjocAcMz2Wp1kc1OGK5Ubnc7bW3rF/zONw4056aezZpPd1nz0c5gNk8vGHAbB7WNfw+LdUxEo5u1lr8JMpkxurvPE0VdJwERkAXzaP3jXMqU1WJKW/q0md5a0biuu9R9Nt5M9H3qLUv5/Axud3vTDUjPhFsHB/H4kBas1RuO3mdptweQJAlFURasZgVdRzti+OQCVKtF7HavoXjkdAaNojN96tlstmttKy5yuRnsdg+1WtlYw3O5QsRiL1MqJQiF+lEUmVRqjHI5Ra1Wpatru+HOs3//bwkEegmH12E2W7Dbg0Aah8PLli1/wcTE07hcUbzeNq3oqp9MZoKenu3E4wcJBHool7NkMhNYrXHy+SlNb3uGYHANfn8X5XIWUGUso9GtDA5exujoY9hsbmq1Mna7W8soNzA7+4pmdO/BZvPjcPg0QYkovb2XEImcgd3uw+/v5tAhVfrR5+tmYmI39XoVgMHBtxqfqd3uZnp6j9ZfbqKr6ywSiYOk04ewWBxa61kGWZap14uao1SNiYnn8Pl6MJtt9PW9GUWxEIvBzMzLuN1ROjs3Mzb2BG53D05nmMnJp6jVKlrv+gDFYqKptahWq2CxODSRkYy2Puwml0szMfE02ewU5XIKq9VLT895lEoZbDYP1WqeeHwISUJrX7MQjw9hNlvI5aYJhdZgt3sMWUx14DVENjuB1WrFZDLPy4z173AuN83Y2C5UK85+yuWM1jOt/s3l8zFUt6608XdztJbExWa1Gk1f1GWZ+JL/ZgXHhwjIguPiSG1PehW0HuheqwSfbvygF8Po2tbFYpxKJU97u1qZqq9hLzaSD4cHm/5VkYwWk2Ix3qTW1YjP183g4NuMYpdkcoRKJUMgMKCd6wx2u5dIZD0Oh59arYTN5sNqdZDPT5PJTOJ0BiiXVdu/Q4ceZXT0T9pNOkSplDLUx/T2Jn0gIsuqXV84vAbdRCMef4X29s1IUp16vYrDEWRw8K3E4wex2QJYLFZKpQyKIlMoJIE609N7sNsDeDwd2oxANxaLi3R6GFDw+3sAiMcPUKnktYHGDKHQAKnUIXy+TmKxVwiF1uD1dlKrleno2Mrk5G5Wr95BLPYKxeKs1k/eT0fHFlKpQ0xNvagZeqiZZzB4BrHYbhyO7eRy06TTo3i9HRQKCcbGHqdeVyvNI5F1+P09ZDJjuFwdmqPXc9hsTrze1Vgsat9vMDiAzebEanVy6NCjuFxtVColZLlELjfJ88/fQ7mco1TKEQ4PYrV6kaQCweAgqsvSCJmMKm0aiayjWs0jyyXsdh/p9CgOR4COji1MTclYrX7C4QFisb14PB3UamVCoX4kyQyAzebCbLbjcoXJZMaZnd1HOq1mmboxSLGYorv7HG3N90xmZvbS2XkBLlcE3VZRF+do7p+fawtsVZbT3c/g6LNZOkdrbdR7/vVBqmD5EQFZ8Jpp7C+GhX2S8/kYMNfTuJC85tGCdGNmq0/pORx+4wakT1Ufba1bbxHRaSwwU9d81eKthTJkk8mCz9dtvJfN5iaZHDGKvhozk1xumlRqhEJhVltL7aK7+xySyRFkucL09B4Awz+4XI5rRTRT9PdfZPSK6sU4JpOFrq7tWtYC6fQY6fQhzGYr6fQshYJqP6hOgzpxu8NIklUr7JrGbvdit/dQKqm+uuVygUCgR+sF3kYyOYjD4UOSzMRiL1OtqsEsm53C4fCTSh3CYnEyOfkC4fBq3O6o1oYWZnj4QW39OqdNaatT6YlEFaczSDz+KmBCkswoSgVZLhGPv4TLpXo/x+MHmJp6gXpdxm73U6lkqFaL+HzdSJI6M6GugwYxm00Ui6swm21YLBYURaZaLXLo0J+IRs8imTyg+UmrimAeTy+JxKuafrQ6bZ/NTpDPT+H3q1XPlUoWSTLj8URwOAI4nUGSyREtQ1YHBm53u2b7qGblPl8HodAgxWICSQKr1Y3TGSSR2E8ymcbtjhpLGJVKVtuvGmzHxh4zdK27us5mevp5MpkJEolO2ts3MT29h1qtpGlhq+jfg+7ucykWk4TDg0YxVuv381g4WmujXhDWKF0rWF7EVRa8Zhr7ixfLfltH7QuNyo8WTBfKbFtvQEtpv2qluUUqqrlQyUYL1dFe01jhbTKp5u66dZ3TGdbEPcYJBAa06V4vIyMP4XCEKRZjuFwRrFYH4fB5SJIZp9NnTHkGAv0oytwaYCy2D1kuYzbbiUY3a/61aq+t3Z6gXq+QTA5RKMSoVIpYrTatoKpEtZqno+MsPJ4uTQN5gnI5hdMZxu1uY9WqCyiXs1QqORRFwefrxWZz0dl5JtnsFH6/2k9bKMRIpUaxWFyEw4Nks5M4nSEqlTLB4GrARE/PeeTzs1q/cYBQaJDR0Uc1IwcZi8WK19uDJNmQJCs+XyeBwCo6O1XXrmDwDOx2J21tG/H5eshmJ6lUMuTzMDBwmaZbXSSdHqVSyWj2k1M4nSO4XG1YrU5AolIpUqmkiUTWYbcHtQIrq/YdUaUtPZ4I4+PP4fV2I8slbckhi8Pho1xOEQoNUq/L9Paer1X3q2IvxWICt7udQKCPcjmL39+jTU07sFpN5PPTOJ1BY/Bos7lwu9uYnn5Bq/J30Nf3ZjKZSXy+VVitHlavfosh4qEoElNTuykWE7S3b6LR9EGt6M8vS8ba+PfbulQkODmc0IAsyzLVavVE7lKwgjGZ3FitEZzOAJVKjXx+VjMTmMDlCgFQLqdxOEJUKjVALb6yWPxNv5tMbszmKiaTm1KptOB7+f2DVCo1EolXUZQ65bIqxdhI636tVqvWgrSUc1lYY1tnMRWkxipwfd0Y1DVqpzOoTbX7SCSGmJh4AUmyYDZbiUQ2UKnktR7XCFarm0IhQb1eplota0VgFsOZJ5sdp1BI4nT6qNdrOJ1BZmdfoVzOY7XaATs+Xx92ux+3u03rL3bT37+DWq2CzeZievolotFNACQSB5HlIsViGocjSLE4i8/XS0/P+djtXs0qsaxZ8KWJRjeTSIzgdPqR5ZKxfp/LxQgEeo3q5vb2jYCqQOX1dlMspkgk1IGJwxGgq2sbFoudSiXN1NQzyHKJ1av/l7Fk4PW2a9KYHQDUaiXMZiceTzc+X7cmmrIPlyukqacdpF5XTTUCgT6KxTSzs3uZnn4OALvdx9q1V2r95mY6OrYyOvoo3d1nG8VQtVoFRalgNttoa1uvTdO2GxmwLp4xMHAJudy0tqavrqtKksQrr/x/TE3tJho9E6+3E0mStO+jA7e7jURiCLc7hM/XiyT10Nt7ARaLA0maBBS6u8/FZvMYlflWq51SSV2j1tufcrlpZLmkfV4BoyvgRDowtQ6MFyr8EiwvJ+QKK4rC1NQUqVTqROxOcMqhFgIpikK9rhZHpdMJ7Q/YhCRlgAyKUkeSTNq26v/1m1fjfhajXpdRFAWQyGYzSNKRtwcIBAJ0dHS0vM9C+z7ytPlCWbweuGu1EonEfny+XkKhtUbbUyDQRyDQx/j407z44v+LJFno6DiT9evfSaWSN6a91Z7UUaxWD06n2m5itTqpVouG406lUkCSJNLpcU2nOkilkkE/LVXYw4skqeuZmcwh6vUytVpFy85e0jLcMdra1lMqpchkxrQqYrW62OfrNVSf9GK8RGJIs+jLaIYcEaamnsdstpFIjJDPTxMKraVYzJBOH0JRZEKhNVSrFRRFRpZloKIZONQxm910d2/H6+1gZmYvfn8XyeSwZtAAnZ1nadPFNcbHn6RSKVKvlzCbzVp2mkSSwOfrQZLMFIvq+nihENOkQy0oSlWT94wRjW4iFOrDZLIhyyVefPGnyHKVF1/8T9avv0prcStQqxXw+3ua1N30AZVqzenVxGvUz75azWG1OpmY2M3U1AuUyykqFbVP2Wx2GCI4utKVJJmx2x3Y7X6jv1id9lbPJ5ebJh7fTy43jaIo2O1+XK6gUQjpcoXJZicplZIkEkPGPpbSkrhUFpu9yuUmm9TwBMvHCbm6ejBub2/H5XId9eYneOOiKHXNKF71JdYDsCxXqddlTCY1Y9X/r08jLm3fipGNHu07pigKhUKBmZkZADo7O4+4/UIB92iOV/r0dSYzjtpa5CAQ6NNeY2m6eXm9vTgcATZvfj8Wi4NSKU0sto9yOY3d7sdq9RiaxanUMJnMGE5niEJBzcS6us4GIJ+fZnLyBRwOL6HQoBE0EgnViN5m81IuJwmHz6BaLVOvV5iZeYlSKYnN5kdR6gBEIqozkPoeCUO4Qj2XuVabfD5mVIo7nSHK5az2GRexWKy43e1YrVZqtRzFYoIDB/6vNshQTTB8vi76+y8HLJpUZRuh0ABebxcOR0Dbv41yOYfbHcFicRhtOna7D4vFhdsdMfpiZblMPh9HllVf7UJhRpMudWrbSJr85WHgDM1eciOJxAHi8QNYrW6KxTGtkC6D2x2lVhtDkkyUSilyuUns9gBms9r65vV2atre+zSXrnYjMKn90uNYLFbC4fPZvPm91GplIxjralqRyAZtHduC3e411OVUw5D1xiyI3e41VN3MZhtOp2qPqH/n3e42TXAl3PQ9PFFTyq1ryvp7KwrAkZdyBCeG4w7IsiwbwTgcFmsNpzuyXNV0hWVsNosxlakoNmq1MhaLHfWmubTAejw4nU4AZmZmaG9vP+L09VLWthe6GelTh7qikV5Zrq6vBo2pcIvFgdfbwfj403i9ncRiL1GplKhWC0SjG7U15ACqy8/apj7nxuIutztKKDSA1eo2jletyJaNaeZicVZbM7WQSo1is/kMsZPR0V34/d2GEEStVtKCQC8AU1MvkMtNsXr1W7BYHJjNFtzu3qa2M1Az+Hw+1pDpH0KW1WlfRZHo6jqbSqVIINBHKjWmTVPnicf3k81OEQoNaoG2TTuPmhGI5wLZeuM66Ne+WExSKEwxPPx/iUa3kM1OEgqt06RA2ymV0litdqLRjZRKeex2t5bhpwmH15BMHmRgYAelUoZgsJ9KJU+hMEuplDKsMa1WJ9nsJIFAv/YdVQvScrkpTCZdE1o1dtCvR1vbeqPQqtE0RXcVGxt7XOtJL2qtbaMEAn3GvvT9OBwBo39dV4FrbGNqFQtZzgCpS9vq1dxiLXn5Oe6ArK8Zu1yu4z4YwamPegOzYDI1P662fKCpE1mPKTNu5VgyZf17Wa1WjxiQF6o4XUqhWKMet37zjcX2IssVUqlhnE7V2L6tbT379t1HKnWIfH4Wh8NHpaLenBOJESwWm1FM0ypaMieFGMNm82pZXYlUalgrrFP7dtUAUcfhCBIODxo9xaGQ+v9XX/0NqdQwhw7tIhw+A5crrJllqAFfd7wqFOLEYvsYGLjEOH/9mPQK8NnZvRQKSVyuoNaaVaa7+0Ly+cN0dW2lXM4zM7OHePxV8vlZrVfZx9TUCwQCa/D7V2nVzdGma6hrf+vBsLXKt61tPdPTe5BlmcOHn6JcTjMz87xxjqqjWF3Tmi5y+PBT+HzddHScSaWSp7v7XHK5GXy+LiYnd2szDLNUq3lqtQI+3ypKpRSJxAHqdZm2tvXY7apCWF/fDgCSyWFSqRE8ng46O7fN6x7Qvy96S9zExDOMjDxET8959Pa+iYMH/6gNpFJGq5MqhbmfarVIPj9pDKLc7jmRj8WqopeLVnERwfJzwq6ymKYWAEaG0apk1XhDP170Gxhw1MB+PN/LpdwAW4N2qZTG6Qxq64Beo+84l5vGYnHg8/UyOHg56fRh6nW1bcflCiBJzddlsYpXNaOdxevtolJRDRcOHXoUm81FKLSuKZspFOJNPaQmkwmTyUx7u+ruoxZSJahWVQcms9lBT892Dh3Koyh14vGhpnXDRlGWUGgtgcDcYCEa3YIsy7hcqh2g2WylWi1QrRao1XKawMk4oFCtprXp8uYKfHUwM4nd7jPeT215al4mOOOMK6jVCkiSg/HxXQQCa3A4glitDqanX0KSQJJMKAqayphXW99V+8B9vh5t5sCNwxFgcPByI1uPx1/B7Y6iKIrWMuahXM7hdKpmF/l8jMOHH6dczhrV7q3KWPoAQ1FUx6ZU6rBm2GHRWviGyeVihEIDJBJDlMtZo99YLepyY7U6sFrd2O3eed+HkxUcT/YAQCDangTLgCRJ8wLlQo+9VkwmM7JcRVHqms3fyRsMLmR40ViJ2npjrlRyxONDWtGVW5OEVG/u9XoNi8VOKLTGqDLO5aYNfWy1UKlEsZjE6Qzi83VrhUKqmpfT6SeRGKFYTGGzqQpaumyn+vpZrQhOndq02/10dp6J1erRKrcnUJQabW0b8Ho7jTYyi+Vt5PMxZLlMLLbPCMqNU/iNLWeVSo5kcphQqJd0egyAtraN1Ot1Zmb2Ybf7MJnMrF//TqrVAsHgGm0dPWnc9F2usNHTrvc5L9YDW6uV6eo6h3x+Fq/3Xdrae5hsVlWq8ni6MZls2GwuQ9MboFzO0t293XD8qlZzWp9zgL6+ixge3qnpXLvp7NxGKjVCOj2mDVbshuBLT88FSJLU5KzUGLwaBxilUpozzngbXm+U7u7txGL7qNUKeL2dxrq4otQ0N6soDoePXG6ScjlPPj9DuZyhXM5q1e5J47MUvDExHX0TQSP9/f3ceeedr/dhnDQeeughJEk65gp6RVG0oLk0L9Uf/vCHvPWtb13Stmq1tcyb33wRP//5z47puI4XPSjpxVatjzUK8btcYW39Uc0kdRWv6ek9Wla5mfb2TUYGrKtzAVpwb6NYTDI+/iR79/6SZPIg6fQYudwsVquDcjmn2UKajCCWy00a4hKqo5JqrTc9vYdsdlJba84xOvo4+fwspVKWXG7SGFzo/d3R6GbNBatmnKt+TK1T+MmkKoKiDhLCRq+saspRo1xOk8kcZnT0caLRzfj93TidwabsV+9pN5tV/181SDe/l55FOhx+XK4I4fAg7e2b6Ot7Mzabl0IhpgmCRAiF+ikWZ7FYrJTLOSTJjCxXDJvD9vZNdHefb1z7WGwfZrOFWq2g9TKrldx+fy+BQD9OZ1AbYGUJBgfo6TnfGDg1GpMADUsX+zTFNg8DA5dis3loa1tPb++b6O4+B7vdS61WQpZreDxR+vouIhrdSl/fJZqYSDulUgZZLmnXf/61F7yxOG0D8kc/+lEkSUKSJGw2G4ODg3z1q1+lVqsd8XVPPfUU11133Uk6ylMXfVq59Wa1EKVSidtvv50vfelLxmOFQoFbb72VNWvW4HA4aGtr45JLLuHee+/FZFKLxf73//7f3Hbb31Gv15fzVJpYKCgtFqj0gi6Xq83YLpkcIZHYTzw+ZATt6ek9TEw8o1Wez03t6/aSDkfIUMo6fPgxcrlxZLlKd/d2QqE1rFr1ZsLhQVyuMIoCicQQicSQNi0cxm73GypkmcxhJiaeYXT0IUAhEOijVqtowbo279h1T97GY2rNWP3+HsrlDFarQ5siVzPHYLCfQGCAdeuuRFHqlEpZUqlRAAqFWeLx/U0DEI+n08jGG99LD8T6Om2plNYy6JTW9gQTE88Ri71EPp9ElmXNLzmqFUipPb7VqqrbHY8P4fFENdcsizEY0KuIE4khMplx9u//LfH4AcrlLKWSOliqVkuk02NUKjlisX1kMoeJxfbN+57H40NMTT3HxMSzTYO3SiWP1xtFlqtMT7/A2NijTE+/0DSYq1aLuN0RzTt6ALPZ0VTUJXjjclp/uldccQU//vGPKZfL3H///Vx//fVYrVZuvfXWedtWKhVsNhttbW3H9Z76ft7oHMua8c9//nN8Ph9vfvObjcc+9alP8cQTT/Dtb3+bdevWMjs7w+OPP0U8HtcGUibe/va38elPX89vfvMb/vzP/3zZzqWRhdbVjrTWpgcX3cNZNYSfJRjsB9TMMJUaoVLJGpXajdPiFouD9evfSSy2D6vVSSDQq2kgb9Yqih0oClQqWUolh9Yak8Bu9xnVxaHQoFbZvQ+bzUOplMdsdmKz+fB42onFXqZYTBjv2SiO0uhzrffotn6m6fRhrFYHU1MvGsemZ45eb5R8fhaz2UqplDT0mdPpw8Y6dTS6+YjXsNVKUD82vX1IXRLwIMsVqtVpJiaeYHDwCtzuKA5H0Mi63e427TVzLTz1ek2bTYD+/h2MjDyM37+KmZl9FAoxkskDeL1RIhFVdUvVvT5MqZTG7Q5r08nmeS1BujGD0xlsupaN6+J2uxeTya65P80JfegzBb29mxa95oI3Jqdthgxgt9vp6Oigr6+PT3/601x++eXcd999gJpBv/vd7+ZrX/saXV1drFu3Dpg/ZT06OspVV12Fx+PB5/Px/ve/n+npaeP5L3/5y2zbto0f/OAHDAwM4HAs7HZ06NAhrrzySoLBIG63m02bNnH//fcDamvZtddey8DAAE6nk3Xr1vGtb32r6fX68X79618nGo0SCASMjP9zn/scoVCInp4efvzjHxuvGRkZQZIkfvKTn/CmN70Jh8PB5s2b2blz5xGv2yOPPMLFF1+M0+mkt7eXm266iXw+37SNvmYsSRL9/f3GbETjj85PfvITrrzyyqbX33fffdx222284x3vYPXqQbZvP4+bbvprPv7xjwNqoLNa7bz97W/nJz/5yRGP9/XGZnOTz89is7kNY/hSKW1Mv3Z3n8vq1ZfT16cOSFR/4Ekjs1Jbpjqp16sEAv10dm6jVEpjsdjJ52fx+3uMQOXxRGlv32T0z+ruUyaThd7e8wmHz6C39xwikXXUagXNgcqH0xlqWHuOGTKRara9X7MnbJ6q1wmHBzGbHVQqWQ4ffpzx8aeNtWY1+ISQ5SqDg39mmDc4HF48nvYWo4+5AUBjxqnPQDRmiY0ZfDg8SDS6hQ0b/h8to4/i9aqP65KYakFdN21t65Eks2EFqp9jKjVMOn1YM/sIsHnze3E6w9RqBQ4ffpJiMYnLFSYQ6Mfn6yEY7Mfj6aS394KmWQQdi8VBZ+c2AoG+JmU3fd1c71nv7DwTr7fZt1ufKdALxkQwPn1YUZ/0nj17GB0dZdWqVWzevPnoLzjBOJ1O4vG5G84DDzyAz+fjD3/4w4Lb1+t1Ixjv3LmTWq3G9ddfzwc+8AEeeughY7uhoSF+8Ytf8N///d+Ltt5cf/31VCoVHn74YdxuNy+//DIej8d4n56eHv7rv/6LcDjMrl27uO666+js7OT973+/sY8//vGP9PT08PDDD/Poo49y7bXXsmvXLnbs2METTzzBT3/6Uz75yU/yZ3/2Z/T09Biv+9znPsedd97Jxo0b+ed//meuvPJKhoeHF+wrP3DgAFdccQV33HEHP/rRj4jFYtxwww3ccMMNTcG+kaeeekpTbFIHF+9973uxWucKvB555BE+8pGPNL2mo6OD+++/n6uvvhqv17tokdj555/PN77xjQXf92RxtArYZHKEUilJPD5kmCXAnMqSruilr2VWq3mq1aKRlUFzNbcuOiHLNSqVDOn04SbZz8a+Vv34Zmb2YLWqAwJ1KnQQSULrbY4YdoGtVeOh0KDxu571NrdiqVXXXV3n4PFENZ/gzWSzU0ZWrQfoQiFOd/d2xsbihEKDTcFKZyGBlsWy51YtcrV3eIBQaI1RAOd0hpreo1RKG8pY5XLW0B0HjD5hv7+HdPowmza9h4MHA4RCa1EUmVIpTWfnNvz+3pZe4OZBtn5dGg1I9GK7xms718O+9qjnKjg9WDEB+a677uLOO++kWCzidDq5+eabuemmm07KeyuKwgMPPMDvfvc7brzxRuNxt9vND37wg0WnmB944AFefPFFhoeH6e1VhRXuvvtuNm3axFNPPcW5554LqNPUd9999xGnu0dHR3nPe97Dli1bAFi9erXxnNVq5Stf+Yrx+8DAAI899hg/+9nPmgJyKBTirrvuwmQysW7dOr75zW9SKBS47bbbALj11lv5xje+wSOPPMJf/MVfGK+74YYbeM973gPAd7/7XX7729/ywx/+kM9//vPzjvMf/uEf+PCHP8zNN98MwNq1a7nrrru45JJL+O53v7vgDEDjef/1X/81k5OTPPXUUwCkUinS6TRdXV1Nr/n+97/Phz/8YcLhMGeeeSYXXXQR733ve5umtQG6uroYGxujXq9jam1+Pkks1RxD907Ws9lWsQW9p7haLeJ0Bpr8o+ffqBWCwX6q1SLh8KDh7RwKrTUqoPX9q/rL00xMPI3TGaa7e7thfLCY17T+b6MQRePUe6PDlj51LMtVvN52stkpJAkjm+7ru4hUaozOzm2MjT1BKjWCzeY2jl2XytTfE9SgVauVjCIsUNdldTEPvYJZPzbdcctstuH1zqmy6csA+rnW6zVsNi/x+BClUgpQe5v1NX1JgsnJ3ZRKSQKBAbZu/bBxPWq1EpnM+FEzVv26xGJ7KRRUffe+vouaPsM5p7QaHk+nyIIFwAoJyHv27OHOO+9EURQ6OztJJpPceeedvOUtb1nWTPnXv/41Ho+HarVKvV7nQx/6EF/+8peN57ds2XLE9d69e/fS29trBGOAjRs3EggE2Lt3rxGQ+/r6jrr2fNNNN/HpT3+a3//+91x++eW85z3vYevWrcbz3/nOd/jRj37E6OgoxWKRSqXCtm3bmvaxadOmpqAUjUabrp/ZbCYcDhtykjoXXnih8X+LxcL27dvZu3fvgsf5/PPP88ILL3DPPfcYj6lCHXWGh4fZsGHDouf4/e9/nx/+8Ifs2rXLuB7FYhFgXiDfsWMHBw8e5PHHH2fXrl088MADfOtb3+IrX/kKt99+u7Gd0+lENZIvG8pcJ5ujCYjoto+tmXSrRKcejEKhNVprjr9pP62v1//VJS5rtYphH9k6SFAV01RBFZcrTKWSRZZrpFLD2O0+SiV1alsPsJKE8a++j9bzdDj85PMx/P4exsefoV6voCgBIhHVklJ9vdoeNDCwWit+KqMoConEAWq1AvV6jc7ObQsOamKxfYbtZr1eY2LiaWKxfUQigwsemz6j0Co20jplLMs1FEXG4QgQDg8aWbN6TdsIBPpJJkeM4K8PRhKJ/VoLWuiImeycMEg/4+NPY7d7m9as9eCezU4gSeammRDB6c2KWEPWg0wwGMRkMhEMBikWi4yOji7r+1522WXs3r2b/fv3UywW+fd//3fcbrfxfOP/j4el7OcTn/gEBw8e5CMf+Qgvvvgi27dv59vf/jagrrH+7d/+Lddeey2///3v2b17Nx/72MeoVCpN+2icBgZdpGP+Y8dTlZzL5fjkJz/J7t27jZ/nn3+e/fv3s2bNmkVf9+CDD3LjjTdy9913Nw00wmG1TSaZTM57jdVq5eKLL+aWW27h97//PV/96lf5+7//+6bzTiQSuN3u1y0Yw+LVx63roYttpwcjXUaxVEpTLM7OW69t3K6xrUa17QOz2WZkpg6HH0VR169zuWk6OrYwOHgF27b9JdHoZlyuNux2L7oPsd5D7XK1EQyq1o/BYD+69V8up9ZFNFY+x+NDKIpaoCVJqsmG7g4FaAIdZqPVK5udwOEI4ff3Uq9XKRZTVCo5MplxrZWpuVI9HB40zDpUkZUMlUqefD5OMNiPzebV7Blz85YMjlQNr64p24112tY1apvNQzS6WZPVjBn7DoXW0tl5NqHQ4BHbj/TP2WJxEA6vbepX1j9D1Ss5r6mjpY/p+yZ447IiMuRVq1bhdDpJJpMEg0GSySROp5NVq1Yt6/u63W4GBwePvuEibNiwgbGxMcbGxows+eWXXyaVSrFx48Zj3l9vby+f+tSn+NSnPsWtt97Kv/3bv3HjjTfy6KOP8qY3vYnPfOYzxrYHDhx4zcfdyuOPP86OHaosYK1W45lnnuGGG25YcNuzzz6bl19++Ziu29DQEO9973u57bbbuPrqq5ues9lsbNy4kZdffvmofcgbN26kVqtRKpWMmYs9e/Zw1llnLflYTiZHm8rWacw45wK41FTh3Lq+25g96tPPkch6I1hPT+8hlRrR/JBzgERn57aGNVcHqVQJk8ls9Njq68+53DSShOG7m8tNa+09ew3rwDnJTgvh8KChulWv15id3Ucg0G8UO+Vy05pVZJb29g1kMmPUahWcziC53BSKIi+YceozC6AGObvdhyyXjGMrl7MkEkMkkwcJhVY3Zc0LBUz9PVRBlrk13cWy3VbpSL1CfKHCtoXQP39JmnvfxiprpzOoyZb6j74zwWnBisiQN2/ezM0334wkSUxOTiJJEn/zN3/zuhR2HQuXX345W7Zs4cMf/jDPPvssTz75JNdccw2XXHIJ27dvP6Z93Xzzzfzud79jeHiYZ599lgcffNCY/l27di1PP/00v/vd73j11Ve5/fbbjTXYE8F3vvMdfvnLX7Jv3z6uv/56ksmkUc3cyi233MKuXbu44YYbjNmFe++9d9EAXiwWufLKKznrrLO47rrrmJqaMn503va2t/HII480ve7SSy/le9/7Hk8++QTDw8Pcf//93HbbbVx22WX4fD5juz/96U9LFhRZTo5UHbxYNlWrlQyRED0z1tdo9WnMmZk9xjaNGXZj9qgHa31NtVRKk0yOaI5HatHQQlmdHuSSyRFyualFBUBcLrW9p1CY1SrA1epwj6fDmPJtbEVqPVb1vcyadGVOO6Y1DAxcRiDQr9k6HlnwotHEwekM43D4td7riGbFaDEye33Nd7Gq8MVmKpay3ZH224oqDGMxFM9yuemmKmvdvENkyAKdFZEhg7qG+pa3vOV1rbI+ViRJ4t577+XGG29kx44dmEwmrrjiCmOq+ViQZZnrr7+ew4cP4/P5uOKKK/iXf/kXAD75yU/y3HPP8YEPfABJkvjgBz/IZz7zGX7zm9+ckPP4xje+wTe+8Q12797N4OAg9913H5FIZMFtt27dys6dO/nCF77AxRdfjKIorFmzhg984AMLbj89Pc2+ffvYt2/fvMItXcXr2muvZfv27aTTafx+NVt461vfyr//+//hC1/4AoVCga6uLt75znfyxS9+0Xj9+Pg4u3bt4j/+4z9OxGU4LnSXp0bf2NbMSw/aoGbMqq7xXJarZ096EEilDpFKHaJen29915g96u/faG7Q03MuxeKgMS3beAyNMp+SZMZmcxhTy432i4295L29FxgSoI1Zvy7Wkc/HKBZnqddV6cvGY/V4ovT2qnUKDoffWJ9NJtW2O90E40ioU7w5yuU8oFAoxPH5uunru6ipf1qfAl6KMchr4Vj2q7dm6cVbupVhY+Hachyj4NRFUpagbZjJZPD7/aTT6absBFSVpeHh4SP22ApWJiMjIwwMDPDcc8/NKxA72bzvfe/j7LPPNkRZVP/kKrrPsCRJ81yebrnlFpLJJN///vcX3e/J+n7W6zWmp/dQLMaJRNY3aT3rqFO3ewHJkNHUq4jVvuRJJMliBPRMZpzZ2VdwOkNGWxOw6Hr1Yq1Xjc/pgVtXD8vlppAks7H/xuNbaDDRaofYOivQmq3rx9JYMW2xODTlrUmKxZQmnhGZV6jWeD6p1CEmJ5/B6+3W9KkH513j18OAYSnox1Wv14xCM9HadHpxpBjayMr51gpOa/7pn/6J//mf/zF+b8zOdBGRVpen9vZ2PvvZz578g10AtZ+3zRDiaKyc1oOTXhgEc8YDje1HjUbwehtSYzA+fPhJI7tqDF7670dTuoKFszJ9itdmc2O3B5rUpUANpocOPUqhMIvTGcLr7TSy40RiCLvdj9lswWbzGnrclUrWeJ9CIU42O0kqNQygFZWp+9fXvWu1UlPbln7MjW1ZodAZmqf0M6TTYzgc/iYP4pXaw9u4dt3a6iYQNCICsmBF0N/fz4033tiUBbeKgbTKcX72s5+lXq8iyxVMJuuCrk/q/uQlaWofL3rmqhdVFYtxnM4wZvNc5a9+Q24MkkBDwIwYz6dSI4BirDE6HKqiVuP2SwlArcVJrdPJjdPOZrO6vtmYYcZi+5iefh6r1Y3LFTGkJ1UUQwlLD7qBwABeb2fTeTqdQUOmslYrGUVV+hS+ytzn1yzdOWVoUg8NPcD4+BPYbB5N9SxMNjtp2EyupMy4lZU6YBCsHFbut1ew7PT39y/ZjelkcSSvY12dS3eSAoVarQyAxbKwvaOaecqaGbxnWY9dv+GqvrZxLYj4jWCkF/XA/Ew1n48Bc+YS9XqNQKC/SbTD7Y4aRVzHkmkdLRA0Vnk3rr/qxyHLZaxW1ZKwo+NMo4+2Xq9htweMFh9dSESflm7ddzw+pA0y0FqfatoaukQoNEgksn5e5bPugqV7SyuKDEjYbF5DGKVQmKZcTi24Zr8Sp7AFgsUQ31LBimIpphT1epVaraxpZauNApJkQparTVPc+n4kSa3wPVk3aF2kQm/D0b2O7Xa/kTm2CoPobUN6Vtm61thYsKT3yzZfk6Wd20LbNUtQNq+z53LTpNOjuFxhfL4eI3tOJIbI52Oo1o9t+Hzd8wrN9H3rbVqyXDY+L90sIhAYMHSiG4vPGl+vT9nrbWGRyBnGewLGgKdR1lO/ZscykyAQvN6IgCw4JWicytap1+soSh1QqFYLmEyqTnhjpixJEiaT2ZBXPBk3aL1nVc+Ws9lJbW1VNgwDGmlVldIz4sYAc7SKXLXKe7Kpynux7VrXZo8WwEHS+oqjxjGEQoNYre4jrpk3BkZZLmM221m9+i3Gdcnn1alss9nS1EakT2UXi8kmkwWY0/1uxOUKc+jQo1r2jBGoRRWz4FRDBGTBimJuyloBpKYqXfUxMJmsWCxqoFWnVOdvvxDHcoM+Edm0/rpyOW1MPzf67rYel54Bzukzz+lGL2XaudVacLHt5s6veXCyWPbcaD6hP6YPOFqrt/VZgcaArx+b2x0x+m/L5Syzs68iSRI9PecBqo8zKGSzkwwP/5FKJUe9/i66u7cf8fNQp8KHMZlMtLdvatpWZMaCUwkRkAUrirmbrdJSiDUXcPW1ZFDlIk0ma1M71JH2vdQb9FKz6aUEbpPJYlQmN3oNtx6XXlwFx57dNU7tLkXWsVYrzVOJWuic9cHA0ZSv9B5qvc9Yb/HR9xEODxKPDxnvFwz2Mzb2GLJcJh4forf3fGO9XfVxzlOtFo54bKBef6vVidfbhdMZMiRF9WxZBGTBqYQIyIIVRWPhVmvGu1jAbQzQJ4qlBsTWQLGQgUTj1PBSiquWsu1CHMtrdEOFRkephc65Meg2Zu+N59noNKXrM6vnPKf2VSjEKRbjFAqq8EkyOYLf383s7CsoikwyOWJUeDeuQ+v/bzy2RoGVer3G1NQLyHIFWS5rPesgSZZ5Mw4CwUpHfEsFK5LWIHuiA+7RWGpwaw1irQG6NaC1VjI3Bu+T2RZzpOC7EK3n1ahMZrd70VuWWgcVzSjGvhSlhsvVzqpV7bjdauDWHa4sFgfd3c3Ss61iJInEkNG7bbO5URSXZpxSa5qNEEVdglMJEZCPwEc+8hE2bNhg+AkfjdnZWTZu3Mizzz5LT0/PMh/dG59WZa7j3W4pHOvacWsQWyyzbl1jnXv89QkYxxr8W89rbs1ave6h0JzZyEL7XWjqW5/WtlgclEpp8vlpKpWcIbLi83W3FPHNFY6FQoPGmrlaRa8aNejZud4Pns/HhHmD4JRhRZhLrESef/557r//fm666SbjMUVR+OIXv0hnZydOp5PLL7+c/fv3G89HIhGuueYavvSlL70eh/yGo7HS+ERstxT0wKlKO04f8z4XMy7QDRtUQ4Q2o9jpSOYTx8tChhev9fWN56UHxnB4EI+n03i8VEouarrQel1anY9ALX6bmnqeoaHfMD7+lCE3mctNU6uVNIOGSUqlND5fN9HoZny+HtzuNiqVLE5nEEmyGJaTja1iAsGpgAjIi/Dtb3+b973vfXg8c2IS3/zmN7nrrrv43ve+xxNPPIHb7eZtb3sbpVLJ2OZjH/sY99xzD4lE4vU47DcUeqZztEx1qdstBT1IAkty9Vlq0FtI43mx4H2iaHUmOtKxNj6n/18vMjuSL3Nj5rvUwUWhECeR0Cuj565Dd/f5dHScSSh0BoFAv6F4pjte5fPThjmDvoY8V6Ee1GZIIJkcaSiOW74Bj0BwojltA/LIiOo00/pz6aWXIssyP//5z7nyyiuN7RVF4c477+Tv/u7vuOqqq9i6dSt33303ExMT/OpXvzK227RpE11dXfzyl798Hc5q5aKrazUqgy30WCP6OvLRpqGXut1S0IODxxNd0s38WOz4jmXb42WhDPRI79/4XLP29fxrsFDwPZbBhd7H7PP1ks1OUquVjFaqzs5thEJrDLOOfH7G6HU2mcy43W2GEcf0tBqoG9vDGmch9M9RFHQJThVO24Dc29vL5OSk8fPcc88RDofZsWMHL7zwAul0usnTeHh4mKmpKS6//HLjMb/fz/nnn89jjz3WtO/zzjuPP/3pTyftXE4FFppWPpFTzcfDQpnjYgGmddtjyQyXe4q6EV1spHHm4Ejv3/ic/v/FAlrj+nMmM04mM77oZ1iv15q20ae7PZ4o1WqRVGqYeHzI2L5USpNOj3H48OOkUiM4nSECgdW0ta0nEtmAxxPF4fBTLKbI52coFuNIkuU1Dw4EgpXEivrG3ncfPPggXHYZvOtdy/teZrOZjo4OQLXoe/e7382FF17Il7/8Ze677z7MZjPt7e3G9lNTUwBEo80FK9Fo1HhOp6uri+eee255T+AUYyFJTF3YQ1fYOpHFWcfCQtW4ixV3LVZFvRROVBX1UgrPjrWKuvW5pRynate4j3I5TWfnOYZhROv10vWq55S71OsXDg9qetjeJiGRzs4zsVrdRCKDSJKZROIAsdg+3O42Y6ra6QygKDSZSjT2cYuqasGpyIoJyPfdB1ddBWYz3Hkn3Hvv8gdlnY9//ONks1n+8Ic/YDKZKBaL2O321xwUnE4nhULh6BueRizUK1yvy8a/ZrPpiMYSy0Fj1S7M9bg2etdC8819JcgxHkkko7UH+kTT+B4uVxinU70OxWLScLVqvV665WTjNdOP0e1uI5HYb0xZm0wWrFY3fn8XVqtb+xzSFIsJMpkxnM4QoZBaTNYY/BeaohcITjVWTEB+8EE1GMuy+u9DD52cgHzHHXfwu9/9jieffBKv1wuo1dKFQoFKpYLNZgMwsunp6Wk6OzuN109PT7Nt27amfSYSCdra2pb/4E9xWrPmk50xLxTY9CxLvbHPn949mb3Ci3G01ipYvgyx9T3a2tYTjw8RDPYb3sSN6IG2kfnH1vzZtp5fT895xkBtsenoVj1wgeBUZMWsIV922VwwlmW49NLlf89f/OIXfPWrX+VnP/sZa9asMR7XA+zLL79sPDYwMEBHRwcPPPCA8Vgmk+GJJ57gwgsvbNrvnj17OOuss5b34N8AtBZjNWbM6r/Lu8a80Jrq0dZPVwKLBSWHw29UIS8XrddMV+BqrLg+FjyeKJHI+qMuFeiBvbU3ufG4HI7gsn5fBILlZsXcbd71LnWa+qGH1GC83Nnxnj17uOaaa7jlllvYtGmTsQ5ss9loa2vj7LPP5pFHHjGCsyRJ3Hzzzdxxxx2sXbuWgYEBbr/9drq6unj3u99t7LdQKPDMM8/w9a9/fXlP4A1CYxY8P2M+uhXj8bBQtrvQYyvVV7f1uBaSwzzRLDxD8No9tRv3V6/XNB3qOZcr1TNZNZ1o3bZV5cxkajbkWKmfm0CwGCsmQwY1CP/zP5+cqeqnn36aQqHAHXfcQWdnp/Fz9dVXA/CJT3yCe+65p+k1n//857nxxhu57rrrOPfcc8nlcvz2t7/F4Zi7+d17772sWrWKiy++ePlP4hRGb3mS5Ypmdl+dlzGfyHam4+FktisdC63HdTKruHXUDHfDCZkiVyU1ZWq1MqOjj5FKjQAQCg0SCq1tOq+FPhN9hkAXBlmsj1ogWKlIymJNoA1kMhn8fj/pdBqfz9f0XKlUYnh4mIGBgabAdKpTLBZZt24dP/3pT+dNSR+JCy64gJtuuokPfehDy3h0pz6yXNW0iBUURcZisWM22074+5yI7+dKzbSOdFwn4piX+7wb969nxzabi+HhnRSLs7jdUbZu/RAWy/zPbaFjy2TGSSSGsNv9mM0WQyxkpX1ugtOPI8XQRsS3dBGcTid33303s7OzS37N7OwsV199NR/84AeX8cjeGDQXcskr+ob5ehZyHSkoHosZxGthuYvEGvefz8dIJIbI52cpFBKYzRba2zctOv2+0PS17qPtdAYXbMESCFY64tt6BC49xsqySCTC5z//+eU5mDcYzZ7GK2rlZEXxWoPiiWjPWu4Wr8b9Oxx+CoVZKpUiEKO//y34fD3U6zVqtVKT5Ggr+jVyOIJEIhtEIBacsohvrUCwgnmtQfFEZPWvZR/HMs3dWHxVKqXp7b2AYHCAYnELbW3rKZXSFAoxw8UJFh6UHNnyUSA4dRDfXoFgBbMS+p6PhdeS0ev+xqHQIIFAH4FAHwAul3p70j2kdVOJhVqiTqVrJBAshgjIAoHghPHap7mba0vnq445hDSm4A2PCMgCwSnGSq36hoWLrY52nC5XmGIxaVRb53LT5POxedPUK0G2VCBYTlbWX7NAIDgqJ0Mi80TQepytAbqxOloXNAFIJIao1cqYzTYikfXG/sTUtOCNjgjIAsEpxqmSKbYeZ2uA1n+32byG5KfJZCEUGjQy5OVUHRMIVhqi32QRLr30Um6++ebX+zAEgnmcKn6/rcfZqiSm/66ah6jBV9esjkY3G45OAsHpwmkdkD/60Y8iSdK8n6GhoaO/WCAQLIq+Ftxo9NAaoPXfPZ7oPMnPU2XQIRCcSE77b/sVV1zBj3/846bHhHWiQHB8HMs6t1gbFghUTusMGcBut9PR0dH0Yzab522XTCa55pprCAaDuFwu3v72t7N//35ANUpoa2vj5z//ubH9tm3bmnyTH3nkEex2O4VCYflPSiB4nTlWo4uFMmqB4HTjtA/IS+WjH/0oTz/9NPfddx+PPfYYiqLwjne8g2pVdSnasWMHDz30EKAG771791IsFtm3bx8AO3fu5Nxzz8Xlcr2OZyEQnByOdcp5pTpqCQQnk9M+IP/617/G4/EYP+973/vmbbN//37uu+8+fvCDH3DxxRdz5plncs899zA+Ps6vfvUrQC0C0wPyww8/zFlnndX02EMPPcQll1xyks5KIDi1WCijFlmz4HTjtA/Il112Gbt37zZ+7rrrrnnb7N27F4vFwvnnn288Fg6HWbduHXv37gXgkksu4eWXXyYWi7Fz504uvfRSIyBXq1V27dp1zGYVAsHpwkIZtciaBacbK6qo6/VQIHK73QwODh73frZs2UIoFGLnzp3s3LmTr33ta3R0dPCP//iPPPXUU1SrVd70pjedgCMWCE4PTpV+a4HgRLGiMuSVOiLesGEDtVqNJ554wngsHo/zyiuvsHHjRkC1E7z44ou59957eemll7jooovYunUr5XKZf/3Xf2X79u243e7X6xQEglMO0fokON1YUQH5WCszTxZr167lqquu4q/+6q945JFHeP755/nLv/xLuru7ueqqq4ztLr30Uv7zP/+Tbdu24fF4MJlM7Nixg3vuuUesHwsEAoHgiKyogLySR8Q//vGPOeecc3jnO9/JhRdeiKIo3H///VitVmObSy65BFmWm9aKL7300nmPCQQCgUDQiqQoinK0jTKZDH6/n3Q6jc/na3quVCoxPDzMwMAADofQnBWsLMT3UyAQvN4cKYY2sqIyZIFAIBAITldEQBYIBAKBYAUgArJAIBAIBCsAEZAFAoFAIFgBiIAsEAgEAsEK4IQF5CUUawsEJx3xvRQIBKcKxx2Q9T5cYSsoWIno38vGfnGBQCBYiRy3AofZbCYQCDAzMwOAy+VCkqTjPjCB4HhQFIVCocDMzAyBQGBBj2uBQCBYSZwQSayOjg4AIygLBCuFQCBgfD8FAoFgJXNCArIkSXR2dtLe3k61Wj0RuxQIjhur1SoyY4FAcMpwQkWjzWazuAEKBAKBQPAaEG1PAoFAIBCsAERAFggEAoFgBSACskAgEAgEK4AlrSHr4gqZTGZZD0YgEAgEgjcaeuw8mlDRkgJyNpsFoLe39zgPSyAQCASC05NsNovf71/0eUlZgrZgvV5nYmICr9crRD8EAoFAIDgGFEUhm83S1dWFybT4SvGSArJAIBAIBILlRRR1CQQCgUCwAhABWSAQCASCFYAIyAKBQCAQrABEQBYIBAKBYAUgArJAIBAIBCsAEZAFAoFAIFgBiIAsEAgEAsEK4P8HgFOgWC2h4nkAAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " eps_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step(eps_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notice that his yields very similar results to using the underlying score function in the stochastic score based CFM example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notice that there is no difference whether or not we convert the predicted noise to data inside thte .step() function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Let's try other cool sampling functions" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "schedule = DiscreteLinearInferenceSchedule(nsteps = 1000, direction = \"diffusion\").generate_schedule(device= DEVICE) \n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " eps_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step_ddim(eps_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What happens when you sample from an untrained model with DDPM" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens).to(DEVICE)\n", + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE)\n", + "trajectory2 = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " vt = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step_noise(vt, full_t, sample)\n", + " trajectory2.append(sample) #\n", + "plot_limit = 1024\n", + "traj = torch.stack(trajectory2).cpu().detach().numpy()\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(0)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(1)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's switch the parameterization of DDPM from noise to data\n", + "\n", + "Here instead of training the model to learn the noise we want to learn the raw data. Both options are valid and the choice of which depends on the underlying modeling task." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.time.uniform import UniformTimeDistribution\n", + "from bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM\n", + "from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule, DiscreteLinearNoiseSchedule\n", + "from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule\n", + "from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior\n", + "DEVICE = \"cuda:0\"\n", + "uniform_time = UniformTimeDistribution(discrete_time=True, nsteps = 1000)\n", + "simple_prior = GaussianPrior()\n", + "ddpm = DDPM(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior,\n", + " prediction_type = \"data\",\n", + " noise_schedule = DiscreteLinearNoiseSchedule(nsteps = 1000),\n", + " device=DEVICE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Let us first train the model with a weight such that it is theoretically equivalent to the simple noise matching loss. See Equation 9 from https://arxiv.org/pdf/2202.00512" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 1.494\n", + "2000: loss 1.594\n", + "3000: loss 1.660\n", + "4000: loss 0.919\n", + "5000: loss 0.376\n", + "6000: loss 2.588\n", + "7000: loss 0.480\n", + "8000: loss 0.519\n", + "9000: loss 0.386\n", + "10000: loss 0.399\n", + "11000: loss 0.745\n", + "12000: loss 0.468\n", + "13000: loss 0.938\n", + "14000: loss 0.717\n", + "15000: loss 0.402\n", + "16000: loss 0.318\n", + "17000: loss 0.502\n", + "18000: loss 0.328\n", + "19000: loss 0.435\n", + "20000: loss 0.474\n" + ] + } + ], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "ddpm = ddpm.to_device(DEVICE)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = ddpm.sample_time(batch_size)\n", + " xt = ddpm.interpolate(x1, t, x0)\n", + "\n", + " x_hat = model(xt, t)\n", + " loss = ddpm.loss(x_hat, x1, t, weight_type=\"data_to_noise\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step(x_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Now let us train with no loss weighting to optimize a true data matching loss for comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 2.489\n", + "2000: loss 2.395\n", + "3000: loss 2.464\n", + "4000: loss 2.632\n", + "5000: loss 2.732\n", + "6000: loss 2.517\n", + "7000: loss 2.521\n", + "8000: loss 2.830\n", + "9000: loss 2.452\n", + "10000: loss 2.764\n", + "11000: loss 2.643\n", + "12000: loss 2.498\n", + "13000: loss 2.414\n", + "14000: loss 2.753\n", + "15000: loss 2.617\n", + "16000: loss 2.735\n", + "17000: loss 2.732\n", + "18000: loss 2.483\n", + "19000: loss 2.784\n", + "20000: loss 2.502\n" + ] + } + ], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)\n", + "ddpm = ddpm.to_device(DEVICE)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = ddpm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = ddpm.sample_time(batch_size)\n", + " xt = ddpm.interpolate(x1, t, x0)\n", + "\n", + " x_hat = model(xt, t)\n", + " loss = ddpm.loss(x_hat, x1, t, weight_type=\"ones\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = ddpm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "for t in schedule:\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = ddpm.step(x_hat, full_t, sample)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The choice in data vs noise and variance schedule are hyperparameters that must be tuned to each task\n", + "\n", + "### many of these choices are empirical and part of the tuning process to best model your data via noise, data, or even velocity prediction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's try a continuous time analog interpolant to DDPM called VDM\n", + "\n", + "### This interpolant was used in Chroma and is described in great detail here https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.interpolants import VDM\n", + "from bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform, LinearSNRTransform, LinearLogInterpolatedSNRTransform\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior\n", + "DEVICE = \"cuda:0\"\n", + "uniform_time = UniformTimeDistribution(discrete_time=False)\n", + "simple_prior = GaussianPrior()\n", + "vdm = VDM(time_distribution=uniform_time, \n", + " prior_distribution=simple_prior,\n", + " prediction_type = \"data\",\n", + " noise_schedule = LinearLogInterpolatedSNRTransform(),\n", + " device=DEVICE)\n", + "schedule = LinearInferenceSchedule(nsteps = 1000, direction=\"diffusion\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# Place both the model and the interpolant on the same device\n", + "dim = 2\n", + "hidden_size = 128\n", + "num_hiddens = 3\n", + "batch_size = 256\n", + "model = Network(dim_in=dim, \n", + " dim_out=dim, \n", + " dim_hids=[hidden_size]*num_hiddens)\n", + "DEVICE = \"cuda\"\n", + "model = model.to(DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 1.479\n", + "2000: loss 1.102\n", + "3000: loss 1.224\n", + "4000: loss 0.964\n", + "5000: loss 1.172\n", + "6000: loss 1.354\n", + "7000: loss 1.151\n", + "8000: loss 1.016\n", + "9000: loss 1.399\n", + "10000: loss 1.194\n", + "11000: loss 1.213\n", + "12000: loss 1.418\n", + "13000: loss 1.101\n", + "14000: loss 0.953\n", + "15000: loss 1.079\n", + "16000: loss 1.107\n", + "17000: loss 1.231\n", + "18000: loss 1.280\n", + "19000: loss 1.073\n", + "20000: loss 0.935\n" + ] + } + ], + "source": [ + "optimizer = torch.optim.Adam(model.parameters(), lr = 1.e-3)\n", + "for k in range(20000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = vdm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size).to(DEVICE)\n", + "\n", + " t = vdm.sample_time(batch_size)\n", + " xt = vdm.interpolate(x1, t, x0)\n", + "\n", + " x_hat = model(xt, t)\n", + " loss = vdm.loss(x_hat, x1, t, weight_type=\"ones\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 1000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = vdm.step(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = vdm.step_ddim(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What is interesting here is that the deterministic sampling of DDIM best recovers the Flow Matching ODE samples" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " # sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " sample = vdm.step_ode(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " # sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " sample = vdm.step_ode(x_hat, full_t, sample, dt, temperature = 1.5)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " # sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " sample = vdm.step_ode(x_hat, full_t, sample, dt, temperature = 0.5)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 600x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "inf_size = 1024\n", + "sample = vdm.sample_prior((inf_size, 2)).to(DEVICE) # Start with noise\n", + "trajectory = [sample]\n", + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "for dt, t in zip(dts, ts):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " x_hat = model(sample, full_t) # calculate the vector field based on the definition of the model\n", + " sample = vdm.step_hybrid_sde(x_hat, full_t, sample, dt)\n", + " # sample = vdm.step_ode(x_hat, full_t, sample, dt)\n", + " trajectory.append(sample) # save the trajectory for plotting purposes\n", + " \n", + "traj = torch.stack(trajectory).cpu().detach().numpy()\n", + "plot_limit = 1024\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :plot_limit, 0], traj[0, :plot_limit, 1], s=10, alpha=0.8, c=\"black\", label='Prior sample z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, traj.shape[0]-1):\n", + " plt.scatter(traj[i, :plot_limit, 0], traj[i, :plot_limit, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :plot_limit, 0], traj[-1, :plot_limit, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "plt.scatter([], [], s=0.2, alpha=0.2, c=\"olive\", label='Flow')\n", + "plt.legend()\n", + "plt.xticks([])\n", + "plt.yticks([])\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "moco_bionemo", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb b/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb new file mode 100644 index 0000000000..07936397d4 --- /dev/null +++ b/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb @@ -0,0 +1,1000 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Generative Models for Discrete Data via Discrete Interpolants" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import os\n", + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "torch.cuda.manual_seed(42)\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torch.distributions.categorical import Categorical\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tutorial\n", + "\n", + "This notebook walks through how to use 3 discrete data interpolants: (1) Discrete Flow Matching (2) Discrete Denoising Diffusion Probabilistic Models, and (3) Masked Diffusion Language Modeling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task\n", + "\n", + "here our object contains 10 binary elements with the goal distribution being a uniform distribution over the 10 elements.\n", + "\n", + "We initalize our interpolants with a binary uniform prior so on average each sample with have a value of 5 out of 10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define the Model Architecture" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# training\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 2 # state space\n", + "\n", + "class Model(nn.Module):\n", + " def __init__(self, D, S):\n", + " super().__init__()\n", + " self.embedding = nn.Embedding(S+1, 16)\n", + " self.net = nn.Sequential(\n", + " nn.Linear(17 * D, 128),\n", + " nn.ReLU(),\n", + " nn.Linear(128, 128),\n", + " nn.ReLU(),\n", + " nn.Linear(128, S*D),\n", + " )\n", + "\n", + " def forward(self, x, t):\n", + " B, D = x.shape\n", + " x_emb = self.embedding(x) # (B, D, 16)\n", + " net_input = torch.cat([x_emb, t[:, None, None].repeat(1, D, 1)], dim=-1).reshape(B, -1) # (B, D * 17)\n", + " return self.net(net_input).reshape(B, D, S) # (B, D, S)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define the Discret Flow Matching Interpolant" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.prior import DiscreteUniformPrior\n", + "from bionemo.moco.interpolants import DiscreteFlowMatcher\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 2 # state space\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "prior = DiscreteUniformPrior(num_classes=S)\n", + "time_distribution = UniformTimeDistribution()\n", + "dfm = DiscreteFlowMatcher(time_distribution=time_distribution,\n", + " prior_distribution=prior,\n", + " device=DEVICE)\n", + "schedule = LinearInferenceSchedule(nsteps = 1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model = Model(D, S)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train DFM" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [00:54<00:00, 923.41it/s]\n" + ] + } + ], + "source": [ + "model = model.to(DEVICE)\n", + "losses = []\n", + "for _ in tqdm(range(50000)):\n", + " num_ones = torch.randint(0, D+1, (B,))\n", + " x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long().to(DEVICE)\n", + " # x1 e.g. [1, 1, 1, 0, 0, 0, 0, 0, 0, 0] or [1, 1, 1, 1, 1, 1, 1, 1, 1, 0]\n", + " optimizer.zero_grad()\n", + " x0 = dfm.sample_prior(x1.shape) # B x D\n", + " t = dfm.sample_time(B)\n", + " xt = dfm.interpolate(x1, t, x0)\n", + " logits = model(xt, t) # (B, D, S)\n", + " loss = dfm.loss(logits, x1, t).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, label='Training Loss', linestyle='-', color='blue', marker='o')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample from DFM" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1000, 10])\n" + ] + } + ], + "source": [ + "num_samples = 1000\n", + "xt = dfm.sample_prior((num_samples, D))\n", + "print(xt.shape)\n", + "ts = schedule.generate_schedule(device=DEVICE)\n", + "dts = schedule.discretize(device=DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.0000, 0.0010, 0.0020, 0.0030, 0.0040, 0.0050, 0.0060, 0.0070, 0.0080,\n", + " 0.0090, 0.0100, 0.0110, 0.0120, 0.0130, 0.0140, 0.0150, 0.0160, 0.0170,\n", + " 0.0180, 0.0190, 0.0200, 0.0210, 0.0220, 0.0230, 0.0240, 0.0250, 0.0260,\n", + " 0.0270, 0.0280, 0.0290, 0.0300, 0.0310, 0.0320, 0.0330, 0.0340, 0.0350,\n", + " 0.0360, 0.0370, 0.0380, 0.0390, 0.0400, 0.0410, 0.0420, 0.0430, 0.0440,\n", + " 0.0450, 0.0460, 0.0470, 0.0480, 0.0490, 0.0500, 0.0510, 0.0520, 0.0530,\n", + " 0.0540, 0.0550, 0.0560, 0.0570, 0.0580, 0.0590, 0.0600, 0.0610, 0.0620,\n", + " 0.0630, 0.0640, 0.0650, 0.0660, 0.0670, 0.0680, 0.0690, 0.0700, 0.0710,\n", + " 0.0720, 0.0730, 0.0740, 0.0750, 0.0760, 0.0770, 0.0780, 0.0790, 0.0800,\n", + " 0.0810, 0.0820, 0.0830, 0.0840, 0.0850, 0.0860, 0.0870, 0.0880, 0.0890,\n", + " 0.0900, 0.0910, 0.0920, 0.0930, 0.0940, 0.0950, 0.0960, 0.0970, 0.0980,\n", + " 0.0990, 0.1000, 0.1010, 0.1020, 0.1030, 0.1040, 0.1050, 0.1060, 0.1070,\n", + " 0.1080, 0.1090, 0.1100, 0.1110, 0.1120, 0.1130, 0.1140, 0.1150, 0.1160,\n", + " 0.1170, 0.1180, 0.1190, 0.1200, 0.1210, 0.1220, 0.1230, 0.1240, 0.1250,\n", + " 0.1260, 0.1270, 0.1280, 0.1290, 0.1300, 0.1310, 0.1320, 0.1330, 0.1340,\n", + " 0.1350, 0.1360, 0.1370, 0.1380, 0.1390, 0.1400, 0.1410, 0.1420, 0.1430,\n", + " 0.1440, 0.1450, 0.1460, 0.1470, 0.1480, 0.1490, 0.1500, 0.1510, 0.1520,\n", + " 0.1530, 0.1540, 0.1550, 0.1560, 0.1570, 0.1580, 0.1590, 0.1600, 0.1610,\n", + " 0.1620, 0.1630, 0.1640, 0.1650, 0.1660, 0.1670, 0.1680, 0.1690, 0.1700,\n", + " 0.1710, 0.1720, 0.1730, 0.1740, 0.1750, 0.1760, 0.1770, 0.1780, 0.1790,\n", + " 0.1800, 0.1810, 0.1820, 0.1830, 0.1840, 0.1850, 0.1860, 0.1870, 0.1880,\n", + " 0.1890, 0.1900, 0.1910, 0.1920, 0.1930, 0.1940, 0.1950, 0.1960, 0.1970,\n", + " 0.1980, 0.1990, 0.2000, 0.2010, 0.2020, 0.2030, 0.2040, 0.2050, 0.2060,\n", + " 0.2070, 0.2080, 0.2090, 0.2100, 0.2110, 0.2120, 0.2130, 0.2140, 0.2150,\n", + " 0.2160, 0.2170, 0.2180, 0.2190, 0.2200, 0.2210, 0.2220, 0.2230, 0.2240,\n", + " 0.2250, 0.2260, 0.2270, 0.2280, 0.2290, 0.2300, 0.2310, 0.2320, 0.2330,\n", + " 0.2340, 0.2350, 0.2360, 0.2370, 0.2380, 0.2390, 0.2400, 0.2410, 0.2420,\n", + " 0.2430, 0.2440, 0.2450, 0.2460, 0.2470, 0.2480, 0.2490, 0.2500, 0.2510,\n", + " 0.2520, 0.2530, 0.2540, 0.2550, 0.2560, 0.2570, 0.2580, 0.2590, 0.2600,\n", + " 0.2610, 0.2620, 0.2630, 0.2640, 0.2650, 0.2660, 0.2670, 0.2680, 0.2690,\n", + " 0.2700, 0.2710, 0.2720, 0.2730, 0.2740, 0.2750, 0.2760, 0.2770, 0.2780,\n", + " 0.2790, 0.2800, 0.2810, 0.2820, 0.2830, 0.2840, 0.2850, 0.2860, 0.2870,\n", + " 0.2880, 0.2890, 0.2900, 0.2910, 0.2920, 0.2930, 0.2940, 0.2950, 0.2960,\n", + " 0.2970, 0.2980, 0.2990, 0.3000, 0.3010, 0.3020, 0.3030, 0.3040, 0.3050,\n", + " 0.3060, 0.3070, 0.3080, 0.3090, 0.3100, 0.3110, 0.3120, 0.3130, 0.3140,\n", + " 0.3150, 0.3160, 0.3170, 0.3180, 0.3190, 0.3200, 0.3210, 0.3220, 0.3230,\n", + " 0.3240, 0.3250, 0.3260, 0.3270, 0.3280, 0.3290, 0.3300, 0.3310, 0.3320,\n", + " 0.3330, 0.3340, 0.3350, 0.3360, 0.3370, 0.3380, 0.3390, 0.3400, 0.3410,\n", + " 0.3420, 0.3430, 0.3440, 0.3450, 0.3460, 0.3470, 0.3480, 0.3490, 0.3500,\n", + " 0.3510, 0.3520, 0.3530, 0.3540, 0.3550, 0.3560, 0.3570, 0.3580, 0.3590,\n", + " 0.3600, 0.3610, 0.3620, 0.3630, 0.3640, 0.3650, 0.3660, 0.3670, 0.3680,\n", + " 0.3690, 0.3700, 0.3710, 0.3720, 0.3730, 0.3740, 0.3750, 0.3760, 0.3770,\n", + " 0.3780, 0.3790, 0.3800, 0.3810, 0.3820, 0.3830, 0.3840, 0.3850, 0.3860,\n", + " 0.3870, 0.3880, 0.3890, 0.3900, 0.3910, 0.3920, 0.3930, 0.3940, 0.3950,\n", + " 0.3960, 0.3970, 0.3980, 0.3990, 0.4000, 0.4010, 0.4020, 0.4030, 0.4040,\n", + " 0.4050, 0.4060, 0.4070, 0.4080, 0.4090, 0.4100, 0.4110, 0.4120, 0.4130,\n", + " 0.4140, 0.4150, 0.4160, 0.4170, 0.4180, 0.4190, 0.4200, 0.4210, 0.4220,\n", + " 0.4230, 0.4240, 0.4250, 0.4260, 0.4270, 0.4280, 0.4290, 0.4300, 0.4310,\n", + " 0.4320, 0.4330, 0.4340, 0.4350, 0.4360, 0.4370, 0.4380, 0.4390, 0.4400,\n", + " 0.4410, 0.4420, 0.4430, 0.4440, 0.4450, 0.4460, 0.4470, 0.4480, 0.4490,\n", + " 0.4500, 0.4510, 0.4520, 0.4530, 0.4540, 0.4550, 0.4560, 0.4570, 0.4580,\n", + " 0.4590, 0.4600, 0.4610, 0.4620, 0.4630, 0.4640, 0.4650, 0.4660, 0.4670,\n", + " 0.4680, 0.4690, 0.4700, 0.4710, 0.4720, 0.4730, 0.4740, 0.4750, 0.4760,\n", + " 0.4770, 0.4780, 0.4790, 0.4800, 0.4810, 0.4820, 0.4830, 0.4840, 0.4850,\n", + " 0.4860, 0.4870, 0.4880, 0.4890, 0.4900, 0.4910, 0.4920, 0.4930, 0.4940,\n", + " 0.4950, 0.4960, 0.4970, 0.4980, 0.4990, 0.5000, 0.5010, 0.5020, 0.5030,\n", + " 0.5040, 0.5050, 0.5060, 0.5070, 0.5080, 0.5090, 0.5100, 0.5110, 0.5120,\n", + " 0.5130, 0.5140, 0.5150, 0.5160, 0.5170, 0.5180, 0.5190, 0.5200, 0.5210,\n", + " 0.5220, 0.5230, 0.5240, 0.5250, 0.5260, 0.5270, 0.5280, 0.5290, 0.5300,\n", + " 0.5310, 0.5320, 0.5330, 0.5340, 0.5350, 0.5360, 0.5370, 0.5380, 0.5390,\n", + " 0.5400, 0.5410, 0.5420, 0.5430, 0.5440, 0.5450, 0.5460, 0.5470, 0.5480,\n", + " 0.5490, 0.5500, 0.5510, 0.5520, 0.5530, 0.5540, 0.5550, 0.5560, 0.5570,\n", + " 0.5580, 0.5590, 0.5600, 0.5610, 0.5620, 0.5630, 0.5640, 0.5650, 0.5660,\n", + " 0.5670, 0.5680, 0.5690, 0.5700, 0.5710, 0.5720, 0.5730, 0.5740, 0.5750,\n", + " 0.5760, 0.5770, 0.5780, 0.5790, 0.5800, 0.5810, 0.5820, 0.5830, 0.5840,\n", + " 0.5850, 0.5860, 0.5870, 0.5880, 0.5890, 0.5900, 0.5910, 0.5920, 0.5930,\n", + " 0.5940, 0.5950, 0.5960, 0.5970, 0.5980, 0.5990, 0.6000, 0.6010, 0.6020,\n", + " 0.6030, 0.6040, 0.6050, 0.6060, 0.6070, 0.6080, 0.6090, 0.6100, 0.6110,\n", + " 0.6120, 0.6130, 0.6140, 0.6150, 0.6160, 0.6170, 0.6180, 0.6190, 0.6200,\n", + " 0.6210, 0.6220, 0.6230, 0.6240, 0.6250, 0.6260, 0.6270, 0.6280, 0.6290,\n", + " 0.6300, 0.6310, 0.6320, 0.6330, 0.6340, 0.6350, 0.6360, 0.6370, 0.6380,\n", + " 0.6390, 0.6400, 0.6410, 0.6420, 0.6430, 0.6440, 0.6450, 0.6460, 0.6470,\n", + " 0.6480, 0.6490, 0.6500, 0.6510, 0.6520, 0.6530, 0.6540, 0.6550, 0.6560,\n", + " 0.6570, 0.6580, 0.6590, 0.6600, 0.6610, 0.6620, 0.6630, 0.6640, 0.6650,\n", + " 0.6660, 0.6670, 0.6680, 0.6690, 0.6700, 0.6710, 0.6720, 0.6730, 0.6740,\n", + " 0.6750, 0.6760, 0.6770, 0.6780, 0.6790, 0.6800, 0.6810, 0.6820, 0.6830,\n", + " 0.6840, 0.6850, 0.6860, 0.6870, 0.6880, 0.6890, 0.6900, 0.6910, 0.6920,\n", + " 0.6930, 0.6940, 0.6950, 0.6960, 0.6970, 0.6980, 0.6990, 0.7000, 0.7010,\n", + " 0.7020, 0.7030, 0.7040, 0.7050, 0.7060, 0.7070, 0.7080, 0.7090, 0.7100,\n", + " 0.7110, 0.7120, 0.7130, 0.7140, 0.7150, 0.7160, 0.7170, 0.7180, 0.7190,\n", + " 0.7200, 0.7210, 0.7220, 0.7230, 0.7240, 0.7250, 0.7260, 0.7270, 0.7280,\n", + " 0.7290, 0.7300, 0.7310, 0.7320, 0.7330, 0.7340, 0.7350, 0.7360, 0.7370,\n", + " 0.7380, 0.7390, 0.7400, 0.7410, 0.7420, 0.7430, 0.7440, 0.7450, 0.7460,\n", + " 0.7470, 0.7480, 0.7490, 0.7500, 0.7510, 0.7520, 0.7530, 0.7540, 0.7550,\n", + " 0.7560, 0.7570, 0.7580, 0.7590, 0.7600, 0.7610, 0.7620, 0.7630, 0.7640,\n", + " 0.7650, 0.7660, 0.7670, 0.7680, 0.7690, 0.7700, 0.7710, 0.7720, 0.7730,\n", + " 0.7740, 0.7750, 0.7760, 0.7770, 0.7780, 0.7790, 0.7800, 0.7810, 0.7820,\n", + " 0.7830, 0.7840, 0.7850, 0.7860, 0.7870, 0.7880, 0.7890, 0.7900, 0.7910,\n", + " 0.7920, 0.7930, 0.7940, 0.7950, 0.7960, 0.7970, 0.7980, 0.7990, 0.8000,\n", + " 0.8010, 0.8020, 0.8030, 0.8040, 0.8050, 0.8060, 0.8070, 0.8080, 0.8090,\n", + " 0.8100, 0.8110, 0.8120, 0.8130, 0.8140, 0.8150, 0.8160, 0.8170, 0.8180,\n", + " 0.8190, 0.8200, 0.8210, 0.8220, 0.8230, 0.8240, 0.8250, 0.8260, 0.8270,\n", + " 0.8280, 0.8290, 0.8300, 0.8310, 0.8320, 0.8330, 0.8340, 0.8350, 0.8360,\n", + " 0.8370, 0.8380, 0.8390, 0.8400, 0.8410, 0.8420, 0.8430, 0.8440, 0.8450,\n", + " 0.8460, 0.8470, 0.8480, 0.8490, 0.8500, 0.8510, 0.8520, 0.8530, 0.8540,\n", + " 0.8550, 0.8560, 0.8570, 0.8580, 0.8590, 0.8600, 0.8610, 0.8620, 0.8630,\n", + " 0.8640, 0.8650, 0.8660, 0.8670, 0.8680, 0.8690, 0.8700, 0.8710, 0.8720,\n", + " 0.8730, 0.8740, 0.8750, 0.8760, 0.8770, 0.8780, 0.8790, 0.8800, 0.8810,\n", + " 0.8820, 0.8830, 0.8840, 0.8850, 0.8860, 0.8870, 0.8880, 0.8890, 0.8900,\n", + " 0.8910, 0.8920, 0.8930, 0.8940, 0.8950, 0.8960, 0.8970, 0.8980, 0.8990,\n", + " 0.9000, 0.9010, 0.9020, 0.9030, 0.9040, 0.9050, 0.9060, 0.9070, 0.9080,\n", + " 0.9090, 0.9100, 0.9110, 0.9120, 0.9130, 0.9140, 0.9150, 0.9160, 0.9170,\n", + " 0.9180, 0.9190, 0.9200, 0.9210, 0.9220, 0.9230, 0.9240, 0.9250, 0.9260,\n", + " 0.9270, 0.9280, 0.9290, 0.9300, 0.9310, 0.9320, 0.9330, 0.9340, 0.9350,\n", + " 0.9360, 0.9370, 0.9380, 0.9390, 0.9400, 0.9410, 0.9420, 0.9430, 0.9440,\n", + " 0.9450, 0.9460, 0.9470, 0.9480, 0.9490, 0.9500, 0.9510, 0.9520, 0.9530,\n", + " 0.9540, 0.9550, 0.9560, 0.9570, 0.9580, 0.9590, 0.9600, 0.9610, 0.9620,\n", + " 0.9630, 0.9640, 0.9650, 0.9660, 0.9670, 0.9680, 0.9690, 0.9700, 0.9710,\n", + " 0.9720, 0.9730, 0.9740, 0.9750, 0.9760, 0.9770, 0.9780, 0.9790, 0.9800,\n", + " 0.9810, 0.9820, 0.9830, 0.9840, 0.9850, 0.9860, 0.9870, 0.9880, 0.9890,\n", + " 0.9900, 0.9910, 0.9920, 0.9930, 0.9940, 0.9950, 0.9960, 0.9970, 0.9980,\n", + " 0.9990], device='cuda:0')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n", + " 0.0900, 0.1000, 0.1100, 0.1200, 0.1300, 0.1400, 0.1500, 0.1600, 0.1700,\n", + " 0.1800, 0.1900, 0.2000, 0.2100, 0.2200, 0.2300, 0.2400, 0.2500, 0.2600,\n", + " 0.2700, 0.2800, 0.2900, 0.3000, 0.3100, 0.3200, 0.3300, 0.3400, 0.3500,\n", + " 0.3600, 0.3700, 0.3800, 0.3900, 0.4000, 0.4100, 0.4200, 0.4300, 0.4400,\n", + " 0.4500, 0.4600, 0.4700, 0.4800, 0.4900, 0.5000, 0.5100, 0.5200, 0.5300,\n", + " 0.5400, 0.5500, 0.5600, 0.5700, 0.5800, 0.5900, 0.6000, 0.6100, 0.6200,\n", + " 0.6300, 0.6400, 0.6500, 0.6600, 0.6700, 0.6800, 0.6900, 0.7000, 0.7100,\n", + " 0.7200, 0.7300, 0.7400, 0.7500, 0.7600, 0.7700, 0.7800, 0.7900, 0.8000,\n", + " 0.8100, 0.8200, 0.8300, 0.8400, 0.8500, 0.8600, 0.8700, 0.8800, 0.8900,\n", + " 0.9000, 0.9100, 0.9200, 0.9300, 0.9400, 0.9500, 0.9600, 0.9700, 0.9800,\n", + " 0.9900])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "LinearInferenceSchedule(nsteps = 100, min_t=0, inclusive_end=False).generate_schedule()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "for dt, t in zip(dts, ts):\n", + " t = schedule.pad_time(num_samples, t, DEVICE)\n", + " logits = model(xt, t)\n", + " xt = dfm.step(logits, t, xt, dt, stochasticity=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generated DFM Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ground Truth Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_ones = torch.randint(0, D+1, (1000,))\n", + "x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long()\n", + "counts = x1.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discrete Uniform Prior Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x0 = dfm.sample_prior((10000, D))\n", + "counts = x0.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## We see that with DFM we are able to approximate the ground truth distribution.Now let's try a different interpolant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# D3PM Interpolant" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.prior import DiscreteUniformPrior\n", + "from bionemo.moco.interpolants import D3PM\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule\n", + "from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule\n", + "\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 2 # state space\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "prior = DiscreteUniformPrior(num_classes=S)\n", + "time_distribution = UniformTimeDistribution(discrete_time = True, nsteps = 1000)\n", + "noise_schedule = DiscreteCosineNoiseSchedule(nsteps = 1000)\n", + "d3pm = D3PM(time_distribution=time_distribution,\n", + " prior_distribution=prior,\n", + " noise_schedule = noise_schedule,\n", + " device=DEVICE)\n", + "schedule = DiscreteLinearInferenceSchedule(nsteps = 1000, direction=\"diffusion\", device=DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.5000, 0.5000])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = Model(D, S)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n", + "d3pm.terminal_distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train D3PM" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [01:08<00:00, 727.62it/s]\n" + ] + } + ], + "source": [ + "model = model.to(DEVICE)\n", + "losses = []\n", + "for _ in tqdm(range(50000)):\n", + " num_ones = torch.randint(0, D+1, (B,))\n", + " x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long().to(DEVICE)\n", + " # x1 e.g. [1, 1, 1, 0, 0, 0, 0, 0, 0, 0] or [1, 1, 1, 1, 1, 1, 1, 1, 1, 0]\n", + " optimizer.zero_grad()\n", + " # x0 = dfm.sample_prior(x1.shape) # B x D\n", + " t = d3pm.sample_time(B)\n", + " xt = d3pm.interpolate(x1, t)\n", + " logits = model(xt, t) # (B, D, S)\n", + " loss = d3pm.loss(logits, x1, xt, t).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, label='Training Loss', linestyle='-', color='blue', marker='o')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.ylim([0,1])\n", + "# plt.yscale('log')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sample from D3PM" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "ts = schedule.generate_schedule()\n", + "num_samples = 1000\n", + "xt = d3pm.sample_prior((num_samples, D))\n", + "for t in ts:\n", + " t = torch.full((xt.shape[0],), t).to(DEVICE)\n", + " logits = model(xt, t)\n", + " xt = d3pm.step(logits, t, xt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## D3PM Generated Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## D3PM Prior Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xt = d3pm.sample_prior((num_samples, D))\n", + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now let's try a new interpolant and a new prior" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MDLM Interpolant" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.distributions.prior import DiscreteMaskedPrior\n", + "from bionemo.moco.interpolants import MDLM\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.schedules.noise.continuous_noise_transforms import CosineExpNoiseTransform\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "\n", + "DEVICE = \"cuda:0\"\n", + "prior = DiscreteMaskedPrior(num_classes = 2, inclusive = False)\n", + "time_distribution = UniformTimeDistribution(discrete_time = False)\n", + "noise_schedule = CosineExpNoiseTransform()\n", + "mdlm = MDLM(time_distribution=time_distribution,\n", + " prior_distribution=prior,\n", + " noise_schedule = noise_schedule,\n", + " device=DEVICE)\n", + "schedule = LinearInferenceSchedule(direction = \"diffusion\", nsteps = 1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior.num_classes # The inclusive flag allows us to chose whether or not to add a dimension" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train MDLM" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/50000 [00:00<?, ?it/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [01:34<00:00, 530.83it/s]\n" + ] + } + ], + "source": [ + "# training\n", + "B = 32 # batch size\n", + "D = 10 # dimension\n", + "S = 3 # state space\n", + "\n", + "model = Model(D, S)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n", + " \n", + "model = model.to(DEVICE)\n", + "losses = []\n", + "for _ in tqdm(range(50000)):\n", + " num_ones = torch.randint(0, D+1, (B,))\n", + " x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long().to(DEVICE)\n", + " # x1 e.g. [1, 1, 1, 0, 0, 0, 0, 0, 0, 0] or [1, 1, 1, 1, 1, 1, 1, 1, 1, 0]\n", + " optimizer.zero_grad()\n", + " # x0 = dfm.sample_prior(x1.shape) # B x D\n", + " t = mdlm.sample_time(B)\n", + " xt = mdlm.interpolate(x1, t)\n", + " logits = model(xt, t) # (B, D, S)\n", + " loss = mdlm.loss(logits, x1, xt, t).mean()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.item())" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZ0JJREFUeJzt3Xl4E9XeB/Bvmu6UsrSllLYsAgrIpiC9BasgVRAvAgVFREFcEVCwosgVKOBVXBHcwA24LgiyiLwKaKlUQVEEQUERRdmlZam0rG2anvePMWmSZplkJjNJ+v08T542k5k5JyfJzG/OnMUghBAgIiIiChFhemeAiIiISE0MboiIiCikMLghIiKikMLghoiIiEIKgxsiIiIKKQxuiIiIKKQwuCEiIqKQwuCGiIiIQgqDGyIiIgopDG6IyO/uuOMONG/e3Kdtp0+fDoPBoG6GiCikMbghqsUMBoOsR2Fhod5Z1cUdd9yBuLg4vbNBRF4ycG4potrrvffes3v+zjvvID8/H++++67d8muvvRbJyck+p2MymVBVVYWoqCivt62srERlZSWio6N9Tt9Xd9xxB5YvX44zZ85onjYR+S5c7wwQkX5uu+02u+fffvst8vPzayx3dO7cOcTGxspOJyIiwqf8AUB4eDjCw3moIiL5eFuKiNzq2bMn2rdvj23btuGqq65CbGws/vOf/wAAPv74Y9xwww1o0qQJoqKi0LJlSzzxxBMwm812+3Bsc7N//34YDAY8//zzeOONN9CyZUtERUXhiiuuwPfff2+3rbM2NwaDAePGjcOqVavQvn17REVF4dJLL8W6detq5L+wsBBdu3ZFdHQ0WrZsiddff131djzLli1Dly5dEBMTg8TERNx22204cuSI3TpFRUUYNWoU0tLSEBUVhZSUFAwYMAD79++3rrN161b06dMHiYmJiImJQYsWLXDnnXeqlk+i2oKXQ0Tk0cmTJ3H99dfjlltuwW233Wa9RbVo0SLExcUhNzcXcXFx+OKLLzBt2jSUlZXhueee87jfxYsX4/Tp07jvvvtgMBjw7LPPIicnB3/++afH2p5NmzZh5cqVGDNmDOrWrYuXXnoJgwcPxsGDB5GQkAAA2L59O/r27YuUlBTMmDEDZrMZM2fORFJSkvJC+ceiRYswatQoXHHFFZg1axaKi4sxd+5cfP3119i+fTvq168PABg8eDB+/vlnPPDAA2jevDmOHTuG/Px8HDx40Pr8uuuuQ1JSEh577DHUr18f+/fvx8qVK1XLK1GtIYiI/jF27FjheFi4+uqrBQAxf/78GuufO3euxrL77rtPxMbGigsXLliXjRw5UjRr1sz6fN++fQKASEhIECUlJdblH3/8sQAg/u///s+6LC8vr0aeAIjIyEixd+9e67Iff/xRABAvv/yydVn//v1FbGysOHLkiHXZ77//LsLDw2vs05mRI0eKOnXquHy9oqJCNGrUSLRv316cP3/euvyTTz4RAMS0adOEEEL8/fffAoB47rnnXO7ro48+EgDE999/7zFfROQeb0sRkUdRUVEYNWpUjeUxMTHW/0+fPo0TJ04gKysL586dw6+//upxv0OHDkWDBg2sz7OysgAAf/75p8dts7Oz0bJlS+vzjh07Ij4+3rqt2WzG+vXrMXDgQDRp0sS6XqtWrXD99dd73L8cW7duxbFjxzBmzBi7Bs833HAD2rRpg08//RSAVE6RkZEoLCzE33//7XRflhqeTz75BCaTSZX8EdVWDG6IyKPU1FRERkbWWP7zzz9j0KBBqFevHuLj45GUlGRtjFxaWupxv02bNrV7bgl0XAUA7ra1bG/Z9tixYzh//jxatWpVYz1ny3xx4MABAMAll1xS47U2bdpYX4+KisIzzzyDtWvXIjk5GVdddRWeffZZFBUVWde/+uqrMXjwYMyYMQOJiYkYMGAAFi5ciPLyclXySlSbMLghIo9sa2gsTp06hauvvho//vgjZs6cif/7v/9Dfn4+nnnmGQBAVVWVx/0ajUany4WMESqUbKuHCRMm4LfffsOsWbMQHR2NqVOnom3btti+fTsAqZH08uXLsXnzZowbNw5HjhzBnXfeiS5durArOpGXGNwQkU8KCwtx8uRJLFq0COPHj8e///1vZGdn291m0lOjRo0QHR2NvXv31njN2TJfNGvWDACwZ8+eGq/t2bPH+rpFy5Yt8fDDD+Pzzz/Hrl27UFFRgRdeeMFunX/961948sknsXXrVrz//vv4+eefsWTJElXyS1RbMLghIp9Yak5sa0oqKirw2muv6ZUlO0ajEdnZ2Vi1ahX++usv6/K9e/di7dq1qqTRtWtXNGrUCPPnz7e7fbR27Vrs3r0bN9xwAwBpXKALFy7YbduyZUvUrVvXut3ff/9do9apc+fOAMBbU0ReYldwIvJJ9+7d0aBBA4wcORIPPvggDAYD3n333YC6LTR9+nR8/vnn6NGjB+6//36YzWa88soraN++PXbs2CFrHyaTCf/9739rLG/YsCHGjBmDZ555BqNGjcLVV1+NYcOGWbuCN2/eHA899BAA4LfffkPv3r1x8803o127dggPD8dHH32E4uJi3HLLLQCA//3vf3jttdcwaNAgtGzZEqdPn8abb76J+Ph49OvXT7UyIaoNGNwQkU8SEhLwySef4OGHH8aUKVPQoEED3Hbbbejduzf69Omjd/YAAF26dMHatWsxceJETJ06Fenp6Zg5cyZ2794tqzcXINVGTZ06tcbyli1bYsyYMbjjjjsQGxuLp59+GpMmTUKdOnUwaNAgPPPMM9YeUOnp6Rg2bBgKCgrw7rvvIjw8HG3atMGHH36IwYMHA5AaFG/ZsgVLlixBcXEx6tWrh27duuH9999HixYtVCsTotqAc0sRUa0zcOBA/Pzzz/j999/1zgoR+QHb3BBRSDt//rzd899//x1r1qxBz5499ckQEfkda26IKKSlpKTgjjvuwEUXXYQDBw5g3rx5KC8vx/bt29G6dWu9s0dEfsA2N0QU0vr27YsPPvgARUVFiIqKQmZmJp566ikGNkQhTNfbUl999RX69++PJk2awGAwYNWqVR63KSwsxOWXX46oqCi0atUKixYt8ns+iSh4LVy4EPv378eFCxdQWlqKdevW4fLLL9c7W0TkR7oGN2fPnkWnTp3w6quvylp/3759uOGGG9CrVy/s2LEDEyZMwN13343PPvvMzzklIiKiYBEwbW4MBgM++ugjDBw40OU6kyZNwqeffopdu3ZZl91yyy04deoU1q1bp0EuiYiIKNAFVZubzZs3Izs7225Znz59MGHCBJfblJeX243uWVVVhZKSEiQkJMBgMPgrq0RERKQiIQROnz6NJk2aICzM/Y2noApuioqKkJycbLcsOTkZZWVlOH/+vNPJ/WbNmoUZM2ZolUUiIiLyo0OHDiEtLc3tOkEV3Phi8uTJyM3NtT4vLS1F06ZNsW/fPtStW1fVtEwmE5555hfMmdPlnyW2NUPS3b+FC83o3z8g7gQGLZPJhA0bNqBXr16IiIjQOzshi+WsDZazdljW2vBXOZ8+fRotWrSQde4OquCmcePGKC4utltWXFyM+Ph4p7U2ABAVFYWoqKgayxs2bIj4+HhV83fhggnvvpsJIBr2gY3EYACmTQNuvx34Z85B8oHJZEJsbCwSEhJ4gPIjlrM2WM7aYVlrw1/lbNmXnCYlQTVCcWZmJgoKCuyW5efnIzMzU6cc2fvqKwNOnoyBs8AGAIQADh0CNm7UNl9ERES1ia7BzZkzZ7Bjxw7r7Lz79u3Djh07cPDgQQDSLaURI0ZY1x89ejT+/PNPPProo/j111/x2muv4cMPP7TOvKunlSuBW26RVx1z9KifM0NERFSL6XpbauvWrejVq5f1uaVtzMiRI7Fo0SIcPXrUGugAQIsWLfDpp5/ioYcewty5c5GWloa33npL9xmIV64EhgyRambkSEnxb36IiIhqM12Dm549e8LdMDvORh/u2bMntm/f7sdcecdsBsaPtwQ27u8DGgxAWhqQlaVJ1oiIAkpVVRUqKip0S99kMiE8PBwXLlyA2WzWLR+hTkk5R0ZGeuzmLUdQNSgORBs3AocPy19/zhw2Jiai2qeiogL79u1DVVWVbnkQQqBx48Y4dOgQxznzIyXlHBYWhhYtWiAyMlJRHhjcKCS3/UxCAvDGG0BOjn/zQ0QUaIQQOHr0KIxGI9LT01W5MvdFVVUVzpw5g7i4ON3yUBv4Ws5VVVX466+/cPToUTRt2lRRAMrgRiG57WeWLgV69/ZvXoiIAlFlZSXOnTuHJk2aIDY2Vrd8WG6LRUdHM7jxIyXlnJSUhL/++guVlZWKupHz01UoK0tqR+MuwGzcGOjZU7MsEREFFEu7C6W3Gij0Wb4jSttEMbhRyGgE5s61PHPeOHrSJLazISJiOxfyRK3vCIMbFeTkAMuXA3XqOH/92mu1zQ8REVFtxuBGJTk5wNCh1b0A/vUvHTNDREQBqXnz5pgzZ47s9QsLC2EwGHDq1Cm/5SkUMbhRkW27qcRE/fJBRBSKzGagsBD44APprz+HqjEYDG4f06dP92m/33//Pe69917Z63fv3h1Hjx5FvXr1fEpPrlALothbioiIAt7KldKAqbbjiqWlSW0e/THExlGbcT6WLl2KadOmYc+ePdZlcXFx1v+FEDCbzQgP93xKTUpK8iofkZGRaNy4sVfbEGtuiIgowFmmuHEcMPXIEWn5ypXqp9m4cWPro169ejAYDNbnv/76K+rWrYu1a9eiS5cuiIqKwqZNm/DHH39gwIABSE5ORlxcHK644gqsX7/ebr+Ot6UMBgPeeustDBo0CLGxsWjdujVWr15tfd2xRmXRokWoX78+PvvsM7Rt2xZxcXHo27evXTBWWVmJBx98EPXr10dCQgImTZqEkSNHYuDAgT6Xx99//40RI0agQYMGiI2NxfXXX4/ff//d+vqBAwfQv39/NGjQAHXr1kVmZibWrFlj3Xb48OFISkpCTEwMWrdujYULF/qcFzkY3BARkaaEAM6elfcoKwMefND53H2WZePHS+vJ2Z/cOQDleOyxx/D0009j9+7d6NixI86cOYN+/fqhoKAA27dvR9++fdG/f3+7ORKdmTFjBm6++Wb89NNP6NevH4YPH46SkhKX6587dw7PP/883n33XXz11Vc4ePAgJk6caH39mWeewfvvv4+FCxfi66+/RllZGVatWqXovd5xxx3YunUrVq9ejc2bN0MIgX79+sFkMgEAxo4di/Lycnz11Vf48ccfkZeXZ63dmjp1Kn755ResXbsWu3fvxrx585Do57YbvC1FRESaOncOsLmro4gQUo2OvCYpYV6s69nMmTNxrU132IYNG6JTp07W50888QQ++ugjrF69GuPGjXO5nzvuuAPDhg0DADz11FN46aWXsGXLFvTt29fp+iaTCfPnz0fLli0BAOPGjcPMmTOtr7/88suYPHkyBg0aBAB45ZVXrLUovvj999+xevVqfP311+jevTsA4P3330d6ejpWrVqFm266CQcPHsTgwYPRoUMHVFVVITExEfHx8QCAgwcP4rLLLkPXrl0BSLVX/saaGz9R8+qAiIgCj+VkbXHmzBlMnDgRbdu2Rf369REXF4fdu3d7rLnp2LGj9f86deogPj4ex44dc7l+bGysNbABgJSUFOv6paWlKC4uRrdu3ayvG41GdOnSxav3Zmv37t0IDw9HRkaGdVlCQgIuueQS7N69GwDw4IMP4r///S969OiB6dOnY9euXdZ177//fixZsgSdO3fGo48+im+++cbnvMjF4MZPGNwQETkXGwucOSPvIbfCYc0az/sqK6uCmrM/1HEY3GzixIn46KOP8NRTT2Hjxo3YsWMHOnTo4HEmdMdpBgwGg9sJRp2tL3Q+6dx99934888/cfvtt2Pnzp245ppr8MorrwAArr/+ehw4cAAPPfQQ/vrrL/Tu3dvuNpo/MLghIiJNGQzSoKdyHtdd536KG4MBSE+X1pOzP38Okvz111/jjjvuwKBBg9ChQwc0btwY+/fv91+CTtSrVw/Jycn4/vvvrcvMZjN++OEHn/fZtm1bVFZW4rvvvrMuO3nyJPbs2YN27dpZl6Wnp2P06NFYsWIFxo4di7feesv6WlJSEkaOHIn33nsPc+bMwRtvvOFzfuRgmxsiIgpYliluhgyRAhPbCgpLoDJnTmBMcdO6dWusXLkS/fv3h8FgwNSpU93WwPjLAw88gFmzZqFVq1Zo06YNXn75Zfz999+ypjbYuXMn6tata31uMBjQqVMnDBgwAPfccw9ef/111K1bF4899hhSU1MxYMAAAMCECRNw/fXX4+KLL8bJkyexadMmtGnTBgAwbdo0dOnSBZdeeinKy8vxySefoG3btv558/9gcENERAHNMsWNs3Fu5szxzzg3vpg9ezbuvPNOdO/eHYmJiZg0aRLKyso0z8ekSZNQVFSEESNGwGg04t5770WfPn1glBEBXnXVVXbPjUYjKisrsXDhQowfPx7//ve/UVFRgauuugpr1qyx3iIzm80YO3YsDh8+jPj4eFxzzTV4+eWXAUhj9UyePBn79+9HTEwMsrKysGTJEvXfuA2D0PtGncbKyspQr149lJaWWltyq+Wee8x46y3py9OvX/W94l27gEsvVTWpWs1kMmHNmjXo169fjXvPpB6WszZqQzlfuHAB+/btQ4sWLRAdHe3zfsxmYONG4OhRICUFyMryrsamqqoKZWVliI+PR1hY7WmVUVVVhbZt2+Lmm2/GE088oUl6vpazu++KN+dv1twQEVFQMBqBnj31zkXgO3DgAD7//HNcffXVKC8vxyuvvIJ9+/bh1ltv1Ttrmqk9oSsREVEtEBYWhkWLFuGKK65Ajx49sHPnTqxfv97v7VwCCWtuVCSEH5vhExERyZCeno6vv/5a72zoijU3flK7WjIREREFDgY3RESkiVrWf4V8oNZ3hMENERH5laULsqeReoks3xE53dbdYZsbIiLyq/DwcMTGxuL48eOIiIjQrRt2VVUVKioqcOHChVrVFVxrvpZzVVUVjh8/jtjYWISHKwtPGNwQEZFfGQwGpKSkYN++fThw4IBu+RBC4Pz584iJiZE1Wi/5Rkk5h4WFoWnTpoo/HwY3RETkd5GRkWjdurWut6ZMJhO++uorXHXVVSE7YGIgUFLOkZGRqtSqMbghIiJNhIWFKRqhWCnLVALR0dEMbvwoEMqZNx39hJ0CiIiI9MHgxk/++kvvHBAREdVODG5UtH9/9f8//VT9f36+5lkhIiKqtRjcqGTlSqCgwHnr7txc6XUiIiLyPwY3KjCbgfHj3a8zYYK0HhEREfkXgxsVbNwIHD4MAM5rboQADh2S1iMiIiL/YldwFRw9qu56npjNUqB09CiQkgJkZQEKR6omIiIKGQxuVJCSou567qxcKd0Ck2qKJGlpwNy5QE6O8v0TEREFO96WUkFWlhRgAM4HtzEYgPR0aT0lVq4EhgyxD2wA4MgRaTkbLRMRETG4UYXRKNWcuDNnjrJbR5ZGy84GB7QsY6NlIiIiBjeqGTAAuPxy5zU3s2crv2VU3WjZOTZaJiIikjC4UcHKlUDz5sAPPzgvzuxs5Wlo3WiZiIgoWLFBsUKWdjD+nktKy0bLREREwYw1Nwq4awfjuJ5SlkbLBudD6ajWaJmIiCjYMbhRwFM7GIsfflCelm2jZccAx/JcaaNlIiKiUMDgRgG57VuOH1cnvZwcYPlyIDXVfnlamrSc49wQERGxzY0ictu3JCWpl2ZOjtQzK/yfTy4qCti3jzU2REREFqy5UcBTOxiLyy9XN13bQMZoZGBDRERki8GNAnIG7wOADRv8nxciIiKSMLhRyNIOJj7e9Tq5uZwagYiISCsMblQwYAAQHe36dSGkLuOcGoGIiMj/GNyoYONG4Ngx9+scPgw8+aQ2+SEiIqrNGNyoQG6X8Lw83p4iIiLyNwY3KvBmygO1Z+721FOLiIiotmFwo4KsLKBRI3nrcuZuIiIi/2JwowKjEXj4Yfnrc+ZuIiIi/2Fwo5IdO+Svy5m7iYiI/IfBjQqWLQM++EDeuvXqceZuIiIif2Jwo5DZDNx9t/z1y8uBjz/2X36IiIhqOwY3Cj35JFBWJn/9CxeAIUPYJZyIiMhfGNwoYDbLm1vKGbW7hBMREZGEwY0CGzcCJSXebycEu4QTERH5C4MbBZR26WaXcCIiIvUxuFFAaZdudgknIiJSH4MbBbKygNRU77czGID0dHYJJyIi8gfdg5tXX30VzZs3R3R0NDIyMrBlyxa368+ZMweXXHIJYmJikJ6ejoceeggXLlzQKLf2jEbg3nu9304IYM4caXsiIiJSl67BzdKlS5Gbm4u8vDz88MMP6NSpE/r06YNjx445XX/x4sV47LHHkJeXh927d+Ptt9/G0qVL8Z///EfjnFdr3dr7bRISgAED1EmfE2cSERHZ0zW4mT17Nu655x6MGjUK7dq1w/z58xEbG4sFCxY4Xf+bb75Bjx49cOutt6J58+a47rrrMGzYMI+1Pf70++/eb3PypHo9pYRQZz9EREShIlyvhCsqKrBt2zZMnjzZuiwsLAzZ2dnYvHmz0226d++O9957D1u2bEG3bt3w559/Ys2aNbj99ttdplNeXo7y8nLr87J/RtwzmUwwmUyK3oPZDLz+uqUIvatCOXCgEiaTksgk4p+/AiZTpYL9BB/L56b08yP3WM7aYDlrh2WtDX+Vszf70y24OXHiBMxmM5KTk+2WJycn49dff3W6za233ooTJ07gyiuvhBAClZWVGD16tNvbUrNmzcKMGTNqLP/8888RGxur6D3s3JmAv/660qdtCwt3o379PxWkLt3XMpvNWLNmjYL9BK/8/Hy9s1ArsJy1wXLWDstaG2qX87lz52Svq1tw44vCwkI89dRTeO2115CRkYG9e/di/PjxeOKJJzB16lSn20yePBm5ubnW52VlZUhPT8d1112H+Ph4Rfk5dcr3Bi+NG7dDv35tFKUPAEajEf369VO8n2BiMpmQn5+Pa6+9FhEREZ43IJ+wnLXBctYOy1ob/irnMi/mOtItuElMTITRaERxcbHd8uLiYjRu3NjpNlOnTsXtt9+Ou/+ZqbJDhw44e/Ys7r33Xjz++OMIC6vZhCgqKgpRUVE1lkdERCgu9L//9n3b8HAjIiLU6C5lqLU/UjU+Q/KM5awNlrN2WNbaULucvdmXbg2KIyMj0aVLFxQUFFiXVVVVoaCgAJmZmU63OXfuXI0AxvhPf2qhQ8vapCTft+3ZU7VsEBERkQ1db0vl5uZi5MiR6Nq1K7p164Y5c+bg7NmzGDVqFABgxIgRSE1NxaxZswAA/fv3x+zZs3HZZZdZb0tNnToV/fv3twY5WnJRweRRXByDGyIiIn/RNbgZOnQojh8/jmnTpqGoqAidO3fGunXrrI2MDx48aFdTM2XKFBgMBkyZMgVHjhxBUlIS+vfvjyeffFKvt+CTRx6R/hYWSvNLpaRIoxVzUD8iIiLldG9QPG7cOIwbN87pa4WFhXbPw8PDkZeXh7y8PA1y5pmLsQbdSkgA2rUDmjcHDh+uXp6WBsydC+TkqJY9IiKiWkn36ReCWaNG3m9z553AzTfbBzYAcOQIMGQIsHKlOnkjIiKqrRjcKGA2e7f+1KnABx84H1XYsmzCBO/3S0RERNUY3Cjw5Zfer+9YY2NLCODQIe+mZuDcUkRERPYY3Chw8KB363/1lbz1jh71Pi9EREQkYXCjQNOm/tlvSop/9ktERFQbMLhR4Kqr1N2fwQCkp0vdwomIiMg3DG4U2LFDvX1Z2s7MmcPxboiIiJRgcKPA6tW+b1u3rv3ztDRg+XKOc0NERKQUgxsFvJigtIaMjOr/N2wA9u1jYENERKQGBjcKtG/v+7br11f/37Mnb0URERGphcGNAl266J0DIiIicsTgRoGkJL1zQERERI4Y3Cjw7bfq7OeDD6QZwjntAhERkXIMbhQ4dEid/dx6K9CrlzRTOCfOJCIiUobBjQK//abu/jgzOBERkXIMbhRwHKtGKV9mBufEmURERPYY3CjQrZv6+/RlZnAiIiKqxuBGgRtu8N++OTM4ERGRbxjcKLB5s//2zZnBiYiIfBOudwaC2f796u/TYJDmmZI7M7ilnQ4RERFJWHOjgL8a83JmcCIiIt8xuFGgWTP19zlxIifQJCIiUoLBjQLXXKP+Pt9+Gygo4GjFREREvmJwo0DPnkBUlLr7LCkBsrOBRo2AmTOBigppagZO0UBERCQPGxQrYDQClZX+2XdJCZCXB8yYAVRVVS9PSwPmzvVPmkRERKGANTcKlJb6vybFNrABqqdoICIiIucY3CjQr5/2abLrNxERkXsMbhRQe+JMuWwDHM4tRUREZI/BjQKsRSEiIgo8DG4UaNVK7xwQERGRIwY3CsTF6ZMub0URERG5xuBGgaQk7dNkYENEROQeg5sAF+bwCaWlAcuX65MXIiKiYMDgRgF/16IkJgJvvVX9/PPPgX37OPcUERGROwxuFHCsVVHbiRPAnXdWP7/6as4WTkRE5AmDGwWaNtU2vVWrtE2PiIgoGDG4UaBBA23Te/hhTpxJRETkCYMbBUpKtE3v8GFg40Zt0yQiIgo2DG4UOHRI+zSPHtU+TSIiomDC4CbIpKTonQMiIqLAxuBGAa0bFKelAVlZ9ss4qB8REZE9BjcKNGyobXqzZ7MrOBERkSfhemcgmGndoHjQIG3TIyKiwGQ2Sx1Mjh6VmitkZfHi1xZrbhQ4fNj/adSt6/80iIgoeKxcCTRvDvTqBdx6q/S3eXNpOUkY3CiQnu7/NE6f9n8aREQUHFauBIYMqXlxfeSItJwBjoTBjQLXXKNtehzAj4godJnNQGEh8MEH0l/HY77ZDIwfDwhRc1vLsgkTeK4AGNwo4thzyd82baq5zNmXnIiIgoucW00bN7pvDiGENP4aB3tlcKOI1l8gDuBHRBR65N5qknsO4LmCwY0iBQXapscB/IiIQos3t5rkngN4rmBwo8j332ubnta3wYiIyL+8udWUlSUN5upq8FaDQerownMFgxtFzp/XNj2OYUBEFFq8udVkNAJz50rPHQMcy/M5c3iuABjcKKL19AtsAU9EFFq8vdWUkwMsXw6kptq/npYmLc/JUTd/wYrBjQIdOmibnrMGzJxbiogoePlyqyknB9i/3369ffsY2NhicKPAzp3apldUpG16RETkX77eavL0vLZjcKPAwYPapte4sbbpERGR//FWk/oY3CigdZsbtoAnIgpNjreaBgzgrSYlGNwo0Lmz3jkgIqJQYXtrKTWVt5qUYHCjQGmptulxSG0iIiLPwvXOQDAL0zg0DOYGxWazFJwdPSp1aczK4lUJEZEr7AmrDGtuFOjZU9v0grVBsZwJ4YiIiNTC4EaB7t21TS8YGxTLnRCOiIhILQxuFHjtNW3TC7bbON5MCEdERKQWBjcKaN3A97//Da5AwJsJ4YiIqCazGSgsBD74QPobTOcAPeke3Lz66qto3rw5oqOjkZGRgS1btrhd/9SpUxg7dixSUlIQFRWFiy++GGvWrNEot/ZOn9Y2venTgeTk4LmV482EcEREZI/tFX2na2+ppUuXIjc3F/Pnz0dGRgbmzJmDPn36YM+ePWjUqFGN9SsqKnDttdeiUaNGWL58OVJTU3HgwAHUr19f+8zr5ORJqa2KRSC3qPd2QjgiIpL88YfU9MHxtr6lveLy5frkK1joGtzMnj0b99xzD0aNGgUAmD9/Pj799FMsWLAAjz32WI31FyxYgJKSEnzzzTeIiIgAADRv3lzLLNuJjdUnXWdtWAKRZUK4I0ec59lgkF4PxobSRET+tHGj6/aKBoPUXpFc0y24qaiowLZt2zB58mTrsrCwMGRnZ2Pz5s1Ot1m9ejUyMzMxduxYfPzxx0hKSsKtt96KSZMmweiitW15eTnKy8utz8vKygAAJpMJJpNJ0XswGMIA6NvKVwgBk6lS1zy488ILBtxyixEGAyBEdTWTwSD9ap9/3oyqKoGqKvn7tHxuSj8/co/lrA2Ws3aCo6ylC/ezZ12vYWmvaCuQ3pO/ytmb/ekW3Jw4cQJmsxnJycl2y5OTk/Hrr7863ebPP//EF198geHDh2PNmjXYu3cvxowZA5PJhLy8PKfbzJo1CzNmzKix/PPPP0eswqqXCxc6ALhI0T6UOn0amDp1OzIzA7PhSlQU8OijKXj99Y44dSraujwh4TzuumsXoqKOwtcmU/n5+SrlktxhOWuD5aydwC7rAT5tpVfbU3fULudz587JXtcghD43Of766y+kpqbim2++QWZmpnX5o48+ii+//BLfffddjW0uvvhiXLhwAfv27bPW1MyePRvPPfccjrpoleqs5iY9PR0nTpxAfHy8ovcweHAY/u//9O6fLWAwAEuWmDFoUODer9qzB+jQQboiWbOmEr16CZ+7tptMJuTn5+Paa6+13p4k9bGctcFy1k4wlHVkpG/5qqgIrJobf5RzWVkZEhMTUVpa6vH8rVvNTWJiIoxGI4qLi+2WFxcXo7GLoXhTUlIQERFhdwuqbdu2KCoqQkVFBSIjI2tsExUVhaioqBrLIyIiFBd6WpqizVUi3eqZODEcgwcH7lg40dWVNujdOxxOPiqvqfEZkmcsZ22wnLUTDGUdFyfdmnLXXtH21lQgvh+1y9mbfenWFTwyMhJdunRBQUGBdVlVVRUKCgrsanJs9ejRA3v37kWVTQON3377DSkpKU4DG39r0ULzJJ3ieDFERKHFVUcLSw/ZOXM0y0pQ0nWcm9zcXLz55pv43//+h927d+P+++/H2bNnrb2nRowYYdfg+P7770dJSQnGjx+P3377DZ9++imeeuopjB07Vq+3EFCCZbyYYOntRUSkl5Ytpe7eDRrYL09Lk5bn5OiTr2Cha1fwoUOH4vjx45g2bRqKiorQuXNnrFu3ztrI+ODBgwizmXo7PT0dn332GR566CF07NgRqampGD9+PCZNmqRL/g8e1CVZl5wMDRQwAnk8HiKiQJSTA5SVAf9c72PDBqlGJ1CbHwQSXYMbABg3bhzGjRvn9LXCwsIayzIzM/Htt9/6OVfytGypdw6IiCgUWS4Iba7v0bOnLlkJSrpPvxDMxozROwf2Vq3i3CNEREQMbhSIjAQyMvTORbVXXuHcI0RERAxuFHrySb1zUJNl7pFADXDYoJiIiPyJwY1CgXgPVAjpMX48b1ERyWU2S7d1P/iAt3cpcLAzhm8Y3ChUUaF3Dlw7fDgwa5ZCCU+IoWHlSul2bq9ewK238vYuBR8ei+wxuFHoxhv1zoF7eXmBcYC2vfoIldtSPCGGhpUrpdu4hw/bLw/027tEtngsssfgRgGzGVi/Xu9ceDZhgusoXqtoP9SqVnlCDA1ms3T71lnAbVnm7vdDFCh4LLLH4EYBJ8PwBCRXUzOw5sE3PCGGjo0ba54UbHFqE9KL0gvC2n4sYnCjwBdf6J0D+RynZmDNg++UnBB5XzywyJ2yJFimNqHQoyTIqc3BOYMbBWxnZA10KSnV/3tT88CTcU2+nhBZUxZ4bH8XaqxHFIhqY3DO4EaBJk30zoFnBgOQnm4/w6zcmocnn+TJ2BlfTojBXFMWygFuVpY0EaGrq2Nnvx+iYFMbg3MGNwr8/bfeOXDPcsCeM8d+ojW5UXxeXnCejP3N2xNiMLfR2bw5Ba1ahYdsgGs0AnPnSv87fp6ufj9EwaI2B+cMbhQoLtY7B+6lpQHLl0szy9pSEsUH+slYC96eEIO10epHHxnwzDNX4MgR++WhFuDm5Ei/k9RU++Wufj9EgYjBuT0GNwrUrat3DlzbsAHYt8/5gdlTzYMnSk/GoTDOjTcnxGBstGo2A7m5liOi/RclFAPcnBxg/377565+P0RaknucZnBuj8GNArffrncOXOvZ03W0LqfmQQ5vTsahNs4NUPOE2KuX8xNiMDZa3bgROHLEAMfAxiJQa5uUsP29pKXVzqtdCl62xyKjkcE5gxsFevfWOwe+c1fzMGOGvH0E0slYL7YnwORk5yfEYGy0Goy1TVoJ5QbWFDi8vSC0PfaEhTE4Z3ATApKTfdvOseYhOVmK9h9/3L8n41C4LeUNfzZa9deJNhhrm9Tk6rsfKN35GWARucfgRoFAqZL/5BPft7U9oUZHS89tT8aOansjNV/5o9GqP0+0WVlAaqoA4DwSVbu2KRhO1oHSnT9QAiwKbMHwm/Inn4KbQ4cO4bDNL3zLli2YMGEC3njjDdUyFgwCpUr+hx/U36flZBwVZb+8tjdSc8dTNbJjTdmLL/p+X9zfJ1qjEZg923I0tA9w1A5wg+FkHSjd+QMlwCLt+NJesaoq8H9T/uZTcHPrrbdiw4YNAICioiJce+212LJlCx5//HHMnDlT1QwGskCpkr/vPv/sNycH+Ne/qp+764FF8tgGA507+34rSosT7aBBApMmfe/XAFfJyVqrK1OzGXj5Zf278wdKgEXaUHL73mxmAOxTcLNr1y5069YNAPDhhx+iffv2+Oabb/D+++9j0aJFauYvoGVlAQ0b6p0L/7K9anDXA8ub/ZAyWo6bk5l5FD16VB9l1QxwlZys/VHbY5vO4cPSc0s6Dz0kbx/+rM0N1vGSKDDUtgDYp+DGZDIh6p/LufXr1+PGG28EALRp0wZHA+VejQaMRuC11/TOhX/5IyipbQ2KHWsYlNK6J5NaAa4jX0/W/rg1YwliLFaskBrYDx7sPo+O/Fmbyx5spFRtCoB9Cm4uvfRSzJ8/Hxs3bkR+fj769u0LAPjrr7+QkJCgagYDna89lWqb2lpz46yGQSk9ezKpeQvIl5O1P27NuAqWTp6Uvw8tuvPX9h5stY0/j5m1IQD2Kbh55pln8Prrr6Nnz54YNmwYOnXqBABYvXq19XZVbVEbviQkj+MJ19VJ0+Krr3xLR+txc2ynGVGzcaIvJ2u1b824C5bk0qoHYTCOl0TK+SPIqQ0BsE/BTc+ePXHixAmcOHECCxYssC6/9957MX/+fNUyFwwaNdI7B+qpbbeL/EnOSfOVV3yrAdFyssfNm1Owa1fNo6sajRN9OVmrfWvGU7Akh1Y9CDlEAylVmwJgn4Kb8+fPo7y8HA0aNAAAHDhwAHPmzMGePXvQKJTO9rWYpZ1IoE8OGqjknDSPH/f93rcWkz2azcBbb3Vw+poajRN9OVmrfWtGac1r167a9iC0fO516tgv5xAN5EltC4B9Cm4GDBiAd955BwBw6tQpZGRk4IUXXsDAgQMxb948VTMY6I4d0zsHzinpImvbTuSXX+yXkzxaNP50HDfnpZfUPdFu2mTAyZMx8GZ+KW+7Z1tO1nFx9stdnazVvjWjtHq+TRvtTxQ5OcDw4dXPOUQDOQoL4xhlPgU3P/zwA7L+OXosX74cycnJOHDgAN555x289NJLqmYw0AXqvUtfu8i6ayfieBtCrxEwzWZg584ELFliCNiRN/3d+NNS9h9+WL3s8svVPdHKDbxWrJDysny5b92zc3KAO++sfu7uZK32LTlPwZIztuuG6TTGu226avZgI/1YftMWVVW+78tgALp3r35eGwNgn36a586dQ926dQEAn3/+OXJychAWFoZ//etfOHDggKoZDHRZWUB8vN65cE9u+wghPLcTGT8eKCiQxv1ISdF2BEyzGZg5E0hNDcfUqVdixIhwv6brbfBme9KTc9JMSvLt3rdjDywLNbqZ25IbeL3yipSXm27yvXu2NydrNW/JyQmWHKWlVf/PdmqS2j7Uv1K2v2mLhQul5b42KPZmCIeQ/PyEDzp06CDmzp0rDh48KOLj48U333wjhBBi69atIjk52Zddaqa0tFQAEKWlpart84EHhJAOc4H7MBiESE8XorKyZv4t6zRqpDwNg0GIFSuk/VZWCrFhgxCLFwuxZEn1emVl3pfxihVCJCTIS1cNK1YIkZZmn05amvM0LK8PG1ZzHwaD6/KaPt23fLnbp5plcP58hUhIOCeAKsXfP1ffPYsJE6rXlauysnqb9u3d798TZ593erq0PC6uetmGDfbp3n6772laVFRUiFWrVomKigrZ24we7X15+Ys3vxW9+VLW/ubuN20wCPHQQ64/a9t1bZ8bjUJcc42874g/Pj9/lbM352+ffhrLli0TERERIiwsTGRnZ1uXP/XUU6Jv376+7FIz/ghuXnxR/+BF7uPFF6Vgw3KQFqL6NVfBg7ePhg2FyMur+YOxPLwt+hUrPKfpLnjzlquDjWXZjBn2ZWh53TG4seyrbl3neS4o8C5flZWuy1RuEOGNiooKMWnSd0KN4AaQyssVX4IbIaq3ufJKRW9VCGH/WQLV5Wj7+TmmW9uDG3e/FbUvONTgbVnbXqDZHjPV4uk3bTDYH5cd2a5r+1xucOOvzy8QghufbksNGTIEBw8exNatW/HZZ59Zl/fu3RsvvviiKjVKwSQpSe8cyPfQQ65vI6nVfqCkBJgxw3VvodWr5e/L0qXaEyHUGXlTziBxeXn2ZehOTg4wdmz183+mZPPJk0967oGl9uijmZlH0b69k8Lwwccfu37NWXlrzbHanu1Y3Av1ua60mNBVzrhN3gwm6Y1Q//x8Pp01btwYl112Gf766y/rDOHdunVDmzZtVMtcsHC89x8sLO0hLKKi7NsT+Mtjj7n/wdje//U0YaEjpV17vR335MgRz+s4tifxxcqVUlAlh9oDS6o1usP77wfngTIQAi9f+bMtRSjPdaXV7Ov+GgRWznc2lD8/wMfgpqqqCjNnzkS9evXQrFkzNGvWDPXr18cTTzyBKiVNvIOUpfFosHH8AZw/Lz387cgR1z8Yx6sluRMWWig9EXt7sLEtQ3999eXWXlkEag8+JeP6hAotG276u+YhVOe60rJGQ8/faqh+fhbhvmz0+OOP4+2338bTTz+NHj16AAA2bdqE6dOn48KFC3jyySdVzWSg+/hjbYICf7D9Afur+tMZZz8Yy9WSnlfKSg42x4+rlw9b3tQmaTH6aGys9H335XMK1gOlGlaulE6atp9lWhrwwguGGmOSqJGWs9+SpeZBjfFOQnWuK29qNHytibWwXBgfOeL892QwAA0b+ufYLPdzKS6WgvGUFCm/wXK71qeam//973946623cP/996Njx47o2LEjxowZgzfffBOLFi1SOYuBzXIQ0TIw0Iuac5w4/rDUmOMHUD6ooi/jnlh4G+DKTePQIfn71GL00Suu8H1bVwfUYL71I4e72xy33GLE5s3qRQByax4qKpzXIsmtXfLnXFd6dk3WskbD3SjdFiNHKk/HGTnHOqPRdTvNQO8+7lNwU1JS4rRtTZs2bVBSUqI4U8FCrRNysFDrfaam1jzgyWksK4erk6fcH6K7cU88iYlxvtzVfuSW53ffyVuvWzdtBulq1ky68m/Y0H65u6CqNs1p40hOsPH22+1VOznIrXlIS6t5y+rRR2veymrUSBpfyjF//prjTIuGvO5oXSPlapTuuDhpub/mopYTWDl+5paaP2ffEy0/Izl8Cm46deqEV155pcbyV155BR07dlScqWChxqR7tdGIEdLIupYgw5vGsu64GhTP24Olq0HiPHHV3kdpUCh3+yZNlKXjjZwcaboHiw0bgCVLnK+r5EQXCFeH7spfnYabBpw4EYtNm9SpGpVbo+B4G/XwYeC552rmtaRE+n0mJ9f8zag9x5lWDXnd6d7dfQ9YfwTqAwYA2dn2y+66Syo/f8wKbmH5/P4Zk9fK1e/U0lnc2fdEy89IDp+Cm2effRYLFixAu3btcNddd+Guu+5Cu3btsGjRIjz//PNq5zFg1eb2A0rMmlUdZDRrBtx7rzr7fe21mj9KXw+WjvM23X6784OM7TJ/HYRat5a/rj9O/q5O4I69wIYMcR7gKTnRBfrVoRz+uM3h7rvmrzYuJ086/804/lYyMnwb6j8QuiavXAm0bOm6/Zw/Jp+0fM9XrbJf/scf3u3HdoRyby6oHIerePFF38o40LqP+xTcXH311fjtt98waNAgnDp1CqdOnUJOTg5+/vlnvPvuu2rnMWAFW0M5RwYDkJCgbx6OHFGnvdIjj9h3aweUHyxtD17t20v7cjbBo7/dd5+8MYhWrdLm5O/uwOk4W7XcOW0c9xkIV/Bq0fo2h5J2Y54IIf0OHNvr2GrY0LcTv95dk93Nq2eh9uST7tL85BPvvue2UzcIYd/+UM7teAslMyhZPiO1aiGV8HmcmyZNmuDJJ5/EihUrsGLFCvz3v//F33//jbffflvN/AW0rKzgHeMG8O8AUVqJj5ducT37bM3X1DxYTpokXa2dOVO9zHLi9qeVK4GLL5bfzVzvk7/jCdWXSR0D4QpeTZ6DDYG6dctx5ZXqNGozGoFhw/zXFvDwYem2jW2NWrNm1a+fPOnbZ6Nn12S57Sefe069wEZOmhMm+D7ExK5d1f97U/M5Z45v6dkKhLsaOs1pGxqMRvVuqZBvyspcnzzl/sBcDcTn6SBQUuLfnklyriQdaXny99fJU+8reGfpKWFpuOluP6dPR2L1ain6UdrOaOVKwN+tA8rK7J/b/oa2bPGtBlHPruVy208+8ID3vcqUpHnoELB7t/PXfPl9a3XxEwh3NXwa54aqedMegvzjnnuAevVq1hLI/YE99JDU08n2ikzOwHkTJkgNAT3x5faAkp54ao7DoVRhoRRkejNGhi9X8IHeY3HAAOkWsPOaUgMAgdxcI375RRqV27bTaVqaFBzJqTGQ870xGqXaAH+W2eHD0kl06VKplsfZd8Bslr6jlte6d/c85ktamu8Nec1m4MsvDfjqq1TUqWNAr17VefGmEfbGjdLn42zMIrmfkzdpnjrlfLkvwb0QUjlajl1qX5xZPqMrrxSwmZlJFwxuFFJraHryXUmJ1NPA8eDiaYAsixMnah6Ii4t9m8fJ8YCdleU6bctyZ9uo0RMvEKqGbdsByD34y/1NuQtenZWpnoOPbdzo6RawAUeOSHOyOXI28J7trYrCwur3J+d7o9XtPCGk22O26Vm+A4Dz4GDYMKnWyWCw/90obchbPYBiOICumD3b/vuYmCh/X88+C6xdW3O5twMkyr34atDA+XJff9/+vvjRYqwtObwKbnI8fGKnXIWYRBpwPLhYbgc4NjR2ZDmIOh6I5bA9wBw6JFXHOx6w3Y1T4WrUWk95lsPZwVPPk767g7/tiUzOoGXuuuK6KlNvrqrVpiTQdLza/vhj4L33ql/v1av6/ZWXy9vnhAnAq68CJlP1svR04JZbgAUL1GuL52yclMGDna975IgU2EycKN3qcfz85szx7fPzNFrzxInSe5bLWWADeF8rkpXlrjZP0rCh6zY3Sm/9+OPiZ/p06TOy/V7pxas2N/Xq1XP7aNasGUaMGOGvvAYkpSPiknosYzCMH199ULWM4yDnysyXK1rbA8ymTc5797i6v71xo+seQUoa9bkah8PbrtVmM7BzZwKKi+WnLWdMGE/tgeRMRnrLLc5PHlr0srLN+44dQEGB5++O0hOR5Wr7ySel93H2rP3rlvf3++/y9jdgAHDppdXPLY3jn30WXn3e3pLz/ViyxL4bdJ063nctt7SHef99YPRo143TLWO2qBXMWT6nl1/23BZn8mTP6ZaUAE884fw1pePs2H4n1RrSIqCaaYhaprS0VAAQpaWlquxvwwbLT4SPQHrMmGH/Ob3zjvpppKcLUVnp3TZCVP+fmOh+XaNRCIPBu/0bDNJjxQr7979ihfN9uVs/NbXKaRq33y6t89579u9LCCFSUuTlc8oU6bdTWSltd//9ysq+Rw/peVqa+7JJTxeivFxKe/Fi+zzYfja27ykmxv57lZBQc98JCTXL0JYlb95+no6Phg3dvz93rzuWXefONd+rs3LQ42F7XK1f33W5OrNihfvvgdaPtLSa340PP/RtX4778WUflt+B7fd+yhT71339nm7YIO2voqJCrFq1SlRUVHj34Xngzfnbydc6tKkd3Hg6oPKh38NyIFixwnMgoWT/3mzj7fqAdwea9HTpwGl78i4v9/wdTUqSgpUNG4RYtsySpvPg5qqrpPfhGNxUVkonIm/em+XAP3Cg9+ViewLs0UP+hUZSkvM8OH42lu+ON+XvLsDxdl/+eixbJuUnkIObxYur//cmuAmUMrZ9OF5AVFb6fjxyDEqU5sXCNrhxFRwajfLzxuBGB2oHN0JIXwbpA3Z+MuBDn0d6uu2JWv2HhbfbeLP+hAnyg+cXX5Ter+P63h5IPR3EDAYpHdvgxterZcvBtmNH77e1PQH26GH/3JdH9e+4+rm33520NPuTT2WlfaA5d67v+ZNTKyPnsX69lJdmzaqXOXK3fVycOvlw97ANVOvVk3ccDuQLTdvaEqW1/ZbaEU+fU4cONZelpzsPwG2DG0tZOm4bHu4+Pdv9BkJww3FuVJCTA9x0EyB16aRAcegQMGaM9NNTS4sW1f+bzVIDOm8sX+7d+s2a2bc/6N/f9bqnTwM331yzvcmJE96l6an9iBDS9/3776uXeTsej+2+hAB++837bR3bsSht1+I4ZpUvXfEPH67uQeesjdOsWb7nr2lT37e1ddNNUl5sR6J1nOnZleHD7Qey9IeEBO/bk5jNUjuXQJ3rT4jqHkpKG/LK3d6x1+HNN8tvu+SsPVtlpev1w8P1a6zvCruCq2DlSmDZMr1zQc64miPGV7YH9mbN5DV+tSUFwfI99BDwwgvVz92NiP3yy+oGcp7YzrSiNN0LF7zfxjZoO37c/UlZDsfGnb6eKI8elYJYZ5+1ksa6O3b4vq2tv/+uuWzwYGkKE8deSo7+7//UyYM7Dz7oXQ8+Z73jApWll6ISvm7ftGnNcrX0nrQdzdgXcqaH0VoAZim4yBnsjUKHbbDkbWDjK7npqB3IeWI70JweRo+u/v+335yPEaOHzz6TrpKd0TL49JazmZ4dOY5M7E6XLtIVvTfi46WJK+UGqr6M4m2Rni4FdFqyDL/g65x0DRtK5xxfenba9oIym4GZM6XanV697Cft9KVHYSB+rxncKKTGYGtE7tgeOALxIKKXQJwXzWAA/vc/fk4AcPAg0KqVd9uUlQG33WY/+KMrSkbxnjzZbO36vmKFvAmEGza0fx4Z6V2aSUnShcrGjdLM2750ubYMWOrL9BaW9FauBJKTgbw85xcovgyZ4Ov8V/7E4EahQBgFlmqPbdv0zkHt4cvVtbcnWjkn1WB1/LjzW2DeKitzfrJVcmFpW+4DBkijk3vyyivV/69f7/3gl8ePVwdu998P3HCDFPD4wjKukbdWrpRuQbq7MBBCmtLGG/6YgV4pBjcKBcIEYVR7bN2qdw5qj/Pn/Z+GnNGYg5kaAwIKIZ2QZ860HxhPyYXlxIlGNG8OPPqoVAuSne15G9t2lV9/rez7ceIE8Mknvt9K9qW2av9++U0ofLnlrGQSUX8wCFG7KlDLyspQr149lJaWIj4+XvH+zGbpx+Fp/iIiIlJHWhpw112B087KlZgYbYJkZzp0AHbu1Cft1FSB2277Hk88cRkiIiJU2683528GNyqwNGoDBIQIwPo5IiIijRgMAkIAS5eacfPN6nXK9ub8zdtSKrDMX8RbVEREVNtZLvIfftio2y0qBjcqyckBFi4MgBuNREQuDB3q/CJsxQrp4WsDV6KaDDh82GAd1FJrDG5U5M/ZdIlCUYMGeueg9jAYpFmyv/mm5mvl5dJAbrWrkQJpQa8exQxuVMTbUkTesR19mfzL0q7TWRfmW2+Vxj3xdqoO0s+IEXrnQB69zosMblR05ZUCCQnnYTDw8odIjh9+0DsHtUdFhTQi7dq1eueE1PDOO3rnwBOBtDTh9TxhamFwoyKjEbj77p2s2qWA4TiqaqBZvFjvHNQuJSXAfffpnQsKfdJJ8IUXzF4PdqiWgAhuXn31VTRv3hzR0dHIyMjAli1bZG23ZMkSGAwGDBw40L8Z9EK3bkcD/oRCtYcaI8T6k97zUxGRf3TrdhSDBul3pa97cLN06VLk5uYiLy8PP/zwAzp16oQ+ffrg2LFjbrfbv38/Jk6ciCy96rxc+OWXBJSUcKwbCgysRSQiPWzZkoLHHtMvxNA9uJk9ezbuuecejBo1Cu3atcP8+fMRGxuLBQsWuNzGbDZj+PDhmDFjBi666CINc+vZ339H650FIiIiHUkX+HPnhqGiQp8cqDd0oA8qKiqwbds2TJ482bosLCwM2dnZ2Lx5s8vtZs6ciUaNGuGuu+7CRg+d6MvLy1FeXm59XlZWBgAwmUwwmUwK34E9k8mEBg0uqLpPIiKi4GOA2Qy8/LIZDz6ozrTh3pyzdQ1uTpw4AbPZjOTkZLvlycnJ+PXXX51us2nTJrz99tvYsWOHrDRmzZqFGU4mIPn8888RGxvrdZ49adcOiIurwJkzkarvm4iIKJh88cUBtGqlziRX586dk72ursGNt06fPo3bb78db775JhITE2VtM3nyZOTm5lqfl5WVIT09Hdddd51qc0tZmEwm5OfnY8IE4L//VXXXRFSDgKX6m4gCU1JSM/Trl67Kvix3XuTQNbhJTEyE0WhEscPQvsXFxWjcuHGN9f/44w/s378f/fv3ty6rqpKqu8LDw7Fnzx60bNnSbpuoqChERUXV2FdERISqs5XaevxxA555BlD5rhcR2WFgQxTYBN55x4gbbzQiJ0f53rw5Z+vaoDgyMhJdunRBQUGBdVlVVRUKCgqQmZlZY/02bdpg586d2LFjh/Vx4403olevXtixYwfS09WJDtWgV99+IiKiwCBdgEyYAM0n0NT9tlRubi5GjhyJrl27olu3bpgzZw7Onj2LUaNGAQBGjBiB1NRUzJo1C9HR0Wjfvr3d9vXr1weAGsv1tGmTARfYrpiIiGo5IYBDh4CNG4GePbVLV/fgZujQoTh+/DimTZuGoqIidO7cGevWrbM2Mj548CDCwnTvse6VI0f0zgEREVHg0HoCTd2DGwAYN24cxo0b5/S1wsJCt9suWrRI/QwpdOIE2wIQERFZNGqkbXrBVSUSJBITOSwsERGRhdaD+TG48YPUVL1zQEREFDjefVfb9Bjc+EFmpkCQNRMiIiLym53qjOMnG0/BfrB5swFV6ow2TUREFPTq1dM2PQY3fqB1q3AiIqJANmCAtukxuPGDvXvZW4qIiMhi/Hht0wuIruChZPPmFDzzDGNGIiIiALj8ciBS47mkeRZWkdkMvPVWB72zQUREFDAOHdJ++gUGNyratMmAkydjwAn9iIiIJMePS9MvaInBjYrYkJiIiKgmrc+PDG5UlJKidw6IiIgCj9bnRwY3KrrySoGEhPMwGDj9AhERESCNcZOVpW2aDG5UZDQCd98tDcNoYLMbIiIijB8vnR+1xOBGZZmZR7FkibnG/FIJCfrkh4iISE9lZdqnyeDGDwYNEti/H9iwAVi8GFi/HoiJ0TtXRERE2luwgF3BQ4bRCPTsCQwbJv1/+LDeOSIiItJeWRlQWKhtmgxuNMAu4kREVJutX69tegxuNNCokd45ICIi0s/332ubHoMbIiIi8qsLF7RNj8GNBo4d0zsHRERE+mneXNv0GNxogCMXExFRbTZypLbpMbjRQFYWkJamdy6IiIj0ceKEtukxuNGA0QjMnq13LoiIiPRx993ajnXD4EYjSUl654CIiEgf585pO9YNgxuNHDmidw6IiIj0w+AmBB0/rncOiIiIagcGNxrhbSkiIqrNevbULi0GNxpxnCWciIiotoiMZHATktgdnIiIaqsbb5R6DmuFwY1GjEZg7ly9c0FERKS9b79lV/CQNWAA0LCh3rkgIiLS1uHDwMaN2qXH4EZDGzcCJSV654KIiEh7R49qlxaDGw1p+cESEREFEi3nWWRwoyFOoElERLVVRoZ2aTG40VBWFpCYqHcuiIiItPfaa9qlxeBGQ0YjcNtteueCiIhIe2xQHMIGDNA7B0RERNo7e1a7tBjcaCwrC0hI0DsXRERE2rr8cu3SYnCjAyH0zgEREZG2tGxzyuBGYxzrhoiIaqNTp7RLi8GNxjjWDRERkX8xuNEYx7ohIqLaSMv2pgxuNJaVBaSm6p0LIiIibSUna5cWgxuNGY3ASy/pnQsiIiJtaXlhz+BGBzk5wIcfAmEsfSIiqgWMRunOhVbCtUuKbN10E2AwSH+JiIhCmdZDoLDuQEdDhgBDh+qdCyIiIv+qquL0C7XGypXA0qV654KIiMj/tBwKhcGNTsxmYPx4vXNBRESkjUaNtEuLwY1ONm4EDh/WOxdEREShh8GNTjhSMRER1SZaXtAzuNEJRyomIqLaZOVK7dJicKOTrCwgLU3qDk5ERBTqjhzRLi0GNzoxGoG5c6X/HQMcy/O4OG3zRERE5C8NGmiXFoMbHeXkAMuX1xySOi1NGsE4KkqffBEREamtZ0/t0mJwo7OcHGD/fmDDBmDxYunvvn1AUhJw8qTeuSMiIlLHzz9rlxanXwgARmPNiJa9qYiIKJQcPKhdWqy5CVDsTUVERKGkaVPt0mJwE6CysoCEBL1zQUREpI7LLtMuLQY3Aerjj9nmhoiIQkeTJtqlxeAmAHHeKSIiCjWOPYP9icFNAOK8U0REFErCwqTmFpqlp11SJBd7ShERUSgJD5d6BmslIIKbV199Fc2bN0d0dDQyMjKwZcsWl+u++eabyMrKQoMGDdCgQQNkZ2e7XT8YsacUERGFkspKqcmFVnQPbpYuXYrc3Fzk5eXhhx9+QKdOndCnTx8cO3bM6fqFhYUYNmwYNmzYgM2bNyM9PR3XXXcdjmg5aYWfWeadIiIiCgVVVVKTC63oHtzMnj0b99xzD0aNGoV27dph/vz5iI2NxYIFC5yu//7772PMmDHo3Lkz2rRpg7feegtVVVUoKCjQOOf+YzvvFBERUSjQssmFriMUV1RUYNu2bZg8ebJ1WVhYGLKzs7F582ZZ+zh37hxMJhMaNmzo9PXy8nKUl5dbn5eVlQEATCYTTCaTgtzXZNmfGvvt3x/44AMDhg83oqqKU4cTEVFwS0qqhMkkfN7em3OrrsHNiRMnYDabkZycbLc8OTkZv/76q6x9TJo0CU2aNEF2drbT12fNmoUZM2bUWP75558jNjbW+0zLkJ+fr8p+YmKAhx9OwXPPXfHPEgY5REQUfIxGM8rKPsWaNb7v49y5c7LXDeq5pZ5++mksWbIEhYWFiI6OdrrO5MmTkZuba31eVlZmbacTHx+van5MJhPy8/Nx7bXXIiIiQpV99usHdO1qRm6uESHUrIiIiGqRmBgD+vfvp2gfljsvcuga3CQmJsJoNKK4uNhueXFxMRo3bux22+effx5PP/001q9fj44dO7pcLyoqClFRUTWWR0REqBaA+HvfN98MDB4MFBZK/5eUqLZrIiIivztzJgxChCEy0vd9eHNe1bVBcWRkJLp06WLXGNjSODgzM9Plds8++yyeeOIJrFu3Dl27dtUiq7ozGqUHAxsiIgpGr72mXVq635bKzc3FyJEj0bVrV3Tr1g1z5szB2bNnMWrUKADAiBEjkJqailmzZgEAnnnmGUybNg2LFy9G8+bNUVRUBACIi4tDXFycbu9DCxzcj4iIgtUff2iXlu7BzdChQ3H8+HFMmzYNRUVF6Ny5M9atW2dtZHzw4EGEhVVXMM2bNw8VFRUYMmSI3X7y8vIwffp0LbOuOQ7uR0REwaplS+3SMgghfO+XFYTKyspQr149lJaW+qVB8Zo1a9CvXz+/tOcxm4FGjXhrioiIgk95ORS1ufHm/K37IH4kn9HI2cKJiCj4hIXVwrmlSL7HHwdCvGkRERGFmFo3/QJ5x2gEHnlE71wQERF5R8tOMQxugtDjjwMuZpsgIiIKSFp2imFwE4SMRuDNN/XOBRERkXzdu2uXFoObIDVgAJCQoHcuiIiI5PnmG+3SYnATpDZuBE6e1DsXRERE8rDNDXnE0YqJiCiYsM0NecTRiomIKFjUrw9kZWmXHoObIJWVBaSlAQaD3jkhIiJyLyODg/iRDEYjMHeu9D8DHCIiCmStWmmbHoObIJaTAyxfDqSm6p0TIiIi1zIytE2PwU2Qy8kB9u8HNmwAJkzQOzdEREQ1padrmx6DmxBgNAI9ewIvvgisWMGaHCIiCixaDuAHMLgJOTk5wIEDUk3OlCl654aIiEjbAfwABjchyVKTM3261KOKiIhIT0eOaJseg5sQZjQCs2frnQsiIqrtjh/XNj0GNyEuKUnvHBARUW2n9VyIDG5CHKdpICIivR07pm16DG5CnNxpGl58ERg/HqhXz7/5ISKi2qekRNv0GNyEOE/TNBgM0vgDDzwAzJkjzTQ+Y4amWSQiohAXpnG0weAmxLmbpsHyfM4c+zk/3nxTk6wREVEt0bOntukxuKkFXE3TkJYmLc/JqV62cSNw+LC2+SMiotBVt672wU24tsmRXnJygAEDpODl6FGpLU5WVs1ZWtkAmYiI1BQZqX2aDG5qEcvgfu7IbYBMREQkx8mT0oW1lrU3vC1FdiwNkImIiNSi9V0BBjdkx9IA2VXvqkD173/rnQMiInKlUSNt02NwQzW4aoAciIxGYNky4OGH9c4JEREFCgY35JRldnFXY95Yanbi4rTLU00CEyYAQ4bwdhoRUSDjCMUUMIxGYNo0YMWKmoFDWpq0/NQpYP16YMoU6fHZZ+oGGQ0bun999mxg5Uopr8OGqZcuERGpR+vOKgYhhNA2SX2VlZWhXr16KC0tRXx8vKr7NplMWLNmDfr164eIiAhV9603s9lzN3KLZcuAm292v7+6dYHTpz2n+9lnwG23uZ5R1mCQgqm9e4GWLTlGD2mvXj3g5ZelHiEPPSQty86Wlq9YIWcPAkCQNXIj+kfr1sDvv7tfx2gEzp1T3iXcm/M3a25IFks38mHDpL+uAhtA3kzkp0+7X88yLYTR6DqwAQAhgEOHgNde839gs3gxsGGDFLwFQ3skvVluXc6YAUyYUPPz1no4dn8pLZW+qxMmVC8zmeQGNha16hrT77SegVqta9nYWHX2o6WhQz2vYzYD33zj/7zY4jg3pDq5Xf4yMoBPPnH9+pw58u/T/vGHvPWcSU8HXnhBOvkePVrdqj87234929tegwZJNVlHjkhX6+4CsFD3/PNSYPn++/blkJYmfYaWEbCff96+9q+4GLjlFl2yrDrH7/z333u3vcEgIARrb9QQHy/VomnJZFK2/ZQpQO/ewPbtQG6uOnkKNOwKTkFP7r1Vd4HNxInSSVHuvlq2lLeeoxdfBPbtA266qbpmqndv6eGOpSZr+HBg/nzf0vZFVJR6+xo3Tp39NGkilePRo8B//lO9fOFCaVRsC8fav6FDgUceUScPenP8np47583WBggRhpEjzc5fNUiPRx7RvkYiGJWV6Z0D77Vrp/4Ad0lJwHvvSbXNixapu2+L9HT5+dZ8gFhRy5SWlgoAorS0VPV9V1RUiFWrVomKigrV9x1MKiuFSEsTwmAQQrpxVPNhNLp+DRAiPV3aj6d9GQzSuuXl0nru9ulsu8pK1+/BcRt3PvzQ83tS45GZKcT69UJMmaJ8X+vXq5OnDRukMlixQoiGDe1fS0uTlruzbJkQSUk1t4uO9n95qvVYtkx6L0r28c47JrFiRc3vcXp6dRlWVlZ//t266f+++VDnsWGD9BnXry9vfYNBiIQE98dF29/dhg3+yfcjj0jfyYQE93l1d6z1hjfnbyhPLrgwuNHGihXSl9rxx+cu4HH2g3e/ryq7H/GKFd79MF2ddJ2dYNytb7FsmTYHwrQ0ISZM8H17y4HRm2DQ1cNy0LJ8Rs7ScjzQOlNZKX3eixdLfysrhRgyRP2yS0oSYulSdd67s3JQso/8fJPLsnDGXycsPrR7WE78y5bJPzba/qY8BcO2vy9PF5y+5v+RR9ytUyUAz79/uRjcuMHgRjuufnhyT8yLF7vfV1paVY0fjdx9T5jgOs9yr4acURJ0eHNA0WNbV+VhOXC6W8+XKze1apYsebD9/CwBxHvvCfHii9JfpbVhtsFGnTre5K1KJCaeFefPe3fc8NcJS+kjLU2IvDwhbrtN/7wE0sPZhZ7BINX6ehNsOwYvcoNhVxeJSh/ua6yrREKCOrU2QjC4cYvBjbac/fDkXnFaam4c9/XOOybxxBMbnZ4MfN23Zf9KT9JaXk0bje4DMWe1M2lp7quQnR2EnT1sbzcpKXNP3x1PeZX7SEryHJgq/ewWL67+v3dvb67Eq8SkSd/5dNxQo4ZUziM9XToJz5jh/NbjjBk1T65ygq/UVCmI1eKiQM/HI4+4rmGR+72bMsV98CL3++KYj4SEmr8zy2eqxu1vwPvfvisMbtxgcKM/ue1oXP2I3ZWzkn2rcZLW42ra1RWhpVbFNrj0pjbEYKhyunzGDPvysz2pu3vY1sTJ5e2tRleP997znJbSz872+3PPPVLePQVnCQlCLF1qUnTccFVDaqkRUPpdvP9+qU2bbTnJqSmw5M1V8OVYE+rqdrA33/1AfMyY4b7c5P5+XNU2e8tZPpTmzdPDl9++Mwxu3GBwExi8Oeg58lTOvu5brYOMr9W/vrSFmTBB3j13X95jamqVrP36q+bGtjwTE5UdXOWm7ctnZ9uo3bLs3/+W18g9LU2I8+eVHzdcnZzUuhUhp2G4uzKV+x21vV3Yq5f7PA0YoE2tldJy81TTIvf3k5Sk3u0dudSqiWbNjQYY3AQObw56tuSUsy/79uaH7CmPrtJ/5BHPgVdlpdQORO5Bw5sraW8CkfPnK8QTT2wU77xjcrtfpTVxcpSX1+xRJefhS9ququ6dnTgtn5uz2w5yA7L8fGU1N768H2/LUm7DcFe8+Y7a5jsurmZewsKk8nb13tLTpdoSOe+rXj11Tt5KyquyUv53Ra0gQS65PV9d//arVOspJQSDG7cY3AQWXw56csvZ2317anPj7QnT3dW0p8DLXwGDN/v15vuspCZOLm9rIZSk7eyz8xSw+noifOcd/wY3zt7Pe+/5dsJW80TljruG/YDnBrWev+fSSXfJEnWCGcfgRM5Fmi1fOlloxdNv29UFG1AlDIaanT6UYHDjBoOb4OfPcvamjYeSqyg5gZe/Aga5+/W2nH2tifM2764CDH+nLUTNz83b8ZWcPfxdc+OMktsN/q49UKv3netg2P6k674rs+eHZawXby/SbPn71q5Snn7bzl5PTDwrli41qZoPBjduMLgJfv4u50C6ivJXwCBnv76Us9KDvJI0tEjbkZIgwXKSVqPNjbeUNJ729/dezRO93JPusmXet+syGqtvjymlxa1dNfLo7vdl+3p+vkmsWKH+d9qb8zfnliJyMGCANCeSJ1oMJ56TI+VH7ozseu/XMsWCP7lKQ4u0Hfk6X45lUtE5c5SXuS+MRmDuXGDIECkvQsjf1t/fe7llKmc9x+95UlIlysry0b9/P7v1hgyR5ot78kkgL6/mfixldMcdQFycNN3LmDHKZ7m2cPd56P1dsfD0+7J93WQSWLNGi1y5xuCGyEFWljTp45Ejzg/6BoP0elaWNvnx10lbj2Ag1Mg90ScluZ5UVOmki77KyQGWLwfGj5cmPvVEq++93DKVu57ck67RCEybBrRvX7NMHCeB9QdXn4cWaYciBjdEDoLhKooCg9xAeO9e4Jtv1K0lU4NjzcbvvwPTp0uv6fW91/viwl+1moGedqhhcEPkBK+iSA65gXBkZODWkjnW4OlVc2GbH70vLvSs1WSNqjrC9M4AUaDKyQH27wc2bAAWL5b+7tvHwIbsWQLh1FT75Wlp0vJg+74Ewvc+1MqUtMeaGyI3eBVFcoTa7YRA+N6HWpmSthjcEBGpIBACglDDMiVf8bYUERERhRQGN0RERBRSGNwQERFRSGFwQ0RERCGFwQ0RERGFFAY3REREFFIY3BAREVFIYXBDREREIYXBDREREYUUBjdEREQUUhjcEBERUUgJiODm1VdfRfPmzREdHY2MjAxs2bLF7frLli1DmzZtEB0djQ4dOmDNmjUa5ZSIiIgCne7BzdKlS5Gbm4u8vDz88MMP6NSpE/r06YNjx445Xf+bb77BsGHDcNddd2H79u0YOHAgBg4ciF27dmmccyIiIgpEugc3s2fPxj333INRo0ahXbt2mD9/PmJjY7FgwQKn68+dOxd9+/bFI488grZt2+KJJ57A5ZdfjldeeUXjnBMREVEg0jW4qaiowLZt25CdnW1dFhYWhuzsbGzevNnpNps3b7ZbHwD69Onjcn0iIiKqXcL1TPzEiRMwm81ITk62W56cnIxff/3V6TZFRUVO1y8qKnK6fnl5OcrLy63PS0tLAQAlJSUwmUxKsl+DyWTCuXPncPLkSURERKi6b6rGctYGy1kbLGftsKy14a9yPn36NABACOFxXV2DGy3MmjULM2bMqLG8RYsWOuSGiIiIlDh9+jTq1avndh1dg5vExEQYjUYUFxfbLS8uLkbjxo2dbtO4cWOv1p88eTJyc3Otz6uqqlBSUoKEhAQYDAaF78BeWVkZ0tPTcejQIcTHx6u6b6rGctYGy1kbLGftsKy14a9yFkLg9OnTaNKkicd1dQ1uIiMj0aVLFxQUFGDgwIEApOCjoKAA48aNc7pNZmYmCgoKMGHCBOuy/Px8ZGZmOl0/KioKUVFRdsvq16+vRvZdio+P5w9HAyxnbbCctcFy1g7LWhv+KGdPNTYWut+Wys3NxciRI9G1a1d069YNc+bMwdmzZzFq1CgAwIgRI5CamopZs2YBAMaPH4+rr74aL7zwAm644QYsWbIEW7duxRtvvKHn2yAiIqIAoXtwM3ToUBw/fhzTpk1DUVEROnfujHXr1lkbDR88eBBhYdWdurp3747FixdjypQp+M9//oPWrVtj1apVaN++vV5vgYiIiAKI7sENAIwbN87lbajCwsIay2666SbcdNNNfs6V96KiopCXl1fjNhipi+WsDZazNljO2mFZayMQytkg5PSpIiIiIgoSuo9QTERERKQmBjdEREQUUhjcEBERUUhhcENEREQhhcGNSl599VU0b94c0dHRyMjIwJYtW/TOUkD56quv0L9/fzRp0gQGgwGrVq2ye10IgWnTpiElJQUxMTHIzs7G77//brdOSUkJhg8fjvj4eNSvXx933XUXzpw5Y7fOTz/9hKysLERHRyM9PR3PPvtsjbwsW7YMbdq0QXR0NDp06IA1a9ao/n71MGvWLFxxxRWoW7cuGjVqhIEDB2LPnj1261y4cAFjx45FQkIC4uLiMHjw4Bojfh88eBA33HADYmNj0ahRIzzyyCOorKy0W6ewsBCXX345oqKi0KpVKyxatKhGfkL5NzFv3jx07NjROkhZZmYm1q5da32d5ay+p59+GgaDwW4AV5azOqZPnw6DwWD3aNOmjfX1oCxnQYotWbJEREZGigULFoiff/5Z3HPPPaJ+/fqiuLhY76wFjDVr1ojHH39crFy5UgAQH330kd3rTz/9tKhXr55YtWqV+PHHH8WNN94oWrRoIc6fP29dp2/fvqJTp07i22+/FRs3bhStWrUSw4YNs75eWloqkpOTxfDhw8WuXbvEBx98IGJiYsTrr79uXefrr78WRqNRPPvss+KXX34RU6ZMEREREWLnzp1+LwN/69Onj1i4cKHYtWuX2LFjh+jXr59o2rSpOHPmjHWd0aNHi/T0dFFQUCC2bt0q/vWvf4nu3btbX6+srBTt27cX2dnZYvv27WLNmjUiMTFRTJ482brOn3/+KWJjY0Vubq745ZdfxMsvvyyMRqNYt26ddZ1Q/02sXr1afPrpp+K3334Te/bsEf/5z39ERESE2LVrlxCC5ay2LVu2iObNm4uOHTuK8ePHW5eznNWRl5cnLr30UnH06FHr4/jx49bXg7GcGdyooFu3bmLs2LHW52azWTRp0kTMmjVLx1wFLsfgpqqqSjRu3Fg899xz1mWnTp0SUVFR4oMPPhBCCPHLL78IAOL777+3rrN27VphMBjEkSNHhBBCvPbaa6JBgwaivLzcus6kSZPEJZdcYn1+8803ixtuuMEuPxkZGeK+++5T9T0GgmPHjgkA4ssvvxRCSGUaEREhli1bZl1n9+7dAoDYvHmzEEIKQsPCwkRRUZF1nXnz5on4+HhruT766KPi0ksvtUtr6NChok+fPtbntfE30aBBA/HWW2+xnFV2+vRp0bp1a5Gfny+uvvpqa3DDclZPXl6e6NSpk9PXgrWceVtKoYqKCmzbtg3Z2dnWZWFhYcjOzsbmzZt1zFnw2LdvH4qKiuzKsF69esjIyLCW4ebNm1G/fn107drVuk52djbCwsLw3XffWde56qqrEBkZaV2nT58+2LNnD/7++2/rOrbpWNYJxc+qtLQUANCwYUMAwLZt22Aymezef5s2bdC0aVO7cu7QoYN1hHBAKp+ysjL8/PPP1nXclWFt+02YzWYsWbIEZ8+eRWZmJstZZWPHjsUNN9xQoyxYzur6/fff0aRJE1x00UUYPnw4Dh48CCB4y5nBjUInTpyA2Wy2+1ABIDk5GUVFRTrlKrhYysldGRYVFaFRo0Z2r4eHh6Nhw4Z26zjbh20artYJtc+qqqoKEyZMQI8ePaxTkxQVFSEyMrLGxLGO5exrGZaVleH8+fO15jexc+dOxMXFISoqCqNHj8ZHH32Edu3asZxVtGTJEvzwww/WuQVtsZzVk5GRgUWLFmHdunWYN28e9u3bh6ysLJw+fTpoyzkgpl8gInWNHTsWu3btwqZNm/TOSsi65JJLsGPHDpSWlmL58uUYOXIkvvzyS72zFTIOHTqE8ePHIz8/H9HR0XpnJ6Rdf/311v87duyIjIwMNGvWDB9++CFiYmJ0zJnvWHOjUGJiIoxGY42W48XFxWjcuLFOuQoulnJyV4aNGzfGsWPH7F6vrKxESUmJ3TrO9mGbhqt1QumzGjduHD755BNs2LABaWlp1uWNGzdGRUUFTp06Zbe+Yzn7Wobx8fGIiYmpNb+JyMhItGrVCl26dMGsWbPQqVMnzJ07l+Wskm3btuHYsWO4/PLLER4ejvDwcHz55Zd46aWXEB4ejuTkZJazn9SvXx8XX3wx9u7dG7TfZwY3CkVGRqJLly4oKCiwLquqqkJBQQEyMzN1zFnwaNGiBRo3bmxXhmVlZfjuu++sZZiZmYlTp05h27Zt1nW++OILVFVVISMjw7rOV199BZPJZF0nPz8fl1xyCRo0aGBdxzYdyzqh8FkJITBu3Dh89NFH+OKLL9CiRQu717t06YKIiAi7979nzx4cPHjQrpx37txpF0jm5+cjPj4e7dq1s67jrgxr62+iqqoK5eXlLGeV9O7dGzt37sSOHTusj65du2L48OHW/1nO/nHmzBn88ccfSElJCd7vs9dNkKmGJUuWiKioKLFo0SLxyy+/iHvvvVfUr1/fruV4bXf69Gmxfft2sX37dgFAzJ49W2zfvl0cOHBACCF1Ba9fv774+OOPxU8//SQGDBjgtCv4ZZddJr777juxadMm0bp1a7uu4KdOnRLJycni9ttvF7t27RJLliwRsbGxNbqCh4eHi+eff17s3r1b5OXlhUxX8Pvvv1/Uq1dPFBYW2nXpPHfunHWd0aNHi6ZNm4ovvvhCbN26VWRmZorMzEzr65Yundddd53YsWOHWLdunUhKSnLapfORRx4Ru3fvFq+++qrTLp2h/Jt47LHHxJdffin27dsnfvrpJ/HYY48Jg8EgPv/8cyEEy9lfbHtLCcFyVsvDDz8sCgsLxb59+8TXX38tsrOzRWJiojh27JgQIjjLmcGNSl5++WXRtGlTERkZKbp16ya+/fZbvbMUUDZs2CAA1HiMHDlSCCF1B586dapITk4WUVFRonfv3mLPnj12+zh58qQYNmyYiIuLE/Hx8WLUqFHi9OnTduv8+OOP4sorrxRRUVEiNTVVPP300zXy8uGHH4qLL75YREZGiksvvVR8+umnfnvfWnJWvgDEwoULreucP39ejBkzRjRo0EDExsaKQYMGiaNHj9rtZ//+/eL6668XMTExIjExUTz88MPCZDLZrbNhwwbRuXNnERkZKS666CK7NCxC+Tdx5513imbNmonIyEiRlJQkevfubQ1shGA5+4tjcMNyVsfQoUNFSkqKiIyMFKmpqWLo0KFi79691teDsZwNQgjhfX0PERERUWBimxsiIiIKKQxuiIiIKKQwuCEiIqKQwuCGiIiIQgqDGyIiIgopDG6IiIgopDC4ISIiopDC4IaIaj2DwYBVq1bpnQ0iUgmDGyLS1R133AGDwVDj0bdvX72zRkRBKlzvDBAR9e3bFwsXLrRbFhUVpVNuiCjYseaGiHQXFRWFxo0b2z0sM7kbDAbMmzcP119/PWJiYnDRRRdh+fLldtvv3LkT11xzDWJiYpCQkIB7770XZ86csVtnwYIFuPTSSxEVFYWUlBSMGzfO7vUTJ05g0KBBiI2NRevWrbF69Wr/vmki8hsGN0QU8KZOnYrBgwfjxx9/xPDhw3HLLbdg9+7dAICzZ8+iT58+aNCgAb7//nssW7YM69evtwte5s2bh7Fjx+Lee+/Fzp07sXr1arRq1coujRkzZuDmm2/GTz/9hH79+mH48OEoKSnR9H0SkUp8mm6TiEglI0eOFEajUdSpU8fu8eSTTwohpNnOR48ebbdNRkaGuP/++4UQQrzxxhuiQYMG4syZM9bXP/30UxEWFiaKioqEEEI0adJEPP744y7zAEBMmTLF+vzMmTMCgFi7dq1q75OItMM2N0Sku169emHevHl2yxo2bGj9PzMz0+61zMxM7NixAwCwe/dudOrUCXXq1LG+3qNHD1RVVWHPnj0wGAz466+/0Lt3b7d56Nixo/X/OnXqID4+HseOHfP1LRGRjhjcEJHu6tSpU+M2kVpiYmJkrRcREWH33GAwoKqqyh9ZIiI/Y5sbIgp43377bY3nbdu2BQC0bdsWP/74I86ePWt9/euvv0ZYWBguueQS1K1bF82bN0dBQYGmeSYi/bDmhoh0V15ejqKiIrtl4eHhSExMBAAsW7YMXbt2xZVXXon3338fW7Zswdtvvw0AGD58OPLy8jBy5EhMnz4dx48fxwMPPIDbb78dycnJAIDp06dj9OjRaNSoEa6//nqcPn0aX3/9NR544AFt3ygRaYLBDRHpbt26dUhJSbFbdskll+DXX38FIPVkWrJkCcaMGYOUlBR88MEHaNeuHQAgNjYWn332GcaPH48rrrgCsbGxGDx4MGbPnm3d18iRI3HhwgW8+OKLmDhxIhITEzFkyBDt3iARacoghBB6Z4KIyBWDwYCPPvoIAwcO1DsrRBQk2OaGiIiIQgqDGyIiIgopbHNDRAGNd86JyFusuSEiIqKQwuCGiIiIQgqDGyIiIgopDG6IiIgopDC4ISIiopDC4IaIiIhCCoMbIiIiCikMboiIiCikMLghIiKikPL/L6lgY5EB+a4AAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses, label='Training Loss', linestyle='-', color='blue', marker='o')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.ylim([0,1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize the MASK Prior" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_samples = 1000\n", + "xt = mdlm.sample_prior((num_samples, D))\n", + "counts = xt.flatten().cpu()\n", + "\n", + "# Compute frequency of each class index\n", + "class_counts = torch.bincount(counts)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(range(len(class_counts)), class_counts.numpy(), color='red')\n", + "plt.xlabel('Class Index')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Discrete Distribution of Class Indices')\n", + "plt.xticks(range(len(class_counts))) # Set x-ticks to class indices\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sample from the MDLM trained model" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "ts = schedule.generate_schedule()\n", + "dts = schedule.discretize()\n", + "num_samples = 1000\n", + "xt = mdlm.sample_prior((num_samples, D))\n", + "for dt, t in zip(dts, ts):\n", + " t = torch.full((xt.shape[0],), t).to(DEVICE)\n", + " logits = model(xt, t)\n", + " xt = mdlm.step(logits, t, xt, dt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize the class breakdown (green) and generated samples (blue)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "counts = xt.flatten().cpu()\n", + "\n", + "# Compute frequency of each class index\n", + "class_counts = torch.bincount(counts)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(range(len(class_counts)), class_counts.numpy(), color='green')\n", + "plt.xlabel('Class Index')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Discrete Distribution of Class Indices')\n", + "plt.xticks(range(len(class_counts))) # Set x-ticks to class indices\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "counts = xt.cpu().sum(dim=1).float()\n", + "plt.hist(counts.numpy(), bins=range(D+2))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## here we can take binary data and rather than using a uniform prior introduce a MASK state. Here MDLM trained on the same data is able to generate the desired discrete data shown ion blue although starting from pure MASK states seen in red." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# These 3 cases show how on the same data one can switch between various diffusion and flow matching options that each come with various inference time sampling abilities. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "moco_bionemo", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/sub-packages/bionemo-moco/examples/ot_sampler_tutorial.ipynb b/sub-packages/bionemo-moco/examples/ot_sampler_tutorial.ipynb new file mode 100644 index 0000000000..d1869e45f9 --- /dev/null +++ b/sub-packages/bionemo-moco/examples/ot_sampler_tutorial.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimal Transport Samplers Tutorial" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import os\n", + "import time\n", + "import copy\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from bionemo.moco.interpolants import EquivariantOTSampler, OTSampler\n", + "\n", + "from sklearn.datasets import make_moons" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task Setup\n", + "### Demonstrating the effectiveness of OT sampler and Kabsch-based Equivariant OT sampler\n", + "\n", + "#### 1. We will start with the OT sampler. The OT sampler is an implementation of the \"OT-CFM\" algorithm proposed by [Tong et. al](https://arxiv.org/pdf/2307.03672). For a batch of randomly sampled noise ($\\mathrm{x}_0$) and data ($\\mathrm{x}_1$), the OT sampler will sample $(x_0, x_1)$ pairs based on their Euclidean distances. We will demonstrate how to use the OT sampler with a simple 2D example." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 1.1 Sample 100 points from a standard Gaussian distribution ($\\mathrm{x}_0 \\sim \\pi_0$, orange colored), and another 100 points from a double moon-shape distribution ($\\mathrm{x}_1 \\sim \\pi_1$, blue colored). The linear interpolation between pairs ($x_0^i, x_1^i$) are plotted using grey lines. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def sample_moons(n, normalize = False):\n", + " x1, _ = make_moons(n_samples=n, noise=0.08)\n", + " x1 = torch.Tensor(x1)\n", + " x1 = x1 * 3 - 1\n", + " if normalize:\n", + " x1 = (x1 - x1.mean(0))/x1.std(0) * 2\n", + " return x1\n", + "\n", + "def sample_gaussian(n, dim = 2):\n", + " return torch.randn(n, dim)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x78315adebca0>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sample x0 and x1\n", + "x1 = sample_moons(100, normalize=True).numpy()\n", + "x0 = sample_gaussian(100).numpy()\n", + "# Plot data points and linear interpolation\n", + "plt.scatter(x1[:, 0], x1[:, 1], label='$x_0$')\n", + "plt.scatter(x0[:, 0], x0[:, 1], label='$x_1$')\n", + "x0 = np.asarray(x0)\n", + "x1 = np.asarray(x1)\n", + "for i in range(len(x1)):\n", + " plt.plot([x0[i, 0], x1[i, 0]], [x0[i, 1], x1[i, 1]], color='k', alpha=0.2)\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 1.2 Initialize the OT sampler and sample new $(x_0, x_1)$ pairs to minimize the transport cost of the entire batch. The linear interpolation between new pairs ($x_0^i, x_1^i$) are plotted using grey lines. We can see that there are less crossover of interpolation trajectories and the transport cost has been reduced." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the OTSampler\n", + "ot_sampler = OTSampler(method=\"exact\", num_threads=1)\n", + "# Sample new pairs from the OTSampler, mask is not used in this example\n", + "# Replace is set to False, so no duplicates are allowed\n", + "# Sort is set to \"x0\", so the order of output x0 is the same as input x0\n", + "ot_sampled_x0, ot_sampled_x1, mask = ot_sampler.apply_ot(\n", + " torch.Tensor(x0), \n", + " torch.Tensor(x1), \n", + " mask=None, replace=False, sort=\"x0\")\n", + "# Convert the sampled tensors to numpy arrays\n", + "ot_sampled_x0 = ot_sampled_x0.numpy()\n", + "ot_sampled_x1 = ot_sampled_x1.numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x783152f9f4f0>" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot data points and linear interpolation\n", + "plt.scatter(ot_sampled_x1[:, 0], ot_sampled_x1[:, 1], label='$x_0$')\n", + "plt.scatter(ot_sampled_x0[:, 0], ot_sampled_x0[:, 1], label='$x_1$')\n", + "for i in range(len(x1)):\n", + " plt.plot(\n", + " [ot_sampled_x0[i, 0], ot_sampled_x1[i, 0]], \n", + " [ot_sampled_x0[i, 1], ot_sampled_x1[i, 1]], \n", + " color='k', alpha=0.2\n", + " )\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 1.3 Let's see how the OT can help in conditional flow matching training. We will train two models, one with OT and the other one without, and compare the flow trajectory during sampling.\n", + "\n", + "Note the ContinuousFlowMatcher object can be initialized with any batch augmentation using the 'ot_type' parameter. For clarity we pull in our previosuly initialized OT Sampler." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from bionemo.moco.interpolants import ContinuousFlowMatcher\n", + "from bionemo.moco.distributions.time import UniformTimeDistribution\n", + "from bionemo.moco.distributions.prior import GaussianPrior\n", + "\n", + "def trainCFM(use_ot=False):\n", + " # Initialize model, optimizer, and flow matcher\n", + " dim = 2\n", + " hidden_size = 64\n", + " batch_size = 256\n", + " model = torch.nn.Sequential(\n", + " torch.nn.Linear(dim + 1, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, hidden_size),\n", + " torch.nn.SELU(),\n", + " torch.nn.Linear(hidden_size, dim),\n", + " )\n", + " optimizer = torch.optim.Adam(model.parameters())\n", + "\n", + " uniform_time = UniformTimeDistribution()\n", + " moon_prior = GaussianPrior()\n", + " sigma = 0.1\n", + " cfm = ContinuousFlowMatcher(time_distribution=uniform_time, \n", + " prior_distribution=moon_prior, \n", + " sigma=sigma, \n", + " prediction_type=\"velocity\")\n", + "\n", + " # Place both the model and the interpolant on the same device\n", + " DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " model = model.to(DEVICE)\n", + " cfm = cfm.to_device(DEVICE)\n", + "\n", + " for k in range(10000):\n", + " optimizer.zero_grad()\n", + " shape = (batch_size, dim)\n", + " x0 = cfm.sample_prior(shape).to(DEVICE)\n", + " x1 = sample_moons(batch_size, normalize=False).to(DEVICE)\n", + " if use_ot:\n", + " x0, x1, mask = ot_sampler.apply_ot(\n", + " x0, x1, \n", + " mask=None, replace=False, sort=\"x0\"\n", + " )\n", + " t = cfm.sample_time(batch_size)\n", + " xt = cfm.interpolate(x1, t, x0)\n", + " ut = cfm.calculate_target(x1, x0)\n", + "\n", + " vt = model(torch.cat([xt, t[:, None]], dim=-1))\n", + " loss = cfm.loss(vt, ut, target_type=\"velocity\").mean()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (k + 1) % 5000 == 0:\n", + " print(f\"{k+1}: loss {loss.item():0.3f}\") \n", + " return model, cfm" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000: loss 0.053\n", + "10000: loss 0.058\n", + "5000: loss 2.955\n", + "10000: loss 3.211\n" + ] + } + ], + "source": [ + "# Train a model with OT\n", + "ot_model, ot_cfm = trainCFM(use_ot=True)\n", + "# Train a model without OT\n", + "no_ot_model, no_ot_cfm = trainCFM(use_ot=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up the sampling time schedule\n", + "from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule\n", + "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "inference_sched = LinearInferenceSchedule(nsteps = 100)\n", + "schedule = inference_sched.generate_schedule().to(DEVICE)\n", + "dts = inference_sched.discretize().to(DEVICE)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Sampling with the two trained models\n", + "inf_size = 1024\n", + "ot_sample = ot_cfm.sample_prior((inf_size, 2)) # Start with noise\n", + "no_ot_sample = copy.deepcopy(ot_sample) # Ensure the same starting point for both models\n", + "ot_sample, no_ot_sample = ot_sample.to(DEVICE), no_ot_sample.to(DEVICE)\n", + "ot_trajectory, no_ot_trajectory = [ot_sample], [no_ot_sample]\n", + "for dt, t in zip(dts, schedule):\n", + " full_t = torch.full((inf_size,), t).to(DEVICE)\n", + " ot_vt = ot_model(torch.cat([ot_sample, full_t[:, None]], dim=-1)) # calculate the vector field based on the definition of the model\n", + " ot_sample = ot_cfm.step(ot_vt, ot_sample, dt, full_t)\n", + " no_ot_vt = no_ot_model(torch.cat([no_ot_sample, full_t[:, None]], dim=-1)) # calculate the vector field based on the definition of the model\n", + " no_ot_sample = no_ot_cfm.step(no_ot_vt, no_ot_sample, dt, full_t)\n", + " ot_trajectory.append(ot_sample) # save the trajectory for plotting purposes\n", + " no_ot_trajectory.append(no_ot_sample) # save the trajectory for plotting purposes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 1.4 Visualization of flow trajectories predicted by the two models. With OT (left), the flow trajectory is straighter, thus less transport cost comapred to without OT (right)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1200x600 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ot_traj = torch.stack(ot_trajectory).cpu().detach().numpy()\n", + "no_ot_traj = torch.stack(no_ot_trajectory).cpu().detach().numpy()\n", + "n = 2000\n", + "\n", + "# Assuming traj is your tensor and traj.shape = (N, 2000, 2)\n", + "# where N is the number of time points, 2000 is the number of samples at each time point, and 2 is for the x and y coordinates.\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Plot the first time point in black\n", + "ax[0].scatter(ot_traj[0, :n, 0], ot_traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior z(S)')\n", + "ax[1].scatter(no_ot_traj[0, :n, 0], no_ot_traj[0, :n, 1], s=10, alpha=0.8, c=\"black\", label='Prior z(S)')\n", + "\n", + "# Plot all the rest of the time points except the first and last in olive\n", + "for i in range(1, ot_traj.shape[0]-1):\n", + " ax[0].scatter(ot_traj[i, :n, 0], ot_traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\", zorder=1)\n", + " ax[1].scatter(no_ot_traj[i, :n, 0], no_ot_traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\", zorder=1)\n", + "\n", + "# Plot the last time point in blue\n", + "ax[0].scatter(ot_traj[-1, :n, 0], ot_traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "ax[1].scatter(no_ot_traj[-1, :n, 0], no_ot_traj[-1, :n, 1], s=4, alpha=1, c=\"blue\", label='z(0)')\n", + "\n", + "# Add a second legend for \"Flow\" since we can't label in the loop directly\n", + "for i in range(2):\n", + " ax[i].scatter([], [], s=2, alpha=1, c=\"olive\", label='Flow')\n", + " ax[i].legend()\n", + " # ax[i].set_aspect('equal')\n", + " ax[i].set_xticks([])\n", + " ax[i].set_yticks([])\n", + " ax[i].set_xlim(-5, 6)\n", + " ax[i].set_ylim(-4, 5)\n", + " if i == 0:\n", + " ax[i].set_title(\"With OT\")\n", + " else:\n", + " ax[i].set_title(\"Without OT\")\n", + "plt.subplots_adjust(wspace=0.05)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average Distance between First and Last Points without OT: 4.119970321655273\n", + "Average Distance between First and Last Points with OT: 3.9200291633605957\n" + ] + } + ], + "source": [ + "\n", + "first_points = no_ot_traj[0]\n", + "last_points = no_ot_traj[-1]\n", + "distances = ((last_points - first_points)**2).sum(-1)\n", + "average_distance = np.mean(distances)\n", + "\n", + "print(f\"Average Distance between First and Last Points without OT: {average_distance.item()}\")\n", + "\n", + "first_points = ot_traj[0]\n", + "last_points = ot_traj[-1]\n", + "distances = ((last_points - first_points)**2).sum(-1)\n", + "average_distance = np.mean(distances)\n", + "\n", + "print(f\"Average Distance between First and Last Points with OT: {average_distance.item()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sum of Squared Distances (start to mid + mid to end):\n", + "Without OT: 2667.9356\n", + "With OT: 2009.3874\n" + ] + } + ], + "source": [ + "def sum_of_squared_distances(trajectory):\n", + " \"\"\"\n", + " Calculate the sum of squared distances from start to mid and mid to end of a trajectory.\n", + " \n", + " Parameters:\n", + " - trajectory: A numpy array of shape (N, D) where N is the number of points \n", + " in the trajectory and D is the dimensionality of the space.\n", + " \n", + " Returns:\n", + " - Sum of squared distances (start to mid + mid to end).\n", + " \"\"\"\n", + " mid_idx = len(trajectory) // 2\n", + " start_point = trajectory[0]\n", + " mid_point = trajectory[mid_idx]\n", + " end_point = trajectory[-1]\n", + " \n", + " start_to_mid_distance = np.linalg.norm(start_point - mid_point)\n", + " mid_to_end_distance = np.linalg.norm(mid_point - end_point)\n", + " \n", + " return start_to_mid_distance**2 + mid_to_end_distance**2\n", + "\n", + "# Calculate and print sum of squared distances for both trajectories\n", + "no_ot_sum_squared_distance = sum_of_squared_distances(no_ot_traj)\n", + "ot_sum_squared_distance = sum_of_squared_distances(ot_traj)\n", + "\n", + "print(\"Sum of Squared Distances (start to mid + mid to end):\")\n", + "print(f\"Without OT: {no_ot_sum_squared_distance:.4f}\")\n", + "print(f\"With OT: {ot_sum_squared_distance:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2. We will then introduce the Kabsch OT sampler. The Kabsch OT sampler is an implementation of the \"Equivariant OT\" algorithm ([Klein et al.](https://arxiv.org/abs/2306.15030)). For a batch of randomly sampled noise ($\\mathrm{x}_0$) and data ($\\mathrm{x}_1$), the Kabsch OT sampler will sample $(x_0, x_1)$ pairs based on the RMSD after aligning *zero-centered* $(x_0, x_1)$ using *Kabsch algorithm*. We will demonstrate how to use the Kabsch OT sampler with a simple 2D example." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Define helper functions\n", + "def rotation_matrix(angle):\n", + " theta = (angle/180.) * np.pi\n", + " c, s = np.cos(theta), np.sin(theta)\n", + " return np.array([[c, -s], [s, c]])\n", + "\n", + "def rotate(x, angle):\n", + " R = rotation_matrix(angle)\n", + " return x @ R.T\n", + "\n", + "def plot_quadrilateral(x, axis, color='C0', marker='o', label=None):\n", + " assert x.shape == (4, 2)\n", + " axis.scatter(\n", + " x[:, 0], x[:, 1], \n", + " c=color, marker=marker, linewidths=1, \n", + " edgecolors='k', zorder=2, label=label\n", + " )\n", + " for i in range(len(x)):\n", + " if i < 3:\n", + " axis.plot([x[i, 0], x[i+1, 0]], [x[i, 1], x[i+1, 1]], c=color, zorder=1)\n", + " else:\n", + " axis.plot([x[i, 0], x[0, 0]], [x[i, 1], x[0, 1]], c=color, zorder=1)\n", + " return axis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 2.1 Initialize $\\mathrm{k}_0$ which contains two samples. $k_0^0$ is a rhombus and $k_0^1$ is a square. Then initialize $\\mathrm{k}_1$ which is rotated $\\mathrm{k}_0$. Shuffle the order of $\\mathrm{k}_1$ so $k_1^0$ is rotated square and $k_1^1$ is rotated rhombus. When plotting, the $k_0^0$ and $k_1^0$ are shown with circle-shaped dots while $k_0^1$ and $k_1^1$ are shown with square-shaped dots." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize \n", + "k0 = np.array([\n", + " [[-2, 0], [0, 1], [2, 0], [0, -1]], # Rhombus\n", + " [[-1, 2], [-1, 4], [1, 4], [1, 2]], # Square\n", + "])\n", + "angles = [60, 25]\n", + "\n", + "# Rotate and shuffle samples in k0 to create k1\n", + "k1 = np.array([rotate(k0[i], angles[i]) for i in [1, 0]])\n", + "markers = ['o', 's']\n", + "\n", + "# Translate k0 and k1\n", + "k0 = np.array(k0)-2\n", + "k1 = np.array(k1)+2" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 500x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot k0 and k1\n", + "fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n", + "for i in range(len(k0)):\n", + " plot_quadrilateral(k0[i], ax, color='C1', marker=markers[i], label='$k_0^%d$'%i)\n", + " plot_quadrilateral(k1[i], ax, color='C0', marker=markers[i], label='$k_1^%d$'%i)\n", + " # Calculate centroids of k0 and k1\n", + " centroid_k0 = np.mean(k0[i], axis=0)\n", + " centroid_k1 = np.mean(k1[i], axis=0)\n", + "\n", + " # Plot a red line connecting the centroids\n", + " ax.plot(*zip(centroid_k0, centroid_k1), color='red', linewidth=1, linestyle='--')\n", + "ax.legend()\n", + "ax.set_aspect('equal', adjustable='box')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### We see that we have arbitraility set up a mismatch. The orange rhombus with circle dots is tied to the blue rotated square with circle dots. We can use EquivariantOT to fix this." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### 2.2 Initialize the Kabsch-based Equivariant OT sampler and sample new $(k_0, k_1)$ pairs to minimize the transport cost of the entire batch after rotational alignment. We can see that the order of newly sampled $\\mathrm{k}_1$ has changed to match $\\mathrm{k}_0$. Note that the sampled $\\mathrm{k}_1$ will be rotated but not translated." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the Kabsch OT Sampler\n", + "kabsch_ot_sampler = EquivariantOTSampler(method=\"exact\", num_threads=1)\n", + "# Sample new pairs from the EquivariantOTSampler, mask is not used in this example\n", + "# Replace is set to False, so no duplicates are allowed\n", + "# Sort is set to \"x0\", so the order of output x0 is the same as input x0\n", + "kabsch_k0, kabsch_k1, mask = kabsch_ot_sampler.apply_ot(\n", + " torch.Tensor(k0), \n", + " torch.Tensor(k1), \n", + " mask=None, replace=False, sort=\"x0\")\n", + "# Convert the sampled tensors to numpy arrays\n", + "kabsch_k0 = kabsch_k0.numpy()\n", + "kabsch_k1 = kabsch_k1.numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 500x500 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot newly sampled k0 and k1, note that k1 is rotated to match k0\n", + "fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n", + "for i in range(len(kabsch_k0)):\n", + " plot_quadrilateral(kabsch_k0[i], ax, color='C1', marker=markers[i], label='$k_0^%d$'%i)\n", + " plot_quadrilateral(kabsch_k1[i], ax, color='C0', marker=markers[i], label='$k_1^%d$'%i)\n", + " # Calculate centroids of k0 and k1\n", + " # Calculate centroids of k0 and k1\n", + " centroid_k0 = np.mean(kabsch_k0[i], axis=0)\n", + " centroid_k1 = np.mean(kabsch_k1[i], axis=0)\n", + "\n", + " # Plot a red line connecting the centroids\n", + " ax.plot(*zip(centroid_k0, centroid_k1), color='red', linewidth=1, linestyle='--')\n", + "ax.legend()\n", + "ax.set_aspect('equal', adjustable='box')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### If you wanted to align with respect to rotations and translations you could center your data or augment the EquivariantOT object" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "moco_bionemo", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sub-packages/bionemo-moco/pyproject.toml b/sub-packages/bionemo-moco/pyproject.toml new file mode 100644 index 0000000000..1b3c30ce35 --- /dev/null +++ b/sub-packages/bionemo-moco/pyproject.toml @@ -0,0 +1,34 @@ +[build-system] +requires = ["setuptools>=64", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "bionemo-moco" +readme = "README.md" +description = "BioNeMo Modular Co-Design: Making building Diffusion and Flow Matching generative models easier" +authors = [{ name = "BioNeMo Team", email = "bionemofeedback@nvidia.com" }] +requires-python = ">=3.10" +license = { file = "LICENSE" } +dynamic = ["version"] +dependencies = [ + # bionemo sub-packages + # external + 'torch>=2.2', + 'numpy>=1.24.4,<2', + 'jaxtyping>=0.2.34', + 'pot>=0.9.5', + 'scikit-learn>=1.6.0', + 'matplotlib>=3.3.2' +] + +[tool.setuptools.packages.find] +where = ["src"] +include = ["bionemo.*"] +namespaces = true +exclude = ["test*."] + +[tool.setuptools.dynamic] +version = { file = "VERSION" } + +[tool.uv] +cache-keys = [{ git = true }] diff --git a/sub-packages/bionemo-moco/scripts/README.md b/sub-packages/bionemo-moco/scripts/README.md new file mode 100644 index 0000000000..8993e43d56 --- /dev/null +++ b/sub-packages/bionemo-moco/scripts/README.md @@ -0,0 +1,35 @@ +# Create Documentation Script (create_documentation.sh) + +## Overview +--------------- + +The `create_documentation.sh` script automates the process of generating local documentation for the `bionemo.moco` project and ensures its accuracy by performing a post-generation cleanup. This process enhances discoverability and maintainability of the project's codebase including local changes. + +### Usage +--------- + +```bash +./create_documentation.sh +``` + +## Step-by-Step Process Explained +------------------------------------ + +### 1. **Generating Documentation with pydoc-markdown** + +* **Command:** `pydoc-markdown -I src/bionemo --render-toc > documentation.md` +* **Description:** This step leverages `pydoc-markdown` to parse the `src/bionemo` directory, generating Markdown documentation. The `--render-toc` flag includes a Table of Contents for easier navigation. The output is redirected to a file named `documentation.md`. + +### 2. **Cleaning and Refining Documentation** + +* **Command:** `python scripts/clean_documentation.py` +* **Description:** Following the initial documentation generation, this Python script (`clean_documentation.py`) is executed to: + + Remove redundant or unnecessary sections. + + Ensure proper linkage within the documentation (e.g., fixing internal references). + + Optionally, format code blocks and tables for better readability. + +## Output +---------- + +* **Location:** The refined documentation will be available in the project's root directory as `documentation.md`. +* **Content:** A comprehensive, readable, and accurately linked documentation for `bionemo.moco`, covering modules, classes, functions, and variables documented within the `src/bionemo` directory. diff --git a/sub-packages/bionemo-moco/scripts/clean_documentation.py b/sub-packages/bionemo-moco/scripts/clean_documentation.py new file mode 100644 index 0000000000..8992720332 --- /dev/null +++ b/sub-packages/bionemo-moco/scripts/clean_documentation.py @@ -0,0 +1,43 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import re + + +with open("documentation.md", "r") as file: + lines = file.readlines() + +# Delete lines that start with " * " and " * " +lines = [line for line in lines if not line.startswith(" * ") and not line.startswith(" * ")] + +# Join the lines back into a string +markdown = "".join(lines) + +# Replace dots with no space in anchor ids +markdown = re.sub(r'<a id="([a-zA-Z0-9_\.]+)">', lambda match: f'<a id="{match.group(1).replace(".", "")}">', markdown) + +# Replace dots with no space in links +markdown = re.sub( + r"\[([^\]]+)\]\(#([a-zA-Z0-9_\.]+)\)", + lambda match: f'[{match.group(1)}](#{match.group(2).replace(".", "")})', + markdown, +) + +# Replace 'moco.' with 'bionemo.moco.' +markdown = re.sub(r"moco\.", "bionemo.moco.", markdown) + +with open("documentation.md", "w") as file: + file.write(markdown) diff --git a/sub-packages/bionemo-moco/scripts/create_documentation.sh b/sub-packages/bionemo-moco/scripts/create_documentation.sh new file mode 100644 index 0000000000..44027eb127 --- /dev/null +++ b/sub-packages/bionemo-moco/scripts/create_documentation.sh @@ -0,0 +1,2 @@ + pydoc-markdown -I src/bionemo --render-toc > documentation.md + python scripts/clean_documentation.py diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/__init__.py new file mode 100644 index 0000000000..67abd91797 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/__init__.py @@ -0,0 +1,20 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from .schedules.utils import TimeDirection + + +__all__ = ["TimeDirection"] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py new file mode 100644 index 0000000000..af646f22ba --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/__init__.py @@ -0,0 +1,23 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from .continuous.gaussian import GaussianPrior +from .discrete.custom import DiscreteCustomPrior +from .discrete.mask import DiscreteMaskedPrior +from .discrete.uniform import DiscreteUniformPrior + + +__all__ = ["GaussianPrior", "DiscreteUniformPrior", "DiscreteMaskedPrior", "DiscreteCustomPrior"] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py new file mode 100644 index 0000000000..01fb494195 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/gaussian.py @@ -0,0 +1,80 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Tuple, Union + +import torch +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.utils import remove_center_of_mass +from bionemo.moco.distributions.prior.distribution import PriorDistribution + + +class GaussianPrior(PriorDistribution): + """A subclass representing a Gaussian prior distribution.""" + + def __init__( + self, + mean: Float = 0.0, + std: Float = 1.0, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None, + ) -> None: + """Gaussian prior distribution. + + Args: + mean (Float): The mean of the Gaussian distribution. Defaults to 0.0. + std (Float): The standard deviation of the Gaussian distribution. Defaults to 1.0. + center (bool): Whether to center the samples around the mean. Defaults to False. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + self.mean = mean + self.std = std + self.center = center + self.rng_generator = rng_generator + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples from the Gaussian prior distribution. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + samples = torch.randn(*shape, device=device, generator=rng_generator) + if self.std != 1: + samples = samples * self.std + if self.mean != 0: + samples = samples + self.mean + + if self.center: + samples = remove_center_of_mass(samples, mask) + if mask is not None: + samples = samples * mask.unsqueeze(-1) + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py new file mode 100644 index 0000000000..48502e281a --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/harmonic.py @@ -0,0 +1,104 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Tuple, Union + +import torch +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.utils import remove_center_of_mass +from bionemo.moco.distributions.prior.distribution import PriorDistribution + + +class LinearHarmonicPrior(PriorDistribution): + """A subclass representing a Linear Harmonic prior distribution from Jit et al. https://arxiv.org/abs/2304.02198.""" + + def __init__( + self, + distance: Float = 3.8, + length: Optional[int] = None, + center: Bool = False, + rng_generator: Optional[torch.Generator] = None, + device: Union[str, torch.device] = "cpu", + ) -> None: + """Linear Harmonic prior distribution. + + Args: + distance (Float): RMS distance between adjacent points in the line graph. + length (Optional[int]): The number of points in a batch. + center (bool): Whether to center the samples around the mean. Defaults to False. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + self.distance = distance + self.length = length + self.center = center + self.rng_generator = rng_generator + self.device = device + if length: + self._calculate_terms(length, device) + + def _calculate_terms(self, N, device): + a = 3 / (self.distance * self.distance) + J = torch.zeros(N, N) + for i, j in zip(torch.arange(N - 1), torch.arange(1, N)): + J[i, i] += a + J[j, j] += a + J[i, j] = J[j, i] = -a + D, P = torch.linalg.eigh(J) + D_inv = 1 / D + D_inv[0] = 0 + self.P, self.D_inv = P.to(device), D_inv.to(device) + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples from the Harmonic prior distribution. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + if len(shape) != 3: + raise ValueError("Input shape can only work for B x L x D") + if rng_generator is None: + rng_generator = self.rng_generator + + samples = torch.randn(*shape, device=device, generator=rng_generator) + N = shape[1] + + if N != self.length: + self._calculate_terms(N, device) + + std = torch.sqrt(self.D_inv).unsqueeze(-1) + samples = self.P @ (std * samples) + + if self.center: + samples = remove_center_of_mass(samples, mask) + + if mask is not None: + samples = samples * mask.unsqueeze(-1) + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py new file mode 100644 index 0000000000..9a9bf9dfe5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/continuous/utils.py @@ -0,0 +1,38 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional + +from torch import Tensor + + +def remove_center_of_mass(data: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Calculates the center of mass (CoM) of the given data. + + Args: + data: The input data with shape (..., nodes, features). + mask: An optional binary mask to apply to the data with shape (..., nodes) to mask out interaction from CoM calculation. Defaults to None. + + Returns: + The CoM of the data with shape (..., 1, features). + """ + if mask is None: + com = data.mean(dim=-2, keepdim=True) + else: + masked_data = data * mask.unsqueeze(-1) + num_nodes = mask.sum(dim=-1, keepdim=True).unsqueeze(-1) + com = masked_data.sum(dim=-2, keepdim=True) / num_nodes + return data - com diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py new file mode 100644 index 0000000000..6b2f040b77 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/custom.py @@ -0,0 +1,72 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import math +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution + + +class DiscreteCustomPrior(DiscretePriorDistribution): + """A subclass representing a discrete custom prior distribution. + + This class allows for the creation of a prior distribution with a custom + probability mass function defined by the `prior_dist` tensor. For example if my data has 4 classes and I want [.3, .2, .4, .1] as the probabilities of the 4 classes. + """ + + def __init__(self, prior_dist: Tensor, num_classes: int = 10) -> None: + """Initializes a DiscreteCustomPrior distribution. + + Args: + prior_dist: A tensor representing the probability mass function of the prior distribution. + num_classes: The number of classes in the prior distribution. Defaults to 10. + + Note: + The `prior_dist` tensor should have a sum close to 1.0, as it represents a probability mass function. + """ + super().__init__(num_classes, prior_dist) + if torch.sum(self.prior_dist).item() - 1.0 > 1e-5: + raise ValueError("Prior distribution probabilities do not sum up to 1.0") + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Samples from the discrete custom prior distribution. + + Args: + shape: A tuple specifying the shape of the samples to generate. + mask: An optional tensor mask to apply to the samples, broadcastable to the sample shape. Defaults to None. + device: The device on which to generate the samples, specified as a string or a :class:`torch.device`. Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples drawn from the prior distribution. + """ + samples = ( + torch.multinomial(self.prior_dist, math.prod(shape), replacement=True, generator=rng_generator) + .to(device) + .reshape(shape) + ) + if mask is not None: + samples = samples * mask[(...,) + (None,) * (len(samples.shape) - len(mask.shape))] + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py new file mode 100644 index 0000000000..cd8031cc99 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/mask.py @@ -0,0 +1,112 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution + + +class DiscreteMaskedPrior(DiscretePriorDistribution): + """A subclass representing a Discrete Masked prior distribution.""" + + def __init__(self, num_classes: int = 10, mask_dim: Optional[int] = None, inclusive: bool = True) -> None: + """Discrete Masked prior distribution. + + Theres 3 ways I can think of defining the problem that are hard to mesh together. + + 1. [..., M, ....] inclusive anywhere --> exisiting LLM tokenizer where the mask has a specific location not at the end + 2. [......, M] inclusive on end --> mask_dim = None with inclusive set to True default stick on the end + 3. [.....] + [M] exclusive --> the number of classes representes the number of data classes and one wishes to add a separate MASK dimension. + - Note the pad_sample function is provided to help add this extra external dimension. + + Args: + num_classes (int): The number of classes in the distribution. Defaults to 10. + mask_dim (int): The index for the mask token. Defaults to num_classes - 1 if inclusive or num_classes if exclusive. + inclusive (bool): Whether the mask is included in the specified number of classes. + If True, the mask is considered as one of the classes. + If False, the mask is considered as an additional class. Defaults to True. + """ + if inclusive: + if mask_dim is None: + mask_dim = num_classes - 1 + else: + if mask_dim >= num_classes: + raise ValueError( + "As Inclusive accounts for the mask as one of the specified num_classes, the provided mask_dim cannot be >= to num_classes" + ) + prior_dist = torch.zeros((num_classes)) + prior_dist[-1] = 1.0 + super().__init__(num_classes, prior_dist) + self.mask_dim = mask_dim + else: + prior_dist = torch.zeros((num_classes + 1)) + prior_dist[-1] = 1.0 + super().__init__(num_classes + 1, prior_dist) + self.mask_dim = num_classes + if torch.sum(self.prior_dist).item() - 1.0 >= 1e-5: + raise ValueError("Invalid probability distribution. Must sum to 1.0") + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + samples = torch.ones(shape, dtype=torch.int64, device=device) * self.mask_dim + if mask is not None: + samples = samples * mask[(...,) + (None,) * (len(samples.shape) - len(mask.shape))] + return samples + + def is_masked(self, sample: Tensor) -> Tensor: + """Creates a mask for whether a state is masked. + + Args: + sample (Tensor): The sample to check. + + Returns: + Tensor: A float tensor indicating whether the sample is masked. + """ + return (sample == self.mask_dim).float() + + def pad_sample(self, sample: Tensor) -> Tensor: + """Pads the input sample with zeros along the last dimension. + + Args: + sample (Tensor): The input sample to be padded. + + Returns: + Tensor: The padded sample. + """ + # Create a zeros tensor with the same shape as the original tensor, except the last dimension is 1 + zeros = torch.zeros((*sample.shape[:-1], 1), dtype=torch.float, device=sample.device) + # Concatenate along the last dimension to make the shape (..., N+1) + padded_sample = torch.cat((sample, zeros), dim=-1) + return padded_sample diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py new file mode 100644 index 0000000000..53a71b601e --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/discrete/uniform.py @@ -0,0 +1,60 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution + + +class DiscreteUniformPrior(DiscretePriorDistribution): + """A subclass representing a discrete uniform prior distribution.""" + + def __init__(self, num_classes: int = 10) -> None: + """Initializes a discrete uniform prior distribution. + + Args: + num_classes (int): The number of classes in the discrete uniform distribution. Defaults to 10. + """ + prior_dist = torch.ones((num_classes)) * 1 / num_classes + super().__init__(num_classes, prior_dist) + if torch.sum(self.prior_dist).item() - 1.0 > 1e-5: + raise ValueError("Prior distribution probabilities do not sum up to 1.0") + + def sample( + self, + shape: Tuple, + mask: Optional[Tensor] = None, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ) -> Tensor: + """Generates a specified number of samples. + + Args: + shape (Tuple): The shape of the samples to generate. + device (str): cpu or gpu. + mask (Optional[Tensor]): An optional mask to apply to the samples. Defaults to None. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A tensor of samples. + """ + samples = torch.randint(0, self.num_classes, shape, device=device, generator=rng_generator) + if mask is not None: + samples = samples * mask[(...,) + (None,) * (len(samples.shape) - len(mask.shape))] + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py new file mode 100644 index 0000000000..bc3fb34965 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/prior/distribution.py @@ -0,0 +1,64 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod +from typing import Optional, Tuple, Union + +import torch +from torch import Tensor + + +class PriorDistribution(ABC): + """An abstract base class representing a prior distribution.""" + + @abstractmethod + def sample(self, shape: Tuple, mask: Optional[Tensor] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generates a specified number of samples from the time distribution. + + Args: + shape (Tuple): The shape of the samples to generate. + mask (Optional[Tensor], optional): A tensor indicating which samples should be masked. Defaults to None. + device (str, optional): The device on which to generate the samples. Defaults to "cpu". + + Returns: + Float: A tensor of samples. + """ + pass + + +class DiscretePriorDistribution(PriorDistribution): + """An abstract base class representing a discrete prior distribution.""" + + def __init__(self, num_classes: int, prior_dist: Tensor): + """Initializes a DiscretePriorDistribution instance. + + Args: + num_classes (int): The number of classes in the discrete distribution. + prior_dist (Tensor): The prior distribution over the classes. + + Returns: + None + """ + self.num_classes = num_classes + self.prior_dist = prior_dist + + def get_num_classes(self) -> int: + """Getter for num_classes.""" + return self.num_classes + + def get_prior_dist(self) -> Tensor: + """Getter for prior_dist.""" + return self.prior_dist diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py new file mode 100644 index 0000000000..0d1b736ca1 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/__init__.py @@ -0,0 +1,29 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from .beta import BetaTimeDistribution +from .distribution import MixTimeDistribution, TimeDistribution +from .logit_normal import LogitNormalTimeDistribution +from .uniform import UniformTimeDistribution + + +__all__ = [ + "BetaTimeDistribution", + "LogitNormalTimeDistribution", + "MixTimeDistribution", + "UniformTimeDistribution", + "TimeDistribution", +] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py new file mode 100644 index 0000000000..0a4164d161 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/beta.py @@ -0,0 +1,75 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.distributions.time.utils import float_time_to_index + + +class BetaTimeDistribution(TimeDistribution): + """A class representing a beta time distribution.""" + + def __init__( + self, + p1: Float = 2.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a BetaTimeDistribution object. + + Args: + p1 (Float): The first shape parameter of the beta distribution. + p2 (Float): The second shape parameter of the beta distribution. + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + self.dist = torch.distributions.Beta(p1, p2) + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + time_step = self.dist.sample(torch.Size([n_samples])).to(device=device) + if self.min_t and self.max_t and self.min_t > 0: + time_step = time_step * (self.max_t - self.min_t) + self.min_t + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = float_time_to_index(time_step, self.nsteps) + return time_step diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py new file mode 100644 index 0000000000..846e95e4f6 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/distribution.py @@ -0,0 +1,124 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + + +class TimeDistribution(ABC): + """An abstract base class representing a time distribution. + + Args: + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + min_t (Optional[Float]): Min continuous time. + max_t (Optional[Float]): Max continuous time. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + + def __init__( + self, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + min_t: Optional[Float] = None, + max_t: Optional[Float] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a TimeDistribution object.""" + self.discrete_time = discrete_time + self.nsteps = nsteps + self.rng_generator = rng_generator + if discrete_time: + min_t = 0.0 + max_t = 1.0 + if nsteps is None: + raise ValueError("nsteps must not be None and must be specified for discrete time") + if min_t is not None and isinstance(min_t, float): + if not 0 <= min_t < 1.0: + raise ValueError("min_t must be greater than or equal to 0 and less than 1.0") + self.min_t = min_t + if max_t is not None and isinstance(max_t, float): + if not 0 < max_t <= 1.0: + raise ValueError("max_t must be greater than 0 and less than or equal to 1.0") + self.max_t = max_t + if ( + self.min_t is not None + and self.max_t is not None + and isinstance(self.min_t, float) + and isinstance(self.max_t, float) + ): + if self.min_t >= self.max_t: + raise ValueError("min_t must be less than max_t") + + @abstractmethod + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ) -> Float: + """Generates a specified number of samples from the time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A list or array of samples. + """ + pass + + +class MixTimeDistribution: + """An abstract base class representing a mixed time distribution. + + uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) + beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) + mix_dist = MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=0.5) + """ + + def __init__(self, dist1: TimeDistribution, dist2: TimeDistribution, mix_fraction: Float): + """Initializes a MixTimeDistribution object. + + Args: + dist1 (TimeDistribution): The first time distribution. + dist2 (TimeDistribution): The second time distribution. + mix_fraction (Float): The fraction of samples to draw from dist1. Must be between 0 and 1. + """ + if not 0 <= mix_fraction <= 1: + raise ValueError("mix_fraction must be between 0 and 1") + self.dist1 = dist1 + self.dist2 = dist2 + self.mix_fraction = mix_fraction + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ) -> Float: + """Generates a specified number of samples from the mixed time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + Float: A list or array of samples. + """ + samples_dist1 = self.dist1.sample(n_samples, device) + samples_dist2 = self.dist2.sample(n_samples, device) + mix = torch.rand(n_samples, device=device, generator=rng_generator) + return torch.where(mix < self.mix_fraction, samples_dist1, samples_dist2) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py new file mode 100644 index 0000000000..0d6c9a28c4 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/logit_normal.py @@ -0,0 +1,77 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.distributions.time.utils import float_time_to_index + + +class LogitNormalTimeDistribution(TimeDistribution): + """A class representing a logit normal time distribution.""" + + def __init__( + self, + p1: Float = 0.0, + p2: Float = 1.0, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a BetaTimeDistribution object. + + Args: + p1 (Float): The first shape parameter of the logit normal distribution i.e. the mean. + p2 (Float): The second shape parameter of the logit normal distribution i.e. the std. + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + self.p1 = p1 + self.p2 = p2 + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + time_step = torch.randn(n_samples, device=device, generator=rng_generator) * self.p2 + self.p1 + time_step = torch.nn.functional.sigmoid(time_step) + if self.min_t and self.max_t and (self.min_t > 0 or self.max_t < 1): + time_step = time_step * (self.max_t - self.min_t) + self.min_t + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = float_time_to_index(time_step, self.nsteps) + return time_step diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py new file mode 100644 index 0000000000..444abe4d08 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/uniform.py @@ -0,0 +1,122 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Union + +import torch +from jaxtyping import Bool, Float + +from bionemo.moco.distributions.time.distribution import TimeDistribution + + +class UniformTimeDistribution(TimeDistribution): + """A class representing a uniform time distribution.""" + + def __init__( + self, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a UniformTimeDistribution object. + + Args: + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = torch.randint(0, self.nsteps, size=(n_samples,), device=device, generator=rng_generator) + else: + time_step = torch.rand(n_samples, device=device, generator=rng_generator) + if self.min_t and self.max_t and self.min_t > 0: + time_step = time_step * (self.max_t - self.min_t) + self.min_t + return time_step + + +class SymmetricUniformTimeDistribution(TimeDistribution): + """A class representing a uniform time distribution.""" + + def __init__( + self, + min_t: Float = 0.0, + max_t: Float = 1.0, + discrete_time: Bool = False, + nsteps: Optional[int] = None, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes a UniformTimeDistribution object. + + Args: + min_t (Float): The minimum time value. + max_t (Float): The maximum time value. + discrete_time (Bool): Whether the time is discrete. + nsteps (Optional[int]): Number of nsteps for discretization. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(discrete_time, nsteps, min_t, max_t, rng_generator) + + def sample( + self, n_samples: int, device: Union[str, torch.device] = "cpu", rng_generator: Optional[torch.Generator] = None + ): + """Generates a specified number of samples from the uniform time distribution. + + Args: + n_samples (int): The number of samples to generate. + device (str): cpu or gpu. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + + Returns: + A tensor of samples. + """ + if rng_generator is None: + rng_generator = self.rng_generator + if self.discrete_time: + if self.nsteps is None: + raise ValueError("nsteps cannot be None for discrete time sampling") + time_step = torch.randint( + 0, self.nsteps, size=(n_samples // 2 + 1,), device=device, generator=rng_generator + ) + time_step = torch.cat([time_step, self.nsteps - time_step - 1], dim=0)[:n_samples] + else: + time_step = torch.rand(n_samples // 2 + 1, device=device, generator=rng_generator) + time_step = torch.cat([time_step, 1 - time_step], dim=0)[:n_samples] + if self.min_t and self.max_t and self.min_t > 0: + time_step = time_step * (self.max_t - self.min_t) + self.min_t + return time_step diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py new file mode 100644 index 0000000000..e4bb0ca173 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/distributions/time/utils.py @@ -0,0 +1,35 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import torch + + +def float_time_to_index(time: torch.Tensor, num_time_steps: int) -> torch.Tensor: + """Convert a float time value to a time index. + + Args: + time (torch.Tensor): A tensor of float time values in the range [0, 1]. + num_time_steps (int): The number of discrete time steps. + + Returns: + torch.Tensor: A tensor of time indices corresponding to the input float time values. + """ + # Ensure time values are in the range [0, 1] + time = torch.clamp(time, 0.0, 1.0) + + # Scale to the index range and round + indices = torch.round(time * (num_time_steps - 1)).to(torch.int64) + + return indices diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py new file mode 100644 index 0000000000..743489e4f4 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/__init__.py @@ -0,0 +1,38 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from .continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher +from .continuous_time.continuous.optimal_transport.equivariant_ot_sampler import EquivariantOTSampler +from .continuous_time.continuous.optimal_transport.kabsch_augmentation import KabschAugmentation +from .continuous_time.continuous.optimal_transport.ot_sampler import OTSampler +from .continuous_time.continuous.vdm import VDM +from .continuous_time.discrete.discrete_flow_matching import DiscreteFlowMatcher +from .continuous_time.discrete.mdlm import MDLM +from .discrete_time.continuous.ddpm import DDPM +from .discrete_time.discrete.d3pm import D3PM + + +__all__ = [ + "DDPM", + "D3PM", + "VDM", + "MDLM", + "ContinuousFlowMatcher", + "DiscreteFlowMatcher", + "EquivariantOTSampler", + "OTSampler", + "KabschAugmentation", +] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py new file mode 100644 index 0000000000..ac6018a402 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/base_interpolant.py @@ -0,0 +1,241 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod +from enum import Enum +from typing import Optional, Type, TypeVar, Union + +import torch +from jaxtyping import Bool +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution + + +# Define a generic type for Enum +AnyEnum = TypeVar("AnyEnum", bound=Enum) + + +def string_to_enum(value: Union[str, AnyEnum], enum_type: Type[AnyEnum]) -> AnyEnum: + """Converts a string to an enum value of the specified type. If the input is already an enum instance, it is returned as-is. + + Args: + value (Union[str, E]): The string to convert or an existing enum instance. + enum_type (Type[E]): The enum type to convert to. + + Returns: + E: The corresponding enum value. + + Raises: + ValueError: If the string does not correspond to any enum member. + """ + if isinstance(value, enum_type): + # If the value is already an enum, return it + return value + + try: + # Match the value to the Enum, case-insensitively + return enum_type(value) + except ValueError: + # Raise a helpful error if the value is invalid + valid_values = [e.value for e in enum_type] + raise ValueError(f"Invalid value '{value}'. Expected one of {valid_values}.") + + +def pad_like(source: Tensor, target: Tensor) -> Tensor: + """Pads the dimensions of the source tensor to match the dimensions of the target tensor. + + Args: + source (Tensor): The tensor to be padded. + target (Tensor): The tensor that the source tensor should match in dimensions. + + Returns: + Tensor: The padded source tensor. + + Raises: + ValueError: If the source tensor has more dimensions than the target tensor. + + Example: + >>> source = torch.tensor([1, 2, 3]) # shape: (3,) + >>> target = torch.tensor([[1, 2], [4, 5], [7, 8]]) # shape: (3, 2) + >>> padded_source = pad_like(source, target) # shape: (3, 1) + """ + if source.ndim == target.ndim: + return source + elif source.ndim > target.ndim: + raise ValueError(f"Cannot pad {source.shape} to {target.shape}") + return source.view(list(source.shape) + [1] * (target.ndim - source.ndim)) + + +class PredictionType(Enum): + """An enumeration representing the type of prediction a Denoising Diffusion Probabilistic Model (DDPM) can be used for. + + DDPMs are versatile models that can be utilized for various prediction tasks, including: + + - **Data**: Predicting the original data distribution from a noisy input. + - **Noise**: Predicting the noise that was added to the original data to obtain the input. + - **Velocity**: Predicting the velocity or rate of change of the data, particularly useful for modeling temporal dynamics. + + These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + """ + + DATA = "data" + NOISE = "noise" + VELOCITY = "velocity" + + +# Adding useful aliases for Flow Matching +PredictionType._value2member_map_["vector_field"] = PredictionType.VELOCITY +PredictionType._value2member_map_["flow"] = PredictionType.VELOCITY + + +class Interpolant(ABC): + """An abstract base class representing an Interpolant. + + This class serves as a foundation for creating interpolants that can be used + in various applications, providing a basic structure and interface for + interpolation-related operations. + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the Interpolant class. + + Args: + time_distribution (TimeDistribution): The distribution of time steps. + prior_distribution (PriorDistribution): The prior distribution of the variable. + device (Union[str, torch.device], optional): The device on which to operate. Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + self.time_distribution = time_distribution + self.prior_distribution = prior_distribution + self.device = device + self.rng_generator = rng_generator + + @abstractmethod + def interpolate(self, *args, **kwargs) -> Tensor: + """Get x(t) with given time t from noise and data. + + Interpolate between x0 and x1 at the given time t. + """ + pass + + @abstractmethod + def step(self, *args, **kwargs) -> Tensor: + """Do one step integration.""" + pass + + def general_step(self, method_name: str, kwargs: dict): + """Calls a step method of the class by its name, passing the provided keyword arguments. + + Args: + method_name (str): The name of the step method to call. + kwargs (dict): Keyword arguments to pass to the step method. + + Returns: + The result of the step method call. + + Raises: + ValueError: If the provided method name does not start with 'step'. + Exception: If the step method call fails. The error message includes a list of available step methods. + + Note: + This method allows for dynamic invocation of step methods, providing flexibility in the class's usage. + """ + if not method_name.startswith("step"): + raise ValueError(f"Method name '{method_name}' does not start with 'step'") + + try: + # Get the step method by its name + func = getattr(self, method_name) + # Call the step method with the provided keyword arguments + return func(**kwargs) + except Exception as e: + # Get a list of available step methods + available_methods = "\n".join([f" - {attr}" for attr in dir(self) if attr.startswith("step")]) + # Create a detailed error message + error_message = f"Error calling method '{method_name}': {e}\nAvailable step methods:\n{available_methods}" + # Re-raise the exception with the detailed error message + raise type(e)(error_message) + + def sample_prior(self, *args, **kwargs) -> Tensor: + """Sample from prior distribution. + + This method generates a sample from the prior distribution specified by the + `prior_distribution` attribute. + + Returns: + Tensor: The generated sample from the prior distribution. + """ + # Ensure the device is specified, default to self.device if not provided + if "device" not in kwargs: + kwargs["device"] = self.device + kwargs["rng_generator"] = self.rng_generator + # Sample from the prior distribution + return self.prior_distribution.sample(*args, **kwargs) + + def sample_time(self, *args, **kwargs) -> Tensor: + """Sample from time distribution.""" + # Ensure the device is specified, default to self.device if not provided + if "device" not in kwargs: + kwargs["device"] = self.device + kwargs["rng_generator"] = self.rng_generator + # Sample from the time distribution + return self.time_distribution.sample(*args, **kwargs) + + def to_device(self, device: str): + """Moves all internal tensors to the specified device and updates the `self.device` attribute. + + Args: + device (str): The device to move the tensors to (e.g. "cpu", "cuda:0"). + + Note: + This method is used to transfer the internal state of the DDPM interpolant to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + """ + self.device = device + for attr_name in dir(self): + if attr_name.startswith("_") and isinstance(getattr(self, attr_name), torch.Tensor): + setattr(self, attr_name, getattr(self, attr_name).to(device)) + return self + + def clean_mask_center(self, data: Tensor, mask: Optional[Tensor] = None, center: Bool = False) -> Tensor: + """Returns a clean tensor that has been masked and/or centered based on the function arguments. + + Args: + data: The input data with shape (..., nodes, features). + mask: An optional mask to apply to the data with shape (..., nodes). If provided, it is used to calculate the CoM. Defaults to None. + center: A boolean indicating whether to center the data around the calculated CoM. Defaults to False. + + Returns: + The data with shape (..., nodes, features) either centered around the CoM if `center` is True or unchanged if `center` is False. + """ + if mask is not None: + data = data * mask.unsqueeze(-1) + if not center: + return data + if mask is None: + num_nodes = torch.tensor(data.shape[1], device=data.device) + else: + num_nodes = torch.clamp(mask.sum(dim=-1), min=1) # clamp used to prevent divide by 0 + com = data.sum(dim=-2) / num_nodes.unsqueeze(-1) + return data - com.unsqueeze(-2) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/batch_augmentation.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/batch_augmentation.py new file mode 100644 index 0000000000..dd718744e6 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/batch_augmentation.py @@ -0,0 +1,62 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.equivariant_ot_sampler import ( + EquivariantOTSampler, +) +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.kabsch_augmentation import ( + KabschAugmentation, +) +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.ot_sampler import OTSampler +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.ot_types import OptimalTransportType + + +class BatchAugmentation: + """Facilitates the creation of batch augmentation objects based on specified optimal transport types. + + Args: + device (str): The device to use for computations (e.g., 'cpu', 'cuda'). + num_threads (int): The number of threads to utilize. + """ + + def __init__(self, device, num_threads): + """Initializes a BatchAugmentation instance. + + Args: + device (str): Device for computation. + num_threads (int): Number of threads to use. + """ + self.device = device + self.num_threads = num_threads + + def create(self, method_type: OptimalTransportType): + """Creates a batch augmentation object of the specified type. + + Args: + method_type (OptimalTransportType): The type of optimal transport method. + + Returns: + The augmentation object if the type is supported, otherwise **None**. + """ + if method_type == OptimalTransportType.EXACT: + augmentation = OTSampler(method="exact", device=self.device, num_threads=self.num_threads) + elif method_type == OptimalTransportType.KABSCH: + augmentation = KabschAugmentation() + elif method_type == OptimalTransportType.EQUIVARIANT: + augmentation = EquivariantOTSampler(method="exact", device=self.device, num_threads=self.num_threads) + else: + return None + return augmentation diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py new file mode 100644 index 0000000000..e8ac12cbce --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py @@ -0,0 +1,545 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Union + +import torch +import torch.nn as nn +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, PredictionType, pad_like, string_to_enum +from bionemo.moco.interpolants.batch_augmentation import BatchAugmentation +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.ot_types import OptimalTransportType + + +class ContinuousFlowMatcher(Interpolant): + """A Continuous Flow Matching interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher + >>> from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + + flow_matcher = ContinuousFlowMatcher( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = flow_matcher.sample_time(batch_size) + noise = flow_matcher.sample_prior(data.shape) + data, time, noise = flow_matcher.apply_ot(noise, data) # Optional, only for OT + xt = flow_matcher.interpolate(data, time, noise) + flow = flow_matcher.calculate_target(data, noise) + + u_pred = model(xt, time) + loss = flow_matcher.loss(u_pred, flow) + loss.backward() + + # Generation + x_pred = flow_matcher.sample_prior(data.shape) + inference_sched = LinearInferenceSchedule(...) + for t in inference_sched.generate_schedule(): + time = inference_sched.pad_time(x_pred.shape[0], t) + u_hat = model(x_pred, time) + x_pred = flow_matcher.step(u_hat, x_pred, time) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + sigma: Float = 0, + ot_type: Optional[Union[OptimalTransportType, str]] = None, + ot_num_threads: int = 1, + data_scale: Float = 1.0, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + eps: Float = 1e-5, + ): + """Initializes the Continuous Flow Matching interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + prediction_type (PredictionType, optional): The type of prediction, either "flow" or another type. Defaults to PredictionType.DATA. + sigma (Float, optional): The standard deviation of the Gaussian noise added to the interpolated data. Defaults to 0. + ot_type (Optional[Union[OptimalTransportType, str]], optional): The type of optimal transport, if applicable. Defaults to None. + ot_num_threads: Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + data_scale (Float, optional): The scale factor for the data. Defaults to 1.0. + device (Union[str, torch.device], optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + eps: Small float to prevent divide by zero + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + self.prediction_type = string_to_enum(prediction_type, PredictionType) + self.sigma = sigma + self.ot_type = ot_type + self.data_scale = data_scale + self.eps = eps + if data_scale <= 0: + raise ValueError("Data Scale must be > 0") + if ot_type is not None: + self.ot_type = ot_type = string_to_enum(ot_type, OptimalTransportType) + self.ot_sampler = self._build_ot_sampler(method_type=ot_type, num_threads=ot_num_threads) + self._loss_function = nn.MSELoss(reduction="none") + + def _build_ot_sampler(self, method_type: OptimalTransportType, num_threads: int = 1): + """Build the optimal transport sampler for the given optimal transport type. + + Args: + method_type (OptimalTransportType): The type of augmentation. + num_threads (int): The number of threads to use for the OT sampler, default to 1. + + Returns: + The augmentation object. + """ + return BatchAugmentation(self.device, num_threads).create(method_type) + + def apply_ot(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None, **kwargs) -> tuple: + """Sample and apply the optimal transport plan between batched (and masked) x0 and x1. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + **kwargs: Additional keyword arguments to be passed to self.ot_sampler.apply_ot or handled within this method. + + + Returns: + Tuple: tuple of 2 tensors, represents the noise and data samples following OT plan pi. + """ + if self.ot_sampler is None: + raise ValueError("Optimal Transport Sampler is not defined") + return self.ot_sampler.apply_ot(x0, x1, mask=mask, **kwargs) + + def undo_scale_data(self, data: Tensor) -> Tensor: + """Downscale the input data by the data scale factor. + + Args: + data (Tensor): The input data to downscale. + + Returns: + The downscaled data. + """ + return 1 / self.data_scale * data + + def scale_data(self, data: Tensor) -> Tensor: + """Upscale the input data by the data scale factor. + + Args: + data (Tensor): The input data to upscale. + + Returns: + The upscaled data. + """ + return self.data_scale * data + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor) -> Tensor: + """Get x_t with given time t from noise (x_0) and data (x_1). + + Currently, we use the linear interpolation as defined in: + 1. Rectified flow: https://arxiv.org/abs/2209.03003. + 2. Conditional flow matching: https://arxiv.org/abs/2210.02747 (called conditional optimal transport). + + Args: + noise (Tensor): noise from prior(), shape (batchsize, nodes, features) + t (Tensor): time, shape (batchsize) + data (Tensor): target, shape (batchsize, nodes, features) + """ + assert data.size() == noise.size() + # Expand t to the same shape as noise: ones([b,n,f]) * t([b,1,1]) + t = pad_like(t, data) + # Calculate x_t as the linear interpolation between noise and data + x_t = data * t + noise * (1.0 - t) + # Add Gaussian Noise + if self.sigma > 0: + x_t += self.sigma * torch.randn(x_t.shape, device=x_t.device, generator=self.rng_generator) + return x_t + + def calculate_target(self, data: Tensor, noise: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Get the target vector field at time t. + + Args: + noise (Tensor): noise from prior(), shape (batchsize, nodes, features) + data (Tensor): target, shape (batchsize, nodes, features) + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + Tensor: The target vector field at time t. + """ + assert data.size() == noise.size() + # Calculate the target vector field u_t(x_t|x_1) as the difference between data and noise because t~[0,1] + if self.prediction_type == PredictionType.VELOCITY: + u_t = data - noise + elif self.prediction_type == PredictionType.DATA: + u_t = data + else: + raise ValueError( + f"Given prediction_type {self.prediction_type} is not supproted for Continuous Flow Matching." + ) + if mask is not None: + u_t = u_t * mask.unsqueeze(-1) + return u_t + + def process_vector_field_prediction( + self, + model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + ): + """Process the model output based on the prediction type to calculate vecotr field. + + Args: + model_output (Tensor): The output of the model. + xt (Tensor): The input sample. + t (Tensor): The time step. + mask (Optional[Tensor], optional): An optional mask to apply to the model output. Defaults to None. + + Returns: + The vector field prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not "flow" or "data". + """ + if self.prediction_type == PredictionType.VELOCITY: + pred_vector_field = model_output + elif self.prediction_type == PredictionType.DATA: + if xt is None or t is None: + raise ValueError("Xt and Time cannpt be None for vector field conversion") + t = pad_like(t, model_output) + pred_vector_field = (model_output - xt) / (1 - t + self.eps) + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be `flow` or `data` " + "for Continuous Flow Matching." + ) + if mask is not None: + pred_vector_field = pred_vector_field * mask.unsqueeze(-1) + return pred_vector_field + + def process_data_prediction( + self, + model_output: Tensor, + xt: Optional[Tensor] = None, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + ): + """Process the model output based on the prediction type to generate clean data. + + Args: + model_output (Tensor): The output of the model. + xt (Tensor): The input sample. + t (Tensor): The time step. + mask (Optional[Tensor], optional): An optional mask to apply to the model output. Defaults to None. + + Returns: + The data prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not "flow". + """ + if self.prediction_type == PredictionType.VELOCITY: + if xt is None or t is None: + raise ValueError("Xt and time cannot be None") + t = pad_like(t, model_output) + pred_data = xt + (1 - t) * model_output + elif self.prediction_type == PredictionType.DATA: + pred_data = model_output + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be `flow` " "for Continuous Flow Matching." + ) + if mask is not None: + pred_data = pred_data * mask.unsqueeze(-1) + return pred_data + + def step( + self, + model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + center: Bool = False, + ): + """Perform a single ODE step integration using Euler method. + + Args: + model_out (Tensor): The output of the model at the current time step. + xt (Tensor): The current intermediate state. + dt (Tensor): The time step size. + t (Tensor, optional): The current time. Defaults to None. + mask (Optional[Tensor], optional): A mask to apply to the model output. Defaults to None. + center (Bool, optional): Whether to center the output. Defaults to False. + + Returns: + x_next (Tensor): The updated state of the system after the single step, x_(t+dt). + + Notes: + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + v_t = self.process_vector_field_prediction(model_out, xt, t, mask) + dt = pad_like(dt, model_out) + delta_x = v_t * dt + x_next = xt + delta_x + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def step_score_stochastic( + self, + model_out: Tensor, + xt: Tensor, + dt: Tensor, + t: Tensor, + mask: Optional[Tensor] = None, + gt_mode: str = "tan", + gt_p: Float = 1.0, + gt_clamp: Optional[Float] = None, + score_temperature: Float = 1.0, + noise_temperature: Float = 1.0, + t_lim_ode: Float = 0.99, + center: Bool = False, + ): + r"""Perform a single SDE step integration using a score-based Langevin update. + + d x_t = [v(x_t, t) + g(t) * s(x_t, t) * score_temperature] dt + \sqrt{2 * g(t) * noise_temperature} dw_t. + + Args: + model_out (Tensor): The output of the model at the current time step. + xt (Tensor): The current intermediate state. + dt (Tensor): The time step size. + t (Tensor, optional): The current time. Defaults to None. + mask (Optional[Tensor], optional): A mask to apply to the model output. Defaults to None. + gt_mode (str, optional): The mode for the gt function. Defaults to "tan". + gt_p (Float, optional): The parameter for the gt function. Defaults to 1.0. + gt_clamp: (Float, optional): Upper limit of gt term. Defaults to None. + score_temperature (Float, optional): The temperature for the score part of the step. Defaults to 1.0. + noise_temperature (Float, optional): The temperature for the stochastic part of the step. Defaults to 1.0. + t_lim_ode (Float, optional): The time limit for the ODE step. Defaults to 0.99. + center (Bool, optional): Whether to center the output. Defaults to False. + + Returns: + x_next (Tensor): The updated state of the system after the single step, x_(t+dt). + + Notes: + - If a mask is provided, it is applied element-wise to the model output before scaling. + - The `clean` method is called on the updated state before it is returned. + """ + if self.ot_type is not None: + raise ValueError("Optimal Transport violates the vector field to score conversion") + if not isinstance(self.prior_distribution, GaussianPrior): + raise ValueError( + "Prior distribution must be an instance of GaussianPrior to learn a proper score function" + ) + if t.min() >= t_lim_ode: + return self.step(model_out, xt, dt, t, mask, center) + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + v_t = self.process_vector_field_prediction(model_out, xt, t, mask) + dt = pad_like(dt, model_out) + t = pad_like(t, model_out) + score = self.vf_to_score(xt, v_t, t) + gt = self.get_gt(t, gt_mode, gt_p, gt_clamp) + eps = torch.randn(xt.shape, dtype=xt.dtype, device=xt.device, generator=self.rng_generator) + std_eps = torch.sqrt(2 * gt * noise_temperature * dt) + delta_x = (v_t + gt * score * score_temperature) * dt + std_eps * eps + x_next = xt + delta_x + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def loss( + self, + model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + xt: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + target_type: Union[PredictionType, str] = PredictionType.DATA, + ): + """Calculate the loss given the model prediction, data sample, time, and mask. + + If target_type is FLOW loss = ||v_hat - (x1-x0)||**2 + If target_type is DATA loss = ||x1_hat - x1||**2 * 1 / (1 - t)**2 as the target vector field = x1 - x0 = (1/(1-t)) * x1 - xt where xt = tx1 - (1-t)x0. + This functions supports any cominbation of prediction_type and target_type in {DATA, FLOW}. + + Args: + model_pred (Tensor): The predicted output from the model. + target (Tensor): The target output for the model prediction. + t (Optional[Tensor], optional): The time for the model prediction. Defaults to None. + xt (Optional[Tensor], optional): The interpolated data. Defaults to None. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + target_type (PredictionType, optional): The type of the target output. Defaults to PredictionType.DATA. + + Returns: + Tensor: The calculated loss batch tensor. + """ + target_type = string_to_enum(target_type, PredictionType) + if target_type == PredictionType.DATA: + model_pred = self.process_data_prediction(model_pred, xt, t, mask) + else: + model_pred = self.process_vector_field_prediction(model_pred, xt, t, mask) + raw_loss = self._loss_function(model_pred, target) + + if mask is not None: + loss = raw_loss * mask.unsqueeze(-1) + n_elem = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / n_elem + else: + loss = torch.sum(raw_loss, dim=tuple(range(1, raw_loss.ndim))) / model_pred.size(1) + if target_type == PredictionType.DATA: + if t is None: + raise ValueError("Time cannot be None when using a time-based weighting") + loss_weight = 1.0 / ((1.0 - t) ** 2 + self.eps) + loss = loss_weight * loss + return loss + + def vf_to_score( + self, + x_t: Tensor, + v: Tensor, + t: Tensor, + ) -> Tensor: + """From Geffner et al. Computes score of noisy density given the vector field learned by flow matching. + + With our interpolation scheme these are related by + + v(x_t, t) = (1 / t) (x_t + scale_ref ** 2 * (1 - t) * s(x_t, t)), + + or equivalently, + + s(x_t, t) = (t * v(x_t, t) - x_t) / (scale_ref ** 2 * (1 - t)). + + with scale_ref = 1 + + Args: + x_t: Noisy sample, shape [*, dim] + v: Vector field, shape [*, dim] + t: Interpolation time, shape [*] (must be < 1) + + Returns: + Score of intermediate density, shape [*, dim]. + """ + assert torch.all(t < 1.0), "vf_to_score requires t < 1 (strict)" + t = pad_like(t, v) + num = t * v - x_t # [*, dim] + den = 1.0 - t # [*, 1] + score = num / den + return score # [*, dim] + + def get_gt( + self, + t: Tensor, + mode: str = "tan", + param: float = 1.0, + clamp_val: Optional[float] = None, + eps: float = 1e-2, + ) -> Tensor: + """From Geffner et al. Computes gt for different modes. + + Args: + t: times where we'll evaluate, covers [0, 1), shape [nsteps] + mode: "us" or "tan" + param: parameterized transformation + clamp_val: value to clamp gt, no clamping if None + eps: small value leave as it is + """ + + # Function to get variants for some gt mode + def transform_gt(gt, f_pow=1.0): + # 1.0 means no transformation + if f_pow == 1.0: + return gt + + # First we somewhat normalize between 0 and 1 + log_gt = torch.log(gt) + mean_log_gt = torch.mean(log_gt) + log_gt_centered = log_gt - mean_log_gt + normalized = torch.nn.functional.sigmoid(log_gt_centered) + # Transformation here + normalized = normalized**f_pow + # Undo normalization with the transformed variable + log_gt_centered_rec = torch.logit(normalized, eps=1e-6) + log_gt_rec = log_gt_centered_rec + mean_log_gt + gt_rec = torch.exp(log_gt_rec) + return gt_rec + + # Numerical reasons for some schedule + t = torch.clamp(t, 0, 1 - self.eps) + + if mode == "us": + num = 1.0 - t + den = t + gt = num / (den + eps) + elif mode == "tan": + num = torch.sin((1.0 - t) * torch.pi / 2.0) + den = torch.cos((1.0 - t) * torch.pi / 2.0) + gt = (torch.pi / 2.0) * num / (den + eps) + elif mode == "1/t": + num = 1.0 + den = t + gt = num / (den + eps) + elif mode == "1/t2": + num = 1.0 + den = t**2 + gt = num / (den + eps) + elif mode == "1/t1p5": + num = 1.0 + den = t**1.5 + gt = num / (den + eps) + elif mode == "2/t": + num = 2.0 + den = t + gt = num / (den + eps) + elif mode == "2/t2": + num = 2.0 + den = t**2 + gt = num / (den + eps) + elif mode == "2/t1p5": + num = 2.0 + den = t**1.5 + gt = num / (den + eps) + elif mode == "1mt": + gt = 1 - t + elif mode == "t": + gt = t + elif mode == "ones": + gt = 0 * t + 1 + else: + raise NotImplementedError(f"gt not implemented {mode}") + gt = transform_gt(gt, f_pow=param) + gt = torch.clamp(gt, 0, clamp_val) # If None no clamping + return gt # [s] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/equivariant_ot_sampler.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/equivariant_ot_sampler.py new file mode 100644 index 0000000000..7dbad11f5b --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/equivariant_ot_sampler.py @@ -0,0 +1,243 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import warnings +from functools import partial +from typing import Callable, Literal, Optional, Tuple, Union + +import ot as pot +import torch +from jaxtyping import Bool +from torch import Tensor + + +class EquivariantOTSampler: + """Sampler for Mini-batch Optimal Transport Plan with cost calculated after Kabsch alignment. + + EquivariantOTSampler implements sampling coordinates according to an OT plan + (wrt squared Euclidean cost after Kabsch alignment) with different implementations of the plan calculation. + + """ + + def __init__( + self, + method: str = "exact", + device: Union[str, torch.device] = "cpu", + num_threads: int = 1, + ) -> None: + """Initialize the OTSampler class. + + Args: + method (str): Choose which optimal transport solver you would like to use. Currently only support exact OT solvers (pot.emd). + device (Union[str, torch.device], optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + num_threads (Union[int, str], optional): Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + + Raises: + ValueError: If the OT solver is not documented. + NotImplementedError: If the OT solver is not implemented. + """ + # ot_fn should take (a, b, M) as arguments where a, b are marginals and + # M is a cost matrix + if method == "exact": + self.ot_fn: Callable[..., torch.Tensor] = partial(pot.emd, numThreads=num_threads) # type: ignore + elif method in {"sinkhorn", "unbalanced", "partial"}: + raise NotImplementedError("OT solver other than 'exact' is not implemented.") + else: + raise ValueError(f"Unknown method: {method}") + self.device = device + + def to_device(self, device: str): + """Moves all internal tensors to the specified device and updates the `self.device` attribute. + + Args: + device (str): The device to move the tensors to (e.g. "cpu", "cuda:0"). + + Note: + This method is used to transfer the internal state of the OTSampler to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + """ + self.device = device + for attr_name in dir(self): + if attr_name.startswith("_") and isinstance(getattr(self, attr_name), torch.Tensor): + setattr(self, attr_name, getattr(self, attr_name).to(device)) + return self + + def sample_map(self, pi: Tensor, batch_size: int, replace: Bool = False) -> Tuple[Tensor, Tensor]: + r"""Draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + pi (Tensor): shape (bs, bs), the OT matrix between noise and data in minibatch. + batch_size (int): The batch size of the minibatch. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + + Returns: + Tuple: tuple of 2 tensors, represents the indices of noise and data samples from pi. + """ + if pi.shape[0] != batch_size or pi.shape[1] != batch_size: + raise ValueError("Shape mismatch: pi.shape = {}, batch_size = {}".format(pi.shape, batch_size)) + p = pi.flatten() + p = p / p.sum() + choices = torch.multinomial(p, batch_size, replacement=replace) + return torch.div(choices, pi.shape[1], rounding_mode="floor"), choices % pi.shape[1] + + def kabsch_align(self, target: Tensor, noise: Tensor) -> Tensor: + """Find the Rotation matrix (R) such that RMSD is minimized between target @ R.T and noise. + + Args: + target (Tensor): shape (N, *dim), data from source minibatch. + noise (Tensor): shape (N, *dim), noise from source minibatch. + + Returns: + R (Tensor): shape (*dim, *dim), the rotation matrix. + """ + dimension = target.shape[-1] + noise_centered = noise - noise.mean(dim=0) + target_centered = target - target.mean(dim=0) + + # Compute the covariance matrix + covariance_matix = target_centered.T @ noise_centered + + # Compute the SVD of the covariance matrix + U, S, Vt = torch.linalg.svd(covariance_matix) + d = torch.sign(torch.linalg.det(Vt.T @ U.T)).item() + d_mat = torch.tensor([1] * (dimension - 1) + [d], device=Vt.device, dtype=Vt.dtype) + R = Vt.T @ torch.diag(d_mat) @ U.T + return R + + def _calculate_cost_matrix(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None) -> Tuple[Tensor, Tensor]: + """Compute the cost matrix between a source and a target minibatch. + + The distance between noise and data is calculated after aligning them using Kabsch algorithm. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + M: shape (bs, bs), the cost matrix between noise and data in minibatch. + Rs: shape (bs, bs, *dim, *dim), the rotation matrix between noise and data in minibatch. + """ + if x0.shape[0] != x1.shape[0]: + raise ValueError("Shape mismatch: x0.shape = {}, x1.shape = {}".format(x0.shape, x1.shape)) + batchsize, maxlen, dimension = x0.shape[0], x0.shape[1], x0.shape[-1] + M = torch.zeros(batchsize, batchsize, device=x0.device) + Rs = torch.zeros(batchsize, batchsize, dimension, dimension, device=x0.device) + for i in range(batchsize): + for j in range(batchsize): + if mask is not None: + x0i_mask = mask[i].bool() + else: + x0i_mask = torch.ones(maxlen, device=x0.device).bool() + x0_masked, x1_masked = x0[i][x0i_mask], x1[j][x0i_mask] + # Rotate the data to align with the noise + R = self.kabsch_align(x1_masked, x0_masked) + x1_aligned = x1_masked @ R.T + # Here the cost only considered the rotational RMSD, not the translational RMSD + cost = torch.dist(x0_masked - x0_masked.mean(dim=0), x1_aligned - x1_aligned.mean(dim=0), p=2) + M[i, j] = cost + Rs[i, j] = R.T + + return M, Rs + + def get_ot_matrix(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None) -> Tuple[Tensor, Tensor]: + """Compute the OT matrix between a source and a target minibatch. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + p (Tensor): shape (bs, bs), the OT matrix between noise and data in minibatch. + Rs (Tensor): shape (bs, bs, *dim, *dim), the rotation matrix between noise and data in minibatch. + """ + # Compute the cost matrix + M, Rs = self._calculate_cost_matrix(x0, x1, mask) + + # Set uniform weights for all samples in a minibatch + a, b = pot.unif(x0.shape[0], type_as=M), pot.unif(x1.shape[0], type_as=M) + + # Compute the OT matrix using POT package + p = self.ot_fn(a, b, M) + + # Handle Exceptions + if not torch.all(torch.isfinite(p)): + raise ValueError("OT plan map is not finite, cost mean, max: {}, {}".format(M.mean(), M.max())) + if torch.abs(p.sum()) < 1e-8: + warnings.warn("Numerical errors in OT matrix, reverting to uniform plan.") + p = torch.ones_like(p) / p.numel() + + return p, Rs + + def apply_ot( + self, + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False, + sort: Optional[Literal["noise", "x0", "data", "x1"]] = "x0", + ) -> Tuple[Tensor, Tensor, Optional[Tensor]]: + r"""Sample indices for noise and data in minibatch according to OT plan. + + Compute the OT plan $\pi$ (wrt squared Euclidean cost after Kabsch alignment) between a source and a target + minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + sort (str): Optional Literal string to sort either x1 or x0 based on the input. + + Returns: + Tuple: tuple of 2 tensors, represents the noise and data samples following OT plan pi. + """ + # Calculate the optimal transport + pi, Rs = self.get_ot_matrix(x0, x1, mask) + + # Sample (x0, x1) mapping indices from the OT matrix + i, j = self.sample_map(pi, x0.shape[0], replace=replace) + + if not replace and (sort == "noise" or sort == "x0"): + sort_idx = torch.argsort(i) + i = i[sort_idx] + j = j[sort_idx] + + if not (i == torch.arange(x0.shape[0], device=i.device)).all(): + raise ValueError("x0_idx should be a tensor from 0 to size - 1 when sort is 'noise' or 'x0") + elif not replace and (sort == "data" or sort == "x1"): + sort_idx = torch.argsort(j) + i = i[sort_idx] + j = j[sort_idx] + + if not (j == torch.arange(x1.shape[0], device=j.device)).all(): + raise ValueError("x1_idx should be a tensor from 0 to size - 1 when sort is 'noise' or 'x0") + + # Get the corresponding rotation matrices + rotations = Rs[i, j, :, :] + noise = x0[i] + # Align the data samples using the rotation matrices + x1_aligned = torch.bmm(x1[j], rotations) + # Returns the true data that has been permuated and rotated. Translations are done either in preprocessing or after the fact. + data = x1_aligned + + if mask is not None: + if mask.device != x0.device: + mask = mask.to(x0.device) + mask = mask[i] + # Output the permuted samples in the minibatch + return noise, data, mask diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/kabsch_augmentation.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/kabsch_augmentation.py new file mode 100644 index 0000000000..c1277be90c --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/kabsch_augmentation.py @@ -0,0 +1,148 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional, Tuple + +import torch +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import pad_like + + +class KabschAugmentation: + """Point-wise Kabsch alignment.""" + + def __init__(self): + """Initialize the KabschAugmentation instance. + + Notes: + - This implementation assumes no required initialization arguments. + - You can add instance variables (e.g., `self.variable_name`) as needed. + """ + pass # No operations are performed when initializing with no args + + def kabsch_align(self, target: Tensor, noise: Tensor): + """Find the Rotation matrix (R) such that RMSD is minimized between target @ R.T and noise. + + Args: + target (Tensor): shape (N, *dim), data from source minibatch. + noise (Tensor): shape (N, *dim), noise from source minibatch. + + Returns: + R (Tensor): shape (*dim, *dim), the rotation matrix. + Aliged Target (Tensor): target tensor rotated and shifted to reduced RMSD with noise + """ + dimension = target.shape[-1] + noise_translation = noise.mean(dim=0) + noise_centered = noise - noise_translation + target_centered = target - target.mean(dim=0) + + # Compute the covariance matrix + covariance_matix = target_centered.T @ noise_centered + + # Compute the SVD of the covariance matrix + U, S, Vt = torch.linalg.svd(covariance_matix) + d = torch.sign(torch.linalg.det(Vt.T @ U.T)).item() + d_mat = torch.tensor([1] * (dimension - 1) + [d], device=Vt.device, dtype=Vt.dtype) + R = Vt.T @ torch.diag(d_mat) @ U.T + + target_aligned = target_centered @ R.T + noise_translation + + return R, target_aligned + + def batch_kabsch_align(self, target: Tensor, noise: Tensor): + """Find the Rotation matrix (R) such that RMSD is minimized between target @ R.T and noise. + + Args: + target (Tensor): shape (N, *dim), data from source minibatch. + noise (Tensor): shape (N, *dim), noise from source minibatch. + + Returns: + R (Tensor): shape (*dim, *dim), the rotation matrix. + Aliged Target (Tensor): target tensor rotated and shifted to reduced RMSD with noise + """ + # Corrected Batched Kabsch Alignment + batch_size, _, dimension = target.shape + + # Center the target and noise tensors along the middle dimension (N) for each batch item + noise_translation = noise.mean(dim=1, keepdim=True) + noise_centered = noise - noise_translation + target_centered = target - target.mean(dim=1, keepdim=True) + + # Compute the covariance matrix for each batch item + covariance_matrix = torch.matmul(target_centered.transpose(1, 2), noise_centered) + + # Compute the SVD of the covariance matrix for each batch item + U, S, Vt = torch.linalg.svd(covariance_matrix) + + # Adjust for proper rotation (determinant=1) for each batch item + d = torch.sign(torch.linalg.det(Vt @ U.transpose(-1, -2))) # Keep as tensor for batch operations + d_mat = torch.diag_embed( + torch.cat( + [torch.ones(batch_size, dimension - 1, device=Vt.device, dtype=Vt.dtype), d.unsqueeze(-1)], dim=-1 + ) + ) + + R_batch = torch.matmul(torch.matmul(Vt.transpose(-1, -2), d_mat), U.transpose(-1, -2)) + + target_aligned = target_centered @ R_batch.transpose(-1, -2) + noise_translation + return R_batch, target_aligned + + def apply_ot( + self, + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + align_noise_to_data=True, + ) -> Tuple[Tensor, Tensor]: + r"""Sample indices for noise and data in minibatch according to OT plan. + + Compute the OT plan $\pi$ (wrt squared Euclidean cost after Kabsch alignment) between a source and a target + minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + align_noise_to_data (bool): Direction of alignment default is True meaning it augments Noise to reduce error to Data. + + Returns: + Tuple: tuple of 2 tensors, represents the noise and data samples following OT plan pi. + """ + if x1.ndim > 2: + align_func = self.batch_kabsch_align + else: + align_func = self.kabsch_align + if mask is not None: + mask = pad_like(mask, x1) + x1 = x1 * mask + x0 = x0 * mask + if align_noise_to_data: + # Compute the rotation matrix R that aligns x0 to x1 + R, aligned_x0 = align_func(x0, x1) + noise = aligned_x0 + data = x1 + else: + # Compute the rotation matrix R that aligns x1 to x0 + R, aligned_x1 = align_func(x1, x0) + noise = x0 + data = aligned_x1 + if mask is not None: + noise = noise * mask + data = data * mask + # Output the permuted samples in the minibatch + return noise, data diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_sampler.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_sampler.py new file mode 100644 index 0000000000..cb977828eb --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_sampler.py @@ -0,0 +1,209 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import warnings +from functools import partial +from typing import Callable, Literal, Optional, Tuple, Union + +import ot as pot +import torch +from jaxtyping import Bool +from torch import Tensor + + +class OTSampler: + """Sampler for Exact Mini-batch Optimal Transport Plan. + + OTSampler implements sampling coordinates according to an OT plan (wrt squared Euclidean cost) + with different implementations of the plan calculation. Code is adapted from https://github.com/atong01/conditional-flow-matching/blob/main/torchcfm/optimal_transport.py + + """ + + def __init__( + self, + method: str = "exact", + device: Union[str, torch.device] = "cpu", + num_threads: int = 1, + ) -> None: + """Initialize the OTSampler class. + + Args: + method (str): Choose which optimal transport solver you would like to use. Currently only support exact OT solvers (pot.emd). + device (Union[str, torch.device], optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + num_threads (Union[int, str], optional): Number of threads to use for OT solver. If "max", uses the maximum number of threads. Default is 1. + + Raises: + ValueError: If the OT solver is not documented. + NotImplementedError: If the OT solver is not implemented. + """ + # ot_fn should take (a, b, M) as arguments where a, b are marginals and + # M is a cost matrix + if method == "exact": + self.ot_fn: Callable[..., torch.Tensor] = partial(pot.emd, numThreads=num_threads) # type: ignore + elif method in {"sinkhorn", "unbalanced", "partial"}: + raise NotImplementedError("OT solver other than 'exact' is not implemented.") + else: + raise ValueError(f"Unknown method: {method}") + self.device = device + + def to_device(self, device: str): + """Moves all internal tensors to the specified device and updates the `self.device` attribute. + + Args: + device (str): The device to move the tensors to (e.g. "cpu", "cuda:0"). + + Note: + This method is used to transfer the internal state of the OTSampler to a different device. + It updates the `self.device` attribute to reflect the new device and moves all internal tensors to the specified device. + """ + self.device = device + for attr_name in dir(self): + if attr_name.startswith("_") and isinstance(getattr(self, attr_name), torch.Tensor): + setattr(self, attr_name, getattr(self, attr_name).to(device)) + return self + + def sample_map(self, pi: Tensor, batch_size: int, replace: Bool = False) -> Tuple[Tensor, Tensor]: + r"""Draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + pi (Tensor): shape (bs, bs), the OT matrix between noise and data in minibatch. + batch_size (int): The batch size of the minibatch. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + + Returns: + Tuple: tuple of 2 tensors, represents the indices of noise and data samples from pi. + """ + if pi.shape[0] != batch_size or pi.shape[1] != batch_size: + raise ValueError("Shape mismatch: pi.shape = {}, batch_size = {}".format(pi.shape, batch_size)) + p = pi.flatten() + p = p / p.sum() + choices = torch.multinomial(p, batch_size, replacement=replace) + return torch.div(choices, pi.shape[1], rounding_mode="floor"), choices % pi.shape[1] + + def _calculate_cost_matrix(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Compute the cost matrix between a source and a target minibatch. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + Tensor: shape (bs, bs), the cost matrix between noise and data in minibatch. + """ + if mask is None: + # Flatten the input tensors + x0, x1 = x0.reshape(x0.shape[0], -1), x1.reshape(x1.shape[0], -1) + + # Compute the cost matrix. For exact OT, we use squared Euclidean distance. + M = torch.cdist(x0, x1) ** 2 + else: + # Initialize the cost matrix + M = torch.zeros((x0.shape[0], x1.shape[0])) + # For each x0 sample, apply its mask to all x1 samples and calculate the cost + for i in range(x0.shape[0]): + x0i_mask = mask[i].unsqueeze(-1) + masked_x1 = x1 * x0i_mask + masked_x0 = x0[i] * x0i_mask + cost = torch.cdist(masked_x0.reshape(1, -1), masked_x1.reshape(x1.shape[0], -1)) ** 2 + M[i] = cost + return M + + def get_ot_matrix(self, x0: Tensor, x1: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Compute the OT matrix between a source and a target minibatch. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + + Returns: + p (Tensor): shape (bs, bs), the OT matrix between noise and data in minibatch. + + """ + # Compute the cost matrix + M = self._calculate_cost_matrix(x0, x1, mask) + # Set uniform weights for all samples in a minibatch + a, b = pot.unif(x0.shape[0], type_as=M), pot.unif(x1.shape[0], type_as=M) + + p = self.ot_fn(a, b, M) + # Handle exceptions + if not torch.all(torch.isfinite(p)): + raise ValueError("OT plan map is not finite, cost mean, max: {}, {}".format(M.mean(), M.max())) + if torch.abs(p.sum()) < 1e-8: + warnings.warn("Numerical errors in OT matrix, reverting to uniform plan.") + p = torch.ones_like(p) / p.numel() + + return p + + def apply_ot( + self, + x0: Tensor, + x1: Tensor, + mask: Optional[Tensor] = None, + replace: Bool = False, + sort: Optional[Literal["noise", "x0", "data", "x1"]] = "x0", + ) -> Tuple[Tensor, Tensor, Optional[Tensor]]: + r"""Sample indices for noise and data in minibatch according to OT plan. + + Compute the OT plan $\pi$ (wrt squared Euclidean cost) between a source and a target + minibatch and draw source and target samples from pi $(x,z) \sim \pi$. + + Args: + x0 (Tensor): shape (bs, *dim), noise from source minibatch. + x1 (Tensor): shape (bs, *dim), data from source minibatch. + mask (Optional[Tensor], optional): mask to apply to the output, shape (batchsize, nodes), if not provided no mask is applied. Defaults to None. + replace (bool): sampling w/ or w/o replacement from the OT plan, default to False. + sort (str): Optional Literal string to sort either x1 or x0 based on the input. + + Returns: + Tuple: tuple of 2 tensors or 3 tensors if mask is used, represents the noise (plus mask) and data samples following OT plan pi. + """ + if replace and sort is not None: + raise ValueError("Cannot sample with replacement and sort") + # Calculate the optimal transport + pi = self.get_ot_matrix(x0, x1, mask) + + # Sample (x0, x1) mapping indices from the OT matrix + i, j = self.sample_map(pi, x0.shape[0], replace=replace) + if not replace and (sort == "noise" or sort == "x0"): + sort_idx = torch.argsort(i) + i = i[sort_idx] + j = j[sort_idx] + + if not (i == torch.arange(x0.shape[0], device=i.device)).all(): + raise ValueError("x0_idx should be a tensor from 0 to size - 1 when sort is 'noise' or 'x0") + noise = x0 + data = x1[j] + elif not replace and (sort == "data" or sort == "x1"): + sort_idx = torch.argsort(j) + i = i[sort_idx] + j = j[sort_idx] + + if not (j == torch.arange(x1.shape[0], device=j.device)).all(): + raise ValueError("x1_idx should be a tensor from 0 to size - 1 when sort is 'noise' or 'x0") + noise = x0[i] + data = x1 + else: + noise = x0[i] + data = x1[j] + + # Output the permuted samples in the minibatch + if mask is not None: + if mask.device != x0.device: + mask = mask.to(x0.device) + mask = mask[i] + return noise, data, mask diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_types.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_types.py new file mode 100644 index 0000000000..bbe58fe2c1 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/optimal_transport/ot_types.py @@ -0,0 +1,32 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from enum import Enum + + +class OptimalTransportType(Enum): + """An enumeration representing the type ofOptimal Transport that can be used in Continuous Flow Matching. + + - **EXACT**: Standard mini batch optimal transport defined in https://arxiv.org/pdf/2302.00482. + - **EQUIVARIANT**: Adding roto/translation optimization to mini batch OT see https://arxiv.org/pdf/2306.15030 https://arxiv.org/pdf/2312.07168 4.2. + - **KABSCH**: Simple Kabsch alignment between each data and noise point, No permuation # https://arxiv.org/pdf/2410.22388 Sec 3.2 + + These prediction types can be used to train neural networks for specific tasks, such as denoising, image synthesis, or time-series forecasting. + """ + + EXACT = "exact" + EQUIVARIANT = "equivariant" + KABSCH = "kabsch" diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py new file mode 100644 index 0000000000..fe9f395453 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/vdm.py @@ -0,0 +1,515 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import warnings +from typing import Callable, Optional, Union + +import torch +import torch.nn as nn +import torch.nn.functional as F +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, PredictionType, pad_like, string_to_enum +from bionemo.moco.schedules.noise.continuous_snr_transforms import ContinuousSNRTransform + + +class VDM(Interpolant): + """A Variational Diffusion Models (VDM) interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.discrete_time.continuous.vdm import VDM + >>> from bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform + >>> from bionemo.moco.schedules.inference_time_schedules import LinearInferenceSchedule + + + vdm = VDM( + time_distribution = UniformTimeDistribution(...), + prior_distribution = GaussianPrior(...), + noise_schedule = CosineSNRTransform(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = vdm.sample_time(batch_size) + noise = vdm.sample_prior(data.shape) + xt = vdm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = vdm.loss(x_pred, data, time) + loss.backward() + + # Generation + x_pred = vdm.sample_prior(data.shape) + for t in LinearInferenceSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = vdm.step(x_hat, time, x_pred) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: ContinuousSNRTransform, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the DDPM interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + noise_schedule (ContinuousSNRTransform): The schedule of noise, defining the amount of noise added at each time step. + prediction_type (PredictionType, optional): The type of prediction, either "data" or another type. Defaults to "data". + device (str, optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + if not isinstance(prior_distribution, GaussianPrior): + warnings.warn("Prior distribution is not a GaussianPrior, unexpected behavior may occur") + self.noise_schedule = noise_schedule + self.prediction_type = string_to_enum(prediction_type, PredictionType) + self._loss_function = nn.MSELoss(reduction="none") + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor): noise from prior() + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + psi, omega = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + psi = pad_like(psi, data) + omega = pad_like(omega, data) + x_t = data * psi + noise * omega + return x_t + + def forward_process(self, data: Tensor, t: Tensor, noise: Optional[Tensor] = None): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor, optional): noise from prior(). Defaults to None + """ + if noise is None: + noise = self.sample_prior(data.shape) + return self.interpolate(data, t, noise) + + def process_data_prediction(self, model_output: Tensor, sample, t): + """Converts the model output to a data prediction based on the prediction type. + + This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. + Given the model output and the sample, we convert the output to a data prediction based on the prediction type. + The conversion formulas are as follows: + - For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` + - For "data" prediction type: `pred_data = model_output` + - For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + + Args: + model_output (Tensor): The output of the model. + sample (Tensor): The input sample. + t (Tensor): The time step. + + Returns: + The data prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not one of "noise", "data", or "v_prediction". + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + data_scale, noise_scale = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_data = (sample - noise_scale * model_output) / data_scale + elif self.prediction_type == PredictionType.DATA: + pred_data = model_output + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of PredictionType.NOISE, PredictionType.DATA or" + f" PredictionType.VELOCITY for vdm." + ) + return pred_data + + def process_noise_prediction(self, model_output: Tensor, sample: Tensor, t: Tensor): + """Do the same as process_data_prediction but take the model output and convert to nosie. + + Args: + model_output (Tensor): The output of the model. + sample (Tensor): The input sample. + t (Tensor): The time step. + + Returns: + The input as noise if the prediction type is "noise". + + Raises: + ValueError: If the prediction type is not "noise". + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + data_scale, noise_scale = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_noise = model_output + elif self.prediction_type == PredictionType.DATA: + pred_noise = (sample - data_scale * model_output) / noise_scale + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + pred_noise = (sample - data_scale * pred_data) / noise_scale + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of `noise`, `data` or" + " `v_prediction` for vdm." + ) + return pred_noise + + def step( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ): + """Do one step integration. + + Args: + model_out (Tensor): The output of the model. + xt (Tensor): The current data point. + t (Tensor): The current time step. + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool): Whether to center the data. Defaults to False. + temperature (Float): The temperature parameter for low temperature sampling. Defaults to 1.0. + + Note: + The temperature parameter controls the trade off between diversity and sample quality. + Decreasing the temperature sharpens the sampling distribtion to focus on more likely samples. + The impact of low temperature sampling must be ablated analytically. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + alpha_t, sigma_t = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + + if (t - dt < 0).any(): + raise ValueError( + "Error in inference schedule: t - dt < 0. Please ensure that your inference time schedule has shape T with the final t = dt to make s = 0" + ) + + log_snr_s = self.noise_schedule.calculate_log_snr(t - dt, device=self.device) + alpha_s, sigma_s = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr_s) + sigma_s_2 = sigma_s * sigma_s + sigma_t_2 = sigma_t * sigma_t + alpha_t_s = alpha_t / alpha_s + sigma_2_t_s = -torch.expm1(F.softplus(-log_snr_s) - F.softplus(-log_snr)) # Equation 63 + + omega_r = alpha_t_s * sigma_s_2 / sigma_t_2 # Equation 28 + psi_r = alpha_s * sigma_2_t_s / sigma_t_2 + std = sigma_2_t_s.sqrt() * sigma_s / sigma_t + nonzero_mask = ( + t > 0 + ).float() # based on the time this is always just ones. can leave for now to see if ever want to take extra step and only grab mean + + psi_r = pad_like(psi_r, x_hat) + omega_r = pad_like(omega_r, x_hat) + std = pad_like(std, x_hat) + nonzero_mask = pad_like(nonzero_mask, x_hat) + + mean = psi_r * x_hat + omega_r * xt + eps = torch.randn_like(mean).to(model_out.device) + x_next = mean + nonzero_mask * std * eps * temperature + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def score(self, x_hat: Tensor, xt: Tensor, t: Tensor): + """Converts the data prediction to the estimated score function. + + Args: + x_hat (tensor): The predicted data point. + xt (Tensor): The current data point. + t (Tensor): The time step. + + Returns: + The estimated score function. + """ + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + psi, omega = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + psi = pad_like(psi, x_hat) + omega = pad_like(omega, x_hat) + score = psi * x_hat - xt + score = score / (omega * omega) + return score + + def step_ddim( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False, + ): + """Do one step of DDIM sampling. + + From the ddpm equations alpha_bar = alpha**2 and 1 - alpha**2 = sigma**2 + + Args: + model_out (Tensor): output of the model + t (Tensor): current time step + xt (Tensor): current data point + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): mask for the data point. Defaults to None. + eta (Float, optional): DDIM sampling parameter. Defaults to 0.0. + center (Bool, optional): whether to center the data point. Defaults to False. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + data_pred = self.process_data_prediction(model_out, xt, t) + noise_pred = self.process_noise_prediction(model_out, xt, t) + eps = torch.randn_like(data_pred).to(model_out.device) + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + squared_alpha = log_snr.sigmoid() + squared_sigma = (-log_snr).sigmoid() + log_snr_prev = self.noise_schedule.calculate_log_snr(t - dt, device=self.device) + squared_alpha_prev = log_snr_prev.sigmoid() + squared_sigma_prev = (-log_snr_prev).sigmoid() + sigma_t_2 = squared_sigma_prev / squared_sigma * (1 - squared_alpha / squared_alpha_prev) + psi_r = torch.sqrt(squared_alpha_prev) + omega_r = torch.sqrt(1 - squared_alpha_prev - eta * eta * sigma_t_2) + + sigma_t_2 = pad_like(sigma_t_2, model_out) + psi_r = pad_like(psi_r, model_out) + omega_r = pad_like(omega_r, model_out) + + mean = data_pred * psi_r + omega_r * noise_pred + x_next = mean + eta * sigma_t_2.sqrt() * eps + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def set_loss_weight_fn(self, fn: Callable): + """Sets the loss_weight attribute of the instance to the given function. + + Args: + fn: The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + """ + self.loss_weight = fn + + def loss_weight(self, raw_loss: Tensor, t: Tensor, weight_type: str, dt: Float = 0.001) -> Tensor: + """Calculates the weight for the loss based on the given weight type. + + This function computes the loss weight according to the specified `weight_type`. + The available weight types are: + - "ones": uniform weight of 1.0 + - "data_to_noise": derived from Equation (9) of https://arxiv.org/pdf/2202.00512 + - "variational_objective": based on the variational objective, see https://arxiv.org/pdf/2202.00512 + + Args: + raw_loss (Tensor): The raw loss calculated from the model prediction and target. + t (Tensor): The time step. + weight_type (str): The type of weight to use. Can be "ones", "data_to_noise", or "variational_objective". + dt (Float, optional): The time step increment. Defaults to 0.001. + + Returns: + Tensor: The weight for the loss. + + Raises: + ValueError: If the weight type is not recognized. + """ + if weight_type == "ones": + schedule = torch.ones_like(raw_loss).to(raw_loss.device) + elif weight_type == "data_to_noise": # + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + psi, omega = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + schedule = (psi**2) / (omega**2) + for _ in range(raw_loss.ndim - 1): + schedule = schedule.unsqueeze(-1) + elif weight_type == "variational_objective": + # (1-SNR(t-1)/SNR(t)), + snr = torch.exp(self.noise_schedule.calculate_log_snr(t, device=self.device)) + snr_m1 = torch.exp(self.noise_schedule.calculate_log_snr(t - dt, device=self.device)) + schedule = 1 - snr_m1 / snr + for _ in range(raw_loss.ndim - 1): + schedule = schedule.unsqueeze(-1) + else: + raise ValueError("Invalid loss weight keyword") + return schedule + + def loss( + self, + model_pred: Tensor, + target: Tensor, + t: Tensor, + dt: Optional[Float] = 0.001, + mask: Optional[Tensor] = None, + weight_type: str = "ones", + ): + """Calculates the loss given the model prediction, target, and time. + + Args: + model_pred (Tensor): The predicted output from the model. + target (Tensor): The target output for the model prediction. + t (Tensor): The time at which the loss is calculated. + dt (Optional[Float], optional): The time step increment. Defaults to 0.001. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + weight_type (str, optional): The type of weight to use for the loss. Can be "ones", "data_to_noise", or "variational_objective". Defaults to "ones". + + Returns: + Tensor: The calculated loss batch tensor. + """ + raw_loss = self._loss_function(model_pred, target) + update_weight = self.loss_weight(raw_loss, t, weight_type, dt) + loss = raw_loss * update_weight + if mask is not None: + loss = loss * mask.unsqueeze(-1) + n_elem = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / n_elem + else: + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / model_pred.size(1) + return loss + + def step_hybrid_sde( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + equilibrium_rate: Float = 0.0, + ) -> Tensor: + """Do one step integration of Hybrid Langevin-Reverse Time SDE. + + See section B.3 page 37 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. + and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + + Args: + model_out (Tensor): The output of the model. + xt (Tensor): The current data point. + t (Tensor): The current time step. + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + equilibrium_rate (Float, optional): The rate of Langevin equilibration. Scales the amount of Langevin dynamics per unit time. Best values are in the range [1.0, 5.0]. Defaults to 0.0. + + Note: + For all step functions that use the SDE formulation its important to note that we are moving backwards in time which corresponds to an apparent sign change. + A clear example can be seen in slide 29 https://ernestryu.com/courses/FM/diffusion1.pdf. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + alpha, sigma = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + # Schedule coeffiecients + beta = self.noise_schedule.calculate_beta(t) + inverse_temperature = 1 / temperature # lambda_0 + langevin_factor = equilibrium_rate + # Temperature coefficients + lambda_t = ( + inverse_temperature * (sigma.pow(2) + alpha.pow(2)) / (inverse_temperature * sigma.pow(2) + alpha.pow(2)) + ) + # langevin_isothermal = True + lambda_langevin = inverse_temperature # if langevin_isothermal else lambda_t + + score_scale_t = lambda_t + lambda_langevin * langevin_factor / 2.0 + + eps = torch.randn_like(x_hat).to(model_out.device) + score = self.score(x_hat, xt, t) + beta = pad_like(beta, model_out) + score_scale_t = pad_like(score_scale_t, model_out) + + gT = beta * ((-1 / 2) * xt - score_scale_t * score) + gW = torch.sqrt((1.0 + langevin_factor) * beta.abs()) * eps + + x_next = xt + dt * gT + dt.sqrt() * gW + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def step_ode( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ) -> Tensor: + """Do one step integration of ODE. + + See section B page 36 https://www.biorxiv.org/content/10.1101/2022.12.01.518682v1.full.pdf. + and https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L730 + + Args: + model_out (Tensor): The output of the model. + xt (Tensor): The current data point. + t (Tensor): The current time step. + dt (Tensor): The time step increment. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + log_snr = self.noise_schedule.calculate_log_snr(t, device=self.device) + alpha, sigma = self.noise_schedule.log_snr_to_alphas_sigmas(log_snr) + # Schedule coeffiecients + beta = self.noise_schedule.calculate_beta(t) + inverse_temperature = 1 / temperature + # Temperature coefficients + lambda_t = ( + inverse_temperature * (sigma.pow(2) + alpha.pow(2)) / (inverse_temperature * sigma.pow(2) + alpha.pow(2)) + ) + + score = self.score(x_hat, xt, t) + beta = pad_like(beta, model_out) + lambda_t = pad_like(lambda_t, model_out) + + gT = (-1 / 2) * beta * (xt + lambda_t * score) + + x_next = xt + gT * dt + x_next = self.clean_mask_center(x_next, mask, center) + return x_next diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py new file mode 100644 index 0000000000..7b649d9135 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/discrete_flow_matching.py @@ -0,0 +1,352 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, pad_like + + +class DiscreteFlowMatcher(Interpolant): + """A Discrete Flow Model (DFM) interpolant.""" + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + device: str = "cpu", + eps: Float = 1e-5, + rng_generator: Optional[torch.Generator] = None, + ): + """Initialize the DFM interpolant. + + Args: + time_distribution (TimeDistribution): The time distribution for the diffusion process. + prior_distribution (DiscretePriorDistribution): The prior distribution for the discrete masked tokens. + device (str, optional): The device to use for computations. Defaults to "cpu". + eps: small Float to prevent dividing by zero. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + self.num_classes = prior_distribution.num_classes + self.eps = eps + self.use_mask = isinstance(self.prior_distribution, DiscreteMaskedPrior) + if self.use_mask: + self.mask_index = prior_distribution.mask_dim # type: ignore + self._loss_function = nn.CrossEntropyLoss(reduction="none") + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + noise: tensor noise ids + """ + if data.dtype == torch.float and data.ndim > 2: + x1 = data.argmax(-1) + else: + x1 = data + x0 = noise + t = pad_like(t, x1) + threshold = torch.rand_like(x1.float()) + xt = torch.where((threshold < 1 - t), x0, x1) + return xt + + def loss( + self, + logits: Tensor, + target: Tensor, + time: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + use_weight: Bool = False, + ): + """Calculate the cross-entropy loss between the model prediction and the target output. + + The loss is calculated between the batch x node x class logits and the target batch x node. + If using a masked prior please pass in the correct mask to calculate loss values on only masked states. + i.e. mask = data_mask * is_masked_state which is calculated with self.prior_dist.is_masked(xt)) + + If `use_weight` is True, the loss is weighted by 1/(1-t) defined in equation 24 in Appndix C. of https://arxiv.org/pdf/2402.04997 + + Args: + logits (Tensor): The predicted output from the model, with shape batch x node x class. + target (Tensor): The target output for the model prediction, with shape batch x node. + time (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + use_weight (bool, optional): Whether to use the DFM time weight for the loss. Defaults to True. + + Returns: + Tensor: The calculated loss batch tensor. + """ + assert target.ndim + 1 == logits.ndim + loss = self._loss_function(logits.transpose(-1, 1), target.long()) + if mask is not None: + loss = loss * mask + num_non_masked_elements = torch.sum(mask, dim=-1) + num_non_masked_elements[num_non_masked_elements == 0] = ( + 1.0 #! prevents divide by zero since if the row is all zero the sum of loss = 0 + ) + loss = torch.sum(loss, dim=(-1)) / num_non_masked_elements + else: + loss = torch.sum(loss, dim=(-1)) / logits.size(1) + if use_weight: + if time is None: + raise ValueError("Time is required to compute the DFM liklehood weighting of 1/(1-t + self.eps)") + loss = loss * 1 / (1 - time + self.eps) + return loss + + def step( + self, + logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0, + ) -> Tensor: + """Perform a single step of DFM euler updates. + + Args: + logits (Tensor): The input logits. + t (Tensor): The current time step. + xt (Tensor): The current state. + dt (Tensor | float): The time step increment. + temperature (Float, optional): The temperature for the softmax calculation. Defaults to 1.0. + stochasticity (Float, optional): The stochasticity value for the step calculation. Defaults to 1.0. + + Returns: + Tensor: The updated state. + """ + x_1_pred_logits = logits + S = x_1_pred_logits.shape[-1] + t = pad_like(t, logits) + if isinstance(dt, float): + dt = torch.Tensor([dt] * t.shape[0]).to(self.device) + dt = pad_like(dt, logits) # type: ignore + + if self.use_mask: + if self.mask_index >= S: + raise ValueError( + "If using a non inclusive DiscreteMaskedPrior initialization, please pad the logits input with DiscreteMaskedPrior.pad_sample(logits)" + ) + + mask_one_hot = torch.zeros((S,), device=self.device) + mask_one_hot[self.mask_index] = 1.0 + x_1_pred_logits[..., self.mask_index] = -1.0e9 + + x_1_pred_prob = F.softmax(x_1_pred_logits / temperature, dim=-1) + + xt_is_mask = (xt == self.mask_index).unsqueeze(-1).float() # b x n x 1 + step_prob = ( + dt * x_1_pred_prob * ((1 + stochasticity * t) / (1 - t)) * xt_is_mask + + dt + * (1 - xt_is_mask) + * mask_one_hot.view(1, 1, -1) + * stochasticity + * ( + t + dt < 1 + ).float() # No remasking if on final step. NOTE should probably use step_argmax or step_sample instead + ) # (b, n, S) + step_prob = self._regularize_step_probs(step_prob, xt) + else: + x_1_pred_prob = torch.nn.functional.softmax(x_1_pred_logits / temperature, dim=-1) # (b, n, S) + + pt_x1_eq_xt_prob = torch.gather(x_1_pred_prob, dim=-1, index=xt.long().unsqueeze(-1)) # (b, n, 1) + + step_prob = ( + dt * x_1_pred_prob * ((1 + stochasticity + stochasticity * (S - 1) * t) / (1 - t)) + + dt * pt_x1_eq_xt_prob * stochasticity + ) + step_prob = self._regularize_step_probs(step_prob, xt) + + x_next = torch.multinomial(step_prob.view(-1, S), num_samples=1, generator=self.rng_generator).view(xt.shape) + return x_next + + def _regularize_step_probs(self, step_prob: Tensor, xt: Tensor) -> Tensor: + """Regularize the step probabilities to ensure that the probability of the current state xt is set to the remaining probability mass after clipping and scattering. + + Args: + step_prob (Tensor): The input step probabilities with shape (batch, node, class). + xt (Tensor): The current state with shape (batch, node). + + Returns: + Tensor: The regularized step probabilities with shape (batch, node, class). + """ + device = step_prob.device + # Clamp the step probabilities to ensure they are within the valid range [0.0, 1.0] + step_prob = torch.clamp(step_prob, min=0.0, max=1.0) + # Set the probability of the current state xt to 0 + step_prob.scatter_( + dim=-1, + index=xt.unsqueeze(-1), + src=torch.zeros((*xt.shape, 1), dtype=torch.float, device=device), + ) + # Set the probability of the current state xt to the remaining probability mass + step_prob.scatter_( + dim=-1, + index=xt[..., None], + src=1 - torch.sum(step_prob, dim=-1, keepdim=True), + ) + step_prob = torch.clamp(step_prob, min=0.0, max=1.0) + # Clamp the step probabilities again to ensure they are within the valid range [0.0, 1.0] + return step_prob + + def step_purity( + self, + logits: Tensor, + t: Tensor, + xt: Tensor, + dt: Tensor | float, + temperature: Float = 1.0, + stochasticity: Float = 1.0, + ) -> Tensor: + """Perform a single step of purity sampling. + + https://github.com/jasonkyuyim/multiflow/blob/6278899970523bad29953047e7a42b32a41dc813/multiflow/data/interpolant.py#L346 + Here's a high-level overview of what the function does: + TODO: check if the -1e9 and 1e-9 are small enough or using torch.inf would be better + + 1. Preprocessing: + Checks if dt is a float and converts it to a tensor if necessary. + Pads t and dt to match the shape of xt. + Checks if the mask_index is valid (i.e., within the range of possible discrete values). + 2. Masking: + Sets the logits corresponding to the mask_index to a low value (-1e9) to effectively mask out those values. + Computes the softmax probabilities of the logits. + Sets the probability of the mask_index to a small value (1e-9) to avoid numerical issues. + 3.Purity sampling: + Computes the maximum log probabilities of the softmax distribution. + Computes the indices of the top-number_to_unmask samples with the highest log probabilities. + Uses these indices to sample new values from the original distribution. + 4. Unmasking and updating: + Creates a mask to select the top-number_to_unmask samples. + Uses this mask to update the current state xt with the new samples. + 5. Re-masking: + Generates a new mask to randomly re-mask some of the updated samples. + Applies this mask to the updated state xt. + + Args: + logits (Tensor): The input logits. + t (Tensor): The current time step. + xt (Tensor): The current state. + dt (Tensor): The time step increment. + temperature (Float, optional): The temperature for the softmax calculation. Defaults to 1.0. + stochasticity (Float, optional): The stochasticity value for the step calculation. Defaults to 1.0. + + Returns: + Tensor: The updated state. + """ + if logits.ndim > 3: + raise ValueError("Purity Sampling is only implmented for logits shape batch x sequence x state space.") + if isinstance(dt, float): + dt = torch.Tensor([dt] * t.shape[0]).to(self.device) + x_1_pred_logits = logits + B, N, S = x_1_pred_logits.shape + + if not self.use_mask: + raise ValueError("Purity Sampling only works with a DiscreteMaskPrior") + + if self.mask_index >= S: + raise ValueError( + "If using a non inclusive DiscreteMaskedPrior initialization, please pad the logits input with DiscreteMaskedPrior.pad_sample(logits)" + ) + x_1_pred_logits[..., self.mask_index] = -1.0e9 + x_1_pred_prob = F.softmax(x_1_pred_logits / temperature, dim=-1) + x_1_pred_prob[..., self.mask_index] = 1e-9 + max_logprob = torch.max(torch.log(x_1_pred_prob), dim=-1)[0] # (b, n) + max_logprob = max_logprob - (xt != self.mask_index).float() * 1e9 + sorted_max_logprobs_idcs = torch.argsort(max_logprob, dim=-1, descending=True) # (b, n) + unmask_probs = (dt * (1 + stochasticity * t) / (1 - t)).clamp(max=1) + # For M mask tokens we have p chance to unmask so we try for each one and see how many to do + number_to_unmask = torch.binomial( + count=torch.count_nonzero(xt == self.mask_index, dim=-1).float(), prob=unmask_probs + ) + unmasked_samples = torch.multinomial(x_1_pred_prob.view(-1, S), num_samples=1).view(xt.shape) + + # Taken from MultiFlow + # Vectorized version of: + # for b in range(B): + # for d in range(D): + # if d < number_to_unmask[b]: + # aatypes_t[b, d] = unmasked_samples[b, sorted_max_logprobs_idcs[b, d]] + + D_grid = torch.arange(N, device=self.device).view(1, -1).repeat(B, 1) + mask1 = (D_grid < number_to_unmask.view(-1, 1)).float() + initial_val_max_logprob_idcs = sorted_max_logprobs_idcs[:, 0].view(-1, 1).repeat(1, N) + masked_sorted_max_logprobs_idcs = ( + mask1 * sorted_max_logprobs_idcs + (1 - mask1) * initial_val_max_logprob_idcs + ).long() + mask2 = torch.zeros((B, N), dtype=torch.long, device=self.device) + mask2.scatter_( + dim=1, + index=masked_sorted_max_logprobs_idcs, + src=torch.ones((B, N), dtype=torch.long, device=self.device), + ) + unmask_zero_row = (number_to_unmask == 0).view(-1, 1).repeat(1, N).long() + mask2 = mask2 * (1 - unmask_zero_row) + x_next = xt * (1 - mask2) + unmasked_samples * mask2 + + # re-mask + u = torch.rand((B, N), device=self.device, generator=self.rng_generator) + dt = pad_like(dt, u) # type: ignore + re_mask_mask = (u < dt * stochasticity).long() + x_next = x_next * (1 - re_mask_mask) + self.mask_index * re_mask_mask + + return x_next + + def step_argmax(self, model_out: Tensor): + """Returns the index of the maximum value in the last dimension of the model output. + + Args: + model_out (Tensor): The output of the model. + + """ + if self.use_mask: + model_out[..., self.mask_index] = -1.0e9 + return model_out.argmax(dim=-1) + + def step_simple_sample(self, model_out: Tensor, temperature: float = 1.0, num_samples: int = 1): + """Samples from the model output logits. Leads to more diversity than step_argmax. + + Args: + model_out (Tensor): The output of the model. + temperature (Float, optional): The temperature for the softmax calculation. Defaults to 1.0. + num_samples (int): Number of samples to return + + """ + if self.use_mask: + model_out[..., self.mask_index] = -1.0e9 + samples = torch.multinomial( + torch.nn.functional.softmax(model_out / temperature, dim=-1).view(-1, self.num_classes), + num_samples=num_samples, + generator=self.rng_generator, + ) # batch * seq_len x num_samples + if num_samples == 1: + samples = samples.view(*model_out.shape[:-1]) + # batch x seq_len + else: + samples = samples.view((*model_out.shape[:-1], num_samples)) + # batch x seq_len x num_samples + return samples diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py new file mode 100644 index 0000000000..4fdeda3aa1 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py @@ -0,0 +1,374 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from typing import Optional + +import torch +from torch import Tensor + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, pad_like +from bionemo.moco.schedules.noise.continuous_noise_transforms import ContinuousExpNoiseTransform + + +class MDLM(Interpolant): + """A Masked discrete Diffusion Language Model (MDLM) interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.continuous_time.discrete.mdlm import MDLM + >>> from bionemo.moco.schedules.noise.continuous_noise_transforms import CosineExpNoiseTransform + >>> from bionemo.moco.schedules.inference_time_schedules import LinearTimeSchedule + + + mdlm = MDLM( + time_distribution = UniformTimeDistribution(discrete_time = False,...), + prior_distribution = DiscreteMaskedPrior(...), + noise_schedule = CosineExpNoiseTransform(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = mdlm.sample_time(batch_size) + xt = mdlm.interpolate(data, time) + + logits = model(xt, time) + loss = mdlm.loss(logits, data, xt, time) + loss.backward() + + # Generation + x_pred = mdlm.sample_prior(data.shape) + schedule = LinearTimeSchedule(...) + inference_time = schedule.generate_schedule() + dts = schedue.discreteize() + for t, dt in zip(inference_time, dts): + time = torch.full((batch_size,), t) + logits = model(x_pred, time) + x_pred = mdlm.step(logits, time, x_pred, dt) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: DiscreteMaskedPrior, + noise_schedule: ContinuousExpNoiseTransform, + device: str = "cpu", + rng_generator: Optional[torch.Generator] = None, + ): + """Initialize the Masked Discrete Language Model (MDLM) interpolant. + + Args: + time_distribution (TimeDistribution): The distribution governing the time variable in the diffusion process. + prior_distribution (DiscreteMaskedPrior): The prior distribution over the discrete token space, including masked tokens. + noise_schedule (ContinuousExpNoiseTransform): The noise schedule defining the noise intensity as a function of time. + device (str, optional): The device to use for computations. Defaults to "cpu". + rng_generator (Optional[torch.Generator], optional): The random number generator for reproducibility. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + if not isinstance(prior_distribution, DiscreteMaskedPrior): + raise ValueError("DiscreteMaskedPrior required for MDLM") + if not isinstance(noise_schedule, ContinuousExpNoiseTransform): + raise ValueError("ContinuousExpNoiseTransform required for MDLM") + self.noise_schedule = noise_schedule + self.num_classes = prior_distribution.num_classes + self.mask_index = prior_distribution.mask_dim + # Gumbel used for confidence sampling. Note rng_generator not compatible with torch.Distribution. + # self.gumbel_dist = torch.distributions.Gumbel(torch.tensor(0.0), torch.tensor(1.0)) + + def interpolate(self, data: Tensor, t: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + """ + if data.dtype == torch.float and data.ndim > 2: + x0 = data.argmax(-1) + else: + x0 = data + sigma = self.noise_schedule.calculate_sigma(t, data.device) + alpha = self.noise_schedule.sigma_to_alpha(sigma) + p_mask = 1 - alpha + p_mask = pad_like(p_mask, x0) + mask_indices = torch.rand(*x0.shape, device=x0.device, generator=self.rng_generator) < p_mask + xt = torch.where(mask_indices, self.mask_index, x0) + return xt + + def forward_process(self, data: Tensor, t: Tensor) -> Tensor: + """Apply the forward process to the data at time t. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + + Returns: + Tensor: x(t) after applying the forward process + """ + return self.interpolate(data, t) + + def loss( + self, + logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + use_weight=True, + ): + """Calculate the cross-entropy loss between the model prediction and the target output. + + The loss is calculated between the batch x node x class logits and the target batch x node, + considering the current state of the discrete sequence `xt` at time `time`. + + If `use_weight` is True, the loss is weighted by the reduced form of the MDLM time weight for continuous NELBO, + as specified in equation 11 of https://arxiv.org/pdf/2406.07524. This weight is proportional to the derivative + of the noise schedule with respect to time, and is used to emphasize the importance of accurate predictions at + certain times in the diffusion process. + + Args: + logits (Tensor): The predicted output from the model, with shape batch x node x class. + target (Tensor): The target output for the model prediction, with shape batch x node. + xt (Tensor): The current state of the discrete sequence, with shape batch x node. + time (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + use_weight (bool, optional): Whether to use the MDLM time weight for the loss. Defaults to True. + + Returns: + Tensor: The calculated loss batch tensor. + """ + logprobs = self._subs_parameterization(logits, xt) + log_p_theta = torch.gather(input=logprobs, dim=-1, index=target[..., None]).squeeze(-1) + + sigma = self.noise_schedule.calculate_sigma(time, target.device) + dsigma = self.noise_schedule.d_dt_sigma(time, target.device) # type: ignore + loss = -log_p_theta + if use_weight: + loss = loss * (dsigma / torch.expm1(sigma))[:, None] + + if mask is not None: + loss = loss * mask + num_non_masked_elements = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=(-1)) / num_non_masked_elements + else: + loss = torch.sum(loss, dim=(-1)) / logits.size(1) + return loss + + def _subs_parameterization(self, logits: Tensor, xt: Tensor) -> Tensor: + """Apply subsititution parameterization to the logits. + + This function enforces that the model can never predict a mask token by lowering the mask logits. + Then, for all unmasked tokens, it copies over from xt to enable carry over unmasked. + Once a token is unmasked, it stays the same. + See Sec. 3.2.3 https://arxiv.org/pdf/2406.07524. + + Note that recent work has shown that allowing the model to rethink + carry over unmasking is beneficial https://arxiv.org/abs/2410.06264. + + Args: + logits (Tensor): The logits tensor with shape batch x node x class. + xt (Tensor): The tensor of unmasked tokens with shape batch x node. + + Returns: + Tensor: The modified logits tensor with substitution parameterization applied. + """ + logits[..., self.mask_index] += -1000000.0 # clean input is never masked + logprobs = logits - torch.logsumexp(logits, dim=-1, keepdim=True) # normalize + unmasked_indices = xt != self.mask_index + logprobs[unmasked_indices] = -1000000.0 + logprobs[unmasked_indices, xt[unmasked_indices]] = 0 # Unmasked token remains unchanged + return logprobs + + def step(self, logits: Tensor, t: Tensor, xt: Tensor, dt: Tensor, temperature: float = 1.0) -> Tensor: + """Perform a single step of MDLM DDPM step. + + Parameters: + logits (Tensor): The input logits. + t (Tensor): The current time step. + xt (Tensor): The current state. + dt (Tensor): The time step increment. + temperature (float): Softmax temperature defaults to 1.0. + + Returns: + Tensor: The updated state. + """ + sigma_t = self.noise_schedule.calculate_sigma(t, logits.device) + sigma_s = self.noise_schedule.calculate_sigma(t - dt, logits.device) + alpha_t = torch.exp(-sigma_t) + alpha_s = torch.exp(-sigma_s) + p_mask_s = 1 - alpha_s + alpha_t = pad_like(alpha_t, logits) + alpha_s = pad_like(alpha_s, logits) + p_mask_s = pad_like(p_mask_s, logits) + # Apply subs parameterization + log_p_x0 = self._subs_parameterization(logits, xt) / temperature + if p_mask_s.ndim != log_p_x0.ndim: + raise ValueError(f"Dimension Mistmatch {p_mask_s.shape} {log_p_x0.shape}") + # Equation 7 from MDLM + prob_s_given_t = log_p_x0.exp() * ( + alpha_s - alpha_t + ) # righthand side (alpha_s - alpha_t)*x = (1 - alpha_t - (1 - alpha_s)) * x + prob_s_given_t[..., self.mask_index] = p_mask_s[..., 0] # lefthand side (1 - alpha_s)*M + sampled_x = self._sample_categorical(prob_s_given_t) + carry_over_unmask = (xt != self.mask_index).to(xt.dtype) + return carry_over_unmask * xt + (1 - carry_over_unmask) * sampled_x + + def _sample_categorical(self, categorical_probs: Tensor) -> Tensor: + """Sample from a categorical distribution using the Gumbel trick. + + Args: + categorical_probs (Tensor): The probabilities of each category, shape batch x node x class. + + Returns: + Tensor: The sampled category indices, shape batch x node. + """ + gumbel_norm = ( + 1e-10 + - ( + torch.rand(*categorical_probs.shape, device=categorical_probs.device, generator=self.rng_generator) + + 1e-10 + ).log() + ) + scaled_proability = categorical_probs / gumbel_norm + return scaled_proability.argmax(dim=-1) + + def get_num_steps_confidence(self, xt: Tensor): + """Calculate the maximum number of steps with confidence. + + This method computes the maximum count of occurrences where the input tensor `xt` matches the `mask_index` + along the last dimension (-1). The result is returned as a single float value. + + Args: + xt (Tensor): Input tensor to evaluate against the mask index. + + Returns: + float: The maximum number of steps with confidence (i.e., matching the mask index). + """ + return (xt == self.mask_index).sum(-1).max().item() + + def step_confidence( + self, + logits: Tensor, + xt: Tensor, + curr_step: int, + num_steps: int, + logit_temperature: float = 1.0, + randomness: float = 1.0, + confidence_temperature: float = 1.0, + num_tokens_unmask: int = 1, + ) -> Tensor: + """Update the input sequence xt by sampling from the predicted logits and adding Gumbel noise. + + Method taken from GenMol Lee et al. https://arxiv.org/abs/2501.06158 + + Args: + logits: Predicted logits + xt: Input sequence + curr_step: Current step + num_steps: Total number of steps + logit_temperature: Temperature for softmax over logits + randomness: Scale for Gumbel noise + confidence_temperature: Temperature for Gumbel confidence + num_tokens_unmask: number of tokens to unmask each step + + Returns: + Updated input sequence xt unmasking num_tokens_unmask token each step. + """ + if xt.ndim > 3: + raise NotImplementedError( + "step_confidence is implemented for Batch x Sequence x State Space shaped tensors." + ) + xt = xt.clone() + log_p_x0 = self._subs_parameterization(logits, xt) + # sample the code from the softmax prediction + probs = torch.softmax(log_p_x0 / logit_temperature, dim=-1) + preds = torch.distributions.Categorical(probs=probs).sample() + + confidence = probs.gather(-1, preds.unsqueeze(-1)).squeeze(-1) + # add Gumbel noise decreasing over the sampling process + ratio = curr_step / (num_steps - 1) + # Using manual definition of 0,1 Gumbel to pass in generator + gumbel_sample = -torch.log(-torch.log(torch.rand(xt.shape, generator=self.rng_generator))).to(logits.device) + # gumbel_sample = self.gumbel_dist.sample(xt.shape).to(logits.device) + gumbel_noise = gumbel_sample * randomness * (1 - ratio) # type: ignore + confidence = ( + (torch.log(confidence) + gumbel_noise) / confidence_temperature + ) # stems from tau of https://pytorch.org/docs/stable/_modules/torch/nn/functional.html#gumbel_softmax + + # do not predict on already predicted tokens + mask = xt == self.mask_index + confidence[~mask] = -torch.inf + + # choose the predicted token with the highest confidence + confidence_threshold, idx_mask = torch.topk(confidence, k=num_tokens_unmask, dim=-1) + confidence_threshold = confidence_threshold[:, -1].unsqueeze(-1) + + # replace the chosen tokens + to_replace = confidence >= confidence_threshold + to_replace = (mask.float() * to_replace.float()).bool() + xt[to_replace] = preds[to_replace] + return xt + + def step_argmax(self, model_out: Tensor): + """Returns the index of the maximum value in the last dimension of the model output. + + Args: + model_out (Tensor): The output of the model. + + Returns: + Tensor: The index of the maximum value in the last dimension of the model output. + """ + return model_out.argmax(dim=-1) + + def calculate_score(self, logits, x, t): + """Returns score of the given sample x at time t with the corresponding model output logits. + + Args: + logits (Tensor): The output of the model. + x (Tensor): The current data point. + t (Tensor): The current time. + + Returns: + Tensor: The score defined in Appendix C.3 Equation 76 of MDLM. + """ + sigma_t = self.noise_schedule.calculate_sigma(t, logits.device) + log_ratio = -torch.log( + torch.expm1(sigma_t) + ) # log ( exp(-sigma) / (1 - exp(-sigma))) = log(1/ (exp(sigma) - 1)) + + # Create masked and unmasked log scores + masked_log_score = logits + pad_like(log_ratio, logits) # xt is masked and prediction is not + masked_log_score[..., self.mask_index] = 0 # xt and prediction are mask + + unmasked_log_score = torch.full_like(logits, -1000000.0) + unmasked_log_score.scatter_(-1, x[..., None], 0) # place zeros where current predictions are + unmasked_log_score[..., self.mask_index] = -pad_like(log_ratio, logits[..., 0]) + + # Combine masked and unmasked log scores + masked_indices = (x == self.mask_index).to(logits.dtype)[..., None] + log_score = masked_log_score * masked_indices + unmasked_log_score * (1 - masked_indices) + + return log_score.exp() diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py new file mode 100644 index 0000000000..ccb1a73699 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py @@ -0,0 +1,537 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import warnings +from typing import Literal, Optional, Union + +import torch +import torch.nn as nn +from jaxtyping import Bool, Float +from torch import Tensor + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.prior.distribution import PriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant, PredictionType, pad_like, string_to_enum +from bionemo.moco.interpolants.discrete_time.utils import safe_index +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteNoiseSchedule + + +class DDPM(Interpolant): + """A Denoising Diffusion Probabilistic Model (DDPM) interpolant. + + ------- + + Examples: + ```python + >>> import torch + >>> from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + >>> from bionemo.moco.distributions.time.uniform import UniformTimeDistribution + >>> from bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM + >>> from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule + >>> from bionemo.moco.schedules.inference_time_schedules import DiscreteLinearInferenceSchedule + + + ddpm = DDPM( + time_distribution = UniformTimeDistribution(discrete_time = True,...), + prior_distribution = GaussianPrior(...), + noise_schedule = DiscreteCosineNoiseSchedule(...), + ) + model = Model(...) + + # Training + for epoch in range(1000): + data = data_loader.get(...) + time = ddpm.sample_time(batch_size) + noise = ddpm.sample_prior(data.shape) + xt = ddpm.interpolate(data, noise, time) + + x_pred = model(xt, time) + loss = ddpm.loss(x_pred, data, time) + loss.backward() + + # Generation + x_pred = ddpm.sample_prior(data.shape) + for t in DiscreteLinearTimeSchedule(...).generate_schedule(): + time = torch.full((batch_size,), t) + x_hat = model(x_pred, time) + x_pred = ddpm.step(x_hat, time, x_pred) + return x_pred + + ``` + """ + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: PriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + prediction_type: Union[PredictionType, str] = PredictionType.DATA, + device: Union[str, torch.device] = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the DDPM interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + noise_schedule (DiscreteNoiseSchedule): The schedule of noise, defining the amount of noise added at each time step. + prediction_type (PredictionType): The type of prediction, either "data" or another type. Defaults to "data". + device (str): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + last_time_idx (int, optional): The last time index for discrete time. Set to 0 if discrete time is T-1, ..., 0 or 1 if T, ..., 1. Defaults to 0. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + super().__init__(time_distribution, prior_distribution, device, rng_generator) + if not isinstance(prior_distribution, GaussianPrior): + warnings.warn("Prior distribution is not a GaussianPrior, unexpected behavior may occur") + self.noise_schedule = noise_schedule + self._initialize_schedules(device) + self.prediction_type = string_to_enum(prediction_type, PredictionType) + self._loss_function = nn.MSELoss(reduction="none") + self.last_time_idx = last_time_idx + + def _initialize_schedules(self, device: Union[str, torch.device] = "cpu"): + """Sets up the Denoising Diffusion Probabilistic Model (DDPM) equations. + + This method initializes the schedules for the forward and reverse processes of the DDPM. It calculates the + alphas, betas, and log variances required for the diffusion process. + + Specifically, it computes: + + * `alpha_bar`: the cumulative product of `alpha_t` + * `alpha_bar_prev`: the previous cumulative product of `alpha_t` + * `posterior_variance`: the variance of the posterior distribution + * `posterior_mean_c0_coef` and `posterior_mean_ct_coef`: the coefficients for the posterior mean + * `log_var`: the log variance of the posterior distribution + + These values are then used to set up the forward and reverse schedules for the DDPM. + Specifically this is equation (6) (7) from https://arxiv.org/pdf/2006.11239 + """ + if self.noise_schedule is None: + raise ValueError("noise_schedule cannot be None for DDPM") + alphas = self.noise_schedule.generate_schedule(device=device) + betas = 1 - alphas + log_alpha = torch.log(alphas) + log_alpha_bar = torch.cumsum(log_alpha, dim=0) + alpha_bar = alphas_cumprod = torch.exp(log_alpha_bar) + alpha_bar_prev = alphas_cumprod_prev = torch.nn.functional.pad(alphas_cumprod[:-1], (1, 0), value=1.0) + posterior_variance = betas * (1.0 - alpha_bar_prev) / (1.0 - alpha_bar) + posterior_mean_c0_coef = betas * torch.sqrt(alphas_cumprod_prev) / (1.0 - alpha_bar) + posterior_mean_ct_coef = (1.0 - alpha_bar_prev) * torch.sqrt(alphas) / (1.0 - alpha_bar) + # log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain + posterior_logvar = torch.log( + torch.nn.functional.pad(posterior_variance[:-1], (1, 0), value=posterior_variance[0].item()) + ) + self._forward_data_schedule = torch.sqrt(alpha_bar) + self._forward_noise_schedule = torch.sqrt(1 - alpha_bar) + self._reverse_data_schedule = posterior_mean_c0_coef + self._reverse_noise_schedule = posterior_mean_ct_coef + self._log_var = posterior_logvar + self._alpha_bar = alpha_bar + self._alpha_bar_prev = alpha_bar_prev + self._betas = betas + self._posterior_variance = betas * (1.0 - alphas_cumprod_prev) / (1.0 - alphas_cumprod) + + @property + def forward_data_schedule(self) -> torch.Tensor: + """Returns the forward data schedule.""" + return self._forward_data_schedule + + @property + def forward_noise_schedule(self) -> torch.Tensor: + """Returns the forward noise schedule.""" + return self._forward_noise_schedule + + @property + def reverse_data_schedule(self) -> torch.Tensor: + """Returns the reverse data schedule.""" + return self._reverse_data_schedule + + @property + def reverse_noise_schedule(self) -> torch.Tensor: + """Returns the reverse noise schedule.""" + return self._reverse_noise_schedule + + @property + def log_var(self) -> torch.Tensor: + """Returns the log variance.""" + return self._log_var + + @property + def alpha_bar(self) -> torch.Tensor: + """Returns the alpha bar values.""" + return self._alpha_bar + + @property + def alpha_bar_prev(self) -> torch.Tensor: + """Returns the previous alpha bar values.""" + return self._alpha_bar_prev + + def interpolate(self, data: Tensor, t: Tensor, noise: Tensor): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor): noise from prior() + """ + psi = safe_index(self._forward_data_schedule, t - self.last_time_idx, data.device) + omega = safe_index(self._forward_noise_schedule, t - self.last_time_idx, data.device) + psi = pad_like(psi, data) + omega = pad_like(omega, data) + x_t = data * psi + noise * omega + return x_t + + def forward_process(self, data: Tensor, t: Tensor, noise: Optional[Tensor] = None): + """Get x(t) with given time t from noise and data. + + Args: + data (Tensor): target + t (Tensor): time + noise (Tensor, optional): noise from prior(). Defaults to None. + """ + if noise is None: + noise = self.sample_prior(data.shape) + return self.interpolate(data, t, noise) + + def process_data_prediction(self, model_output: Tensor, sample: Tensor, t: Tensor): + """Converts the model output to a data prediction based on the prediction type. + + This conversion stems from the Progressive Distillation for Fast Sampling of Diffusion Models https://arxiv.org/pdf/2202.00512. + Given the model output and the sample, we convert the output to a data prediction based on the prediction type. + The conversion formulas are as follows: + - For "noise" prediction type: `pred_data = (sample - noise_scale * model_output) / data_scale` + - For "data" prediction type: `pred_data = model_output` + - For "v_prediction" prediction type: `pred_data = data_scale * sample - noise_scale * model_output` + + Args: + model_output (Tensor): The output of the model. + sample (Tensor): The input sample. + t (Tensor): The time step. + + Returns: + The data prediction based on the prediction type. + + Raises: + ValueError: If the prediction type is not one of "noise", "data", or "v_prediction". + """ + data_scale = safe_index(self._forward_data_schedule, t - self.last_time_idx, model_output.device) + noise_scale = safe_index(self._forward_noise_schedule, t - self.last_time_idx, model_output.device) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_data = (sample - noise_scale * model_output) / data_scale + elif self.prediction_type == PredictionType.DATA: + pred_data = model_output + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of PredictionType.NOISE, PredictionType.DATA or" + f" PredictionType.VELOCITY for DDPM." + ) + return pred_data + + def process_noise_prediction(self, model_output, sample, t): + """Do the same as process_data_prediction but take the model output and convert to nosie. + + Args: + model_output: The output of the model. + sample: The input sample. + t: The time step. + + Returns: + The input as noise if the prediction type is "noise". + + Raises: + ValueError: If the prediction type is not "noise". + """ + data_scale = safe_index(self._forward_data_schedule, t - self.last_time_idx, model_output.device) + noise_scale = safe_index(self._forward_noise_schedule, t - self.last_time_idx, model_output.device) + data_scale = pad_like(data_scale, model_output) + noise_scale = pad_like(noise_scale, model_output) + if self.prediction_type == PredictionType.NOISE: + pred_noise = model_output + elif self.prediction_type == PredictionType.DATA: + pred_noise = (sample - data_scale * model_output) / noise_scale + elif self.prediction_type == PredictionType.VELOCITY: + pred_data = data_scale * sample - noise_scale * model_output + pred_noise = (sample - data_scale * pred_data) / noise_scale + else: + raise ValueError( + f"prediction_type given as {self.prediction_type} must be one of `noise`, `data` or" + " `v_prediction` for DDPM." + ) + return pred_noise + + def calculate_velocity(self, data: Tensor, t: Tensor, noise: Tensor) -> Tensor: + """Calculate the velocity term given the data, time step, and noise. + + Args: + data (Tensor): The input data. + t (Tensor): The current time step. + noise (Tensor): The noise term. + + Returns: + Tensor: The calculated velocity term. + """ + data_scale = safe_index(self._forward_data_schedule, t - self.last_time_idx, data.device) + noise_scale = safe_index(self._forward_noise_schedule, t - self.last_time_idx, data.device) + data_scale = pad_like(data_scale, data) + noise_scale = pad_like(noise_scale, data) + v = data_scale * noise - noise_scale * data + return v + + @torch.no_grad() + def step( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ): + """Do one step integration. + + Args: + model_out (Tensor): The output of the model. + t (Tensor): The current time step. + xt (Tensor): The current data point. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + + Note: + The temperature parameter controls the level of randomness in the sampling process. A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) result in less random and more deterministic samples. This can be useful for tasks that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + x_hat = self.process_data_prediction(model_out, xt, t) + psi_r = safe_index(self._reverse_data_schedule, t - self.last_time_idx, x_hat.device) + omega_r = safe_index(self._reverse_noise_schedule, t - self.last_time_idx, x_hat.device) + log_var = safe_index(self._log_var, t - self.last_time_idx, x_hat.device) # self._log_var[t.long()] + nonzero_mask = (t > self.last_time_idx).float() + psi_r = pad_like(psi_r, x_hat) + omega_r = pad_like(omega_r, x_hat) + log_var = pad_like(log_var, x_hat) + nonzero_mask = pad_like(nonzero_mask, x_hat) + + mean = psi_r * x_hat + omega_r * xt + eps = torch.randn_like(mean).to(model_out.device) + + x_next = mean + nonzero_mask * (0.5 * log_var).exp() * eps * temperature + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def step_noise( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + center: Bool = False, + temperature: Float = 1.0, + ): + """Do one step integration. + + Args: + model_out (Tensor): The output of the model. + t (Tensor): The current time step. + xt (Tensor): The current data point. + mask (Optional[Tensor], optional): An optional mask to apply to the data. Defaults to None. + center (bool, optional): Whether to center the data. Defaults to False. + temperature (Float, optional): The temperature parameter for low temperature sampling. Defaults to 1.0. + + Note: + The temperature parameter controls the level of randomness in the sampling process. + A temperature of 1.0 corresponds to standard diffusion sampling, while lower temperatures (e.g. 0.5, 0.2) + result in less random and more deterministic samples. This can be useful for tasks + that require more control over the generation process. + + Note for discrete time we sample from [T-1, ..., 1, 0] for T steps so we sample t = 0 hence the mask. + For continuous time we start from [1, 1 -dt, ..., dt] for T steps where s = t - 1 when t = 0 i.e dt is then 0 + + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + eps_hat = self.process_noise_prediction(model_out, xt, t) + beta_t = safe_index(self._betas, t - self.last_time_idx, model_out.device) + recip_sqrt_alpha_t = torch.sqrt(1 / (1 - beta_t)) + eps_factor = ( + safe_index(self._betas, t - self.last_time_idx, model_out.device) + / (1 - safe_index(self._alpha_bar, t - self.last_time_idx, model_out.device)).sqrt() + ) + var = safe_index(self._posterior_variance, t - self.last_time_idx, model_out.device) # self._log_var[t.long()] + + nonzero_mask = (t > self.last_time_idx).float() + nonzero_mask = pad_like(nonzero_mask, model_out) + eps_factor = pad_like(eps_factor, xt) + recip_sqrt_alpha_t = pad_like(recip_sqrt_alpha_t, xt) + var = pad_like(var, xt) + + x_next = ( + recip_sqrt_alpha_t * (xt - eps_factor * eps_hat) + + nonzero_mask * var.sqrt() * torch.randn_like(eps_hat).to(model_out.device) * temperature + ) + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def score(self, x_hat: Tensor, xt: Tensor, t: Tensor): + """Converts the data prediction to the estimated score function. + + Args: + x_hat (Tensor): The predicted data point. + xt (Tensor): The current data point. + t (Tensor): The time step. + + Returns: + The estimated score function. + """ + alpha = safe_index(self._forward_data_schedule, t - self.last_time_idx, x_hat.device) + beta = safe_index(self._forward_noise_schedule, t - self.last_time_idx, x_hat.device) + alpha = pad_like(alpha, x_hat) + beta = pad_like(beta, x_hat) + score = alpha * x_hat - xt + score = score / (beta * beta) + return score + + def step_ddim( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + eta: Float = 0.0, + center: Bool = False, + ): + """Do one step of DDIM sampling. + + Args: + model_out (Tensor): output of the model + t (Tensor): current time step + xt (Tensor): current data point + mask (Optional[Tensor], optional): mask for the data point. Defaults to None. + eta (Float, optional): DDIM sampling parameter. Defaults to 0.0. + center (Bool, optional): whether to center the data point. Defaults to False. + """ + if mask is not None: + model_out = model_out * mask.unsqueeze(-1) + data_pred = self.process_data_prediction(model_out, xt, t) + noise_pred = self.process_noise_prediction(model_out, xt, t) + eps = torch.randn_like(data_pred).to(model_out.device) + sigma = ( + eta + * torch.sqrt((1 - self._alpha_bar_prev) / (1 - self._alpha_bar)) + * torch.sqrt(1 - self._alpha_bar / self._alpha_bar_prev) + ) + sigma_t = safe_index(sigma, t - self.last_time_idx, model_out.device) + psi_r = safe_index(torch.sqrt(self._alpha_bar_prev), t - self.last_time_idx, model_out.device) + omega_r = safe_index(torch.sqrt(1 - self._alpha_bar_prev - sigma**2), t - self.last_time_idx, model_out.device) + sigma_t = pad_like(sigma_t, model_out) + psi_r = pad_like(psi_r, model_out) + omega_r = pad_like(omega_r, model_out) + mean = data_pred * psi_r + omega_r * noise_pred + x_next = mean + sigma_t * eps + x_next = self.clean_mask_center(x_next, mask, center) + return x_next + + def set_loss_weight_fn(self, fn): + """Sets the loss_weight attribute of the instance to the given function. + + Args: + fn: The function to set as the loss_weight attribute. This function should take three arguments: raw_loss, t, and weight_type. + """ + self.loss_weight = fn + + def loss_weight(self, raw_loss: Tensor, t: Optional[Tensor], weight_type: str) -> Tensor: + """Calculates the weight for the loss based on the given weight type. + + These data_to_noise loss weights is derived in Equation (9) of https://arxiv.org/pdf/2202.00512. + + Args: + raw_loss (Tensor): The raw loss calculated from the model prediction and target. + t (Tensor): The time step. + weight_type (str): The type of weight to use. Can be "ones" or "data_to_noise" or "noise_to_data". + + Returns: + Tensor: The weight for the loss. + + Raises: + ValueError: If the weight type is not recognized. + """ + if weight_type == "ones": + schedule = torch.ones_like(raw_loss).to(raw_loss.device) + elif weight_type == "data_to_noise": + if t is None: + raise ValueError("Time cannot be None when using the data_to_noise loss weight") + schedule = (safe_index(self._forward_data_schedule, t - self.last_time_idx, raw_loss.device) ** 2) / ( + safe_index(self._forward_noise_schedule, t - self.last_time_idx, raw_loss.device) ** 2 + ) + schedule = pad_like(schedule, raw_loss) + elif weight_type == "noise_to_data": + if t is None: + raise ValueError("Time cannot be None when using the data_to_noise loss weight") + schedule = (safe_index(self._forward_noise_schedule, t - self.last_time_idx, raw_loss.device) ** 2) / ( + safe_index(self._forward_data_schedule, t - self.last_time_idx, raw_loss.device) ** 2 + ) + schedule = pad_like(schedule, raw_loss) + else: + raise ValueError("Invalid loss weight keyword") + return schedule + + def loss( + self, + model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + weight_type: Literal["ones", "data_to_noise", "noise_to_data"] = "ones", + ): + """Calculate the loss given the model prediction, data sample, and time. + + The default weight_type is "ones" meaning no change / multiplying by all ones. + data_to_noise is available to scale the data MSE loss into the appropriate loss that is theoretically equivalent + to noise prediction. noise_to_data is provided for a similar reason for completeness. + + Args: + model_pred (Tensor): The predicted output from the model. + target (Tensor): The target output for the model prediction. + t (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + weight_type (Literal["ones", "data_to_noise", "noise_to_data"]): The type of weight to use for the loss. Defaults to "ones". + + Returns: + Tensor: The calculated loss batch tensor. + """ + raw_loss = self._loss_function(model_pred, target) + if weight_type != "ones": + update_weight = self.loss_weight(raw_loss, t, weight_type) + loss = raw_loss * update_weight + else: + loss = raw_loss + if mask is not None: + loss = loss * mask.unsqueeze(-1) + n_elem = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / n_elem + else: + loss = torch.sum(loss, dim=tuple(range(1, raw_loss.ndim))) / model_pred.size(1) + return loss diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py new file mode 100644 index 0000000000..3382f26f6c --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py @@ -0,0 +1,384 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +from typing import Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.distributions.prior.distribution import DiscretePriorDistribution +from bionemo.moco.distributions.time.distribution import TimeDistribution +from bionemo.moco.interpolants.base_interpolant import Interpolant +from bionemo.moco.interpolants.discrete_time.utils import safe_index +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteNoiseSchedule + + +def _is_one_hot(data, num_classes): + """Check if data is one-hot encoded. + + Parameters: + - data (Tensor): Input data to check. + - num_classes (int): Expected number of classes for one-hot encoding. + + Returns: + - bool: True if data is one-hot encoded, False otherwise. + """ + if len(data.shape) < 2 or data.shape[-1] != num_classes: + return False # Not one-hot if last dim doesn't match num_classes or less than 2D + + # Check if all vectors are one-hot + return (data.sum(dim=-1) == 1).all() and (data.flatten().shape[0] / num_classes) % 1 == 0 + + +class D3PM(Interpolant): + """A Discrete Denoising Diffusion Probabilistic Model (D3PM) interpolant.""" + + def __init__( + self, + time_distribution: TimeDistribution, + prior_distribution: DiscretePriorDistribution, + noise_schedule: DiscreteNoiseSchedule, + device: str = "cpu", + last_time_idx: int = 0, + rng_generator: Optional[torch.Generator] = None, + ): + """Initializes the D3PM interpolant. + + Args: + time_distribution (TimeDistribution): The distribution of time steps, used to sample time points for the diffusion process. + prior_distribution (PriorDistribution): The prior distribution of the variable, used as the starting point for the diffusion process. + noise_schedule (DiscreteNoiseSchedule): The schedule of noise, defining the amount of noise added at each time step. + device (str, optional): The device on which to run the interpolant, either "cpu" or a CUDA device (e.g. "cuda:0"). Defaults to "cpu". + last_time_idx (int, optional): The last time index to consider in the interpolation process. Defaults to 0. + rng_generator: An optional :class:`torch.Generator` for reproducible sampling. Defaults to None. + """ + # We initialize with CPU due to numerical precision issues on A100 that are not observed on A6000 + super().__init__(time_distribution, prior_distribution, "cpu", rng_generator) + self.noise_schedule = noise_schedule + self._loss_function = nn.CrossEntropyLoss(reduction="none") + self.timesteps = noise_schedule.nsteps + self.num_classes = prior_distribution.num_classes + self.terminal_distribution = prior_distribution.prior_dist.to(self.device) + self._initialize_schedules(self.device) + self.last_time_idx = last_time_idx + self.to_device(device) + + def _get_Qt(self, alphas: Tensor) -> Tensor: + """Calculate the transition matrix Qt based on the terminal distribution. + + The transition matrix Qt represents the probabilities of transitioning from one state to another at a given time step. + It is calculated based on the terminal distribution, which can be either uniform, a mask, or a custom distribution. + See Appendix A.2 D3PM https://arxiv.org/pdf/2107.03006 which shows what happens for various prior distributions. + + The terminal distribution can be: + - Uniform: a uniform distribution over all states. + - Mask: a mask where the last dimension is 1 and the rest are 0. + - Custom: a custom distribution provided by the user. + + Args: + alphas (Tensor): A tensor of probabilities, where each alpha represents the probability of staying in a state at a given time step. + + Returns: + Tensor: The transition matrix Qt. + """ + QT = [] + for alpha_t in alphas: + stay_prob = torch.eye(len(self.terminal_distribution), device=self.device) * alpha_t + diffuse_prob = (1.0 - alpha_t) * ( + torch.ones(1, len(self.terminal_distribution), device=self.device) + * (self.terminal_distribution.unsqueeze(0)) + ) + QT.append(stay_prob + diffuse_prob) + return torch.stack(QT, dim=0) + + def _calculate_transition_matrix(self, alphas: Tensor) -> Tuple[Tensor, Tensor, Tensor]: + """Calculates the rate transition matrix `Qt`, its cumulative variant `Qt_bar`, and the cumulative variant of the previous time step `Qt_bar_prev`. + + Args: + alphas (Tensor): A tensor of probabilities, where each alpha represents the probability of staying in a state at a given time step. + + Returns: + Tuple[Tensor, Tensor, Tensor]: A tuple containing the rate transition matrix `Qt`, its cumulative variant `Qt_bar`, and the cumulative variant of the previous time step `Qt_bar_prev`. + """ + Qt = self._get_Qt(alphas) + Qt_prev = torch.eye(self.num_classes, device=self.device) + Qt_bar = [] + for i in range(len(alphas)): + Qtb = Qt_prev @ Qt[i] + if torch.any((Qtb.sum(-1) - 1.0).abs() > 1e-4): + raise ValueError(f"Invalid Distribution for Qt_bar at step {i}") + Qt_bar.append(Qtb) + Qt_prev = Qtb + Qt_bar = torch.stack(Qt_bar) + Qt_bar_prev = Qt_bar[:-1] + Qt_prev_pad = torch.eye(self.num_classes, device=self.device) + Qt_bar_prev = torch.concat([Qt_prev_pad.unsqueeze(0), Qt_bar_prev], dim=0) + return Qt, Qt_bar, Qt_bar_prev + + def _initialize_schedules(self, device): + """Initializes the transition matrices for the discrete diffusion process. + + This method computes the rate transition matrix `Qt` and its cumulative variants `Qt_bar` and `Qt_prev_bar` + based on the provided noise schedule. + + Note: + `Qt` represents the rate transition matrix, where `Qt[t]` is the transition matrix at time step `t`. + `Qt_bar` and `Qt_prev_bar` are the cumulative variants of `Qt`, where `Qt_bar[t]` represents the cumulative + transition matrix from time step `0` to `t`, and `Qt_prev_bar[t]` represents the cumulative transition matrix + from time step `0` to `t-1`. + + Args: + device (str): The device on which to compute the transition matrices. + """ + if self.noise_schedule is None: + raise ValueError("noise_schedule cannot be None for D3PM") + alphas = self.noise_schedule.generate_schedule(device=device) + log_alpha = torch.log(alphas) + log_alpha_bar = torch.cumsum(log_alpha, dim=0) + self._alpha_bar = torch.exp(log_alpha_bar) + #! Note to users that the tranditional cosine schedule is a very quick convergence of alpha. Pay close attention to the scheduler here + Qt, Qt_bar, Qt_prev_bar = self._calculate_transition_matrix(alphas) + self._Qt = Qt[-self.timesteps :] + self._Qt_transposed = self._Qt.transpose(1, 2) + self._Qt_bar = Qt_bar[-self.timesteps :] + self._Qt_prev_bar = Qt_prev_bar[-self.timesteps :] + + def interpolate(self, data: Tensor, t: Tensor): + """Interpolate using discrete interpolation method. + + This method implements Equation 2 from the D3PM paper (https://arxiv.org/pdf/2107.03006), which + calculates the interpolated discrete state `xt` at time `t` given the input data and noise + via q(xt|x0) = Cat(xt; p = x0*Qt_bar). + + Args: + data (Tensor): The input data to be interpolated. + t (Tensor): The time step at which to interpolate. + + Returns: + Tensor: The interpolated discrete state `xt` at time `t`. + """ + if not _is_one_hot(data, self.num_classes): + x1_hot = F.one_hot(data, self.num_classes) + else: + x1_hot = data + ford = safe_index(self._Qt_bar, t - self.last_time_idx, data.device) + if x1_hot.ndim > 3: # einsum precision issues on A100 not A6000 for 2D inputs + ford_prep = ford + for _ in range(x1_hot.ndim - 2): + ford_prep = ford_prep.unsqueeze(1) + probs = (x1_hot.float().unsqueeze(-2) * ford_prep).sum(dim=(-2)) + else: + probs = torch.einsum("b...j, bji -> b...i", [x1_hot.float(), ford]) + if torch.any((probs.sum(-1) - 1.0).abs() > 1e-4): + raise ValueError( + f"**INVALID BEHAVIOR** Probability Distribution does not sum to 1.0 for time {t}. " + f"**INVESTIGATE YOUR DEVICE PRECISION**: This error has been triggered before on A100 by initializing the Qt terms on gpu. " + f"Normalized to ensure validity. Original sums: {probs.sum(-1)}", + ) + xt = self._sample_categorical(torch.log(probs) + 1.0e-6) + return xt + + def forward_process(self, data: Tensor, t: Tensor) -> Tensor: + """Apply the forward process to the data at time t. + + Args: + data (Tensor): target discrete ids + t (Tensor): time + + Returns: + Tensor: x(t) after applying the forward process + """ + return self.interpolate(data, t) + + def _sample_categorical(self, logits, mask: Optional[Tensor] = None, temperature: Float = 1.0) -> Tensor: + """Sample a categorical distribution using the Gumbel-Softmax trick. + + This method samples a categorical distribution from the given logits, + optionally applying a mask and using a specified temperature. + + Args: + logits (Tensor): The logits of the categorical distribution. + mask (Optional[Tensor], optional): An optional mask to apply to the noise added to logits. Defaults to None. + temperature (float, optional): The temperature to use for the Gumbel-Softmax trick. Defaults to 1.0. + + Returns: + Tensor: A sample from the categorical distribution. + """ + noise = torch.rand_like(logits) + noise = torch.clip(noise, 1.0e-6, 1.0) + gumbel_noise = -torch.log(-torch.log(noise)) + if mask is not None: + sample = torch.argmax((logits / temperature) + gumbel_noise * mask, dim=-1) + else: + sample = torch.argmax((logits / temperature) + gumbel_noise, dim=-1) + return sample + + def _q_posterior_logits( + self, model_out: Tensor, t: Tensor, xt: Tensor, model_out_is_logits: bool = True + ) -> Tensor: + """Calculate the q-posterior logits using the predicted x0 and the current state xt at time t. + + This method implements Equation 3 from the D3PM paper (https://arxiv.org/pdf/2107.03006), which calculates the q-posterior + distribution over the previous state x0 given the current state xt and the model output. + + Args: + model_out (Tensor): The output of the model at the current time step. + t (Tensor): The current time step. + xt (Tensor): The current discrete state at time t. + model_out_is_logits (bool, optional): A flag indicating whether the model output is already in logits form. If True, the output is assumed to be logits; otherwise, it is converted to logits. Defaults to True. + + Returns: + Tensor: The q-posterior logits. + """ + if not model_out_is_logits: # model_out.dtype == torch.int64 or model_out.dtype == torch.int32: + # Convert model output to logits if it's a categorical distribution + x0_logits = torch.log(torch.nn.functional.one_hot(model_out, self.num_classes).float() + 1.0e-6) + else: + # Otherwise, assume model output is already logits + x0_logits = model_out.clone() + + # Calculate xt_guess: the predicted probability of xt given x0 and t + xt_guess = torch.einsum( + "b...j, bji -> b...i", + [ + torch.nn.functional.one_hot(xt, self.num_classes).float(), + safe_index(self._Qt_transposed, t - self.last_time_idx, model_out.device), + ], + ) + + # Calculate softmaxed x0_logits + softmaxed = torch.softmax(x0_logits, dim=-1) # bs, ..., num_classes + + # Calculate x0_guess: the predicted probability of x0 given xt and t-1 + x0_guess = torch.einsum( + "b...c,bcd->b...d", + softmaxed, + safe_index(self._Qt_prev_bar, t - self.last_time_idx, model_out.device), + ) + + # Calculate q-posterior logits + out = torch.log(xt_guess + 1.0e-6) + torch.log(x0_guess + 1.0e-6) + t_broadcast = t.reshape((t.shape[0], *[1] * (xt.dim()))) + q_posterior_logits = torch.where(t_broadcast == self.last_time_idx, x0_logits, out) + return q_posterior_logits + + def step( + self, + model_out: Tensor, + t: Tensor, + xt: Tensor, + mask: Optional[Tensor] = None, + temperature: Float = 1.0, + model_out_is_logits: bool = True, + ): + """Perform a single step in the discrete interpolant method, transitioning from the current discrete state `xt` at time `t` to the next state. + + This step involves: + + 1. Computing the predicted q-posterior logits using the model output `model_out` and the current state `xt` at time `t`. + 2. Sampling the next state from the predicted q-posterior distribution using the Gumbel-Softmax trick. + + Args: + model_out (Tensor): The output of the model at the current time step, which is used to compute the predicted q-posterior logits. + t (Tensor): The current time step, which is used to index into the transition matrices and compute the predicted q-posterior logits. + xt (Tensor): The current discrete state at time `t`, which is used to compute the predicted q-posterior logits and sample the next state. + mask (Optional[Tensor], optional): An optional mask to apply to the next state, which can be used to mask out certain tokens or regions. Defaults to None. + temperature (Float, optional): The temperature to use for the Gumbel-Softmax trick, which controls the randomness of the sampling process. Defaults to 1.0. + model_out_is_logits (bool, optional): A flag indicating whether the model output is already in logits form. If True, the output is assumed to be logits; otherwise, it is converted to logits. Defaults to True. + + Returns: + Tensor: The next discrete state at time `t-1`. + """ + pred_q_posterior_logits = self._q_posterior_logits(model_out, t, xt, model_out_is_logits) + nonzero_mask = (t != self.last_time_idx).to(xt.dtype).reshape(xt.shape[0], *([1] * (len(xt.shape)))) + x_next = self._sample_categorical(pred_q_posterior_logits, nonzero_mask, temperature=temperature) + # # Apply mask if provided + if mask is not None: + x_next = x_next * mask + return x_next + + def loss( + self, + logits: Tensor, + target: Tensor, + xt: Tensor, + time: Tensor, + mask: Optional[Tensor] = None, + vb_scale: Float = 0.0, + ): + """Calculate the cross-entropy loss between the model prediction and the target output. + + The loss is calculated between the batch x node x class logits and the target batch x node. If a mask is provided, the loss is + calculated only for the non-masked elements. Additionally, if vb_scale is greater than 0, the variational lower bound loss is + calculated and added to the total loss. + + Args: + logits (Tensor): The predicted output from the model, with shape batch x node x class. + target (Tensor): The target output for the model prediction, with shape batch x node. + xt (Tensor): The current data point. + time (Tensor): The time at which the loss is calculated. + mask (Optional[Tensor], optional): The mask for the data point. Defaults to None. + vb_scale (Float, optional): The scale factor for the variational lower bound loss. Defaults to 0.0. + + Returns: + Tensor: The calculated loss tensor. If aggregate is True, the loss and variational lower bound loss are aggregated and + returned as a single tensor. Otherwise, the loss and variational lower bound loss are returned as separate tensors. + """ + assert target.ndim + 1 == logits.ndim + loss = self._loss_function(logits.transpose(-1, 1), target.long()) + if mask is not None: + loss = loss * mask + num_non_masked_elements = torch.sum(mask, dim=-1) + loss = torch.sum(loss, dim=(-1)) / num_non_masked_elements + else: + loss = torch.sum(loss, dim=(-1)) / logits.size(1) + if vb_scale > 0: + target = F.one_hot(target, num_classes=self.num_classes).float() + true_q_posterior_logits = self._q_posterior_logits(target, time, xt) + pred_q_posterior_logits = self._q_posterior_logits(logits, time, xt) + vb_loss = self._variational_lower_bound(true_q_posterior_logits, pred_q_posterior_logits) + vb_loss = vb_scale * vb_loss + else: + vb_loss = 0 + if vb_scale > 0: + loss += vb_loss + return loss + + def _variational_lower_bound(self, dist1: Tensor, dist2: Tensor) -> Tensor: + """Calculate the variational lower bound (VLB) between two distributions. + + The VLB measures the difference between the true and approximate posterior distributions. + It is used to regularize the model and encourage it to produce more accurate predictions. + + Args: + dist1 (Tensor): The true posterior distribution. + dist2 (Tensor): The approximate posterior distribution. + + Returns: + Tensor: The variational lower bound loss. + """ + # Flatten dist1 and dist2 to simplify calculations + dist1 = dist1.flatten(start_dim=0, end_dim=-2) + dist2 = dist2.flatten(start_dim=0, end_dim=-2) + + # Calculate the VLB + out = torch.softmax(dist1 + 1.0e-6, dim=-1) * ( + torch.log_softmax(dist1 + 1.0e-6, dim=-1) - torch.log_softmax(dist2 + 1.0e-6, dim=-1) + ) + # Return the mean of the VLB across all elements + return out.sum(dim=-1).mean() diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py new file mode 100644 index 0000000000..12be71a573 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/utils.py @@ -0,0 +1,43 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import torch +from torch import Tensor + + +def safe_index(tensor: Tensor, index: Tensor, device: torch.device): + """Safely indexes a tensor using a given index and returns the result on a specified device. + + Note can implement forcing with return tensor[index.to(tensor.device)].to(device) but has costly migration. + + Args: + tensor (Tensor): The tensor to be indexed. + index (Tensor): The index to use for indexing the tensor. + device (torch.device): The device on which the result should be returned. + + Returns: + Tensor: The indexed tensor on the specified device. + + Raises: + ValueError: If tensor, index, and device are not all on the same device. + """ + if not (tensor.device == index.device == device): + raise ValueError( + f"Tensor, index, and device must all be on the same device. " + f"Got tensor.device={tensor.device}, index.device={index.device}, and device={device}." + ) + + return tensor[index] diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py new file mode 100644 index 0000000000..c4d7ae9c0c --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/inference_time_schedules.py @@ -0,0 +1,460 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class InferenceSchedule(ABC): + """A base class for inference time schedules.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the InferenceSchedule. + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + """ + self.nsteps = nsteps + self.min_t = min_t + self.padding = padding + self.dilation = dilation + self.direction = string_to_enum(direction, TimeDirection) + self.device = device + + @abstractmethod + def generate_schedule( + self, nsteps: Optional[int] = None, device: Optional[Union[str, torch.device]] = None + ) -> Tensor: + """Generate the time schedule as a tensor. + + Args: + nsteps (Optioanl[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + pass + + def pad_time( + self, n_samples: int, scalar_time: Float, device: Optional[Union[str, torch.device]] = None + ) -> Tensor: + """Creates a tensor of shape (n_samples,) filled with a scalar time value. + + Args: + n_samples (int): The desired dimension of the output tensor. + scalar_time (Float): The scalar time value to fill the tensor with. + device (Optional[Union[str, torch.device]], optional): + The device to place the tensor on. Defaults to None, which uses the default device. + + Returns: + Tensor: A tensor of shape (n_samples,) filled with the scalar time value. + """ + return torch.full((n_samples,), fill_value=scalar_time).to(device) + + +class ContinuousInferenceSchedule(InferenceSchedule): + """A base class for continuous time inference schedules.""" + + def __init__( + self, + nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the ContinuousInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + inclusive_end (bool): If True, include the end value (1.0) in the schedule otherwise ends at 1.0-1/nsteps (default is False). + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + """ + super().__init__(nsteps, min_t, padding, dilation, direction, device) + self.inclusive_end = inclusive_end + + def discretize( + self, + nsteps: Optional[int] = None, + schedule: Optional[Tensor] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Discretize the time schedule into a list of time deltas. + + Args: + nsteps (Optioanl[int]): Number of time steps. If None, uses the value from initialization. + schedule (Optional[Tensor]): Time scheudle if None will generate it with generate_schedule. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time deltas. + """ + if device is None: + device = self.device + if schedule is None: + schedule = self.generate_schedule(nsteps, device=device) + if self.direction == TimeDirection.UNIFIED: + schedule = torch.cat((schedule, torch.ones((1,), device=schedule.device))) + dt = schedule[1:] - schedule[:-1] + else: + schedule = torch.cat((schedule, torch.zeros((1,), device=schedule.device))) + dt = -1 * (schedule[1:] - schedule[:-1]) + return dt + + +class DiscreteInferenceSchedule(InferenceSchedule): + """A base class for discrete time inference schedules.""" + + def discretize( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Discretize the time schedule into a list of time deltas. + + Args: + nsteps (Optioanl[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time deltas. + """ + if self.padding > 0 or self.dilation > 0: + raise NotImplementedError("discreteize is not implemented for discrete schedules with padding or dilation") + if device is None: + device = self.device + return torch.full( + (nsteps if nsteps is not None else self.nsteps,), + 1 / (nsteps if nsteps is not None else self.nsteps), + device=device, + ) + + +class DiscreteLinearInferenceSchedule(DiscreteInferenceSchedule): + """A linear time schedule for discrete time inference.""" + + def __init__( + self, + nsteps: int, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the DiscreteLinearInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, min_t, padding, dilation, direction, device) + + def generate_schedule( + self, nsteps: Optional[int] = None, device: Optional[Union[str, torch.device]] = None + ) -> Tensor: + """Generate the linear time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps. + Tensor: A tensor of time steps. + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / self.dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + schedule = torch.arange(nsteps).to(device=device) + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.direction == TimeDirection.DIFFUSION: + schedule = schedule.flip(0) + if self.padding > 0: + schedule = torch.cat((schedule, schedule[-1] * torch.ones(self.padding, device=device))) + return schedule + + +class LinearInferenceSchedule(ContinuousInferenceSchedule): + """A linear time schedule for continuous time inference.""" + + def __init__( + self, + nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the LinearInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + inclusive_end (bool): If True, include the end value (1.0) in the schedule otherwise ends at 1.0-1/nsteps (default is False). + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, inclusive_end, min_t, padding, dilation, direction, device) + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Generate the linear time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor of time steps. + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + if not self.inclusive_end: + schedule = torch.linspace(self.min_t, 1, nsteps + 1).to(device=device) + schedule = schedule[:-1] + else: + schedule = torch.linspace(self.min_t, 1, nsteps).to(device=device) + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.padding > 0: + schedule = torch.cat((schedule, torch.ones(self.padding, device=device))) + if self.direction == TimeDirection.DIFFUSION: + schedule = 1 - schedule + return schedule + + +class PowerInferenceSchedule(ContinuousInferenceSchedule): + """A power time schedule for inference, where time steps are generated by raising a uniform schedule to a specified power.""" + + def __init__( + self, + nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = 1.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the PowerInferenceSchedule. + + Args: + nsteps (int): Number of time steps. + inclusive_end (bool): If True, include the end value (1.0) in the schedule otherwise ends at <1.0 (default is False). + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + exponent (Float): Power parameter defaults to 1.0. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, inclusive_end, min_t, padding, dilation, direction, device) + self.exponent = exponent + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Generate the power time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + + + Returns: + Tensor: A tensor of time steps. + Tensor: A tensor of time steps. + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + if not self.inclusive_end: + schedule = torch.linspace(self.min_t, 1, nsteps + 1).to(device=device) ** self.exponent + schedule = schedule[:-1] + else: + schedule = torch.linspace(self.min_t, 1, nsteps).to(device=device) ** self.exponent + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.padding > 0: + schedule = torch.cat((schedule, torch.ones(self.padding, device=device))) + if self.direction == TimeDirection.DIFFUSION: + schedule = 1 - schedule + return schedule + + +class LogInferenceSchedule(ContinuousInferenceSchedule): + """A log time schedule for inference, where time steps are generated by taking the logarithm of a uniform schedule.""" + + def __init__( + self, + nsteps: int, + inclusive_end: bool = False, + min_t: Float = 0, + padding: Float = 0, + dilation: Float = 0, + exponent: Float = -2.0, + direction: Union[TimeDirection, str] = TimeDirection.UNIFIED, + device: Union[str, torch.device] = "cpu", + ): + """Initialize the LogInferenceSchedule. + + Returns a log space time schedule. + + Which for 100 steps with default parameters is: + tensor([0.0000, 0.0455, 0.0889, 0.1303, 0.1699, 0.2077, 0.2439, 0.2783, 0.3113, + 0.3427, 0.3728, 0.4015, 0.4288, 0.4550, 0.4800, 0.5039, 0.5266, 0.5484, + 0.5692, 0.5890, 0.6080, 0.6261, 0.6434, 0.6599, 0.6756, 0.6907, 0.7051, + 0.7188, 0.7319, 0.7444, 0.7564, 0.7678, 0.7787, 0.7891, 0.7991, 0.8086, + 0.8176, 0.8263, 0.8346, 0.8425, 0.8500, 0.8572, 0.8641, 0.8707, 0.8769, + 0.8829, 0.8887, 0.8941, 0.8993, 0.9043, 0.9091, 0.9136, 0.9180, 0.9221, + 0.9261, 0.9299, 0.9335, 0.9369, 0.9402, 0.9434, 0.9464, 0.9492, 0.9520, + 0.9546, 0.9571, 0.9595, 0.9618, 0.9639, 0.9660, 0.9680, 0.9699, 0.9717, + 0.9734, 0.9751, 0.9767, 0.9782, 0.9796, 0.9810, 0.9823, 0.9835, 0.9847, + 0.9859, 0.9870, 0.9880, 0.9890, 0.9899, 0.9909, 0.9917, 0.9925, 0.9933, + 0.9941, 0.9948, 0.9955, 0.9962, 0.9968, 0.9974, 0.9980, 0.9985, 0.9990, + 0.9995]) + + Args: + nsteps (int): Number of time steps. + inclusive_end (bool): If True, include the end value (1.0) in the schedule otherwise ends at <1.0 (default is False). + min_t (Float): minimum time value defaults to 0. + padding (Float): padding time value defaults to 0. + dilation (Float): dilation time value defaults to 0 ie the number of replicates. + exponent (Float): log space exponent parameter defaults to -2.0. The lower number the more aggressive the acceleration of 0 to 0.9 will be thus having more steps from 0.9 to 1.0. + direction (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, this parameter allows to flip the direction to match the specified one (default is None). + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + super().__init__(nsteps, inclusive_end, min_t, padding, dilation, direction, device) + if exponent is None: + raise ValueError("exponent cannot be None for the log schedule") + if exponent >= 0: + raise ValueError(f"exponent input must be <0, got {exponent}") + self.exponent = exponent + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + ) -> Tensor: + """Generate the log time schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + if device is None: + device = self.device + if nsteps is None: + nsteps = self.nsteps + nsteps -= self.padding + dilation = self.dilation + 1 + if dilation > 1: + if nsteps % dilation != 0: + raise ValueError(f"nsteps ({nsteps}) is not divisible by dilation + 1 ({dilation})") + nsteps = int(nsteps / self.dilation) + if nsteps is None: + raise ValueError("nsteps cannot be None") + + if not self.inclusive_end: + t = 1.0 - torch.logspace(self.exponent, 0, nsteps + 1).flip(0).to(device=device) + t = t - torch.min(t) + schedule = t / torch.max(t) + schedule = schedule[:-1] + else: + t = 1.0 - torch.logspace(self.exponent, 0, nsteps).flip(0).to(device=device) + t = t - torch.min(t) + schedule = t / torch.max(t) + + if self.min_t > 0: + schedule = torch.clamp(schedule, min=self.min_t) + + if dilation > 1: + schedule = schedule.repeat_interleave(dilation) + if self.padding > 0: + schedule = torch.cat((schedule, torch.ones(self.padding, device=device))) + if self.direction == TimeDirection.DIFFUSION: + schedule = 1 - schedule + return schedule diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py new file mode 100644 index 0000000000..25e6abfbc5 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py new file mode 100644 index 0000000000..d40320e722 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_noise_transforms.py @@ -0,0 +1,182 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class ContinuousExpNoiseTransform(ABC): + """A base class for continuous schedules. + + alpha = exp(- sigma) where 1 - alpha controls the masking fraction. + """ + + def __init__(self, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + direction : TimeDirection, required this defines in which direction the scheduler was built + """ + self.direction = string_to_enum(direction, TimeDirection) + + def calculate_sigma( + self, + t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Calculate the sigma for the given time steps. + + Args: + t (Tensor): The input tensor representing the time steps, with values ranging from 0 to 1. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + synchronize (optional[TimeDirection]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + + Raises: + ValueError: If the input time steps exceed the maximum allowed value of 1. + """ + if t.max() > 1: + raise ValueError(f"Invalid value: max continuous time is 1, but got {t.max().item()}") + + if synchronize and self.direction != string_to_enum(synchronize, TimeDirection): + t = 1 - t + return self._calculate_sigma(t, device) + + @abstractmethod + def _calculate_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the -log of the clean data value for the given time steps. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + """ + pass + + def sigma_to_alpha(self, sigma: Tensor) -> Tensor: + """Converts sigma to alpha values by alpha = exp(- sigma). + + Args: + sigma (Tensor): The input sigma tensor. + + Returns: + Tensor: A tensor containing the alpha values. + """ + return torch.exp(-1 * sigma) + + +class CosineExpNoiseTransform(ContinuousExpNoiseTransform): + """A cosine Exponential noise schedule.""" + + def __init__(self, eps: Float = 1.0e-3): + """Initialize the CosineNoiseSchedule. + + Args: + eps (Float): small number to prevent numerical issues. + """ + self.direction = TimeDirection.DIFFUSION + self.eps = eps + + def _calculate_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate negative log of data interpolant fraction. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + """ + cos = torch.cos(t * torch.pi / 2).to(device) + return -torch.log(self.eps + (1 - self.eps) * cos) + + def d_dt_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Compute the derivative of sigma with respect to time. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the derivative of sigma with respect to time. + + Notes: + The derivative of sigma as a function of time is given by: + + d/dt sigma(t) = d/dt (-log(cos(t * pi / 2) + eps)) + + Using the chain rule, we get: + + d/dt sigma(t) = (-1 / (cos(t * pi / 2) + eps)) * (-sin(t * pi / 2) * pi / 2) + + This is the derivative that is computed and returned by this method. + """ + cos = (1 - self.eps) * torch.cos(t * torch.pi / 2) + sin = (1 - self.eps) * torch.sin(t * torch.pi / 2) + scale = torch.pi / 2 + derivative = scale * sin / (cos + self.eps) + return derivative.to(device) + + +class LogLinearExpNoiseTransform(ContinuousExpNoiseTransform): + """A log linear exponential schedule.""" + + def __init__(self, eps: Float = 1.0e-3): + """Initialize the CosineNoiseSchedule. + + Args: + eps (Float): small value to prevent numerical issues. + """ + self.direction = TimeDirection.DIFFUSION + self.eps = eps + + def _calculate_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate negative log of data interpolant fraction. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the sigma values for the given time steps. + """ + return -torch.log1p(-(1 - self.eps) * t).to(device) + + def d_dt_sigma(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Compute the derivative of sigma with respect to time. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the derivative of sigma with respect to time. + """ + derivative = (1 - self.eps) / (1 - (1 - self.eps) * t) + return derivative.to(device) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py new file mode 100644 index 0000000000..b3b001b5ec --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/continuous_snr_transforms.py @@ -0,0 +1,294 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import math +from abc import ABC, abstractmethod +from typing import Callable, Optional, Tuple, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +def log(t, eps=1e-20): + """Compute the natural logarithm of a tensor, clamping values to avoid numerical instability. + + Args: + t (Tensor): The input tensor. + eps (float, optional): The minimum value to clamp the input tensor (default is 1e-20). + + Returns: + Tensor: The natural logarithm of the input tensor. + """ + return torch.log(t.clamp(min=eps)) + + +class ContinuousSNRTransform(ABC): + """A base class for continuous SNR schedules.""" + + def __init__(self, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + direction (TimeDirection): required this defines in which direction the scheduler was built + """ + self.direction = string_to_enum(direction, TimeDirection) + + def calculate_log_snr( + self, + t: Tensor, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Public wrapper to generate the time schedule as a tensor. + + Args: + t (Tensor): The input tensor representing the time steps, with values ranging from 0 to 1. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + synchronize (optional[TimeDirection]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one. Defaults to None. + + Returns: + Tensor: A tensor representing the log signal-to-noise (SNR) ratio for the given time steps. + """ + if t.max() > 1: + raise ValueError(f"Invalid value: max continuous time is 1, but got {t.max().item()}") + + if synchronize and self.direction != string_to_enum(synchronize, TimeDirection): + t = 1 - t + return self._calculate_log_snr(t, device) + + @abstractmethod + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the log signal-to-noise (SNR) ratio. + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the log SNR values for the given time steps. + """ + pass + + def log_snr_to_alphas_sigmas(self, log_snr: Tensor) -> Tuple[Tensor, Tensor]: + """Converts log signal-to-noise ratio (SNR) to alpha and sigma values. + + Args: + log_snr (Tensor): The input log SNR tensor. + + Returns: + tuple[Tensor, Tensor]: A tuple containing the squared root of alpha and sigma values. + """ + squared_alpha = log_snr.sigmoid() + squared_sigma = (-log_snr).sigmoid() + return squared_alpha.sqrt(), squared_sigma.sqrt() + + def derivative(self, t: Tensor, func: Callable) -> Tensor: + """Compute derivative of a function, it supports bached single variable inputs. + + Args: + t (Tensor): time variable at which derivatives are taken + func (Callable): function for derivative calculation + + Returns: + Tensor: derivative that is detached from the computational graph + """ + with torch.enable_grad(): + t.requires_grad_(True) + derivative = torch.autograd.grad(func(t).sum(), t, create_graph=False)[0].detach() + t.requires_grad_(False) + return derivative + + def calculate_general_sde_terms(self, t): + """Compute the general SDE terms for a given time step t. + + Args: + t (Tensor): The input tensor representing the time step. + + Returns: + tuple[Tensor, Tensor]: A tuple containing the drift term f_t and the diffusion term g_t_2. + + Notes: + This method computes the drift and diffusion terms of the general SDE, which can be used to simulate the stochastic process. + The drift term represents the deterministic part of the process, while the diffusion term represents the stochastic part. + """ + t = t.clone() + t.requires_grad_(True) + + # Compute log SNR + log_snr = self.calculate_log_snr(t, device=t.device) + + # Alpha^2 and Sigma^2 + alpha_squared = torch.sigmoid(log_snr) + sigma_squared = torch.sigmoid(-log_snr) + + # Log Alpha + log_alpha = 0.5 * torch.log(alpha_squared) + + # Compute derivatives + log_alpha_deriv = torch.autograd.grad(log_alpha.sum(), t, create_graph=False)[0].detach() + sigma_squared_deriv = torch.autograd.grad(sigma_squared.sum(), t, create_graph=False)[0].detach() + + # Compute drift and diffusion terms + f_t = log_alpha_deriv # Drift term + g_t_2 = sigma_squared_deriv - 2 * log_alpha_deriv * sigma_squared # Diffusion term + + return f_t, g_t_2 + + def calculate_beta(self, t): + r"""Compute the drift coefficient for the OU process of the form $dx = -\frac{1}{2} \beta(t) x dt + sqrt(beta(t)) dw_t$. + + beta = d/dt log(alpha**2) = 2 * 1/alpha * d/dt(alpha) + + Args: + t (Union[float, Tensor]): t in [0, 1] + + Returns: + Tensor: beta(t) + """ + t = t.clone() + t.requires_grad_(True) + log_snr = self.calculate_log_snr(t, device=t.device) + alpha = self.calculate_alpha_log_snr(log_snr).detach() + alpha_deriv_t = self.derivative(t, self.calculate_alpha_t).detach() + beta = 2.0 * alpha_deriv_t / alpha + # Chroma has a negative here but when removing the negative we get f = d/dt log (alpha**2) and the step_ode function works as expected + return beta + + def calculate_alpha_log_snr(self, log_snr: Tensor) -> Tensor: + """Compute alpha values based on the log SNR. + + Args: + log_snr (Tensor): The input tensor representing the log signal-to-noise ratio. + + Returns: + Tensor: A tensor representing the alpha values for the given log SNR. + + Notes: + This method computes alpha values as the square root of the sigmoid of the log SNR. + """ + return torch.sigmoid(log_snr).sqrt() + + def calculate_alpha_t(self, t: Tensor) -> Tensor: + """Compute alpha values based on the log SNR schedule. + + Parameters: + t (Tensor): The input tensor representing the time steps. + + Returns: + Tensor: A tensor representing the alpha values for the given time steps. + + Notes: + This method computes alpha values as the square root of the sigmoid of the log SNR. + """ + log_snr = self.calculate_log_snr(t, device=t.device) + alpha = torch.sigmoid(log_snr).sqrt() + return alpha + + +class CosineSNRTransform(ContinuousSNRTransform): + """A cosine SNR schedule. + + Args: + nu (Optional[Float]): Hyperparameter for the cosine schedule exponent (default is 1.0). + s (Optional[Float]): Hyperparameter for the cosine schedule shift (default is 0.008). + """ + + def __init__(self, nu: Float = 1.0, s: Float = 0.008): + """Initialize the CosineNoiseSchedule.""" + self.direction = TimeDirection.DIFFUSION + self.nu = nu + self.s = s + + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the log signal-to-noise ratio (SNR) for the cosine noise schedule i.e. -gamma. + + The SNR is the equivalent to alpha_bar**2 / (1 - alpha_bar**2) from DDPM. + This method computes the log SNR as described in the paper "Improved Denoising Diffusion Probabilistic Models" (https://arxiv.org/pdf/2107.00630). + Note 1 / (1 + exp(- log_snr)) returns this cosine**2 for alpha_bar**2 + See https://openreview.net/attachment?id=2LdBqxc1Yv&name=supplementary_material and https://github.com/lucidrains/denoising-diffusion-pytorch/blob/main/denoising_diffusion_pytorch/continuous_time_gaussian_diffusion.py + + Args: + t (Tensor): The input tensor representing the time steps. + device (str): Device to place the schedule on (default is "cpu"). + + Returns: + Tensor: A tensor representing the log SNR for the given time steps. + """ + return -log((torch.cos((t**self.nu + self.s) / (1 + self.s) * math.pi * 0.5) ** -2) - 1, eps=1e-5).to(device) + + +class LinearSNRTransform(ContinuousSNRTransform): + """A Linear SNR schedule.""" + + def __init__(self, min_value: Float = 1.0e-4): + """Initialize the Linear SNR Transform. + + Args: + min_value (Float): min vaue of SNR defaults to 1.e-4. + """ + self.direction = TimeDirection.DIFFUSION + self.min_value = min_value + + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the log signal-to-noise ratio (SNR) for the cosine noise schedule i.e. -gamma. + + The SNR is the equivalent to alpha_bar**2 / (1 - alpha_bar**2) from DDPM. + See https://openreview.net/attachment?id=2LdBqxc1Yv&name=supplementary_material and https://github.com/lucidrains/denoising-diffusion-pytorch/blob/main/denoising_diffusion_pytorch/continuous_time_gaussian_diffusion.py + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the log SNR for the given time steps. + """ + # This is equivalanet to the interpolated one from -10 to 9.2 + return -log(torch.expm1(self.min_value + 10 * (t**2))).to(device) + + +class LinearLogInterpolatedSNRTransform(ContinuousSNRTransform): + """A Linear Log space interpolated SNR schedule.""" + + def __init__(self, min_value: Float = -7.0, max_value=13.5): + """Initialize the Linear log space interpolated SNR Schedule from Chroma. + + Args: + min_value (Float): The min log SNR value. + max_value (Float): the max log SNR value. + """ + self.direction = TimeDirection.DIFFUSION + self.min_value = min_value + self.max_value = max_value + + def _calculate_log_snr(self, t: Tensor, device: Union[str, torch.device] = "cpu") -> Tensor: + """Calculate the log signal-to-noise ratio (SNR) for the cosine noise schedule i.e. -gamma. + + See https://github.com/generatebio/chroma/blob/929407c605013613941803c6113adefdccaad679/chroma/layers/structure/diffusion.py#L316C23-L316C50 + + Args: + t (Tensor): The input tensor representing the time steps. + device (Optional[str]): The device to place the schedule on. Defaults to "cpu". + + Returns: + Tensor: A tensor representing the log SNR for the given time steps. + """ + log_snr = (1 - t) * self.max_value + t * self.min_value + return log_snr.to(device) diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py new file mode 100644 index 0000000000..bc8cfc2cd8 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/noise/discrete_noise_schedules.py @@ -0,0 +1,173 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from abc import ABC, abstractmethod +from typing import Optional, Union + +import torch +from jaxtyping import Float +from torch import Tensor + +from bionemo.moco.interpolants.base_interpolant import string_to_enum +from bionemo.moco.schedules.utils import TimeDirection + + +class DiscreteNoiseSchedule(ABC): + """A base class for discrete noise schedules.""" + + def __init__(self, nsteps: int, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + nsteps (int): number of discrete steps. + direction (TimeDirection): required this defines in which direction the scheduler was built + """ + self.nsteps = nsteps + self.direction = string_to_enum(direction, TimeDirection) + + def generate_schedule( + self, + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Generate the noise schedule as a tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + synchronize (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + """ + schedule = self._generate_schedule(nsteps, device) + if synchronize and self.direction != string_to_enum(synchronize, TimeDirection): + return torch.flip(schedule, dims=[0]) + else: + return schedule + + @abstractmethod + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the noise schedule tensor. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + pass + + def calculate_derivative( + self, + nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None, + ) -> Tensor: + """Calculate the time derivative of the schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + synchronize (Optional[str]): TimeDirection to synchronize the schedule with. If the schedule is defined with a different direction, + this parameter allows to flip the direction to match the specified one (default is None). + + Returns: + Tensor: A tensor representing the time derivative of the schedule. + + Raises: + NotImplementedError: If the derivative calculation is not implemented for this schedule. + """ + raise NotImplementedError("Derivative calculation is not implemented for this schedule.") + + +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule): + """A cosine discrete noise schedule.""" + + def __init__(self, nsteps: int, nu: Float = 1.0, s: Float = 0.008): + """Initialize the CosineNoiseSchedule. + + Args: + nsteps (int): Number of discrete steps. + nu (Optional[Float]): Hyperparameter for the cosine schedule exponent (default is 1.0). + s (Optional[Float]): Hyperparameter for the cosine schedule shift (default is 0.008). + """ + super().__init__(nsteps=nsteps, direction=TimeDirection.DIFFUSION) + self.nu = nu + self.s = s + + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the cosine noise schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + if nsteps is None: + nsteps = self.nsteps + steps = ( + nsteps + 1 + ) #! matches OpenAI code https://github.com/openai/improved-diffusion/blob/main/improved_diffusion/gaussian_diffusion.py#L62 + x = torch.linspace(0, nsteps, steps, device=device) + alphas_cumprod = torch.cos(((x / nsteps) ** self.nu + self.s) / (1 + self.s) * torch.pi * 0.5) ** 2 + alphas_cumprod = alphas_cumprod / alphas_cumprod[0] + betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1]) + betas = torch.clip(betas, 0.001, 0.999) + return 1 - betas + + def _clip_noise_schedule(self, alphas2: Tensor, clip_value: Float = 0.001) -> Tensor: + """For a noise schedule given by alpha^2, this clips alpha_t / alpha_t-1. This may help improve stability during sampling. + + Args: + alphas2 (Tensor): The noise schedule given by alpha^2. + clip_value (Optional[Float]): The minimum value for alpha_t / alpha_t-1 (default is 0.001). + + Returns: + Tensor: The clipped noise schedule. + """ + alphas2 = torch.cat([torch.ones(1, device=alphas2.device), alphas2], dim=0) + + alphas_step = alphas2[1:] / alphas2[:-1] + + alphas_step = torch.clamp(alphas_step, min=clip_value, max=1.0) + alphas2 = torch.cumprod(alphas_step, dim=0) + + return alphas2 + + +class DiscreteLinearNoiseSchedule(DiscreteNoiseSchedule): + """A linear discrete noise schedule.""" + + def __init__(self, nsteps: int, beta_start: Float = 1e-4, beta_end: Float = 0.02): + """Initialize the CosineNoiseSchedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + beta_start (Optional[int]): starting beta value. Defaults to 1e-4. + beta_end (Optional[int]): end beta value. Defaults to 0.02. + """ + super().__init__(nsteps=nsteps, direction=TimeDirection.DIFFUSION) + self.beta_start = beta_start + self.beta_end = beta_end + + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the cosine noise schedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + device (Optional[str]): Device to place the schedule on (default is "cpu"). + """ + if nsteps is None: + nsteps = self.nsteps + betas = torch.linspace(self.beta_start, self.beta_end, nsteps, dtype=torch.float32, device=device) + return 1 - betas diff --git a/sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py new file mode 100644 index 0000000000..e6bd485c16 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/utils.py @@ -0,0 +1,24 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from enum import Enum + + +class TimeDirection(Enum): + """Enum for the direction of the noise schedule.""" + + UNIFIED = "unified" # Noise(0) --> Data(1) + DIFFUSION = "diffusion" # Noise(1) --> Data(0) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py new file mode 100644 index 0000000000..113aa9e0fb --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_gaussian.py @@ -0,0 +1,73 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import torch + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior + + +def test_gaussian_sampling(): + """ + Test that the GaussianPrior can sample with various shapes.""" + mean, std = 0.5, 2.0 + prior = GaussianPrior(mean, std) + + # Test sampling with various shapes + shapes = [(10,), (10, 20), (10, 20, 3)] + for shape in shapes: + samples = prior.sample(shape) + assert samples.shape == shape + + +def test_gaussian_centering_without_mask(): + """ + Test that the GaussianPrior centers the samples without a mask.""" + mean, std = 0, 1 + prior = GaussianPrior(mean, std, center=True) + shape = (10, 20, 3) + samples = prior.sample(shape) + + # Calculate the mean of the samples along the middle dimension + mask = torch.ones(shape[:-1]).bool() + + # Calculate the mean of the samples along the middle dimension + sample_mean = (samples * mask.unsqueeze(-1)).sum(dim=1, keepdim=True) / mask.sum(dim=1, keepdim=True).unsqueeze(-1) + + # Assert the sum of sample means is close to zero + assert torch.abs(sample_mean.sum()) < 1e-5 + + +def test_gaussian_centering_with_mask(): + """ + Test that the GaussianPrior centers the samples with a mask.""" + mean, std = 0, 1 + prior = GaussianPrior(mean, std, center=True) + shape = (30, 4, 50) + mask = torch.ones(shape[:-1]).bool() + mask[:, 2:] = False # Mask out the last 2 elements of the middle dimension + + samples = prior.sample(shape, mask=mask) + # Calculate the mean of the samples along the middle dimension + sample_mean = (samples * mask.unsqueeze(-1)).sum(dim=1, keepdim=True) / mask.sum(dim=1, keepdim=True).unsqueeze(-1) + + # Assert the sum of sample means is close to zero + assert torch.abs(sample_mean.sum()) < 1e-5 + + # Calculate the sum of all the masked out samples + masked_out_samples_sum = (samples * (~mask).unsqueeze(-1)).sum() + + # Assert the sum of all the masked out samples is close to zero + assert torch.abs(masked_out_samples_sum) < 1e-12 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py new file mode 100644 index 0000000000..a5cddb6e54 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/continuous/test_harmonic.py @@ -0,0 +1,28 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from bionemo.moco.distributions.prior.continuous.harmonic import LinearHarmonicPrior + + +def test_harmonic_sampling(): + """ + Test that the LinearHarmonicPrior can sample with various shapes.""" + prior = LinearHarmonicPrior(length=20) + # Test sampling with various shapes + shapes = [(10, 20, 10), (10, 20, 3), (10, 40, 3)] + for shape in shapes: + samples = prior.sample(shape) + assert samples.shape == shape diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py new file mode 100644 index 0000000000..24c7191291 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_custom.py @@ -0,0 +1,76 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.custom import DiscreteCustomPrior + + +def test_discrete_custom_prior_init(): + """Test the initialization of the DiscreteCustomPrior class.""" + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + assert prior.num_classes == num_classes + assert torch.sum(prior.prior_dist).item() - 1.0 < 1e-5 + + +def test_discrete_custom_prior_sample(): + """Test the sample method of the DiscreteCustomPrior class.""" + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + shape = (10, 5) + samples = prior.sample(shape) + assert samples.shape == shape + assert samples.max() <= num_classes - 1 + assert samples.min() >= 0 + + +def test_discrete_custom_prior_sample_with_mask(): + """Test the sample method of the DiscreteCustomPrior class with a mask.""" + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + shape = (10, 5) + mask = torch.ones((10,) + (1,) * (len(shape) - 1)) + mask[5:] = 0 + samples = prior.sample(shape, mask=mask) + assert samples.shape == shape + assert samples.max() <= num_classes - 1 + assert samples.min() >= 0 + assert torch.all(samples[5:] == 0) + + +def test_discrete_custom_prior_sample_on_gpu(): + """Test the sample method of the DiscreteCustomPrior class on a GPU.""" + if not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + num_classes = 10 + prior_dist = torch.zeros(num_classes) + prior_dist[-2:] = 0.5 + prior = DiscreteCustomPrior(prior_dist, num_classes) + shape = (10, 5) + device = "cuda:0" + samples = prior.sample(shape, device=device) + assert samples.device == torch.device(device) + assert samples.shape == shape + assert samples.max() <= num_classes - 1 + assert samples.min() >= 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py new file mode 100644 index 0000000000..d182745413 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_mask.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior + + +def test_discrete_masked_prior_init(): + """Test the initialization of the DiscreteMaskedPrior class.""" + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + assert prior.num_classes == num_classes + assert prior.mask_dim == num_classes - 1 + assert torch.sum(prior.prior_dist).item() - 1.0 < 1e-5 + + +def test_discrete_masked_prior_sample(): + """Test the sample method of the DiscreteMaskedPrior class.""" + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + shape = (10, 5) + samples = prior.sample(shape) + assert samples.shape == shape + assert samples.max() == prior.mask_dim + assert samples.min() >= 0 + + +def test_discrete_masked_prior_sample_with_mask(): + """Test the sample method of the DiscreteMaskedPrior class with a mask.""" + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + shape = (10, 5) + mask = torch.ones((10,) + (1,) * (len(shape) - 1)) + mask[5:] = 0 + samples = prior.sample(shape, mask=mask) + assert samples.shape == shape + assert samples.max() == prior.mask_dim + assert samples.min() >= 0 + assert torch.all(samples[5:] == 0) + + +def test_discrete_masked_prior_sample_on_gpu(): + """Test the sample method of the DiscreteMaskedPrior class on a GPU.""" + if not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + num_classes = 10 + prior = DiscreteMaskedPrior(num_classes) + shape = (10, 5) + device = "cuda:0" + samples = prior.sample(shape, device=device) + assert samples.device == torch.device(device) + assert samples.shape == shape + assert samples.max() == prior.mask_dim + assert samples.min() >= 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py new file mode 100644 index 0000000000..fbfb28cd47 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/prior/discrete/test_uniform.py @@ -0,0 +1,68 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.uniform import DiscreteUniformPrior + + +def test_discrete_uniform_prior_init(): + """Test the initialization of the DiscreteUniformPrior class.""" + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + assert prior.num_classes == num_classes + assert torch.sum(prior.prior_dist).item() - 1.0 < 1e-5 + + +def test_discrete_uniform_prior_sample(): + """Test the sample method of the DiscreteUniformPrior class.""" + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + shape = (10, 5) + samples = prior.sample(shape) + assert samples.shape == shape + assert samples.max() < num_classes + assert samples.min() >= 0 + + +def test_discrete_uniform_prior_sample_with_mask(): + """Test the sample method of the DiscreteUniformPrior class with a mask.""" + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + shape = (10, 5) + mask = torch.ones((10,) + (1,) * (len(shape) - 1)) + mask[5:] = 0 + samples = prior.sample(shape, mask=mask) + assert samples.shape == shape + assert samples.max() < num_classes + assert samples.min() >= 0 + assert torch.all(samples[5:] == 0) + + +def test_discrete_uniform_prior_sample_on_gpu(): + """Test the sample method of the DiscreteUniformPrior class on a GPU.""" + if not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + num_classes = 10 + prior = DiscreteUniformPrior(num_classes) + shape = (10, 5) + device = "cuda:0" + samples = prior.sample(shape, device=device) + assert samples.device == torch.device(device) + assert samples.shape == shape + assert samples.max() < num_classes + assert samples.min() >= 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py new file mode 100644 index 0000000000..15404806b3 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/distributions/time/test_time_distribution.py @@ -0,0 +1,146 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.time.beta import BetaTimeDistribution +from bionemo.moco.distributions.time.distribution import MixTimeDistribution +from bionemo.moco.distributions.time.logit_normal import LogitNormalTimeDistribution +from bionemo.moco.distributions.time.uniform import SymmetricUniformTimeDistribution, UniformTimeDistribution + + +# List of distributions to test +distributions = [ + (BetaTimeDistribution, {"p1": 2.0, "p2": 1.0}), + (UniformTimeDistribution, {}), + (SymmetricUniformTimeDistribution, {}), + (LogitNormalTimeDistribution, {"p1": 0.0, "p2": 1.0}), +] + +# Devices to test +devices = ["cpu"] +if torch.cuda.is_available(): + devices.append("cuda") + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_continuous_time_sampling(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=False, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=1000, device=device) + + # Check if the samples are within the correct range + assert torch.all(samples >= 0.0) + assert torch.all(samples <= 1.0) + + # Check if the shape of the samples is correct + assert samples.shape == (1000,) + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_discrete_time_sampling(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=True, nsteps=10, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=1000, device=device) + + # Check if the samples are within the correct range + assert torch.all(samples >= 0) + assert torch.all(samples <= 9) + + # Check if the shape of the samples is correct + assert samples.shape == (1000,) + + # Check if the samples are integers + assert samples.dtype == torch.int64 + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_sample_shape(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=False, **dist_kwargs) + + # Sample from the distribution with different number of samples + samples100 = dist.sample(n_samples=100, device=device) + samples1000 = dist.sample(n_samples=1000, device=device) + + # Check if the shape of the samples is correct + assert samples100.shape == (100,) + assert samples1000.shape == (1000,) + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_device(dist_class, dist_kwargs, device): + # Initialize the time distribution + dist = dist_class(min_t=0.0, max_t=1.0, discrete_time=False, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=100, device=device) + + # Check if the samples are on the correct device + assert samples.device.type == device + + +@pytest.mark.parametrize("dist_class, dist_kwargs", distributions) +@pytest.mark.parametrize("device", devices) +def test_min_max_t(dist_class, dist_kwargs, device): + # Initialize the time distribution with min_t and max_t + dist = dist_class(min_t=1e-2, max_t=0.99, discrete_time=False, **dist_kwargs) + + # Sample from the distribution + samples = dist.sample(n_samples=1000, device=device) + + # Check if the samples are within the correct range + assert torch.all(samples >= 1e-2) + assert torch.all(samples <= 0.99) + + +def test_mix_time_distribution(): + # Create a mix of Uniform and Beta distributions + uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) + beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) + mix_dist = MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=0.5) + + # Test sampling + n_samples = 100 + device = "cpu" + samples = mix_dist.sample(n_samples, device) + + # Check that the samples are within the correct range + assert (samples >= 0.0).all() and (samples <= 1.0).all() + + # Test that the device is correct + assert samples.device == torch.device(device) + + +def test_mix_time_distribution_edge_cases(): + # Test that the mix fraction is validated correctly + uniform_dist = UniformTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False) + beta_dist = BetaTimeDistribution(min_t=0.0, max_t=1.0, discrete_time=False, p1=2.0, p2=1.0) + + with pytest.raises(ValueError): + MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=-0.1) + + with pytest.raises(ValueError): + MixTimeDistribution(uniform_dist, beta_dist, mix_fraction=1.1) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py new file mode 100644 index 0000000000..42881aae97 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py @@ -0,0 +1,273 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import pytest +import torch +import torch.nn.functional as F + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.base_interpolant import PredictionType +from bionemo.moco.interpolants.continuous_time.continuous.continuous_flow_matching import ContinuousFlowMatcher + + +@pytest.fixture +def flow_matcher(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=False) + flow_matcher = ContinuousFlowMatcher( + time_distribution=time_distribution, prior_distribution=prior, prediction_type="vector_field" + ) + return flow_matcher + + +@pytest.fixture +def data_matcher(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=False) + flow_matcher = ContinuousFlowMatcher( + time_distribution=time_distribution, prior_distribution=prior, prediction_type=PredictionType.DATA + ) + return flow_matcher + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["flow_matcher"]) +def test_cfm_interpolate(request, fixture, device): + # Create an indices tensor + flow_matcher = request.getfixturevalue(fixture) + assert flow_matcher is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + + # Create a tensor of shape 32 x 10 x 3 where each element is a 3-dimensional one-hot vector + data = F.one_hot(indices, 3).float().to(device) + time = flow_matcher.sample_time(32) + noise = flow_matcher.sample_prior(data.shape) + xt = flow_matcher.interpolate(data, time, noise) + assert xt.shape == data.shape + + # When time is 0, the output should be the noise + data_time = torch.ones_like(time).to(device) * 0 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert torch.all(error < 1e-7) + + # When time is close to 1, i.e. 0.999, the output should be the data + data_time = torch.ones_like(time).to(device) * 0.999 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - (noise + (data - noise) * 0.999)) ** 2 + assert torch.all(error < 1e-7) + + # When time is 0.5, if the data is the reflection of the noise, the output should be zeros + data_time = torch.ones_like(time).to(device) * 0.5 + new_data = torch.clone(noise) * -1 + xt = flow_matcher.interpolate(new_data, data_time, noise) + error = (xt - torch.zeros_like(xt)) ** 2 + assert torch.all(error < 1e-7) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_step(flow_matcher, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + time = flow_matcher.sample_time(32, device=device) + noise = flow_matcher.sample_prior(data.shape, device=device) + + # Check if the last step works + T = 0.999 + dt = time * 0 + 0.001 + model_out = data - noise + xt = noise + (data - noise) * T + next_xt = flow_matcher.step(model_out, xt, dt) + assert next_xt.shape == data.shape + error = (next_xt - data) ** 2 + assert torch.all(error < 1e-7) + + # When data is the reflection of the noise, check if sign flips after passing t=0.5 + data = noise * -1 + T = 0.499 + dt = time * 0 + 0.002 + model_out = data - noise + xt = noise + (data - noise) * T + assert torch.all(torch.sign(xt) == torch.sign(noise)) + next_xt = flow_matcher.step(model_out, xt, dt) + next_xt_gt = noise + (data - noise) * 0.501 + assert torch.all(torch.sign(next_xt) == torch.sign(data)) + error = (next_xt - next_xt_gt) ** 2 + assert torch.all(error < 1e-7) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_loss(flow_matcher, device): + # Check if CUDA is available + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + noise = flow_matcher.sample_prior(data.shape, device=device) + # Set the ground truth to be the flow, like rectified flow objective + gt_flow = flow_matcher.calculate_target(data, noise) # data - noise + # Set the model output to be the flow with small noise perturbation + model_out = (data - noise) + torch.randn_like(data) * 0.001 + # Create a mask to mask the last 4 elements of the sequence + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + # Mask out the model output to test if masking in loss works + model_out = model_out * mask.unsqueeze(-1) + + # Calculate the loss, only model_out is masked but not gt_flow + loss = flow_matcher.loss(model_out, gt_flow, mask=None, target_type="velocity") + # Check the shape of the loss + assert loss.shape == (32,) + # When mask input to flow_matcher.loss is None, the loss should be large because gt is not masked + assert loss.mean() > 0.1 + + # Calculate the loss with input argument mask as the mask + loss = flow_matcher.loss(model_out, gt_flow, mask=mask, target_type=PredictionType.VELOCITY) + # When mask input to flow_matcher.loss is None, the loss should be small + assert loss.mean() < 1e-4 + # Calculate the loss with input argument mask as the mask + time = flow_matcher.sample_time(32) + xt = flow_matcher.interpolate(data, time, noise) + loss = flow_matcher.loss( + model_out, data * mask.unsqueeze(-1), time, xt, mask=mask, target_type=PredictionType.DATA + ) + # When mask input to flow_matcher.loss is None, the loss should be small + assert loss.mean() < 1e-4 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["data_matcher"]) +def test_cfm_interpolate_data(request, fixture, device): + # Create an indices tensor + torch.manual_seed(42) + flow_matcher = request.getfixturevalue(fixture) + assert flow_matcher is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = flow_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + + # Create a tensor of shape 32 x 10 x 3 where each element is a 3-dimensional one-hot vector + data = F.one_hot(indices, 3).float().to(device) + time = flow_matcher.sample_time(32) + noise = flow_matcher.sample_prior(data.shape) + xt = flow_matcher.interpolate(data, time, noise) + assert xt.shape == data.shape + + # When time is 0, the output should be the noise + data_time = torch.ones_like(time).to(device) * 0 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert torch.all(error < 1e-7) + + # When time is close to 1, i.e. 0.999, the output should be the data + data_time = torch.ones_like(time).to(device) * 0.999 + xt = flow_matcher.interpolate(data, data_time, noise) + error = (xt - (noise + (data - noise) * 0.999)) ** 2 + assert torch.all(error < 1e-7) + + # When time is 0.5, if the data is the reflection of the noise, the output should be zeros + data_time = torch.ones_like(time).to(device) * 0.5 + new_data = torch.clone(noise) * -1 + xt = flow_matcher.interpolate(new_data, data_time, noise) + error = (xt - torch.zeros_like(xt)) ** 2 + assert torch.all(error < 1e-7) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_step_data(data_matcher, device): + # Create an indices tensor + torch.manual_seed(42) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + flow_matcher = data_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + time = flow_matcher.sample_time(32, device=device) + noise = flow_matcher.sample_prior(data.shape, device=device) + + # Check if the last step works + T = 0.999 + dt = time * 0 + 0.001 + model_out = data + xt = noise + (data - noise) * T + next_xt = flow_matcher.step(model_out, xt, dt, time * 0 + T) + assert next_xt.shape == data.shape + error = (next_xt - data) ** 2 + assert torch.all(error < 1e-7) + + # When data is the reflection of the noise, check if sign flips after passing t=0.5 + data = noise * -1 + T = 0.499 + dt = time * 0 + 0.002 + model_out = data + xt = noise + (data - noise) * T + assert torch.all(torch.sign(xt) == torch.sign(noise)) + next_xt = flow_matcher.step(model_out, xt, dt, time * 0 + T) + next_xt_gt = noise + (data - noise) * 0.501 + assert torch.all(torch.sign(next_xt) == torch.sign(data)) + error = (next_xt - next_xt_gt) ** 2 + assert torch.all(error < 1e-7) + + next_xt = flow_matcher.step_score_stochastic(model_out, xt, dt, time * 0 + T) + next_xt = flow_matcher.general_step( + "step_score_stochastic", {"model_out": model_out, "xt": xt, "dt": dt, "t": time * 0 + T} + ) + error = (next_xt - next_xt_gt) ** 2 + assert error.mean() < 1e-2 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cfm_loss_data(data_matcher, device): + # Check if CUDA is available + torch.manual_seed(42) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + flow_matcher = data_matcher.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + noise = flow_matcher.sample_prior(data.shape, device=device) + # Set the ground truth to be the flow, like rectified flow objective + gt_target = flow_matcher.calculate_target(data, noise) # data - noise + # Set the model output to be the flow with small noise perturbation + model_out = data + torch.randn_like(data) * 0.001 + # Create a mask to mask the last 4 elements of the sequence + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + # Mask out the model output to test if masking in loss works + model_out = model_out * mask.unsqueeze(-1) + time = flow_matcher.sample_time(32) + xt = flow_matcher.interpolate(data, time, noise) + # Calculate the loss, only model_out is masked but not gt_flow + loss = flow_matcher.loss(model_out, gt_target, time, xt) + # Check the shape of the loss + assert loss.shape == (32,) + # When mask input to flow_matcher.loss is None, the loss should be large because gt is not masked + assert loss.mean() > 0.1 + + # Calculate the loss with input argument mask as the mask + loss = flow_matcher.loss(model_out, gt_target * mask.unsqueeze(-1), time, xt, mask=mask) + assert loss.mean() < 1e-2 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py new file mode 100644 index 0000000000..76828f3739 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_optimal_transport.py @@ -0,0 +1,334 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import numpy as np +import pytest +import torch + +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.equivariant_ot_sampler import ( + EquivariantOTSampler, +) +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.kabsch_augmentation import ( + KabschAugmentation, +) +from bionemo.moco.interpolants.continuous_time.continuous.optimal_transport.ot_sampler import OTSampler + + +@pytest.fixture +def toy_data(): + x0 = torch.tensor( + [ + [[1.1, 1.1, 1.1], [1.1, 1.1, 1.1], [1.1, 1.1, 1.1]], + [[-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1]], + [[1.1, 1.1, 1.1], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + ] + ) + + x1 = torch.tensor( + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], + ] + ) + mask = None + # Calculate the cost in naive for-loop. For exact OT, sqaured Euclidean distance is used + costs = torch.zeros((x0.shape[0], x1.shape[0])) + for i in range(x0.shape[0]): + for j in range(x0.shape[0]): + c = torch.sum(torch.square(x0[i] - x1[j])) + costs[i, j] = c + return x0, x1, mask, costs + + +@pytest.fixture +def toy_masked_data(): + x0 = torch.tensor( + [ + [[1.1, 1.1, 1.1], [1.1, 1.1, 1.1], [1.1, 1.1, 1.1]], + [[-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1], [-1.1, -1.1, -1.1]], + [[1.1, 1.1, 1.1], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + ] + ) + + x1 = torch.tensor( + [ + [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + [[1.0, 1.0, 1.0], [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]], + [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]], + ] + ) + mask = torch.tensor([[1, 1, 0], [1, 1, 1], [1, 0, 0]], dtype=torch.bool) + # Calculate the cost in naive for-loop. For exact OT, sqaured Euclidean distance is used + costs = torch.zeros((x0.shape[0], x1.shape[0])) + for i in range(x0.shape[0]): + mm = mask[i].unsqueeze(-1) + for j in range(x0.shape[0]): + per_atom_cost = torch.where(mm, torch.square(x0[i] - x1[j]), 0) + c = torch.sum(per_atom_cost) + costs[i, j] = c + return x0, x1, mask, costs + + +@pytest.fixture +def exact_ot_sampler(): + ot_sampler = OTSampler(method="exact", num_threads=1) + return ot_sampler + + +@pytest.fixture +def equivariant_ot_sampler(): + ot_sampler = EquivariantOTSampler(method="exact", num_threads=1) + return ot_sampler + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("sampler", ["exact_ot_sampler"]) +@pytest.mark.parametrize("data", ["toy_data", "toy_masked_data"]) +def test_exact_ot_sampler_ot_matrix(request, sampler, data, device): + # Create an indices tensor + ot_sampler = request.getfixturevalue(sampler) + assert ot_sampler is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ot_sampler = ot_sampler.to_device(device) + x0, x1, mask, ground_truth_cost_matrix = request.getfixturevalue(data) + + cost_matrix = ot_sampler._calculate_cost_matrix(x0, x1, mask=mask) + assert cost_matrix.shape == (3, 3) + assert torch.allclose(cost_matrix, ground_truth_cost_matrix, atol=1e-8) + + ot_matrix = ot_sampler.get_ot_matrix(x0, x1, mask=mask) + ot_truth = torch.tensor([[1 / 3, 0.0, 0.0], [0.0, 0.0, 1 / 3], [0.0, 1 / 3, 0.0]]) + assert ot_matrix.shape == (3, 3) + assert torch.allclose(ot_matrix, ot_truth, atol=1e-8) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("sampler", ["exact_ot_sampler"]) +@pytest.mark.parametrize("data", ["toy_data", "toy_masked_data"]) +def test_exact_ot_sampler_sample_map(request, sampler, data, device): + # Create an indices tensor + ot_sampler = request.getfixturevalue(sampler) + assert ot_sampler is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ot_sampler = ot_sampler.to_device(device) + x0, x1, mask, ground_truth_cost_matrix = request.getfixturevalue(data) + x0, x1 = x0.to(device), x1.to(device) + if mask is not None: + mask = mask.to(device) + ot_matrix = ot_sampler.get_ot_matrix(x0, x1, mask=mask) + correct_mapping = {0: 0, 1: 2, 2: 1} + + x0_idx, x1_idx = ot_sampler.sample_map(ot_matrix, x0.shape[0], replace=False) + assert x0_idx.shape == (x0.shape[0],) + assert x1_idx.shape == (x1.shape[0],) + all_indices = set(range(x0.shape[0])) + sampled_indices = set() + for i in range(len(x0_idx)): + sampled_indices.add(x0_idx[i].item()) + assert x1_idx[i].item() == correct_mapping[x0_idx[i].item()] + # When replace is False, all indices should be sampled + assert all_indices == sampled_indices + + x0_idx, x1_idx = ot_sampler.sample_map(ot_matrix, x0.shape[0], replace=True) + assert x0_idx.shape == (x0.shape[0],) + assert x1_idx.shape == (x1.shape[0],) + for i in range(len(x0_idx)): + sampled_indices.add(x0_idx[i].item()) + assert x1_idx[i].item() == correct_mapping[x0_idx[i].item()] + # When replace is True, not all indices should be sampled + + # Final test to check the apply_ot function + # First check preserving the order of noise + ot_sampled_x0, ot_sampled_x1, ot_sampled_mask = ot_sampler.apply_ot(x0, x1, mask=mask, replace=False, sort="x0") + for i in range(len(x0_idx)): + # Check if x0 output from apply_ot follows the correct order + assert torch.allclose(ot_sampled_x0[i], x0[i], atol=1e-7) + # Check if x1 output from apply_ot matches the correct mapping + assert torch.allclose(ot_sampled_x0[i], ot_sampled_x1[i], atol=0.1) + # Check if mask is preserved + if mask is not None: + assert (ot_sampled_mask[i] == mask[i]).all() + + # Then check preserving the order of data + ot_sampled_x0, ot_sampled_x1, ot_sampled_mask = ot_sampler.apply_ot(x0, x1, mask=mask, replace=False, sort="x1") + reverse_mapping = {v: k for k, v in correct_mapping.items()} + for i in range(len(x0_idx)): + # Check if x1 output from apply_ot follows the correct order + assert torch.allclose(ot_sampled_x1[i], x1[i], atol=1e-7) + # Check if x1 output from apply_ot matches the correct mapping + assert torch.allclose(ot_sampled_x0[i], ot_sampled_x1[i], atol=0.1) + # Check if mask is preserved + if mask is not None: + assert (ot_sampled_mask[i] == mask[reverse_mapping[i]]).all() + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("sampler", ["equivariant_ot_sampler"]) +def test_equivariant_ot_sampler_kabsch_align(request, sampler, device): + ot_sampler = request.getfixturevalue(sampler) + assert ot_sampler is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + if device == "cuda": + atol = 1e-2 + else: + atol = 1e-6 + ot_sampler = ot_sampler.to_device(device) + x0 = torch.randn(size=(32, 3), device=device) + alpha = np.random.rand() * 2 * np.pi + R = torch.Tensor(np.array([[np.cos(alpha), -np.sin(alpha), 0], [np.sin(alpha), np.cos(alpha), 0], [0, 0, 1]])).to( + device + ) + # Apply rotation and translation to x0 + x0_rotated = x0 @ R.T + torch.ones_like(x0) * 5 + + R_kabsch = ot_sampler.kabsch_align(x0, x0_rotated) + assert R_kabsch.shape == (3, 3) + assert torch.allclose(R_kabsch, R, atol=atol) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("sampler", ["equivariant_ot_sampler"]) +def test_equivariant_ot_sample_map(request, sampler, device): + ot_sampler = request.getfixturevalue(sampler) + assert ot_sampler is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + if device == "cuda": + atol = 1e-2 + else: + atol = 1e-6 + ot_sampler = ot_sampler.to_device(device) + x0 = torch.tensor( + [ + [[2, 1, 2], [2, 1, -2], [-2, -1, 2], [-2, -1, -2], [0, 0, 0]], # mask last, rectangle + [[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 0]], # mask last 2, triangle + [[2, 0, 0], [0, 2, 0], [-2, 0, 0], [0, -2, 0], [0, 0, 2]], # mask none, pyramid + ], + dtype=torch.float32, + ).to(device) + mask = torch.tensor([[1, 1, 1, 1, 0], [1, 1, 1, 0, 0], [1, 1, 1, 1, 1]], dtype=torch.bool).to(device) + Rs = [] + for i in range(x0.shape[0]): + alpha = np.random.rand() * 2 * np.pi + R = torch.Tensor( + np.array([[np.cos(alpha), -np.sin(alpha), 0], [np.sin(alpha), np.cos(alpha), 0], [0, 0, 1]]) + ).to(device) + Rs.append(R) + + # Define correct mapping + mapping = {0: 1, 1: 2, 2: 0} + + # Create rotated x0 + x0_rotated = torch.zeros_like(x0) + for i in range(len(x0)): + x0_rotated[mapping[i]] = x0[i] @ Rs[i].T + + # Test the get_ot_matrix and sample_map functions + ot_matrix, Rs_output = ot_sampler.get_ot_matrix(x0, x0_rotated, mask=mask) + x0_idx, x0_rotated_idx = ot_sampler.sample_map(ot_matrix, x0.shape[0], replace=False) + assert x0_idx.shape == (x0.shape[0],) + assert x0_rotated_idx.shape == (x0_rotated.shape[0],) + + rotations = Rs_output[x0_idx, x0_rotated_idx] + + # Make sure the Rotation matrices are correct by checking if x0_rotated can be rotated back to x0 + for i in range(len(x0_idx)): + assert x0_rotated_idx[i].item() == mapping[x0_idx[i].item()] + RR = rotations[i] + x0_rotate_back = x0_rotated[x0_rotated_idx[i]] @ RR + assert torch.allclose(x0[x0_idx[i]], x0_rotate_back, atol=atol) + + # Final test to check the apply_ot function + # First check preserving the order of noise + realigned_x0, realigned_x0_rotated, realigned_mask = ot_sampler.apply_ot( + x0, x0_rotated, mask=mask, replace=False, sort="x0" + ) + for i in range(len(x0_idx)): + # Check if x0 output from apply_ot follows the correct order + assert torch.allclose(realigned_x0[i], x0[i], atol=atol) + # Check if x1 output from apply_ot is rotated correctly + assert torch.allclose(realigned_x0[i], realigned_x0_rotated[i], atol=atol) + # Check if mask is preserved + assert (realigned_mask[i] == mask[i]).all() + + # Then check preserving the order of data + realigned_x0, realigned_x0_rotated, realigned_mask = ot_sampler.apply_ot( + x0, x0_rotated, mask=mask, replace=False, sort="x1" + ) + reverse_mapping = {v: k for k, v in mapping.items()} + for i in range(len(x0_idx)): + # Check if x0 output from apply_ot follows the correct order + # Since the realigned_x0_rotated is rotated back to x0, we check if it is equal to x0[reverse_mapping[i]] + assert torch.allclose(realigned_x0_rotated[i], x0[reverse_mapping[i]], atol=atol) + # Check if x1 output from apply_ot is rotated correctly + assert torch.allclose(realigned_x0[i], realigned_x0_rotated[i], atol=atol) + # Check if mask is preserved + assert (realigned_mask[i] == mask[reverse_mapping[i]]).all() + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_kabsch_augmentation(request, device): + torch.manual_seed(42) + np.random.seed(42) + augmentor = KabschAugmentation() + assert augmentor is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + if device == "cuda": + atol = 1e-2 + else: + atol = 1e-6 + x0 = torch.randn(size=(32, 3), device=device) + alpha = np.random.rand() * 2 * np.pi + R = torch.Tensor(np.array([[np.cos(alpha), -np.sin(alpha), 0], [np.sin(alpha), np.cos(alpha), 0], [0, 0, 1]])).to( + device + ) + # Apply rotation and translation to x0 + x0_rotated = x0 @ R.T + torch.ones_like(x0) * 5 + R_kabsch, _ = augmentor.kabsch_align(x0, x0_rotated) + assert R_kabsch.shape == (3, 3) + assert torch.allclose(R_kabsch, R, atol=atol) + x0_aligned, x0_copy = augmentor.apply_ot(x0_rotated, x0, align_noise_to_data=True) + assert torch.allclose(x0, x0_copy, atol=atol) + assert torch.allclose(x0_aligned, x0, atol=atol) + + x0_rotated_copy, x0_rotated_aligned = augmentor.apply_ot(x0_rotated, x0, align_noise_to_data=False) + assert torch.allclose(x0_rotated, x0_rotated_copy, atol=atol) + assert torch.allclose(x0_rotated_aligned, x0_rotated, atol=atol) + + # Batch wise tests + x0 = torch.randn(size=(10, 32, 3), device=device) + alpha = np.random.rand() * 2 * np.pi + R = torch.Tensor(np.array([[np.cos(alpha), -np.sin(alpha), 0], [np.sin(alpha), np.cos(alpha), 0], [0, 0, 1]])).to( + device + ) + # Apply rotation and translation to x0 + x0_rotated = x0 @ R.T + torch.ones_like(x0) * 5 + R_kabsch, _ = augmentor.batch_kabsch_align(x0, x0_rotated) + assert R_kabsch.shape == (10, 3, 3) + assert torch.allclose(R_kabsch, R, atol=atol) + x0_aligned, x0_copy = augmentor.apply_ot(x0_rotated, x0, align_noise_to_data=True) + assert torch.allclose(x0, x0_copy, atol=atol) + assert torch.allclose(x0_aligned, x0, atol=atol) # values are close but error ranges from <1 to 2 e -6 + + x0_rotated_copy, x0_rotated_aligned = augmentor.apply_ot(x0_rotated, x0, align_noise_to_data=False) + assert torch.allclose(x0_rotated, x0_rotated_copy, atol=atol) + assert torch.allclose(x0_rotated_aligned, x0_rotated, atol=atol) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py new file mode 100644 index 0000000000..b76ace8a9a --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_vdm.py @@ -0,0 +1,194 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +# tests/moco/interpolants/discrete_time/continuous/test_vdm.py + +import pytest +import torch +import torch.nn.functional as F + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.continuous_time.continuous.vdm import VDM +from bionemo.moco.schedules.noise.continuous_snr_transforms import CosineSNRTransform + + +@pytest.fixture +def vdm(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=False) + noise_schedule = CosineSNRTransform() + vdm = VDM(time_distribution, prior, noise_schedule) + return vdm + + +@pytest.fixture +def vdm_centered(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = GaussianPrior(center=True) + noise_schedule = CosineSNRTransform() + vdm = VDM(time_distribution, prior, noise_schedule) + return vdm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["vdm", "vdm_centered"]) +def test_vdm_interpolate(request, fixture, device): + vdm = request.getfixturevalue(fixture) + assert vdm is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + time = vdm.sample_time(32) + noise = vdm.sample_prior(data.shape) + xt = vdm.interpolate(data, time, noise) + assert xt.shape == data.shape + + data_time = torch.ones_like(time).to(device) * 0 + xt = vdm.interpolate(data, data_time, noise) + error = (xt - data) ** 2 + assert error.mean() <= 2e-3 + data_time = torch.ones_like(time).to(device) * (1 - 1e-7) + xt = vdm.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert error.mean() < 1e-7 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_vdm_step(vdm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + T = 1 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + dt = torch.ones_like(time) * 1 / 1000 + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = vdm.step(model_out, time, xt, dt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert torch.allclose(error.mean(), torch.tensor(0.0001), atol=1e-4) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_vdm_centered_step(vdm_centered, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm_centered.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + data = vdm.clean_mask_center(data, center=True) + T = 1 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + dt = torch.ones_like(time) * 1 / 1000 + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = vdm.step(model_out, time, xt, dt, center=True) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert torch.allclose(error.mean(), torch.tensor(0.0001), atol=1e-4) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("weight_type", ["ones", "data_to_noise"]) +def test_vdm_loss(vdm, device, weight_type): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + T = 1 + time = vdm.sample_time(32, device=device) * 0 + T + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + data = data * mask.unsqueeze(-1) + model_out = model_out * mask.unsqueeze(-1) + + loss = vdm.loss(model_out, data, time, mask=mask, weight_type=weight_type) + assert loss.shape == (32,) + assert loss.mean() < 1e-3 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_vdm_2d_step(vdm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + vdm = vdm.to_device(device) + data = torch.rand((32, 10, 10, 3)).to(device) + T = 1 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + dt = torch.ones_like(time) * 1 / 1000 + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + _ = vdm.interpolate(data, time, noise) + xt = 0.99 * data + 0.01 * noise + next_xt = vdm.step(model_out, time, xt, dt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert torch.allclose(error.mean(), torch.tensor(0.0001), atol=1e-4) + T = 100 / 1000 + time = vdm.sample_time(32, device=device) * 0 + T + noise = vdm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = vdm.step(model_out, time, xt, dt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("devices", [("cpu", "cuda"), ("cuda", "cpu")]) +def test_vdm_to_device_multiple(vdm, devices): + if "cuda" in devices and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + vdm.to_device(devices[0]) + + for attr_name in dir(vdm): + if attr_name.startswith("_") and isinstance(getattr(vdm, attr_name), torch.Tensor): + assert getattr(vdm, attr_name).device.type == devices[0] + + vdm.to_device(devices[1]) + + for attr_name in dir(vdm): + if attr_name.startswith("_") and isinstance(getattr(vdm, attr_name), torch.Tensor): + assert getattr(vdm, attr_name).device.type == devices[1] + + assert vdm.device == devices[1] diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py new file mode 100644 index 0000000000..5e366ed614 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_discrete_flow_matching.py @@ -0,0 +1,241 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.prior.discrete.uniform import DiscreteUniformPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.continuous_time.discrete.discrete_flow_matching import DiscreteFlowMatcher + + +@pytest.fixture +def dfm_mask(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteMaskedPrior(num_classes=20) # 19 data classes 1 mask class + dfm = DiscreteFlowMatcher(time_distribution, prior) + return dfm + + +@pytest.fixture +def dfm_mask_non_inclusive(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteMaskedPrior(num_classes=20, inclusive=False) + dfm = DiscreteFlowMatcher(time_distribution, prior) + return dfm + + +@pytest.fixture +def dfm_uniform(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteUniformPrior(num_classes=20) + dfm = DiscreteFlowMatcher(time_distribution, prior) + return dfm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_interpolate(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + result = dfm.interpolate(data, t, noise) + assert result.shape == (batch_size, num_residues) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_step(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + if isinstance(dfm.prior_distribution, DiscreteMaskedPrior) and dfm.prior_distribution.mask_dim == 20: #! exclusive + logits = dfm.prior_distribution.pad_sample(logits) + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + next_xt = dfm.step_argmax(logits) + assert next_xt.shape == xt.shape + next_xt = dfm.step_simple_sample(logits) + else: + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + next_xt = dfm.step_argmax(logits) + assert next_xt.shape == xt.shape + next_xt = dfm.step_simple_sample(logits) + assert next_xt.shape == xt.shape + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive"]) +def test_dfm_loss(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + loss = dfm.loss(logits, data) + assert loss.mean() == 0 + loss = dfm.loss(logits, data, mask=dfm.prior_distribution.is_masked(xt)) + assert loss.mean() == 0 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive"]) +def test_dfm_step_purity(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + if isinstance(dfm.prior_distribution, DiscreteMaskedPrior) and dfm.prior_distribution.mask_dim == 20: #! exclusive + logits = dfm.prior_distribution.pad_sample(logits) + next_xt = dfm.step_purity(logits, 0 * t + 0.5, xt, dt=1 / 100) + else: + next_xt = dfm.step_purity(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_interpolate_square(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues, num_residues)).to(device) + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + result = dfm.interpolate(data, t, noise) + assert result.shape == (batch_size, num_residues, num_residues) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive", "dfm_uniform"]) +def test_dfm_step_square(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + if isinstance(dfm.prior_distribution, DiscreteMaskedPrior) and dfm.prior_distribution.mask_dim == 20: #! exclusive + logits = dfm.prior_distribution.pad_sample(logits) + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + else: + next_xt = dfm.step(logits, 0 * t + 0.5, xt, dt=1 / 100) + assert next_xt.shape == xt.shape + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["dfm_mask", "dfm_mask_non_inclusive"]) +def test_dfm_loss_square(request, fixture, device): + # Create an indices tensor + dfm = request.getfixturevalue(fixture) + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + batch_size = 5 + num_residues = 10 + num_classes = 20 + dfm = dfm.to_device(device) + data = torch.randint(0, 19, (batch_size, num_residues, num_residues)).to(device) + t = dfm.sample_time(batch_size) + logits = torch.zeros((batch_size, num_residues, num_residues, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1) + + t = dfm.sample_time(batch_size) + noise = dfm.sample_prior(data.shape) + dfm.to_device(device) + xt = dfm.interpolate(data, t, noise) + assert xt.shape == data.shape + loss = dfm.loss(logits.reshape(logits.shape[0], -1, logits.shape[3]), data.reshape(data.shape[0], -1)) + assert loss.mean() == 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py new file mode 100644 index 0000000000..abab3d6217 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py @@ -0,0 +1,183 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.mask import DiscreteMaskedPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.continuous_time.discrete.mdlm import MDLM +from bionemo.moco.schedules.noise.continuous_noise_transforms import LogLinearExpNoiseTransform + + +@pytest.fixture +def mdlm(): + time_distribution = UniformTimeDistribution(discrete_time=False) + prior = DiscreteMaskedPrior(num_classes=20) + noise_schedule = LogLinearExpNoiseTransform() + mdlm = MDLM(time_distribution, prior, noise_schedule) + return mdlm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_interpolate(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + data = torch.randint(0, 16, (5, 10)).to(device) + t = torch.rand((5,)).to(device) + mdlm.to_device(device) + result = mdlm.interpolate(data, t) + assert result.shape == (5, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_step(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + mdlm = mdlm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes - 1, (32, 5)).to(device) + # Create time tensor + # T = 500 + time = mdlm.sample_time(32, device=device) # * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + # Sample noise + noise = mdlm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + time = time * 0 + 40 / 100 + next_xt = mdlm.step(model_out, time, xt, dt=1 / 100) + score = mdlm.calculate_score(logits, xt, time) + assert score.shape == logits.shape + next_xt = mdlm.step_argmax(model_out) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = mdlm.loss(logits, data, xt, time) + assert loss.mean() == 0 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_step_confidence(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + mdlm = mdlm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes - 1, (32, 5)).to(device) + # Create time tensor + # T = 500 + time = mdlm.sample_time(32, device=device) # * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1) + # Sample noise + noise = mdlm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + time = time * 0 + 2 / 100 + conf_nsteps = mdlm.get_num_steps_confidence(xt) + assert conf_nsteps == 1 + next_xt = mdlm.step_confidence(model_out, xt, curr_step=90, num_steps=100) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = mdlm.loss(logits, data, xt, time) + assert loss.mean() == 0 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_interpolate_square(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + data = torch.randint(0, 16, (5, 10, 10)).to(device) + t = torch.rand((5,)).to(device) + mdlm.to_device(device) + result = mdlm.interpolate(data, t) + assert result.shape == (5, 10, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_mdlm_step_square(mdlm, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + # Create a random data tensor + + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + mdlm = mdlm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes - 1, (5, 10, 10)).to(device) + # Create time tensor + # T = 500 + time = mdlm.sample_time(5, device=device) # * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((5, 10, 10, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1) + # Sample noise + noise = mdlm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0, 0] = noise[:, 0, 0] + time = time * 0 + 40 / 100 + next_xt = mdlm.step(model_out, time, xt, dt=1 / 100) + next_xt = mdlm.step_argmax(model_out) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, H, W, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = mdlm.loss( + logits.reshape(logits.shape[0], -1, logits.shape[3]), + data.reshape(data.shape[0], -1), + xt.data.reshape(data.shape[0], -1), + time, + ) + assert loss.mean() == 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py new file mode 100644 index 0000000000..15001ca382 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/continuous/test_ddpm.py @@ -0,0 +1,365 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch +import torch.nn.functional as F + +from bionemo.moco.distributions.prior.continuous.gaussian import GaussianPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.discrete_time.continuous.ddpm import DDPM +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule + + +@pytest.fixture +def ddpm(): + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + prior = GaussianPrior(center=False) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + ddpm = DDPM(time_distribution, prior, noise_schedule) + return ddpm + + +@pytest.fixture +def ddpm_centered(): + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + prior = GaussianPrior(center=True) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + ddpm = DDPM(time_distribution, prior, noise_schedule) + return ddpm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("fixture", ["ddpm", "ddpm_centered"]) +def test_ddpm_interpolate(request, fixture, device): + # Create an indices tensor + ddpm = request.getfixturevalue(fixture) + assert ddpm is not None + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + + # Create a tensor of shape 32 x 10 x 3 where each element is a 3-dimensional one-hot vector + data = F.one_hot(indices, 3).float().to(device) + time = ddpm.sample_time(32) + noise = ddpm.sample_prior(data.shape) + xt = ddpm.interpolate(data, time, noise) + assert xt.shape == data.shape + + data_time = torch.ones_like(time).to(device) * 0 + xt = ddpm.interpolate(data, data_time, noise) + error = (xt - data) ** 2 + assert error.mean() <= 2e-3 + + data_time = torch.ones_like(time).to(device) * 999 + xt = ddpm.interpolate(data, data_time, noise) + error = (xt - noise) ** 2 + assert error.mean() < 1e-7 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_step(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_step_masked(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + + # Create a mask to mask out the last 3-4 elements + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + xt = xt * mask.unsqueeze(-1) + data = data * mask.unsqueeze(-1) + model_out = model_out * mask.unsqueeze(-1) + # import ipdb; ipdb.set_trace() + next_xt = ddpm.step(model_out, time, xt, mask=mask) + + # Check that the masked elements are unchanged + assert torch.allclose(next_xt[:, -4:, :], xt[:, -4:, :]) + + # Check the shape of the output + assert next_xt.shape == data.shape + + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_centered_step(ddpm_centered, device): + # Create an indices tensor + ddpm = ddpm_centered + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + data = ddpm.clean_mask_center(data, center=True) + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt, center=True) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt, center=True) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddim_step(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.general_step("step_ddim", {"model_out": model_out, "t": time, "xt": xt}) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step_ddim(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("weight_type", ["ones", "data_to_noise"]) +def test_ddpm_loss(ddpm, device, weight_type): + # Check if CUDA is available + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + ddpm = ddpm.to_device(device) + indices = torch.arange(3).repeat(32, 10) + data = F.one_hot(indices, 3).float().to(device) # shape = [32, 30, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + mask = torch.ones(32, 30, dtype=torch.bool).to(device) + mask[:, -4:] = False + data = data * mask.unsqueeze(-1) + model_out = model_out * mask.unsqueeze(-1) + + # Calculate the loss + loss = ddpm.loss(model_out, data, time, mask=mask, weight_type=weight_type) + + # Check the shape of the loss + assert loss.shape == (32,) + assert loss.mean() < 1e-3 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_ddpm_2d_step(ddpm, device): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + data = torch.rand((32, 10, 10, 3)).to(device) # shape = [32, 10, 10, 3] + T = 1 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + _ = ddpm.interpolate(data, time, noise) + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(32, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("ndim", [2, 3, 4, 5]) +def test_ddpm_ndim_step(ddpm, device, ndim): + # Create an indices tensor + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + ddpm = ddpm.to_device(device) + shape = [10] * ndim + batch_size = 32 + data = torch.rand((batch_size, *shape, 3)).to(device) + T = 1 + time = ddpm.sample_time(batch_size, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.9999 * data + 0.0001 * noise + _ = ddpm.interpolate(data, time, noise) + xt = 0.99 * data + 0.01 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-6 + error = (xt - data) ** 2 + assert error.mean() < 1e-3 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-4 + T = 100 + time = ddpm.sample_time(batch_size, device=device) * 0 + T + noise = ddpm.sample_prior(data.shape, device=device) + model_out = 0.99 * data + 0.01 * noise + xt = 0.9 * data + 0.1 * noise + next_xt = ddpm.step(model_out, time, xt) + assert next_xt.shape == data.shape + error = (model_out - data) ** 2 + assert error.mean() < 1e-3 + error = (xt - data) ** 2 + assert error.mean() < 1e-1 + error = (next_xt - data) ** 2 + assert error.mean() < 1e-1 + + +@pytest.mark.parametrize("devices", [("cpu", "cuda"), ("cuda", "cpu")]) +def test_ddpm_to_device_multiple(ddpm, devices): + # Check if CUDA is available + if "cuda" in devices and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + # Move the DDPM instance to the first device + ddpm.to_device(devices[0]) + + # Check that all internal tensors have been moved to the first device + for attr_name in dir(ddpm): + if attr_name.startswith("_") and isinstance(getattr(ddpm, attr_name), torch.Tensor): + assert getattr(ddpm, attr_name).device.type == devices[0] + + # Move the DDPM instance to the second device + ddpm.to_device(devices[1]) + + # Check that all internal tensors have been moved to the second device + for attr_name in dir(ddpm): + if attr_name.startswith("_") and isinstance(getattr(ddpm, attr_name), torch.Tensor): + assert getattr(ddpm, attr_name).device.type == devices[1] + + # Check that the device attribute has been updated + assert ddpm.device == devices[1] + + +def test_set_loss_weight_fn(ddpm): + # Define a test function to set as the loss_weight attribute + def test_loss_weight_fn(raw_loss, t, weight_type): + return raw_loss * t * weight_type + + # Set the test function as the loss_weight attribute + ddpm.set_loss_weight_fn(test_loss_weight_fn) + + # Verify that the loss_weight attribute is set to the test function + assert ddpm.loss_weight is test_loss_weight_fn + + # Test that the function is callable with the correct arguments + raw_loss = 1.0 + t = 2.0 + weight_type = 3.0 + expected_output = raw_loss * t * weight_type + assert ddpm.loss_weight(raw_loss, t, weight_type) == expected_output diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py new file mode 100644 index 0000000000..9c7dfe588c --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py @@ -0,0 +1,157 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.distributions.prior.discrete.uniform import DiscreteUniformPrior +from bionemo.moco.distributions.time.uniform import UniformTimeDistribution +from bionemo.moco.interpolants.discrete_time.discrete.d3pm import D3PM +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule + + +@pytest.fixture +def d3pm(): + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + prior = DiscreteUniformPrior(num_classes=20) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + d3pm = D3PM(time_distribution, prior, noise_schedule) + return d3pm + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_d3pm_interpolate(d3pm, device): + data = torch.randint(0, 16, (5, 10)).to(device) + t = torch.randint(0, 10, (5,)).to(device) + d3pm.to_device(device) + result = d3pm.interpolate(data, t) + assert result.shape == (5, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_d3pm_interpolate_square(d3pm, device): + data = torch.randint(0, 16, (5, 10, 10)).to(device) + t = torch.randint(0, 10, (5,)).to(device) + d3pm.to_device(device) + result = d3pm.interpolate(data, t) + assert result.shape == (5, 10, 10) + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_d3pm_step(d3pm, device): + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + d3pm = d3pm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes, (32, 5)).to(device) + # Create time tensor + T = 500 + time = d3pm.sample_time(32, device=device) * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(2, data.unsqueeze(-1), 1000) + # Sample noise + noise = d3pm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + # Take a step + next_xt = d3pm.step(model_out, time, xt) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = d3pm.loss(logits, data, xt, time).mean() + assert loss.item() == 0 + loss = d3pm.loss(logits, data, xt, time, vb_scale=0.5).mean() + assert loss.item() < 1.0e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_d3pm_step_square(d3pm, device): + # Create a random data tensor + num_classes = 20 + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + d3pm = d3pm.to_device(device) + torch.manual_seed(42) # for reproducibility + data = torch.randint(0, num_classes, (32, 5, 6)).to(device) + # Create time tensor + T = 500 + time = d3pm.sample_time(32, device=device) * 0 + T + # Create a mock model that outputs logits + logits = torch.zeros((32, 5, 6, num_classes), device=device) + # Set the logits to a large value (e.g., 1000) for the correct discrete choices + logits[:, :, :, :] = -1000 # initialize with a low value + # Set the logits to 1000 for the correct discrete choices + logits = logits.scatter(3, data.unsqueeze(-1), 1000) + # Sample noise + noise = d3pm.sample_prior(data.shape, device=device) + # Create model output and xt + model_out = logits # torch.softmax(logits, dim=-1) + xt = data.clone() + xt[:, 0] = noise[:, 0] + # Take a step + next_xt = d3pm.step(model_out, time, xt) + # Assert shapes + assert next_xt.shape == data.shape + model_out_onehot = torch.nn.functional.one_hot( + model_out.argmax(-1), num_classes=num_classes + ).float() # (B, N, num_classes) + nll = -torch.sum(torch.log(model_out_onehot.view(-1, num_classes) + 1e-8).gather(1, data.view(-1, 1)).squeeze(1)) + assert nll < 1e-10 + loss = d3pm.loss( + logits.reshape(logits.shape[0], -1, logits.shape[3]), data.reshape(data.shape[0], -1), xt, time + ).mean() + assert loss.item() == 0 + loss = d3pm.loss( + logits.reshape(logits.shape[0], -1, logits.shape[3]), + data.reshape(data.shape[0], -1), + xt.reshape(xt.shape[0], -1), + time, + vb_scale=0.5, + ).mean() + assert loss.item() < 1.0e-1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("state_space", [20, 10, 5, 3, 2]) +def test_d3pm_interpolate_notebook(device, state_space): + B = 32 # batch size + D = 10 # dimension + S = state_space # state space + DEVICE = device + prior = DiscreteUniformPrior(num_classes=S) + time_distribution = UniformTimeDistribution(discrete_time=True, nsteps=1000) + noise_schedule = DiscreteCosineNoiseSchedule(nsteps=1000) + d3pm = D3PM( + time_distribution=time_distribution, prior_distribution=prior, noise_schedule=noise_schedule, device=DEVICE + ) # this failed on A100 before init on cpu then shift to GPU + for _ in range(100): + num_ones = torch.randint(0, D + 1, (B,)) + x1 = (torch.arange(D)[None, :] < num_ones[:, None]).long().to(DEVICE) + t = d3pm.sample_time(B) + xt = d3pm.interpolate(x1, t) + assert xt.shape == x1.shape diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_noise_transforms.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_noise_transforms.py new file mode 100644 index 0000000000..f495fe8142 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_noise_transforms.py @@ -0,0 +1,73 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco import TimeDirection +from bionemo.moco.schedules.noise.continuous_noise_transforms import ( + CosineExpNoiseTransform, + LogLinearExpNoiseTransform, +) + + +class TestContinuousNoiseTransforms: + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_init(self, transform_cls): + transform = transform_cls() + assert transform.direction == TimeDirection.DIFFUSION + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_calculate_sigma(self, transform_cls): + transform = transform_cls() + t = torch.linspace(0, 1, 10) + sigma = transform.calculate_sigma(t) + assert sigma.shape == t.shape + assert (sigma >= 0).all() + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_calculate_sigma_invalid_input(self, transform_cls): + transform = transform_cls() + t = torch.tensor([1.1, 2.2]) # invalid input, max value > 1 + with pytest.raises(ValueError): + transform.calculate_sigma(t) + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_sigma_to_alpha(self, transform_cls): + transform = transform_cls() + sigma = torch.linspace(0.1, 1.0, 10) + alpha = transform.sigma_to_alpha(sigma) + assert alpha.shape == sigma.shape + assert (alpha >= 0).all() + + @pytest.mark.parametrize("transform_cls", [CosineExpNoiseTransform, LogLinearExpNoiseTransform]) + def test_d_dt_sigma(self, transform_cls): + transform = transform_cls() + t = torch.linspace(0, 1, 10) + derivative = transform.d_dt_sigma(t) + assert derivative.shape == t.shape + + def test_cosine_transform(self): + transform = CosineExpNoiseTransform() + t = torch.linspace(0, 1, 10) + sigma = transform.calculate_sigma(t) + assert torch.allclose(sigma, -torch.log(1e-3 + (1 - 1e-3) * torch.cos(t * torch.pi / 2))) + + def test_loglinear_transform(self): + transform = LogLinearExpNoiseTransform() + t = torch.linspace(0, 1, 10) + sigma = transform.calculate_sigma(t) + assert torch.allclose(sigma, -torch.log1p(-(1 - 1e-3) * t)) diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_snr_transforms.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_snr_transforms.py new file mode 100644 index 0000000000..d9633a2eee --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_continuous_snr_transforms.py @@ -0,0 +1,127 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.schedules.noise.continuous_snr_transforms import ( + CosineSNRTransform, + LinearLogInterpolatedSNRTransform, + LinearSNRTransform, + TimeDirection, +) + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_cosine_snr_transform(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.linspace(0, 1, timesteps, device=device) + snr_transform = CosineSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device, synchronize=synchronize) + + # Check if log_snr has the correct shape + assert log_snr.shape == (timesteps,) + # Check if log_snr is on the correct device + assert log_snr.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_linear_snr_transform(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.linspace(0, 1, timesteps, device=device) + snr_transform = LinearSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device, synchronize=synchronize) + + # Check if log_snr has the correct shape + assert log_snr.shape == (timesteps,) + # Check if log_snr is on the correct device + assert log_snr.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_linear_log_interpolated_snr_transform(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.linspace(0, 1, timesteps, device=device) + snr_transform = LinearLogInterpolatedSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device, synchronize=synchronize) + + # Check if log_snr has the correct shape + assert log_snr.shape == (timesteps,) + # Check if log_snr is on the correct device + assert log_snr.device.type == device + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cosine_snr_transform_alpha(device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.tensor(0.5, device=device) + snr_transform = CosineSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device) + alpha = snr_transform.calculate_alpha_log_snr(log_snr) + + # Check if alpha is a valid value + assert alpha > 0 + assert alpha <= 1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_linear_snr_transform_alpha(device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.tensor(0.5, device=device) + snr_transform = LinearSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device) + alpha = snr_transform.calculate_alpha_log_snr(log_snr) + + # Check if alpha is a valid value + assert alpha > 0 + assert alpha <= 1 + + +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_linear_log_interpolated_snr_transform_alpha(device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + t = torch.tensor(0.5, device=device) + snr_transform = LinearLogInterpolatedSNRTransform() + + log_snr = snr_transform.calculate_log_snr(t, device=device) + alpha = snr_transform.calculate_alpha_log_snr(log_snr) + + # Check if alpha is a valid value + assert alpha > 0 + assert alpha <= 1 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py new file mode 100644 index 0000000000..7ddcc7adfd --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/noise/test_discrete_noise_schedule.py @@ -0,0 +1,64 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.schedules.noise.discrete_noise_schedules import DiscreteCosineNoiseSchedule +from bionemo.moco.schedules.utils import TimeDirection + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +def test_cosine_schedule(timesteps, device): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + scheduler = DiscreteCosineNoiseSchedule(timesteps) + schedule = scheduler.generate_schedule(device=device) + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("synchronize", [TimeDirection.DIFFUSION, TimeDirection.UNIFIED]) +def test_cosine_schedule_direction(timesteps, device, synchronize): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = DiscreteCosineNoiseSchedule(timesteps) + # import ipdb; ipdb.set_trace() + schedule = scheduler.generate_schedule(device=device, synchronize=synchronize) + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,), f"Expected schedule shape to be {(timesteps,)}, but got {schedule.shape}" + # Check if schedule is on the correct device + assert ( + schedule.device.type == device + ), f"Expected schedule to be on device '{device}', but got '{schedule.device.type}'" + # Check if the schedule is in the correct direction + + if synchronize == TimeDirection.UNIFIED: + assert ( + schedule[0] < schedule[-1] + ), f"Expected schedule to be in increasing order when synchronized, but got {schedule[0]} >= {schedule[-1]}" + else: + assert ( + schedule[0] > schedule[-1] + ), f"Expected schedule to be in decreasing order when not synchronized, but got {schedule[0]} <= {schedule[-1]}" diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py new file mode 100644 index 0000000000..d509391df6 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_inference_schedules.py @@ -0,0 +1,162 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch + +from bionemo.moco.schedules.inference_time_schedules import ( + DiscreteLinearInferenceSchedule, + LinearInferenceSchedule, + LogInferenceSchedule, + PowerInferenceSchedule, +) +from bionemo.moco.schedules.utils import TimeDirection + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_uniform_dt(timesteps, device, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = LinearInferenceSchedule(timesteps, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + # Check if all dt's are equal to 1/timesteps + assert torch.allclose(dt, torch.ones_like(dt) / timesteps) + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + else: + assert schedule[0] > schedule[-1] + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("power", [0.5, 1.5, 2.0]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_power_dt(timesteps, device, power, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = PowerInferenceSchedule(timesteps, exponent=power, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + else: + assert schedule[0] > schedule[-1] + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_log_dt(timesteps, device, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = LogInferenceSchedule(timesteps, exponent=-2, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] and schedule[0] == 0 + else: + assert schedule[0] > schedule[-1] and schedule[0] == 1 + + +@pytest.mark.parametrize("timesteps", [5, 10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +def test_discrete_uniform_dt(timesteps, device, direction): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + + scheduler = DiscreteLinearInferenceSchedule(timesteps, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + # Additional checks specific to DiscreteUniformInferenceSchedule + assert torch.all(dt == torch.full((timesteps,), 1 / timesteps, device=device)) + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + else: + assert schedule[0] > schedule[-1] + + +@pytest.mark.parametrize("timesteps", [10, 20]) +@pytest.mark.parametrize("device", ["cpu", "cuda"]) +@pytest.mark.parametrize("direction", [TimeDirection.UNIFIED, TimeDirection.DIFFUSION]) +@pytest.mark.parametrize("padding", [0, 2]) +@pytest.mark.parametrize("dilation", [0, 1]) +def test_uniform_dt_padding_dilation(timesteps, device, direction, padding, dilation): + if device == "cuda" and not torch.cuda.is_available(): + pytest.skip("CUDA is not available") + scheduler = LinearInferenceSchedule(timesteps, padding=padding, dilation=dilation, direction=direction) + dt = scheduler.discretize(device=device) + schedule = scheduler.generate_schedule(device=device) + + # Check if all dt's are equal to 1/timesteps + assert dt.device.type == device + + # Check if schedule has the correct shape + assert schedule.shape == (timesteps,) + # Check if dt has the correct shape + assert dt.shape == (timesteps,) + # Check if schedule is on the correct device + assert schedule.device.type == device + if direction == TimeDirection.UNIFIED: + assert schedule[0] < schedule[-1] + for i in range(padding): + assert schedule[-1 * (i + 1)] == 1.0 + else: + assert schedule[0] > schedule[-1] + for i in range(padding): + assert schedule[-1 * (i + 1)] == 0 diff --git a/sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py b/sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py new file mode 100644 index 0000000000..0b60811790 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/test_env.py @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import torch +import torch.nn as nn + + +def test_torch_import(): + assert torch is not None + + +def test_gpu_availability(): + assert torch.cuda.is_available() + + +def test_tensor_creation_on_gpu(): + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + tensor = torch.randn(2, 2, device=device) + assert tensor.is_cuda + + +def test_loss_calculation(): + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + input_tensor = torch.randn(2, 2, device=device) + target_tensor = torch.randn(2, 2, device=device) + criterion = nn.MSELoss() + loss = criterion(input_tensor, target_tensor) + assert loss is not None + + +def test_backpropagation(): + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + input_tensor = torch.randn(2, 2, device=device, requires_grad=True) + target_tensor = torch.randn(2, 2, device=device) + criterion = nn.MSELoss() + loss = criterion(input_tensor, target_tensor) + loss.backward() + assert input_tensor.grad is not None diff --git a/sub-packages/bionemo-scdl/README.md b/sub-packages/bionemo-scdl/README.md index 4adde79b5c..42cdf81c98 100644 --- a/sub-packages/bionemo-scdl/README.md +++ b/sub-packages/bionemo-scdl/README.md @@ -1,4 +1,4 @@ -# BioNemo-SCDL: Single Cell Data Loading for Scalable Training of Single Cell Foundation Models. +# BioNeMo-SCDL: Single Cell Data Loading for Scalable Training of Single Cell Foundation Models. ## Package Overview @@ -109,6 +109,13 @@ for e in range(n_epochs): model(batch) ``` +For some applications, we might want to also use the features. These can be specified with get_row(index, return_features = True). By default, all features are returned, but the features can be specified with the feature_vars argument in get_row, which corresponds to a list of the feature names to return. + +``` +for index in range(len(data)): + model(data.get_row(index,return_features = True)) +``` + ## Examples The examples directory contains various examples for utilizing SCDL. @@ -125,6 +132,16 @@ Here's an example: convert_h5ad_to_scdl --data-path hdf5s --save-path example_dataset ``` +## Runtimes with SCDL + +The runtime and memory usage are examined on a CellXGene Dataset with ~1.5 million rows and a size of 24 GB. On this dataset, there is a 4.9x memory speed up. + +<img src="images/throughput.png" alt="Throughput Image" width="600"> + +Additionally, the peak memory usage when iterating over the datasets with the SCDL dataloader is only 36.5 MB, since the whole dataset is never loaded into memory due to the numpy memomory-mapped backing. + +<img src="images/disk_space.png" alt="Memory Image" width="600"> + ## Future Work and Roadmap SCDL is currently in public beta. In the future, expect improvements in data compression @@ -132,4 +149,4 @@ and data loading performance. ## LICENSE -BioNemo-SCDL has an Apache 2.0 license, as found in the LICENSE file. +BioNeMo-SCDL has an Apache 2.0 license, as found in the LICENSE file. diff --git a/sub-packages/bionemo-scdl/examples/example_notebook.ipynb b/sub-packages/bionemo-scdl/examples/example_notebook.ipynb index adc9c4db30..aca9d7b214 100644 --- a/sub-packages/bionemo-scdl/examples/example_notebook.ipynb +++ b/sub-packages/bionemo-scdl/examples/example_notebook.ipynb @@ -9,10 +9,9 @@ "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> It takes about 10 minutes to deploy this notebook as a Launchable. As of this writing, we are working on a free tier so a credit card may be required. You can reach out to your NVIDIA rep for credits.</div>" ] }, - -{ + { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -48,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -61,9 +60,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#Save the dataset to the disk. \n", "data.save()" @@ -71,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -90,9 +100,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pbinder/bionemo-framework/sub-packages/bionemo-scdl/src/bionemo/scdl/util/torch_dataloader_utils.py:39: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)\n", + " batch_sparse_tensor = torch.sparse_csr_tensor(batch_rows, batch_cols, batch_values, size=(len(batch), max_pointer))\n" + ] + } + ], "source": [ "model = lambda x : x\n", "\n", @@ -114,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -127,6 +146,23 @@ " model(batch)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For some applications, we might want to also use the features. These can be specified with get_row(index, return_features = True). By default, all features are returned, but the features can be specified with the feature_vars argument in get_row, which corresponds to a list of the feature names to return. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "for index in range(len(data)):\n", + " model(data.get_row(index,return_features = True))\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -196,7 +232,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.5" } }, "nbformat": 4, diff --git a/sub-packages/bionemo-scdl/images/disk_space.png b/sub-packages/bionemo-scdl/images/disk_space.png new file mode 100644 index 0000000000000000000000000000000000000000..b1e75afd2d70413464530cdb00ce5a49a640db5a GIT binary patch literal 71701 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%0AqX1vtoB=E9ZWQ9dWVc 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 literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-scdl/images/throughput.png b/sub-packages/bionemo-scdl/images/throughput.png new file mode 100644 index 0000000000000000000000000000000000000000..d771a13451c79ff56e67b8062ff4f2f9961fa075 GIT binary patch literal 31447 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 LQ+>!~;l}>~PDcP$ literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py b/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py index e7fd99438d..836e41e9de 100644 --- a/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py +++ b/sub-packages/bionemo-scdl/src/bionemo/scdl/index/row_feature_index.py @@ -96,9 +96,7 @@ def __len__(self) -> int: """The length is the number of rows or RowFeatureIndex length.""" return len(self._feature_arr) - def append_features( - self, n_obs: int, features: dict[str, np.ndarray], num_genes: int, label: Optional[str] = None - ) -> None: + def append_features(self, n_obs: int, features: dict[str, np.ndarray], label: Optional[str] = None) -> None: """Updates the index with the given features. The dict is inserted into the feature array by adding a @@ -108,7 +106,6 @@ def append_features( n_obs (int): The number of times that these feature occur in the class. features (dict): Corresponding features. - num_genes (int): the length of the features for each feature key in features (i.e., number of genes) label (str): Label for the features. """ if isinstance(features, pd.DataFrame): @@ -122,8 +119,12 @@ def append_features( else: self._cumulative_sum_index = np.append(self._cumulative_sum_index, csum + n_obs) self._feature_arr.append(features) - self._num_genes_per_row.append(num_genes) self._labels.append(label) + if len(features) == 0: + num_genes = 0 + else: + num_genes = len(features[next(iter(features.keys()))]) + self._num_genes_per_row.append(num_genes) def lookup(self, row: int, select_features: Optional[list[str]] = None) -> Tuple[list[np.ndarray], str]: """Find the features at a given row. @@ -248,8 +249,7 @@ def concat(self, other_row_index: RowFeatureIndex, fail_on_empty_index: bool = T for i, feats in enumerate(list(other_row_index._feature_arr)): c_span = other_row_index._cumulative_sum_index[i + 1] label = other_row_index._labels[i] - num_genes = other_row_index._num_genes_per_row[i] - self.append_features(c_span, feats, num_genes, label) + self.append_features(c_span, feats, label) return self diff --git a/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py b/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py index 8569149127..84a24f0a27 100644 --- a/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py +++ b/sub-packages/bionemo-scdl/src/bionemo/scdl/io/single_cell_memmap_dataset.py @@ -239,6 +239,7 @@ def __init__( mode: Mode = Mode.READ_APPEND, paginated_load_cutoff: int = 10_000, load_block_row_size: int = 1_000_000, + feature_index_name="feature_id", ) -> None: """Instantiate the class. @@ -251,12 +252,14 @@ def __init__( mode: Whether to read or write from the data_path. paginated_load_cutoff: MB size on disk at which to load the h5ad structure with paginated load. load_block_row_size: Number of rows to load into memory with paginated load + feature_index_name: The name of the features if the features are only stored in features_df.index.values """ self._version: str = importlib.metadata.version("bionemo.scdl") self.data_path: str = data_path self.mode: Mode = mode self.paginated_load_cutoff = paginated_load_cutoff self.load_block_row_size = load_block_row_size + self.feature_index_name = feature_index_name # Backing arrays self.data: Optional[np.ndarray] = None self.row_index: Optional[np.ndarray] = None @@ -612,14 +615,15 @@ def load_h5ad( if file_size_MB < self.paginated_load_cutoff: features_df, num_rows = self.regular_load_h5ad(anndata_path) - else: features_df, num_rows = self.paginated_load_h5ad(anndata_path) - - features = {col: np.array(features_df[col].values) for col in features_df.columns} - self._feature_index.append_features( - n_obs=num_rows, features=features, num_genes=len(features[next(iter(features.keys()))]), label=anndata_path - ) + if len(features_df.columns) > 0: + features = {col: np.array(features_df[col].values) for col in features_df.columns} + elif len(features_df.index) > 0: + features = {self.feature_index_name: features_df.index.values} + else: + features = {} + self._feature_index.append_features(n_obs=num_rows, features=features, label=anndata_path) self.save() def save(self, output_path: Optional[str] = None) -> None: diff --git a/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py b/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py index c18ca2ef5f..d32da63d9a 100644 --- a/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py +++ b/sub-packages/bionemo-scdl/tests/bionemo/scdl/index/test_row_feature_index.py @@ -58,7 +58,7 @@ def create_first_RowFeatureIndex() -> RowFeatureIndex: """ one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} index = RowFeatureIndex() - index.append_features(12, one_feats, len(one_feats["feature_name"])) + index.append_features(12, one_feats) return index @@ -72,7 +72,7 @@ def create_same_features_first_RowFeatureIndex() -> RowFeatureIndex: """ one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} index = RowFeatureIndex() - index.append_features(6, one_feats, len(one_feats["feature_name"])) + index.append_features(6, one_feats) return index @@ -91,7 +91,7 @@ def create_second_RowFeatureIndex() -> RowFeatureIndex: } index2 = RowFeatureIndex() - index2.append_features(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") + index2.append_features(8, two_feats, "MY_DATAFRAME") return index2 @@ -105,7 +105,7 @@ def test_dataframe_results_in_error(): ) index = RowFeatureIndex() with pytest.raises(TypeError) as error_info: - index.append_features(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") + index.append_features(8, two_feats, "MY_DATAFRAME") assert "Expected a dictionary, but received a Pandas DataFrame." in str(error_info.value) @@ -125,6 +125,19 @@ def test_feature_index_internals_on_single_index(create_first_RowFeatureIndex): assert len(vals) == 1 +def test_feature_index_internals_on_append_empty_features(create_first_RowFeatureIndex): + index = RowFeatureIndex() + index.append_features(10, {}) + create_first_RowFeatureIndex.concat(index) + assert len(create_first_RowFeatureIndex) == 2 + assert [3, 0] == create_first_RowFeatureIndex.column_dims() + assert create_first_RowFeatureIndex.number_of_rows() == 22 + + vals = create_first_RowFeatureIndex.number_of_values() + assert vals == [12 * 3, 0] + assert len(vals) == 2 + + def test_feature_index_internals_on_append_different_features( create_first_RowFeatureIndex, create_second_RowFeatureIndex ): @@ -135,7 +148,6 @@ def test_feature_index_internals_on_append_different_features( "spare": np.array([None, None, None, None, None]), } create_first_RowFeatureIndex.concat(create_second_RowFeatureIndex) - # append(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") assert len(create_first_RowFeatureIndex) == 2 assert create_first_RowFeatureIndex.number_vars_at_row(1) == 3 assert create_first_RowFeatureIndex.number_vars_at_row(13) == 5 @@ -158,7 +170,6 @@ def test_feature_index_internals_on_append_different_features( def test_feature_index_internals_on_append_same_features(create_first_RowFeatureIndex): one_feats = {"feature_name": np.array(["FF", "GG", "HH"]), "feature_int": np.array([1, 2, 3])} create_first_RowFeatureIndex.concat(create_first_RowFeatureIndex) - # append(8, two_feats, len(two_feats["feature_name"]), "MY_DATAFRAME") assert len(create_first_RowFeatureIndex) == 1 assert create_first_RowFeatureIndex.number_vars_at_row(1) == 3 assert create_first_RowFeatureIndex.number_vars_at_row(13) == 3 diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/lightning.py b/sub-packages/bionemo-testing/src/bionemo/testing/lightning.py index 67acf2b945..221abd4e2d 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/lightning.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/lightning.py @@ -18,9 +18,15 @@ import torch +from bionemo.llm.data.collate import MLM_LOSS_IGNORE_INDEX + def get_random_microbatch( - microbatch_size: int, max_sequence_length: int, vocab_size: int, seed: int + microbatch_size: int, + max_sequence_length: int, + vocab_size: int, + seed: int, + mask_index: int = MLM_LOSS_IGNORE_INDEX, ) -> Dict[str, Dict[str, torch.Tensor]]: """Generate random microbatches for testing. @@ -45,7 +51,7 @@ def get_random_microbatch( token_logits = torch.rand( max_sequence_length, microbatch_size, vocab_size, device=torch.cuda.current_device(), generator=generator ) # [s b v] - labels[loss_mask == 0] = -100 # propagate masking to labels + labels[loss_mask == 0] = mask_index # propagate masking to labels microbatch_output = { "batch": {"labels": labels, "loss_mask": loss_mask}, "forward_out": {"token_logits": token_logits}, diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py index 1686de309d..8ef0762239 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py @@ -42,9 +42,12 @@ def my_test(): import torch.distributed from megatron.core import parallel_state from megatron.core.tensor_parallel import random as tp_random +from nemo import lightning as nl from nemo.utils import logging from torch.testing._internal.distributed.fake_pg import FakeStore +from bionemo.core.utils.dtypes import PrecisionTypes + __all__: Sequence[str] = ( "clean_parallel_state_context", @@ -81,12 +84,24 @@ def _initialize_distributed_parallel_state( pipeline_model_parallel_split_rank: int = 0, context_parallel_size: int = 1, interactive: bool = False, -) -> None: + precision: PrecisionTypes = "fp32", +) -> pl.Trainer | None: + trainer = None # initialize pytorch DDP # if not interactive and not torch.distributed.is_initialized(): if not torch.distributed.is_initialized(): - logging.info("pytorch DDP is not initialized. Initializing with pytorch-lightening...") - trainer = pl.Trainer(devices=devices, strategy="ddp" if not interactive else "auto", num_nodes=1) + logging.info("pytorch DDP is not initialized. Initializing with pytorch-lightning...") + trainer = pl.Trainer( + devices=devices, + strategy="ddp" if not interactive else "auto", + num_nodes=1, + # plugins=nl.MegatronMixedPrecision( + # precision=precision, + # params_dtype=get_autocast_dtype(precision), + # pipeline_dtype=get_autocast_dtype(precision), + # autocast_enabled=False, + # ), + ) if trainer.strategy.launcher is not None: trainer.strategy.launcher.launch(_dummy, trainer=trainer) @@ -101,6 +116,8 @@ def _initialize_distributed_parallel_state( context_parallel_size=context_parallel_size, ) + return trainer + @contextmanager def clean_parallel_state_context() -> Iterator[None]: @@ -124,6 +141,7 @@ def distributed_model_parallel_state( pipeline_model_parallel_split_rank: int = 0, context_parallel_size: int = 1, interactive: bool = False, + precision: PrecisionTypes = "fp32", ) -> Iterator[None]: """Context manager for handling creating and cleaning up distributed model parallel state for tests. Use like: @@ -132,16 +150,18 @@ def distributed_model_parallel_state( # After the block your state is cleaned up. """ # noqa: D205 initial_states: Optional[Any] = None + trainer: pl.Trainer | None = None try: _teardown_apex_megatron_cuda() - _initialize_distributed_parallel_state( + trainer = _initialize_distributed_parallel_state( devices=devices, tensor_model_parallel_size=tensor_model_parallel_size, pipeline_model_parallel_size=pipeline_model_parallel_size, pipeline_model_parallel_split_rank=pipeline_model_parallel_split_rank, context_parallel_size=context_parallel_size, interactive=interactive, + precision=precision, ) # Our goal is to set required state on entry, and then restore current state on exit for the RNGs. # there are two possibilities that are handled below: @@ -174,6 +194,8 @@ def distributed_model_parallel_state( # Reset to the unset state tp_random.get_cuda_rng_tracker().reset() _teardown_apex_megatron_cuda() + if trainer is not None: + nl.teardown(trainer) @contextmanager diff --git a/tach.toml b/tach.toml index 8bb10ef323..6d27368c50 100644 --- a/tach.toml +++ b/tach.toml @@ -1,24 +1,26 @@ +interfaces = [] exclude = [ - ".*__pycache__", - ".*egg-info", + "**/*__pycache__", + "**/*egg-info", + "LICENSE", + "build", "docs", "tests", "venv", - "LICENSE", - "build", ] source_roots = [ - 'sub-packages/bionemo-core/src', - 'sub-packages/bionemo-esm2/src', - 'sub-packages/bionemo-example_model/src', - 'sub-packages/bionemo-fw/src', - 'sub-packages/bionemo-geneformer/src', - 'sub-packages/bionemo-geometric/src', - 'sub-packages/bionemo-llm/src', - 'sub-packages/bionemo-scdl/src', - 'sub-packages/bionemo-size-aware-batching/src', - 'sub-packages/bionemo-testing/src', - 'sub-packages/bionemo-webdatamodule/src', + "sub-packages/bionemo-core/src", + "sub-packages/bionemo-esm2/src", + "sub-packages/bionemo-evo2/src", + "sub-packages/bionemo-example_model/src", + "sub-packages/bionemo-fw/src", + "sub-packages/bionemo-geneformer/src", + "sub-packages/bionemo-geometric/src", + "sub-packages/bionemo-llm/src", + "sub-packages/bionemo-scdl/src", + "sub-packages/bionemo-size-aware-batching/src", + "sub-packages/bionemo-testing/src", + "sub-packages/bionemo-webdatamodule/src", ] [[modules]] @@ -28,80 +30,88 @@ depends_on = [] [[modules]] path = "bionemo.esm2" depends_on = [ - { path = "bionemo.core" }, - { path = "bionemo.llm" }, + "bionemo.core", + "bionemo.llm", +] + +[[modules]] +path = "bionemo.evo2" +depends_on = [ + "bionemo.noodles", + "bionemo.core", + "bionemo.llm", ] [[modules]] path = "bionemo.example_model" depends_on = [ - { path = "bionemo.core" }, - { path = "bionemo.llm" }, + "bionemo.core", + "bionemo.llm", ] [[modules]] path = "bionemo.fw" depends_on = [ - { path = "bionemo.core" }, - { path = "bionemo.esm2" }, - { path = "bionemo.geneformer" }, - { path = "bionemo.geometric" }, - { path = "bionemo.llm" }, - { path = "bionemo.noodles" }, - { path = "bionemo.scdl" }, - { path = "bionemo.size_aware_batching" }, - { path = "bionemo.webdatamodule" }, - { path = "bionemo.noodles" }, + "bionemo.core", + "bionemo.esm2", + "bionemo.geneformer", + "bionemo.geometric", + "bionemo.llm", + "bionemo.noodles", + "bionemo.noodles", + "bionemo.scdl", + "bionemo.size_aware_batching", + "bionemo.webdatamodule", ] [[modules]] path = "bionemo.geneformer" depends_on = [ - { path = "bionemo.core" }, - { path = "bionemo.llm" }, - { path = "bionemo.scdl" }, + "bionemo.core", + "bionemo.llm", + "bionemo.scdl", ] [[modules]] path = "bionemo.geometric" depends_on = [ - { path = "bionemo.core" }, + "bionemo.core", ] [[modules]] path = "bionemo.llm" depends_on = [ - { path = "bionemo.core" }, + "bionemo.core", ] [[modules]] path = "bionemo.noodles" depends_on = [ - { path = "bionemo.core" }, + "bionemo.core", ] [[modules]] path = "bionemo.scdl" depends_on = [ - { path = "bionemo.core" }, + "bionemo.core", ] [[modules]] path = "bionemo.size_aware_batching" depends_on = [ - { path = "bionemo.core" }, + "bionemo.core", ] [[modules]] path = "bionemo.testing" depends_on = [ - { path = "bionemo.core" }, - { path = "bionemo.llm" }, + "bionemo.core", + "bionemo.llm", ] [[modules]] path = "bionemo.webdatamodule" depends_on = [ - { path = "bionemo.core" }, - { path = "bionemo.llm" }, + "bionemo.core", + "bionemo.llm", ] From 1df0176a214aaaea783768048ad57389e1861eac Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska <dorotat@nvidia.com> Date: Fri, 7 Feb 2025 08:55:21 -0800 Subject: [PATCH 048/140] CI hotfix --- sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py | 3 ++- .../tests/bionemo/core/data/test_load_notebook.ipynb | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py index 8b36690a9f..725ed9afa7 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py @@ -45,8 +45,9 @@ def test_load_raises_error_on_invalid_tag(tmp_path): def test_load_cli(): # It looks like there's some issues with our NGC resources, but this is blocking CI. TODO: Revert to ngc when these # resources are available. + # FIXME (dorotat): set source=ngc once the access issue with NGC is resolved (https://github.com/NVIDIA/bionemo-framework/issues/682) result = subprocess.run( - ["download_bionemo_data", "--source", "ngc", "single_cell/testdata-20240506"], + ["download_bionemo_data", "--source", "pbss", "single_cell/testdata-20240506"], stdout=subprocess.PIPE, # Capture stdout stderr=subprocess.PIPE, # Capture stderr (optional) text=True, # Return output as string rather than bytes diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb index cd7d99ad72..ab374d1950 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load_notebook.ipynb @@ -42,8 +42,9 @@ } ], "source": [ + "# FIXME (dorotat): set source=ngc once the access issue with NGC is resolved (https://github.com/NVIDIA/bionemo-framework/issues/682)\n", "with tempfile.TemporaryDirectory() as cache_dir:\n", - " load(\"scdl/sample\", source=\"ngc\", cache_dir=Path(cache_dir))" + " load(\"scdl/sample\", source=\"pbss\", cache_dir=Path(cache_dir))" ] } ], From 624e797095f8c48ffd7ccc5fdc90191c2f6100e2 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Fri, 7 Feb 2025 11:21:20 -0800 Subject: [PATCH 049/140] test: Create tests for Evo2Dataset mask_phylogenetic_tags --- .../bionemo/test_mask_phylogenetic_tags.py | 570 ++++++++++++++++++ 1 file changed, 570 insertions(+) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/test_mask_phylogenetic_tags.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_mask_phylogenetic_tags.py b/sub-packages/bionemo-evo2/tests/bionemo/test_mask_phylogenetic_tags.py new file mode 100644 index 0000000000..001fccf403 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/test_mask_phylogenetic_tags.py @@ -0,0 +1,570 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +import torch +from nemo.collections.llm.gpt.data.megatron.hyena import Evo2Dataset + + +@pytest.fixture +def tag_tokens(): + """Standard tokens for phylogenetic tag tests, defined in Evo2_DataseT: + + CONTROL_TAGS: ClassVar[list[int]] = [64, 35] # '@' tag for splice splits/windows, '#' for contig splits + TAG_BOUNDS = 124 # start and end delim: '|' + TAG_CHARS: ClassVar[set[int]] = {95, 59, 32} # chars only found in control tags: _, ;, space + DEFAULT_EOD = 0 + """ + return { + "terminal": 124, # | + "other_chars": {95, 59, 32}, # _, ;, space + "eod": 0, # end of document token + } + + +def test_mask_phylogenetic_tags_with_eod(tag_tokens): + """Tests handling of EOD tokens within tag context. + + Since we want to ensure the model only learns to output {A,C,G,T}, even EOD tokens + within a tag context should be masked to prevent the model from learning to + output non-DNA tokens. + + Example sequence: token | _ EOD | token + Expected masking: 1 0 0 0 0 1 + """ + sequence = torch.tensor([65, 124, 95, 0, 124, 65]) # token|_<EOD>|token + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], # | + other_tag_chars=tag_tokens["other_chars"], # _, ;, space + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor([1, 0, 0, 0, 0, 1]) + assert torch.equal(mask, expected_mask) + + +def test_mask_phylogenetic_tags_middle(tag_tokens): + """Tests masking a phylogenetic tag that appears in the middle of a DNA sequence. + + The sequence contains: + 1. Normal DNA (ATG) + 2. A phylo tag (|info_tag|) + 3. More DNA (TCGA) + + Expected behavior: The DNA should be unmasked (1s) while everything between + and including the pipe characters should be masked (0s), as it's a valid phylo tag. + """ + sequence = torch.tensor( + [ + 65, + 84, + 71, # ATG + 124, + 105, + 110, + 102, + 111, + 95, + 116, + 97, + 103, + 124, # |info_tag| + 84, + 67, + 71, + 65, # TCGA + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], # | + other_tag_chars=tag_tokens["other_chars"], # _, ;, space + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor( + [ + 1, + 1, + 1, # DNA unmasked + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, # phylo tag masked + 1, + 1, + 1, + 1, # DNA unmasked + ] + ) + assert torch.equal(mask, expected_mask) + + +def test_mask_partial_tag_start(tag_tokens): + """Tests handling a sequence that starts with a partial phylogenetic tag. + + The sequence starts with characters that would be inside a phylo tag, + followed by a closing pipe and DNA. Since we want to prevent the model from + learning non-DNA outputs, we mask all potential tag characters even without + complete tag delimiters. + + Sequence: "tag;_|ATG" (starting mid-tag) + Expected: All tag characters and delimiters masked, only DNA unmasked + """ + sequence = torch.tensor( + [ + 116, + 97, + 103, + 59, + 95, # tag;_ + 124, # | + 65, + 84, + 71, # ATG + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor( + [ + 0, + 0, + 0, + 0, + 0, # partial tag start masked + 0, # closing pipe masked + 1, + 1, + 1, # DNA unmasked + ] + ) + assert torch.equal(mask, expected_mask) + + +def test_mask_partial_tag_end(tag_tokens): + """Tests handling a sequence that ends with a partial phylogenetic tag. + + The sequence contains DNA followed by an opening pipe and tag characters, + but no closing pipe. Per requirements, we aggressively mask any potential + tag characters to ensure the model only learns DNA bases {A,C,G,T}. + + Sequence: "ATG|info_" (ending mid-tag) + Expected: DNA unmasked, all tag-related characters masked + """ + sequence = torch.tensor( + [ + 65, + 84, + 71, # ATG + 124, # | + 105, + 110, + 102, + 111, + 95, # info_ + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor( + [ + 1, + 1, + 1, # DNA unmasked + 0, # opening pipe masked + 0, + 0, + 0, + 0, + 0, # partial tag end masked + ] + ) + assert torch.equal(mask, expected_mask) + + +def test_standalone_tag(tag_tokens): + """Tests masking of a single complete tag with no surrounding sequence. + + Tests that a standalone tag (|tag_|) is fully masked since it contains + non-DNA characters. This ensures the model only learns to output + {A,C,G,T} tokens. + + Sequence: |tag_| + Expected: All tokens masked (all zeros) + """ + sequence = torch.tensor([124, 116, 97, 103, 95, 124]) # |tag_| + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + expected = torch.tensor([0, 0, 0, 0, 0, 0]) # All masked + assert torch.equal(mask, expected) + + +def test_sequence_starting_with_tag(tag_tokens): + """Tests sequence that begins with a complete tag followed by DNA. + + Verifies that when a sequence starts with a complete tag followed by + DNA bases, the tag portion is masked while the DNA portion remains + unmasked. + + Sequence: |tag_|ATG + Expected: Tag masked (zeros), DNA unmasked (ones) + """ + sequence = torch.tensor( + [ + 124, + 116, + 97, + 103, + 95, + 124, # |tag_| + 65, + 84, + 71, # ATG + ] + ) + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + expected = torch.tensor([0, 0, 0, 0, 0, 0, 1, 1, 1]) # Tag masked, DNA unmasked + assert torch.equal(mask, expected) + + +def test_sequence_ending_with_tag(tag_tokens): + """Tests sequence that ends with a complete tag. + + Verifies that when a sequence ends with a complete tag, the DNA portion + remains unmasked while the entire tag portion is masked. + + Sequence: ATG|tag_| + Expected: DNA unmasked (ones), tag masked (zeros) + """ + sequence = torch.tensor( + [ + 65, + 84, + 71, # ATG + 124, + 116, + 97, + 103, + 95, + 124, # |tag_| + ] + ) + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + expected = torch.tensor([1, 1, 1, 0, 0, 0, 0, 0, 0]) # DNA unmasked, tag masked + assert torch.equal(mask, expected) + + +def test_mask_multiple_tags(tag_tokens): + """Tests handling multiple phylogenetic tags in sequence, demonstrating state transitions. + + This tests how the masking switches states between phylo and non-phylo regions: + 1. Starts in non-phylo state with DNA + 2. Switches to phylo state at first pipe (with tag chars) + 3. Switches back to non-phylo at closing pipe + 4. Pattern repeats for second tag + + Sequence: "ATG|tag_1|CG|tag_2|AT" + Expected: Only DNA sequences should remain unmasked + """ + sequence = torch.tensor( + [ + 65, + 84, + 71, # ATG + 124, + 116, + 97, + 103, + 95, + 49, + 124, # |tag_1| + 67, + 71, # CG + 124, + 116, + 97, + 103, + 95, + 50, + 124, # |tag_2| + 65, + 84, # AT + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor( + [ + 1, + 1, + 1, # DNA unmasked + 0, + 0, + 0, + 0, + 0, + 0, + 0, # first tag masked + 1, + 1, # DNA unmasked + 0, + 0, + 0, + 0, + 0, + 0, + 0, # second tag masked + 1, + 1, # DNA unmasked + ] + ) + assert torch.equal(mask, expected_mask) + + +def test_mask_dna_after_pipe(tag_tokens): + """Tests the scenario where we have a pipe followed by DNA sequence. + + This tests the edge case of a pipe character appearing at the start of a sequence. + Even if DNA follows, we mask the pipe character to prevent the model from + learning to output non-DNA tokens. + + Sequence: "|ATG" (pipe followed by DNA) + Expected: Pipe masked, DNA unmasked + """ + sequence = torch.tensor( + [ + 124, # | + 65, + 84, + 71, # ATG + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor([0, 1, 1, 1]) # Pipe masked, DNA unmasked + assert torch.equal(mask, expected_mask) + + +def test_ambiguous_dna_char_followed_by_tag_start(tag_tokens): + """Tests handling of an ambiguous DNA character followed by a tag start. + + When we see a character that could be either DNA or the end of a truncated tag + followed by a pipe, we should mask both for safety since we can't disambiguate + whether the character was part of a tag. + + Sequence: "t|AAAT" (t could be DNA or end of tag) + Expected: First t and pipe masked (0), AAAT unmasked (1) + """ + sequence = torch.tensor( + [ + 116, # t (ambiguous - could be DNA or end of tag) + 124, # | + 65, # A + 65, # A + 65, # A + 84, # T + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor([0, 0, 1, 1, 1, 1]) # Ambiguous t and pipe masked, DNA unmasked + assert torch.equal(mask, expected_mask) + + +def test_dna_followed_by_unambiguous_tag_start(tag_tokens): + """Tests handling of DNA sequence followed by clear tag start. + + When we see DNA followed by |d, it's unambiguous - the d clearly indicates + the start of a phylogenetic tag (d__), so we can safely unmask the DNA and + mask the tag portion. + + Sequence: "AAAT|d" (AAAT is DNA, |d starts tag) + Expected: AAAT unmasked (1), |d masked (0) + """ + sequence = torch.tensor( + [ + 65, # A + 65, # A + 65, # A + 84, # T + 124, # | + 100, # d (clearly starts d__ tag) + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor([1, 1, 1, 1, 0, 0]) # DNA unmasked, tag start masked + assert torch.equal(mask, expected_mask) + + +def test_double_partial_tags_with_dna_middle(tag_tokens): + """Tests a sequence that has partial tags at both ends with DNA in the middle. + + Tests the specific case where a sequence slice cuts through phylogenetic tags + on both ends, with valid DNA sequence in the middle. The behavior we want is: + 1. The partial tag at the start should be masked + 2. The DNA in the middle should be unmasked + 3. The partial tag at the end should be masked + + Sequence: "cacata|acagataaaataTACAGGGAATA|d__" + Expected: First partial tag masked (0s), middle DNA unmasked (1s), end tag masked (0s) + """ + sequence = torch.tensor( + [ + 99, + 97, + 99, + 97, + 116, + 97, # cacata + 124, # | + 97, + 99, + 97, + 103, + 97, + 116, + 97, + 97, + 97, + 97, + 116, + 97, # acagataaaata + 84, + 65, + 67, + 65, + 71, + 71, + 71, + 65, + 65, + 84, + 65, # TACAGGGAATA + 124, # | + 100, + 95, + 95, # d__ + ] + ) + + mask = Evo2Dataset.mask_phylogenetic_tags( + tokenized_sequence=sequence, + terminal_tag_char=tag_tokens["terminal"], + other_tag_chars=tag_tokens["other_chars"], + eod_token_id=tag_tokens["eod"], + ) + + expected_mask = torch.tensor( + [ + 0, + 0, + 0, + 0, + 0, + 0, # partial start tag masked + 0, # pipe masked + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, # middle DNA unmasked + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, # middle DNA unmasked + 0, # pipe masked + 0, + 0, + 0, # partial end tag masked + ] + ) + + assert torch.equal(mask, expected_mask) From 75205b079d41b7dbc8ccbc9ef55f80e5496b916a Mon Sep 17 00:00:00 2001 From: Cory Ye <cye@nvidia.com> Date: Mon, 10 Feb 2025 16:37:58 -0800 Subject: [PATCH 050/140] [cye/torch_dist_fix] Remove torch_dist patch and bump Megatron, reorganize tests. --- 3rdparty/Megatron-LM | 2 +- 3rdparty/NeMo | 2 +- Dockerfile | 7 ------- sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py | 7 +++++++ .../tests/bionemo/{ => evo2}/run/test_infer.py | 7 +------ .../tests/bionemo/{ => evo2/run}/test_inference.py | 4 +--- .../bionemo-evo2/tests/bionemo/{ => evo2}/test_evo2.py | 0 .../tests/bionemo/{ => evo2}/test_hyena_operators.py | 0 .../bionemo/{ => evo2}/test_mask_phylogenetic_tags.py | 0 .../src/bionemo/testing/megatron_parallel_state_utils.py | 2 +- 10 files changed, 12 insertions(+), 19 deletions(-) rename sub-packages/bionemo-evo2/tests/bionemo/{ => evo2}/run/test_infer.py (90%) rename sub-packages/bionemo-evo2/tests/bionemo/{ => evo2/run}/test_inference.py (97%) rename sub-packages/bionemo-evo2/tests/bionemo/{ => evo2}/test_evo2.py (100%) rename sub-packages/bionemo-evo2/tests/bionemo/{ => evo2}/test_hyena_operators.py (100%) rename sub-packages/bionemo-evo2/tests/bionemo/{ => evo2}/test_mask_phylogenetic_tags.py (100%) diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index 2a9793d19e..bcee0521dc 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit 2a9793d19e3a5c0a557c899ad4b902302bbf5fdf +Subproject commit bcee0521dc886545a6af88a4e268715d99e03143 diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 03d5a439d8..08ce325d41 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 03d5a439d87801b60faf8e92a016ca81029dd655 +Subproject commit 08ce325d41678ff2311296947b96be8a651555b9 diff --git a/Dockerfile b/Dockerfile index 34d3e00425..bd76455e5d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -99,13 +99,6 @@ COPY ./LICENSE /workspace/bionemo2/LICENSE COPY ./3rdparty /workspace/bionemo2/3rdparty COPY ./sub-packages /workspace/bionemo2/sub-packages -# Apply patches with temporary fixes, before the modules are installed. (Use absolute path for patch filepath.) -# FIXME(cspades) Remove the torch_dist checkpoint size patch when https://gitlab-master.nvidia.com/ADLR/megatron-lm/-/merge_requests/2604 is merged. -COPY ./ci/scripts/*.patch /workspace/bionemo2/ci/scripts/ -RUN MEGATRON_DIR=./3rdparty/Megatron-LM && \ -patch -p1 -d $MEGATRON_DIR -i /workspace/bionemo2/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch && \ -rm ./ci/scripts/*.patch - # Note, we need to mount the .git folder here so that setuptools-scm is able to fetch git tag for version. # Includes a hack to install tensorstore 0.1.45, which doesn't distribute a pypi wheel for python 3.12, and the metadata # in the source distribution doesn't match the expected pypi version. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index ad62cb3de6..b34c0106bf 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -54,6 +54,7 @@ def parse_args(): ap.add_argument("--top-k", type=int, default=0, help="Top K during sampling for generation.") ap.add_argument("--top-p", type=float, default=0.0, help="Top P during sampling for generation.") ap.add_argument("--max-new-tokens", type=int, default=1024, help="Maximum number of tokens to generate.") + ap.add_argument("--seed", type=int, default=None, help="Random seed for generation.") # compute args: ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1.") ap.add_argument( @@ -93,6 +94,7 @@ def infer( context_parallel_size: int, output_file: Optional[str] = None, ckpt_format: CheckpointFormats = "torch_dist", + seed: Optional[int] = None, ): """Inference workflow for Evo2. @@ -108,6 +110,7 @@ def infer( context_parallel_size (int): Order of context parallelism. output_file (str): Output file containing the generated text produced by the Evo2 model. ckpt_format (CheckpointFormats): Checkpoint format to use. + seed (int): Random seed for generation. Returns: None @@ -148,6 +151,7 @@ def infer( num_tokens_to_generate=max_new_tokens, ), text_only=True, + random_seed=seed if seed is not None else None, ) if torch.distributed.get_rank() == 0: @@ -157,6 +161,8 @@ def infer( with open(output_file, "w") as f: f.write(f"{results}\n") + return results + if __name__ == "__main__": # Parse args. @@ -173,4 +179,5 @@ def infer( context_parallel_size=args.context_parallel_size, output_file=args.output_file, ckpt_format=args.ckpt_format, + seed=args.seed, ) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py similarity index 90% rename from sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py rename to sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index 448e6e8710..33945e3b03 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -14,11 +14,9 @@ # limitations under the License. -import torch - from bionemo.core.data.load import load from bionemo.evo2.run.infer import infer -from bionemo.testing.megatron_parallel_state_utils import _teardown_apex_megatron_cuda, clean_parallel_state_context +from bionemo.testing.megatron_parallel_state_utils import clean_parallel_state_context RANDOM_SEED = 42 @@ -60,6 +58,3 @@ def test_run_infer(): pipeline_model_parallel_size=pipeline_model_parallel_size, context_parallel_size=context_parallel_size, ) - - _teardown_apex_megatron_cuda() - torch.cuda.empty_cache() diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py similarity index 97% rename from sub-packages/bionemo-evo2/tests/bionemo/test_inference.py rename to sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index 4526aa0834..935b3acdf3 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -19,7 +19,7 @@ from nemo.collections.llm import generate from bionemo.core.data.load import load -from bionemo.testing.megatron_parallel_state_utils import _teardown_apex_megatron_cuda, clean_parallel_state_context +from bionemo.testing.megatron_parallel_state_utils import clean_parallel_state_context RANDOM_SEED = 42 @@ -92,8 +92,6 @@ def test_infer_model_generates_expected_single_token_output(): assert isinstance(results, list) assert results == ["T"] - _teardown_apex_megatron_cuda() - torch.cuda.empty_cache() # def test_infer_model_generates_expected_single_token_output_from_input_seq(): diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py similarity index 100% rename from sub-packages/bionemo-evo2/tests/bionemo/test_evo2.py rename to sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py similarity index 100% rename from sub-packages/bionemo-evo2/tests/bionemo/test_hyena_operators.py rename to sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/test_mask_phylogenetic_tags.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_mask_phylogenetic_tags.py similarity index 100% rename from sub-packages/bionemo-evo2/tests/bionemo/test_mask_phylogenetic_tags.py rename to sub-packages/bionemo-evo2/tests/bionemo/evo2/test_mask_phylogenetic_tags.py diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py index 8ef0762239..0b9bf73fa2 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py @@ -72,9 +72,9 @@ def _teardown_apex_megatron_cuda(): - sets the global variables related to model and data parallelism to None in Apex and Megatron:. - releases all unoccupied cached GPU memory currently held by the caching CUDA allocator, see torch.cuda.empty_cache """ # noqa: D205, D415 + parallel_state.destroy_model_parallel() torch.cuda.empty_cache() _reset_microbatch_calculator() - parallel_state.destroy_model_parallel() def _initialize_distributed_parallel_state( From 0f6efebcb925a46a5207b8cae9830592a92a1833 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 11 Feb 2025 12:42:06 -0800 Subject: [PATCH 051/140] Changes related to accuracy and perf with new nemo2 changes --- 3rdparty/NeMo | 2 +- .../src/bionemo/evo2/run/train.py | 198 ++++++++++++++---- .../src/bionemo/evo2/utils/config.py | 2 +- .../tests/bionemo/evo2/run/test_train.py | 63 ++++++ 4 files changed, 220 insertions(+), 45 deletions(-) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 08ce325d41..d89c1f75ab 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 08ce325d41678ff2311296947b96be8a651555b9 +Subproject commit d89c1f75ab03ec1ffdad8fc4dfb107774809670a diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index e4c61d1813..2410e40bb3 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -16,6 +16,7 @@ import argparse from collections import defaultdict from dataclasses import asdict +from typing import Type # import nvidia_resiliency_ext.ptl_resiliency as res_module import torch @@ -26,8 +27,8 @@ from megatron.core.optimizer import OptimizerConfig from nemo import lightning as nl from nemo.collections import llm -from nemo.collections.llm.gpt.data import PreTrainingDataModule -from nemo.collections.llm.gpt.data.megatron.hyena import Evo2Dataset +from nemo.collections.llm.gpt.data import MockDataModule, PreTrainingDataModule +from nemo.collections.llm.gpt.data.megatron.hyena.evo2_dataset import Evo2Dataset, Evo2DatasetPadEodLossMask from nemo.collections.llm.recipes.tp_overlap_configs.userbuffers import userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192 from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger @@ -46,7 +47,7 @@ torch._dynamo.config.suppress_errors = True -model_options = { +model_options: dict[str, Type[llm.HyenaConfig]] = { "7b": llm.Hyena7bConfig, "7b_arc_longcontext": llm.Hyena7bARCLongContextConfig, "7b_nv": llm.HyenaNV7bConfig, @@ -61,13 +62,19 @@ def parse_args(): """Parse arguments for Evo2 model training.""" parser = argparse.ArgumentParser(description="Train a Hyena model using NeMo 2.0.") - parser.add_argument( + data_group = parser.add_mutually_exclusive_group(required=True) + + data_group.add_argument( "-d", "--dataset-config", type=str, - required=True, help="Path to the blended / weighted training dataset configuration YAML.", ) + data_group.add_argument( + "--mock-data", + action="store_true", + help="Train with Mock data (for testing/debugging), either set this or provide a dataset config.", + ) parser.add_argument("--num-nodes", type=int, default=1, help="Number of nodes to use for training, defaults to 1.") parser.add_argument("--devices", type=int, default=1, help="Number of devices to use for training, defaults to 1.") parser.add_argument("--seq-length", type=int, default=8192, help="Training sequence length") @@ -80,6 +87,7 @@ def parse_args(): parser.add_argument( "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." ) + parser.add_argument("--no-wandb", action="store_true", default=False, help="Disable Wandb logging") parser.add_argument("--wandb-project", type=str, default="bionemo_evo2", help="Wandb project name") parser.add_argument("--wandb-run-id", type=str, default=None, help="Wandb run identifier") parser.add_argument( @@ -108,6 +116,12 @@ def parse_args(): "--val-check-interval", type=int, help="Number of steps between validation measurements and model checkpoints." ) parser.add_argument("--grad-reduce-in-fp32", action="store_true", default=False, help="Gradient reduce in FP32.") + parser.add_argument( + "--fp8-wgrad", + action="store_true", + default=False, + help="Faster option that is maybe less accurate (TBD) when using fp8.", + ) parser.add_argument( "--no-aligned-megatron-ddp", action="store_true", default=False, help="Do not do aligned gradient updates etc." ) @@ -119,7 +133,15 @@ def parse_args(): type=str, choices=sorted(model_options.keys()), default="7b", - help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained with TP<=8.", + help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B " + "parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained " + "with TP<=8.", + ) + parser.add_argument( + "--add-bias-output", + action="store_true", + default=False, + help="Add bias to the output layer to enable learning a simple prior.", ) parser.add_argument( "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." @@ -142,6 +164,12 @@ def parse_args(): action="store_true", help="Restore optimizer state from initial checkpoint. Defaults to False.", ) + parser.add_argument( + "--no-average-in-collective", + action="store_true", + default=False, + help="Avaerage optimizer state in collective rather than dividing by dp size and summing.", + ) parser.add_argument("--seed", type=int, default=1234, help="Set random seed for training.") parser.add_argument("--workers", type=int, default=0, help="Number of workers to use for data loading.") parser.add_argument( @@ -168,11 +196,51 @@ def parse_args(): default="torch_dist", help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated.", ) + parser.add_argument( + "--eod-pad-in-loss-mask", + action="store_true", + default=False, + help="Do not predict EOD/Pad tokens (typical default, but not default in original evo2).", + ) + parser.add_argument( + "--cross-entropy-loss-fusion", + action="store_true", + default=False, + help="Use the faster, but maybe less accurate fused form of cross entropy, " + "which also has bf16 grads internally.", + ) + parser.add_argument( + "--no-fp32-residual-connection", + action="store_true", + default=False, + help="If set, turn off fp32 residual connections which may be faster but may impact accuracy.", + ) + parser.add_argument( + "--debug-ddp-parity-freq", + type=int, + default=0, + help="Set to value > 0 to debug DDP weight parity between ranks.", + ) + parser.add_argument( + "--hybrid-override-pattern", + type=str, + help="Override the hybrid override pattern in the config (specifies hyena layer ordering and type).", + ) + parser.add_argument( + "--num-layers", type=int, help="If set, override the number of layers specified in the requested config." + ) parser.add_argument( "--tflops-callback", action="store_true", + default=False, help="Enable tflops calculation callback for Hyena / Evo2. Defaults to False.", ) + parser.add_argument( + "--log-parameters-and-shapes", + action="store_true", + default=False, + help="Log training parameters shapes and dtypes for debugging.", + ) parser.add_argument("--lr", type=float, default=3e-4, help="Learning rate.") parser.add_argument("--min-lr", type=float, default=3e-5, help="Min learning rate in cosine annealing.") parser.add_argument("--warmup-steps", type=int, default=2500, help="Number of warmup steps in cosine annealing") @@ -181,8 +249,10 @@ def parse_args(): "--nsys-profiling", action="store_true", default=False, - help="Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling output you must run the whole program with `nsys`. For example: " - " `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true --capture-range=cudaProfilerApi --capture-range-end=stop [regular python command here]`", + help="Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling" + " output you must run the whole program with `nsys`. For example: " + " `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true " + "--capture-range=cudaProfilerApi --capture-range-end=stop [regular python command here]`", ) # start, end, rank parser.add_argument( @@ -218,6 +288,12 @@ def parse_args(): type=int, help="If set, override the default value set in the config.", ) + parser.add_argument( + "--clip-grad", + type=float, + default=1.0, + help="Grad clip value. Note that when using DDP this may need to be inflated.", + ) recompute_group = parser.add_mutually_exclusive_group(required=False) recompute_group.add_argument("--no-activation-checkpointing", action="store_true", default=False) recompute_group.add_argument("--selective-activation-checkpointing", action="store_true", default=False) @@ -258,7 +334,6 @@ def main(): args = parse_args() # Parse dataset configuration. - blended_dataset_config = parse_dataset_config(args.dataset_config) # Instantiate tokenizer. tokenizer = get_nmt_tokenizer( @@ -277,19 +352,29 @@ def main(): pipeline_model_parallel_size=args.pipeline_model_parallel_size, context_model_parallel_size=args.context_parallel_size, ) - - # Instantiate pre-training module. - data = PreTrainingDataModule( - paths=blended_dataset_config, - dataset_cls=Evo2Dataset, - seq_length=args.seq_length, - micro_batch_size=args.micro_batch_size, - global_batch_size=global_batch_size, - seed=args.seed, - num_workers=args.workers, - tokenizer=tokenizer, - eod_mask_loss=False, - ) + if args.mock_data: + data = MockDataModule( + seq_length=args.seq_length, + micro_batch_size=args.micro_batch_size, + global_batch_size=global_batch_size, + num_workers=args.workers, + tokenizer=tokenizer, + ) + else: + blended_dataset_config = parse_dataset_config(args.dataset_config) + dataset_cls = Evo2DatasetPadEodLossMask if args.eod_pad_in_loss_mask else Evo2Dataset + # Instantiate pre-training module. + data = PreTrainingDataModule( + paths=blended_dataset_config, + dataset_cls=dataset_cls, + seq_length=args.seq_length, + micro_batch_size=args.micro_batch_size, + global_batch_size=global_batch_size, + seed=args.seed, + num_workers=args.workers, + tokenizer=tokenizer, + eod_mask_loss=args.eod_pad_in_loss_mask, + ) if args.no_activation_checkpointing: activation_checkpointing_args = { @@ -317,8 +402,15 @@ def main(): "seq_length": args.seq_length, "to_upper": "weighted" if args.no_renormalize_loss else "normalized_weighted", "distribute_saved_activations": False if args.sequence_parallel else True, + "cross_entropy_loss_fusion": args.cross_entropy_loss_fusion, + "fp32_residual_connection": not args.no_fp32_residual_connection, + "add_bias_output": args.add_bias_output, **activation_checkpointing_args, } + if args.hybrid_override_pattern: + config_modifiers_init["hybrid_override_pattern"] = args.hybrid_override_pattern + if args.num_layers: + config_modifiers_init["num_layers"] = args.num_layers if args.model_size not in model_options: raise ValueError(f"Invalid model size: {args.model_size}") @@ -344,6 +436,10 @@ def main(): ] if args.enable_preemption: callbacks.append(nl_callbacks.PreemptionCallback()) + if args.debug_ddp_parity_freq > 0: + callbacks.append(nl_callbacks.DdpParityChecker(interval=args.debug_ddp_parity_freq)) + if args.log_parameters_and_shapes: + callbacks.append(nl_callbacks.ParameterDebugger()) if args.tflops_callback: # Add callback that logs the tera-FLOPS per second per GPU during training. flop_meas_callback = FLOPsMeasurementCallback( @@ -396,35 +492,48 @@ def main(): ) loggers = [] - wandb_logger = WandbLogger( - name=( - f"evo2-size-{args.model_size}-TP{args.tensor_parallel_size}-" - f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" - f"-GBS{global_batch_size}-MBS{args.micro_batch_size}-SkipLossRenorm{args.no_renormalize_loss}" - f"-NOAC{args.no_activation_checkpointing}-SELAC{args.selective_activation_checkpointing}" - f"-ACRNL{evo2_config.recompute_num_layers}" - f"-LR{args.lr}-MINLR{args.min_lr}-WUSTEPS{args.warmup_steps}-WD{args.wd}" - f"-GRFP32{args.grad_reduce_in_fp32}-ALIGN{not args.no_aligned_megatron_ddp}" - f"-NODES{args.num_nodes}-FP8{args.fp8}" - ), - group=args.wandb_group, - job_type=args.wandb_job_type, - id=args.wandb_run_id, # set this to use the same curve name for restarts. - project=args.wandb_project, - save_dir=args.experiment_dir, - ) - loggers.append(wandb_logger) + nemo_logger_kwargs = {} + if (not args.no_wandb) and args.wandb_project: + wandb_logger = WandbLogger( + name=( + f"evo2-size-{args.model_size}-TP{args.tensor_parallel_size}-" + f"PP{args.pipeline_model_parallel_size}-CP{args.context_parallel_size}" + f"-GBS{global_batch_size}-MBS{args.micro_batch_size}-SkipLossRenorm{args.no_renormalize_loss}" + f"-NOAC{args.no_activation_checkpointing}-SELAC{args.selective_activation_checkpointing}" + f"-ACRNL{evo2_config.recompute_num_layers}" + f"-PAT{evo2_config.hybrid_override_pattern}" + f"-F32R{evo2_config.fp32_residual_connection}" + f"-FCE{evo2_config.cross_entropy_loss_fusion}" + f"-AIC{not args.no_average_in_collective}" + f"-PEOD{args.eod_pad_in_loss_mask}" + f"-BO{args.add_bias_output}" + f"-GCLP{args.clip_grad}" + f"-LR{args.lr}-MINLR{args.min_lr}-WUSTEPS{args.warmup_steps}-WD{args.wd}" + f"-GRFP32{args.grad_reduce_in_fp32}-FP8WG{args.fp8_wgrad and args.fp8}" + f"-ALIGN{not args.no_aligned_megatron_ddp}" + f"-NODES{args.num_nodes}-FP8{args.fp8}" + ), + group=args.wandb_group, + job_type=args.wandb_job_type, + id=args.wandb_run_id, # set this to use the same curve name for restarts. + project=args.wandb_project, + save_dir=args.experiment_dir, + ) + loggers.append(wandb_logger) + nemo_logger_kwargs["wandb"] = wandb_logger tb_logger = TensorBoardLogger( save_dir="dummy", ## NOTE: this gets overwritten by default ) + nemo_logger_kwargs["tensorboard"] = tb_logger loggers.append(tb_logger) - nemo_logger = NeMoLogger(log_dir=args.experiment_dir, wandb=wandb_logger) + nemo_logger = NeMoLogger(log_dir=args.experiment_dir, **nemo_logger_kwargs) if args.no_aligned_megatron_ddp: ddp: str | DistributedDataParallelConfig = DistributedDataParallelConfig( check_for_nan_in_grad=True, grad_reduce_in_fp32=args.grad_reduce_in_fp32, align_param_gather=args.align_param_gather, + average_in_collective=not args.no_average_in_collective, ) else: ddp = DistributedDataParallelConfig( @@ -432,7 +541,7 @@ def main(): grad_reduce_in_fp32=args.grad_reduce_in_fp32, overlap_grad_reduce=True, overlap_param_gather=True, - average_in_collective=True, + average_in_collective=not args.no_average_in_collective, align_param_gather=args.align_param_gather, use_distributed_optimizer=True, # this should inherit from the optimizer config, but just in case... ) @@ -465,9 +574,11 @@ def main(): plugins=nl.MegatronMixedPrecision( precision="bf16-mixed", params_dtype=torch.bfloat16, + grad_reduce_in_fp32=args.grad_reduce_in_fp32, fp8="hybrid" if args.fp8 else None, fp8_amax_history_len=16 if args.fp8 else 1, fp8_amax_compute_algo="max" if args.fp8 else "most_recent", + fp8_wgrad=args.fp8_wgrad and args.fp8, # faster and less accurate when set to True ), val_check_interval=args.val_check_interval, ) @@ -502,6 +613,7 @@ def main(): adam_beta1=0.9, adam_beta2=0.95, weight_decay=args.wd, + clip_grad=args.clip_grad, use_distributed_optimizer=True, bf16=True, ) @@ -511,7 +623,7 @@ def main(): min_lr=args.min_lr, ) - opt = MegatronOptimizerModule(opt_config, sched) + opt = MegatronOptimizerModule(opt_config, sched, no_weight_decay_cond=evo2_config.hyena_no_weight_decay_cond_fn) opt.connect(model) # Start training diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index 231bca8516..ead023a37c 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -61,7 +61,7 @@ class Evo2PreprocessingConfig(BaseModel): force_uppercase: bool = False indexed_dataset_dtype: str = "uint8" # Tokenization Transforms - append_eod: bool = False + append_eod: bool = True enforce_sample_length: None | int = None ftfy: bool = False # NeMo Tokenizer Configuration diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py new file mode 100644 index 0000000000..cfe84ac335 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py @@ -0,0 +1,63 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import os +import subprocess +import sys + +import pytest +from lightning.fabric.plugins.environments.lightning import find_free_network_port + + +@pytest.mark.timeout(256) # Optional: fail if the test takes too long. +def test_train_evo2_runs(tmp_path, num_steps=5): + """ + This test runs the `train_evo2` command with mock data in a temporary directory. + It uses the temporary directory provided by pytest as the working directory. + The command is run in a subshell, and we assert that it returns an exit code of 0. + """ + open_port = find_free_network_port() + # a local copy of the environment + env = dict(**os.environ) + env["MASTER_PORT"] = str(open_port) + + # Build the command string. + # Note: The command assumes that `train_evo2` is in your PATH. + command = ( + f"train_evo2 --mock-data --experiment-dir {tmp_path}/test_train " + "--model-size 7b_nv --num-layers 4 --hybrid-override-pattern SDH* " + "--no-activation-checkpointing --add-bias-output " + f"--max-steps {num_steps} --warmup-steps 1 --no-wandb " + "--seq-length 128 " + ) + + # Run the command in a subshell, using the temporary directory as the current working directory. + result = subprocess.run( + command, + shell=True, # Use the shell to interpret wildcards (e.g. SDH*) + cwd=tmp_path, # Run in the temporary directory + capture_output=True, # Capture stdout and stderr for debugging + env=env, # Pass in the env where we override the master port. + text=True, # Decode output as text + ) + + # For debugging purposes, print the output if the test fails. + if result.returncode != 0: + sys.stderr.write("STDOUT:\n" + result.stdout + "\n") + sys.stderr.write("STDERR:\n" + result.stderr + "\n") + + # Assert that the command completed successfully. + assert "reduced_train_loss:" in result.stdout + assert result.returncode == 0, "train_evo2 command failed." From 0af5f9e3ea8ed5887cb86385a02439eaedb363c4 Mon Sep 17 00:00:00 2001 From: Cory Ye <cye@login-eos01.eos.clusters.nvidia.com> Date: Wed, 12 Feb 2025 15:09:07 -0800 Subject: [PATCH 052/140] [cye/tp-comm-fp8-wgrad-fix]Require --fp8-wgrad when using TP communication overlap. --- .../src/bionemo/evo2/run/train.py | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 2410e40bb3..904027de82 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -29,7 +29,10 @@ from nemo.collections import llm from nemo.collections.llm.gpt.data import MockDataModule, PreTrainingDataModule from nemo.collections.llm.gpt.data.megatron.hyena.evo2_dataset import Evo2Dataset, Evo2DatasetPadEodLossMask -from nemo.collections.llm.recipes.tp_overlap_configs.userbuffers import userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192 +from nemo.collections.llm.recipes.tp_overlap_configs.userbuffers import ( + userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, + userbuffers_fp8_h100_h8192_tp4_mbs1_seqlen8192, +) from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger from nemo.lightning.pytorch import callbacks as nl_callbacks @@ -126,6 +129,13 @@ def parse_args(): "--no-aligned-megatron-ddp", action="store_true", default=False, help="Do not do aligned gradient updates etc." ) parser.add_argument("--use-megatron-comm-overlap-llama3-8k", action="store_true", default=False) + parser.add_argument( + "--tp-comm-overlap-backend", + type=str, + choices=["nccl", "mpi", "gloo"], + default="nccl", + help="TP communication backend to use. Defaults to 'nccl'.", + ) parser.add_argument("--align-param-gather", action="store_true", default=False) # parser.add_argument("--straggler-detection", action="store_true", default=False) parser.add_argument( @@ -467,7 +477,10 @@ def main(): callbacks.append( MegatronCommOverlapCallback( tp_comm_overlap=evo2_config.tp_comm_overlap, - tp_comm_overlap_cfg=userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, + tp_comm_overlap_cfg=userbuffers_fp8_h100_h8192_tp4_mbs1_seqlen8192 + if args.fp8 + else userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, + tp_comm_bootstrap_backend=args.tp_comm_overlap_backend, wgrad_deferral_limit=22, # default from NeMo overlap_param_gather_with_optimizer_step=False, # Currently disabled due to an issue with checkpointing. align_param_gather=args.align_param_gather, @@ -578,7 +591,10 @@ def main(): fp8="hybrid" if args.fp8 else None, fp8_amax_history_len=16 if args.fp8 else 1, fp8_amax_compute_algo="max" if args.fp8 else "most_recent", - fp8_wgrad=args.fp8_wgrad and args.fp8, # faster and less accurate when set to True + fp8_wgrad=args.fp8 + and ( + args.fp8_wgrad or args.use_megatron_comm_overlap_llama3_8k + ), # faster and less accurate when set to True, and MUST be True if using TP communication overlap ), val_check_interval=args.val_check_interval, ) From 0917616b5f6b353fab3e074775920eb6ed084632 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska <dorotat@nvidia.com> Date: Thu, 13 Feb 2025 10:40:48 -0800 Subject: [PATCH 053/140] Adding evo2 to JET --- ci/benchmarks/partial-conv/evo2_pretrain.yaml | 63 ++++++ ci/benchmarks/perf/evo2_pretrain.yaml | 67 +++++++ ci/benchmarks/test_dataset_config.yaml | 81 ++++++++ .../src/bionemo/evo2/run/train.py | 85 ++++---- .../src/bionemo/evo2/utils/config.py | 78 +++++++- ...omoters_uint8_distinct_byte-level_test.bin | Bin 0 -> 2404 bytes ...omoters_uint8_distinct_byte-level_test.idx | Bin 42 -> 122 bytes ...moters_uint8_distinct_byte-level_train.bin | Bin 8414 -> 4808 bytes ...moters_uint8_distinct_byte-level_train.idx | Bin 322 -> 202 bytes ...romoters_uint8_distinct_byte-level_val.bin | Bin 1202 -> 2404 bytes ...romoters_uint8_distinct_byte-level_val.idx | Bin 82 -> 122 bytes .../bionemo/evo2/data/test_preprocess.py | 28 ++- .../tests/bionemo/evo2/test_config.py | 183 ++++++++++++++++++ 13 files changed, 528 insertions(+), 57 deletions(-) create mode 100644 ci/benchmarks/partial-conv/evo2_pretrain.yaml create mode 100644 ci/benchmarks/perf/evo2_pretrain.yaml create mode 100644 ci/benchmarks/test_dataset_config.yaml create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py diff --git a/ci/benchmarks/partial-conv/evo2_pretrain.yaml b/ci/benchmarks/partial-conv/evo2_pretrain.yaml new file mode 100644 index 0000000000..56d95aee7a --- /dev/null +++ b/ci/benchmarks/partial-conv/evo2_pretrain.yaml @@ -0,0 +1,63 @@ +scope: partial-conv +time_limit: 14400 +script_args: + # All arguments referenced in the script string must be specified here. + # Arguments not referenced in the script string must have the 'arg' field specified. + # See jet/core/configs.py for the specification of the configuration class + workspace: + value: /workspace/bionemo2 + key_segment: False + data_path: + value: /data/evo2 + key_segment: False + model: + value: evo2 + variant: + value: train + config_name: + value: 7b + precision: + value: fp8 + nodes: + value: 4 + gpus: + value: 8 + batch_size: + value: 2 + pp: + value: 1 + tp: + value: 8 + cp: + value: 1 + acc_grad: + value: 1 + max_steps: + value: 20000 +script: |- + WANDB_API_KEY=$BIONEMO_WANDB_API_KEY python ${workspace}/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py \ + -d ${workspace}/ci/benchmarks/test_dataset_config.yaml \ + --dataset-path ${data_path} \ + --grad-acc-batches ${acc_grad} \ + --fp8 \ + --enable-preemption \ + --ckpt-async-save \ + --seq-length=8192 \ + --tensor-parallel-size=${tp} \ + --context-parallel-size=${cp} \ + --pipeline-model-parallel-size=${pp} \ + --workers 8 \ + --num-nodes=${nodes} \ + --devices=${gpus} \ + --micro-batch-size=${batch_size} \ + --model-size=${config_name} \ + --max-steps=${max_steps} \ + --limit-val-batches=20 \ + --log-every-n-steps=50 \ + --val-check-interval=500 \ + --tflops-callback \ + --experiment-dir=${tensorboard_dir}/${batch_size}bs_${nodes}node_${gpus}gpu_${max_steps}s_${precision}prec \ + --wandb-project=${wandb_project_name} \ + --wandb-group=${model}_${variant}_${config_name}__${target} \ + --wandb-job-type=${pipeline_label} \ + --disable-checkpointing; diff --git a/ci/benchmarks/perf/evo2_pretrain.yaml b/ci/benchmarks/perf/evo2_pretrain.yaml new file mode 100644 index 0000000000..865bbb0df3 --- /dev/null +++ b/ci/benchmarks/perf/evo2_pretrain.yaml @@ -0,0 +1,67 @@ +scope: perf +time_limit: 1800 +script_args: + # All arguments referenced in the script string must be specified here. + # Arguments not referenced in the script string must have the 'arg' field specified. + # See jet/core/configs.py for the specification of the configuration class + workspace: + value: /workspace/bionemo2 + key_segment: False + data_path: + value: /data/evo2 + key_segment: False + model: + value: evo2 + variant: + value: train + precision: + value: fp8 + gpus: + value: 8 + batch_size: + value: 2 + max_steps: + value: 100 + tp: + value: 8 + cp: + value: 1 + pp: + value: 1 + acc_grad: + value: 1 + products: + - nodes: 1 + config_name: 7b + - nodes: 2 + config_name: 7b + - nodes: 8 + config_name: 40b +script: |- + WANDB_API_KEY=$BIONEMO_WANDB_API_KEY python ${workspace}/sub-packages/bionemo-evo2/src/bionemo/evo2/run/${variant}.py \ + -d ${workspace}/ci/benchmarks/test_dataset_config.yaml \ + --dataset-path ${data_path} \ + --grad-acc-batches ${acc_grad} \ + --fp8 \ + --enable-preemption \ + --ckpt-async-save \ + --use-megatron-comm-overlap-llama3-8k \ + --seq-length=8192 \ + --tensor-parallel-size=${tp} \ + --context-parallel-size=${cp} \ + --pipeline-model-parallel-size=${pp} \ + --workers 8 \ + --num-nodes=${nodes} \ + --devices=${gpus} \ + --micro-batch-size=${batch_size} \ + --model-size=${config_name} \ + --max-steps=${max_steps} \ + --limit-val-batches=20 \ + --log-every-n-steps=50 \ + --val-check-interval=${max_steps} \ + --tflops-callback \ + --experiment-dir=${tensorboard_dir}/${batch_size}bs_${nodes}node_${gpus}gpu_${max_steps}s_${precision}prec \ + --wandb-project=${wandb_project_name} \ + --wandb-group=${model}_${variant}_${config_name}__${target} \ + --wandb-job-type=${pipeline_label} \ + --disable-checkpointing; diff --git a/ci/benchmarks/test_dataset_config.yaml b/ci/benchmarks/test_dataset_config.yaml new file mode 100644 index 0000000000..63709d2cbd --- /dev/null +++ b/ci/benchmarks/test_dataset_config.yaml @@ -0,0 +1,81 @@ +- dataset_prefix: metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.18 +- dataset_prefix: gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.24 +- dataset_prefix: imgvr/pretraining_data_imgvr/data_imgvr_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.03 +- dataset_prefix: ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.02 +- dataset_prefix: mrna/pretraining_data_mrna/data_mrna_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.09 +- dataset_prefix: euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.09 +- dataset_prefix: euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.35 +- dataset_prefix: promoters/pretraining_data_promoters/data_promoters_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.0003 +- dataset_prefix: organelle/pretraining_data_organelle/data_organelle_train_text_CharLevelTokenizer_document + dataset_split: train + dataset_weight: 0.005 +- dataset_prefix: metagenomics/pretraining_data_metagenomics/data_metagenomics_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.18 +- dataset_prefix: gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.24 +- dataset_prefix: imgvr/pretraining_data_imgvr/data_imgvr_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.03 +- dataset_prefix: ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.02 +- dataset_prefix: mrna/pretraining_data_mrna/data_mrna_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.09 +- dataset_prefix: euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.09 +- dataset_prefix: euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.35 +- dataset_prefix: promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.0003 +- dataset_prefix: organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document + dataset_split: validation + dataset_weight: 0.005 +- dataset_prefix: metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.18 +- dataset_prefix: gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.24 +- dataset_prefix: imgvr/pretraining_data_imgvr/data_imgvr_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.03 +- dataset_prefix: ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.02 +- dataset_prefix: mrna/pretraining_data_mrna/data_mrna_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.09 +- dataset_prefix: euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.09 +- dataset_prefix: euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.35 +- dataset_prefix: promoters/pretraining_data_promoters/data_promoters_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.0003 +- dataset_prefix: organelle/pretraining_data_organelle/data_organelle_test_text_CharLevelTokenizer_document + dataset_split: test + dataset_weight: 0.005 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 904027de82..899d86e71d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -14,13 +14,11 @@ # limitations under the License. import argparse -from collections import defaultdict from dataclasses import asdict from typing import Type # import nvidia_resiliency_ext.ptl_resiliency as res_module import torch -import yaml from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary from lightning.pytorch.loggers import TensorBoardLogger, WandbLogger from megatron.core.distributed import DistributedDataParallelConfig @@ -44,7 +42,7 @@ from nemo.lightning.pytorch.strategies.utils import RestoreConfig from nemo.utils.exp_manager import TimingCallback -from bionemo.evo2.utils.config import Evo2BlendedDatasetConfig +from bionemo.evo2.utils.config import parse_dataset_config from bionemo.llm.utils.datamodule_utils import infer_global_batch_size @@ -78,6 +76,13 @@ def parse_args(): action="store_true", help="Train with Mock data (for testing/debugging), either set this or provide a dataset config.", ) + + parser.add_argument( + "--dataset-dir", + type=str, + help="Absolute path to the dataset directory. Defaults to using the absolute or relative paths (dataset_prefix) specified in the dataset config YAML.", + ) + parser.add_argument("--num-nodes", type=int, default=1, help="Number of nodes to use for training, defaults to 1.") parser.add_argument("--devices", type=int, default=1, help="Number of devices to use for training, defaults to 1.") parser.add_argument("--seq-length", type=int, default=8192, help="Training sequence length") @@ -154,7 +159,10 @@ def parse_args(): help="Add bias to the output layer to enable learning a simple prior.", ) parser.add_argument( - "--experiment-dir", type=str, default=None, help="Directory to write model checkpoints and results to." + "--experiment-dir", + type=str, + required=True, + help="Directory to write model checkpoints and results to.", ) parser.add_argument( "--limit-val-batches", @@ -162,6 +170,13 @@ def parse_args(): default=20, help="Number of validation steps", ) + parser.add_argument( + "--log-every-n-steps", + type=int, + default=1, + required=False, + help="Number of steps between logging. Default is 50.", + ) parser.add_argument( "--ckpt-dir", type=str, @@ -298,47 +313,26 @@ def parse_args(): type=int, help="If set, override the default value set in the config.", ) + parser.add_argument( + "--disable-checkpointing", + action="store_false", + default=True, + dest="create_checkpoint_callback", + help="Disable creating a ModelCheckpoint callback.", + ) parser.add_argument( "--clip-grad", type=float, default=1.0, help="Grad clip value. Note that when using DDP this may need to be inflated.", ) + recompute_group = parser.add_mutually_exclusive_group(required=False) recompute_group.add_argument("--no-activation-checkpointing", action="store_true", default=False) recompute_group.add_argument("--selective-activation-checkpointing", action="store_true", default=False) return parser.parse_args() -def parse_dataset_config(dataset_config_path: str): - """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena. - - Args: - dataset_config_path (str): Path to the dataset configuration YAML file. - - Returns: - defaultdict: A dictionary where keys are dataset splits and values are lists containing the normalized weight - and dataset prefix for each split. - """ - blended_dataset_config = defaultdict(list) - weight_sums = defaultdict(float) - with open(dataset_config_path, "r") as config_file: - dataset_config_batch = yaml.safe_load(config_file) - for dataset_config in dataset_config_batch: - # Validate. - config_model = Evo2BlendedDatasetConfig(**dataset_config) - # Integrate the weights for renormalization. - weight_sums[config_model.dataset_split] += abs(config_model.dataset_weight) - for dataset_config in dataset_config_batch: - # Validate. - config_model = Evo2BlendedDatasetConfig(**dataset_config) - # Add indexed dataset to split and associate with blended training weight. - blended_dataset_config[config_model.dataset_split].extend( - [config_model.dataset_weight / weight_sums[config_model.dataset_split], config_model.dataset_prefix] - ) - return blended_dataset_config - - def main(): """Main function to run Evo2 training.""" args = parse_args() @@ -371,7 +365,7 @@ def main(): tokenizer=tokenizer, ) else: - blended_dataset_config = parse_dataset_config(args.dataset_config) + blended_dataset_config = parse_dataset_config(args.dataset_config, args.dataset_path) dataset_cls = Evo2DatasetPadEodLossMask if args.eod_pad_in_loss_mask else Evo2Dataset # Instantiate pre-training module. data = PreTrainingDataModule( @@ -430,20 +424,22 @@ def main(): model = llm.GPTModel(evo2_config, tokenizer=data.tokenizer) # Setup callbacks. - checkpoint_callback = ModelCheckpoint( - every_n_train_steps=args.val_check_interval, - dirpath=args.experiment_dir, - save_top_k=5, - always_save_context=True, - save_optim_on_train_end=True, - save_context_on_train_end=True, - ) callbacks = [ - checkpoint_callback, RichModelSummary(max_depth=4), LearningRateMonitor(), TimingCallback(), ] + if args.create_checkpoint_callback: + checkpoint_callback = ModelCheckpoint( + every_n_train_steps=args.val_check_interval, + dirpath=args.experiment_dir, + save_top_k=5, + always_save_context=True, + save_optim_on_train_end=True, + save_context_on_train_end=True, + ) + callbacks.append(checkpoint_callback) + if args.enable_preemption: callbacks.append(nl_callbacks.PreemptionCallback()) if args.debug_ddp_parity_freq > 0: @@ -580,7 +576,7 @@ def main(): strategy=strategy, logger=loggers, callbacks=callbacks, - log_every_n_steps=1, + log_every_n_steps=args.log_every_n_steps, limit_val_batches=args.limit_val_batches, num_sanity_val_steps=0, use_distributed_sampler=False, @@ -597,6 +593,7 @@ def main(): ), # faster and less accurate when set to True, and MUST be True if using TP communication overlap ), val_check_interval=args.val_check_interval, + enable_checkpointing=args.create_checkpoint_callback, ) # Logger setup diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index ead023a37c..f6d63a1015 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -14,19 +14,57 @@ # limitations under the License. +from collections import defaultdict from pathlib import Path -from typing import Literal +from typing import Literal, Optional -from pydantic import BaseModel +import yaml +from pydantic import BaseModel, model_validator class Evo2BlendedDatasetConfig(BaseModel): - """Pydantic model class that specifies indexed datasets, dataset weights, and datasplits assignments for training.""" + """Configuration for blended dataset specifications. - dataset_prefix: None | str = None - dataset_weight: None | float = None + Validates and constructs dataset paths, weights and splits configuration. + Ensures dataset paths exist and are properly resolved relative to base data path. + + Attributes: + dataset_path: Base directory path for datasets. Used to resolve relative dataset prefixes. + dataset_prefix: Path prefix for dataset files. Can be absolute or relative to dataset_path. + dataset_weight: Weight factor for this dataset during blending (0-1). + dataset_split: Dataset partition - 'train', 'validation' or 'test'. + + Raises: + ValueError: If dataset path doesn't exist or prefix can't be resolved. + """ + + dataset_path: str | None = None + dataset_prefix: str + dataset_weight: float dataset_split: Literal["train", "validation", "test"] + @model_validator(mode="before") + @classmethod + def validate_dataset_prefix(cls, values: dict) -> dict: + """Ensure dataset_prefix paths exist and are properly resolved or are relative to base dataset_path if provided.""" + dataset_path = Path(values.get("dataset_path")) if values.get("dataset_path") else None + prefix = Path(values.get("dataset_prefix")) + + if not prefix.is_absolute(): + if dataset_path: + prefix = dataset_path / prefix + else: + prefix = Path(prefix).resolve() + parent = prefix.parent + stem = prefix.stem + if not parent.exists(): + raise ValueError(f"dataset_prefix parent path does not exist: {parent}") + matching_files = list(parent.glob(f"{stem}.*")) + if not matching_files: + raise ValueError(f"dataset_prefix file does not exist: {prefix}") + values["dataset_prefix"] = str(prefix) + return values + class Evo2TaxonomyLineage(BaseModel): """Pydantic model class that defines the source lineage of a DNA sequence.""" @@ -96,3 +134,33 @@ class Evo2PreprocessingConfig(BaseModel): taxonomy_data: dict[str, Evo2TaxonomyLineage] = {} # Periodicity of injecting phylogenetic lineage tags in the sequence prior to tokenization. prompt_spacer_length: int = 131072 + + +def parse_dataset_config(dataset_config_path: str, dataset_path: Optional[str] = None): + """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena. + + Args: + dataset_config_path (str): Path to the dataset configuration YAML file. + dataset_path (str): Path to the dataset directory. Defaults to None. + + Returns: + defaultdict: A dictionary where keys are dataset splits and values are lists containing the normalized weight + and dataset prefix for each split. + """ + blended_dataset_config = defaultdict(list) + weight_sums = defaultdict(float) + with open(dataset_config_path, "r") as config_file: + dataset_config_batch = yaml.safe_load(config_file) + for dataset_config in dataset_config_batch: + # Validate. + config_model = Evo2BlendedDatasetConfig(dataset_path=dataset_path, **dataset_config) + # Integrate the weights for renormalization. + weight_sums[config_model.dataset_split] += abs(config_model.dataset_weight) + for dataset_config in dataset_config_batch: + # Validate. + config_model = Evo2BlendedDatasetConfig(dataset_path=dataset_path, **dataset_config) + # Add indexed dataset to split and associate with blended training weight. + blended_dataset_config[config_model.dataset_split].extend( + [config_model.dataset_weight / weight_sums[config_model.dataset_split], config_model.dataset_prefix] + ) + return blended_dataset_config diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..70d052773dea483ca7b95058d0e03f56d0d59513 100644 GIT binary patch literal 2404 zcmZY8Taw!_3`Eh{no1wqfcL+a+|!gNm5OAOARdhdKt0d>+}HKopPu{k-1mKb?)!5k z+?hPAdvDrnubsJ{KnNV49Ixy8e4fN7lvK|(DHS32e$OCt`1Ct=$piYX;(`T`B}(@r zvb}se+dCAm205yP_Y@Lyf6ytET`KM=G9%G4ig|Hf6)(G}oIGE;3jf^W6%oa?#!~JP zXaNxP=}mwfvZk9Q_Bs~K49Tam0|UE%ln?a*B?=*rs=(Ln)CcV^5C*wdt2~yxmt9#i z9xiOP`#_6N7E~i%UDYm}!Gy<om*X&uMFAt(Vp`Y}Liiy^jC|U-b+f0_NugY>#zXo| zM~JP77d-=l(-|EB`>ZxJoFx0&n(~aRAW9wN+q(Q2qy{Q-={O%bz_iXUDCgA{L_vCj zL;u|)Tx!P*Z=M%)9Cb!}P%LiWMODLW>y@u6dR+RjeieW<C|^|1bdb}qbD_ccQhbOf za@@}yP~I8M+{4ZH&9mLrKW8;-`Eu<W@i~e(l%?yp+DF&;@km20uIQwMJbj33aIG<6 zc}vx=npXDNOW{>%4>Iyq359GTA(+O`f~7Q?a>iI+zW+M9^Co9z>WNHeZ&0WV4tfVb zx->vdIt|OIe&T=DGOVKLD6%y5?a0M+I8-*1Pz{581gE7w=Jej8MUIdVrKu#HjsjTx zam>)k4NVYb8YeGZr4DrU>vkEFbB3SyCNt*c!5z-IfNc$L)hPb7eLW3Blh--2)^%Y( zPagIe1Z9q{L#sPb(Icgc8hqxzkfj*6`6(d%IJjW24JQoX(cfw@b`+{UuQ^c7r4UnA z@z+q`zp|4GptdNe^?80$>A#MxhhWB75gGnp!JL+4Ydl{kL)zrisN%&_MvAaj1*(Rl zNs-af7RLA}K;ut}Na=|ivSG~6pg;>B?pc6n!|Kq8Z=O})EZz1}xDV^yfJ$>h-;3tt zh8d?zh|YVd^qZ2yOUg8=?p(_({LzE5tGO%NshpkdA*i$sG<?xv5A;3ATp?}6aZ5je zfls<OZ>LjDdd#tGU!Hmk<gDddS%_>(8l1FyVU3E`oz$jW3M67$!+SKJ`RwGKQ89>f InUwbP2Wvf@AOHXW literal 0 HcmV?d00001 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx index 5896b07cd8488e90ac5ea44bde70bb0343065dc5..6a89174c8be4dbda5db6e7ca51aced27619abd52 100644 GIT binary patch literal 122 zcmebE^>p!ciC|!0WPkuh7AS)iN=Gs=Fd$>7Fjx%4-UQXa%?^`+&@cmm+QEPsO2f<t E0Iz!lu>b%7 literal 42 acmebE^>p!ciC|!0WPkt|4HtllGXMZkIRX#> diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin index 15221e3374a5209e145f93fd06cc68d85403c48b..f57e3de9febbe90166c835efe9785e34f9dc3fae 100644 GIT binary patch delta 17 ZcmccTctUma3856u&0>6;ST<~80RTmt2KoR1 literal 8414 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 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx index f40faa5af120aecc73a3268d559e8932ed8e97ce..d9e68ce0d9e0c2dc57483e6d75339fedd58d5e34 100644 GIT binary patch delta 41 ncmX@abc#{h*Vog<(<Op|fsp|M7&)K}&WY0M6Qdj^p7H<ym#hbC literal 322 zcmebE^>p!ciC|!0WPkuhJ}849N=Gs=Fpz_x+QE83>`g2X5pH$}ox%yB_i{sMF{s7) z0ucTQAqcG~3ZbjSA@pTQ2(2Rnp<Cr3G>n9K1n6uqV209A>ls*~d^RWzbq)guln-?l T0~eGJbshr`l+O#LVc`S-Gd&Ih diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin index 9dd51c243e4c32344704ce9ab61dbfa093bb47cf..a9df9953b9dd06d2ca22bb1fbba3a400543cd049 100644 GIT binary patch literal 2404 zcmYk+(UI#&3`5aL&E*dz;QV9RdqDfudSt1aO#&b&&-;0O-mmxTd4FE-&&R#M^Dg$Z zeYSpHMZfV9T9wfC?)j_!h<rZ5b-gOR?eJb8JL_9KfB*;6LG`E#boe|e+4>U1N{)v> z>g1JSJ!nq}?ZN@E$8#|}?fWW`gl|BJ(dE!0eRVlrqoPluA{ylC5<-7Gj7d*fEhI4K zXhtq$5GPb>IjmGtMG2?RE?6wFsd{$rnXxEXBff}qB3!|l5$tlq7`22VCi8njh`HMP z&fznrc==gqYQ!;tFE~@xHa!7Tez&$1a*kNT0joE+%n*FP|L#Fm6^`Ls%(1e7kXyB$ z?j|HFFt%xBGqVUmzc~67Kiy#a7S~Ri+9&Ux)JI=>kwDgOLHb<*N-#utA=Ch|-w3gi z%S~0;(r?{?9p!q2Jt3vDBsAj$Y+h_t=!U{>851EmK^4Tsq_Wg_C7Cc=__4tz>-=2Z zs=qWPqR}t%+fX9bt%5N39GWiLX1j#1I(qSQ7|^YYD(}R+Hn6oLqskpnAKHvDvT<&! z<?1&f37vTd43s2Vx2B;f{Nhtr+EthHN2Btp-Pv~S#pU&BMjboLwR^LMf7~RvFt?c6 z(CeXVCyNe2Pu@rW==?TJVivH$&mowI2!Sw`-2<aaB?~8h>uupp=|RI-vS);<vKLc@ zo5KzqdU3lC^YT)3_4;L;UGI-@x4xqiyqG@WksMs24apSr)Coh)gRSMYC1yej@iiH@ zcMpaq6#>(Tnm#dvV{5<-iofUUsMA>dTtxK$Lk<nN8%gs>SAA(~57wz4%VrHPc&sb8 z>>^_ThSi4z=%wxCmTmqp4R`RjTry?Zc5Y#e&_%K|%SgG_8ly0Za;L9Tgd9RU{wp8B z6jzYrL~yZ?S9wy&rpZVK8%_|0qGc{}x@*Tj|IMJR4*4JCK4p!lP}&ro6V*mJ3G6<R zTAG7?a`L)HY5D!3x44<$3VKY-)TSR;aNXtqJJyTOf!@LIH5rr8oZRrfBH(FNRb>7+ zd_JGAGwfU}MgN%U+1nPR%B1km*zTR!)W=q&*ZmtE45f==>QB4cndv5TZ?Ld&RO?+X K(S1L;zyAPUYN0>? literal 1202 zcmZ9K+id_r2m{j^;)4e0zn09HJt>M#w@<K*+1Z)tE{Cq|+1+9B{+`Odz3!gb*)HSq z70aEPW)vq=H`(k>SVFgiFOa)9xe*4KJa<*l6kJ)8!{(&0W|vs81Od<?)OT$RAK7L` zkSTnrf-~|WB>5Kz6+7xhY7&Whyq-~NKvO>vq$`qO@gvEyR1S~Y#bLVL;+54{yvAUW zyPLT~zH7o=u}rG|!I4HJR(Y5Pjb1)cx~ReSjE0yJifBum1#lh>ACJueLvZA0bV!$w zK=syOfJX@-#V$+nUEKAb(HkoemBE4-XMPldKpoRBj&N7SIveHxM`5_tmU#CC*`#zH z46Ar}mcaoisY0puP6(pK6vN;pdMv=#eH4fa3E_%1A9dPHIOIw`Q<Gv5c_uO9<B3Xe ziA`%m;d_X80fOdI5g>v)U$$I6Lgk=Si}c$=1D+_mL3Q^mxiMaOqU34PVo)$djLaY? zgGp%d%?3N5ZzD6#F_C8&=UI4R3}=s*-BrW6%2mlsfH}VOH^P;&6oPko1E`Jbz6dli eMG(|>845+96vNH1M+mstb@ocJ8~2zj?dKPz1W<Ya diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx index 2cfb8caa9a3fe9e62315775aa8c954a2dd200b45..6a89174c8be4dbda5db6e7ca51aced27619abd52 100644 GIT binary patch literal 122 zcmebE^>p!ciC|!0WPkuh7AS)iN=Gs=Fd$>7Fjx%4-UQXa%?^`+&@cmm+QEPsO2f<t E0Iz!lu>b%7 literal 82 ncmebE^>p!ciC|!0WPkuhCMbg$N=E_(Ko|y)*&s2PMwk)+&({Me diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index cf42ef77ca..23166c86af 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -23,7 +23,12 @@ @pytest.fixture -def preprocessing_config(tmp_path: Path) -> Evo2PreprocessingConfig: +def output_prefix() -> str: + return "test_promoters_uint8_distinct" + + +@pytest.fixture +def preprocessing_config(tmp_path: Path, output_prefix: str) -> Evo2PreprocessingConfig: """Creates a preprocessing configuration with test settings.""" # grab dir where test located test_dir = Path(__file__).parent @@ -32,8 +37,10 @@ def preprocessing_config(tmp_path: Path) -> Evo2PreprocessingConfig: config_dict = { "datapaths": [str(test_dir / "test_datasets" / "mmseqs_results_rep_seq_distinct_sample_sequences.fasta")], "output_dir": str(tmp_path), - "output_prefix": "test_promoters_uint8_distinct", - "train_split": 1.0, + "output_prefix": output_prefix, + "train_split": 0.6, + "validation_split": 0.2, + "test_split": 0.2, "overwrite": True, "embed_reverse_complement": True, "random_reverse_complement": 0.0, @@ -73,12 +80,17 @@ def test_preprocessor_creates_expected_files( preprocessor.preprocess_offline(preprocessing_config) # Check that all expected files exist + output_dir = Path(preprocessing_config.output_dir) + prefix = preprocessing_config.output_prefix expected_files = [ - "test_promoters_uint8_distinct_byte-level_train.bin", - "test_promoters_uint8_distinct_byte-level_train.idx", + output_dir / Path(prefix + "_byte-level_" + split + suffix) + for suffix in [".bin", ".idx"] + for split in ["train", "val", "test"] ] - - for filename in expected_files: - file_path = Path(preprocessing_config.output_dir) / filename + for file_path in expected_files: assert file_path.exists(), f"Expected file {file_path} was not created" assert file_path.stat().st_size > 0, f"File {file_path} is empty" + + # Check that no unexpected files were created + all_files = [f for f in output_dir.iterdir() if f.is_file()] + assert set(all_files) == set(expected_files), "Unexpected files were created" diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py new file mode 100644 index 0000000000..341766d9a5 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py @@ -0,0 +1,183 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import os +import tempfile +from collections import defaultdict +from contextlib import contextmanager +from pathlib import Path +from typing import Union + +import pytest +import yaml + +from bionemo.evo2.utils.config import Evo2BlendedDatasetConfig, parse_dataset_config + + +@contextmanager +def change_dir(new_dir: Union[str, Path]): + """ + Context manager for temporarily changing the working directory using os. + + Args: + new_dir (Union[str, Path]): The directory to change to + + Yields: + str: The new working directory path + + Example: + with change_dir('/path/to/dir'): + # Do some work in the new directory + ... + # Original directory is restored + """ + prev_dir = os.getcwd() + new_dir = os.path.expanduser(str(new_dir)) + try: + os.chdir(new_dir) + yield new_dir + finally: + os.chdir(prev_dir) + + +@pytest.fixture +def temp_dataset_config(): + # Create a temporary directory for the dataset path + temp_dir = tempfile.TemporaryDirectory() + dataset_path = temp_dir.name + + # Create a temporary YAML file for the dataset configuration + temp_yaml = tempfile.NamedTemporaryFile(delete=False, suffix=".yaml") + dataset_config_path = temp_yaml.name + + # Define dataset configuration content + dataset_config_content = [ + {"dataset_prefix": "dataset1", "dataset_weight": 0.5, "dataset_split": "train"}, + {"dataset_prefix": "dataset2", "dataset_weight": 0.5, "dataset_split": "train"}, + {"dataset_prefix": "dataset1", "dataset_weight": 0.6, "dataset_split": "validation"}, + {"dataset_prefix": "dataset2", "dataset_weight": 0.6, "dataset_split": "validation"}, + {"dataset_prefix": "dataset2", "dataset_weight": 0.2, "dataset_split": "test"}, + ] + + # Write the dataset configuration content to the YAML file + with open(dataset_config_path, "w") as yaml_file: + yaml.dump(dataset_config_content, yaml_file) + + # Create dummy dataset files in the temporary directory + for dataset in dataset_config_content: + dataset_file = Path(dataset_path) / f"{dataset['dataset_prefix']}.txt" + dataset_file.touch() + + yield dataset_config_path, dataset_path + + # Clean up temporary files and directories + temp_yaml.close() + os.remove(dataset_config_path) + temp_dir.cleanup() + + +@pytest.fixture +def tmp_dataset(tmp_path): + """Create temporary dataset files for testing.""" + dataset_dir = tmp_path / "data" + dataset_dir.mkdir() + (dataset_dir / "dataset.bin").touch() + return dataset_dir + + +def test_valid_absolute_path(tmp_dataset): + """Test configuration with valid absolute path.""" + config = Evo2BlendedDatasetConfig( + dataset_prefix=str(tmp_dataset / "dataset"), dataset_weight=0.5, dataset_split="train" + ) + assert config.dataset_prefix == str(tmp_dataset / "dataset") + assert config.dataset_weight == 0.5 + assert config.dataset_split == "train" + + +def test_valid_relative_path(tmp_dataset): + """Test configuration with valid relative path and base data path.""" + config = Evo2BlendedDatasetConfig( + dataset_path=str(tmp_dataset), dataset_prefix="dataset", dataset_weight=0.5, dataset_split="validation" + ) + assert config.dataset_prefix == str(tmp_dataset / "dataset") + + +def test_invalid_relative_path_without_base(): + """Test relative path fails without base data path.""" + with pytest.raises(ValueError, match=f"dataset_prefix file does not exist: {Path('dataset').resolve()}"): + Evo2BlendedDatasetConfig(dataset_prefix="dataset", dataset_weight=0.5, dataset_split="train") + + +def test_valid_relative_path_without_base(tmp_dataset: Path): + """Test relative path in current workdir does not fail without base data path.""" + # changing temporary cwd since Path(dataset_prefix).resolve() will resolve relative paths to the current working directory + with change_dir(tmp_dataset): + Evo2BlendedDatasetConfig(dataset_prefix="dataset", dataset_weight=0.5, dataset_split="train") + + +def test_nonexistent_parent_path(tmp_path): + """Test configuration fails with nonexistent parent directory.""" + invalid_path = tmp_path / "nonexistent" / "dataset" + with pytest.raises(ValueError, match="parent path does not exist"): + Evo2BlendedDatasetConfig(dataset_prefix=str(invalid_path), dataset_weight=0.5, dataset_split="train") + + +def test_nonexistent_dataset_file(tmp_dataset): + """Test configuration fails with nonexistent dataset file.""" + invalid_path = tmp_dataset / "nonexistent_dataset" + with pytest.raises(ValueError, match="dataset_prefix file does not exist"): + Evo2BlendedDatasetConfig(dataset_prefix=str(invalid_path), dataset_weight=0.5, dataset_split="train") + + +def test_path_resolution(tmp_dataset): + """Test proper path resolution with different input formats.""" + relative_path = Path("dataset") + absolute_path = tmp_dataset / "dataset" + + config1 = Evo2BlendedDatasetConfig( + dataset_path=str(tmp_dataset), dataset_prefix=str(relative_path), dataset_weight=0.5, dataset_split="train" + ) + # changing temporary cwd since Path(dataset_prefix).resolve() will resolve relative paths to the current working directory + with change_dir(tmp_dataset): + config2 = Evo2BlendedDatasetConfig( + dataset_prefix=str(absolute_path), dataset_weight=0.5, dataset_split="train" + ) + + assert config1.dataset_prefix == config2.dataset_prefix + + +def test_parse_dataset_config(temp_dataset_config): + dataset_config_path, dataset_path = temp_dataset_config + + # Call the function to test + result = parse_dataset_config(dataset_config_path, dataset_path) + + print(result) + # Define the expected result + expected_result = defaultdict( + list, + { + "train": [0.5, str(Path(dataset_path) / "dataset1"), 0.5, str(Path(dataset_path) / "dataset2")], + "validation": [0.5, str(Path(dataset_path) / "dataset1"), 0.5, str(Path(dataset_path) / "dataset2")], + "test": [ + 1.0, + str(Path(dataset_path) / "dataset2"), + ], + }, + ) + + # Assert the result matches the expected result + assert result == expected_result From 3d1e19e3fc197a8a72ae840e42f897a64de6ae5a Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska <dorotat@nvidia.com> Date: Thu, 13 Feb 2025 11:03:26 -0800 Subject: [PATCH 054/140] Remove sample data from evo2-dev branch --- .../src/bionemo/core/data/resources/evo2.yaml | 9 +++++++++ ...ults_rep_seq_distinct_sample_sequences.fasta | 16 ---------------- ...promoters_uint8_distinct_byte-level_test.bin | Bin 2404 -> 0 bytes ...promoters_uint8_distinct_byte-level_test.idx | Bin 122 -> 0 bytes ...romoters_uint8_distinct_byte-level_train.bin | Bin 4808 -> 0 bytes ...romoters_uint8_distinct_byte-level_train.idx | Bin 202 -> 0 bytes ..._promoters_uint8_distinct_byte-level_val.bin | Bin 2404 -> 0 bytes ..._promoters_uint8_distinct_byte-level_val.idx | Bin 122 -> 0 bytes .../tests/bionemo/evo2/data/test_preprocess.py | 15 +++++++++------ 9 files changed, 18 insertions(+), 22 deletions(-) delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index b9a04679ec..ba6377ea8e 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -21,3 +21,12 @@ TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT ATAATTTTAATTTATATAAT + +- tag: sample-data-raw:1.0 + ngc: null + ngc_registry: resource + pbss: "s3://bionemo-ci/test_data/evo2/mmseqs_results_rep_seq_distinct_sample_sequences.fasta" + sha256: 9938a2234496366e57c136958e697550bb608ddf1427ba080eb51d1d331a744f # pragma: allowlist secret + owner: John St John <jstjohn@nvidia.com> + description: > + Sample data for Evo2 preprocessing required by training. diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta deleted file mode 100644 index 6820948285..0000000000 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/mmseqs_results_rep_seq_distinct_sample_sequences.fasta +++ /dev/null @@ -1,16 +0,0 @@ ->FP010138_142154 FP010138 GRMZM2G113244_1 :+U EU:NC; range -499 to 100. -GTGGGCCAGGCCCATCGTTTGCATGCATGCACGATTGCACGCCCCCGGTGTCAATCGCGCGCAAATTGAGCTTGGGGCTTGGGCCTGCTGGCCCCTATCTACAGGAGTTCACCTTCACCTATGTTTAGGAATGTAGATACGAATGTATATTACTCGTTTTATATTTGTTTCTATAGTTTCTTTTCAAATTTATATTATATATAAATATTATTGAGTTGTGTGGCATGTTAAGTATCTAAGTTTAAATATATGAGTCGTCTGATATTTAATTACTCGGTCTCGGATATAGATTGTGAATCAGATCTGTTGATTTGTACAGTAGAGTGACGACTGACGAGTGACGTCCGAATGCTACGGGCAGCATGCCAGCATCCGCAACAGCGAGCAACCAGACGAGCTTGATCCCATCCCAGCCGTCCACGTACCCTTCGGATACACCGCTGAGGCGGTTGATGGGCACTGTTCCCTTGTCTTTGCCGAAACAGCGAGGCTTCCTCCCAATTCCAATCCAAGCCCCAACTAACGACCTCCGCCCATTCCGCTCGCGGTTGCCTCCGCCTCCGCCTCCGCCTCCGCGCCTAACCCAATCCAGAGCCAGGG ->FP010794_111285 FP010794 AT3G14130_1 :+U EU:NC; range -499 to 100. -AAAGTTACAAAGGTAAGAATAATCAAAGGATTCAAAAAAAGGGTTTAAAAACACACAAAAACACTTAAAAAAGATGACATTATATAATATAACTACCGGGCTTTCTATTCTCTGACGACGACGATACACATTAGAGGCTTCCCCGTGATTCGTCGCGGAACATAGGCATGACCATTGAGTAATTGGTCGTTGCCATTTTTATAGACATATATGTTCTGAGGTAAAAATTTGCAACTTTTCAAGAAACGCTTCGGTCTCTGAGACTGAGCATTGGTGTCAGAAGAGAAGAAATAAAAGCTCCCGTTGGAAAATGGCTCTCTGAAATGATGATGACTCGGTACGCCACGTCCTCATTGAGTTGAATAGTCAACGTTTACTGTGGGCAAAGACTCTAGACGACTTAGAGGGTTAGCAGGTGTTTTGTCGTTTTCTGTCTTGGTCTCCGACAGGACCGACTCTGTTCTCGTGTTCTTTTTTCCCTGTCATTTCCAGATTTCATAAAGCTAAAAGATATCTAATTTCTTTGTTTACCAGAGACTTAAACTGGTTTCTGTATCTTTTACTGGGTTCTTTCAGATATGTAAGTACTTCTAAAATCAA ->FP003588_9147 FP003588 Wipf3_1 :+U EU:NC; range -499 to 100. -GGCGCAAGCTTTTCTGCCCATCCTACCCCCGCCCCCAGCTCTCTCCACCCACACACCCACCGCCGCCTTTCAAGCCCAGGTCTAAATTGGGTGTACAGGGATGTACTGGATGTCTTCTTGGCTCTGTATTATATGTACCTGCTCATGCTCATGGGGACAACAGGCTGTCCCGTTCTCCCTTTGTCCCTTTGCTTATAGCGCTGTAGCAGGCTTAGCGAGGGCTCCGAAATGTTTGTAATATATAGATGAGGTGGCGTGCAGGGGAACTCCAGCCCTTGGCTCCATTGTCCCCTTGGCTCACACTCGGGACTCTGTACCTGGGAGCTGCGCTGCGCAGCCAGGACCGCCTCCTGGGTGCCAGAGCCACCCCGCCCTCTGGGTCGCGTCCCGGGGAGCCGGGCGGCGAGGCTCCAGGACGGCCGCCAGGAGCAGGTGGGGGCGGCGGCTCCGCCTCCGCGTCCCGGCAGCGCCTAAGCCCAGCCGGGAGAGCTTGGAGCGCAGAGCCCAGCTCAGCCAGGCGCGCAGAAGCAACGCCAGGCACTGCCGGCAGATCAACTGGGATCCTCGAGGCGGCAAGAGGACAGGGACAGCGGGGACCGC ->FP001999_32042 FP001999 ZNF800_1 :+U EU:NC; range -499 to 100. -CAAGAAAAAAGTAAGTTCAACTTTTGCCATTTAGCAATGCACTGACAGCCTTTTGGGGATCATCACTACTTACGGCTCATACATCTGCTCACCGCTTCCTAAGCCCTCTCCTAACCCTCCCCGAGTTTCAGTTCCACTGTACAGAGAACGCCGAGAGCAACAGTTTGGTGGCGGAGCAACCCGTCTCCGTGGGCGCGCACGCCGCACCGCAGACCTCACACCTCACCCTGGGCTTCGGCTCTCGGTCGGCCCGAAACTCCGGCCGCGGCCCTGGTGTCCCCTGCCCCGGTTCCCTCCCCTTGGACACGGCCCTCGCGCCCGCGGACCCGGTCGCCTCCCCATCCGCCGCAGCGGGTACAGCGCGTCGCCTCCCCAACAAGCGGGGGCGCCGACCGGGCGCATGCGCGCGGCGCTCCCGGGCGTGCCGGCCACACTCCCCCCACCCACTCGGTGAGCTTGTCACTTCCTGCCCTCGCCCCATCTCCGTCCGGGGTCAGTCAGTCGCTCCCTGTCGCTGCCGGAGAGTCTCTGCTTCCCCCTTCCTACGCGCTCCGCGGCGGTAGCTCGGGCTCTCCGGAGGAGGGAACGACAGAGAAAAAG ->FP004409_149038 FP004409 CASQ2_1 :+U EU:NC; range -499 to 100. -GAAAGGCAGGTGCAGAACATAAAGTTCACCTCGGGGGCTGCACTTGGTTCGTGTGTGAGCAGTGAGGAGGTAGGGGACAAGCAGCCCACCAGGAGGGGACAGGCTGGATTCTCTCCCTATAGTAATTGAATGAATCCGAGGTCTGGGTGGCCCTGTGTCTGTGCACACATCTCCACTGGCTGTTCCACCACTGTCCCACCTCTCTCCCGTCTCATCTTCTCTTCCTCCTTTTTGAGCTTATTTCTCTTTCTTGACCTTGCTGGCCTCCTTATTTCTCATGCACACGTTCTCCGCTTTCCTTCCTACCTCCTCCCTTTCCACCACTCTGGCCGACTGTATCAGCGAATCCCTCAACAGTGTCATATCTAACTTTTTTATTCATTGCATGATTTATTTTTAGCCTGAAACAACTGCATCCTAAAAATGGAGTTCCTGATGAGACAGGGGCTGGGCCGAGCTATGCGAGGTATCTGGGGCTGGGCCGCCCAGCCTGGCCCTCAGTCTCCGCTCGCGTGTGTCCTGAGCCCACGCGCACTGCTAGGCGGAGCCCAGGCGGCGGTGGACAGTCGGTCCCCGGGCCCAGGAGGGACACAGGAGAGG ->FP007746_105660 FP007746 Mad1l1_1 :+U EU:NC; range -499 to 100. -TCCCAGGACTTCTCATTCACAAAAGAAAGAAAGTGAAACAAGCTAACCAATCAAAACAGTGCCCAAACAAAACAACCTGTGTATACAAAGTGGCAAGATTCAGAGGCAACGCAACTTTCCAAAACTTTGTTCCCTTTCCGAGCGTGCCCAGCAGTTGTGCGGCAAGCCTTTAATTCCAGGGAGGCAGAGGCAGGCACGGGTGGATCTTTGTGAGTTCGAGGCTACACAGAGAAACATTGTCTCAAAAACAAAAACAAACAAACCTTTCCTCCTGCGCGGTGCTATTCCATACATTACGGCGCACCCCGGGGCAGTGGAAGAGCGCCCTGCGGGACAGGCAGCCGGGCCCAGTTTGGTTCCGGGTCCCCTGGCGGGACTGCGGTTTGTTCTCAGGCTACGCCCGTGGAGCACATATTTAATTCTTTACGGGCCGTTTTCTCAGATCTCGCGAGACCCCGGCGGAAGTCTCGCGATATATAGACACCGGCGGAGAGGAGGGAGATCTGAGCGGCTGCTGCAGCACCGGGCTCCTCAACTGAGGTAAGGGACCCGGTGGCGGGATCTGCGAGCGCCCCAGGCGCCTCGCGCCCTGCCCGACCG ->FP005252_170005 FP005252 CG17193_1 :+U EU:NT; range -499 to 100. -CGATCACAGCTACTTCTACATCGCCACGTTCGTCGCCGAACACATCGCCTACCATGCCGCCCTGCTCACAGCTTCCGCTTGATGATATTCCGCTTGTACATAATCGTTGGTTTCCACCGAAACCATAATTCAACGTAAATTTGGCAGTAAATAAACCAATTTCGACTGAGCTTCTAAAATGTATTCTTACATTCTTGACTTTAAACTTTGAACTTGGACTTTGAAAAACAAATATTTTTATTCATTCTAGGTGCCAATGTACAGAAGATTATACACAAATGGCGTGTACTTTGTTATTTCGGTTTTAAGTTCAGCAATTTCCTTTCACAAACAAAAACTTAAGTAATGGGTATTCAGCATTCGTCGAATTCCTAAGGACTTTTTCCCGGACTTGTGGTAAGGGTAAAAGCTCGCAACGTAGTAAAAGCTTTCCGGTTGTTGGTCCACGGCATGCTGGAAACTTTCCGCATCCTGGCATCCTGCGTACGATTCATTCATCAGTAGAAAAAACGCCGTCTGATGGAATAGATGTGCTAGTGACAGAGGGAACCGAACCGAACGGAGGTACCAAAAGGCGACATTCTCGACTCGTTTGGCGCC ->FP004145_60966 FP004145 Sprr2b_1 :+U EU:NC; range -499 to 100. -CCCCATGGCTTACTGAGGGGGGCACTTGGTATCTTTTGTTTCTCTTCTTTCTAACAAACTTGTAAATGTGTGAGGAAAATACCCCTCCACTTCTGAAAAAGGAAAGTGTAAATGGCTTTACACACTAGCAACGAACTAAGGATGAACTAAAGAGGTTCAAATAATGGAAAACCTTGAATTTAAGACAAATAGAGGCTGTCATGAAAAAAGGCTTATGCTTCCAGTCAAGAAAGAGATGTATCAAACAGTTGGAAAAGCTCCAAGTACCACAATTACTGGAAGCAAGAAGAAAGAAAAGGACTCTTGAGTCACAAGACTCAACCTAGTAATGATAGCCATGGGTGGGATATTTCCTATTTTGTAGAGTCCCTGTCCAGCCAGTTACGGATGAATTTGCATTTGTGTTAGGAAATTCCAGGACCAGCCCATTACAGGGAGATCCACTTCCCACTGGGTGAGGCAGGCAATCCTATAAAAAAGAGTCTCAGTGCTTGACTGCAGTATTCCTGGTACTCAAGCATTGGTCTGCTCCGGAGAACCTGGTGAGTCTGATTTCTTGAGTTCTTGAGAGGGTCTGCTCTTTTTGGTACTGTCATGAGC diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.bin deleted file mode 100644 index 70d052773dea483ca7b95058d0e03f56d0d59513..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2404 zcmZY8Taw!_3`Eh{no1wqfcL+a+|!gNm5OAOARdhdKt0d>+}HKopPu{k-1mKb?)!5k z+?hPAdvDrnubsJ{KnNV49Ixy8e4fN7lvK|(DHS32e$OCt`1Ct=$piYX;(`T`B}(@r zvb}se+dCAm205yP_Y@Lyf6ytET`KM=G9%G4ig|Hf6)(G}oIGE;3jf^W6%oa?#!~JP zXaNxP=}mwfvZk9Q_Bs~K49Tam0|UE%ln?a*B?=*rs=(Ln)CcV^5C*wdt2~yxmt9#i z9xiOP`#_6N7E~i%UDYm}!Gy<om*X&uMFAt(Vp`Y}Liiy^jC|U-b+f0_NugY>#zXo| zM~JP77d-=l(-|EB`>ZxJoFx0&n(~aRAW9wN+q(Q2qy{Q-={O%bz_iXUDCgA{L_vCj zL;u|)Tx!P*Z=M%)9Cb!}P%LiWMODLW>y@u6dR+RjeieW<C|^|1bdb}qbD_ccQhbOf za@@}yP~I8M+{4ZH&9mLrKW8;-`Eu<W@i~e(l%?yp+DF&;@km20uIQwMJbj33aIG<6 zc}vx=npXDNOW{>%4>Iyq359GTA(+O`f~7Q?a>iI+zW+M9^Co9z>WNHeZ&0WV4tfVb zx->vdIt|OIe&T=DGOVKLD6%y5?a0M+I8-*1Pz{581gE7w=Jej8MUIdVrKu#HjsjTx zam>)k4NVYb8YeGZr4DrU>vkEFbB3SyCNt*c!5z-IfNc$L)hPb7eLW3Blh--2)^%Y( zPagIe1Z9q{L#sPb(Icgc8hqxzkfj*6`6(d%IJjW24JQoX(cfw@b`+{UuQ^c7r4UnA z@z+q`zp|4GptdNe^?80$>A#MxhhWB75gGnp!JL+4Ydl{kL)zrisN%&_MvAaj1*(Rl zNs-af7RLA}K;ut}Na=|ivSG~6pg;>B?pc6n!|Kq8Z=O})EZz1}xDV^yfJ$>h-;3tt zh8d?zh|YVd^qZ2yOUg8=?p(_({LzE5tGO%NshpkdA*i$sG<?xv5A;3ATp?}6aZ5je zfls<OZ>LjDdd#tGU!Hmk<gDddS%_>(8l1FyVU3E`oz$jW3M67$!+SKJ`RwGKQ89>f InUwbP2Wvf@AOHXW diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test.idx deleted file mode 100644 index 6a89174c8be4dbda5db6e7ca51aced27619abd52..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 122 zcmebE^>p!ciC|!0WPkuh7AS)iN=Gs=Fd$>7Fjx%4-UQXa%?^`+&@cmm+QEPsO2f<t E0Iz!lu>b%7 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.bin deleted file mode 100644 index f57e3de9febbe90166c835efe9785e34f9dc3fae..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4808 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 S2$8$)#z0j(<M}Q3_45z$n?T_J diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_train.idx deleted file mode 100644 index d9e68ce0d9e0c2dc57483e6d75339fedd58d5e34..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 202 zcmebE^>p!ciC|!0WPkuh4k&{YN=Gs=FyO;bWneWR_9hmH2sb-~PJtS<mm9(t<Ac!o f0uUNT!W;m!4h)!~G}Jf-Rw$nhN<)ojfVmd{l^zHe diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.bin deleted file mode 100644 index a9df9953b9dd06d2ca22bb1fbba3a400543cd049..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2404 zcmYk+(UI#&3`5aL&E*dz;QV9RdqDfudSt1aO#&b&&-;0O-mmxTd4FE-&&R#M^Dg$Z zeYSpHMZfV9T9wfC?)j_!h<rZ5b-gOR?eJb8JL_9KfB*;6LG`E#boe|e+4>U1N{)v> z>g1JSJ!nq}?ZN@E$8#|}?fWW`gl|BJ(dE!0eRVlrqoPluA{ylC5<-7Gj7d*fEhI4K zXhtq$5GPb>IjmGtMG2?RE?6wFsd{$rnXxEXBff}qB3!|l5$tlq7`22VCi8njh`HMP z&fznrc==gqYQ!;tFE~@xHa!7Tez&$1a*kNT0joE+%n*FP|L#Fm6^`Ls%(1e7kXyB$ z?j|HFFt%xBGqVUmzc~67Kiy#a7S~Ri+9&Ux)JI=>kwDgOLHb<*N-#utA=Ch|-w3gi z%S~0;(r?{?9p!q2Jt3vDBsAj$Y+h_t=!U{>851EmK^4Tsq_Wg_C7Cc=__4tz>-=2Z zs=qWPqR}t%+fX9bt%5N39GWiLX1j#1I(qSQ7|^YYD(}R+Hn6oLqskpnAKHvDvT<&! z<?1&f37vTd43s2Vx2B;f{Nhtr+EthHN2Btp-Pv~S#pU&BMjboLwR^LMf7~RvFt?c6 z(CeXVCyNe2Pu@rW==?TJVivH$&mowI2!Sw`-2<aaB?~8h>uupp=|RI-vS);<vKLc@ zo5KzqdU3lC^YT)3_4;L;UGI-@x4xqiyqG@WksMs24apSr)Coh)gRSMYC1yej@iiH@ zcMpaq6#>(Tnm#dvV{5<-iofUUsMA>dTtxK$Lk<nN8%gs>SAA(~57wz4%VrHPc&sb8 z>>^_ThSi4z=%wxCmTmqp4R`RjTry?Zc5Y#e&_%K|%SgG_8ly0Za;L9Tgd9RU{wp8B z6jzYrL~yZ?S9wy&rpZVK8%_|0qGc{}x@*Tj|IMJR4*4JCK4p!lP}&ro6V*mJ3G6<R zTAG7?a`L)HY5D!3x44<$3VKY-)TSR;aNXtqJJyTOf!@LIH5rr8oZRrfBH(FNRb>7+ zd_JGAGwfU}MgN%U+1nPR%B1km*zTR!)W=q&*ZmtE45f==>QB4cndv5TZ?Ld&RO?+X K(S1L;zyAPUYN0>? diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val.idx deleted file mode 100644 index 6a89174c8be4dbda5db6e7ca51aced27619abd52..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 122 zcmebE^>p!ciC|!0WPkuh7AS)iN=Gs=Fd$>7Fjx%4-UQXa%?^`+&@cmm+QEPsO2f<t E0Iz!lu>b%7 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index 23166c86af..7649eded2d 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -18,24 +18,27 @@ import pytest +from bionemo.core.data.load import load from bionemo.evo2.data.preprocess import Evo2Preprocessor from bionemo.evo2.utils.config import Evo2PreprocessingConfig +@pytest.fixture +def sample_data_path() -> Path: + data_path = load("evo2/sample-data-raw:1.0") / "mmseqs_results_rep_seq_distinct_sample_sequences.fasta" + return data_path + + @pytest.fixture def output_prefix() -> str: return "test_promoters_uint8_distinct" @pytest.fixture -def preprocessing_config(tmp_path: Path, output_prefix: str) -> Evo2PreprocessingConfig: +def preprocessing_config(tmp_path: Path, output_prefix: str, sample_data_path: Path) -> Evo2PreprocessingConfig: """Creates a preprocessing configuration with test settings.""" - # grab dir where test located - test_dir = Path(__file__).parent - - # TODO (dorotat) move mmseqs_results_rep_seq_distinct_sample_sequences.fasta to PBSS and use load(...) config_dict = { - "datapaths": [str(test_dir / "test_datasets" / "mmseqs_results_rep_seq_distinct_sample_sequences.fasta")], + "datapaths": [str(sample_data_path)], "output_dir": str(tmp_path), "output_prefix": output_prefix, "train_split": 0.6, From 9811ae447b04b41126e13b6c38e9a2768be20d9b Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska <dorotat@nvidia.com> Date: Thu, 13 Feb 2025 13:54:18 -0800 Subject: [PATCH 055/140] [BUGFIX] evo2-dev CI --- .../bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index 7649eded2d..28d819f5de 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -25,7 +25,8 @@ @pytest.fixture def sample_data_path() -> Path: - data_path = load("evo2/sample-data-raw:1.0") / "mmseqs_results_rep_seq_distinct_sample_sequences.fasta" + # TODO(@dorotat) replace source with ngc when artefacts are published + data_path = load("evo2/sample-data-raw:1.0", source="pbss") return data_path From f9133f5b355b3c61cb0f2d8d73bab475d19fe2dc Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Thu, 13 Feb 2025 18:01:03 -0800 Subject: [PATCH 056/140] Remove test_mask_phylogenetic tags (moving to nemo repo) --- .../evo2/test_mask_phylogenetic_tags.py | 570 ------------------ 1 file changed, 570 deletions(-) delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/test_mask_phylogenetic_tags.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_mask_phylogenetic_tags.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_mask_phylogenetic_tags.py deleted file mode 100644 index 001fccf403..0000000000 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_mask_phylogenetic_tags.py +++ /dev/null @@ -1,570 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - - -import pytest -import torch -from nemo.collections.llm.gpt.data.megatron.hyena import Evo2Dataset - - -@pytest.fixture -def tag_tokens(): - """Standard tokens for phylogenetic tag tests, defined in Evo2_DataseT: - - CONTROL_TAGS: ClassVar[list[int]] = [64, 35] # '@' tag for splice splits/windows, '#' for contig splits - TAG_BOUNDS = 124 # start and end delim: '|' - TAG_CHARS: ClassVar[set[int]] = {95, 59, 32} # chars only found in control tags: _, ;, space - DEFAULT_EOD = 0 - """ - return { - "terminal": 124, # | - "other_chars": {95, 59, 32}, # _, ;, space - "eod": 0, # end of document token - } - - -def test_mask_phylogenetic_tags_with_eod(tag_tokens): - """Tests handling of EOD tokens within tag context. - - Since we want to ensure the model only learns to output {A,C,G,T}, even EOD tokens - within a tag context should be masked to prevent the model from learning to - output non-DNA tokens. - - Example sequence: token | _ EOD | token - Expected masking: 1 0 0 0 0 1 - """ - sequence = torch.tensor([65, 124, 95, 0, 124, 65]) # token|_<EOD>|token - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], # | - other_tag_chars=tag_tokens["other_chars"], # _, ;, space - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor([1, 0, 0, 0, 0, 1]) - assert torch.equal(mask, expected_mask) - - -def test_mask_phylogenetic_tags_middle(tag_tokens): - """Tests masking a phylogenetic tag that appears in the middle of a DNA sequence. - - The sequence contains: - 1. Normal DNA (ATG) - 2. A phylo tag (|info_tag|) - 3. More DNA (TCGA) - - Expected behavior: The DNA should be unmasked (1s) while everything between - and including the pipe characters should be masked (0s), as it's a valid phylo tag. - """ - sequence = torch.tensor( - [ - 65, - 84, - 71, # ATG - 124, - 105, - 110, - 102, - 111, - 95, - 116, - 97, - 103, - 124, # |info_tag| - 84, - 67, - 71, - 65, # TCGA - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], # | - other_tag_chars=tag_tokens["other_chars"], # _, ;, space - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor( - [ - 1, - 1, - 1, # DNA unmasked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, # phylo tag masked - 1, - 1, - 1, - 1, # DNA unmasked - ] - ) - assert torch.equal(mask, expected_mask) - - -def test_mask_partial_tag_start(tag_tokens): - """Tests handling a sequence that starts with a partial phylogenetic tag. - - The sequence starts with characters that would be inside a phylo tag, - followed by a closing pipe and DNA. Since we want to prevent the model from - learning non-DNA outputs, we mask all potential tag characters even without - complete tag delimiters. - - Sequence: "tag;_|ATG" (starting mid-tag) - Expected: All tag characters and delimiters masked, only DNA unmasked - """ - sequence = torch.tensor( - [ - 116, - 97, - 103, - 59, - 95, # tag;_ - 124, # | - 65, - 84, - 71, # ATG - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor( - [ - 0, - 0, - 0, - 0, - 0, # partial tag start masked - 0, # closing pipe masked - 1, - 1, - 1, # DNA unmasked - ] - ) - assert torch.equal(mask, expected_mask) - - -def test_mask_partial_tag_end(tag_tokens): - """Tests handling a sequence that ends with a partial phylogenetic tag. - - The sequence contains DNA followed by an opening pipe and tag characters, - but no closing pipe. Per requirements, we aggressively mask any potential - tag characters to ensure the model only learns DNA bases {A,C,G,T}. - - Sequence: "ATG|info_" (ending mid-tag) - Expected: DNA unmasked, all tag-related characters masked - """ - sequence = torch.tensor( - [ - 65, - 84, - 71, # ATG - 124, # | - 105, - 110, - 102, - 111, - 95, # info_ - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor( - [ - 1, - 1, - 1, # DNA unmasked - 0, # opening pipe masked - 0, - 0, - 0, - 0, - 0, # partial tag end masked - ] - ) - assert torch.equal(mask, expected_mask) - - -def test_standalone_tag(tag_tokens): - """Tests masking of a single complete tag with no surrounding sequence. - - Tests that a standalone tag (|tag_|) is fully masked since it contains - non-DNA characters. This ensures the model only learns to output - {A,C,G,T} tokens. - - Sequence: |tag_| - Expected: All tokens masked (all zeros) - """ - sequence = torch.tensor([124, 116, 97, 103, 95, 124]) # |tag_| - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - expected = torch.tensor([0, 0, 0, 0, 0, 0]) # All masked - assert torch.equal(mask, expected) - - -def test_sequence_starting_with_tag(tag_tokens): - """Tests sequence that begins with a complete tag followed by DNA. - - Verifies that when a sequence starts with a complete tag followed by - DNA bases, the tag portion is masked while the DNA portion remains - unmasked. - - Sequence: |tag_|ATG - Expected: Tag masked (zeros), DNA unmasked (ones) - """ - sequence = torch.tensor( - [ - 124, - 116, - 97, - 103, - 95, - 124, # |tag_| - 65, - 84, - 71, # ATG - ] - ) - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - expected = torch.tensor([0, 0, 0, 0, 0, 0, 1, 1, 1]) # Tag masked, DNA unmasked - assert torch.equal(mask, expected) - - -def test_sequence_ending_with_tag(tag_tokens): - """Tests sequence that ends with a complete tag. - - Verifies that when a sequence ends with a complete tag, the DNA portion - remains unmasked while the entire tag portion is masked. - - Sequence: ATG|tag_| - Expected: DNA unmasked (ones), tag masked (zeros) - """ - sequence = torch.tensor( - [ - 65, - 84, - 71, # ATG - 124, - 116, - 97, - 103, - 95, - 124, # |tag_| - ] - ) - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - expected = torch.tensor([1, 1, 1, 0, 0, 0, 0, 0, 0]) # DNA unmasked, tag masked - assert torch.equal(mask, expected) - - -def test_mask_multiple_tags(tag_tokens): - """Tests handling multiple phylogenetic tags in sequence, demonstrating state transitions. - - This tests how the masking switches states between phylo and non-phylo regions: - 1. Starts in non-phylo state with DNA - 2. Switches to phylo state at first pipe (with tag chars) - 3. Switches back to non-phylo at closing pipe - 4. Pattern repeats for second tag - - Sequence: "ATG|tag_1|CG|tag_2|AT" - Expected: Only DNA sequences should remain unmasked - """ - sequence = torch.tensor( - [ - 65, - 84, - 71, # ATG - 124, - 116, - 97, - 103, - 95, - 49, - 124, # |tag_1| - 67, - 71, # CG - 124, - 116, - 97, - 103, - 95, - 50, - 124, # |tag_2| - 65, - 84, # AT - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor( - [ - 1, - 1, - 1, # DNA unmasked - 0, - 0, - 0, - 0, - 0, - 0, - 0, # first tag masked - 1, - 1, # DNA unmasked - 0, - 0, - 0, - 0, - 0, - 0, - 0, # second tag masked - 1, - 1, # DNA unmasked - ] - ) - assert torch.equal(mask, expected_mask) - - -def test_mask_dna_after_pipe(tag_tokens): - """Tests the scenario where we have a pipe followed by DNA sequence. - - This tests the edge case of a pipe character appearing at the start of a sequence. - Even if DNA follows, we mask the pipe character to prevent the model from - learning to output non-DNA tokens. - - Sequence: "|ATG" (pipe followed by DNA) - Expected: Pipe masked, DNA unmasked - """ - sequence = torch.tensor( - [ - 124, # | - 65, - 84, - 71, # ATG - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor([0, 1, 1, 1]) # Pipe masked, DNA unmasked - assert torch.equal(mask, expected_mask) - - -def test_ambiguous_dna_char_followed_by_tag_start(tag_tokens): - """Tests handling of an ambiguous DNA character followed by a tag start. - - When we see a character that could be either DNA or the end of a truncated tag - followed by a pipe, we should mask both for safety since we can't disambiguate - whether the character was part of a tag. - - Sequence: "t|AAAT" (t could be DNA or end of tag) - Expected: First t and pipe masked (0), AAAT unmasked (1) - """ - sequence = torch.tensor( - [ - 116, # t (ambiguous - could be DNA or end of tag) - 124, # | - 65, # A - 65, # A - 65, # A - 84, # T - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor([0, 0, 1, 1, 1, 1]) # Ambiguous t and pipe masked, DNA unmasked - assert torch.equal(mask, expected_mask) - - -def test_dna_followed_by_unambiguous_tag_start(tag_tokens): - """Tests handling of DNA sequence followed by clear tag start. - - When we see DNA followed by |d, it's unambiguous - the d clearly indicates - the start of a phylogenetic tag (d__), so we can safely unmask the DNA and - mask the tag portion. - - Sequence: "AAAT|d" (AAAT is DNA, |d starts tag) - Expected: AAAT unmasked (1), |d masked (0) - """ - sequence = torch.tensor( - [ - 65, # A - 65, # A - 65, # A - 84, # T - 124, # | - 100, # d (clearly starts d__ tag) - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor([1, 1, 1, 1, 0, 0]) # DNA unmasked, tag start masked - assert torch.equal(mask, expected_mask) - - -def test_double_partial_tags_with_dna_middle(tag_tokens): - """Tests a sequence that has partial tags at both ends with DNA in the middle. - - Tests the specific case where a sequence slice cuts through phylogenetic tags - on both ends, with valid DNA sequence in the middle. The behavior we want is: - 1. The partial tag at the start should be masked - 2. The DNA in the middle should be unmasked - 3. The partial tag at the end should be masked - - Sequence: "cacata|acagataaaataTACAGGGAATA|d__" - Expected: First partial tag masked (0s), middle DNA unmasked (1s), end tag masked (0s) - """ - sequence = torch.tensor( - [ - 99, - 97, - 99, - 97, - 116, - 97, # cacata - 124, # | - 97, - 99, - 97, - 103, - 97, - 116, - 97, - 97, - 97, - 97, - 116, - 97, # acagataaaata - 84, - 65, - 67, - 65, - 71, - 71, - 71, - 65, - 65, - 84, - 65, # TACAGGGAATA - 124, # | - 100, - 95, - 95, # d__ - ] - ) - - mask = Evo2Dataset.mask_phylogenetic_tags( - tokenized_sequence=sequence, - terminal_tag_char=tag_tokens["terminal"], - other_tag_chars=tag_tokens["other_chars"], - eod_token_id=tag_tokens["eod"], - ) - - expected_mask = torch.tensor( - [ - 0, - 0, - 0, - 0, - 0, - 0, # partial start tag masked - 0, # pipe masked - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, # middle DNA unmasked - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, # middle DNA unmasked - 0, # pipe masked - 0, - 0, - 0, # partial end tag masked - ] - ) - - assert torch.equal(mask, expected_mask) From a175d5b9285d56c966feb8823faba93c74e71a5d Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 14 Feb 2025 15:19:31 -0800 Subject: [PATCH 057/140] Bump nemo to fix forward bug Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 03d5a439d8..b2a4e19e27 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 03d5a439d87801b60faf8e92a016ca81029dd655 +Subproject commit b2a4e19e27abe58f790210920a05d26302165f7a From ea70cdec3da6f925ece5d46089474c648229b9cf Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 14 Feb 2025 23:28:42 +0000 Subject: [PATCH 058/140] Add required changes to work with NeMo upstream Signed-off-by: John St John <jstjohn@nvidia.com> --- .../src/bionemo/core/data/resources/evo2.yaml | 9 ++- .../src/bionemo/evo2/run/infer.py | 7 ++ .../src/bionemo/evo2/run/train.py | 74 ++++++++++------- .../src/bionemo/evo2/utils/config.py | 80 +------------------ .../tests/bionemo/evo2/run/test_infer.py | 4 +- .../tests/bionemo/evo2/run/test_inference.py | 4 +- .../tests/bionemo/evo2/test_evo2.py | 2 +- 7 files changed, 65 insertions(+), 115 deletions(-) diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index ba6377ea8e..dd41df0962 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -1,11 +1,12 @@ -- tag: 7b-8k-zarr:1.0 +- tag: 7b-8k-zarr:1.1 ngc: null ngc_registry: model - pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_fix_shape.tar.gz" - sha256: 31261b3dce731e257f03b5f609306df1334cfc723a445cb3800c757a06263ebb # pragma: allowlist secret + pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_fix_shape_v2.tar.gz" + sha256: e08d89a1841a6aa3796c772ffe84092f20ac0a11d1b6ef7b1966ebbd8253e17e # pragma: allowlist secret owner: John St John <jstjohn@nvidia.com> description: > - A 7b parameter evo2 model used in testing, zarr format + A 7b parameter evo2 model used in testing, zarr format. 1.1 is the same as 1.0 but the HyenaModel class names have + been updated to match the current version of the code in the checkpoint metadata. - tag: 7b-8k-nofp8-te-goldvalue-testdata:1.0 ngc: null diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index b34c0106bf..9ee1ae3ff9 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -115,9 +115,16 @@ def infer( Returns: None """ + model_parallel_size = tensor_parallel_size * pipeline_model_parallel_size * context_parallel_size + if model_parallel_size > torch.cuda.device_count(): + raise ValueError( + f"Requested model parallel size {model_parallel_size} is greater than the " + f"number of available CUDA devices {torch.cuda.device_count()}" + ) # Create PTL trainer. trainer = nl.Trainer( accelerator="gpu", + devices=model_parallel_size, strategy=nl.MegatronStrategy( tensor_model_parallel_size=tensor_parallel_size, pipeline_model_parallel_size=pipeline_model_parallel_size, diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 899d86e71d..66f1dc534a 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -17,6 +17,7 @@ from dataclasses import asdict from typing import Type +# TODO add back support for slurm resilience. # import nvidia_resiliency_ext.ptl_resiliency as res_module import torch from lightning.pytorch.callbacks import LearningRateMonitor, RichModelSummary @@ -26,6 +27,7 @@ from nemo import lightning as nl from nemo.collections import llm from nemo.collections.llm.gpt.data import MockDataModule, PreTrainingDataModule +from nemo.collections.llm.gpt.data.megatron.hyena.config import parse_dataset_config from nemo.collections.llm.gpt.data.megatron.hyena.evo2_dataset import Evo2Dataset, Evo2DatasetPadEodLossMask from nemo.collections.llm.recipes.tp_overlap_configs.userbuffers import ( userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, @@ -42,7 +44,6 @@ from nemo.lightning.pytorch.strategies.utils import RestoreConfig from nemo.utils.exp_manager import TimingCallback -from bionemo.evo2.utils.config import parse_dataset_config from bionemo.llm.utils.datamodule_utils import infer_global_batch_size @@ -62,7 +63,10 @@ def parse_args(): """Parse arguments for Evo2 model training.""" - parser = argparse.ArgumentParser(description="Train a Hyena model using NeMo 2.0.") + parser = argparse.ArgumentParser( + description="Train a Hyena model using NeMo 2.0.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) data_group = parser.add_mutually_exclusive_group(required=True) data_group.add_argument( @@ -175,7 +179,7 @@ def parse_args(): type=int, default=1, required=False, - help="Number of steps between logging. Default is 50.", + help="Number of steps between logging.", ) parser.add_argument( "--ckpt-dir", @@ -196,7 +200,7 @@ def parse_args(): help="Avaerage optimizer state in collective rather than dividing by dp size and summing.", ) parser.add_argument("--seed", type=int, default=1234, help="Set random seed for training.") - parser.add_argument("--workers", type=int, default=0, help="Number of workers to use for data loading.") + parser.add_argument("--workers", type=int, default=8, help="Number of workers to use for data loading.") parser.add_argument( "--gc-interval", type=int, @@ -219,7 +223,8 @@ def parse_args(): type=str, choices=["torch_dist", "zarr"], default="torch_dist", - help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated.", + help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated. Only use if " + "resuming training from a zarr checkpoint.", ) parser.add_argument( "--eod-pad-in-loss-mask", @@ -326,7 +331,26 @@ def parse_args(): default=1.0, help="Grad clip value. Note that when using DDP this may need to be inflated.", ) - + parser.add_argument( + "--seq-len-interpolation-factor", + type=float, + help="Adjusts the linear scaling of ROPE (Rotary Position Embedding) for context extension. " + "Set this factor relative to your base context length e.g., for an original context length of 8192 and " + "an extended context length of 524288, use 524288/8192 = 64.", + ) + parser.add_argument( + "--overlap-param-gather", + action="store_true", + default=False, + help="Overlap the parameter gather with the optimizer step. This is currently disabled due to a NeMo bug " + "when using DDP. Making this an option defaulting to False is a temporary solution until the bug is fixed.", + ) + parser.add_argument( + "--overlap-grad-reduce", + action="store_true", + default=False, + help="Overlap the gradient reduce with the optimizer step.", + ) recompute_group = parser.add_mutually_exclusive_group(required=False) recompute_group.add_argument("--no-activation-checkpointing", action="store_true", default=False) recompute_group.add_argument("--selective-activation-checkpointing", action="store_true", default=False) @@ -421,7 +445,7 @@ def main(): evo2_config = model_options[args.model_size](**config_modifiers_init) # Instantiate model. - model = llm.GPTModel(evo2_config, tokenizer=data.tokenizer) + model = llm.HyenaModel(evo2_config, tokenizer=data.tokenizer) # Setup callbacks. callbacks = [ @@ -470,12 +494,15 @@ def main(): # ) # ) if args.use_megatron_comm_overlap_llama3_8k: + # Pick the floating point appropriate config. + if args.fp8: + tp_comm_overlap_cfg = userbuffers_fp8_h100_h8192_tp4_mbs1_seqlen8192 + else: + tp_comm_overlap_cfg = userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192 callbacks.append( MegatronCommOverlapCallback( tp_comm_overlap=evo2_config.tp_comm_overlap, - tp_comm_overlap_cfg=userbuffers_fp8_h100_h8192_tp4_mbs1_seqlen8192 - if args.fp8 - else userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, + tp_comm_overlap_cfg=tp_comm_overlap_cfg, tp_comm_bootstrap_backend=args.tp_comm_overlap_backend, wgrad_deferral_limit=22, # default from NeMo overlap_param_gather_with_optimizer_step=False, # Currently disabled due to an issue with checkpointing. @@ -519,7 +546,7 @@ def main(): f"-GCLP{args.clip_grad}" f"-LR{args.lr}-MINLR{args.min_lr}-WUSTEPS{args.warmup_steps}-WD{args.wd}" f"-GRFP32{args.grad_reduce_in_fp32}-FP8WG{args.fp8_wgrad and args.fp8}" - f"-ALIGN{not args.no_aligned_megatron_ddp}" + f"-OGR{args.overlap_grad_reduce}-OPG{args.overlap_param_gather}" f"-NODES{args.num_nodes}-FP8{args.fp8}" ), group=args.wandb_group, @@ -537,23 +564,14 @@ def main(): loggers.append(tb_logger) nemo_logger = NeMoLogger(log_dir=args.experiment_dir, **nemo_logger_kwargs) - if args.no_aligned_megatron_ddp: - ddp: str | DistributedDataParallelConfig = DistributedDataParallelConfig( - check_for_nan_in_grad=True, - grad_reduce_in_fp32=args.grad_reduce_in_fp32, - align_param_gather=args.align_param_gather, - average_in_collective=not args.no_average_in_collective, - ) - else: - ddp = DistributedDataParallelConfig( - check_for_nan_in_grad=True, - grad_reduce_in_fp32=args.grad_reduce_in_fp32, - overlap_grad_reduce=True, - overlap_param_gather=True, - average_in_collective=not args.no_average_in_collective, - align_param_gather=args.align_param_gather, - use_distributed_optimizer=True, # this should inherit from the optimizer config, but just in case... - ) + ddp: DistributedDataParallelConfig = DistributedDataParallelConfig( + check_for_nan_in_grad=True, + overlap_grad_reduce=args.overlap_grad_reduce, + overlap_param_gather=args.overlap_param_gather, # Verify that this works using + grad_reduce_in_fp32=args.grad_reduce_in_fp32, + align_param_gather=args.align_param_gather, + average_in_collective=not args.no_average_in_collective, + ) # Initialize Megatron Strategy and Trainer. strategy = nl.MegatronStrategy( ddp=ddp, diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index f6d63a1015..655bd69348 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -14,56 +14,10 @@ # limitations under the License. -from collections import defaultdict from pathlib import Path -from typing import Literal, Optional +from typing import Literal -import yaml -from pydantic import BaseModel, model_validator - - -class Evo2BlendedDatasetConfig(BaseModel): - """Configuration for blended dataset specifications. - - Validates and constructs dataset paths, weights and splits configuration. - Ensures dataset paths exist and are properly resolved relative to base data path. - - Attributes: - dataset_path: Base directory path for datasets. Used to resolve relative dataset prefixes. - dataset_prefix: Path prefix for dataset files. Can be absolute or relative to dataset_path. - dataset_weight: Weight factor for this dataset during blending (0-1). - dataset_split: Dataset partition - 'train', 'validation' or 'test'. - - Raises: - ValueError: If dataset path doesn't exist or prefix can't be resolved. - """ - - dataset_path: str | None = None - dataset_prefix: str - dataset_weight: float - dataset_split: Literal["train", "validation", "test"] - - @model_validator(mode="before") - @classmethod - def validate_dataset_prefix(cls, values: dict) -> dict: - """Ensure dataset_prefix paths exist and are properly resolved or are relative to base dataset_path if provided.""" - dataset_path = Path(values.get("dataset_path")) if values.get("dataset_path") else None - prefix = Path(values.get("dataset_prefix")) - - if not prefix.is_absolute(): - if dataset_path: - prefix = dataset_path / prefix - else: - prefix = Path(prefix).resolve() - parent = prefix.parent - stem = prefix.stem - if not parent.exists(): - raise ValueError(f"dataset_prefix parent path does not exist: {parent}") - matching_files = list(parent.glob(f"{stem}.*")) - if not matching_files: - raise ValueError(f"dataset_prefix file does not exist: {prefix}") - values["dataset_prefix"] = str(prefix) - return values +from pydantic import BaseModel class Evo2TaxonomyLineage(BaseModel): @@ -134,33 +88,3 @@ class Evo2PreprocessingConfig(BaseModel): taxonomy_data: dict[str, Evo2TaxonomyLineage] = {} # Periodicity of injecting phylogenetic lineage tags in the sequence prior to tokenization. prompt_spacer_length: int = 131072 - - -def parse_dataset_config(dataset_config_path: str, dataset_path: Optional[str] = None): - """Parse the blended training datasplit configuration and renormalize data split weights for training Hyena. - - Args: - dataset_config_path (str): Path to the dataset configuration YAML file. - dataset_path (str): Path to the dataset directory. Defaults to None. - - Returns: - defaultdict: A dictionary where keys are dataset splits and values are lists containing the normalized weight - and dataset prefix for each split. - """ - blended_dataset_config = defaultdict(list) - weight_sums = defaultdict(float) - with open(dataset_config_path, "r") as config_file: - dataset_config_batch = yaml.safe_load(config_file) - for dataset_config in dataset_config_batch: - # Validate. - config_model = Evo2BlendedDatasetConfig(dataset_path=dataset_path, **dataset_config) - # Integrate the weights for renormalization. - weight_sums[config_model.dataset_split] += abs(config_model.dataset_weight) - for dataset_config in dataset_config_batch: - # Validate. - config_model = Evo2BlendedDatasetConfig(dataset_path=dataset_path, **dataset_config) - # Add indexed dataset to split and associate with blended training weight. - blended_dataset_config[config_model.dataset_split].extend( - [config_model.dataset_weight / weight_sums[config_model.dataset_split], config_model.dataset_prefix] - ) - return blended_dataset_config diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index 33945e3b03..6b4f97f62d 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -32,7 +32,7 @@ def test_run_infer(): top_p = 0.0 max_new_tokens = 1 - # generation args: + # Generation args. default_prompt = ( "|d__Bacteria;" + "p__Pseudomonadota;" @@ -44,7 +44,7 @@ def test_run_infer(): ) # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") + checkpoint_path = load("evo2/7b-8k-zarr:1.1", source="pbss") with clean_parallel_state_context(): infer( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index 935b3acdf3..6f39246713 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -72,7 +72,7 @@ def test_infer_model_generates_expected_single_token_output(): top_p = 0.0 max_new_tokens = 1 # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") + checkpoint_path = load("evo2/7b-8k-zarr:1.1", source="pbss") with clean_parallel_state_context(): results = generate( @@ -135,7 +135,7 @@ def test_infer_model_generates_expected_single_token_output(): # top_k = 0 # top_p = 0.0 # max_new_tokens = 1 -# checkpoint_path = load("evo2/7b-8k-zarr:1.0", source="pbss") +# checkpoint_path = load("evo2/7b-8k-zarr:1.1", source="pbss") # gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") # gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8) # gold_standard_no_fp8_tensor = gold_standard_no_fp8_tensor[0, -1] diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index b6a25ba5ea..50c02b6b5b 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -65,7 +65,7 @@ def load_weights_sharded_inplace_nemo2_to_mcore( def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): try: # TODO (dorotat) remove PBSS source once the model is available on NGC - evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.0", source="pbss") / "weights" + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.1", source="pbss") / "weights" # TODO (dorotat) remove PBSS source once the model is available on NGC gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0", source="pbss") except ValueError as e: From dddf9a435fdf37c7b6f386a32dcf8bbb5d6aa84d Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 14 Feb 2025 15:39:50 -0800 Subject: [PATCH 059/140] Add back new context manager for parallel state cleanup Signed-off-by: John St John <jstjohn@nvidia.com> --- .../testing/megatron_parallel_state_utils.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py index 14bb635339..57cd9dba95 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/megatron_parallel_state_utils.py @@ -73,6 +73,19 @@ def clean_up_distributed_and_parallel_states(): torch.cuda.empty_cache() +@contextmanager +def clean_parallel_state_context(): + """Puts you into a clean parallel state, and again tears it down at the end.""" + try: + clean_up_distributed_and_parallel_states() + yield + except Exception as e: + # TODO (@skothenhill) verify this is a problem and that this is a solution. Had issues with keyboard interrupts being ignored inside context manager. + raise Exception from e + finally: + clean_up_distributed_and_parallel_states() + + @contextmanager def distributed_model_parallel_state( seed: int = 42, From e1929826cd52edd624feb8efa72d495075e1f8ef Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 14 Feb 2025 23:57:43 +0000 Subject: [PATCH 060/140] Move test_config into nemo where the code is Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- .../tests/bionemo/evo2/test_config.py | 183 ------------------ 2 files changed, 1 insertion(+), 184 deletions(-) delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py diff --git a/3rdparty/NeMo b/3rdparty/NeMo index b2a4e19e27..e1b8b20ef2 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit b2a4e19e27abe58f790210920a05d26302165f7a +Subproject commit e1b8b20ef279455d75696d410c055dab447dc8cd diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py deleted file mode 100644 index 341766d9a5..0000000000 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_config.py +++ /dev/null @@ -1,183 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - -import os -import tempfile -from collections import defaultdict -from contextlib import contextmanager -from pathlib import Path -from typing import Union - -import pytest -import yaml - -from bionemo.evo2.utils.config import Evo2BlendedDatasetConfig, parse_dataset_config - - -@contextmanager -def change_dir(new_dir: Union[str, Path]): - """ - Context manager for temporarily changing the working directory using os. - - Args: - new_dir (Union[str, Path]): The directory to change to - - Yields: - str: The new working directory path - - Example: - with change_dir('/path/to/dir'): - # Do some work in the new directory - ... - # Original directory is restored - """ - prev_dir = os.getcwd() - new_dir = os.path.expanduser(str(new_dir)) - try: - os.chdir(new_dir) - yield new_dir - finally: - os.chdir(prev_dir) - - -@pytest.fixture -def temp_dataset_config(): - # Create a temporary directory for the dataset path - temp_dir = tempfile.TemporaryDirectory() - dataset_path = temp_dir.name - - # Create a temporary YAML file for the dataset configuration - temp_yaml = tempfile.NamedTemporaryFile(delete=False, suffix=".yaml") - dataset_config_path = temp_yaml.name - - # Define dataset configuration content - dataset_config_content = [ - {"dataset_prefix": "dataset1", "dataset_weight": 0.5, "dataset_split": "train"}, - {"dataset_prefix": "dataset2", "dataset_weight": 0.5, "dataset_split": "train"}, - {"dataset_prefix": "dataset1", "dataset_weight": 0.6, "dataset_split": "validation"}, - {"dataset_prefix": "dataset2", "dataset_weight": 0.6, "dataset_split": "validation"}, - {"dataset_prefix": "dataset2", "dataset_weight": 0.2, "dataset_split": "test"}, - ] - - # Write the dataset configuration content to the YAML file - with open(dataset_config_path, "w") as yaml_file: - yaml.dump(dataset_config_content, yaml_file) - - # Create dummy dataset files in the temporary directory - for dataset in dataset_config_content: - dataset_file = Path(dataset_path) / f"{dataset['dataset_prefix']}.txt" - dataset_file.touch() - - yield dataset_config_path, dataset_path - - # Clean up temporary files and directories - temp_yaml.close() - os.remove(dataset_config_path) - temp_dir.cleanup() - - -@pytest.fixture -def tmp_dataset(tmp_path): - """Create temporary dataset files for testing.""" - dataset_dir = tmp_path / "data" - dataset_dir.mkdir() - (dataset_dir / "dataset.bin").touch() - return dataset_dir - - -def test_valid_absolute_path(tmp_dataset): - """Test configuration with valid absolute path.""" - config = Evo2BlendedDatasetConfig( - dataset_prefix=str(tmp_dataset / "dataset"), dataset_weight=0.5, dataset_split="train" - ) - assert config.dataset_prefix == str(tmp_dataset / "dataset") - assert config.dataset_weight == 0.5 - assert config.dataset_split == "train" - - -def test_valid_relative_path(tmp_dataset): - """Test configuration with valid relative path and base data path.""" - config = Evo2BlendedDatasetConfig( - dataset_path=str(tmp_dataset), dataset_prefix="dataset", dataset_weight=0.5, dataset_split="validation" - ) - assert config.dataset_prefix == str(tmp_dataset / "dataset") - - -def test_invalid_relative_path_without_base(): - """Test relative path fails without base data path.""" - with pytest.raises(ValueError, match=f"dataset_prefix file does not exist: {Path('dataset').resolve()}"): - Evo2BlendedDatasetConfig(dataset_prefix="dataset", dataset_weight=0.5, dataset_split="train") - - -def test_valid_relative_path_without_base(tmp_dataset: Path): - """Test relative path in current workdir does not fail without base data path.""" - # changing temporary cwd since Path(dataset_prefix).resolve() will resolve relative paths to the current working directory - with change_dir(tmp_dataset): - Evo2BlendedDatasetConfig(dataset_prefix="dataset", dataset_weight=0.5, dataset_split="train") - - -def test_nonexistent_parent_path(tmp_path): - """Test configuration fails with nonexistent parent directory.""" - invalid_path = tmp_path / "nonexistent" / "dataset" - with pytest.raises(ValueError, match="parent path does not exist"): - Evo2BlendedDatasetConfig(dataset_prefix=str(invalid_path), dataset_weight=0.5, dataset_split="train") - - -def test_nonexistent_dataset_file(tmp_dataset): - """Test configuration fails with nonexistent dataset file.""" - invalid_path = tmp_dataset / "nonexistent_dataset" - with pytest.raises(ValueError, match="dataset_prefix file does not exist"): - Evo2BlendedDatasetConfig(dataset_prefix=str(invalid_path), dataset_weight=0.5, dataset_split="train") - - -def test_path_resolution(tmp_dataset): - """Test proper path resolution with different input formats.""" - relative_path = Path("dataset") - absolute_path = tmp_dataset / "dataset" - - config1 = Evo2BlendedDatasetConfig( - dataset_path=str(tmp_dataset), dataset_prefix=str(relative_path), dataset_weight=0.5, dataset_split="train" - ) - # changing temporary cwd since Path(dataset_prefix).resolve() will resolve relative paths to the current working directory - with change_dir(tmp_dataset): - config2 = Evo2BlendedDatasetConfig( - dataset_prefix=str(absolute_path), dataset_weight=0.5, dataset_split="train" - ) - - assert config1.dataset_prefix == config2.dataset_prefix - - -def test_parse_dataset_config(temp_dataset_config): - dataset_config_path, dataset_path = temp_dataset_config - - # Call the function to test - result = parse_dataset_config(dataset_config_path, dataset_path) - - print(result) - # Define the expected result - expected_result = defaultdict( - list, - { - "train": [0.5, str(Path(dataset_path) / "dataset1"), 0.5, str(Path(dataset_path) / "dataset2")], - "validation": [0.5, str(Path(dataset_path) / "dataset1"), 0.5, str(Path(dataset_path) / "dataset2")], - "test": [ - 1.0, - str(Path(dataset_path) / "dataset2"), - ], - }, - ) - - # Assert the result matches the expected result - assert result == expected_result From d3557297fe3342623407ac3a2f37a9df160a2d25 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Sat, 15 Feb 2025 00:47:10 +0000 Subject: [PATCH 061/140] Fix arg name mismatch Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 66f1dc534a..90f11c4b23 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -389,7 +389,7 @@ def main(): tokenizer=tokenizer, ) else: - blended_dataset_config = parse_dataset_config(args.dataset_config, args.dataset_path) + blended_dataset_config = parse_dataset_config(args.dataset_config, args.dataset_dir) dataset_cls = Evo2DatasetPadEodLossMask if args.eod_pad_in_loss_mask else Evo2Dataset # Instantiate pre-training module. data = PreTrainingDataModule( From d90c10d167fb374b0da7ed7b424294ba48a0d1bb Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Fri, 14 Feb 2025 16:58:06 -0800 Subject: [PATCH 062/140] add new license Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- .../src/infra_bionemo/license_check.py | 65 +++++++++++++++++-- .../bionemo-evo2/src/bionemo/evo2/__init__.py | 5 +- .../src/bionemo/evo2/data/__init__.py | 7 +- .../src/bionemo/evo2/data/preprocess.py | 5 +- .../src/bionemo/evo2/data/tokenizer.py | 5 +- .../evo2/data/transcript_extraction.py | 5 +- .../src/bionemo/evo2/run/__init__.py | 5 +- .../src/bionemo/evo2/run/infer.py | 5 +- .../src/bionemo/evo2/run/train.py | 5 +- .../convert_checkpoint_model_parallel_evo2.py | 5 +- .../checkpoint/convert_zero3_to_zero1.py | 5 +- .../bionemo/evo2/utils/checkpoint/params.py | 5 +- .../evo2/utils/checkpoint/torch2nemo.py | 5 +- .../utils/checkpoint/zero3_conversion_lib.py | 5 +- .../src/bionemo/evo2/utils/config.py | 5 +- .../bionemo/evo2/data/test_preprocess.py | 5 +- .../tests/bionemo/evo2/data/test_tokenizer.py | 5 +- .../tests/bionemo/evo2/run/test_infer.py | 5 +- .../tests/bionemo/evo2/run/test_inference.py | 5 +- .../tests/bionemo/evo2/run/test_train.py | 5 +- .../tests/bionemo/evo2/test_evo2.py | 5 +- .../bionemo/evo2/test_hyena_operators.py | 5 +- 22 files changed, 146 insertions(+), 26 deletions(-) diff --git a/internal/infra-bionemo/src/infra_bionemo/license_check.py b/internal/infra-bionemo/src/infra_bionemo/license_check.py index 32f30d4790..cac3b1116b 100644 --- a/internal/infra-bionemo/src/infra_bionemo/license_check.py +++ b/internal/infra-bionemo/src/infra_bionemo/license_check.py @@ -44,8 +44,10 @@ "main", ) -LICENSE_HEADER: str = """ -# SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +NVIDIA_COPYRIGHT: str = ( + "# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved." +) +APACHE_BLOCK: str = """ # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -61,6 +63,9 @@ # limitations under the License. """.strip() +# default header (split to allow for intermediate copyright headers) +LICENSE_HEADER = f"{NVIDIA_COPYRIGHT}\n{APACHE_BLOCK}" + @dataclass(frozen=True) class HeaderNotFound(ValueError): @@ -134,8 +139,60 @@ def is_valid_python(pyfile_contents: str) -> Optional[SyntaxError]: def has_header(pyfile_contents: str, *, license_header: str = LICENSE_HEADER) -> bool: - """True if the :param:`pyfile_contents` starts with the :param:`license_header`. False otherwise.""" - return pyfile_contents.startswith(license_header) + """Check if file has valid license header. + + First checks if file has multiple copyright lines - if so, validates structure only. + If not, and custom license_header provided, does exact string match. + Otherwise validates basic structure. + """ + lines = pyfile_contents.split("\n") + + # Count copyright lines at start of file + copyright_count = 0 + for line in lines: + if line.strip().startswith("# SPDX-FileCopyrightText: Copyright"): + copyright_count += 1 + else: + break + + # If file has multiple copyrights, only validate structure + if copyright_count > 1: + # Must start with NVIDIA copyright + if not lines or not lines[0].strip() == NVIDIA_COPYRIGHT: + return False + + # Find where Apache block starts + apache_start = None + for i, line in enumerate(lines): + if line.strip().startswith("# SPDX-License-Identifier: LicenseRef-Apache2"): + apache_start = i + break + + if apache_start is None: + return False + + # All lines between NVIDIA copyright and Apache block must be valid SPDX copyright lines + for line in lines[1:apache_start]: + if line.strip() and not line.strip().startswith("# SPDX-FileCopyrightText: Copyright"): + return False + + # Check Apache block matches exactly + apache_lines = APACHE_BLOCK.split("\n") + if len(lines[apache_start:]) < len(apache_lines): + return False + + for actual, expected in zip(lines[apache_start : apache_start + len(apache_lines)], apache_lines): + if actual.strip() != expected.strip(): + return False + + return True + + # Otherwise, if custom header provided, use exact match + if license_header != LICENSE_HEADER: + return pyfile_contents.startswith(license_header) + + # Otherwise do basic structure validation + return lines[0].strip() == NVIDIA_COPYRIGHT and pyfile_contents.startswith(LICENSE_HEADER) def append_license_header(pyfile_contents: str, *, license_header: str = LICENSE_HEADER, n_sep_lines: int = 2) -> str: diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py index 25e6abfbc5..d3887f06e4 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py index 25e6abfbc5..2a87ab7d69 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -11,4 +14,4 @@ # 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. +# limitations under the License. \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index 442c2a76c5..cd85e5d959 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py index 85b4f1dbe1..270e9e6a9b 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py index d2c897f240..80641c9a0b 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py index 25e6abfbc5..d3887f06e4 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 9ee1ae3ff9..4106892cf7 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 90f11c4b23..58dfb85a54 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py index 46c4558ce7..90e557289d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py index 3eab8ecad9..81750023f0 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py index 709ce0e5b4..fd2780b6a5 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py index d92e2ac8be..8e2bccbcdf 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py index ce2bd74103..45595892f7 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index 655bd69348..0aacbd7c44 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index 28d819f5de..af6c8b6d46 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py index 8270829701..40ada040d8 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index 6b4f97f62d..b316323ee4 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index 6f39246713..0c8c235283 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py index cfe84ac335..89979ab501 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index 50c02b6b5b..7498d43ef7 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py index f633effdda..89aec295c0 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py @@ -1,4 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); From a8432a2bfdbd331a1e171c5d2748b923fa1f14f5 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Fri, 14 Feb 2025 17:00:37 -0800 Subject: [PATCH 063/140] remove tab from license Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py | 8 ++++---- .../bionemo-evo2/src/bionemo/evo2/data/__init__.py | 10 +++++----- .../bionemo-evo2/src/bionemo/evo2/data/preprocess.py | 8 ++++---- .../bionemo-evo2/src/bionemo/evo2/data/tokenizer.py | 8 ++++---- .../src/bionemo/evo2/data/transcript_extraction.py | 8 ++++---- .../bionemo-evo2/src/bionemo/evo2/run/__init__.py | 8 ++++---- .../bionemo-evo2/src/bionemo/evo2/run/infer.py | 8 ++++---- .../bionemo-evo2/src/bionemo/evo2/run/train.py | 8 ++++---- .../convert_checkpoint_model_parallel_evo2.py | 8 ++++---- .../evo2/utils/checkpoint/convert_zero3_to_zero1.py | 8 ++++---- .../src/bionemo/evo2/utils/checkpoint/params.py | 8 ++++---- .../src/bionemo/evo2/utils/checkpoint/torch2nemo.py | 8 ++++---- .../evo2/utils/checkpoint/zero3_conversion_lib.py | 8 ++++---- .../bionemo-evo2/src/bionemo/evo2/utils/config.py | 8 ++++---- .../tests/bionemo/evo2/data/test_preprocess.py | 8 ++++---- .../tests/bionemo/evo2/data/test_tokenizer.py | 8 ++++---- .../bionemo-evo2/tests/bionemo/evo2/run/test_infer.py | 8 ++++---- .../tests/bionemo/evo2/run/test_inference.py | 8 ++++---- .../bionemo-evo2/tests/bionemo/evo2/run/test_train.py | 8 ++++---- .../bionemo-evo2/tests/bionemo/evo2/test_evo2.py | 8 ++++---- .../tests/bionemo/evo2/test_hyena_operators.py | 8 ++++---- 21 files changed, 85 insertions(+), 85 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py index d3887f06e4..9981337fda 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/__init__.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py index 2a87ab7d69..9981337fda 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/__init__.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,4 +14,4 @@ # 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. \ No newline at end of file +# limitations under the License. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index cd85e5d959..f31bb77222 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py index 270e9e6a9b..380c1a91f6 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/tokenizer.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py index 80641c9a0b..0676e2abe7 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/transcript_extraction.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py index d3887f06e4..9981337fda 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/__init__.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 4106892cf7..9391044aea 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 58dfb85a54..a1227b48a1 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py index 90e557289d..7edb5d76c6 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py index 81750023f0..f6060f6d0f 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_zero3_to_zero1.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py index fd2780b6a5..818fde3f3d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/params.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py index 8e2bccbcdf..8ff1eb8c99 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py index 45595892f7..f776c16f8f 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/zero3_conversion_lib.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index 0aacbd7c44..8dd0b1c1ba 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index af6c8b6d46..da3ed32a7c 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py index 40ada040d8..dc0742862d 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_tokenizer.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index b316323ee4..20c5c75a75 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index 0c8c235283..8989af84d5 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py index 89979ab501..6c1e9223f5 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index 7498d43ef7..828385e976 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py index 89aec295c0..71f237b885 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py @@ -1,7 +1,7 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved # SPDX-License-Identifier: LicenseRef-Apache2 # # Licensed under the Apache License, Version 2.0 (the "License"); From 4f2ade56a181f1e9db7723cd123f714926a8df6a Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Sat, 15 Feb 2025 01:21:51 +0000 Subject: [PATCH 064/140] Bump nemo to fix bug in dataset --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index e1b8b20ef2..c0c4bbd43d 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit e1b8b20ef279455d75696d410c055dab447dc8cd +Subproject commit c0c4bbd43d4dec22f3f8205cb357e5050dd718aa From 396550292dacd2a6ebd74251e7aa598459c6f11a Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 17:36:57 +0000 Subject: [PATCH 065/140] Bump NeMo commit for perf improved loss mask Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index c0c4bbd43d..733a79d57f 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit c0c4bbd43d4dec22f3f8205cb357e5050dd718aa +Subproject commit 733a79d57f3384285ca9208ffe9bff9532416524 From f09aa363918b87bd6a2aee2bc6ed6ba490031c8b Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 17:59:22 +0000 Subject: [PATCH 066/140] Adding options for controlling dropout to train.py Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/src/bionemo/evo2/run/train.py | 16 ++++++++++++++++ .../tests/bionemo/evo2/run/test_train.py | 2 +- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index a1227b48a1..76073d7eef 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -354,6 +354,18 @@ def parse_args(): default=False, help="Overlap the gradient reduce with the optimizer step.", ) + parser.add_argument( + "--hidden-dropout", + type=float, + default=0.0, + help="Dropout probability for the hyena layers", + ) + parser.add_argument( + "--attention-dropout", + type=float, + default=0.0, + help="Dropout probability for the attention layers.", + ) recompute_group = parser.add_mutually_exclusive_group(required=False) recompute_group.add_argument("--no-activation-checkpointing", action="store_true", default=False) recompute_group.add_argument("--selective-activation-checkpointing", action="store_true", default=False) @@ -431,6 +443,8 @@ def main(): config_modifiers_init = { "tp_comm_overlap": args.use_megatron_comm_overlap_llama3_8k, "seq_length": args.seq_length, + "hidden_dropout": args.hidden_dropout, + "attention_dropout": args.attention_dropout, "to_upper": "weighted" if args.no_renormalize_loss else "normalized_weighted", "distribute_saved_activations": False if args.sequence_parallel else True, "cross_entropy_loss_fusion": args.cross_entropy_loss_fusion, @@ -547,6 +561,8 @@ def main(): f"-PEOD{args.eod_pad_in_loss_mask}" f"-BO{args.add_bias_output}" f"-GCLP{args.clip_grad}" + f"-HDO{args.hidden_dropout}" + f"-ADO{args.attention_dropout}" f"-LR{args.lr}-MINLR{args.min_lr}-WUSTEPS{args.warmup_steps}-WD{args.wd}" f"-GRFP32{args.grad_reduce_in_fp32}-FP8WG{args.fp8_wgrad and args.fp8}" f"-OGR{args.overlap_grad_reduce}-OPG{args.overlap_param_gather}" diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py index 6c1e9223f5..08c6be8d3b 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py @@ -43,7 +43,7 @@ def test_train_evo2_runs(tmp_path, num_steps=5): "--model-size 7b_nv --num-layers 4 --hybrid-override-pattern SDH* " "--no-activation-checkpointing --add-bias-output " f"--max-steps {num_steps} --warmup-steps 1 --no-wandb " - "--seq-length 128 " + "--seq-length 128 --hidden-dropout 0.1 --attention-dropout 0.1 " ) # Run the command in a subshell, using the temporary directory as the current working directory. From 955978d8460808b6246ba4203abdb8aa8bb7a53a Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 19:11:24 +0000 Subject: [PATCH 067/140] Bump nemo and remove nograd decorator Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 733a79d57f..3bed043457 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 733a79d57f3384285ca9208ffe9bff9532416524 +Subproject commit 3bed0434575a3a04b78602947f15997e0c0a5465 From 3e14262d1e1b8f7b7c2bdb1a03a79bdc54177892 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 20:04:56 +0000 Subject: [PATCH 068/140] Bump nemo with latest tag masking --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 3bed043457..e085f87f92 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 3bed0434575a3a04b78602947f15997e0c0a5465 +Subproject commit e085f87f92bc09311d4ae5d78c62306282190e23 From 46baa5fceb2772525324800323376c1a2ce3ca91 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 20:15:46 +0000 Subject: [PATCH 069/140] Cover non-DNA case due to bug in preprocessing, never have non-dna unmasked in loss other than pad/eod Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index e085f87f92..a32ac160e4 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit e085f87f92bc09311d4ae5d78c62306282190e23 +Subproject commit a32ac160e4d71035a91f67267e09b748b3d90e47 From ef3f55e76c341c5787a96d0da737a68bab4b9946 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 20:56:50 +0000 Subject: [PATCH 070/140] Try reverting some of the recent fixes related to TP Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index a32ac160e4..79997b2b77 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit a32ac160e4d71035a91f67267e09b748b3d90e47 +Subproject commit 79997b2b771919ee3f65a50e330c6c921b5b7e0c From af9016e5b4d1f264e7550891cfba1f824f8dad74 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 22:34:50 +0000 Subject: [PATCH 071/140] Bump nemo version with better tested --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 79997b2b77..33d8957e1f 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 79997b2b771919ee3f65a50e330c6c921b5b7e0c +Subproject commit 33d8957e1f44a6d57f201b2a3739efba6635cf38 From aafb7a30028599bf738d284bc398ba40a04cc9ba Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 22:53:05 +0000 Subject: [PATCH 072/140] Revert loss mask updates --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 33d8957e1f..c28efaf546 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 33d8957e1f44a6d57f201b2a3739efba6635cf38 +Subproject commit c28efaf546cc278dcee77a1e64c356d413a23026 From a966b8b397ce23c51783e870e37749016b2e5883 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 18 Feb 2025 23:34:26 +0000 Subject: [PATCH 073/140] handle 0 token case more gracefully --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index c28efaf546..9816ff15b4 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit c28efaf546cc278dcee77a1e64c356d413a23026 +Subproject commit 9816ff15b48662b189691287f856598e3dfc2932 From c4ef1f1b627688dba90eab05b26f660c44841063 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 19 Feb 2025 00:46:04 +0000 Subject: [PATCH 074/140] bump NeMo with proper handling of control character containing sequences and handling divide by zero in loss --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 9816ff15b4..fadacc30f5 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 9816ff15b48662b189691287f856598e3dfc2932 +Subproject commit fadacc30f5b928c55851ce012125cc0a335289dd From 0976fac804178734a3fb78037f3d8de7da8877d9 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 19 Feb 2025 16:17:03 +0000 Subject: [PATCH 075/140] Update remote pointers to new public NeMo branches --- .gitmodules | 2 +- 3rdparty/NeMo | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 1580a2e194..0b6458ab20 100644 --- a/.gitmodules +++ b/.gitmodules @@ -3,4 +3,4 @@ url = https://github.com/NVIDIA/Megatron-LM.git [submodule "3rdparty/NeMo"] path = 3rdparty/NeMo - url = https://gitlab-master.nvidia.com/ataghibakhsh/nemo-savanna.git + url = https://github.com/NVIDIA/NeMo.git diff --git a/3rdparty/NeMo b/3rdparty/NeMo index fadacc30f5..a7a5092ab8 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit fadacc30f5b928c55851ce012125cc0a335289dd +Subproject commit a7a5092ab8a290fb066d3dacb85ce5655f4e09d1 From 04982aee311b9963bf1f55d1d1591de32370b1b4 Mon Sep 17 00:00:00 2001 From: Cory Ye <cye@nvidia.com> Date: Wed, 19 Feb 2025 09:19:19 -0800 Subject: [PATCH 076/140] Remove unused Megatron torch_dist sizing patch. --- ...atron-lm-mr2604-torch-dist-ckpt-size.patch | 32 ------------------- 1 file changed, 32 deletions(-) delete mode 100644 ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch diff --git a/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch b/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch deleted file mode 100644 index fb064ff7ff..0000000000 --- a/ci/scripts/megatron-lm-mr2604-torch-dist-ckpt-size.patch +++ /dev/null @@ -1,32 +0,0 @@ -diff --git a/megatron/core/dist_checkpointing/strategies/filesystem_async.py b/megatron/core/dist_checkpointing/strategies/filesystem_async.py -index 47ab4d112..48de3218b 100644 ---- a/megatron/core/dist_checkpointing/strategies/filesystem_async.py -+++ b/megatron/core/dist_checkpointing/strategies/filesystem_async.py -@@ -113,6 +113,18 @@ class FileSystemWriterAsync(FileSystemWriter): - file_count += 1 - return file_name - -+ def _copy_to_cpu(ten: torch.Tensor): -+ """Pinned D2H copy (or a simple clone() if already on the CPU). -+ -+ Makes sure we perform a `clone` only if we detect incontiguous storage, -+ so that we don't blow up host memory unnecessarily. -+ """ -+ ten = ten.detach() -+ if ten.device.type != "cpu": -+ return ten.to("cpu", non_blocking=True) -+ is_view = ten.untyped_storage().size() != ten.numel() * ten.itemsize -+ return ten.clone() if is_view else ten -+ - # Prepare bytes / tensor data in each bucket, which will be assigned to each writer process - self.write_buckets = [] - for group_name, group_buckets in _split_by_separation_hint( -@@ -125,7 +137,7 @@ class FileSystemWriterAsync(FileSystemWriter): - if item.type == WriteItemType.BYTE_IO - ] - tensor_data = [ -- (item, planner.resolve_data(item).detach().to("cpu", non_blocking=True)) -+ (item, _copy_to_cpu(planner.resolve_data(item))) - for item in bucket - if item.type != WriteItemType.BYTE_IO - ] From 242f3fe8f1d1b5c57871d51d33b267915c7539c6 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 19 Feb 2025 20:56:04 +0000 Subject: [PATCH 077/140] Remove fasta from test and replace with synthetic sequence Signed-off-by: John St John <jstjohn@nvidia.com> --- .../src/bionemo/core/data/resources/evo2.yaml | 9 -- .../bionemo/evo2/data/test_preprocess.py | 84 ++++++++++++++----- 2 files changed, 63 insertions(+), 30 deletions(-) diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index dd41df0962..da48357c07 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -22,12 +22,3 @@ TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT ATAATTTTAATTTATATAAT - -- tag: sample-data-raw:1.0 - ngc: null - ngc_registry: resource - pbss: "s3://bionemo-ci/test_data/evo2/mmseqs_results_rep_seq_distinct_sample_sequences.fasta" - sha256: 9938a2234496366e57c136958e697550bb608ddf1427ba080eb51d1d331a744f # pragma: allowlist secret - owner: John St John <jstjohn@nvidia.com> - description: > - Sample data for Evo2 preprocessing required by training. diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index da3ed32a7c..d752a3dd7b 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -21,25 +21,22 @@ import pytest -from bionemo.core.data.load import load from bionemo.evo2.data.preprocess import Evo2Preprocessor from bionemo.evo2.utils.config import Evo2PreprocessingConfig +from bionemo.noodles.nvfaidx import NvFaidx -@pytest.fixture -def sample_data_path() -> Path: - # TODO(@dorotat) replace source with ngc when artefacts are published - data_path = load("evo2/sample-data-raw:1.0", source="pbss") - return data_path +ALU_SEQUENCE: str = ( + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACGAGGTC" + "aggagatcgagaccatcctggctaacacggtgaaaccccgtctctactaaaaatacaaaaaattagccgggc" + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATGGCGTGAACCCGGGAGGCG" + "GAGCTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA" +) -@pytest.fixture -def output_prefix() -> str: - return "test_promoters_uint8_distinct" - - -@pytest.fixture -def preprocessing_config(tmp_path: Path, output_prefix: str, sample_data_path: Path) -> Evo2PreprocessingConfig: +def create_preprocessing_config( + tmp_path: Path, sample_data_path: Path, output_prefix: str = "test_alu_uint8_distinct" +) -> Evo2PreprocessingConfig: """Creates a preprocessing configuration with test settings.""" config_dict = { "datapaths": [str(sample_data_path)], @@ -74,16 +71,61 @@ def preprocessing_config(tmp_path: Path, output_prefix: str, sample_data_path: P return Evo2PreprocessingConfig(**config_dict) -@pytest.fixture -def preprocessor(preprocessing_config: Evo2PreprocessingConfig) -> Evo2Preprocessor: - """Creates an Evo2Preprocessor instance with test configuration.""" - return Evo2Preprocessor(preprocessing_config) - - -def test_preprocessor_creates_expected_files( - preprocessor: Evo2Preprocessor, preprocessing_config: Evo2PreprocessingConfig +def create_fasta_file( + fasta_file_path: Path, + num_sequences: int, + sequence_length: int, + repeating_dna_pattern: str = ALU_SEQUENCE, + max_line_length: int = 80, +) -> Path: + """Creates a fasta file with the given number of sequences, sequence length, and repeating dna pattern. Each contig uses a shifted version of the repeating pattern.""" + with open(fasta_file_path, "w") as f: + for i in range(num_sequences): + # get the repeating pattern shifted by i for this contig + repeat_pattern_for_contig = repeating_dna_pattern[i:] + repeating_dna_pattern[:i] + # repeat the pattern enough times to reach the desired sequence length + if sequence_length <= len(repeat_pattern_for_contig): + contig_output = repeat_pattern_for_contig[:sequence_length] + else: + # Calculate how many complete repeats we need + num_repeats = sequence_length // len(repeat_pattern_for_contig) + remainder = sequence_length % len(repeat_pattern_for_contig) + contig_output = repeat_pattern_for_contig * num_repeats + repeat_pattern_for_contig[:remainder] + # verify the length of the contig is as expected + assert len(contig_output) == sequence_length + # Fold the contig output into lines of max_line_length + contig_output = "\n".join( + contig_output[i : i + max_line_length] for i in range(0, sequence_length, max_line_length) + ) + # write to the fasta file with the actual contig_output, not the repeating pattern + f.write(f">contig_{i}\n{contig_output}\n") + return fasta_file_path + + +@pytest.mark.parametrize("target_sequence_length, num_sequences", [(123, 3), (1234, 2), (12345, 1)]) +def test_created_fasta_file_has_expected_length( + tmp_path: Path, num_sequences: int, target_sequence_length: int ) -> None: + fasta_file_path = tmp_path / "test.fasta" + create_fasta_file(fasta_file_path, num_sequences, target_sequence_length, repeating_dna_pattern=ALU_SEQUENCE) + assert fasta_file_path.stat().st_size > 0 + idx = NvFaidx(fasta_file_path) + for i, (seq_name, sequence) in enumerate(sorted(idx.items())): + assert seq_name == f"contig_{i}" + assert len(sequence) == target_sequence_length + if i == 0: + assert ALU_SEQUENCE[:target_sequence_length] in sequence + + +def test_preprocessor_creates_expected_files(tmp_path: Path) -> None: """Verifies that preprocessing creates all expected output files.""" + test_fasta_file_path = create_fasta_file(tmp_path / "test.fasta", num_sequences=10, sequence_length=10000) + output_dir = tmp_path / "processed_data" + output_dir.mkdir(parents=True, exist_ok=True) + preprocessing_config = create_preprocessing_config( + tmp_path / "processed_data", test_fasta_file_path, output_prefix="test_alu_uint8_distinct" + ) + preprocessor = Evo2Preprocessor(preprocessing_config) preprocessor.preprocess_offline(preprocessing_config) # Check that all expected files exist From 22ada77d06c779fc56476e2f491218609c6ebecc Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 19 Feb 2025 21:35:54 +0000 Subject: [PATCH 078/140] Move fasta creation utility into testing sub-package Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo/evo2/data/test_preprocess.py | 58 +------------------ .../src/bionemo/testing/data/fasta.py | 56 ++++++++++++++++++ .../tests/bionemo/testing/data/test_fasta.py | 35 +++++++++++ 3 files changed, 92 insertions(+), 57 deletions(-) create mode 100644 sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py create mode 100644 sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index d752a3dd7b..8e1956fa77 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -19,19 +19,9 @@ from pathlib import Path -import pytest - from bionemo.evo2.data.preprocess import Evo2Preprocessor from bionemo.evo2.utils.config import Evo2PreprocessingConfig -from bionemo.noodles.nvfaidx import NvFaidx - - -ALU_SEQUENCE: str = ( - "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACGAGGTC" - "aggagatcgagaccatcctggctaacacggtgaaaccccgtctctactaaaaatacaaaaaattagccgggc" - "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATGGCGTGAACCCGGGAGGCG" - "GAGCTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA" -) +from bionemo.testing.data.fasta import create_fasta_file def create_preprocessing_config( @@ -71,52 +61,6 @@ def create_preprocessing_config( return Evo2PreprocessingConfig(**config_dict) -def create_fasta_file( - fasta_file_path: Path, - num_sequences: int, - sequence_length: int, - repeating_dna_pattern: str = ALU_SEQUENCE, - max_line_length: int = 80, -) -> Path: - """Creates a fasta file with the given number of sequences, sequence length, and repeating dna pattern. Each contig uses a shifted version of the repeating pattern.""" - with open(fasta_file_path, "w") as f: - for i in range(num_sequences): - # get the repeating pattern shifted by i for this contig - repeat_pattern_for_contig = repeating_dna_pattern[i:] + repeating_dna_pattern[:i] - # repeat the pattern enough times to reach the desired sequence length - if sequence_length <= len(repeat_pattern_for_contig): - contig_output = repeat_pattern_for_contig[:sequence_length] - else: - # Calculate how many complete repeats we need - num_repeats = sequence_length // len(repeat_pattern_for_contig) - remainder = sequence_length % len(repeat_pattern_for_contig) - contig_output = repeat_pattern_for_contig * num_repeats + repeat_pattern_for_contig[:remainder] - # verify the length of the contig is as expected - assert len(contig_output) == sequence_length - # Fold the contig output into lines of max_line_length - contig_output = "\n".join( - contig_output[i : i + max_line_length] for i in range(0, sequence_length, max_line_length) - ) - # write to the fasta file with the actual contig_output, not the repeating pattern - f.write(f">contig_{i}\n{contig_output}\n") - return fasta_file_path - - -@pytest.mark.parametrize("target_sequence_length, num_sequences", [(123, 3), (1234, 2), (12345, 1)]) -def test_created_fasta_file_has_expected_length( - tmp_path: Path, num_sequences: int, target_sequence_length: int -) -> None: - fasta_file_path = tmp_path / "test.fasta" - create_fasta_file(fasta_file_path, num_sequences, target_sequence_length, repeating_dna_pattern=ALU_SEQUENCE) - assert fasta_file_path.stat().st_size > 0 - idx = NvFaidx(fasta_file_path) - for i, (seq_name, sequence) in enumerate(sorted(idx.items())): - assert seq_name == f"contig_{i}" - assert len(sequence) == target_sequence_length - if i == 0: - assert ALU_SEQUENCE[:target_sequence_length] in sequence - - def test_preprocessor_creates_expected_files(tmp_path: Path) -> None: """Verifies that preprocessing creates all expected output files.""" test_fasta_file_path = create_fasta_file(tmp_path / "test.fasta", num_sequences=10, sequence_length=10000) diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py b/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py new file mode 100644 index 0000000000..1559430e47 --- /dev/null +++ b/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py @@ -0,0 +1,56 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +from pathlib import Path + + +ALU_SEQUENCE: str = ( + "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACGAGGTC" + "aggagatcgagaccatcctggctaacacggtgaaaccccgtctctactaaaaatacaaaaaattagccgggc" + "GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATGGCGTGAACCCGGGAGGCG" + "GAGCTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA" +) + + +def create_fasta_file( + fasta_file_path: Path, + num_sequences: int, + sequence_length: int, + repeating_dna_pattern: str = ALU_SEQUENCE, + max_line_length: int = 80, +) -> Path: + """Creates a fasta file with the given number of sequences, sequence length, and repeating dna pattern. Each contig uses a shifted version of the repeating pattern.""" + with open(fasta_file_path, "w") as f: + for i in range(num_sequences): + # get the repeating pattern shifted by i for this contig + repeat_pattern_for_contig = repeating_dna_pattern[i:] + repeating_dna_pattern[:i] + # repeat the pattern enough times to reach the desired sequence length + if sequence_length <= len(repeat_pattern_for_contig): + contig_output = repeat_pattern_for_contig[:sequence_length] + else: + # Calculate how many complete repeats we need + num_repeats = sequence_length // len(repeat_pattern_for_contig) + remainder = sequence_length % len(repeat_pattern_for_contig) + contig_output = repeat_pattern_for_contig * num_repeats + repeat_pattern_for_contig[:remainder] + # verify the length of the contig is as expected + assert len(contig_output) == sequence_length + # Fold the contig output into lines of max_line_length + contig_output = "\n".join( + contig_output[i : i + max_line_length] for i in range(0, sequence_length, max_line_length) + ) + # write to the fasta file with the actual contig_output, not the repeating pattern + f.write(f">contig_{i}\n{contig_output}\n") + return fasta_file_path diff --git a/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py b/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py new file mode 100644 index 0000000000..9953e2ade6 --- /dev/null +++ b/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py @@ -0,0 +1,35 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. +from pathlib import Path + +import pytest + +from bionemo.noodles.nvfaidx import NvFaidx +from bionemo.testing.data.fasta import ALU_SEQUENCE, create_fasta_file + + +@pytest.mark.parametrize("target_sequence_length, num_sequences", [(123, 3), (1234, 2), (12345, 1)]) +def test_created_fasta_file_has_expected_length( + tmp_path: Path, num_sequences: int, target_sequence_length: int +) -> None: + fasta_file_path = tmp_path / "test.fasta" + create_fasta_file(fasta_file_path, num_sequences, target_sequence_length, repeating_dna_pattern=ALU_SEQUENCE) + assert fasta_file_path.stat().st_size > 0 + idx = NvFaidx(fasta_file_path) + for i, (seq_name, sequence) in enumerate(sorted(idx.items())): + assert seq_name == f"contig_{i}" + assert len(sequence) == target_sequence_length + if i == 0: + assert ALU_SEQUENCE[:target_sequence_length] in sequence From b5bdec8481a74fcadbbaa128f2541f590b0f6441 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 19 Feb 2025 22:27:05 +0000 Subject: [PATCH 079/140] Add a test that verifies that the new phylo tag masking code is faster than the old code Signed-off-by: John St John <jstjohn@nvidia.com> --- .../data/test_benchmark_phylo_tag_speed.py | 131 ++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py new file mode 100644 index 0000000000..8a3b3de208 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py @@ -0,0 +1,131 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import random +import timeit +from typing import Tuple + +import torch +from nemo.collections.llm.gpt.data.megatron.hyena.evo2_dataset import Evo2Dataset + + +def _construct_taxonomy_token(dropout: float = 0.0) -> str: + """Construct a special Taxonomy token for natural language prompting of DNA generation models. + + Args: + dropout (float): The probability of dropping out segments of the lineage. Defaults to 0.0. + + Returns: + Optional[str]: The constructed taxonomy token or None if lineage is None. + """ + # If dropout > 0, randomly drop out segments of the lineage for training on incomplete lineages. + return "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( + "somekingdom" if random.random() >= dropout else None, + "somephylum" if random.random() >= dropout else None, + "someclass" if random.random() >= dropout else None, + "someorder" if random.random() >= dropout else None, + "somefamily" if random.random() >= dropout else None, + "lineage.genus" if random.random() >= dropout else None, + "lineage.speciescactaca" if random.random() >= dropout else None, + ) + + +def mask_phylogenetic_tags_old(tokenized_sequence, terminal_tag_char, other_tag_chars, eod_token_id): + """ + Optimized version to create a phylonetic tag mask for batched tokenized sequences with correct handling of partial tags. + Args: + - tokenized_sequence (torch.Tensor): A batched tensor of shape (batch_size, seq_length). + - terminal_tag_char (int): The token ID representing the start and end of a phylogenetic tag ('|'). + - other_tag_chars (set of int): A set of token IDs that are uniquely part of the tag ('_', ';', etc.). + - eod_token_id (int): The token ID representing the end-of-document (EOD). + Returns: + - mask_vector (torch.Tensor): A batched mask of the same shape as tokenized_sequence where + 1 represents non-tag tokens and 0 represents tokens within the masked region. + """ + device = tokenized_sequence.device + batch_size, seq_len = tokenized_sequence.shape + mask_vector = torch.ones_like(tokenized_sequence, dtype=torch.int, device=device) + + # To address when unbalanced tags are present + terms = torch.tensor([0, seq_len - 1], device=device) + other_tags = torch.tensor(list(other_tag_chars), device=device) + for batch_idx in range(batch_size): + tag_term_locs = torch.where(tokenized_sequence[batch_idx] == terminal_tag_char)[0] + tag_end_locs = torch.where(tokenized_sequence[batch_idx] == eod_token_id)[0] + + merged_tags = torch.cat((terms, tag_term_locs, tag_end_locs)).sort()[0] + merged_tags = merged_tags.unique() + + start = 0 # First and last locations are always added + for end in merged_tags[1:]: + if torch.isin(tokenized_sequence[batch_idx][start:end], other_tags).sum() > 0: + # end token is not part of the tag + if eod_token_id == tokenized_sequence[batch_idx][end]: + end = end - 1 + if eod_token_id == tokenized_sequence[batch_idx][start]: + start = start + 1 + + mask_vector[batch_idx][start : (end + 1)] = 0 + start = end + return mask_vector + + +def benchmark_phylo_tag_masking(num_iterations: int = 1000) -> Tuple[float, float]: + """Benchmark the performance of phylogenetic tag masking functions. + + Args + num_iterations: Number of iterations to run for timing + """ + tax_token = _construct_taxonomy_token(dropout=0.0) + sequence_alpha = ( + tax_token[2:] + + "".join(random.choice("ACGTacgt") for _ in range(5000)) + + tax_token[:-25] + + "0" + + tax_token[36:] + + "".join(random.choice("ACGTacgt") for _ in range(5000)) + ) + sequence = torch.tensor([ord(t) if t != "0" else 0 for t in sequence_alpha], dtype=torch.int32) + + # Time the new implementation + new_time = timeit.timeit( + lambda: Evo2Dataset.mask_phylogenetic_tags(sequence.unsqueeze(0), 124, {95, 59, 32}, 0), + number=num_iterations, + ) + print(f"New implementation average time: {new_time/num_iterations:.6f} seconds") + + # Time the old implementation + old_time = timeit.timeit( + lambda: mask_phylogenetic_tags_old(sequence.unsqueeze(0), 124, {95, 59, 32}, 0), + number=num_iterations, + ) + return old_time, new_time + + +def test_phylo_tag_masking_speed(): + num_iterations = 1000 + old_time, new_time = benchmark_phylo_tag_masking(num_iterations=num_iterations) + assert old_time / num_iterations > new_time / num_iterations + + +if __name__ == "__main__": + num_iterations = 1000 + old_time, new_time = benchmark_phylo_tag_masking(num_iterations=num_iterations) + print(f"Old implementation average time: {old_time/num_iterations:.6f} seconds") + print(f"New implementation average time: {new_time/num_iterations:.6f} seconds") + print(f"Speed improvement: {(old_time/new_time - 1)*100:.2f}%") From ac1bd1f333b854410c3f8ff9e3f83340986bd2cf Mon Sep 17 00:00:00 2001 From: "John St. John" <jstjohn@nvidia.com> Date: Wed, 19 Feb 2025 23:33:48 +0000 Subject: [PATCH 080/140] Move phylo tag benchmark to NeMo testing Signed-off-by: John St. John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- .../data/test_benchmark_phylo_tag_speed.py | 131 ------------------ 2 files changed, 1 insertion(+), 132 deletions(-) delete mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py diff --git a/3rdparty/NeMo b/3rdparty/NeMo index a7a5092ab8..9c3fb74e2c 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit a7a5092ab8a290fb066d3dacb85ce5655f4e09d1 +Subproject commit 9c3fb74e2c168111e30179b185c6e9a1a4c30474 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py deleted file mode 100644 index 8a3b3de208..0000000000 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_benchmark_phylo_tag_speed.py +++ /dev/null @@ -1,131 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. -# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved -# SPDX-License-Identifier: LicenseRef-Apache2 -# -# 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. - -import random -import timeit -from typing import Tuple - -import torch -from nemo.collections.llm.gpt.data.megatron.hyena.evo2_dataset import Evo2Dataset - - -def _construct_taxonomy_token(dropout: float = 0.0) -> str: - """Construct a special Taxonomy token for natural language prompting of DNA generation models. - - Args: - dropout (float): The probability of dropping out segments of the lineage. Defaults to 0.0. - - Returns: - Optional[str]: The constructed taxonomy token or None if lineage is None. - """ - # If dropout > 0, randomly drop out segments of the lineage for training on incomplete lineages. - return "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( - "somekingdom" if random.random() >= dropout else None, - "somephylum" if random.random() >= dropout else None, - "someclass" if random.random() >= dropout else None, - "someorder" if random.random() >= dropout else None, - "somefamily" if random.random() >= dropout else None, - "lineage.genus" if random.random() >= dropout else None, - "lineage.speciescactaca" if random.random() >= dropout else None, - ) - - -def mask_phylogenetic_tags_old(tokenized_sequence, terminal_tag_char, other_tag_chars, eod_token_id): - """ - Optimized version to create a phylonetic tag mask for batched tokenized sequences with correct handling of partial tags. - Args: - - tokenized_sequence (torch.Tensor): A batched tensor of shape (batch_size, seq_length). - - terminal_tag_char (int): The token ID representing the start and end of a phylogenetic tag ('|'). - - other_tag_chars (set of int): A set of token IDs that are uniquely part of the tag ('_', ';', etc.). - - eod_token_id (int): The token ID representing the end-of-document (EOD). - Returns: - - mask_vector (torch.Tensor): A batched mask of the same shape as tokenized_sequence where - 1 represents non-tag tokens and 0 represents tokens within the masked region. - """ - device = tokenized_sequence.device - batch_size, seq_len = tokenized_sequence.shape - mask_vector = torch.ones_like(tokenized_sequence, dtype=torch.int, device=device) - - # To address when unbalanced tags are present - terms = torch.tensor([0, seq_len - 1], device=device) - other_tags = torch.tensor(list(other_tag_chars), device=device) - for batch_idx in range(batch_size): - tag_term_locs = torch.where(tokenized_sequence[batch_idx] == terminal_tag_char)[0] - tag_end_locs = torch.where(tokenized_sequence[batch_idx] == eod_token_id)[0] - - merged_tags = torch.cat((terms, tag_term_locs, tag_end_locs)).sort()[0] - merged_tags = merged_tags.unique() - - start = 0 # First and last locations are always added - for end in merged_tags[1:]: - if torch.isin(tokenized_sequence[batch_idx][start:end], other_tags).sum() > 0: - # end token is not part of the tag - if eod_token_id == tokenized_sequence[batch_idx][end]: - end = end - 1 - if eod_token_id == tokenized_sequence[batch_idx][start]: - start = start + 1 - - mask_vector[batch_idx][start : (end + 1)] = 0 - start = end - return mask_vector - - -def benchmark_phylo_tag_masking(num_iterations: int = 1000) -> Tuple[float, float]: - """Benchmark the performance of phylogenetic tag masking functions. - - Args - num_iterations: Number of iterations to run for timing - """ - tax_token = _construct_taxonomy_token(dropout=0.0) - sequence_alpha = ( - tax_token[2:] - + "".join(random.choice("ACGTacgt") for _ in range(5000)) - + tax_token[:-25] - + "0" - + tax_token[36:] - + "".join(random.choice("ACGTacgt") for _ in range(5000)) - ) - sequence = torch.tensor([ord(t) if t != "0" else 0 for t in sequence_alpha], dtype=torch.int32) - - # Time the new implementation - new_time = timeit.timeit( - lambda: Evo2Dataset.mask_phylogenetic_tags(sequence.unsqueeze(0), 124, {95, 59, 32}, 0), - number=num_iterations, - ) - print(f"New implementation average time: {new_time/num_iterations:.6f} seconds") - - # Time the old implementation - old_time = timeit.timeit( - lambda: mask_phylogenetic_tags_old(sequence.unsqueeze(0), 124, {95, 59, 32}, 0), - number=num_iterations, - ) - return old_time, new_time - - -def test_phylo_tag_masking_speed(): - num_iterations = 1000 - old_time, new_time = benchmark_phylo_tag_masking(num_iterations=num_iterations) - assert old_time / num_iterations > new_time / num_iterations - - -if __name__ == "__main__": - num_iterations = 1000 - old_time, new_time = benchmark_phylo_tag_masking(num_iterations=num_iterations) - print(f"Old implementation average time: {old_time/num_iterations:.6f} seconds") - print(f"New implementation average time: {new_time/num_iterations:.6f} seconds") - print(f"Speed improvement: {(old_time/new_time - 1)*100:.2f}%") From 0ae0c507580d41938ec7e68951917ffa1cddb1f2 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Thu, 20 Feb 2025 13:56:06 -0800 Subject: [PATCH 081/140] Update Megatron-LM submodule to commit 62529f1d (has 1M context fix) (#697) Point megatron to commit with our fix merged. Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- 3rdparty/Megatron-LM | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/Megatron-LM b/3rdparty/Megatron-LM index bcee0521dc..62529f1d8e 160000 --- a/3rdparty/Megatron-LM +++ b/3rdparty/Megatron-LM @@ -1 +1 @@ -Subproject commit bcee0521dc886545a6af88a4e268715d99e03143 +Subproject commit 62529f1d8e3d76f45ba5c0b4d7791566055d3eee From 2ba5da318c29ba2bdac37adb1a8a4c87b5f468b8 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 21 Feb 2025 00:23:48 +0000 Subject: [PATCH 082/140] fix config typo in test Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py index 8e1956fa77..1a412e2525 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_preprocess.py @@ -33,7 +33,7 @@ def create_preprocessing_config( "output_dir": str(tmp_path), "output_prefix": output_prefix, "train_split": 0.6, - "validation_split": 0.2, + "valid_split": 0.2, "test_split": 0.2, "overwrite": True, "embed_reverse_complement": True, From 253a7f29b9be9fd66026d7b2ecee341a897fcd71 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 21 Feb 2025 01:35:12 +0000 Subject: [PATCH 083/140] bump NeMo to latest PR version --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 9c3fb74e2c..7d52494da0 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 9c3fb74e2c168111e30179b185c6e9a1a4c30474 +Subproject commit 7d52494da0bd797c936cdbb49c2f8fba0db0e174 From 82e9c475d82b5621c3acd8b97b46ca92760342e6 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Fri, 21 Feb 2025 10:58:16 -0800 Subject: [PATCH 084/140] Fix issue causing gh-docs-deploy failure (#698) gh-docs-deploy was failing. This fixes the failures by adding `__init__.py`'s mkdocs was expecting Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py | 0 .../bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py | 0 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py new file mode 100644 index 0000000000..e69de29bb2 From fa73a009dd47fe0ab117ae4bfa4226fd78b28e6b Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 21 Feb 2025 19:20:17 +0000 Subject: [PATCH 085/140] Update nemo pointer with PR updates Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 7d52494da0..04eba8ebb9 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 7d52494da0bd797c936cdbb49c2f8fba0db0e174 +Subproject commit 04eba8ebb9696981f064c7739e832e34fde3a39c From f4667744908af3fad4f9e04f698cf0a58be217fb Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Fri, 21 Feb 2025 11:22:58 -0800 Subject: [PATCH 086/140] Add new license to new files (failing ci) (#699) Add license header to new files causing CI failure. Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- .../src/bionemo/evo2/utils/__init__.py | 17 +++++++++++++++++ .../bionemo/evo2/utils/checkpoint/__init__.py | 17 +++++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py index e69de29bb2..9981337fda 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py @@ -0,0 +1,17 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py index e69de29bb2..9981337fda 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py @@ -0,0 +1,17 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. From 39290e4ed00ba4225762859baee7d859c2926211 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Fri, 21 Feb 2025 22:20:33 +0000 Subject: [PATCH 087/140] Change kingdom to domain in tag description Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- .../src/bionemo/evo2/data/preprocess.py | 2 +- .../src/bionemo/evo2/utils/__init__.py | 14 ++++++++++++++ .../src/bionemo/evo2/utils/checkpoint/__init__.py | 14 ++++++++++++++ .../bionemo-evo2/src/bionemo/evo2/utils/config.py | 2 +- 5 files changed, 31 insertions(+), 3 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 04eba8ebb9..8b9fdb279c 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 04eba8ebb9696981f064c7739e832e34fde3a39c +Subproject commit 8b9fdb279cf03051db3f37b3bb070b9fce92e1d6 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index f31bb77222..352683b7b0 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -206,7 +206,7 @@ def _construct_taxonomy_token( with Evo2Preprocessor.preprocessing_context_manager(seed if seed is not None else None): return ( "|d__{};p__{};c__{};o__{};f__{};g__{};s__{}|".format( - lineage.kingdom if random.random() >= dropout else None, + lineage.domain if random.random() >= dropout else None, lineage.phylum if random.random() >= dropout else None, lineage.clazz if random.random() >= dropout else None, lineage.order if random.random() >= dropout else None, diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py index e69de29bb2..25e6abfbc5 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py index e69de29bb2..25e6abfbc5 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/__init__.py @@ -0,0 +1,14 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py index 8dd0b1c1ba..4dda5b884a 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/config.py @@ -26,7 +26,7 @@ class Evo2TaxonomyLineage(BaseModel): """Pydantic model class that defines the source lineage of a DNA sequence.""" - kingdom: None | str = None + domain: None | str = None phylum: None | str = None clazz: None | str = None order: None | str = None From 15c7dcaed3090bcc5da8891f332cb632a7dd287d Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Sat, 22 Feb 2025 02:10:31 +0000 Subject: [PATCH 088/140] Make new versions of the files available freshly converted from HF --- 3rdparty/NeMo | 2 +- .../src/bionemo/core/data/resources/evo2.yaml | 29 ++++++-- sub-packages/bionemo-evo2/README.md | 72 +++++++++++++++++++ sub-packages/bionemo-evo2/pyproject.toml | 1 + .../src/bionemo/evo2/run/train.py | 19 ++--- .../{torch2nemo.py => convert_to_nemo.py} | 47 ++++++------ .../tests/bionemo/evo2/run/test_infer.py | 2 +- .../tests/bionemo/evo2/run/test_inference.py | 4 +- .../tests/bionemo/evo2/test_evo2.py | 6 +- 9 files changed, 134 insertions(+), 48 deletions(-) rename sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/{torch2nemo.py => convert_to_nemo.py} (54%) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 8b9fdb279c..21300b0f08 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 8b9fdb279cf03051db3f37b3bb070b9fce92e1d6 +Subproject commit 21300b0f088e77aec4742ff78fc71ff4a378a424 diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index da48357c07..97322d102a 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -1,12 +1,31 @@ -- tag: 7b-8k-zarr:1.1 +- tag: 1b-8k:1.0 ngc: null ngc_registry: model - pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_fix_shape_v2.tar.gz" - sha256: e08d89a1841a6aa3796c772ffe84092f20ac0a11d1b6ef7b1966ebbd8253e17e # pragma: allowlist secret + pbss: "s3://bionemo-ci/models/nemo2_evo2_1b_8k.tar.gz" + sha256: d663c529ac7ae0b6f2fd3a852253a484bd8a6576992e9ec73045ce7af2365990 # pragma: allowlist secret owner: John St John <jstjohn@nvidia.com> description: > - A 7b parameter evo2 model used in testing, zarr format. 1.1 is the same as 1.0 but the HyenaModel class names have - been updated to match the current version of the code in the checkpoint metadata. + A 7b parameter evo2 model used in testing, torch_dist format. Converted from hf://arcinstitute/savanna_evo2_1b_base. + + +- tag: 7b-8k:1.0 + ngc: null + ngc_registry: model + pbss: "s3://bionemo-ci/models/nemo2_evo2_7b_8k.tar.gz" + sha256: 78fc05536e1a9bd2febacea079a4beedf93ddcba1c69ac24690a5f7b649a0655 # pragma: allowlist secret + owner: John St John <jstjohn@nvidia.com> + description: > + A 7b parameter evo2 model used in testing, torch_dist format. Converted from hf://arcinstitute/savanna_evo2_7b_base. + +- tag: 7b-1m:1.0 + ngc: null + ngc_registry: model + pbss: "s3://bionemo-ci/models/nemo2_evo2_7b_1m.tar.gz" + sha256: 448cf1f09204c079f9be3e6a46d6349de563fc1713ae5c38c376cfb274647f94 # pragma: allowlist secret + owner: John St John <jstjohn@nvidia.com> + description: > + A 7b parameter evo2 model used in testing, torch_dist format. Converted from hf://arcinstitute/savanna_evo2_7b. + - tag: 7b-8k-nofp8-te-goldvalue-testdata:1.0 ngc: null diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 92ee5e5b37..d203a9b15d 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -157,3 +157,75 @@ As in `train_evo2`, `--ckpt-dir` points to the NeMo2 checkpoint directory for Ev ``` [NeMo I 2025-01-06 17:22:22 infer:102] ['CTCTTCTGGTATTTGG'] ``` + +## Checkpoint conversion from hugging face to NeMo2 +The following conversion script should work on any savanna formatted arc evo2 checkpoint. Make sure you match up the +model size with the checkpoint you are converting. +The pyproject.toml also makes the conversion script available as a command line tool `evo2_convert_to_nemo2`, so you +can try replacing: +```bash +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ + ... +``` +with: +```bash +evo2_convert_to_nemo2 \ + ... +``` + + +```bash +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ + --model-path hf://arcinstitute/savanna_evo2_1b_base \ + --model-size 1b --output-dir nemo2_evo2_1b_8k +``` + +To create the checkpoint for distribution in NGC, first cd into the checkpiont directory: +```bash +cd nemo2_evo2_1b_8k +``` + +Then run the following command to make a tar of the full directory that gets unpacked into the current directory which +our NGC loader expects: +```bash +tar -czvf ../nemo2_evo2_1b_8k.tar.gz . +``` + +Finally `sha256sum` the tar file to get the checksum: +```bash +sha256sum nemo2_evo2_1b_8k.tar.gz +``` + +Then register it into the loader for testing purposes by editing +`sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml`. + +### 7b-8k +```bash +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ + --model-path hf://arcinstitute/savanna_evo2_7b_base \ + --model-size 7b --output-dir nemo2_evo2_7b_8k +``` +### 7b-1M +```bash +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ + --model-path hf://arcinstitute/savanna_evo2_7b \ + --model-size 7b_arc_longcontext --output-dir nemo2_evo2_7b_1m +``` +### 40b-8k +```bash +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ + --model-path hf://arcinstitute/savanna_evo2_40b_base \ + --model-size 40b --output-dir nemo2_evo2_40b_8k +``` +### 40b-1M +```bash +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ + --model-path hf://arcinstitute/savanna_evo2_40b \ + --model-size 40b_arc_longcontext --output-dir nemo2_evo2_40b_1m +``` diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index 638ea3a61c..88499e2777 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -21,6 +21,7 @@ infer_evo2 = "bionemo.evo2.run.infer:main" train_evo2 = "bionemo.evo2.run.train:main" preprocess_evo2 = "bionemo.evo2.data.preprocess:main" splice_evo2 = "bionemo.evo2.data.transcript_extraction:main" +evo2_convert_to_nemo2 = "bionemo.evo2.utils.checkpoint.convert_to_nemo:main" [tool.setuptools.packages.find] where = ["src"] diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 76073d7eef..d3784d81fa 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -18,7 +18,6 @@ import argparse from dataclasses import asdict -from typing import Type # TODO add back support for slurm resilience. # import nvidia_resiliency_ext.ptl_resiliency as res_module @@ -32,6 +31,7 @@ from nemo.collections.llm.gpt.data import MockDataModule, PreTrainingDataModule from nemo.collections.llm.gpt.data.megatron.hyena.config import parse_dataset_config from nemo.collections.llm.gpt.data.megatron.hyena.evo2_dataset import Evo2Dataset, Evo2DatasetPadEodLossMask +from nemo.collections.llm.gpt.model.hyena import HYENA_MODEL_OPTIONS from nemo.collections.llm.recipes.tp_overlap_configs.userbuffers import ( userbuffers_bf16_h100_h8192_tp4_mbs1_seqlen8192, userbuffers_fp8_h100_h8192_tp4_mbs1_seqlen8192, @@ -52,17 +52,6 @@ torch._dynamo.config.suppress_errors = True -model_options: dict[str, Type[llm.HyenaConfig]] = { - "7b": llm.Hyena7bConfig, - "7b_arc_longcontext": llm.Hyena7bARCLongContextConfig, - "7b_nv": llm.HyenaNV7bConfig, - "40b": llm.Hyena40bConfig, - "40b_arc_longcontext": llm.Hyena40bARCLongContextConfig, - "40b_nv": llm.HyenaNV40bConfig, - "test": llm.HyenaTestConfig, - "test_nv": llm.HyenaNVTestConfig, -} - def parse_args(): """Parse arguments for Evo2 model training.""" @@ -153,7 +142,7 @@ def parse_args(): parser.add_argument( "--model-size", type=str, - choices=sorted(model_options.keys()), + choices=sorted(HYENA_MODEL_OPTIONS.keys()), default="7b", help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B " "parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained " @@ -457,9 +446,9 @@ def main(): if args.num_layers: config_modifiers_init["num_layers"] = args.num_layers - if args.model_size not in model_options: + if args.model_size not in HYENA_MODEL_OPTIONS: raise ValueError(f"Invalid model size: {args.model_size}") - evo2_config = model_options[args.model_size](**config_modifiers_init) + evo2_config = HYENA_MODEL_OPTIONS[args.model_size](**config_modifiers_init) # Instantiate model. model = llm.HyenaModel(evo2_config, tokenizer=data.tokenizer) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py similarity index 54% rename from sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py rename to sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py index 8ff1eb8c99..5b1b074eae 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py @@ -19,42 +19,47 @@ import argparse -from nemo.collections import llm -from nemo.collections.llm.gpt.model.hyena import PyTorchHyenaImporter +from nemo.collections.llm.gpt.model.hyena import ( + HYENA_MODEL_OPTIONS, + HuggingFaceSavannaHyenaImporter, + PyTorchHyenaImporter, +) def parse_args(): """Parse command-line arguments.""" parser = argparse.ArgumentParser() parser.add_argument( - "--model-path", type=str, required=True, help="Path to the Evo2 un-sharded (MP1) model checkpoint file." + "--model-path", + type=str, + required=True, + help="Path to the Evo2 un-sharded (MP1) model checkpoint file, or a Hugging Face model name. Any model " + "from the Savanna Evo2 family is supported such as 'hf://arcinstitute/savanna_evo2_1b_base'.", ) parser.add_argument("--output-dir", type=str, required=True, help="Output directory path for the converted model.") parser.add_argument( "--model-size", type=str, - choices=["7b", "7b_arc_1m", "40b", "40b_arc_1m", "test"], - default="7b", - help="Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B parameters). '_arc_1m' models have GLU / FFN dimensions that support 1M context length when trained with TP<=8.", + choices=sorted(HYENA_MODEL_OPTIONS.keys()), + default="1b", + help="Model architecture to use, choose between 1b, 7b, 40b, or test (a sub-model of 4 layers, " + "less than 1B parameters). '*_arc_longcontext' models have GLU / FFN dimensions that support 1M " + "context length when trained with TP>>8.", ) return parser.parse_args() -if __name__ == "__main__": - # Parse args. +def main(): + """Convert a PyTorch Evo2 model checkpoint to a NeMo model checkpoint.""" args = parse_args() - # Hyena Model Config - if args.model_size == "7b": - evo2_config = llm.Hyena7bConfig() - elif args.model_size == "7b_arc_1m": - evo2_config = llm.Hyena7bARCLongContextConfig() - elif args.model_size == "40b": - evo2_config = llm.Hyena40bConfig() - elif args.model_size == "40b_arc_1m": - evo2_config = llm.Hyena40bARCLongContextConfig() - elif args.model_size == "test": - evo2_config = llm.HyenaTestConfig() - - importer = PyTorchHyenaImporter(args.model_path, model_config=evo2_config) + evo2_config = HYENA_MODEL_OPTIONS[args.model_size]() + if args.model_path.startswith("hf://"): + importer = HuggingFaceSavannaHyenaImporter(args.model_path.lstrip("hf://"), model_config=evo2_config) + else: + importer = PyTorchHyenaImporter(args.model_path, model_config=evo2_config) importer.apply(args.output_dir) + + +if __name__ == "__main__": + main() diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index 20c5c75a75..4919a10932 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -47,7 +47,7 @@ def test_run_infer(): ) # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/7b-8k-zarr:1.1", source="pbss") + checkpoint_path = load("evo2/7b-8k:1.0", source="pbss") with clean_parallel_state_context(): infer( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index 8989af84d5..a8860a5196 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -44,7 +44,7 @@ def test_infer_model_generates_expected_single_token_output(): ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. ckpt_save_optimizer=False, ckpt_async_save=False, - save_ckpt_format="zarr", + save_ckpt_format="torch_dist", ckpt_load_strictness="log_all", ) trainer = nl.Trainer( @@ -75,7 +75,7 @@ def test_infer_model_generates_expected_single_token_output(): top_p = 0.0 max_new_tokens = 1 # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/7b-8k-zarr:1.1", source="pbss") + checkpoint_path = load("evo2/7b-8k:1.0", source="pbss") with clean_parallel_state_context(): results = generate( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index 828385e976..bae566810b 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -46,7 +46,7 @@ def load_weights_sharded_inplace_nemo2_to_mcore( model: MegatronModelType, distributed_checkpoint_dir: str | Path, skip_keys_with_these_prefixes: Set[str], - ckpt_format: Literal["zarr", "torch_dist"] = "zarr", + ckpt_format: Literal["zarr", "torch_dist"] = "torch_dist", ): logger.info("Start setting up state dict") sharded_state_dict = { @@ -68,7 +68,7 @@ def load_weights_sharded_inplace_nemo2_to_mcore( def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): try: # TODO (dorotat) remove PBSS source once the model is available on NGC - evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.1", source="pbss") / "weights" + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k:1.0", source="pbss") / "weights" # TODO (dorotat) remove PBSS source once the model is available on NGC gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0", source="pbss") except ValueError as e: @@ -86,7 +86,7 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): ) raw_megatron_model = hyena_config.configure_model(tokenizer).eval().cuda() device = raw_megatron_model.parameters().__next__().device - load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "zarr") + load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "torch_dist") model = Float16Module(hyena_config, raw_megatron_model) input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAAT" input_ids = torch.tensor(tokenizer.text_to_ids(input_seq)).int().unsqueeze(0).to(device) From 3324bd4b50ab215859ec9272b878f2d19cf082b5 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Sat, 22 Feb 2025 02:42:16 +0000 Subject: [PATCH 089/140] bump nemo version to fix broken import --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 21300b0f08..a9867cca5f 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 21300b0f088e77aec4742ff78fc71ff4a378a424 +Subproject commit a9867cca5fac4c5f7e4a46a63fa6783f277cf8ab From ce133d2c2a149ea1a14514945890eeb8a89a8cc3 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Sat, 22 Feb 2025 02:44:04 +0000 Subject: [PATCH 090/140] bump nemo to top of tree --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index a9867cca5f..9111382886 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit a9867cca5fac4c5f7e4a46a63fa6783f277cf8ab +Subproject commit 91113828868576a646f217bc8ee6f83d860af4af From 78f92b50f08917211222778152dbc85d8310d5a2 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Mon, 24 Feb 2025 21:04:35 +0000 Subject: [PATCH 091/140] Adding in the predict method and test Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/pyproject.toml | 1 + .../src/bionemo/evo2/run/predict.py | 328 ++++++++++++++++++ .../tests/bionemo/evo2/run/test_predict.py | 97 ++++++ .../bionemo-llm/src/bionemo/llm/lightning.py | 45 ++- .../src/bionemo/llm/utils/callbacks.py | 26 +- .../src/bionemo/testing/data/fasta.py | 21 +- .../tests/bionemo/testing/data/test_fasta.py | 8 +- 7 files changed, 510 insertions(+), 16 deletions(-) create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py diff --git a/sub-packages/bionemo-evo2/pyproject.toml b/sub-packages/bionemo-evo2/pyproject.toml index 88499e2777..8f6d0b25eb 100644 --- a/sub-packages/bionemo-evo2/pyproject.toml +++ b/sub-packages/bionemo-evo2/pyproject.toml @@ -19,6 +19,7 @@ dependencies = [ [project.scripts] infer_evo2 = "bionemo.evo2.run.infer:main" train_evo2 = "bionemo.evo2.run.train:main" +predict_evo2 = "bionemo.evo2.run.predict:main" preprocess_evo2 = "bionemo.evo2.data.preprocess:main" splice_evo2 = "bionemo.evo2.data.transcript_extraction:main" evo2_convert_to_nemo2 = "bionemo.evo2.utils.checkpoint.convert_to_nemo:main" diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py new file mode 100644 index 0000000000..78dc87e2ec --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py @@ -0,0 +1,328 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import argparse +import json +import tempfile +from pathlib import Path +from typing import Literal, Optional + +import nemo.lightning as nl +import torch +from lightning.pytorch import LightningDataModule +from nemo.collections.llm.gpt.model.base import get_batch_on_this_context_parallel_rank, get_packed_seq_params +from nemo.collections.llm.gpt.model.hyena import HYENA_MODEL_OPTIONS, HyenaModel +from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer +from nemo.lightning import NeMoLogger +from torch import Tensor + +from bionemo.llm.lightning import LightningPassthroughPredictionMixin +from bionemo.llm.utils.callbacks import PredictionWriter +from bionemo.noodles.nvfaidx import NvFaidx + + +CheckpointFormats = Literal["torch_dist", "zarr"] + + +def parse_args(): + """Parse arguments for Evo2 inference.""" + ap = argparse.ArgumentParser() + + ap.add_argument("--fasta", type=Path, required=True, help="Fasta path from which to generate logit predictions.") + ap.add_argument("--ckpt-dir", type=Path, required=True, help="NeMo2 checkpoint directory for inference.") + ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1.") + ap.add_argument( + "--pipeline-model-parallel-size", type=int, default=1, help="Order of pipeline parallelism. Defaults to 1." + ) + ap.add_argument( + "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." + ) + ap.add_argument( + "--model-size", + type=str, + default="7b", + choices=sorted(HYENA_MODEL_OPTIONS.keys()), + help="Model size to use. Defaults to '7b'.", + ) + # output args: + ap.add_argument( + "--output-dir", + type=Path, + default=None, + help="Output dir that will contain the generated text produced by the Evo2 model. If not provided, the output will be logged.", + ) + ap.add_argument("--fp8", action="store_true", help="Use FP8 precision. Defaults to BF16.") + # extra: + ap.add_argument( + "--ckpt-format", + type=str, + choices=["torch_dist", "zarr"], + default="torch_dist", + help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated.", + ) + + return ap.parse_args() + + +class HyenaPredictor(LightningPassthroughPredictionMixin, HyenaModel): + """A predictor for the Hyena model. This adds in the predict step and the passthrough method.""" + + def predict_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: + """Alias for forward_step, also log the pad mask since sequences may not all have the same length.""" + if len(batch) == 0: + return + forward_out = self.forward_step(batch) + if isinstance(forward_out, Tensor): + return {"token_logits": forward_out, "pad_mask": batch["loss_mask"], "seq_idx": batch["seq_idx"]} + return forward_out + + +class SimpleFastaDataset(torch.utils.data.Dataset): + """A simple dataset for Evo2 prediction.""" + + def __init__(self, fasta_path: Path, tokenizer): + """Initialize the dataset.""" + super().__init__() + self.fasta = NvFaidx(fasta_path) + self.seqids = list(self.fasta.keys()) + self.tokenizer = tokenizer + + def write_idx_map(self, output_dir: Path): + """Write the index map to the output directory.""" + with open(output_dir / "seq_idx_map.json", "w") as f: + json.dump({seqid: idx for idx, seqid in enumerate(self.seqids)}, f) + + def __len__(self): + """Get the length of the dataset.""" + return len(self.seqids) + + def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: + """Get an item from the dataset.""" + sequence = self.fasta[self.seqids[idx]].sequence().upper() + tokens: list[int] = self.tokenizer.text_to_ids(sequence) + return { + "tokens": torch.tensor(tokens, dtype=torch.long), + "position_ids": torch.arange(len(tokens), dtype=torch.long), + "seq_idx": torch.tensor(idx, dtype=torch.long), + "loss_mask": torch.ones_like(torch.tensor(tokens, dtype=torch.long), dtype=torch.long), + } + + +def hyena_predict_forward_step(model, batch) -> torch.Tensor: + """Performs a forward step for the Hyena model. + + Args: + model: The Hyena model + batch: Dictionary containing input batch data with keys: + - tokens: Input token IDs + - position_ids: Position IDs + - labels: Labels for loss computation + - loss_mask: Mask for loss computation + + Returns: + torch.Tensor: Output from the model forward pass + """ + forward_args = { + "input_ids": batch["tokens"], + "position_ids": batch["position_ids"], + # "labels": batch["labels"], + # "loss_mask": batch["loss_mask"], + } + + forward_args["attention_mask"] = None + if "cu_seqlens" in batch: + forward_args["packed_seq_params"] = get_packed_seq_params(batch) + return model(**forward_args) + + +def hyena_predict_data_step(dataloader_iter) -> dict[str, torch.Tensor]: + """Data step for the Hyena model prediction. Modified from the original gpt data step to include the seq_idx.""" + from megatron.core import parallel_state + + # Based on: https://github.com/NVIDIA/Megatron-LM/blob/main/pretrain_gpt.py#L87 + # https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/nlp/models/language_modeling/megatron_gpt_model.py#L828-L842 + + batch = next(dataloader_iter) + + _batch: dict + if isinstance(batch, tuple) and len(batch) == 3: + _batch = batch[0] + else: + _batch = batch + + required_device_keys = set() + required_host_keys = set() + + required_device_keys.add("attention_mask") + if "cu_seqlens" in _batch: + required_device_keys.add("cu_seqlens") + required_host_keys.add("cu_seqlens_argmin") + required_host_keys.add("max_seqlen") + + if parallel_state.is_pipeline_first_stage(): + required_device_keys.update(("tokens", "position_ids")) + if parallel_state.is_pipeline_last_stage(): + required_device_keys.update(("labels", "loss_mask", "seq_idx")) + + _batch_required_keys = {} + for key, val in _batch.items(): + if key in required_device_keys: + _batch_required_keys[key] = val.cuda(non_blocking=True) + elif key in required_host_keys: + _batch_required_keys[key] = val.cpu() + else: + _batch_required_keys[key] = None + + # slice batch along sequence dimension for context parallelism + output = get_batch_on_this_context_parallel_rank(_batch_required_keys) + + return output + + +class PredictDataModule(LightningDataModule): + """Create a dataloader for prediction.""" + + def __init__(self, dataset: torch.utils.data.Dataset, batch_size: int = 1): + """Create a dataloader for prediction.""" + super().__init__() + self.dataset = dataset + self.batch_size = batch_size + + def setup(self, stage: Optional[str] = None) -> None: + """Set up the dataloader.""" + pass + + def predict_dataloader(self): + """Create a dataloader for prediction.""" + return torch.utils.data.DataLoader(self.dataset, batch_size=self.batch_size, shuffle=False) + + +def predict( + fasta_path: Path, + ckpt_dir: str, + output_dir: Path, + tensor_parallel_size: int, + pipeline_model_parallel_size: int, + context_parallel_size: int, + model_size: str = "7b", + ckpt_format: CheckpointFormats = "torch_dist", + fp8: bool = False, + work_dir: Path | None = None, +): + """Inference workflow for Evo2. + + Returns: + None + """ + if work_dir is None: + work_dir = Path(tempfile.mkdtemp()) + output_dir.mkdir(parents=True, exist_ok=True) # Make sure the output directory exists, files will be written here. + model_parallel_size = tensor_parallel_size * pipeline_model_parallel_size * context_parallel_size + if model_parallel_size > torch.cuda.device_count(): + raise ValueError( + f"Requested model parallel size {model_parallel_size} is greater than the " + f"number of available CUDA devices {torch.cuda.device_count()}" + ) + # Create PTL trainer. + trainer = nl.Trainer( + accelerator="gpu", + devices=model_parallel_size, + strategy=nl.MegatronStrategy( + tensor_model_parallel_size=tensor_parallel_size, + pipeline_model_parallel_size=pipeline_model_parallel_size, + context_parallel_size=context_parallel_size, + pipeline_dtype=torch.bfloat16, + ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. + ckpt_save_optimizer=False, + ckpt_async_save=False, + save_ckpt_format=ckpt_format, + ckpt_load_strictness="log_all", + data_sampler=nl.MegatronDataSampler( + micro_batch_size=1, + global_batch_size=1, + seq_len=8192, + output_log=False, # this is needed for predict step to work + ), + ), + log_every_n_steps=1, + limit_val_batches=10, + num_sanity_val_steps=0, + callbacks=[ + PredictionWriter( + output_dir=output_dir, + write_interval="epoch", + batch_dim_key_defaults={"token_logits": 0}, + seq_dim_key_defaults={"token_logits": 1}, + ) + ], + plugins=nl.MegatronMixedPrecision( + precision="bf16-mixed", + params_dtype=torch.bfloat16, + fp8="hybrid" if fp8 else None, + fp8_amax_history_len=16 if fp8 else 1, + fp8_amax_compute_algo="max" if fp8 else "most_recent", + ), + ) + config = HYENA_MODEL_OPTIONS[model_size]( + forward_step_fn=hyena_predict_forward_step, data_step_fn=hyena_predict_data_step + ) + trainer.strategy._setup_optimizers = False + + nemo_logger = NeMoLogger(log_dir=work_dir) + nemo_logger.setup(trainer, resume_if_exists=True) + resume = nl.AutoResume( + resume_if_exists=True, + resume_ignore_no_checkpoint=False, + resume_past_end=False, + restore_config=nl.RestoreConfig( + path=str(ckpt_dir), # NeMo expects a string path. + load_model_state=True, + load_optim_state=False, + ), + ) + tokenizer = get_nmt_tokenizer("byte-level") + model = HyenaPredictor(config, tokenizer=tokenizer) + resume.setup(trainer, model) # this pulls weights from the starting checkpoint. + + dataset = SimpleFastaDataset(fasta_path, tokenizer) + datamodule = PredictDataModule(dataset) + trainer.predict(model, datamodule.predict_dataloader()) + dataset.write_idx_map( + output_dir + ) # Finally write out the index map so we can match the predictions to the original sequences. + + +def main(): + """Entrypoint for Evo2 prediction (single inference step, no new tokens).""" + args = parse_args() + predict( + fasta_path=args.fasta, + ckpt_dir=args.ckpt_dir, + tensor_parallel_size=args.tensor_parallel_size, + pipeline_model_parallel_size=args.pipeline_model_parallel_size, + context_parallel_size=args.context_parallel_size, + output_dir=args.output_dir, + model_size=args.model_size, + ckpt_format=args.ckpt_format, + fp8=args.fp8, + ) + + +if __name__ == "__main__": + main() diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py new file mode 100644 index 0000000000..3b57d9c66a --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py @@ -0,0 +1,97 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + +import glob +import json +import os +import subprocess +import sys + +import torch +from lightning.fabric.plugins.environments.lightning import find_free_network_port + +from bionemo.core.data.load import load +from bionemo.noodles.nvfaidx import NvFaidx +from bionemo.testing.data.fasta import ALU_SEQUENCE, create_fasta_file + + +def test_train_evo2_runs( + tmp_path, num_sequences: int = 5, target_sequence_lengths: list[int] = [3149, 3140, 1024, 3149, 3149] +): + """ + This test runs the `predict_evo2` command with mock data in a temporary directory. + It uses the temporary directory provided by pytest as the working directory. + The command is run in a subshell, and we assert that it returns an exit code of 0. + """ + fasta_file_path = tmp_path / "test.fasta" + create_fasta_file( + fasta_file_path, num_sequences, sequence_lengths=target_sequence_lengths, repeating_dna_pattern=ALU_SEQUENCE + ) + # Create a mock data directory. + open_port = find_free_network_port() + # a local copy of the environment + env = dict(**os.environ) + env["MASTER_PORT"] = str(open_port) + checkpoint_path = load("evo2/1b-8k:1.0", source="pbss") + # Build the command string. + # Note: The command assumes that `train_evo2` is in your PATH. + output_dir = tmp_path / "test_output" + command = ( + f"predict_evo2 --fasta {fasta_file_path} --ckpt-dir {checkpoint_path} " + f"--output-dir {output_dir} --model-size 1b --tensor-parallel-size 1 " + "--pipeline-model-parallel-size 1 --context-parallel-size 1" + ) + + # Run the command in a subshell, using the temporary directory as the current working directory. + result = subprocess.run( + command, + shell=True, # Use the shell to interpret wildcards (e.g. SDH*) + cwd=tmp_path, # Run in the temporary directory + capture_output=True, # Capture stdout and stderr for debugging + env=env, # Pass in the env where we override the master port. + text=True, # Decode output as text + ) + + # For debugging purposes, print the output if the test fails. + if result.returncode != 0: + sys.stderr.write("STDOUT:\n" + result.stdout + "\n") + sys.stderr.write("STDERR:\n" + result.stderr + "\n") + + # Assert that the command completed successfully. + assert result.returncode == 0, "train_evo2 command failed." + + # Assert that the output directory was created. + pred_files = glob.glob(os.path.join(output_dir, "predictions__rank_*.pt")) + assert len(pred_files) == 1, "Expected 1 prediction file (for this test), got {}".format(len(pred_files)) + with open(output_dir / "seq_idx_map.json", "r") as f: + seq_idx_map = json.load( + f + ) # This gives us the mapping from the sequence names to the indices in the predictions. + preds = torch.load(pred_files[0]) + assert isinstance(preds, dict) + assert "token_logits" in preds + assert "pad_mask" in preds + assert "seq_idx" in preds + assert len(preds["token_logits"]) == len(preds["pad_mask"]) == len(preds["seq_idx"]) == num_sequences + assert len(seq_idx_map) == num_sequences + fasta = NvFaidx(fasta_file_path) + for i, seq_name in enumerate(sorted(fasta.keys())): + expected_len = target_sequence_lengths[i] + idx = seq_idx_map[seq_name] # look up the out of order prediction index for this sequence. + assert preds["pad_mask"][idx].sum() == expected_len + assert preds["token_logits"][idx].shape == (max(target_sequence_lengths), 512) diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py index 6d25a30ae0..da203f816f 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/lightning.py @@ -82,7 +82,9 @@ def get_dtype_device(torch_object) -> Tuple[torch.dtype, torch.device]: # noqa: def batch_collator( batches: Optional[Union[Tuple[ReductionT], List[ReductionT]]], batch_dim: int = 0, + seq_dim: int = 1, batch_dim_key_defaults: dict[str, int] = {"token_logits": 1}, + seq_dim_key_defaults: dict[str, int] = {"token_logits": 0}, ) -> Optional[ReductionT]: """Takes a sequence of batches and collates them into a single batch. @@ -106,9 +108,14 @@ def batch_collator( batches (Optional[Sequence[ReductionT]]): sequence of batches to collate into a single batch. batch_dim: If you know that the batch dim for the batch you are concatenating is not the 0th dimension (for example it is sequence first) then supply that dimension. + seq_dim: If you know that the sequence dim for the batch you are concatenating is not the 1st dimension (for + example it is sequence first) then supply that dimension. This is used for padding to the max length. batch_dim_key_defaults (dictionary of keys to integers): If your batch is a dictionary and you know that some keys have non-standard (0) batch dimensions, supply those here. By default "token_logits" has batch dim 1 and otherwise all keys are assumed to have batch dim 0. + seq_dim_key_defaults (dictionary of keys to integers): If your batch is a dictionary and you know that some + keys have non-standard (1) sequence dimensions, supply those here. By default "token_logits" has seq dim 0 + and otherwise all keys are assumed to have seq dim 1. Returns: A single batch of the same type as the elements of your input sequence. @@ -118,28 +125,58 @@ def batch_collator( case [None, *_]: return None case [Tensor(), *_]: - return torch.cat(batches, dim=batch_dim) + # First shortcut if all tensors are 1D (they have at least one batch dim, and it must be at 0) + if len(batches) > 0 and isinstance(batches[0], Tensor) and batches[0].ndim == 1: + return torch.cat(batches, dim=0) + # Find max sequence length across all tensors + max_seq_len = max(batch.size(seq_dim) for batch in batches) + # Pad each tensor to max length along seq_dim + padded_batches = [] + for batch in batches: + # Initialize padding tuple - needs 2 values per dim, starting from last dim + # e.g. for 3D tensor: [left_pad_dim2, right_pad_dim2, left_pad_dim1, right_pad_dim1, left_pad_dim0, right_pad_dim0] + pad_size = [0] * (2 * batch.ndim) + # Calculate padding needed at end of sequence dimension + pad_amount = max_seq_len - batch.size(seq_dim) + # Pad end of sequence dimension by putting padding amount in correct position + # For seq_dim=1 in 3D tensor: [0, 0, 0, pad_amount, 0, 0] + pad_size[2 * (batch.ndim - 1 - seq_dim) + 1] = pad_amount + padded_batch = torch.nn.functional.pad(batch, tuple(pad_size)) + padded_batches.append(padded_batch) + padded_batch = torch.cat(padded_batches, dim=batch_dim) + assert padded_batch.size(seq_dim) == max_seq_len + return padded_batch # Next 3 calls are the recursive calls into the sub-structures of the batch. We handle dictionaries, tuples, and lists case [dict(), *_]: return { key: batch_collator( [batch[key] for batch in batches], - batch_dim=batch_dim_key_defaults.get(key, 0), + batch_dim=batch_dim_key_defaults.get(key, batch_dim), + seq_dim=seq_dim_key_defaults.get(key, seq_dim), batch_dim_key_defaults=batch_dim_key_defaults, + seq_dim_key_defaults=seq_dim_key_defaults, ) for key in batches[0] } case [tuple(), *_]: return tuple( batch_collator( - [batch[i] for batch in batches], batch_dim=batch_dim, batch_dim_key_defaults=batch_dim_key_defaults + [batch[i] for batch in batches], + batch_dim=batch_dim, + seq_dim=seq_dim, + batch_dim_key_defaults=batch_dim_key_defaults, + seq_dim_key_defaults=seq_dim_key_defaults, ) for i in range(len(batches[0])) ) case [list(), *_]: return [ batch_collator( - [batch[i] for batch in batches], batch_dim=batch_dim, batch_dim_key_defaults=batch_dim_key_defaults + [batch[i] for batch in batches], + batch_dim=batch_dim, + seq_dim=seq_dim, + batch_dim_key_defaults=batch_dim_key_defaults, + seq_dim_key_defaults=seq_dim_key_defaults, ) for i in range(len(batches[0])) ] diff --git a/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py b/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py index 9f835dff2e..9e703111d8 100644 --- a/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py +++ b/sub-packages/bionemo-llm/src/bionemo/llm/utils/callbacks.py @@ -31,16 +31,25 @@ class PredictionWriter(BasePredictionWriter, pl.Callback): """A callback that writes predictions to disk at specified intervals during training.""" - def __init__(self, output_dir: str | os.PathLike, write_interval: IntervalT): + def __init__( + self, + output_dir: str | os.PathLike, + write_interval: IntervalT, + batch_dim_key_defaults: dict[str, int] | None = None, + seq_dim_key_defaults: dict[str, int] | None = None, + ): """Initializes the callback. Args: output_dir: The directory where predictions will be written. write_interval: The interval at which predictions will be written. (batch, epoch) - + batch_dim_key_defaults: The default batch dimension for each key, if different from the standard 0. + seq_dim_key_defaults: The default sequence dimension for each key, if different from the standard 1. """ super().__init__(write_interval) self.output_dir = str(output_dir) + self.batch_dim_key_defaults = batch_dim_key_defaults + self.seq_dim_key_defaults = seq_dim_key_defaults def write_on_batch_end( self, @@ -92,9 +101,18 @@ def write_on_epoch_end( result_path = os.path.join(self.output_dir, f"predictions__rank_{trainer.global_rank}.pt") # collate multiple batches / ignore empty ones - prediction = batch_collator([item for item in predictions if item is not None]) + collate_kwargs = {} + if self.batch_dim_key_defaults is not None: + collate_kwargs["batch_dim_key_defaults"] = self.batch_dim_key_defaults + if self.seq_dim_key_defaults is not None: + collate_kwargs["seq_dim_key_defaults"] = self.seq_dim_key_defaults + prediction = batch_collator([item for item in predictions if item is not None], **collate_kwargs) # batch_indices is not captured due to a lightning bug when return_predictions = False # we use input IDs in the prediction to map the result to input torch.save(prediction, result_path) - logging.info(f"Inference predictions are stored in {result_path}\n{prediction.keys()}") + if isinstance(prediction, dict): + keys = prediction.keys() + else: + keys = "tensor" + logging.info(f"Inference predictions are stored in {result_path}\n{keys}") diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py b/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py index 1559430e47..7285edb239 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/data/fasta.py @@ -28,28 +28,35 @@ def create_fasta_file( fasta_file_path: Path, num_sequences: int, - sequence_length: int, + sequence_length: int | None = None, + sequence_lengths: list[int] | None = None, repeating_dna_pattern: str = ALU_SEQUENCE, max_line_length: int = 80, ) -> Path: """Creates a fasta file with the given number of sequences, sequence length, and repeating dna pattern. Each contig uses a shifted version of the repeating pattern.""" + assert sequence_length is not None or sequence_lengths is not None with open(fasta_file_path, "w") as f: + if sequence_lengths is not None: + assert len(sequence_lengths) == num_sequences + else: + assert sequence_length is not None + sequence_lengths: list[int] = [sequence_length] * num_sequences for i in range(num_sequences): # get the repeating pattern shifted by i for this contig repeat_pattern_for_contig = repeating_dna_pattern[i:] + repeating_dna_pattern[:i] # repeat the pattern enough times to reach the desired sequence length - if sequence_length <= len(repeat_pattern_for_contig): - contig_output = repeat_pattern_for_contig[:sequence_length] + if sequence_lengths[i] <= len(repeat_pattern_for_contig): + contig_output = repeat_pattern_for_contig[: sequence_lengths[i]] else: # Calculate how many complete repeats we need - num_repeats = sequence_length // len(repeat_pattern_for_contig) - remainder = sequence_length % len(repeat_pattern_for_contig) + num_repeats = sequence_lengths[i] // len(repeat_pattern_for_contig) + remainder = sequence_lengths[i] % len(repeat_pattern_for_contig) contig_output = repeat_pattern_for_contig * num_repeats + repeat_pattern_for_contig[:remainder] # verify the length of the contig is as expected - assert len(contig_output) == sequence_length + assert len(contig_output) == sequence_lengths[i] # Fold the contig output into lines of max_line_length contig_output = "\n".join( - contig_output[i : i + max_line_length] for i in range(0, sequence_length, max_line_length) + contig_output[i : i + max_line_length] for i in range(0, sequence_lengths[i], max_line_length) ) # write to the fasta file with the actual contig_output, not the repeating pattern f.write(f">contig_{i}\n{contig_output}\n") diff --git a/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py b/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py index 9953e2ade6..96c9f32c1d 100644 --- a/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py +++ b/sub-packages/bionemo-testing/tests/bionemo/testing/data/test_fasta.py @@ -22,14 +22,20 @@ @pytest.mark.parametrize("target_sequence_length, num_sequences", [(123, 3), (1234, 2), (12345, 1)]) def test_created_fasta_file_has_expected_length( - tmp_path: Path, num_sequences: int, target_sequence_length: int + tmp_path: Path, + target_sequence_length: int, + num_sequences: int, ) -> None: fasta_file_path = tmp_path / "test.fasta" create_fasta_file(fasta_file_path, num_sequences, target_sequence_length, repeating_dna_pattern=ALU_SEQUENCE) assert fasta_file_path.stat().st_size > 0 idx = NvFaidx(fasta_file_path) + assert len(idx) == num_sequences + n_out = 0 for i, (seq_name, sequence) in enumerate(sorted(idx.items())): assert seq_name == f"contig_{i}" assert len(sequence) == target_sequence_length if i == 0: assert ALU_SEQUENCE[:target_sequence_length] in sequence + n_out += 1 + assert n_out == num_sequences From d9e495233db118a079e3a3ed63e6489bb2030d00 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Mon, 24 Feb 2025 13:55:12 -0800 Subject: [PATCH 092/140] bump NeMo commit Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 9111382886..d280df1c75 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 91113828868576a646f217bc8ee6f83d860af4af +Subproject commit d280df1c756de6a4b55bd016f2e49eeee9dc4008 From b148750e0304aa28654715f188cdda40e61de69a Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Mon, 24 Feb 2025 22:59:10 +0000 Subject: [PATCH 093/140] Fix multipart download naming in nemo Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index d280df1c75..fe99a498a4 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit d280df1c756de6a4b55bd016f2e49eeee9dc4008 +Subproject commit fe99a498a4acbcde757d2c2834e748e73783a69a From ba1d9bf6c600bd807b6e6508cbbdc908b436024b Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Mon, 24 Feb 2025 23:17:21 +0000 Subject: [PATCH 094/140] Update docs for checkpoint conversion Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md index 10ed075afd..3a2936058c 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/README.md @@ -6,7 +6,7 @@ This library contains helper scripts for converting checkpoint formats for Evo2. To convert a single PyTorch or ZeRO-1 checkpoints (`.pt`) into NeMo2 format, run the following command: ``` -python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/torch2nemo.py --model-path <CKPT_FILE> --output-dir <OUTPUT_DIR> --model-size <MODEL_SIZE> --ckpt-format <CONVERTED_CKPT_FORMAT> +python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py --model-path <CKPT_FILE> --output-dir <OUTPUT_DIR> --model-size <MODEL_SIZE> --ckpt-format <CONVERTED_CKPT_FORMAT> ``` where `--model-size` can be set to `7b` or `40b` (or their `_arc_1m` variants with modified GLU dimensions) and `--ckpt-format` can be set to `torch_dist` or `zarr`. @@ -36,7 +36,7 @@ interleaved_hyena_7b_fix_shape ## Converting ZeRO-1 MP{N} to ZeRO-1 MP1 -To convert sharded (MP>1) ZeRO-1 checkpoints to un-sharded (MP1) checkpoints (or any order of model parallelism) compatible with the `torch2nemo.py` conversion script, you can run the following command: +To convert sharded (MP>1) ZeRO-1 checkpoints to un-sharded (MP1) checkpoints (or any order of model parallelism) compatible with the `convert_to_nemo.py` conversion script, you can run the following command: ``` python sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_checkpoint_model_parallel_evo2.py --source_dir <CKPT_DIR> --output_dir <OUTPUT_DIR> --mp_size <TARGET_MODEL_PARALLEL_SIZE> ``` From 0af3e0a7731191473451f6b68fc0190335a66a82 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Mon, 24 Feb 2025 23:57:18 +0000 Subject: [PATCH 095/140] shrink tests down to 1b case --- 3rdparty/NeMo | 2 +- .../src/bionemo/core/data/resources/evo2.yaml | 23 +++++++++++++++++++ .../tests/bionemo/evo2/run/test_infer.py | 2 +- .../tests/bionemo/evo2/run/test_inference.py | 2 +- .../tests/bionemo/evo2/test_evo2.py | 8 +++---- 5 files changed, 30 insertions(+), 7 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index fe99a498a4..fa3fac04a8 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit fe99a498a4acbcde757d2c2834e748e73783a69a +Subproject commit fa3fac04a8736d8f2f492c77e58c99c2c630ddcd diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index 97322d102a..368d88218e 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -41,3 +41,26 @@ TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT ATAATTTTAATTTATATAAT + +- tag: 1b-8k-nofp8-te-goldvalue-testdata-A6000:1.0 + ngc: null + ngc_registry: resource + pbss: "s3://bionemo-ci/test_data/evo2/final_1b_no_fp8_golden_value_A6000.pt" + sha256: 289dc1c4c919162b467c7f068d27fa16e9670cb4a9fd15696198c6a6aac2fa21 # pragma: allowlist secret + owner: John St John <jstjohn@nvidia.com> + description: > + Test data for Evo2 inference. Built using the `evo2/1b-8k:1.0` checkpoint on an A6000 GPU and the following DNA: + GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAG + ATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAA + CCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGG + TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA + CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT + ATAATTTTAATTTATATAAT + The following command was used to get logits after adding the above to a fasta file: + ```bash + predict_evo2 \ + --fasta test_seq.fasta \ + --ckpt-dir path_to_1b_ckpt \ + --output-dir new_gs_a6000 \ + --model-size 1b + ``` diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index 4919a10932..5347ab170a 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -47,7 +47,7 @@ def test_run_infer(): ) # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/7b-8k:1.0", source="pbss") + checkpoint_path = load("evo2/1b-8k:1.0", source="pbss") with clean_parallel_state_context(): infer( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index a8860a5196..4a06a66b13 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -75,7 +75,7 @@ def test_infer_model_generates_expected_single_token_output(): top_p = 0.0 max_new_tokens = 1 # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/7b-8k:1.0", source="pbss") + checkpoint_path = load("evo2/1b-8k:1.0", source="pbss") with clean_parallel_state_context(): results = generate( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index bae566810b..3bf7bd53b5 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -68,9 +68,9 @@ def load_weights_sharded_inplace_nemo2_to_mcore( def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): try: # TODO (dorotat) remove PBSS source once the model is available on NGC - evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k:1.0", source="pbss") / "weights" + evo2_1b_checkpoint_weights: Path = load("evo2/1b-8k:1.0", source="pbss") / "weights" # TODO (dorotat) remove PBSS source once the model is available on NGC - gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0", source="pbss") + gold_standard_no_fp8 = load("evo2/1b-8k-nofp8-te-goldvalue-testdata-A6000:1.0", source="pbss") except ValueError as e: if e.args[0].endswith("does not have an NGC URL."): raise ValueError( @@ -80,13 +80,13 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): else: raise e with distributed_model_parallel_state(), torch.no_grad(): - hyena_config = llm.Hyena7bConfig(use_te=True, seq_length=seq_len) + hyena_config = llm.Hyena1bConfig(use_te=True, seq_length=seq_len) tokenizer = get_nmt_tokenizer( "byte-level", ) raw_megatron_model = hyena_config.configure_model(tokenizer).eval().cuda() device = raw_megatron_model.parameters().__next__().device - load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "torch_dist") + load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_1b_checkpoint_weights, {}, "torch_dist") model = Float16Module(hyena_config, raw_megatron_model) input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAAT" input_ids = torch.tensor(tokenizer.text_to_ids(input_seq)).int().unsqueeze(0).to(device) From c5e42d8561f8002f939d087e4347da7297facabc Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 01:17:22 +0000 Subject: [PATCH 096/140] add end to end fine-tuning tutorial Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/fine-tuning-tutorial.ipynb | 999 ++++++++++++++++++ .../src/bionemo/evo2/data/preprocess.py | 23 +- 2 files changed, 1018 insertions(+), 4 deletions(-) create mode 100644 docs/docs/user-guide/examples/bionemo-evo2/fine-tuning-tutorial.ipynb diff --git a/docs/docs/user-guide/examples/bionemo-evo2/fine-tuning-tutorial.ipynb b/docs/docs/user-guide/examples/bionemo-evo2/fine-tuning-tutorial.ipynb new file mode 100644 index 0000000000..f72a70b614 --- /dev/null +++ b/docs/docs/user-guide/examples/bionemo-evo2/fine-tuning-tutorial.ipynb @@ -0,0 +1,999 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fine-tuning tutorial for Evo2\n", + "This tutorial goes through a toy fine-tuning example end to end starting with a fasta and continuing training a hugging\n", + "face checkpoint on this user defined dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Clean up any prior runs\n", + "!rm -rf preprocessed_data\n", + "!rm -rf preatraining_demo\n", + "!rm -rf nemo2_evo2_1b_8k\n", + "!rm -rf pretraining_demo\n", + "!rm -rf training_data_config.yaml\n", + "!rm -rf preprocess_config.yaml\n", + "!rm -f chr17.fa.gz\n", + "!rm -f chr18.fa.gz\n", + "!rm -f chr21.fa.gz\n", + "!rm -f chr17.fa\n", + "!rm -f chr18.fa\n", + "!rm -f chr21.fa\n", + "!rm -f chr17_18_21.fa\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2025-02-25 01:11:46-- https://hgdownload.soe.ucsc.edu/goldenpath/hg38/chromosomes/chr17.fa.gz\n", + "Resolving hgdownload.soe.ucsc.edu (hgdownload.soe.ucsc.edu)... 128.114.119.163\n", + "Connecting to hgdownload.soe.ucsc.edu (hgdownload.soe.ucsc.edu)|128.114.119.163|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 25930986 (25M) [application/x-gzip]\n", + "Saving to: ‘chr17.fa.gz.2’\n", + "\n", + "chr17.fa.gz.2 100%[===================>] 24.73M 82.3MB/s in 0.3s \n", + "\n", + "2025-02-25 01:11:49 (82.3 MB/s) - ‘chr17.fa.gz.2’ saved [25930986/25930986]\n", + "\n", + "--2025-02-25 01:11:49-- https://hgdownload.soe.ucsc.edu/goldenpath/hg38/chromosomes/chr18.fa.gz\n", + "Resolving hgdownload.soe.ucsc.edu (hgdownload.soe.ucsc.edu)... 128.114.119.163\n", + "Connecting to hgdownload.soe.ucsc.edu (hgdownload.soe.ucsc.edu)|128.114.119.163|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 25154367 (24M) [application/x-gzip]\n", + "Saving to: ‘chr18.fa.gz.1’\n", + "\n", + "chr18.fa.gz.1 100%[===================>] 23.99M 54.6MB/s in 0.4s \n", + "\n", + "2025-02-25 01:11:50 (54.6 MB/s) - ‘chr18.fa.gz.1’ saved [25154367/25154367]\n", + "\n", + "--2025-02-25 01:11:50-- https://hgdownload.soe.ucsc.edu/goldenpath/hg38/chromosomes/chr21.fa.gz\n", + "Resolving hgdownload.soe.ucsc.edu (hgdownload.soe.ucsc.edu)... 128.114.119.163\n", + "Connecting to hgdownload.soe.ucsc.edu (hgdownload.soe.ucsc.edu)|128.114.119.163|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 12709705 (12M) [application/x-gzip]\n", + "Saving to: ‘chr21.fa.gz.1’\n", + "\n", + "chr21.fa.gz.1 100%[===================>] 12.12M 67.5MB/s in 0.2s \n", + "\n", + "2025-02-25 01:11:50 (67.5 MB/s) - ‘chr21.fa.gz.1’ saved [12709705/12709705]\n", + "\n" + ] + } + ], + "source": [ + "import os\n", + "concat_path = \"chr17_18_21.fa\"\n", + "if not os.path.exists(concat_path):\n", + " !wget https://hgdownload.soe.ucsc.edu/goldenpath/hg38/chromosomes/chr17.fa.gz\n", + " !wget https://hgdownload.soe.ucsc.edu/goldenpath/hg38/chromosomes/chr18.fa.gz\n", + " !wget https://hgdownload.soe.ucsc.edu/goldenpath/hg38/chromosomes/chr21.fa.gz\n", + " !zcat chr17.fa.gz > chr17.fa\n", + " !zcat chr18.fa.gz > chr18.fa\n", + " !zcat chr21.fa.gz > chr21.fa\n", + " !cat chr17.fa chr18.fa chr21.fa > chr17_18_21.fa\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "full_fasta_path = os.path.abspath(concat_path)\n", + "output_dir = os.path.abspath(\"preprocessed_data\")\n", + "output_yaml = f\"\"\"\n", + "- datapaths: [\"{full_fasta_path}\"]\n", + " output_dir: \"{output_dir}\"\n", + " output_prefix: chr17_18_21_uint8_distinct\n", + " train_split: 0.9\n", + " valid_split: 0.05\n", + " test_split: 0.05\n", + " overwrite: True\n", + " embed_reverse_complement: true\n", + " random_reverse_complement: 0.0\n", + " random_lineage_dropout: 0.0\n", + " include_sequence_id: false\n", + " transcribe: \"back_transcribe\"\n", + " force_uppercase: false\n", + " indexed_dataset_dtype: \"uint8\"\n", + " tokenizer_type: \"Byte-Level\"\n", + " vocab_file: null\n", + " vocab_size: null\n", + " merges_file: null\n", + " pretrained_tokenizer_model: null\n", + " special_tokens: null\n", + " fast_hf_tokenizer: true\n", + " append_eod: true\n", + " enforce_sample_length: null\n", + " ftfy: false\n", + " workers: 1\n", + " preproc_concurrency: 100000\n", + " chunksize: 25\n", + " drop_empty_sequences: true\n", + " nnn_filter: false # If you split your fasta on NNN (in human these are contigs), then you should set this to true.\n", + " seed: 12342 # Not relevant because we are not using random reverse complement or lineage dropout.\n", + "\"\"\"\n", + "with open(\"preprocess_config.yaml\", \"w\") as f:\n", + " print(output_yaml, file=f)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + "\n", + "[NeMo I 2025-02-25 01:12:03 nemo_logging:393] Using byte-level tokenization\n", + "[NeMo I 2025-02-25 01:12:03 nemo_logging:393] Created temporary binary datasets: /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_train.bin.tmp /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_val.bin.tmp /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_test.bin.tmp\n", + "[NeMo I 2025-02-25 01:12:32 nemo_logging:393] Average preprocessing time per sequence: 1.337763786315918\n", + "[NeMo I 2025-02-25 01:12:32 nemo_logging:393] Average indexing time per sequence: 3.9368359645207724\n", + "[NeMo I 2025-02-25 01:12:32 nemo_logging:393] Number of sequences processed: 6\n", + "[NeMo I 2025-02-25 01:12:32 nemo_logging:393] Finished preprocessing chr17_18_21_uint8_distinct ([PosixPath('/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/chr17_18_21.fa')]) in 28.605 seconds with 1 workers.\n" + ] + } + ], + "source": [ + "!preprocess_evo2 --config preprocess_config.yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 402M\n", + "-rw-r--r-- 1 ubuntu ubuntu 159M Feb 25 01:12 chr17_18_21_uint8_distinct_byte-level_test.bin\n", + "-rw-r--r-- 1 ubuntu ubuntu 82 Feb 25 01:12 chr17_18_21_uint8_distinct_byte-level_test.idx\n", + "-rw-r--r-- 1 ubuntu ubuntu 154M Feb 25 01:12 chr17_18_21_uint8_distinct_byte-level_train.bin\n", + "-rw-r--r-- 1 ubuntu ubuntu 82 Feb 25 01:12 chr17_18_21_uint8_distinct_byte-level_train.idx\n", + "-rw-r--r-- 1 ubuntu ubuntu 90M Feb 25 01:12 chr17_18_21_uint8_distinct_byte-level_val.bin\n", + "-rw-r--r-- 1 ubuntu ubuntu 82 Feb 25 01:12 chr17_18_21_uint8_distinct_byte-level_val.idx\n" + ] + } + ], + "source": [ + "!ls -lh preprocessed_data/" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[NeMo W 2025-02-25 01:12:44 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Using byte-level tokenization\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: False\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/lightning/pytorch/trainer/setup.py:177: GPU available but not used. You can set it by doing `Trainer(accelerator='gpu')`.\n", + "\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Rank 0 has embedding rank: 0\n", + "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", + "distributed_backend=gloo\n", + "All distributed processes registered. Starting with 1 processes\n", + "----------------------------------------------------------------------------------------------------\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/lightning/pytorch/trainer/trainer.py:1090: `trainer.init_module` cannot fully support proper instantiation of your model with the `MegatronStrategy` strategy. Please instantiate your model inside the`LightningModule.configure_model` hook instead\n", + "\n", + "[NeMo I 2025-02-25 01:12:48 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[WARNING | megatron.core.tensor_parallel.random]: CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:12:49 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[NeMo W 2025-02-25 01:12:59 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[NeMo I 2025-02-25 01:13:03 nemo_logging:393] Converted Hyena model to Nemo, model saved to nemo2_evo2_1b_8k\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/torch/__init__.py:1074: FutureWarning: `torch.distributed.reduce_op` is deprecated, please use `torch.distributed.ReduceOp` instead\n", + " return isinstance(obj, torch.Tensor)\n", + "\n" + ] + } + ], + "source": [ + "!evo2_convert_to_nemo2 \\\n", + " --model-path hf://arcinstitute/savanna_evo2_1b_base \\\n", + " --model-size 1b --output-dir nemo2_evo2_1b_8k" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "output_pfx = str(Path(os.path.abspath(\"preprocessed_data\"))/\"chr17_18_21_uint8_distinct_byte-level\")\n", + "output_yaml = f\"\"\"\n", + "- dataset_prefix: {output_pfx}_train\n", + " dataset_split: train\n", + " dataset_weight: 1.0\n", + "- dataset_prefix: {output_pfx}_val\n", + " dataset_split: validation\n", + " dataset_weight: 1.0\n", + "- dataset_prefix: {output_pfx}_test\n", + " dataset_split: test\n", + " dataset_weight: 1.0\n", + "\"\"\"\n", + "with open(\"training_data_config.yaml\", \"w\") as f:\n", + " print(output_yaml, file=f)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[NeMo W 2025-02-25 01:13:17 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Using byte-level tokenization\n", + "[WARNING | py.warnings ]: /workspaces/bionemo-framework/3rdparty/NeMo/nemo/collections/llm/gpt/data/pre_training.py:190: UserWarning: split='900,50,50' will be ignored since datasets are being created from 3 separate distributions.\n", + " warnings.warn(\n", + "\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: Trainer already configured with model summary callbacks: [<class 'lightning.pytorch.callbacks.rich_model_summary.RichModelSummary'>]. Skipping setting a default `ModelSummary` callback.\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[NeMo W 2025-02-25 01:13:19 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Experiments will be logged at pretraining_demo/default\n", + "[NeMo W 2025-02-25 01:13:19 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to pretraining_demo/dummy\n", + "[NeMo W 2025-02-25 01:13:19 nemo_logging:405] There were no checkpoints found in checkpoint_dir or no checkpoint folder at checkpoint_dir :pretraining_demo. Training from scratch.\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Fixing mis-match between ddp-config & mcore-optimizer config\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-02-25 01:13:19 nemo_logging:393] Rank 0 has embedding rank: 0\n", + "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", + "distributed_backend=nccl\n", + "All distributed processes registered. Starting with 1 processes\n", + "----------------------------------------------------------------------------------------------------\n", + "\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Building Evo2Dataset splits with sizes=[200, 120, 2] and config=GPTDatasetConfig(random_seed=1234, sequence_length=1024, blend=None, blend_per_split=[(['/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_train'], [1.0]), (['/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_val'], [1.0]), (['/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_test'], [1.0])], split=None, split_matrix=None, num_dataset_builder_threads=1, path_to_cache=None, mmap_bin_files=True, mock=False, tokenizer=<nemo.collections.common.tokenizers.bytelevel_tokenizers.ByteLevelTokenizer object at 0x7e5db038ffe0>, reset_position_ids=False, reset_attention_mask=False, eod_mask_loss=False, create_attention_mask=False, drop_last_partial_validation_sequence=True, add_extra_token_to_sequence=True, s3_cache_path=None)\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Load the _IndexReader from /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_train.idx\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the sequence lengths\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the sequence pointers\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the document indices\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of sequences: 2\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of documents: 2\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Build and save the Evo2Dataset train indices\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of samples: 156979\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of epochs: 1\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Load the _IndexReader from /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_val.idx\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the sequence lengths\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the sequence pointers\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the document indices\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of sequences: 2\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of documents: 2\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Build and save the Evo2Dataset valid indices\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of samples: 91230\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of epochs: 1\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Load the _IndexReader from /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/preprocessed_data/chr17_18_21_uint8_distinct_byte-level_test.idx\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the sequence lengths\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the sequence pointers\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] \tExtract the document indices\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of sequences: 2\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of documents: 2\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Build and save the Evo2Dataset test indices\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of samples: 162612\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] > total number of epochs: 1\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/lightning/pytorch/callbacks/model_checkpoint.py:654: Checkpoint directory /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo exists and is not empty.\n", + "\n", + "[NeMo I 2025-02-25 01:13:20 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-02-25 01:13:20 random:220] CPU RNG state changed within GPU RNG context\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "[NeMo I 2025-02-25 01:13:20 nemo_logging:393] Copying Trainer's 'max_steps' (100) to LR scheduler's 'max_steps'.\n", + "[NeMo I 2025-02-25 01:13:20 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", + "[NeMo I 2025-02-25 01:13:20 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 1108204800\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=True, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=True, fp8_param_gather=False)\n", + "[NeMo I 2025-02-25 01:13:20 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + " Params for bucket 1 (1108204800 elements):\n", + " \tmodule.decoder.layers.23.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.15.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.1.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.21.mixer.dense.weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.16.mixer.dense.weight\n", + " \tmodule.decoder.layers.13.mixer.dense.bias\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.4.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.12.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.21.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.8.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.6.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.14.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.23.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.20.mixer.dense.weight\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.dense.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.23.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.7.mixer.dense.bias\n", + " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.22.mixer.dense.weight\n", + " \tmodule.decoder.layers.14.mixer.dense.weight\n", + " \tmodule.decoder.layers.12.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.9.mixer.dense.weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.15.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.14.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.0.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.13.mixer.dense.weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.6.mixer.dense.bias\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.15.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.5.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mixer.dense.weight\n", + " \tmodule.decoder.layers.0.mixer.dense.weight\n", + " \tmodule.decoder.layers.23.mixer.dense.bias\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.19.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.15.mixer.dense.weight\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.22.mixer.dense.bias\n", + " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.12.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.18.mixer.dense.weight\n", + " \tmodule.decoder.layers.15.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.8.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.22.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.18.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.7.mixer.dense.weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.4.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.11.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.24.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.22.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.20.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.12.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.7.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.15.mixer.dense.bias\n", + " \tmodule.decoder.layers.13.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.18.mixer.dense.bias\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.dense.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.11.mixer.dense.weight\n", + " \tmodule.decoder.layers.9.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.6.mixer.dense.weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.21.mixer.dense.bias\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", + " \tmodule.embedding.word_embeddings.weight\n", + " \tmodule.decoder.layers.23.mixer.dense.weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.16.mixer.dense.bias\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.11.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.8.mixer.dense.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.1.mixer.dense.weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", + " \tmodule.decoder.final_norm.weight\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.18.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.15.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.20.mixer.dense.bias\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense.weight\n", + " \tmodule.decoder.layers.11.mixer.dense.bias\n", + " \tmodule.decoder.layers.7.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.19.mixer.dense.bias\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.14.mixer.dense.bias\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.4.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.17.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.9.mixer.dense.bias\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.5.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.21.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mixer.dense.bias\n", + " \tmodule.decoder.layers.6.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.22.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.4.mixer.dense.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", + "[NeMo I 2025-02-25 01:13:20 utils:302] Setting up optimizer with config OptimizerConfig(optimizer='adam', lr=0.0001, min_lr=None, decoupled_lr=None, decoupled_min_lr=None, weight_decay=0.01, fp16=False, bf16=True, params_dtype=torch.bfloat16, use_precision_aware_optimizer=False, main_grads_dtype=torch.float32, main_params_dtype=torch.float32, exp_avg_dtype=torch.float32, exp_avg_sq_dtype=torch.float32, loss_scale=None, initial_loss_scale=4294967296, min_loss_scale=1.0, loss_scale_window=1000, hysteresis=2, adam_beta1=0.9, adam_beta2=0.95, adam_eps=1e-08, sgd_momentum=0.9, use_distributed_optimizer=True, overlap_param_gather_with_optimizer_step=False, optimizer_cpu_offload=False, optimizer_offload_fraction=0.0, use_torch_optimizer_for_cpu_offload=False, overlap_cpu_optimizer_d2h_h2d=False, pin_cpu_grads=True, pin_cpu_params=True, clip_grad=1.0, log_num_zeros_in_grad=False, barrier_with_L1_time=False, timers=None, config_logger_dir='')\n", + "[NeMo I 2025-02-25 01:13:20 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=True)\n", + "[WARNING | py.warnings ]: /workspaces/bionemo-framework/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", + " checkpoint.load_state_dict(\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/torch/distributed/checkpoint/planner_helpers.py:316: FutureWarning: Please use DTensor instead and we are deprecating ShardedTensor.\n", + " device = getattr(value, \"device\", None)\n", + "\n", + "[NeMo I 2025-02-25 01:13:21 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=True)\n", + "[NeMo I 2025-02-25 01:13:21 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=True), cleaning up.\n", + "┏━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓\n", + "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\n", + "┡━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩\n", + "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ module │ DDP │ 1.1 B │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m│ module.module │ Float16Module │ 1.1 B │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m│ module.module.module │ HyenaModel │ 1.1 B │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m│ module.module.module.embedding │ LanguageModelEmb… │ 983 K │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m│ module.module.module.rotary_pos_emb │ RotaryEmbedding │ 0 │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m5\u001b[0m\u001b[2m \u001b[0m│ module.module.module.decoder │ HyenaStack │ 1.1 B │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m6\u001b[0m\u001b[2m \u001b[0m│ module.module.module.output_layer │ ColumnParallelLi… │ 0 │ train │\n", + "└───┴─────────────────────────────────────┴───────────────────┴────────┴───────┘\n", + "\u001b[1mTrainable params\u001b[0m: 1.1 B \n", + "\u001b[1mNon-trainable params\u001b[0m: 0 \n", + "\u001b[1mTotal params\u001b[0m: 1.1 B \n", + "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 4.4 K \n", + "\u001b[1mModules in train mode\u001b[0m: 356 \n", + "\u001b[1mModules in eval mode\u001b[0m: 0 \n", + "[NeMo W 2025-02-25 01:13:30 rerun_state_machine:1264] Implicit initialization of Rerun State Machine!\n", + "[NeMo W 2025-02-25 01:13:30 rerun_state_machine:239] RerunStateMachine initialized in mode RerunMode.DISABLED\n", + "Training epoch 0, iteration 0/99 | lr: 0 | global_batch_size: 2 | global_step: 0 | reduced_train_loss: 1.246 | train_step_timing in s: 9.091\n", + "Training epoch 0, iteration 1/99 | lr: 2e-05 | global_batch_size: 2 | global_step: 1 | reduced_train_loss: 1.322 | train_step_timing in s: 1.682 | consumed_samples: 4\n", + "Training epoch 0, iteration 2/99 | lr: 4e-05 | global_batch_size: 2 | global_step: 2 | reduced_train_loss: 1.217 | train_step_timing in s: 0.4297 | consumed_samples: 6\n", + "Training epoch 0, iteration 3/99 | lr: 6e-05 | global_batch_size: 2 | global_step: 3 | reduced_train_loss: 1.277 | train_step_timing in s: 0.4295 | consumed_samples: 8\n", + "Training epoch 0, iteration 4/99 | lr: 8e-05 | global_batch_size: 2 | global_step: 4 | reduced_train_loss: 1.3 | train_step_timing in s: 0.4304 | consumed_samples: 10\n", + "Training epoch 0, iteration 5/99 | lr: 0.0001 | global_batch_size: 2 | global_step: 5 | reduced_train_loss: 1.309 | train_step_timing in s: 0.4296 | consumed_samples: 12\n", + "Training epoch 0, iteration 6/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 6 | reduced_train_loss: 1.062 | train_step_timing in s: 0.4301 | consumed_samples: 14\n", + "Training epoch 0, iteration 7/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 7 | reduced_train_loss: 1.287 | train_step_timing in s: 0.4293 | consumed_samples: 16\n", + "Training epoch 0, iteration 8/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 8 | reduced_train_loss: 1.292 | train_step_timing in s: 0.4287 | consumed_samples: 18\n", + "Training epoch 0, iteration 9/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 9 | reduced_train_loss: 1.274 | train_step_timing in s: 0.4288 | consumed_samples: 20\n", + "Training epoch 0, iteration 10/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 10 | reduced_train_loss: 1.131 | train_step_timing in s: 0.4289 | consumed_samples: 22\n", + "Training epoch 0, iteration 11/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 11 | reduced_train_loss: 1.243 | train_step_timing in s: 0.4298 | consumed_samples: 24\n", + "Training epoch 0, iteration 12/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 12 | reduced_train_loss: 1.226 | train_step_timing in s: 0.4305 | consumed_samples: 26\n", + "Training epoch 0, iteration 13/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 13 | reduced_train_loss: 1.316 | train_step_timing in s: 0.429 | consumed_samples: 28\n", + "Training epoch 0, iteration 14/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 14 | reduced_train_loss: 1.263 | train_step_timing in s: 0.4286 | consumed_samples: 30\n", + "Training epoch 0, iteration 15/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 15 | reduced_train_loss: 1.305 | train_step_timing in s: 0.43 | consumed_samples: 32\n", + "Training epoch 0, iteration 16/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 16 | reduced_train_loss: 1.286 | train_step_timing in s: 0.4297 | consumed_samples: 34\n", + "Training epoch 0, iteration 17/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 17 | reduced_train_loss: 1.272 | train_step_timing in s: 0.4298 | consumed_samples: 36\n", + "Training epoch 0, iteration 18/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 18 | reduced_train_loss: 1.289 | train_step_timing in s: 0.4294 | consumed_samples: 38\n", + "Training epoch 0, iteration 19/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 19 | reduced_train_loss: 1.273 | train_step_timing in s: 0.4304 | consumed_samples: 40\n", + "Training epoch 0, iteration 20/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 20 | reduced_train_loss: 0.6654 | train_step_timing in s: 0.4304 | consumed_samples: 42\n", + "Training epoch 0, iteration 21/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 21 | reduced_train_loss: 1.213 | train_step_timing in s: 0.4297 | consumed_samples: 44\n", + "Training epoch 0, iteration 22/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 22 | reduced_train_loss: 1.289 | train_step_timing in s: 0.4305 | consumed_samples: 46\n", + "Training epoch 0, iteration 23/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 23 | reduced_train_loss: 1.304 | train_step_timing in s: 0.4312 | consumed_samples: 48\n", + "Training epoch 0, iteration 24/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 24 | reduced_train_loss: 1.264 | train_step_timing in s: 0.4316 | consumed_samples: 50\n", + "Training epoch 0, iteration 25/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 25 | reduced_train_loss: 1.257 | train_step_timing in s: 0.4316 | consumed_samples: 52\n", + "Training epoch 0, iteration 26/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 26 | reduced_train_loss: 1.295 | train_step_timing in s: 0.4309 | consumed_samples: 54\n", + "Training epoch 0, iteration 27/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 27 | reduced_train_loss: 1.305 | train_step_timing in s: 0.4309 | consumed_samples: 56\n", + "Training epoch 0, iteration 28/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 28 | reduced_train_loss: 1.324 | train_step_timing in s: 0.4322 | consumed_samples: 58\n", + "Training epoch 0, iteration 29/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 29 | reduced_train_loss: 1.311 | train_step_timing in s: 0.4309 | consumed_samples: 60\n", + "Training epoch 0, iteration 30/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 30 | reduced_train_loss: 1.334 | train_step_timing in s: 0.4308 | consumed_samples: 62\n", + "Training epoch 0, iteration 31/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 31 | reduced_train_loss: 0.709 | train_step_timing in s: 0.4315 | consumed_samples: 64\n", + "Training epoch 0, iteration 32/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 32 | reduced_train_loss: 1.262 | train_step_timing in s: 0.4312 | consumed_samples: 66\n", + "Training epoch 0, iteration 33/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 33 | reduced_train_loss: 1.332 | train_step_timing in s: 0.4318 | consumed_samples: 68\n", + "Training epoch 0, iteration 34/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 34 | reduced_train_loss: 1.272 | train_step_timing in s: 0.4318 | consumed_samples: 70\n", + "Training epoch 0, iteration 35/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 35 | reduced_train_loss: 1.249 | train_step_timing in s: 0.4322 | consumed_samples: 72\n", + "Training epoch 0, iteration 36/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 36 | reduced_train_loss: 1.28 | train_step_timing in s: 0.4311 | consumed_samples: 74\n", + "Training epoch 0, iteration 37/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 37 | reduced_train_loss: 1.321 | train_step_timing in s: 0.4313 | consumed_samples: 76\n", + "Training epoch 0, iteration 38/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 38 | reduced_train_loss: 1.293 | train_step_timing in s: 0.4321 | consumed_samples: 78\n", + "Training epoch 0, iteration 39/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 39 | reduced_train_loss: 1.279 | train_step_timing in s: 0.4316 | consumed_samples: 80\n", + "Training epoch 0, iteration 40/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 40 | reduced_train_loss: 1.081 | train_step_timing in s: 0.4306 | consumed_samples: 82\n", + "Training epoch 0, iteration 41/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 41 | reduced_train_loss: 1.284 | train_step_timing in s: 0.4313 | consumed_samples: 84\n", + "Training epoch 0, iteration 42/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 42 | reduced_train_loss: 1.305 | train_step_timing in s: 0.4307 | consumed_samples: 86\n", + "Training epoch 0, iteration 43/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 43 | reduced_train_loss: 1.265 | train_step_timing in s: 0.4307 | consumed_samples: 88\n", + "Training epoch 0, iteration 44/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 44 | reduced_train_loss: 1.296 | train_step_timing in s: 0.4335 | consumed_samples: 90\n", + "Training epoch 0, iteration 45/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 45 | reduced_train_loss: 1.313 | train_step_timing in s: 0.4335 | consumed_samples: 92\n", + "Training epoch 0, iteration 46/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 46 | reduced_train_loss: 1.304 | train_step_timing in s: 0.4326 | consumed_samples: 94\n", + "Training epoch 0, iteration 47/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 47 | reduced_train_loss: 1.299 | train_step_timing in s: 0.4329 | consumed_samples: 96\n", + "Training epoch 0, iteration 48/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 48 | reduced_train_loss: 1.321 | train_step_timing in s: 0.4335 | consumed_samples: 98\n", + "Training epoch 0, iteration 49/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 49 | reduced_train_loss: 1.281 | train_step_timing in s: 0.4338 | consumed_samples: 100\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/lightning/pytorch/callbacks/model_checkpoint.py:384: `ModelCheckpoint(monitor='val_loss')` could not find the monitored key in the returned metrics: ['lr-McoreOpt/pg1', 'lr-McoreOpt/pg2', 'lr', 'global_batch_size', 'global_step', 'step', 'reduced_train_loss', 'grad_norm', 'num_zeros_in_grad', 'train_step_timing in s', 'consumed_samples', 'epoch']. HINT: Did you call `log('val_loss', value)` in the `LightningModule`?\n", + "\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: Epoch 0, global step 49: 'val_loss' was not in top 5\n", + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[NeMo W 2025-02-25 01:14:02 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[NeMo I 2025-02-25 01:14:17 nemo_logging:393] Scheduled async checkpoint save for /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=0.0000-epoch=0-consumed_samples=100.0-last.ckpt\n", + "Validation: iteration 1/20\n", + "Validation: iteration 2/20\n", + "Validation: iteration 3/20\n", + "Validation: iteration 4/20\n", + "Validation: iteration 5/20\n", + "Validation: iteration 6/20\n", + "Validation: iteration 7/20\n", + "Validation: iteration 8/20\n", + "Validation: iteration 9/20\n", + "Validation: iteration 10/20\n", + "Validation: iteration 11/20\n", + "Validation: iteration 12/20\n", + "Validation: iteration 13/20\n", + "Validation: iteration 14/20\n", + "Validation: iteration 15/20\n", + "Validation: iteration 16/20\n", + "Validation: iteration 17/20\n", + "Validation: iteration 18/20\n", + "Validation: iteration 19/20\n", + "Validation: iteration 20/20\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:431: It is recommended to use `self.log('global_batch_size', ..., sync_dist=True)` when logging on epoch level in distributed setting to accumulate the metric across devices.\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/lightning/pytorch/trainer/connectors/logger_connector/result.py:431: It is recommended to use `self.log('val_loss', ..., sync_dist=True)` when logging on epoch level in distributed setting to accumulate the metric across devices.\n", + "\n", + "Training epoch 0, iteration 50/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 50 | reduced_train_loss: 1.316 | train_step_timing in s: 0.4343 | consumed_samples: 102 | val_loss: 1.049\n", + "Training epoch 0, iteration 51/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 51 | reduced_train_loss: 1.151 | train_step_timing in s: 0.4323 | consumed_samples: 104 | val_loss: 1.049\n", + "Training epoch 0, iteration 52/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 52 | reduced_train_loss: 1.255 | train_step_timing in s: 0.432 | consumed_samples: 106 | val_loss: 1.049\n", + "Training epoch 0, iteration 53/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 53 | reduced_train_loss: 1.302 | train_step_timing in s: 0.4316 | consumed_samples: 108 | val_loss: 1.049\n", + "Training epoch 0, iteration 54/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 54 | reduced_train_loss: 1.315 | train_step_timing in s: 0.4319 | consumed_samples: 110 | val_loss: 1.049\n", + "Training epoch 0, iteration 55/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 55 | reduced_train_loss: 1.315 | train_step_timing in s: 0.4194 | consumed_samples: 112 | val_loss: 1.049\n", + "Training epoch 0, iteration 56/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 56 | reduced_train_loss: 1.302 | train_step_timing in s: 0.4328 | consumed_samples: 114 | val_loss: 1.049\n", + "Training epoch 0, iteration 57/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 57 | reduced_train_loss: 1.239 | train_step_timing in s: 0.4334 | consumed_samples: 116 | val_loss: 1.049\n", + "Training epoch 0, iteration 58/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 58 | reduced_train_loss: 1.325 | train_step_timing in s: 0.4343 | consumed_samples: 118 | val_loss: 1.049\n", + "Training epoch 0, iteration 59/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 59 | reduced_train_loss: 0.7567 | train_step_timing in s: 0.4317 | consumed_samples: 120 | val_loss: 1.049\n", + "Training epoch 0, iteration 60/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 60 | reduced_train_loss: 1.289 | train_step_timing in s: 0.432 | consumed_samples: 122 | val_loss: 1.049\n", + "Training epoch 0, iteration 61/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 61 | reduced_train_loss: 1.31 | train_step_timing in s: 0.4225 | consumed_samples: 124 | val_loss: 1.049\n", + "Training epoch 0, iteration 62/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 62 | reduced_train_loss: 1.255 | train_step_timing in s: 0.4342 | consumed_samples: 126 | val_loss: 1.049\n", + "Training epoch 0, iteration 63/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 63 | reduced_train_loss: 1.328 | train_step_timing in s: 0.4246 | consumed_samples: 128 | val_loss: 1.049\n", + "Training epoch 0, iteration 64/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 64 | reduced_train_loss: 1.222 | train_step_timing in s: 0.4377 | consumed_samples: 130 | val_loss: 1.049\n", + "Training epoch 0, iteration 65/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 65 | reduced_train_loss: 1.252 | train_step_timing in s: 0.4324 | consumed_samples: 132 | val_loss: 1.049\n", + "Training epoch 0, iteration 66/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 66 | reduced_train_loss: 1.288 | train_step_timing in s: 0.4327 | consumed_samples: 134 | val_loss: 1.049\n", + "Training epoch 0, iteration 67/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 67 | reduced_train_loss: 1.307 | train_step_timing in s: 0.4338 | consumed_samples: 136 | val_loss: 1.049\n", + "[NeMo I 2025-02-25 01:14:27 nemo_logging:393] Async checkpoint save for step 50 (/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=0.0000-epoch=0-consumed_samples=100.0-last.ckpt) finalized successfully.\n", + "Training epoch 0, iteration 68/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 68 | reduced_train_loss: 1.286 | train_step_timing in s: 0.4343 | consumed_samples: 138 | val_loss: 1.049\n", + "Training epoch 0, iteration 69/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 69 | reduced_train_loss: 1.321 | train_step_timing in s: 0.433 | consumed_samples: 140 | val_loss: 1.049\n", + "Training epoch 0, iteration 70/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 70 | reduced_train_loss: 1.286 | train_step_timing in s: 0.4332 | consumed_samples: 142 | val_loss: 1.049\n", + "Training epoch 0, iteration 71/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 71 | reduced_train_loss: 1.285 | train_step_timing in s: 0.4348 | consumed_samples: 144 | val_loss: 1.049\n", + "Training epoch 0, iteration 72/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 72 | reduced_train_loss: 0.7515 | train_step_timing in s: 0.4342 | consumed_samples: 146 | val_loss: 1.049\n", + "Training epoch 0, iteration 73/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 73 | reduced_train_loss: 1.365 | train_step_timing in s: 0.4333 | consumed_samples: 148 | val_loss: 1.049\n", + "Training epoch 0, iteration 74/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 74 | reduced_train_loss: 1.252 | train_step_timing in s: 0.4332 | consumed_samples: 150 | val_loss: 1.049\n", + "Training epoch 0, iteration 75/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 75 | reduced_train_loss: 1.265 | train_step_timing in s: 0.4338 | consumed_samples: 152 | val_loss: 1.049\n", + "Training epoch 0, iteration 76/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 76 | reduced_train_loss: 1.314 | train_step_timing in s: 0.4333 | consumed_samples: 154 | val_loss: 1.049\n", + "Training epoch 0, iteration 77/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 77 | reduced_train_loss: 1.298 | train_step_timing in s: 0.4341 | consumed_samples: 156 | val_loss: 1.049\n", + "Training epoch 0, iteration 78/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 78 | reduced_train_loss: 1.333 | train_step_timing in s: 0.4339 | consumed_samples: 158 | val_loss: 1.049\n", + "Training epoch 0, iteration 79/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 79 | reduced_train_loss: 1.291 | train_step_timing in s: 0.4348 | consumed_samples: 160 | val_loss: 1.049\n", + "Training epoch 0, iteration 80/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 80 | reduced_train_loss: 1.316 | train_step_timing in s: 0.4219 | consumed_samples: 162 | val_loss: 1.049\n", + "Training epoch 0, iteration 81/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 81 | reduced_train_loss: 1.335 | train_step_timing in s: 0.4347 | consumed_samples: 164 | val_loss: 1.049\n", + "Training epoch 0, iteration 82/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 82 | reduced_train_loss: 1.319 | train_step_timing in s: 0.434 | consumed_samples: 166 | val_loss: 1.049\n", + "Training epoch 0, iteration 83/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 83 | reduced_train_loss: 1.23 | train_step_timing in s: 0.434 | consumed_samples: 168 | val_loss: 1.049\n", + "Training epoch 0, iteration 84/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 84 | reduced_train_loss: 1.33 | train_step_timing in s: 0.4342 | consumed_samples: 170 | val_loss: 1.049\n", + "Training epoch 0, iteration 85/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 85 | reduced_train_loss: 1.316 | train_step_timing in s: 0.4351 | consumed_samples: 172 | val_loss: 1.049\n", + "Training epoch 0, iteration 86/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 86 | reduced_train_loss: 1.309 | train_step_timing in s: 0.4353 | consumed_samples: 174 | val_loss: 1.049\n", + "Training epoch 0, iteration 87/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 87 | reduced_train_loss: 1.19 | train_step_timing in s: 0.4353 | consumed_samples: 176 | val_loss: 1.049\n", + "Training epoch 0, iteration 88/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 88 | reduced_train_loss: 1.301 | train_step_timing in s: 0.4223 | consumed_samples: 178 | val_loss: 1.049\n", + "Training epoch 0, iteration 89/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 89 | reduced_train_loss: 1.327 | train_step_timing in s: 0.4385 | consumed_samples: 180 | val_loss: 1.049\n", + "Training epoch 0, iteration 90/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 90 | reduced_train_loss: 1.3 | train_step_timing in s: 0.4235 | consumed_samples: 182 | val_loss: 1.049\n", + "Training epoch 0, iteration 91/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 91 | reduced_train_loss: 1.278 | train_step_timing in s: 0.4357 | consumed_samples: 184 | val_loss: 1.049\n", + "Training epoch 0, iteration 92/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 92 | reduced_train_loss: 1.302 | train_step_timing in s: 0.4364 | consumed_samples: 186 | val_loss: 1.049\n", + "Training epoch 0, iteration 93/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 93 | reduced_train_loss: 1.094 | train_step_timing in s: 0.4364 | consumed_samples: 188 | val_loss: 1.049\n", + "Training epoch 0, iteration 94/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 94 | reduced_train_loss: 1.326 | train_step_timing in s: 0.4234 | consumed_samples: 190 | val_loss: 1.049\n", + "Training epoch 0, iteration 95/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 95 | reduced_train_loss: 1.176 | train_step_timing in s: 0.4366 | consumed_samples: 192 | val_loss: 1.049\n", + "Training epoch 0, iteration 96/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 96 | reduced_train_loss: 1.282 | train_step_timing in s: 0.4364 | consumed_samples: 194 | val_loss: 1.049\n", + "Training epoch 0, iteration 97/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 97 | reduced_train_loss: 1.293 | train_step_timing in s: 0.437 | consumed_samples: 196 | val_loss: 1.049\n", + "Training epoch 0, iteration 98/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 98 | reduced_train_loss: 1.313 | train_step_timing in s: 0.4363 | consumed_samples: 198 | val_loss: 1.049\n", + "Training epoch 0, iteration 99/99 | lr: 3e-05 | global_batch_size: 2 | global_step: 99 | reduced_train_loss: 1.309 | train_step_timing in s: 0.4345 | consumed_samples: 200 | val_loss: 1.049\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: Epoch 0, global step 99: 'val_loss' reached 1.04856 (best 1.04856), saving model to '/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=1.0486-epoch=0-consumed_samples=200.0.ckpt' as top 5\n", + "[NeMo I 2025-02-25 01:14:42 nemo_logging:393] Scheduled async checkpoint save for /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=1.0486-epoch=0-consumed_samples=200.0.ckpt\n", + "[NeMo I 2025-02-25 01:14:43 nemo_logging:393] Scheduled async checkpoint save for /workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=1.0486-epoch=0-consumed_samples=200.0-last.ckpt\n", + "Validation: iteration 1/20\n", + "Validation: iteration 2/20\n", + "Validation: iteration 3/20\n", + "Validation: iteration 4/20\n", + "Validation: iteration 5/20\n", + "Validation: iteration 6/20\n", + "Validation: iteration 7/20\n", + "Validation: iteration 8/20\n", + "Validation: iteration 9/20\n", + "Validation: iteration 10/20\n", + "Validation: iteration 11/20\n", + "Validation: iteration 12/20\n", + "Validation: iteration 13/20\n", + "Validation: iteration 14/20\n", + "Validation: iteration 15/20\n", + "Validation: iteration 16/20\n", + "Validation: iteration 17/20\n", + "Validation: iteration 18/20\n", + "Validation: iteration 19/20\n", + "Validation: iteration 20/20\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: `Trainer.fit` stopped: `max_steps=100` reached.\n", + "[NeMo I 2025-02-25 01:14:45 nemo_logging:393] Pending async checkpoint saves. Finalizing them synchronously now\n", + "[NeMo I 2025-02-25 01:14:54 nemo_logging:393] Async checkpoint save for step 100 (/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=1.0486-epoch=0-consumed_samples=200.0.ckpt) finalized successfully.\n", + "[NeMo I 2025-02-25 01:14:54 nemo_logging:393] Async checkpoint save for step 100 (/workspaces/bionemo-framework/docs/docs/user-guide/examples/bionemo-evo2/pretraining_demo/default--val_loss=1.0486-epoch=0-consumed_samples=200.0-last.ckpt) finalized successfully.\n" + ] + } + ], + "source": [ + "# For evo2 training and fine-tuning follow the same set of steps, so we use the same train_evo2 command.\n", + "# the big difference is the --ckpt-dir argument which points to a pre-existing checkpoint from some other training run.\n", + "!train_evo2 \\\n", + " -d training_data_config.yaml \\\n", + " --dataset-dir {preprocessed_data} \\\n", + " --experiment-dir pretraining_demo \\\n", + " --model-size 1b \\\n", + " --devices 1 \\\n", + " --num-nodes 1 \\\n", + " --seq-length 1024 \\\n", + " --micro-batch-size 2 \\\n", + " --lr 0.0001 \\\n", + " --warmup-steps 5 \\\n", + " --max-steps 100 \\\n", + " --ckpt-dir nemo2_evo2_1b_8k \\\n", + " --clip-grad 1 \\\n", + " --wd 0.01 \\\n", + " --activation-checkpoint-recompute-num-layers 1 \\\n", + " --val-check-interval 50 \\\n", + " --ckpt-async-save \\\n", + " --no-wandb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py index 352683b7b0..d3fbfdc291 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/preprocess.py @@ -339,6 +339,14 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): Yields: tuple[dict, float]: Preprocessed sequence data and the time taken for preprocessing. """ + # Track which splits have been assigned + split_assignments = { + "train": preproc_config.train_split > 0, + "val": preproc_config.valid_split > 0, + "test": preproc_config.test_split > 0, + } + splits_needed = {k for k, v in split_assignments.items() if v} + # Instantiate multiprocessing pool. Use semaphore to limit the amount of sequences to read into memory. semaphore = Semaphore(preproc_config.preproc_concurrency + preproc_config.workers) if preproc_config.workers > 1: @@ -359,10 +367,15 @@ def preprocess_generator(self, preproc_config: Evo2PreprocessingConfig): for result, elapsed_time in preproc_tasks: # Release semaphore for the task associated with the result. semaphore.release() - # Randomly assign all sequences to train, validation, or test. - split = self._train_val_test_split( - preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split - ) + # If we still need to ensure splits are assigned + if splits_needed: + # Force assign to a needed split + split = splits_needed.pop() + else: + # Regular random assignment + split = self._train_val_test_split( + preproc_config.train_split, preproc_config.valid_split, preproc_config.test_split + ) for sequence in result: sequence["split"] = split yield sequence, elapsed_time @@ -456,6 +469,8 @@ def main(): start = time.time() # Convert into Evo2PreprocessingConfig. evo2_preproc_config = Evo2PreprocessingConfig(**config) + if evo2_preproc_config.output_dir is not None: + evo2_preproc_config.output_dir.mkdir(parents=True, exist_ok=True) # Instantiate Evo2Preprocessor. evo2_preprocessor = Evo2Preprocessor(evo2_preproc_config) # Preprocess data specified in config. From 544b7a89040131b9cbfab4f5a62b0be9152735ed Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 18:23:37 +0000 Subject: [PATCH 097/140] ignore object hashes in precommit Signed-off-by: John St John <jstjohn@nvidia.com> --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 15cc1e2e37..34918764ad 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -22,7 +22,7 @@ repos: exclude: package.lock.json - id: detect-secrets name: detect-secrets (notebooks only) - args: ['--baseline', '.secrets-nb.baseline', '--exclude-files', '^.(?!.*\.ipynb)', '--exclude-lines', '"(hash|id|image/\w+)":.*', ] + args: ['--baseline', '.secrets-nb.baseline', '--exclude-files', '^.(?!.*\.ipynb)', '--exclude-lines', '"(hash|id|image/\w+)":.*|<.*at 0x[0-9a-f]+>|object at 0x[0-9a-f]+', ] - repo: local hooks: - id: license-header-check From d7a8ea7d7f860794a6a06b72d5779d8b750c5a3b Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 18:56:54 +0000 Subject: [PATCH 098/140] Bump nemo pointer to latest PR pointer Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index fa3fac04a8..2be3af56a4 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit fa3fac04a8736d8f2f492c77e58c99c2c630ddcd +Subproject commit 2be3af56a4eb57a4892c55b66e29a4a918a0867c From 07c48b82f505cdda8a798b95b55a926e3ab53541 Mon Sep 17 00:00:00 2001 From: "John St. John" <jstjohn@users.noreply.github.com> Date: Tue, 25 Feb 2025 10:59:33 -0800 Subject: [PATCH 099/140] Update ci/benchmarks/partial-conv/evo2_pretrain.yaml Co-authored-by: Dorota Toczydlowska <115542912+dorotat-nv@users.noreply.github.com> Signed-off-by: John St. John <jstjohn@users.noreply.github.com> --- ci/benchmarks/partial-conv/evo2_pretrain.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/benchmarks/partial-conv/evo2_pretrain.yaml b/ci/benchmarks/partial-conv/evo2_pretrain.yaml index 56d95aee7a..8963ea63e0 100644 --- a/ci/benchmarks/partial-conv/evo2_pretrain.yaml +++ b/ci/benchmarks/partial-conv/evo2_pretrain.yaml @@ -37,7 +37,7 @@ script_args: script: |- WANDB_API_KEY=$BIONEMO_WANDB_API_KEY python ${workspace}/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py \ -d ${workspace}/ci/benchmarks/test_dataset_config.yaml \ - --dataset-path ${data_path} \ + --dataset-dir ${data_path} \ --grad-acc-batches ${acc_grad} \ --fp8 \ --enable-preemption \ From e779f60ba6ba8097da5506c33b6c48403cbef204 Mon Sep 17 00:00:00 2001 From: "John St. John" <jstjohn@users.noreply.github.com> Date: Tue, 25 Feb 2025 10:59:43 -0800 Subject: [PATCH 100/140] Update ci/benchmarks/perf/evo2_pretrain.yaml Co-authored-by: Dorota Toczydlowska <115542912+dorotat-nv@users.noreply.github.com> Signed-off-by: John St. John <jstjohn@users.noreply.github.com> --- ci/benchmarks/perf/evo2_pretrain.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/benchmarks/perf/evo2_pretrain.yaml b/ci/benchmarks/perf/evo2_pretrain.yaml index 865bbb0df3..185aa94713 100644 --- a/ci/benchmarks/perf/evo2_pretrain.yaml +++ b/ci/benchmarks/perf/evo2_pretrain.yaml @@ -40,7 +40,7 @@ script_args: script: |- WANDB_API_KEY=$BIONEMO_WANDB_API_KEY python ${workspace}/sub-packages/bionemo-evo2/src/bionemo/evo2/run/${variant}.py \ -d ${workspace}/ci/benchmarks/test_dataset_config.yaml \ - --dataset-path ${data_path} \ + --dataset-dir ${data_path} \ --grad-acc-batches ${acc_grad} \ --fp8 \ --enable-preemption \ From a1c80488695cce8c0b340e066af60566c3e70612 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 19:15:55 +0000 Subject: [PATCH 101/140] Slightly smaller test_train.py Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py index 08c6be8d3b..c28c10b2f7 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py @@ -40,7 +40,7 @@ def test_train_evo2_runs(tmp_path, num_steps=5): # Note: The command assumes that `train_evo2` is in your PATH. command = ( f"train_evo2 --mock-data --experiment-dir {tmp_path}/test_train " - "--model-size 7b_nv --num-layers 4 --hybrid-override-pattern SDH* " + "--model-size 1b_nv --num-layers 4 --hybrid-override-pattern SDH* " "--no-activation-checkpointing --add-bias-output " f"--max-steps {num_steps} --warmup-steps 1 --no-wandb " "--seq-length 128 --hidden-dropout 0.1 --attention-dropout 0.1 " From 46edcb6a61700e775f54be07f2a51fa2bd804778 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 19:33:26 +0000 Subject: [PATCH 102/140] Add missing main function for inference cli --- sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py index 9391044aea..58f4d99f85 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/infer.py @@ -174,7 +174,8 @@ def infer( return results -if __name__ == "__main__": +def main(): + """Main function for Evo2 inference.""" # Parse args. args = parse_args() infer( @@ -191,3 +192,7 @@ def infer( ckpt_format=args.ckpt_format, seed=args.seed, ) + + +if __name__ == "__main__": + main() From e81eef3878a2d7003b46e2581bf6112dd0b08359 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 22:06:01 +0000 Subject: [PATCH 103/140] Add --batch-size option to predict Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py index 78dc87e2ec..53d98d27bb 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py @@ -53,6 +53,7 @@ def parse_args(): ap.add_argument( "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." ) + ap.add_argument("--batch-size", type=int, default=1, help="Batch size for prediction. Defaults to 1.") ap.add_argument( "--model-size", type=str, @@ -224,6 +225,7 @@ def predict( ckpt_format: CheckpointFormats = "torch_dist", fp8: bool = False, work_dir: Path | None = None, + batch_size: int = 1, ): """Inference workflow for Evo2. @@ -301,7 +303,7 @@ def predict( resume.setup(trainer, model) # this pulls weights from the starting checkpoint. dataset = SimpleFastaDataset(fasta_path, tokenizer) - datamodule = PredictDataModule(dataset) + datamodule = PredictDataModule(dataset, batch_size=batch_size) trainer.predict(model, datamodule.predict_dataloader()) dataset.write_idx_map( output_dir @@ -321,6 +323,7 @@ def main(): model_size=args.model_size, ckpt_format=args.ckpt_format, fp8=args.fp8, + batch_size=args.batch_size, ) From 4e5acda95bc4c667ba9045a59ee1fe5ef8d08bf5 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 25 Feb 2025 23:10:07 +0000 Subject: [PATCH 104/140] Fixing the description of the 1b model Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-core/src/bionemo/core/data/resources/evo2.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index 368d88218e..d61b2b27e9 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -5,7 +5,7 @@ sha256: d663c529ac7ae0b6f2fd3a852253a484bd8a6576992e9ec73045ce7af2365990 # pragma: allowlist secret owner: John St John <jstjohn@nvidia.com> description: > - A 7b parameter evo2 model used in testing, torch_dist format. Converted from hf://arcinstitute/savanna_evo2_1b_base. + A 1b parameter evo2 model used in testing, torch_dist format. Converted from hf://arcinstitute/savanna_evo2_1b_base. - tag: 7b-8k:1.0 From 5bd0e2c78a9e33c0f762c4d3867090b73a576b2f Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 26 Feb 2025 01:15:06 +0000 Subject: [PATCH 105/140] remove hard-coded PBSS Signed-off-by: John St John <jstjohn@nvidia.com> --- .../tests/bionemo/core/data/test_load.py | 3 +-- .../tests/bionemo/evo2/run/test_infer.py | 13 ++++++++++--- .../tests/bionemo/evo2/run/test_inference.py | 13 ++++++++++--- .../tests/bionemo/evo2/run/test_predict.py | 11 ++++++++++- .../bionemo-evo2/tests/bionemo/evo2/test_evo2.py | 4 ++-- .../bionemo-scdl/tests/bionemo/scdl/conftest.py | 2 +- 6 files changed, 34 insertions(+), 12 deletions(-) diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py index 725ed9afa7..356b967b02 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py @@ -45,9 +45,8 @@ def test_load_raises_error_on_invalid_tag(tmp_path): def test_load_cli(): # It looks like there's some issues with our NGC resources, but this is blocking CI. TODO: Revert to ngc when these # resources are available. - # FIXME (dorotat): set source=ngc once the access issue with NGC is resolved (https://github.com/NVIDIA/bionemo-framework/issues/682) result = subprocess.run( - ["download_bionemo_data", "--source", "pbss", "single_cell/testdata-20240506"], + ["download_bionemo_data", "single_cell/testdata-20240506"], stdout=subprocess.PIPE, # Capture stdout stderr=subprocess.PIPE, # Capture stderr (optional) text=True, # Return output as string rather than bytes diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py index 5347ab170a..273a07bfdf 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_infer.py @@ -45,9 +45,16 @@ def test_run_infer(): + "g__Escherichia;" + "s__Escherichia|" ) - - # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/1b-8k:1.0", source="pbss") + try: + checkpoint_path = load("evo2/1b-8k:1.0") + except ValueError as e: + if e.args[0].endswith("does not have an NGC URL."): + raise ValueError( + "Please re-run test with `BIONEMO_DATA_SOURCE=pbss py.test ...`, " + "one or more files are missing from ngc." + ) + else: + raise e with clean_parallel_state_context(): infer( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index 4a06a66b13..dee5843fd9 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -74,9 +74,16 @@ def test_infer_model_generates_expected_single_token_output(): top_k = 0 top_p = 0.0 max_new_tokens = 1 - # TODO (dorotat) remove PBSS source once the model is available on NGC - checkpoint_path = load("evo2/1b-8k:1.0", source="pbss") - + try: + checkpoint_path = load("evo2/1b-8k:1.0") + except ValueError as e: + if e.args[0].endswith("does not have an NGC URL."): + raise ValueError( + "Please re-run test with `BIONEMO_DATA_SOURCE=pbss py.test ...`, " + "one or more files are missing from ngc." + ) + else: + raise e with clean_parallel_state_context(): results = generate( path=checkpoint_path, diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py index 3b57d9c66a..e5dd2e476d 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py @@ -47,7 +47,16 @@ def test_train_evo2_runs( # a local copy of the environment env = dict(**os.environ) env["MASTER_PORT"] = str(open_port) - checkpoint_path = load("evo2/1b-8k:1.0", source="pbss") + try: + checkpoint_path = load("evo2/1b-8k:1.0") + except ValueError as e: + if e.args[0].endswith("does not have an NGC URL."): + raise ValueError( + "Please re-run test with `BIONEMO_DATA_SOURCE=pbss py.test ...`, " + "one or more files are missing from ngc." + ) + else: + raise e # Build the command string. # Note: The command assumes that `train_evo2` is in your PATH. output_dir = tmp_path / "test_output" diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index 3bf7bd53b5..e12787c377 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -68,9 +68,9 @@ def load_weights_sharded_inplace_nemo2_to_mcore( def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): try: # TODO (dorotat) remove PBSS source once the model is available on NGC - evo2_1b_checkpoint_weights: Path = load("evo2/1b-8k:1.0", source="pbss") / "weights" + evo2_1b_checkpoint_weights: Path = load("evo2/1b-8k:1.0") / "weights" # TODO (dorotat) remove PBSS source once the model is available on NGC - gold_standard_no_fp8 = load("evo2/1b-8k-nofp8-te-goldvalue-testdata-A6000:1.0", source="pbss") + gold_standard_no_fp8 = load("evo2/1b-8k-nofp8-te-goldvalue-testdata-A6000:1.0") except ValueError as e: if e.args[0].endswith("does not have an NGC URL."): raise ValueError( diff --git a/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py b/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py index 8a90f3b049..ce8c48071d 100644 --- a/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py +++ b/sub-packages/bionemo-scdl/tests/bionemo/scdl/conftest.py @@ -30,7 +30,7 @@ def test_directory() -> Path: A Path object that is the directory with test data. """ # return load("scdl/sample") / "scdl_data" - return load("scdl/sample_scdl_feature_ids", source="pbss") / "scdl_data_with_feature_ids" + return load("scdl/sample_scdl_feature_ids") / "scdl_data_with_feature_ids" @pytest.fixture From ca16c2acf9bf813d020b6d1e2d4e1240cfef6a69 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 26 Feb 2025 01:22:30 +0000 Subject: [PATCH 106/140] Remove comment block from code Signed-off-by: John St John <jstjohn@nvidia.com> --- .../tests/bionemo/evo2/run/test_inference.py | 74 ------------------- 1 file changed, 74 deletions(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py index dee5843fd9..c1d205c732 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_inference.py @@ -102,77 +102,3 @@ def test_infer_model_generates_expected_single_token_output(): assert isinstance(results, list) assert results == ["T"] - - -# def test_infer_model_generates_expected_single_token_output_from_input_seq(): -# # Create PTL trainer. -# # TODO: Uncomment when the GPU Memory allocation issue is resolved. -# _teardown_apex_megatron_cuda() -# torch.cuda.empty_cache() -# TENSOR_PARALLEL_SIZE = 1 -# PIPELINE_MODEL_PARALLEL_SIZE = 1 -# CONTEXT_PARALLEL_SIZE = 1 -# NUM_GPUS = 1 -# NUM_NODES = 1 - -# strategy = nl.MegatronStrategy( -# tensor_model_parallel_size=TENSOR_PARALLEL_SIZE, -# pipeline_model_parallel_size=PIPELINE_MODEL_PARALLEL_SIZE, -# context_parallel_size=CONTEXT_PARALLEL_SIZE, -# pipeline_dtype=torch.bfloat16, -# ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. -# ckpt_save_optimizer=False, -# ckpt_async_save=False, -# save_ckpt_format="zarr", -# ) -# trainer = nl.Trainer( -# accelerator="gpu", -# num_nodes=NUM_NODES, -# devices=NUM_GPUS, -# strategy=strategy, -# log_every_n_steps=1, -# limit_val_batches=10, -# num_sanity_val_steps=0, -# plugins=nl.MegatronMixedPrecision( -# precision="bf16-mixed", -# params_dtype=torch.bfloat16, -# ), -# ) -# # Last char from gold std removed. -# input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAA" -# deleted_char = "T" -# temperature = 1.0 -# top_k = 0 -# top_p = 0.0 -# max_new_tokens = 1 -# checkpoint_path = load("evo2/7b-8k-zarr:1.1", source="pbss") -# gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") -# gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8) -# gold_standard_no_fp8_tensor = gold_standard_no_fp8_tensor[0, -1] -# results = generate( -# path=checkpoint_path, -# prompts=[input_seq], -# trainer=trainer, -# inference_params=CommonInferenceParams( -# temperature, -# top_k, -# top_p, -# return_log_probs=False, -# num_tokens_to_generate=max_new_tokens, -# ), -# random_seed=RANDOM_SEED, -# text_only=False, -# ) - -# # Text equal to "T" (deleted char) -# assert results[0].generated_text == deleted_char -# assert isinstance(results, list) - -# TODO: Later... -# Do comparison to test golden values for the logit vector. -# gold_standard_logits_vector = gold_standard_no_fp8_tensor - -# Do cosine similarity between the two vectors, for the topk=4 indices. -# Make sure topk=4 = ACTG -# Use indices to go from 512 -> 4. -# Do cosine similarity between the two vectors. From 5248e5d0395719466ba496154f65e6b0892799f7 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska <115542912+dorotat-nv@users.noreply.github.com> Date: Thu, 27 Feb 2025 18:01:57 +0100 Subject: [PATCH 107/140] evo2 train unit test (#704) ### Description Slightly refactoring train script for evo2 to better handle unit testing and a bug fix ### Type of changes <!-- Mark the relevant option with an [x] --> - [ ] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [x] Refactor - [ ] Documentation update - [ ] Other (please describe): ### CI Pipeline Configuration Configure CI behavior by applying the relevant labels: - [SKIP_CI](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#skip_ci) - Skip all continuous integration tests - [INCLUDE_NOTEBOOKS_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_notebooks_tests) - Execute notebook validation tests in pytest - [INCLUDE_SLOW_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_slow_tests) - Execute tests labelled as slow in pytest for extensive testing > [!NOTE] > By default, the notebooks validation tests are skipped unless explicitly enabled. ### Usage <!--- How does a user interact with the changed code --> ```python TODO: Add code snippet ``` ### Pre-submit Checklist <!--- Ensure all items are completed before submitting --> - [x] I have tested these changes locally - [ ] I have updated the documentation accordingly - [x] I have added/updated tests as needed - [ ] All existing tests pass successfully --------- Signed-off-by: dorotat <dorotat@nvidia.com> --- .../src/bionemo/evo2/run/train.py | 28 ++++--- .../tests/bionemo/evo2/run/test_train.py | 84 +++++++++++++++++++ 2 files changed, 102 insertions(+), 10 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index d3784d81fa..5fff84abcd 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -17,7 +17,7 @@ # limitations under the License. import argparse -from dataclasses import asdict +from typing import List, Optional # TODO add back support for slurm resilience. # import nvidia_resiliency_ext.ptl_resiliency as res_module @@ -53,7 +53,7 @@ torch._dynamo.config.suppress_errors = True -def parse_args(): +def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace: """Parse arguments for Evo2 model training.""" parser = argparse.ArgumentParser( description="Train a Hyena model using NeMo 2.0.", @@ -103,6 +103,10 @@ def parse_args(): default=None, help="A unique string representing a type of run, which is useful when you're grouping runs together into larger experiments using group.", ) + parser.add_argument("--wandb-offline", action="store_true", help="Use wandb in offline mode") + parser.add_argument( + "--wandb-anonymous", action="store_true", help="Enable or explicitly disable anonymous logging" + ) parser.add_argument("--sequence-parallel", action="store_true", help="Set to enable sequence parallelism.") parser.add_argument("--fp8", action="store_true", help="Set to enable FP8") parser.add_argument("--micro-batch-size", type=int, default=1, help="Micro-batch size for data-parallel training.") @@ -358,15 +362,11 @@ def parse_args(): recompute_group = parser.add_mutually_exclusive_group(required=False) recompute_group.add_argument("--no-activation-checkpointing", action="store_true", default=False) recompute_group.add_argument("--selective-activation-checkpointing", action="store_true", default=False) - return parser.parse_args() + return parser.parse_args(args=args) -def main(): +def train(args: argparse.Namespace): """Main function to run Evo2 training.""" - args = parse_args() - - # Parse dataset configuration. - # Instantiate tokenizer. tokenizer = get_nmt_tokenizer( "byte-level", @@ -479,7 +479,7 @@ def main(): if args.tflops_callback: # Add callback that logs the tera-FLOPS per second per GPU during training. flop_meas_callback = FLOPsMeasurementCallback( - asdict(evo2_config), + evo2_config, data, "hyena", ) @@ -559,9 +559,11 @@ def main(): ), group=args.wandb_group, job_type=args.wandb_job_type, - id=args.wandb_run_id, # set this to use the same curve name for restarts. + id=args.wandb_run_id, project=args.wandb_project, save_dir=args.experiment_dir, + offline=args.wandb_offline, + anonymous=args.wandb_anonymous, ) loggers.append(wandb_logger) nemo_logger_kwargs["wandb"] = wandb_logger @@ -669,5 +671,11 @@ def main(): trainer.fit(model, data) +def main(): + """Parsing args and running evo2 training.""" + args = parse_args() + train(args=args) + + if __name__ == "__main__": main() diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py index c28c10b2f7..4811e2142e 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_train.py @@ -21,10 +21,17 @@ import sys import pytest +import torch from lightning.fabric.plugins.environments.lightning import find_free_network_port +from bionemo.evo2.run.train import parse_args, train +from bionemo.testing.megatron_parallel_state_utils import ( + distributed_model_parallel_state, +) + @pytest.mark.timeout(256) # Optional: fail if the test takes too long. +@pytest.mark.slow def test_train_evo2_runs(tmp_path, num_steps=5): """ This test runs the `train_evo2` command with mock data in a temporary directory. @@ -64,3 +71,80 @@ def test_train_evo2_runs(tmp_path, num_steps=5): # Assert that the command completed successfully. assert "reduced_train_loss:" in result.stdout assert result.returncode == 0, "train_evo2 command failed." + + +@pytest.mark.slow +@pytest.mark.parametrize("model_size", ["7b_nv", "7b_arc_longcontext"]) +def test_train_single_gpu(tmp_path, model_size: str): + """ + This test runs them single gpu evo2 training command with sample data in a temporary directory. + """ + num_steps = 5 + open_port = find_free_network_port() + # a local copy of the environment + env = dict(**os.environ) + env["MASTER_PORT"] = str(open_port) + + additional_args = [ + "--experiment-dir", + str(tmp_path), + "--model", + model_size, + "--num-layers", + str(4), + "--hybrid-override-pattern", + "SDH*", + "--no-activation-checkpointing", + "--add-bias-output", + "--max-steps", + str(num_steps), + "--warmup-steps", + str(1), + "--seq-length", + str(128), + "--wandb-offline", + "--wandb-anonymous", + "--mock-data", + ] + args = parse_args(args=additional_args) + with distributed_model_parallel_state(): + train(args=args) + + +@pytest.mark.slow +@pytest.mark.distributed +@pytest.mark.parametrize("model_size", ["7b_nv"]) +@pytest.mark.skip( + reason="This tests requires to be run on a multi-gpu machine with torchrun --nproc_per_node=N_GPU -m pytest TEST_NAME" +) +def test_train_multi_gpu(tmp_path, model_size: str): + """ + This test runs multi gpu distributed (tensor_model_parallel_size>1) evo2 training with sample data in a temporary directory. + """ + num_steps = 5 + world_size = torch.cuda.device_count() + print(f"Number of GPUs available: {world_size}") + if world_size < 2: + pytest.fail("This test requires at least 2 GPUs.") + + additional_args = [ + "--experiment-dir", + str(tmp_path), + "--model", + model_size, + "--add-bias-output", + "--max-steps", + str(num_steps), + "--warmup-steps", + str(1), + "--wandb-offline", + "--wandb-anonymous", + "--devices", + str(world_size), + "--tensor-parallel-size", + str(world_size), + ] + + with distributed_model_parallel_state(devices=world_size, tensor_model_parallel_size=world_size): + args = parse_args(args=additional_args) + train(args=args) From 1e7323be2b78a1d34b13a3a25a0c7b1a79cafe69 Mon Sep 17 00:00:00 2001 From: Dorota Toczydlowska <115542912+dorotat-nv@users.noreply.github.com> Date: Fri, 28 Feb 2025 12:32:28 +0100 Subject: [PATCH 108/140] Updates to benchmarks: evo2 (#705) ### Description Bugfixing and updating evo2 scripts for automated benchmarking execution ### Type of changes <!-- Mark the relevant option with an [x] --> - [x] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Refactor - [ ] Documentation update - [ ] Other (please describe): ### CI Pipeline Configuration Configure CI behavior by applying the relevant labels: - [SKIP_CI](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#skip_ci) - Skip all continuous integration tests - [INCLUDE_NOTEBOOKS_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_notebooks_tests) - Execute notebook validation tests in pytest - [INCLUDE_SLOW_TESTS](https://github.com/NVIDIA/bionemo-framework/blob/main/docs/docs/user-guide/contributing/contributing.md#include_slow_tests) - Execute tests labelled as slow in pytest for extensive testing > [!NOTE] > By default, the notebooks validation tests are skipped unless explicitly enabled. ### Usage <!--- How does a user interact with the changed code --> ```python TODO: Add code snippet ``` ### Pre-submit Checklist <!--- Ensure all items are completed before submitting --> - [x] I have tested these changes locally - [ ] I have updated the documentation accordingly - [ ] I have added/updated tests as needed - [ ] All existing tests pass successfully --- 3rdparty/NeMo | 2 +- ci/benchmarks/partial-conv/evo2_pretrain.yaml | 2 +- ci/benchmarks/perf/evo2_pretrain.yaml | 2 +- ci/benchmarks/test_dataset_config.yaml | 81 ------------------- .../src/bionemo/evo2/run/train.py | 4 +- .../evo2/data/test_dataset_config.yaml | 3 + .../tests/config/test_dataset_config.yaml | 54 ++++++------- 7 files changed, 36 insertions(+), 112 deletions(-) delete mode 100644 ci/benchmarks/test_dataset_config.yaml diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 2be3af56a4..44d08b5fe4 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 2be3af56a4eb57a4892c55b66e29a4a918a0867c +Subproject commit 44d08b5fe4a4a452c9c7b6f83ee2ccbc7e055f7f diff --git a/ci/benchmarks/partial-conv/evo2_pretrain.yaml b/ci/benchmarks/partial-conv/evo2_pretrain.yaml index 8963ea63e0..5877ed1bf6 100644 --- a/ci/benchmarks/partial-conv/evo2_pretrain.yaml +++ b/ci/benchmarks/partial-conv/evo2_pretrain.yaml @@ -36,7 +36,7 @@ script_args: value: 20000 script: |- WANDB_API_KEY=$BIONEMO_WANDB_API_KEY python ${workspace}/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py \ - -d ${workspace}/ci/benchmarks/test_dataset_config.yaml \ + -d ${workspace}/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml \ --dataset-dir ${data_path} \ --grad-acc-batches ${acc_grad} \ --fp8 \ diff --git a/ci/benchmarks/perf/evo2_pretrain.yaml b/ci/benchmarks/perf/evo2_pretrain.yaml index 185aa94713..e7956251ca 100644 --- a/ci/benchmarks/perf/evo2_pretrain.yaml +++ b/ci/benchmarks/perf/evo2_pretrain.yaml @@ -39,7 +39,7 @@ script_args: config_name: 40b script: |- WANDB_API_KEY=$BIONEMO_WANDB_API_KEY python ${workspace}/sub-packages/bionemo-evo2/src/bionemo/evo2/run/${variant}.py \ - -d ${workspace}/ci/benchmarks/test_dataset_config.yaml \ + -d ${workspace}/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml \ --dataset-dir ${data_path} \ --grad-acc-batches ${acc_grad} \ --fp8 \ diff --git a/ci/benchmarks/test_dataset_config.yaml b/ci/benchmarks/test_dataset_config.yaml deleted file mode 100644 index 63709d2cbd..0000000000 --- a/ci/benchmarks/test_dataset_config.yaml +++ /dev/null @@ -1,81 +0,0 @@ -- dataset_prefix: metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.18 -- dataset_prefix: gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.24 -- dataset_prefix: imgvr/pretraining_data_imgvr/data_imgvr_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.03 -- dataset_prefix: ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.02 -- dataset_prefix: mrna/pretraining_data_mrna/data_mrna_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.09 -- dataset_prefix: euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.09 -- dataset_prefix: euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.35 -- dataset_prefix: promoters/pretraining_data_promoters/data_promoters_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.0003 -- dataset_prefix: organelle/pretraining_data_organelle/data_organelle_train_text_CharLevelTokenizer_document - dataset_split: train - dataset_weight: 0.005 -- dataset_prefix: metagenomics/pretraining_data_metagenomics/data_metagenomics_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.18 -- dataset_prefix: gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.24 -- dataset_prefix: imgvr/pretraining_data_imgvr/data_imgvr_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.03 -- dataset_prefix: ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.02 -- dataset_prefix: mrna/pretraining_data_mrna/data_mrna_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.09 -- dataset_prefix: euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.09 -- dataset_prefix: euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.35 -- dataset_prefix: promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.0003 -- dataset_prefix: organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document - dataset_split: validation - dataset_weight: 0.005 -- dataset_prefix: metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.18 -- dataset_prefix: gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.24 -- dataset_prefix: imgvr/pretraining_data_imgvr/data_imgvr_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.03 -- dataset_prefix: ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.02 -- dataset_prefix: mrna/pretraining_data_mrna/data_mrna_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.09 -- dataset_prefix: euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.09 -- dataset_prefix: euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.35 -- dataset_prefix: promoters/pretraining_data_promoters/data_promoters_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.0003 -- dataset_prefix: organelle/pretraining_data_organelle/data_organelle_test_text_CharLevelTokenizer_document - dataset_split: test - dataset_weight: 0.005 diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index 5fff84abcd..a8c65a584d 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -393,7 +393,9 @@ def train(args: argparse.Namespace): tokenizer=tokenizer, ) else: - blended_dataset_config = parse_dataset_config(args.dataset_config, args.dataset_dir) + blended_dataset_config = parse_dataset_config( + dataset_config_path=args.dataset_config, dataset_path=args.dataset_dir + ) dataset_cls = Evo2DatasetPadEodLossMask if args.eod_pad_in_loss_mask else Evo2Dataset # Instantiate pre-training module. data = PreTrainingDataModule( diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml index 51c9606739..b73b8b214c 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml @@ -4,3 +4,6 @@ - dataset_prefix: /workspace/bionemo2/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_val dataset_split: validation dataset_weight: 1.0 +- dataset_prefix: /workspace/bionemo2/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_datasets/test_promoters_uint8_distinct_byte-level_test + dataset_split: test + dataset_weight: 1.0 diff --git a/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml index 5956d22498..c4c0609394 100644 --- a/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml +++ b/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml @@ -1,81 +1,81 @@ -- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document +- dataset_prefix: data/metagenomics/pretraining_data_metagenomics/data_metagenomics_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.18 -- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_train_text_CharLevelTokenizer_document +- dataset_prefix: data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.24 -- dataset_prefix: /workspace/bionemo2/data/imgvr/pretraining_data_imgvr/data_imgvr_train_text_CharLevelTokenizer_document +- dataset_prefix: data/imgvr/pretraining_data_imgvr/data_imgvr_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.03 -- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document +- dataset_prefix: data/ncrna/pretraining_data_ncrna/data_ncrna_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.02 -- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_train_text_CharLevelTokenizer_document +- dataset_prefix: data/mrna/pretraining_data_mrna/data_mrna_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.09 -- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_train_text_CharLevelTokenizer_document +- dataset_prefix: data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.09 -- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_train_text_CharLevelTokenizer_document +- dataset_prefix: data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.35 -- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_train_text_CharLevelTokenizer_document +- dataset_prefix: data/promoters/pretraining_data_promoters/data_promoters_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.0003 -- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_train_text_CharLevelTokenizer_document +- dataset_prefix: data/organelle/pretraining_data_organelle/data_organelle_train_text_CharLevelTokenizer_document dataset_split: train dataset_weight: 0.005 -- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/metagenomics/pretraining_data_metagenomics/data_metagenomics_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.18 -- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.24 -- dataset_prefix: /workspace/bionemo2/data/imgvr/pretraining_data_imgvr/data_imgvr_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/imgvr/pretraining_data_imgvr/data_imgvr_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.03 -- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/ncrna/pretraining_data_ncrna/data_ncrna_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.02 -- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/mrna/pretraining_data_mrna/data_mrna_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.09 -- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.09 -- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.35 -- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/promoters/pretraining_data_promoters/data_promoters_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.0003 -- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document +- dataset_prefix: data/organelle/pretraining_data_organelle/data_organelle_valid_text_CharLevelTokenizer_document dataset_split: validation dataset_weight: 0.005 -- dataset_prefix: /workspace/bionemo2/data/metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document +- dataset_prefix: data/metagenomics/pretraining_data_metagenomics/data_metagenomics_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.18 -- dataset_prefix: /workspace/bionemo2/data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document +- dataset_prefix: data/gtdb_v220/gtdb_v220_imgpr_merged_data/data_gtdb_imgpr_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.24 -- dataset_prefix: /workspace/bionemo2/data/imgvr/pretraining_data_imgvr/data_imgvr_test_text_CharLevelTokenizer_document +- dataset_prefix: data/imgvr/pretraining_data_imgvr/data_imgvr_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.03 -- dataset_prefix: /workspace/bionemo2/data/ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document +- dataset_prefix: data/ncrna/pretraining_data_ncrna/data_ncrna_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.02 -- dataset_prefix: /workspace/bionemo2/data/mrna/pretraining_data_mrna/data_mrna_test_text_CharLevelTokenizer_document +- dataset_prefix: data/mrna/pretraining_data_mrna/data_mrna_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.09 -- dataset_prefix: /workspace/bionemo2/data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_test_text_CharLevelTokenizer_document +- dataset_prefix: data/euk_windows/stitched_transcripts/pretraining_data_stiched_mrna/data_mrna_stitch_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.09 -- dataset_prefix: /workspace/bionemo2/data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_test_text_CharLevelTokenizer_document +- dataset_prefix: data/euk_windows/windows_split/5kb_windows_lowercase/5kb_windows_lowercase_pretraining_data/windows_5kb_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.35 -- dataset_prefix: /workspace/bionemo2/data/promoters/pretraining_data_promoters/data_promoters_test_text_CharLevelTokenizer_document +- dataset_prefix: data/promoters/pretraining_data_promoters/data_promoters_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.0003 -- dataset_prefix: /workspace/bionemo2/data/organelle/pretraining_data_organelle/data_organelle_test_text_CharLevelTokenizer_document +- dataset_prefix: data/organelle/pretraining_data_organelle/data_organelle_test_text_CharLevelTokenizer_document dataset_split: test dataset_weight: 0.005 From 24f1db09d20a971870e4372da7de20d7b2089b83 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Mon, 3 Mar 2025 16:34:46 -0800 Subject: [PATCH 109/140] Add brca1 zeroshot example + predict and scoring updates to evo2. Add brca1 zeroshot example + predict and scoring updates to evo2. --------- Signed-off-by: John St John <jstjohn@nvidia.com> Signed-off-by: Jared Wilber <jwilber@nvidia.com> Co-authored-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- .../examples/bionemo-evo2/.gitignore | 12 + .../bionemo-evo2/evo2_zeroshot_brca.ipynb | 1550 +++++++++++++++++ .../src/bionemo/evo2/run/predict.py | 172 +- 4 files changed, 1720 insertions(+), 16 deletions(-) create mode 100644 docs/docs/user-guide/examples/bionemo-evo2/.gitignore create mode 100644 docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 44d08b5fe4..dace808098 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 44d08b5fe4a4a452c9c7b6f83ee2ccbc7e055f7f +Subproject commit dace808098a2a82e3e733874a61eac9d36921b68 diff --git a/docs/docs/user-guide/examples/bionemo-evo2/.gitignore b/docs/docs/user-guide/examples/bionemo-evo2/.gitignore new file mode 100644 index 0000000000..fa71590940 --- /dev/null +++ b/docs/docs/user-guide/examples/bionemo-evo2/.gitignore @@ -0,0 +1,12 @@ +# ignore temp files made by this tutorial +# chromosome files +*.fa +*.fa.gz + +# config files +*.yaml + +# directories +nemo2_evo2_1b_8k/ +preprocessed_data/ +pretraining_demo/ diff --git a/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb b/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb new file mode 100644 index 0000000000..02e1bbc203 --- /dev/null +++ b/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb @@ -0,0 +1,1550 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zero-shot prediction of BRCA1 variant effects with Evo 2\n", + "\n", + "*Note - this notebook is a reproduction of The Arc Institute’s same-titled notebook [here](https://github.com/ArcInstitute/evo2/blob/main/notebooks/brca1/brca1_zero_shot_vep.ipynb), using the BioNeMo 2 implementation of Evo2.*\n", + "\n", + "The human *BRCA1* gene encodes for a protein that repairs damaged DNA ([Moynahan et al., 1999](https://www.cell.com/molecular-cell/fulltext/S1097-2765%2800%2980202-6)). Certain variants of this gene have been associated with an increased risk of breast and ovarian cancers ([Miki et al., 1994](https://www.science.org/doi/10.1126/science.7545954?url_ver=Z39.88-2003&rfr_id=ori:rid:crossref.org&rfr_dat=cr_pub%20%200pubmed)). Using Evo 2, we can predict whether a particular single nucleotide variant (SNV) of the *BRCA1* gene is likely to be harmful to the protein's function, and thus potentially increase the risk of cancer for the patient with the genetic variant." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/opt_einsum-3.4.0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/nvfuser-0.2.23a0+6627725-py3.12-linux-x86_64.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/lightning_utilities-0.12.0.dev0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/dill-0.3.9-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/looseversion-1.3.0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/lightning_thunder-0.2.0.dev0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n", + "Requirement already satisfied: biopython in /usr/local/lib/python3.12/dist-packages (1.85)\n", + "Requirement already satisfied: openpyxl in /usr/local/lib/python3.12/dist-packages (3.1.5)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from biopython) (1.26.4)\n", + "Requirement already satisfied: et-xmlfile in /usr/local/lib/python3.12/dist-packages (from openpyxl) (2.0.0)\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.3.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython -m pip install --upgrade pip\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install biopython openpyxl" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import glob\n", + "import gzip\n", + "import json\n", + "import math\n", + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import torch\n", + "from Bio import SeqIO\n", + "from pathlib import Path\n", + "from sklearn.metrics import roc_auc_score\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by loading a dataset from [Findlay et al. (2018)](https://www.nature.com/articles/s41586-018-0461-z), which contains experimentally measured function scores of 3,893 *BRCA1* SNVs. These function scores reflect the extent by which the genetic variant has disrupted the protein's function, with lower scores indicating greater disruption. In this dataset, the SNVs are classified into three categories based on their function scores: `LOF` (loss-of-function), `INT` (intermediate), and `FUNC` (functional). We start by reading in this dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Download the data if not present\n", + "if not os.path.exists('brca1'):\n", + " os.makedirs('brca1')\n", + "\n", + "commit_hash = \"3819474bee6c24938016614411f1fa025e542bbe\"\n", + "\n", + "if not os.path.exists(os.path.join('brca1', '41586_2018_461_MOESM3_ESM.xlsx')):\n", + " !wget https://github.com/ArcInstitute/evo2/raw/{commit_hash}/notebooks/brca1/41586_2018_461_MOESM3_ESM.xlsx -O brca1/41586_2018_461_MOESM3_ESM.xlsx\n", + "\n", + "if not os.path.exists(os.path.join('brca1', 'GRCh37.p13_chr17.fna.gz')):\n", + " !wget https://github.com/ArcInstitute/evo2/raw/{commit_hash}/notebooks/brca1/GRCh37.p13_chr17.fna.gz -O brca1/GRCh37.p13_chr17.fna.gz\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then group the `FUNC` and `INT` classes of SNVs together into a single category (`FUNC/INT`).\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>chrom</th>\n", + " <th>pos</th>\n", + " <th>ref</th>\n", + " <th>alt</th>\n", + " <th>score</th>\n", + " <th>class</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>17</td>\n", + " <td>41276135</td>\n", + " <td>T</td>\n", + " <td>G</td>\n", + " <td>-0.372611</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>17</td>\n", + " <td>41276135</td>\n", + " <td>T</td>\n", + " <td>C</td>\n", + " <td>-0.045313</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>17</td>\n", + " <td>41276135</td>\n", + " <td>T</td>\n", + " <td>A</td>\n", + " <td>-0.108254</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>17</td>\n", + " <td>41276134</td>\n", + " <td>T</td>\n", + " <td>G</td>\n", + " <td>-0.277963</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>17</td>\n", + " <td>41276134</td>\n", + " <td>T</td>\n", + " <td>C</td>\n", + " <td>-0.388414</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>17</td>\n", + " <td>41276134</td>\n", + " <td>T</td>\n", + " <td>A</td>\n", + " <td>-0.280973</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>6</th>\n", + " <td>17</td>\n", + " <td>41276133</td>\n", + " <td>C</td>\n", + " <td>T</td>\n", + " <td>-0.973683</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7</th>\n", + " <td>17</td>\n", + " <td>41276133</td>\n", + " <td>C</td>\n", + " <td>G</td>\n", + " <td>-0.373489</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>8</th>\n", + " <td>17</td>\n", + " <td>41276133</td>\n", + " <td>C</td>\n", + " <td>A</td>\n", + " <td>0.006314</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " <tr>\n", + " <th>9</th>\n", + " <td>17</td>\n", + " <td>41276132</td>\n", + " <td>A</td>\n", + " <td>T</td>\n", + " <td>-0.207552</td>\n", + " <td>FUNC/INT</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " chrom pos ref alt score class\n", + "0 17 41276135 T G -0.372611 FUNC/INT\n", + "1 17 41276135 T C -0.045313 FUNC/INT\n", + "2 17 41276135 T A -0.108254 FUNC/INT\n", + "3 17 41276134 T G -0.277963 FUNC/INT\n", + "4 17 41276134 T C -0.388414 FUNC/INT\n", + "5 17 41276134 T A -0.280973 FUNC/INT\n", + "6 17 41276133 C T -0.973683 FUNC/INT\n", + "7 17 41276133 C G -0.373489 FUNC/INT\n", + "8 17 41276133 C A 0.006314 FUNC/INT\n", + "9 17 41276132 A T -0.207552 FUNC/INT" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brca1_df = pd.read_excel(\n", + " os.path.join('brca1', '41586_2018_461_MOESM3_ESM.xlsx'),\n", + " header=2,\n", + ")\n", + "brca1_df = brca1_df[[\n", + " 'chromosome', 'position (hg19)', 'reference', 'alt', 'function.score.mean', 'func.class',\n", + "]]\n", + "\n", + "# Rename columns\n", + "brca1_df.rename(columns={\n", + " 'chromosome': 'chrom',\n", + " 'position (hg19)': 'pos',\n", + " 'reference': 'ref',\n", + " 'alt': 'alt',\n", + " 'function.score.mean': 'score',\n", + " 'func.class': 'class',\n", + "}, inplace=True)\n", + "\n", + "# Convert to two-class system\n", + "brca1_df['class'] = brca1_df['class'].replace(['FUNC', 'INT'], 'FUNC/INT')\n", + "\n", + "brca1_df.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We build a function to parse the reference and variant sequences of a 8,192-bp window around the genomic position of each SNV, using the reference sequence of human chromosome 17 where *BRCA1* is located.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "WINDOW_SIZE = 8192\n", + "\n", + "# Read the reference genome sequence of chromosome 17\n", + "with gzip.open(os.path.join('brca1', 'GRCh37.p13_chr17.fna.gz'), \"rt\") as handle:\n", + " for record in SeqIO.parse(handle, \"fasta\"):\n", + " seq_chr17 = str(record.seq)\n", + " break\n", + "\n", + "def parse_sequences(pos, ref, alt):\n", + " \"\"\"\n", + " Parse reference and variant sequences from the reference genome sequence.\n", + " \"\"\"\n", + " p = pos - 1 # Convert to 0-indexed position\n", + " full_seq = seq_chr17\n", + "\n", + " ref_seq_start = max(0, p - WINDOW_SIZE//2)\n", + " ref_seq_end = min(len(full_seq), p + WINDOW_SIZE//2)\n", + " ref_seq = seq_chr17[ref_seq_start:ref_seq_end]\n", + " snv_pos_in_ref = min(WINDOW_SIZE//2, p)\n", + " var_seq = ref_seq[:snv_pos_in_ref] + alt + ref_seq[snv_pos_in_ref+1:]\n", + "\n", + " # Sanity checks\n", + " assert len(var_seq) == len(ref_seq)\n", + " assert ref_seq[snv_pos_in_ref] == ref\n", + " assert var_seq[snv_pos_in_ref] == alt\n", + "\n", + " return ref_seq, var_seq" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make things run faster, we'll just look at a balanced sample of our data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(84, 6)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "disable_sample = False\n", + "SAMPLE_FRAC = 0.05\n", + "balanced_sample = True\n", + "\n", + "random_state = 42\n", + "if not disable_sample:\n", + " if balanced_sample:\n", + " # Get the number of rows in the dataframe\n", + " num_rows_minor_class = math.ceil(len(brca1_df[brca1_df['class'] == 'LOF']) * SAMPLE_FRAC)\n", + " brca1_df = pd.concat([\n", + " brca1_df[brca1_df['class'] == 'LOF'].sample(n=num_rows_minor_class, random_state=random_state),\n", + " brca1_df[brca1_df['class'] == 'FUNC/INT'].sample(n=num_rows_minor_class, random_state=random_state)\n", + " ]).sample(frac=1.0, random_state=random_state).reset_index(drop=True)\n", + " else:\n", + " # Calculate the number of rows to sample\n", + " num_rows_to_sample = int(len(brca1_df) * SAMPLE_FRAC)\n", + " brca1_df = brca1_df.sample(frac=SAMPLE_FRAC, random_state=random_state).reset_index(drop=True)\n", + "brca1_df.shape\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we'll write these to local `.fasta` files so we can use them for prediction below." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total unique reference sequences: 79\n", + "Total unique variant sequences: 84\n" + ] + } + ], + "source": [ + "# Create output directory\n", + "output_dir = Path(\"brca1_fasta_files\")\n", + "output_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + "# Save reference and variant sequences to FASTA\n", + "ref_fasta_path = output_dir / \"brca1_reference_sequences.fasta\"\n", + "var_fasta_path = output_dir / \"brca1_variant_sequences.fasta\"\n", + "\n", + "# Track unique sequences\n", + "ref_sequences = set()\n", + "var_sequences = set()\n", + "ref_seq_to_name = {}\n", + "# Store unique sequences with metadata for writing\n", + "ref_entries = []\n", + "var_entries = []\n", + "ref_names = []\n", + "var_names = []\n", + "# Collect unique reference and variant sequences\n", + "for idx, row in brca1_df.iterrows():\n", + " ref_seq, var_seq = parse_sequences(row['pos'], row['ref'], row['alt'])\n", + "\n", + " # Add to sets to ensure uniqueness\n", + " if ref_seq not in ref_sequences:\n", + " ref_sequences.add(ref_seq)\n", + " ref_name = f\"BRCA1_ref_pos_{row['pos']}_{row['ref']}_class_{row['class']}\"\n", + "\n", + " ref_entries.append(\n", + " f\">{ref_name}\\n{ref_seq}\\n\"\n", + " )\n", + " ref_names.append(ref_name)\n", + " ref_seq_to_name[ref_seq] = ref_name\n", + " else:\n", + " ref_name = ref_seq_to_name[ref_seq]\n", + " ref_names.append(ref_name)\n", + " if var_seq not in var_sequences:\n", + " var_sequences.add(var_seq)\n", + " var_name = f\"BRCA1_var_pos_{row['pos']}_{row['ref']}to{row['alt']}_class_{row['class']}\"\n", + "\n", + " var_entries.append(\n", + " f\">{var_name}\\n{var_seq}\\n\"\n", + " )\n", + " var_names.append(var_name)\n", + " else:\n", + " assert False, \"Duplicate variant sequence\"\n", + "\n", + "# Write unique sequences to FASTA files\n", + "with open(ref_fasta_path, \"w\") as f:\n", + " f.writelines(ref_entries)\n", + "\n", + "with open(var_fasta_path, \"w\") as f:\n", + " f.writelines(var_entries)\n", + "\n", + "\n", + "brca1_df['ref_fasta_name'] = ref_names\n", + "brca1_df['var_fasta_name'] = var_names\n", + "\n", + "# Print counts\n", + "print(f\"Total unique reference sequences: {len(ref_sequences)}\")\n", + "print(f\"Total unique variant sequences: {len(var_sequences)}\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Then, we load Evo 2 1B model, loading the Evo 2 weights from hugging face.\n", + "\n", + "*Note - for better performance, load the 7b model by replacing all occurrences of `1b` below with `7b`.*\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checkpoint directory is not empty. Skipping command.\n" + ] + } + ], + "source": [ + "# Define checkpoint path\n", + "checkpoint_path = Path(\"nemo2_evo2_1b_8k\")\n", + "\n", + "# Check if the directory does not exist or is empty\n", + "if not checkpoint_path.exists() or not any(checkpoint_path.iterdir()):\n", + " !evo2_convert_to_nemo2 --model-path hf://arcinstitute/savanna_evo2_1b_base --model-size 1b --output-dir nemo2_evo2_1b_8k\n", + "else:\n", + " print(\"Checkpoint directory is not empty. Skipping command.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we score the likelihoods of the reference and variant sequences of each SNV.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Define output directories for prediction results\n", + "predict_ref_dir = output_dir / \"reference_predictions\"\n", + "predict_var_dir = output_dir / \"variant_predictions\"\n", + "predict_ref_dir.mkdir(parents=True, exist_ok=True)\n", + "predict_var_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + "# Update predict commands to run on the full dataset\n", + "predict_ref_command = (\n", + " f\"predict_evo2 --fasta {ref_fasta_path} --ckpt-dir {checkpoint_path} \"\n", + " f\"--output-dir {predict_ref_dir} --model-size 1b --tensor-parallel-size 1 \"\n", + " \"--pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs\"\n", + ")\n", + "\n", + "predict_var_command = (\n", + " f\"predict_evo2 --fasta {var_fasta_path} --ckpt-dir {checkpoint_path} \"\n", + " f\"--output-dir {predict_var_dir} --model-size 1b --tensor-parallel-size 1 \"\n", + " \"--pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[NeMo W 2025-03-03 23:36:30 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[NeMo W 2025-03-03 23:36:31 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Experiments will be logged at /tmp/tmpsn4mexa6/default\n", + "[NeMo W 2025-03-03 23:36:31 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to /tmp/tmpsn4mexa6\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Using byte-level tokenization\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has embedding rank: 0\n", + "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", + "distributed_backend=nccl\n", + "All distributed processes registered. Starting with 1 processes\n", + "----------------------------------------------------------------------------------------------------\n", + "\n", + "[NeMo I 2025-03-03 23:36:31 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", + "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2]\n", + "[NeMo W 2025-03-03 23:36:32 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0 ,0): 1108204800\n", + "[NeMo I 2025-03-03 23:36:32 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=False, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "[NeMo I 2025-03-03 23:36:32 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + " Params for bucket 1 (1108204800 elements):\n", + " \tmodule.decoder.layers.18.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.0.mixer.dense.bias\n", + " \tmodule.decoder.layers.22.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.11.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.embedding.word_embeddings.weight\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.21.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.14.mixer.dense.weight\n", + " \tmodule.decoder.layers.12.mixer.dense.bias\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.17.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.13.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.5.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mixer.dense.bias\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.8.mixer.dense.bias\n", + " \tmodule.decoder.layers.3.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.22.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense.weight\n", + " \tmodule.decoder.layers.11.mixer.dense.bias\n", + " \tmodule.decoder.layers.6.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.18.mixer.dense.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.23.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.dense.weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.4.mixer.dense.weight\n", + " \tmodule.decoder.layers.20.mixer.dense.bias\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.15.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mixer.dense.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.21.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mixer.dense.bias\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.15.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.23.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.20.mixer.dense.weight\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.8.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.5.mixer.dense.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.23.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.14.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.22.mixer.dense.weight\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.2.mixer.dense.weight\n", + " \tmodule.decoder.layers.23.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.16.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.9.mixer.dense.bias\n", + " \tmodule.decoder.layers.8.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mixer.dense.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mixer.dense.bias\n", + " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.11.mixer.dense.weight\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.dense.weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.dense.bias\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mixer.dense.bias\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.19.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.14.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.21.mixer.dense.bias\n", + " \tmodule.decoder.layers.15.mixer.dense.bias\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.13.mixer.dense.weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.8.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.15.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.9.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.18.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.15.mixer.dense.weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mixer.dense.weight\n", + " \tmodule.decoder.layers.21.mixer.dense.weight\n", + " \tmodule.decoder.layers.19.mixer.dense.bias\n", + " \tmodule.decoder.layers.16.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.9.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.dense.bias\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.15.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.7.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.23.mixer.dense.bias\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.dense.weight\n", + " \tmodule.decoder.layers.18.mixer.dense.bias\n", + " \tmodule.decoder.layers.14.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mixer.dense.weight\n", + " \tmodule.decoder.layers.4.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.24.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.23.mixer.dense.weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.12.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.8.mixer.dense.weight\n", + " \tmodule.decoder.layers.6.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", + " \tmodule.decoder.final_norm.weight\n", + " \tmodule.decoder.layers.22.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.14.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] Using <megatron.core.dist_checkpointing.strategies.fully_parallel.FullyParallelLoadStrategyWrapper object at 0x769f8ed2e7e0> dist-ckpt load strategy.\n", + "[WARNING | py.warnings ]: /workspace/bionemo2/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", + " checkpoint.load_state_dict(\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/torch/distributed/checkpoint/planner_helpers.py:316: FutureWarning: Please use DTensor instead and we are deprecating ShardedTensor.\n", + " device = getattr(value, \"device\", None)\n", + "\n", + "[NeMo I 2025-03-03 23:36:33 nemo_logging:393] Global Checkpoint Load : Rank : 0 : Start time : 1741044992.504s : Time spent in load_checkpoint: 1.046s\n", + "[NeMo I 2025-03-03 23:36:33 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-03 23:36:33 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False), cleaning up.\n" + ] + } + ], + "source": [ + "!{predict_ref_command}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Predict variant seqs (sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[NeMo W 2025-03-03 23:37:15 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", + " \n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:239: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:985: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/layer_norm.py:1044: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:25: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/distributed/tensor_parallel.py:61: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:757: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", + " @custom_fwd\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/triton/ssd_combined.py:835: FutureWarning: `torch.cuda.amp.custom_bwd(args...)` is deprecated. Please use `torch.amp.custom_bwd(args..., device_type='cuda')` instead.\n", + " @custom_bwd\n", + "\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", + "[NeMo W 2025-03-03 23:37:17 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Experiments will be logged at /tmp/tmpcu9581ff/default\n", + "[NeMo W 2025-03-03 23:37:17 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to /tmp/tmpcu9581ff\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Using byte-level tokenization\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has embedding rank: 0\n", + "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", + "distributed_backend=nccl\n", + "All distributed processes registered. Starting with 1 processes\n", + "----------------------------------------------------------------------------------------------------\n", + "\n", + "[NeMo I 2025-03-03 23:37:17 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2]\n", + "[NeMo W 2025-03-03 23:37:17 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0 ,0): 1108204800\n", + "[NeMo I 2025-03-03 23:37:17 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=False, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "[NeMo I 2025-03-03 23:37:17 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + " Params for bucket 1 (1108204800 elements):\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.19.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.14.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.11.mixer.dense.bias\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mixer.dense.bias\n", + " \tmodule.decoder.layers.15.mixer.dense.bias\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.13.mixer.dense.weight\n", + " \tmodule.decoder.layers.8.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.15.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.18.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.15.mixer.dense.weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.9.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mixer.dense.weight\n", + " \tmodule.decoder.layers.19.mixer.dense.bias\n", + " \tmodule.decoder.layers.16.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.24.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.20.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.15.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.7.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.dense.bias\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.0.mixer.dense.bias\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.dense.weight\n", + " \tmodule.decoder.layers.18.mixer.dense.bias\n", + " \tmodule.decoder.layers.14.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.6.mixer.dense.weight\n", + " \tmodule.decoder.layers.4.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.dense.weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.12.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.11.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.8.mixer.dense.weight\n", + " \tmodule.decoder.layers.6.mixer.dense.bias\n", + " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.22.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.14.mixer.dense.bias\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.18.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.7.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.21.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.14.mixer.dense.weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.17.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.13.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.5.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mixer.dense.bias\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mixer.dense.bias\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.22.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense.weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.18.mixer.dense.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.23.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.dense.weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.4.mixer.dense.weight\n", + " \tmodule.embedding.word_embeddings.weight\n", + " \tmodule.decoder.layers.20.mixer.dense.bias\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.15.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.9.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.7.mixer.dense.weight\n", + " \tmodule.decoder.layers.2.mixer.dense.weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.21.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mixer.dense.weight\n", + " \tmodule.decoder.layers.22.mixer.dense.bias\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.15.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.20.mixer.dense.weight\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.5.mixer.dense.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.23.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.14.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mixer.dense.bias\n", + " \tmodule.decoder.layers.11.mixer.dense.weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.weight\n", + " \tmodule.decoder.final_norm.weight\n", + " \tmodule.decoder.layers.22.mixer.dense.weight\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.9.mixer.dense.weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.23.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.16.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.8.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.3.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.12.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.9.mixer.dense.bias\n", + " \tmodule.decoder.layers.7.mixer.dense.bias\n", + " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.dense.bias\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mixer.dense.weight\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Using <megatron.core.dist_checkpointing.strategies.fully_parallel.FullyParallelLoadStrategyWrapper object at 0x7766d25acb60> dist-ckpt load strategy.\n", + "[WARNING | py.warnings ]: /workspace/bionemo2/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", + " checkpoint.load_state_dict(\n", + "\n", + "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/torch/distributed/checkpoint/planner_helpers.py:316: FutureWarning: Please use DTensor instead and we are deprecating ShardedTensor.\n", + " device = getattr(value, \"device\", None)\n", + "\n", + "[NeMo I 2025-03-03 23:37:18 nemo_logging:393] Global Checkpoint Load : Rank : 0 : Start time : 1741045037.679s : Time spent in load_checkpoint: 1.103s\n", + "[NeMo I 2025-03-03 23:37:18 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-03 23:37:18 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False), cleaning up.\n" + ] + } + ], + "source": [ + "!{predict_var_command}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We calculate the change in likelihoods for each variant relative to the likelihood of their respective wild-type sequence.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we load the prediction files and sequence id maps:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Find and load prediction files\n", + "ref_pred_files = glob.glob(os.path.join(predict_ref_dir, \"predictions__rank_*.pt\"))\n", + "var_pred_files = glob.glob(os.path.join(predict_var_dir, \"predictions__rank_*.pt\"))\n", + "\n", + "# Load sequence ID maps (maps sequence ID -> prediction index)\n", + "with open(os.path.join(predict_ref_dir, \"seq_idx_map.json\"), \"r\") as f:\n", + " ref_seq_idx_map = json.load(f)\n", + "with open(os.path.join(predict_var_dir, \"seq_idx_map.json\"), \"r\") as f:\n", + " var_seq_idx_map = json.load(f)\n", + "\n", + "# Load predictions\n", + "ref_preds = torch.load(ref_pred_files[0])\n", + "var_preds = torch.load(var_pred_files[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, calculate the delta score:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>chrom</th>\n", + " <th>pos</th>\n", + " <th>ref</th>\n", + " <th>alt</th>\n", + " <th>score</th>\n", + " <th>class</th>\n", + " <th>ref_fasta_name</th>\n", + " <th>var_fasta_name</th>\n", + " <th>ref_log_probs</th>\n", + " <th>var_log_probs</th>\n", + " <th>evo2_delta_score</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>17</td>\n", + " <td>41199726</td>\n", + " <td>T</td>\n", + " <td>C</td>\n", + " <td>0.159762</td>\n", + " <td>FUNC/INT</td>\n", + " <td>BRCA1_ref_pos_41199726_T_class_FUNC/INT</td>\n", + " <td>BRCA1_var_pos_41199726_TtoC_class_FUNC/INT</td>\n", + " <td>-1.048409</td>\n", + " <td>-1.048462</td>\n", + " <td>-0.000054</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>17</td>\n", + " <td>41209074</td>\n", + " <td>T</td>\n", + " <td>A</td>\n", + " <td>-2.065569</td>\n", + " <td>LOF</td>\n", + " <td>BRCA1_ref_pos_41209074_T_class_LOF</td>\n", + " <td>BRCA1_var_pos_41209074_TtoA_class_LOF</td>\n", + " <td>-0.826655</td>\n", + " <td>-0.826915</td>\n", + " <td>-0.000260</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>17</td>\n", + " <td>41256913</td>\n", + " <td>A</td>\n", + " <td>C</td>\n", + " <td>-0.847753</td>\n", + " <td>FUNC/INT</td>\n", + " <td>BRCA1_ref_pos_41256913_A_class_FUNC/INT</td>\n", + " <td>BRCA1_var_pos_41256913_AtoC_class_FUNC/INT</td>\n", + " <td>-0.864035</td>\n", + " <td>-0.864014</td>\n", + " <td>0.000021</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>17</td>\n", + " <td>41219631</td>\n", + " <td>T</td>\n", + " <td>A</td>\n", + " <td>-2.053739</td>\n", + " <td>LOF</td>\n", + " <td>BRCA1_ref_pos_41219631_T_class_LOF</td>\n", + " <td>BRCA1_var_pos_41219631_TtoA_class_LOF</td>\n", + " <td>-1.091372</td>\n", + " <td>-1.091227</td>\n", + " <td>0.000145</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>17</td>\n", + " <td>41215965</td>\n", + " <td>G</td>\n", + " <td>A</td>\n", + " <td>-1.671525</td>\n", + " <td>LOF</td>\n", + " <td>BRCA1_ref_pos_41215965_G_class_LOF</td>\n", + " <td>BRCA1_var_pos_41215965_GtoA_class_LOF</td>\n", + " <td>-0.930776</td>\n", + " <td>-0.930750</td>\n", + " <td>0.000026</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " chrom pos ref alt score class \\\n", + "0 17 41199726 T C 0.159762 FUNC/INT \n", + "1 17 41209074 T A -2.065569 LOF \n", + "2 17 41256913 A C -0.847753 FUNC/INT \n", + "3 17 41219631 T A -2.053739 LOF \n", + "4 17 41215965 G A -1.671525 LOF \n", + "\n", + " ref_fasta_name \\\n", + "0 BRCA1_ref_pos_41199726_T_class_FUNC/INT \n", + "1 BRCA1_ref_pos_41209074_T_class_LOF \n", + "2 BRCA1_ref_pos_41256913_A_class_FUNC/INT \n", + "3 BRCA1_ref_pos_41219631_T_class_LOF \n", + "4 BRCA1_ref_pos_41215965_G_class_LOF \n", + "\n", + " var_fasta_name ref_log_probs var_log_probs \\\n", + "0 BRCA1_var_pos_41199726_TtoC_class_FUNC/INT -1.048409 -1.048462 \n", + "1 BRCA1_var_pos_41209074_TtoA_class_LOF -0.826655 -0.826915 \n", + "2 BRCA1_var_pos_41256913_AtoC_class_FUNC/INT -0.864035 -0.864014 \n", + "3 BRCA1_var_pos_41219631_TtoA_class_LOF -1.091372 -1.091227 \n", + "4 BRCA1_var_pos_41215965_GtoA_class_LOF -0.930776 -0.930750 \n", + "\n", + " evo2_delta_score \n", + "0 -0.000054 \n", + "1 -0.000260 \n", + "2 0.000021 \n", + "3 0.000145 \n", + "4 0.000026 " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# next, calculate change in likelihoods\n", + "ref_log_probs = []\n", + "var_log_probs = []\n", + "for _, row in brca1_df.iterrows():\n", + " ref_name = row['ref_fasta_name']\n", + " var_name = row['var_fasta_name']\n", + " ref_log_probs.append(ref_preds['log_probs_seqs'][ref_seq_idx_map[ref_name]].item())\n", + " var_log_probs.append(var_preds['log_probs_seqs'][var_seq_idx_map[var_name]].item())\n", + "brca1_df['ref_log_probs'] = ref_log_probs\n", + "brca1_df['var_log_probs'] = var_log_probs\n", + "# ideally probability of a broken variant is lower than a good one. So a bad var - good ref is negative.\n", + "brca1_df['evo2_delta_score'] = brca1_df['var_log_probs'] - brca1_df['ref_log_probs']\n", + "brca1_df.head()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This delta likelihood should be predictive of how disruptive the SNV is to the protein's function: the lower the delta, the more likely that the SNV is disruptive. We can show this by comparing the distributions of delta likelihoods for the two classes of SNVs (functional/intermediate vs loss-of-function)." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 400x200 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4, 2))\n", + "\n", + "# Plot stripplot of distributions\n", + "p = sns.stripplot(\n", + " data=brca1_df,\n", + " x='evo2_delta_score',\n", + " y='class',\n", + " hue='class',\n", + " order=['FUNC/INT', 'LOF'],\n", + " palette=['#777777', 'C3'],\n", + " size=2,\n", + " jitter=0.3,\n", + ")\n", + "\n", + "# Mark medians from each distribution\n", + "sns.boxplot(showmeans=True,\n", + " meanline=True,\n", + " meanprops={'visible': False},\n", + " medianprops={'color': 'k', 'ls': '-', 'lw': 2},\n", + " whiskerprops={'visible': False},\n", + " zorder=10,\n", + " x=\"evo2_delta_score\",\n", + " y=\"class\",\n", + " data=brca1_df,\n", + " showfliers=False,\n", + " showbox=False,\n", + " showcaps=False,\n", + " ax=p)\n", + "plt.xlabel('Delta likelihood score, Evo 2')\n", + "plt.ylabel('BRCA1 SNV class')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also calculate the area under the receiver operating characteristic curve (AUROC) of this zero-shot prediction method.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Zero-shot prediction AUROC: 0.4\n" + ] + } + ], + "source": [ + "# Calculate AUROC of zero-shot predictions\n", + "# class 1 is LOF which is the bad thing. That means we expect this to be more negative.\n", + "y_true = (brca1_df['class'] == 'LOF')\n", + "auroc = roc_auc_score(y_true, -brca1_df['evo2_delta_score'])\n", + "print(f'Zero-shot prediction AUROC: {auroc:.2}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py index 53d98d27bb..2ee0c051b1 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py @@ -26,10 +26,13 @@ import nemo.lightning as nl import torch from lightning.pytorch import LightningDataModule +from megatron.core import parallel_state +from megatron.core.tensor_parallel.mappings import _gather_along_last_dim from nemo.collections.llm.gpt.model.base import get_batch_on_this_context_parallel_rank, get_packed_seq_params from nemo.collections.llm.gpt.model.hyena import HYENA_MODEL_OPTIONS, HyenaModel from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer from nemo.lightning import NeMoLogger +from nemo.lightning.data import WrappedDataLoader from torch import Tensor from bionemo.llm.lightning import LightningPassthroughPredictionMixin @@ -46,6 +49,7 @@ def parse_args(): ap.add_argument("--fasta", type=Path, required=True, help="Fasta path from which to generate logit predictions.") ap.add_argument("--ckpt-dir", type=Path, required=True, help="NeMo2 checkpoint directory for inference.") + ap.add_argument("--prepend-bos", action="store_true", help="Prepend BOS token to sequences. Defaults to False.") ap.add_argument("--tensor-parallel-size", type=int, default=1, help="Order of tensor parallelism. Defaults to 1.") ap.add_argument( "--pipeline-model-parallel-size", type=int, default=1, help="Order of pipeline parallelism. Defaults to 1." @@ -53,6 +57,13 @@ def parse_args(): ap.add_argument( "--context-parallel-size", type=int, default=1, help="Order of context parallelism. Defaults to 1." ) + ap.add_argument( + "--no-sequence-parallel", + action="store_true", + help="When using TP, skip sequence parallelism. Otherwise sequence parallelism is used whenever tensor " + "parallelism is used. sequence parallelism should save a small amount of GPU memory so it's on" + " by default.", + ) ap.add_argument("--batch-size", type=int, default=1, help="Batch size for prediction. Defaults to 1.") ap.add_argument( "--model-size", @@ -77,32 +88,126 @@ def parse_args(): default="torch_dist", help="Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated.", ) - + ap.add_argument( + "--output-log-prob-seqs", action="store_true", help="Output log probability of sequences. Defaults to False." + ) + ap.add_argument( + "--log-prob-collapse-option", + choices=["sum", "mean"], + default="mean", + help="How to collapse the log probabilities across the sequence dimension.", + ) return ap.parse_args() +def _gather_along_cp_dim(input_, seq_dim: int = 1): + """Gather tensors and concatenate along the last dimension.""" + world_size = parallel_state.get_context_parallel_world_size() + # Bypass the function if we are using only 1 GPU. + if world_size == 1: + return input_ + + dim_size = list(input_.size()) + dim_size[0] = dim_size[0] * world_size + + output = torch.empty(dim_size, dtype=input_.dtype, device=torch.cuda.current_device()) + torch.distributed.all_gather_into_tensor( + output, input_.contiguous(), group=parallel_state.get_tensor_model_parallel_group() + ) + tensor_list = output.chunk(world_size, dim=0) + output = torch.cat(tensor_list, dim=seq_dim).contiguous() + + return output + + +def _collect_into_dim(input_: torch.Tensor, dim: int = -1): + """Gather tensors and concatenate along the last dimension, assuming the input shape is not split. + + This is needed when there is no sequence parallelism but tensor parallelism is enabled along the last dimension. + """ + world_size = parallel_state.get_tensor_model_parallel_world_size() + my_rank = parallel_state.get_tensor_model_parallel_rank() + # Bypass the function if we are using only 1 GPU. + if world_size == 1: + return input_ + my_chunk_input = input_.chunk(world_size, dim=dim)[my_rank] + dim_size = list(my_chunk_input.size()) + dim_size[0] = dim_size[0] * world_size + output = torch.empty(dim_size, dtype=my_chunk_input.dtype, device=torch.cuda.current_device()) + # Gather all chunks into the 0th dimension of the output tensor. + torch.distributed.all_gather_into_tensor( + output, my_chunk_input.contiguous(), group=parallel_state.get_tensor_model_parallel_group() + ) + # Split the output tensor back into the original chunks, now synchronized across GPUs that own each chunk. + tensor_list = output.chunk(world_size, dim=0) + output = torch.cat(tensor_list, dim=dim).contiguous() + + return output + + class HyenaPredictor(LightningPassthroughPredictionMixin, HyenaModel): """A predictor for the Hyena model. This adds in the predict step and the passthrough method.""" + def __init__( + self, + *args, + output_log_prob_seqs: bool = False, + log_prob_collapse_option: Literal["sum", "mean"] = "mean", + **kwargs, + ): + """Initialize the predictor with our needs around computing log probabilities.""" + super().__init__(*args, **kwargs) + self.output_log_prob_seqs = output_log_prob_seqs + self.log_prob_collapse_option = log_prob_collapse_option + def predict_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: """Alias for forward_step, also log the pad mask since sequences may not all have the same length.""" if len(batch) == 0: return forward_out = self.forward_step(batch) - if isinstance(forward_out, Tensor): - return {"token_logits": forward_out, "pad_mask": batch["loss_mask"], "seq_idx": batch["seq_idx"]} - return forward_out + if not isinstance(forward_out, Tensor): + return forward_out + # Reminder: the model's predictions for input i land at output i+1. To get everything to align, we prepend the + # EOS token to the input sequences and take the outputs for all but the first token. + forward_out_tp_gathered = _gather_along_last_dim(forward_out) + # else: + # forward_out_tp_gathered = _collect_into_dim(forward_out, dim=-1) + forward_out_gathered = _gather_along_cp_dim(forward_out_tp_gathered) + assert self.tokenizer.vocab_size == forward_out_gathered.shape[-1] + if self.output_log_prob_seqs: + softmax_logprobs = torch.log_softmax(forward_out_gathered, dim=-1) + softmax_logprobs = softmax_logprobs[:, :-1] + input_ids = batch["tokens"][:, 1:] + assert softmax_logprobs.shape[1] == input_ids.shape[1] + + logprobs = torch.gather( + softmax_logprobs, # Gather likelihoods... + 2, # along the vocab dimension... + input_ids.unsqueeze(-1), # using the token ids to index. + ).squeeze(-1) + log_prob_seqs = torch.sum(logprobs * batch["loss_mask"][:, 1:].float(), dim=-1) + if self.log_prob_collapse_option == "mean": + log_prob_seqs = log_prob_seqs / (batch["loss_mask"][:, 1:].float().sum(dim=-1) + 1e-8) + return {"log_probs_seqs": log_prob_seqs.cpu(), "seq_idx": batch["seq_idx"].cpu()} + else: + # If the user wants to match back to logits, then they will need to do the offsetting logic themselves. + return { + "token_logits": forward_out_gathered.cpu(), + "pad_mask": batch["loss_mask"].cpu(), + "seq_idx": batch["seq_idx"].cpu(), + } class SimpleFastaDataset(torch.utils.data.Dataset): """A simple dataset for Evo2 prediction.""" - def __init__(self, fasta_path: Path, tokenizer): + def __init__(self, fasta_path: Path, tokenizer, prepend_bos: bool = True): """Initialize the dataset.""" super().__init__() self.fasta = NvFaidx(fasta_path) - self.seqids = list(self.fasta.keys()) + self.seqids = sorted(self.fasta.keys()) self.tokenizer = tokenizer + self.prepend_bos = prepend_bos # needed for getting predictions for the requested set of tokens. def write_idx_map(self, output_dir: Path): """Write the index map to the output directory.""" @@ -116,12 +221,22 @@ def __len__(self): def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: """Get an item from the dataset.""" sequence = self.fasta[self.seqids[idx]].sequence().upper() - tokens: list[int] = self.tokenizer.text_to_ids(sequence) + tokenized_seq = self.tokenizer.text_to_ids(sequence) + if self.prepend_bos: # in pretraining we use EOS to start new sequences. + tokens: list[int] = [self.tokenizer.eod] + tokenized_seq + else: + tokens: list[int] = tokenized_seq + loss_mask = torch.ones_like(torch.tensor(tokens, dtype=torch.long), dtype=torch.long) + if self.prepend_bos: + loss_mask[0] = ( + 0 # mask the eos token which we use for causal offsetting. Later in predict we take the output + ) + # for the first [:-1] tokens which align with the sequence starting after the EOS. return { "tokens": torch.tensor(tokens, dtype=torch.long), "position_ids": torch.arange(len(tokens), dtype=torch.long), "seq_idx": torch.tensor(idx, dtype=torch.long), - "loss_mask": torch.ones_like(torch.tensor(tokens, dtype=torch.long), dtype=torch.long), + "loss_mask": loss_mask, } @@ -211,7 +326,15 @@ def setup(self, stage: Optional[str] = None) -> None: def predict_dataloader(self): """Create a dataloader for prediction.""" - return torch.utils.data.DataLoader(self.dataset, batch_size=self.batch_size, shuffle=False) + # need to use this to communicate that we are in predict mode and safe to not drop last batch + return WrappedDataLoader( + mode="predict", + dataset=self.dataset, + batch_size=self.batch_size, + num_workers=8, + shuffle=False, + drop_last=False, + ) def predict( @@ -226,6 +349,10 @@ def predict( fp8: bool = False, work_dir: Path | None = None, batch_size: int = 1, + output_log_prob_seqs: bool = False, + log_prob_collapse_option: Literal["sum", "mean"] = "mean", + prepend_bos: bool = False, + no_sequence_parallel: bool = False, ): """Inference workflow for Evo2. @@ -234,6 +361,7 @@ def predict( """ if work_dir is None: work_dir = Path(tempfile.mkdtemp()) + sequence_parallel = tensor_parallel_size > 1 and not no_sequence_parallel output_dir.mkdir(parents=True, exist_ok=True) # Make sure the output directory exists, files will be written here. model_parallel_size = tensor_parallel_size * pipeline_model_parallel_size * context_parallel_size if model_parallel_size > torch.cuda.device_count(): @@ -246,6 +374,7 @@ def predict( accelerator="gpu", devices=model_parallel_size, strategy=nl.MegatronStrategy( + drop_last_batch=False, tensor_model_parallel_size=tensor_parallel_size, pipeline_model_parallel_size=pipeline_model_parallel_size, context_parallel_size=context_parallel_size, @@ -253,11 +382,12 @@ def predict( ckpt_load_optimizer=False, # Needs to be false for a normal model checkpoint. ckpt_save_optimizer=False, ckpt_async_save=False, + sequence_parallel=tensor_parallel_size > 1 and sequence_parallel, save_ckpt_format=ckpt_format, ckpt_load_strictness="log_all", data_sampler=nl.MegatronDataSampler( - micro_batch_size=1, - global_batch_size=1, + micro_batch_size=batch_size, + global_batch_size=batch_size, seq_len=8192, output_log=False, # this is needed for predict step to work ), @@ -282,7 +412,9 @@ def predict( ), ) config = HYENA_MODEL_OPTIONS[model_size]( - forward_step_fn=hyena_predict_forward_step, data_step_fn=hyena_predict_data_step + forward_step_fn=hyena_predict_forward_step, + data_step_fn=hyena_predict_data_step, # , attention_backend=AttnBackend.fused, + distribute_saved_activations=False if sequence_parallel and tensor_parallel_size > 1 else True, ) trainer.strategy._setup_optimizers = False @@ -296,15 +428,21 @@ def predict( path=str(ckpt_dir), # NeMo expects a string path. load_model_state=True, load_optim_state=False, + load_artifacts=False, ), ) tokenizer = get_nmt_tokenizer("byte-level") - model = HyenaPredictor(config, tokenizer=tokenizer) + model = HyenaPredictor( + config, + tokenizer=tokenizer, + output_log_prob_seqs=output_log_prob_seqs, + log_prob_collapse_option=log_prob_collapse_option, + ) resume.setup(trainer, model) # this pulls weights from the starting checkpoint. - dataset = SimpleFastaDataset(fasta_path, tokenizer) + dataset = SimpleFastaDataset(fasta_path, tokenizer, prepend_bos=prepend_bos) datamodule = PredictDataModule(dataset, batch_size=batch_size) - trainer.predict(model, datamodule.predict_dataloader()) + trainer.predict(model, datamodule=datamodule) dataset.write_idx_map( output_dir ) # Finally write out the index map so we can match the predictions to the original sequences. @@ -324,6 +462,10 @@ def main(): ckpt_format=args.ckpt_format, fp8=args.fp8, batch_size=args.batch_size, + output_log_prob_seqs=args.output_log_prob_seqs, + log_prob_collapse_option=args.log_prob_collapse_option, + prepend_bos=args.prepend_bos, + no_sequence_parallel=args.no_sequence_parallel, ) From e01214693697b1dddc92da5034322a373e0a03bd Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 00:46:44 +0000 Subject: [PATCH 110/140] Add vortex style fp8 support to predict Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- .../src/bionemo/evo2/run/predict.py | 44 +++++++------------ 2 files changed, 17 insertions(+), 29 deletions(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index dace808098..5afbbadf20 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit dace808098a2a82e3e733874a61eac9d36921b68 +Subproject commit 5afbbadf20177410753eb5f241822198648818fc diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py index 2ee0c051b1..2c1769803c 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py @@ -79,6 +79,12 @@ def parse_args(): default=None, help="Output dir that will contain the generated text produced by the Evo2 model. If not provided, the output will be logged.", ) + ap.add_argument( + "--full-fp8", + action="store_true", + help="Use full FP8 precision (faster but less accurate) rather than vortex style which " + "only applies FP8 to the projection layer of the hyena mixer, when using FP8.", + ) ap.add_argument("--fp8", action="store_true", help="Use FP8 precision. Defaults to BF16.") # extra: ap.add_argument( @@ -120,31 +126,6 @@ def _gather_along_cp_dim(input_, seq_dim: int = 1): return output -def _collect_into_dim(input_: torch.Tensor, dim: int = -1): - """Gather tensors and concatenate along the last dimension, assuming the input shape is not split. - - This is needed when there is no sequence parallelism but tensor parallelism is enabled along the last dimension. - """ - world_size = parallel_state.get_tensor_model_parallel_world_size() - my_rank = parallel_state.get_tensor_model_parallel_rank() - # Bypass the function if we are using only 1 GPU. - if world_size == 1: - return input_ - my_chunk_input = input_.chunk(world_size, dim=dim)[my_rank] - dim_size = list(my_chunk_input.size()) - dim_size[0] = dim_size[0] * world_size - output = torch.empty(dim_size, dtype=my_chunk_input.dtype, device=torch.cuda.current_device()) - # Gather all chunks into the 0th dimension of the output tensor. - torch.distributed.all_gather_into_tensor( - output, my_chunk_input.contiguous(), group=parallel_state.get_tensor_model_parallel_group() - ) - # Split the output tensor back into the original chunks, now synchronized across GPUs that own each chunk. - tensor_list = output.chunk(world_size, dim=0) - output = torch.cat(tensor_list, dim=dim).contiguous() - - return output - - class HyenaPredictor(LightningPassthroughPredictionMixin, HyenaModel): """A predictor for the Hyena model. This adds in the predict step and the passthrough method.""" @@ -347,6 +328,7 @@ def predict( model_size: str = "7b", ckpt_format: CheckpointFormats = "torch_dist", fp8: bool = False, + full_fp8: bool = False, work_dir: Path | None = None, batch_size: int = 1, output_log_prob_seqs: bool = False, @@ -406,15 +388,20 @@ def predict( plugins=nl.MegatronMixedPrecision( precision="bf16-mixed", params_dtype=torch.bfloat16, - fp8="hybrid" if fp8 else None, - fp8_amax_history_len=16 if fp8 else 1, - fp8_amax_compute_algo="max" if fp8 else "most_recent", + # Only use FP8 in this plugin when using full FP8 precision and FP8. + # Otherwise use vortex_style_fp8 in the model config. + fp8="hybrid" if fp8 and full_fp8 else None, + fp8_amax_history_len=16 if fp8 and full_fp8 else 1, + fp8_amax_compute_algo="max" if fp8 and full_fp8 else "most_recent", ), ) config = HYENA_MODEL_OPTIONS[model_size]( forward_step_fn=hyena_predict_forward_step, data_step_fn=hyena_predict_data_step, # , attention_backend=AttnBackend.fused, distribute_saved_activations=False if sequence_parallel and tensor_parallel_size > 1 else True, + # Only use vortex style FP8 in the model config if using FP8 and not full FP8. This will only apply FP8 to + # the projection layer of the hyena mixer. + vortex_style_fp8=fp8 and not full_fp8, ) trainer.strategy._setup_optimizers = False @@ -461,6 +448,7 @@ def main(): model_size=args.model_size, ckpt_format=args.ckpt_format, fp8=args.fp8, + full_fp8=args.full_fp8, batch_size=args.batch_size, output_log_prob_seqs=args.output_log_prob_seqs, log_prob_collapse_option=args.log_prob_collapse_option, From ec662e4e9f8e5f4b0b8c17196acd4a5be096b7e7 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 01:20:12 +0000 Subject: [PATCH 111/140] Update the brca notebook with a run on an fp8 supporting machine --- .../examples/bionemo-evo2/.gitignore | 2 + .../bionemo-evo2/evo2_zeroshot_brca.ipynb | 985 +++++++++--------- 2 files changed, 512 insertions(+), 475 deletions(-) diff --git a/docs/docs/user-guide/examples/bionemo-evo2/.gitignore b/docs/docs/user-guide/examples/bionemo-evo2/.gitignore index fa71590940..465fe23294 100644 --- a/docs/docs/user-guide/examples/bionemo-evo2/.gitignore +++ b/docs/docs/user-guide/examples/bionemo-evo2/.gitignore @@ -10,3 +10,5 @@ nemo2_evo2_1b_8k/ preprocessed_data/ pretraining_demo/ +brca1_fasta_files/ +brca1/ diff --git a/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb b/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb index 02e1bbc203..7574ebc5dd 100644 --- a/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb +++ b/docs/docs/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca.ipynb @@ -13,19 +13,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/opt_einsum-3.4.0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/nvfuser-0.2.23a0+6627725-py3.12-linux-x86_64.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/lightning_utilities-0.12.0.dev0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", - "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/dill-0.3.9-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/lightning_utilities-0.12.0.dev0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/looseversion-1.3.0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/nvfuser-0.2.23a0+6627725-py3.12-linux-x86_64.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/opt_einsum-3.4.0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/lightning_thunder-0.2.0.dev0-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: Loading egg at /usr/local/lib/python3.12/dist-packages/dill-0.3.9-py3.12.egg is deprecated. pip 25.1 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\u001b[0m\u001b[33m\n", "\u001b[0mLooking in indexes: https://pypi.org/simple, https://pypi.ngc.nvidia.com\n", "Requirement already satisfied: biopython in /usr/local/lib/python3.12/dist-packages (1.85)\n", "Requirement already satisfied: openpyxl in /usr/local/lib/python3.12/dist-packages (3.1.5)\n", @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -98,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -239,7 +239,7 @@ "9 17 41276132 A T -0.207552 FUNC/INT" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -316,28 +316,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To make things run faster, we'll just look at a balanced sample of our data." + "To make things run faster, we'll just look at a balanced sample of our data. If you want to run on the full dataset, set `disable_sample=True`" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(84, 6)" + "(330, 6)" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "disable_sample = False\n", - "SAMPLE_FRAC = 0.05\n", + "SAMPLE_FRAC = 0.2\n", "balanced_sample = True\n", "\n", "random_state = 42\n", @@ -365,15 +365,15 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Total unique reference sequences: 79\n", - "Total unique variant sequences: 84\n" + "Total unique reference sequences: 296\n", + "Total unique variant sequences: 330\n" ] } ], @@ -447,13 +447,13 @@ "\n", "Then, we load Evo 2 1B model, loading the Evo 2 weights from hugging face.\n", "\n", - "*Note - for better performance, load the 7b model by replacing all occurrences of `1b` below with `7b`.*\n", + "*Note - for better performance, load the 7b model by setting `MODEL_SIZE=\"7b\"` which also works well GPUs that do not support FP8.*\n", "\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -465,12 +465,13 @@ } ], "source": [ + "MODEL_SIZE = \"1b\" # also try 7b if you have a GPU with more than 32GB of memory\n", "# Define checkpoint path\n", - "checkpoint_path = Path(\"nemo2_evo2_1b_8k\")\n", + "checkpoint_path = Path(f\"nemo2_evo2_{MODEL_SIZE}_8k\")\n", "\n", "# Check if the directory does not exist or is empty\n", "if not checkpoint_path.exists() or not any(checkpoint_path.iterdir()):\n", - " !evo2_convert_to_nemo2 --model-path hf://arcinstitute/savanna_evo2_1b_base --model-size 1b --output-dir nemo2_evo2_1b_8k\n", + " !evo2_convert_to_nemo2 --model-path hf://arcinstitute/savanna_evo2_1b_base --model-size {MODEL_SIZE} --output-dir nemo2_evo2_{MODEL_SIZE}_8k\n", "else:\n", " print(\"Checkpoint directory is not empty. Skipping command.\")\n" ] @@ -484,40 +485,80 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FP8 Support: True\n", + "Device: NVIDIA RTX 6000 Ada Generation, Compute Capability: 8.9\n" + ] + } + ], "source": [ "# Define output directories for prediction results\n", "predict_ref_dir = output_dir / \"reference_predictions\"\n", "predict_var_dir = output_dir / \"variant_predictions\"\n", "predict_ref_dir.mkdir(parents=True, exist_ok=True)\n", "predict_var_dir.mkdir(parents=True, exist_ok=True)\n", + "# Check if FP8 is supported on the current GPU\n", + "import torch\n", + "\n", + "def check_fp8_support():\n", + " \"\"\"\n", + " Check if FP8 is supported on the current GPU.\n", + " FP8 requires compute capability 8.9+ (Ada Lovelace/Hopper architecture or newer).\n", + " \"\"\"\n", + " if not torch.cuda.is_available():\n", + " return False, \"CUDA not available\"\n", + " \n", + " device_props = torch.cuda.get_device_properties(0)\n", + " compute_capability = f\"{device_props.major}.{device_props.minor}\"\n", + " device_name = device_props.name\n", + " \n", + " # FP8 is supported on compute capability 8.9+ (Ada Lovelace/Hopper architecture)\n", + " is_supported = (device_props.major > 8) or (device_props.major == 8 and device_props.minor >= 9)\n", + " \n", + " return is_supported, f\"Device: {device_name}, Compute Capability: {compute_capability}\"\n", + "\n", + "fp8_supported, gpu_info = check_fp8_support()\n", + "print(f\"FP8 Support: {fp8_supported}\")\n", + "print(gpu_info)\n", + "\n", + "# Note: If FP8 is not supported, you may want to disable it in the model config\n", + "# The Evo2 config has 'use_fp8_input_projections: True' by default\n", + "\n", + "fp8_option = \"--fp8\" if fp8_supported else \"\"\n", "\n", "# Update predict commands to run on the full dataset\n", "predict_ref_command = (\n", " f\"predict_evo2 --fasta {ref_fasta_path} --ckpt-dir {checkpoint_path} \"\n", - " f\"--output-dir {predict_ref_dir} --model-size 1b --tensor-parallel-size 1 \"\n", - " \"--pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs\"\n", + " f\"--output-dir {predict_ref_dir} --model-size {MODEL_SIZE} --tensor-parallel-size 1 \"\n", + " f\"--pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs {fp8_option}\"\n", ")\n", "\n", "predict_var_command = (\n", " f\"predict_evo2 --fasta {var_fasta_path} --ckpt-dir {checkpoint_path} \"\n", - " f\"--output-dir {predict_var_dir} --model-size 1b --tensor-parallel-size 1 \"\n", - " \"--pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs\"\n", + " f\"--output-dir {predict_var_dir} --model-size {MODEL_SIZE} --tensor-parallel-size 1 \"\n", + " f\"--pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs {fp8_option}\"\n", ")" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2025-03-03 23:36:30 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "Running command: predict_evo2 --fasta brca1_fasta_files/brca1_reference_sequences.fasta --ckpt-dir nemo2_evo2_1b_8k --output-dir brca1_fasta_files/reference_predictions --model-size 1b --tensor-parallel-size 1 --pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs --fp8\n", + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[NeMo W 2025-03-04 01:01:10 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", @@ -547,318 +588,319 @@ "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", - "[NeMo W 2025-03-03 23:36:31 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Experiments will be logged at /tmp/tmpsn4mexa6/default\n", - "[NeMo W 2025-03-03 23:36:31 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to /tmp/tmpsn4mexa6\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Using byte-level tokenization\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All context parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All model parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has embedding group: [0]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] All embedding group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:36:31 nemo_logging:393] Rank 0 has embedding rank: 0\n", + "[NeMo W 2025-03-04 01:01:11 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Experiments will be logged at /tmp/tmpupzx4lk1/default\n", + "[NeMo W 2025-03-04 01:01:11 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to /tmp/tmpupzx4lk1\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Using byte-level tokenization\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "[NeMo I 2025-03-03 23:36:31 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", - "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:36:32 random:220] CPU RNG state changed within GPU RNG context\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2]\n", - "[NeMo W 2025-03-03 23:36:32 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0 ,0): 1108204800\n", - "[NeMo I 2025-03-03 23:36:32 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=False, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", - "[NeMo I 2025-03-03 23:36:32 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + "[NeMo I 2025-03-04 01:01:11 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:01:11 random:220] CPU RNG state changed within GPU RNG context\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[NeMo W 2025-03-04 01:01:11 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0 ,0): 1108204800\n", + "[NeMo I 2025-03-04 01:01:11 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=False, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "[NeMo I 2025-03-04 01:01:11 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", " Params for bucket 1 (1108204800 elements):\n", - " \tmodule.decoder.layers.18.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.16.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.13.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.8.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.6.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", - " \tmodule.decoder.layers.0.mixer.dense.bias\n", - " \tmodule.decoder.layers.22.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.20.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.14.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.9.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.7.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.23.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.18.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.15.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.13.mixer.mixer.filter.p\n", - " \tmodule.decoder.layers.11.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.7.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.embedding.word_embeddings.weight\n", - " \tmodule.decoder.layers.24.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.24.self_attention.linear_proj.weight\n", - " \tmodule.decoder.layers.21.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.14.mixer.dense.weight\n", - " \tmodule.decoder.layers.12.mixer.dense.bias\n", - " \tmodule.decoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.9.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.4.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.20.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.17.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.13.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.10.self_attention.linear_qkv.weight\n", - " \tmodule.decoder.layers.7.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.5.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", - " \tmodule.decoder.layers.24.self_attention.linear_qkv.layer_norm_weight\n", - " \tmodule.decoder.layers.23.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.18.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.16.mixer.dense.bias\n", - " \tmodule.decoder.layers.13.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.9.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.8.mixer.dense.bias\n", - " \tmodule.decoder.layers.3.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.22.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.19.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.17.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.15.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.12.mixer.dense.weight\n", - " \tmodule.decoder.layers.11.mixer.dense.bias\n", - " \tmodule.decoder.layers.6.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.18.mixer.dense.weight\n", - " \tmodule.decoder.layers.15.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.13.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.7.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.23.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.16.mixer.dense.weight\n", - " \tmodule.decoder.layers.14.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.8.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.6.mixer.mixer.filter.p\n", - " \tmodule.decoder.layers.4.mixer.dense.weight\n", - " \tmodule.decoder.layers.20.mixer.dense.bias\n", - " \tmodule.decoder.layers.17.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", - " \tmodule.decoder.layers.15.mixer.mixer.filter.h\n", - " \tmodule.decoder.layers.13.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.11.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.7.mixer.dense.weight\n", - " \tmodule.decoder.layers.6.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.24.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.23.mixer.mixer.filter.p\n", - " \tmodule.decoder.layers.21.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.19.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.11.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.6.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.3.self_attention.linear_qkv.weight\n", - " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", " \tmodule.decoder.layers.22.mixer.dense.bias\n", - " \tmodule.decoder.layers.19.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.15.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.19.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.16.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.9.mixer.dense.bias\n", " \tmodule.decoder.layers.6.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.5.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.23.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.20.mixer.dense.weight\n", - " \tmodule.decoder.layers.18.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.16.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.11.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.8.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.5.mixer.dense.weight\n", - " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.17.self_attention.linear_proj.weight\n", - " \tmodule.decoder.layers.24.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.23.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.22.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.19.mixer.mixer.filter.h\n", - " \tmodule.decoder.layers.14.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.11.mixer.dense.weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", " \tmodule.decoder.layers.8.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.4.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.22.mixer.dense.weight\n", - " \tmodule.decoder.layers.13.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.10.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.dense.weight\n", " \tmodule.decoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.5.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.2.mixer.dense.weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.23.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.19.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.16.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.11.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.9.mixer.dense.bias\n", + " \tmodule.decoder.layers.13.mixer.dense.bias\n", + " \tmodule.decoder.layers.10.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.8.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.6.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.4.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.0.mixer.dense.weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mixer.dense.weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", " \tmodule.decoder.layers.22.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.10.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.7.mixer.dense.bias\n", - " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.2.mixer.dense.bias\n", - " \tmodule.decoder.layers.1.mixer.dense.bias\n", - " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.11.mixer.dense.weight\n", - " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.3.self_attention.linear_proj.weight\n", - " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.9.mixer.dense.weight\n", - " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.13.mixer.dense.bias\n", - " \tmodule.decoder.layers.10.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.5.mixer.dense.bias\n", - " \tmodule.decoder.layers.21.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.19.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.16.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.14.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.12.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.6.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.3.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.21.mixer.dense.bias\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.15.mixer.dense.bias\n", " \tmodule.decoder.layers.12.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", - " \tmodule.decoder.layers.4.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.23.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.20.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.8.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", + " \tmodule.decoder.final_norm.weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.16.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.13.mixer.dense.weight\n", " \tmodule.decoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", - " \tmodule.decoder.layers.8.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.5.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.21.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.19.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.16.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.15.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.12.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.10.self_attention.linear_proj.weight\n", - " \tmodule.decoder.layers.9.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.22.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.20.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mixer.dense.bias\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.18.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.15.mixer.dense.weight\n", - " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.1.mixer.dense.weight\n", - " \tmodule.decoder.layers.21.mixer.dense.weight\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.19.mixer.dense.bias\n", " \tmodule.decoder.layers.16.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.12.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.9.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.4.mixer.dense.bias\n", - " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.20.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.17.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.15.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.13.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.7.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.5.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", - " \tmodule.decoder.layers.23.mixer.dense.bias\n", - " \tmodule.decoder.layers.20.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.19.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.16.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.14.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.8.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.19.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.14.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.11.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.5.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", - " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", - " \tmodule.decoder.layers.22.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mixer.dense.bias\n", + " \tmodule.decoder.layers.22.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.19.mixer.dense.weight\n", " \tmodule.decoder.layers.18.mixer.dense.bias\n", " \tmodule.decoder.layers.14.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.9.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.9.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.6.mixer.dense.weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.4.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.22.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.20.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.21.mixer.dense.weight\n", " \tmodule.decoder.layers.16.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.13.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.8.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.5.mixer.mixer.filter.h\n", - " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.24.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.23.mixer.dense.weight\n", - " \tmodule.decoder.layers.21.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.21.mixer.dense.bias\n", " \tmodule.decoder.layers.19.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.14.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.12.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.9.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.7.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.23.mixer.dense.bias\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.14.mixer.dense.bias\n", + " \tmodule.decoder.layers.8.mixer.dense.bias\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.18.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.6.mixer.dense.weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.20.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.23.mixer.dense.weight\n", + " \tmodule.decoder.layers.21.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.18.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.11.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.8.mixer.dense.weight\n", - " \tmodule.decoder.layers.6.mixer.dense.bias\n", - " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", - " \tmodule.decoder.final_norm.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.24.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.22.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.20.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.18.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.14.mixer.dense.bias\n", - " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", - "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", - "[NeMo I 2025-03-03 23:36:32 nemo_logging:393] Using <megatron.core.dist_checkpointing.strategies.fully_parallel.FullyParallelLoadStrategyWrapper object at 0x769f8ed2e7e0> dist-ckpt load strategy.\n", - "[WARNING | py.warnings ]: /workspace/bionemo2/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", + " \tmodule.decoder.layers.14.mixer.dense.weight\n", + " \tmodule.decoder.layers.12.mixer.dense.bias\n", + " \tmodule.decoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.5.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.4.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.17.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.13.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.8.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.22.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.16.mixer.dense.bias\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.3.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense.weight\n", + " \tmodule.decoder.layers.11.mixer.dense.bias\n", + " \tmodule.decoder.layers.7.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.24.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.21.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.18.mixer.dense.weight\n", + " \tmodule.decoder.layers.15.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.13.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.20.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.16.mixer.dense.weight\n", + " \tmodule.decoder.layers.14.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.7.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.5.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.4.mixer.dense.weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.17.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.15.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mixer.dense.weight\n", + " \tmodule.embedding.word_embeddings.weight\n", + " \tmodule.decoder.layers.22.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.9.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.6.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mixer.dense.weight\n", + " \tmodule.decoder.layers.19.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.15.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.7.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.18.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.16.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.11.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.8.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.20.mixer.dense.bias\n", + " \tmodule.decoder.layers.19.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.14.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.7.mixer.dense.weight\n", + " \tmodule.decoder.layers.4.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.21.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.10.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.6.mixer.hyena_proj_conv.short_conv_weight\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-04 01:01:11 nemo_logging:393] Using <megatron.core.dist_checkpointing.strategies.fully_parallel.FullyParallelLoadStrategyWrapper object at 0x7330b1b9bec0> dist-ckpt load strategy.\n", + "[WARNING | py.warnings ]: /workspaces/bionemo-framework/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", " checkpoint.load_state_dict(\n", "\n", "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/torch/distributed/checkpoint/planner_helpers.py:316: FutureWarning: Please use DTensor instead and we are deprecating ShardedTensor.\n", " device = getattr(value, \"device\", None)\n", "\n", - "[NeMo I 2025-03-03 23:36:33 nemo_logging:393] Global Checkpoint Load : Rank : 0 : Start time : 1741044992.504s : Time spent in load_checkpoint: 1.046s\n", - "[NeMo I 2025-03-03 23:36:33 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", - "[NeMo I 2025-03-03 23:36:33 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False), cleaning up.\n" + "[NeMo I 2025-03-04 01:01:12 nemo_logging:393] Global Checkpoint Load : Rank : 0 : Start time : 1741050071.495s : Time spent in load_checkpoint: 0.932s\n", + "[NeMo I 2025-03-04 01:01:12 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-04 01:01:12 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False), cleaning up.\n" ] } ], "source": [ + "print(f\"Running command: {predict_ref_command}\")\n", "!{predict_ref_command}" ] }, @@ -871,14 +913,17 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[NeMo W 2025-03-03 23:37:15 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", + "Running command: predict_evo2 --fasta brca1_fasta_files/brca1_variant_sequences.fasta --ckpt-dir nemo2_evo2_1b_8k --output-dir brca1_fasta_files/variant_predictions --model-size 1b --tensor-parallel-size 1 --pipeline-model-parallel-size 1 --context-parallel-size 1 --output-log-prob-seqs --fp8\n", + "[WARNING | bitsandbytes.cextension]: Could not find the bitsandbytes CUDA binary at PosixPath('/usr/local/lib/python3.12/dist-packages/bitsandbytes/libbitsandbytes_cuda128.so')\n", + "[WARNING | bitsandbytes.cextension]: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", + "[NeMo W 2025-03-04 01:02:34 nemo_logging:405] /usr/local/lib/python3.12/dist-packages/pydub/utils.py:170: RuntimeWarning: Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\n", " warn(\"Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work\", RuntimeWarning)\n", " \n", "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/mamba_ssm/ops/selective_scan_interface.py:163: FutureWarning: `torch.cuda.amp.custom_fwd(args...)` is deprecated. Please use `torch.amp.custom_fwd(args..., device_type='cuda')` instead.\n", @@ -908,69 +953,102 @@ "[INFO | pytorch_lightning.utilities.rank_zero]: GPU available: True (cuda), used: True\n", "[INFO | pytorch_lightning.utilities.rank_zero]: TPU available: False, using: 0 TPU cores\n", "[INFO | pytorch_lightning.utilities.rank_zero]: HPU available: False, using: 0 HPUs\n", - "[NeMo W 2025-03-03 23:37:17 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Experiments will be logged at /tmp/tmpcu9581ff/default\n", - "[NeMo W 2025-03-03 23:37:17 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to /tmp/tmpcu9581ff\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Using byte-level tokenization\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has data parallel group : [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has context parallel group: [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All context parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has model parallel group: [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All model parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has embedding group: [0]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] All embedding group ranks: [[0]]\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Rank 0 has embedding rank: 0\n", + "[NeMo W 2025-03-04 01:02:35 nemo_logging:405] No version folders would be created under the log folder as 'resume_if_exists' is enabled.\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Experiments will be logged at /tmp/tmpf9avvfzw/default\n", + "[NeMo W 2025-03-04 01:02:35 nemo_logging:405] \"update_logger_directory\" is True. Overwriting tensorboard logger \"save_dir\" to /tmp/tmpf9avvfzw\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Using byte-level tokenization\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has data parallel group : [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has combined group of data parallel and context parallel : [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] All data parallel group ranks with context parallel combined: [[0]]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Ranks 0 has data parallel rank: 0\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has context parallel group: [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] All context parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Ranks 0 has context parallel rank: 0\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has model parallel group: [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] All model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has tensor model parallel group: [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] All tensor model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has tensor model parallel rank: 0\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has pipeline model parallel group: [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has embedding group: [0]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] All pipeline model parallel group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has pipeline model parallel rank 0\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] All embedding group ranks: [[0]]\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Rank 0 has embedding rank: 0\n", "Initializing distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", "[INFO | pytorch_lightning.utilities.rank_zero]: ----------------------------------------------------------------------------------------------------\n", "distributed_backend=nccl\n", "All distributed processes registered. Starting with 1 processes\n", "----------------------------------------------------------------------------------------------------\n", "\n", - "[NeMo I 2025-03-03 23:37:17 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "[NeMo W 2025-03-03 23:37:17 random:220] CPU RNG state changed within GPU RNG context\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2]\n", - "[NeMo W 2025-03-03 23:37:17 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0 ,0): 1108204800\n", - "[NeMo I 2025-03-03 23:37:17 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=False, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", - "[NeMo I 2025-03-03 23:37:17 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", + "[NeMo I 2025-03-04 01:02:35 num_microbatches_calculator:228] setting number of microbatches to constant 1\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Padded vocab_size: 512, original vocab_size: 512, dummy tokens: 0.\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "[NeMo W 2025-03-04 01:02:35 random:220] CPU RNG state changed within GPU RNG context\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[NeMo W 2025-03-04 01:02:35 nemo_logging:405] Could not copy Trainer's 'max_steps' to LR scheduler's 'max_steps'. If you are not using an LR scheduler, this warning can safely be ignored.\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] > number of parameters on (tensor, pipeline) model parallel rank (0 ,0): 1108204800\n", + "[NeMo I 2025-03-04 01:02:35 utils:302] Setting up DistributedDataParallel with config DistributedDataParallelConfig(grad_reduce_in_fp32=False, overlap_grad_reduce=False, overlap_param_gather=False, align_param_gather=False, use_distributed_optimizer=False, num_distributed_optimizer_instances=1, check_for_nan_in_grad=True, check_for_large_grads=False, bucket_size=None, average_in_collective=False, fp8_param_gather=False)\n", + "[NeMo I 2025-03-04 01:02:35 utils:323] Number of buckets for gradient all-reduce / reduce-scatter: 1\n", " Params for bucket 1 (1108204800 elements):\n", + " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", + " \tmodule.decoder.layers.22.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.9.mixer.dense.bias\n", + " \tmodule.decoder.layers.7.mixer.dense.bias\n", + " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.2.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mixer.dense.bias\n", + " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", + " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.final_norm.weight\n", + " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.13.mixer.dense.bias\n", + " \tmodule.decoder.layers.12.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.weight\n", + " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.5.mixer.dense.bias\n", " \tmodule.decoder.layers.21.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.19.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.16.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.14.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.11.mixer.dense.bias\n", + " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", " \tmodule.decoder.layers.6.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.3.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.21.mixer.dense.bias\n", " \tmodule.decoder.layers.15.mixer.dense.bias\n", - " \tmodule.decoder.layers.12.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.4.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.23.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.20.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.16.mixer.hyena_proj_conv.short_conv_weight\n", @@ -978,47 +1056,44 @@ " \tmodule.decoder.layers.8.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.5.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.3.self_attention.linear_qkv.layer_norm_weight\n", - " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.1.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.24.self_attention.linear_proj.bias\n", " \tmodule.decoder.layers.21.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.16.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.15.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.11.mixer.mixer.short_conv.short_conv_weight\n", " \tmodule.decoder.layers.6.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.22.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.20.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.18.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.15.mixer.dense.weight\n", - " \tmodule.decoder.layers.10.self_attention.linear_proj.bias\n", " \tmodule.decoder.layers.9.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mixer.dense.weight\n", " \tmodule.decoder.layers.21.mixer.dense.weight\n", " \tmodule.decoder.layers.19.mixer.dense.bias\n", " \tmodule.decoder.layers.16.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.8.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.4.mixer.dense.bias\n", - " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.24.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.20.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.17.self_attention.linear_qkv.weight\n", " \tmodule.decoder.layers.15.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.13.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.12.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.9.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.7.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.5.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.23.mixer.dense.bias\n", " \tmodule.decoder.layers.20.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.19.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.16.mixer.mixer.filter.R\n", " \tmodule.decoder.layers.14.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.13.mixer.mixer.filter.gamma\n", " \tmodule.decoder.layers.5.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.3.self_attention.linear_proj.bias\n", - " \tmodule.decoder.layers.0.mixer.dense.bias\n", + " \tmodule.decoder.layers.2.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.24.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.22.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.19.mixer.dense.weight\n", @@ -1027,63 +1102,68 @@ " \tmodule.decoder.layers.9.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.6.mixer.dense.weight\n", " \tmodule.decoder.layers.4.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.0.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.22.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.20.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.16.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.13.mixer.mixer.conv_bias\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.9.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.8.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.5.mixer.mixer.filter.h\n", - " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.23.mixer.dense.weight\n", " \tmodule.decoder.layers.21.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.19.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.14.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.12.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.11.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.8.mixer.dense.weight\n", " \tmodule.decoder.layers.6.mixer.dense.bias\n", - " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", + " \tmodule.decoder.layers.2.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.24.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.22.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.20.mixer.mixer.filter.R\n", " \tmodule.decoder.layers.18.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.14.mixer.dense.bias\n", " \tmodule.decoder.layers.9.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", + " \tmodule.decoder.layers.2.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.18.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.16.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.13.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.10.self_attention.linear_qkv.weight\n", " \tmodule.decoder.layers.8.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.6.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.0.mixer.dense.bias\n", " \tmodule.decoder.layers.24.self_attention.linear_qkv.layer_norm_weight\n", " \tmodule.decoder.layers.22.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.20.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.14.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.9.mixer.mixer.filter.R\n", " \tmodule.decoder.layers.7.mixer.dense_projection.layer_norm_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.23.mixer.mixer.filter.gamma\n", " \tmodule.decoder.layers.18.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.15.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.13.mixer.mixer.filter.p\n", + " \tmodule.decoder.layers.12.mixer.dense.weight\n", " \tmodule.decoder.layers.7.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.embedding.word_embeddings.weight\n", " \tmodule.decoder.layers.24.self_attention.linear_proj.weight\n", " \tmodule.decoder.layers.21.mixer.mixer.short_conv.short_conv_weight\n", " \tmodule.decoder.layers.14.mixer.dense.weight\n", " \tmodule.decoder.layers.9.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.4.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.0.mixer.mixer.short_conv.short_conv_weight\n", " \tmodule.decoder.layers.20.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.17.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", " \tmodule.decoder.layers.13.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.12.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.7.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.5.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.1.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.23.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.18.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.16.mixer.dense.bias\n", @@ -1091,55 +1171,53 @@ " \tmodule.decoder.layers.11.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.8.mixer.dense.bias\n", " \tmodule.decoder.layers.3.self_attention.linear_qkv.weight\n", - " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.2.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.0.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.22.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.19.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.17.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.15.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.12.mixer.dense.weight\n", " \tmodule.decoder.layers.11.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.9.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.6.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.1.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.18.mixer.dense.weight\n", " \tmodule.decoder.layers.15.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.13.mlp.linear_fc1.layer_norm_weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.12.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.7.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.1.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.23.mlp.linear_fc2.weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_proj.bias\n", " \tmodule.decoder.layers.16.mixer.dense.weight\n", " \tmodule.decoder.layers.14.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.12.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.11.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.8.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.6.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.4.mixer.dense.weight\n", - " \tmodule.embedding.word_embeddings.weight\n", " \tmodule.decoder.layers.20.mixer.dense.bias\n", " \tmodule.decoder.layers.17.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.15.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.13.mixer.mixer.filter.R\n", + " \tmodule.decoder.layers.12.mixer.dense.bias\n", " \tmodule.decoder.layers.9.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.7.mixer.dense.weight\n", - " \tmodule.decoder.layers.2.mixer.dense.weight\n", " \tmodule.decoder.layers.23.mixer.mixer.filter.p\n", " \tmodule.decoder.layers.21.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.19.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.10.mlp.linear_fc2.weight\n", " \tmodule.decoder.layers.6.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.4.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.0.mixer.dense.weight\n", + " \tmodule.decoder.layers.0.mixer.hyena_proj_conv.short_conv_weight\n", + " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", " \tmodule.decoder.layers.22.mixer.dense.bias\n", " \tmodule.decoder.layers.19.mlp.linear_fc1.weight\n", - " \tmodule.decoder.layers.17.self_attention.linear_qkv.layer_norm_weight\n", " \tmodule.decoder.layers.15.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.13.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.11.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.6.mlp.linear_fc1.weight\n", + " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.5.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.2.mixer.dense.bias\n", - " \tmodule.decoder.layers.1.mixer.dense.bias\n", + " \tmodule.decoder.layers.1.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.23.mixer.hyena_proj_conv.short_conv_weight\n", " \tmodule.decoder.layers.20.mixer.dense.weight\n", " \tmodule.decoder.layers.18.mlp.linear_fc1.layer_norm_weight\n", @@ -1148,23 +1226,22 @@ " \tmodule.decoder.layers.8.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.5.mixer.dense.weight\n", " \tmodule.decoder.layers.3.self_attention.linear_proj.weight\n", - " \tmodule.decoder.layers.2.mixer.mixer.filter.gamma\n", + " \tmodule.decoder.layers.1.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.23.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.22.mixer.dense_projection.layer_norm_weight\n", " \tmodule.decoder.layers.19.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.17.self_attention.linear_proj.weight\n", " \tmodule.decoder.layers.14.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.12.mixer.dense.bias\n", " \tmodule.decoder.layers.11.mixer.dense.weight\n", " \tmodule.decoder.layers.8.mlp.linear_fc1.weight\n", " \tmodule.decoder.layers.6.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.4.mixer.dense_projection.weight\n", - " \tmodule.decoder.final_norm.weight\n", " \tmodule.decoder.layers.22.mixer.dense.weight\n", " \tmodule.decoder.layers.13.mixer.dense_projection.weight\n", " \tmodule.decoder.layers.9.mixer.dense.weight\n", " \tmodule.decoder.layers.7.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.5.mixer.dense_projection.weight\n", + " \tmodule.decoder.layers.2.mixer.dense.weight\n", " \tmodule.decoder.layers.23.mlp.linear_fc1.layer_norm_weight\n", " \tmodule.decoder.layers.19.mixer.mixer.conv_bias\n", " \tmodule.decoder.layers.16.mixer.mixer.conv_bias\n", @@ -1172,54 +1249,23 @@ " \tmodule.decoder.layers.8.mixer.mixer.filter.h\n", " \tmodule.decoder.layers.6.mixer.mixer.filter.R\n", " \tmodule.decoder.layers.3.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.0.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.24.self_attention.linear_qkv.weight\n", - " \tmodule.decoder.layers.22.mixer.dense_projection.weight\n", - " \tmodule.decoder.layers.20.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.15.mixer.hyena_proj_conv.short_conv_weight\n", - " \tmodule.decoder.layers.12.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.12.mixer.mixer.filter.h\n", - " \tmodule.decoder.layers.9.mixer.dense.bias\n", - " \tmodule.decoder.layers.7.mixer.dense.bias\n", - " \tmodule.decoder.layers.4.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.2.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.23.mixer.mixer.filter.R\n", - " \tmodule.decoder.layers.21.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.18.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.10.self_attention.linear_qkv.layer_norm_weight\n", - " \tmodule.decoder.layers.6.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.5.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.3.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.21.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.16.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.12.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.11.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.9.mixer.mixer.filter.gamma\n", - " \tmodule.decoder.layers.4.mlp.linear_fc1.layer_norm_weight\n", - " \tmodule.decoder.layers.0.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.23.mixer.dense_projection.layer_norm_weight\n", - " \tmodule.decoder.layers.20.mixer.mixer.conv_bias\n", - " \tmodule.decoder.layers.13.mixer.dense.bias\n", - " \tmodule.decoder.layers.10.self_attention.linear_proj.weight\n", - " \tmodule.decoder.layers.7.mixer.mixer.short_conv.short_conv_weight\n", - " \tmodule.decoder.layers.5.mixer.dense.bias\n", - " \tmodule.decoder.layers.2.mlp.linear_fc2.weight\n", - " \tmodule.decoder.layers.1.mixer.dense.weight\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", - "[NeMo I 2025-03-03 23:37:17 nemo_logging:393] Using <megatron.core.dist_checkpointing.strategies.fully_parallel.FullyParallelLoadStrategyWrapper object at 0x7766d25acb60> dist-ckpt load strategy.\n", - "[WARNING | py.warnings ]: /workspace/bionemo2/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", + " \tmodule.decoder.layers.0.mixer.dense.weight\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Doing selective restore from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-04 01:02:35 nemo_logging:393] Using <megatron.core.dist_checkpointing.strategies.fully_parallel.FullyParallelLoadStrategyWrapper object at 0x7bffabfab6e0> dist-ckpt load strategy.\n", + "[WARNING | py.warnings ]: /workspaces/bionemo-framework/3rdparty/Megatron-LM/megatron/core/dist_checkpointing/strategies/torch.py:847: FutureWarning: `load_state_dict` is deprecated and will be removed in future versions. Please use `load` instead.\n", " checkpoint.load_state_dict(\n", "\n", "[WARNING | py.warnings ]: /usr/local/lib/python3.12/dist-packages/torch/distributed/checkpoint/planner_helpers.py:316: FutureWarning: Please use DTensor instead and we are deprecating ShardedTensor.\n", " device = getattr(value, \"device\", None)\n", "\n", - "[NeMo I 2025-03-03 23:37:18 nemo_logging:393] Global Checkpoint Load : Rank : 0 : Start time : 1741045037.679s : Time spent in load_checkpoint: 1.103s\n", - "[NeMo I 2025-03-03 23:37:18 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", - "[NeMo I 2025-03-03 23:37:18 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False), cleaning up.\n" + "[NeMo I 2025-03-04 01:02:36 nemo_logging:393] Global Checkpoint Load : Rank : 0 : Start time : 1741050155.807s : Time spent in load_checkpoint: 0.618s\n", + "[NeMo I 2025-03-04 01:02:36 nemo_logging:393] Restoring model weights from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False)\n", + "[NeMo I 2025-03-04 01:02:36 nemo_logging:393] Finished restoring from RestoreConfig(path='nemo2_evo2_1b_8k', adapter_path=None, load_model_state=True, load_optim_state=False, load_artifacts=False), cleaning up.\n" ] } ], "source": [ + "print(f\"Running command: {predict_var_command}\")\n", "!{predict_var_command}" ] }, @@ -1240,7 +1286,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -1268,7 +1314,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -1309,108 +1355,101 @@ " <tr>\n", " <th>0</th>\n", " <td>17</td>\n", - " <td>41199726</td>\n", - " <td>T</td>\n", + " <td>41199729</td>\n", " <td>C</td>\n", - " <td>0.159762</td>\n", - " <td>FUNC/INT</td>\n", - " <td>BRCA1_ref_pos_41199726_T_class_FUNC/INT</td>\n", - " <td>BRCA1_var_pos_41199726_TtoC_class_FUNC/INT</td>\n", - " <td>-1.048409</td>\n", - " <td>-1.048462</td>\n", - " <td>-0.000054</td>\n", + " <td>T</td>\n", + " <td>-2.646816</td>\n", + " <td>LOF</td>\n", + " <td>BRCA1_ref_pos_41199729_C_class_LOF</td>\n", + " <td>BRCA1_var_pos_41199729_CtoT_class_LOF</td>\n", + " <td>-0.952360</td>\n", + " <td>-0.953044</td>\n", + " <td>-0.000684</td>\n", " </tr>\n", " <tr>\n", " <th>1</th>\n", " <td>17</td>\n", - " <td>41209074</td>\n", + " <td>41215381</td>\n", " <td>T</td>\n", - " <td>A</td>\n", - " <td>-2.065569</td>\n", + " <td>G</td>\n", + " <td>-2.352741</td>\n", " <td>LOF</td>\n", - " <td>BRCA1_ref_pos_41209074_T_class_LOF</td>\n", - " <td>BRCA1_var_pos_41209074_TtoA_class_LOF</td>\n", - " <td>-0.826655</td>\n", - " <td>-0.826915</td>\n", - " <td>-0.000260</td>\n", + " <td>BRCA1_ref_pos_41215381_T_class_LOF</td>\n", + " <td>BRCA1_var_pos_41215381_TtoG_class_LOF</td>\n", + " <td>-0.848368</td>\n", + " <td>-0.848730</td>\n", + " <td>-0.000361</td>\n", " </tr>\n", " <tr>\n", " <th>2</th>\n", " <td>17</td>\n", - " <td>41256913</td>\n", - " <td>A</td>\n", + " <td>41215390</td>\n", " <td>C</td>\n", - " <td>-0.847753</td>\n", - " <td>FUNC/INT</td>\n", - " <td>BRCA1_ref_pos_41256913_A_class_FUNC/INT</td>\n", - " <td>BRCA1_var_pos_41256913_AtoC_class_FUNC/INT</td>\n", - " <td>-0.864035</td>\n", - " <td>-0.864014</td>\n", - " <td>0.000021</td>\n", + " <td>A</td>\n", + " <td>-1.371155</td>\n", + " <td>LOF</td>\n", + " <td>BRCA1_ref_pos_41215390_C_class_LOF</td>\n", + " <td>BRCA1_var_pos_41215390_CtoA_class_LOF</td>\n", + " <td>-0.848341</td>\n", + " <td>-0.847456</td>\n", + " <td>0.000885</td>\n", " </tr>\n", " <tr>\n", " <th>3</th>\n", " <td>17</td>\n", - " <td>41219631</td>\n", + " <td>41219688</td>\n", " <td>T</td>\n", " <td>A</td>\n", - " <td>-2.053739</td>\n", + " <td>-2.053136</td>\n", " <td>LOF</td>\n", - " <td>BRCA1_ref_pos_41219631_T_class_LOF</td>\n", - " <td>BRCA1_var_pos_41219631_TtoA_class_LOF</td>\n", - " <td>-1.091372</td>\n", - " <td>-1.091227</td>\n", - " <td>0.000145</td>\n", + " <td>BRCA1_ref_pos_41219688_T_class_LOF</td>\n", + " <td>BRCA1_var_pos_41219688_TtoA_class_LOF</td>\n", + " <td>-1.027623</td>\n", + " <td>-1.028068</td>\n", + " <td>-0.000445</td>\n", " </tr>\n", " <tr>\n", " <th>4</th>\n", " <td>17</td>\n", - " <td>41215965</td>\n", + " <td>41219652</td>\n", + " <td>C</td>\n", " <td>G</td>\n", - " <td>A</td>\n", - " <td>-1.671525</td>\n", + " <td>-2.026390</td>\n", " <td>LOF</td>\n", - " <td>BRCA1_ref_pos_41215965_G_class_LOF</td>\n", - " <td>BRCA1_var_pos_41215965_GtoA_class_LOF</td>\n", - " <td>-0.930776</td>\n", - " <td>-0.930750</td>\n", - " <td>0.000026</td>\n", + " <td>BRCA1_ref_pos_41219652_C_class_LOF</td>\n", + " <td>BRCA1_var_pos_41219652_CtoG_class_LOF</td>\n", + " <td>-1.032667</td>\n", + " <td>-1.032678</td>\n", + " <td>-0.000011</td>\n", " </tr>\n", " </tbody>\n", "</table>\n", "</div>" ], "text/plain": [ - " chrom pos ref alt score class \\\n", - "0 17 41199726 T C 0.159762 FUNC/INT \n", - "1 17 41209074 T A -2.065569 LOF \n", - "2 17 41256913 A C -0.847753 FUNC/INT \n", - "3 17 41219631 T A -2.053739 LOF \n", - "4 17 41215965 G A -1.671525 LOF \n", - "\n", - " ref_fasta_name \\\n", - "0 BRCA1_ref_pos_41199726_T_class_FUNC/INT \n", - "1 BRCA1_ref_pos_41209074_T_class_LOF \n", - "2 BRCA1_ref_pos_41256913_A_class_FUNC/INT \n", - "3 BRCA1_ref_pos_41219631_T_class_LOF \n", - "4 BRCA1_ref_pos_41215965_G_class_LOF \n", + " chrom pos ref alt score class \\\n", + "0 17 41199729 C T -2.646816 LOF \n", + "1 17 41215381 T G -2.352741 LOF \n", + "2 17 41215390 C A -1.371155 LOF \n", + "3 17 41219688 T A -2.053136 LOF \n", + "4 17 41219652 C G -2.026390 LOF \n", "\n", - " var_fasta_name ref_log_probs var_log_probs \\\n", - "0 BRCA1_var_pos_41199726_TtoC_class_FUNC/INT -1.048409 -1.048462 \n", - "1 BRCA1_var_pos_41209074_TtoA_class_LOF -0.826655 -0.826915 \n", - "2 BRCA1_var_pos_41256913_AtoC_class_FUNC/INT -0.864035 -0.864014 \n", - "3 BRCA1_var_pos_41219631_TtoA_class_LOF -1.091372 -1.091227 \n", - "4 BRCA1_var_pos_41215965_GtoA_class_LOF -0.930776 -0.930750 \n", + " ref_fasta_name var_fasta_name \\\n", + "0 BRCA1_ref_pos_41199729_C_class_LOF BRCA1_var_pos_41199729_CtoT_class_LOF \n", + "1 BRCA1_ref_pos_41215381_T_class_LOF BRCA1_var_pos_41215381_TtoG_class_LOF \n", + "2 BRCA1_ref_pos_41215390_C_class_LOF BRCA1_var_pos_41215390_CtoA_class_LOF \n", + "3 BRCA1_ref_pos_41219688_T_class_LOF BRCA1_var_pos_41219688_TtoA_class_LOF \n", + "4 BRCA1_ref_pos_41219652_C_class_LOF BRCA1_var_pos_41219652_CtoG_class_LOF \n", "\n", - " evo2_delta_score \n", - "0 -0.000054 \n", - "1 -0.000260 \n", - "2 0.000021 \n", - "3 0.000145 \n", - "4 0.000026 " + " ref_log_probs var_log_probs evo2_delta_score \n", + "0 -0.952360 -0.953044 -0.000684 \n", + "1 -0.848368 -0.848730 -0.000361 \n", + "2 -0.848341 -0.847456 0.000885 \n", + "3 -1.027623 -1.028068 -0.000445 \n", + "4 -1.032667 -1.032678 -0.000011 " ] }, - "execution_count": 26, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1440,12 +1479,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAC+CAYAAAAx3qiRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPWVJREFUeJzt3XdYU9f/B/B3AknYoGwQZSniwgW4RcXiXq0TrVrr3iiO2oq1tjjqqFupirWOr3vhRAFHpW6LljpwoCwVIYDs5Pz+0NwfkYCJJATw83oensq9N+e+uQ35cO899xweY4yBEEIIeY+v7QCEEEIqFioMhBBC5FBhIIQQIocKAyGEEDlUGAghhMihwkAIIUQOFQZCCCFyqDAQQgiRo6vtAKR0UqkUiYmJMDY2Bo/H03YcQkglxRhDZmYm7OzswOeXfk5AhaGCS0xMhIODg7ZjEEKqiOfPn6NGjRqlbkOFoYIzNjYG8O5/pomJiZbTEEIqq4yMDDg4OHCfKaWhwlDByS4fmZiYUGEghJSZMpek6eYzIYQQOVQYCCGEyKHCQAghRI7K9xhu3rwJgUCAhg0bAgCOHDmCbdu2oV69eliwYAGEQqHaQxJCVLNixQpkZGTAxMQEAQEB2o5DKhmVzxjGjh2LBw8eAAAeP36MQYMGwcDAAPv27cOsWbPUHpAQoroVK1bgxx9/xIoVK7QdhVRCKheGBw8eoHHjxgCAffv2oV27dti1axdCQ0Nx4MABdecjhBBSzlQuDIwxSKVSAEB4eDi6desGAHBwcMDr16/Vm44QQki5U7kwNG/eHIsWLcKOHTsQFRWF7t27AwCePHkCa2trtQckhBBSvlQuDKtWrcLNmzcxadIkzJs3D66urgCA/fv3o1WrVmoPSAgpm+zsbBw6dAiRkZHajkIqCZV7JTVq1AgxMTHFli9btgw6OjpqCUWIqmJjY/HixQu0bdsWenp62o6jdQUFBQDeXfqNjo7G33//DQCoXbs27O3ttRmNVAIqF4bnz5+Dx+NxgzBdvXoVu3btQr169TBmzBi1ByTkY7KysrBjxw5IpVLk5uaiZ8+e2o6kVW/fvkVOTg4AIDc3FzVr1oSuri6MjY1RrVo1LacjlYHKl5KGDBmCiIgIAEBycjI6d+6Mq1evYt68eVi4cKHaAxLyMUKhkBsYzNLSUstptE8kEnHj4ejo6MDV1RU//PADZs6cCQMDg3LPExMTgy1btuD+/fvlvu+q6urVq1i+fDl3JqhuKp8x3L17F15eXgCAvXv3okGDBrh8+TLOnDmDcePGYf78+WoPSUhphEIhpk2bhoyMDOoAAeDNmzdgjAH4/wHTRCKR1vKEhYUhPT0dmZmZcHNz01qOqiQqKgqpqam4cOECvL291d6+ymcMBQUF3JssPDwcvXr1AgDUrVsXSUlJ6k1HiJL09fUrXFG4evUqzp49y13vLy8fm4SlvDVq1Ag6OjrcaAmk7Nq0aYPq1aujdevWGmlf5TOG+vXrY+PGjejevTvOnj2Ln376CcC7CWXMzc3VHpCQyighIQEHDx4E8O6v9Xbt2pXbvi0sLGBoaIjMzEwIBAKF27x+/Rr6+vowNDTUeJ5u3bpxzzsR9WjZsiVatmypsfZV/tNiyZIl2LRpE3x8fDB48GB4eHgAAI4ePcpdYiLkc2diYgJDQ0Pw+XytnMmU1kMwJiYGy5cvx/Lly5GVlaVwm+joaOzatYseWv1MqXzG4OPjg9evXyMjI0Ouh8OYMWO0cmOLVG3p6el4+vQp3N3dtXqdXFXGxsaYMWMG8vPzYWZmpu04cl6/fg3GGLKzs5GdnQ0jIyO59bm5uTh8+DCAdwVm4MCBWkhJtOmTZnDT0dEp1u3N0dFRHXkIkRMSEoLU1FR4eHhg8ODB2o6jEqFQiGfPnkFXV7fYh682tWnTBowxmJubw8rKqth6oVAIJycnPH36FHXq1NFCQqJtn1QY9u/fj7179yI+Ph75+fly627evKmWYIRUVq9evUJISAjy8vKQl5cHS0tLzJgxQ9uxOAKBAB07dixxPZ/Px9ixY1FYWAhdXZr993Ok8j2G1atXY+TIkbC2tsatW7fg5eUFc3NzPH78GF27dtVERvIZGz16NAYNGoR+/fppO4rSHj9+jIyMDOTl5QFAsT+eNOXu3bu4efMm11W1rKgofL5U/j+/fv16bN68GYMHD0ZoaChmzZoFZ2dnzJ8/H2/evNFERvIZMzMz44Z5rywaNWqEuLg46OjowMHBoVwuxzx9+hR//vknAODhw4coLCxUa/vJycnYsmULTExMMHr0aBp2pIpTuTDEx8dzg+Xp6+sjMzMTADBs2DC0aNECa9euVW9CQioZfX19DBkypFz3qaenBz6fD6lUilu3biE7O1ut7d+/fx+ZmZnIzMzE5s2boaOjg2HDhsHExESt+yEVg8qXkmxsbLgzg5o1ayI6OhrAu2G31XUKS6q2+Ph4JCYmajtGlWJjY4Np06ahQ4cOAP7/iWd1adq0Kdzd3VG7dm0kJibi+fPniI2NLbbd27dvceHCBfr/W8mpXBg6duyIo0ePAgBGjhyJ6dOno3Pnzhg4cCD69u2r9oCkarl//z7Wr1+PtWvX0oeHmllZWcHPzw8TJ05Uey8oY2NjDB8+HP7+/qhduzZq1aoFd3f3YtsdPnwYJ06cwJYtW8q8z1u3biE8PLzc7tGQ/6fypaTNmzdzM7hNnDgR5ubm+Ouvv9CrVy+MHTtW7QFJ1SK7ISuVSukXXkMcHBzUfsYgo6enh1GjRpW4XlaQyvpE9dOnT/G///0PwLteUqX1oiLqp/IZA5/Pl+utMGjQIKxevRqTJ0+GUChUqa0RI0aAx+MV+3r06BF8fHwwbdq0Yq8JDQ2Ve2BowYIF4PF4GDdunNx2t2/fBo/Hw9OnT+WWHzhwAD4+PjA1NYWRkREaNWqEhQsXFrtxvn37drRp0wYAimXx8fEBj8fDnj175F6zatUq7nkO2TYlffn4+Kh0rKqKRo0aYciQIRgxYgQ9+6JBssu65X15t2fPnhgzZkyx30dV5OXlcTfSARoxVxuUOmP4559/lG6wUaNGKgXo0qULtm3bJrdM1TeCnp4etmzZghkzZqB27dolbjdv3jwsWbIE06dPxy+//AI7Ozs8fPgQGzduxI4dOzB16lRu2yNHjnADBJa0z++//x5ffvmlwvFoDh48yP1F/Pz5c3h5eSE8PBz169cHAJWLaFWi6ntE2woKCpCWlgZLS0uN/SVeVF5eHjIzM2FhYfHJbbx9+xYAuHkZ1EUqlUIqlZbYlZXP58PZ2blM+ygoKOBunnt6etLge1qgVGFo3LgxeDzeR//64PF4kEgkKgUQiUSwsbFR6TUfcnNzg5WVFebNm4e9e/cq3Obq1av45ZdfsGrVKrkC4OjoiM6dOyM9PZ1blpubizNnzuCXX34pcZ+DBw/G0aNHERISggkTJhRbX716dbn2AMDc3LzMPyspf1u2bMHTp0/Rrl07jQ8GV1hYiDVr1uD169fo1atXhZouNy8vD+vWrcObN28wYsQIblpfdTMyMsKIESOQmJio0YHiSMmUKgxPnjzRdI4yW7x4MTw9PXH9+nU0b9682PqdO3fCyMhI4Yc4ALnLU+fOnYO9vT3q1q1b4v5MTEy4yYmGDx+utlEqZU/LymRkZKilXfLpXr58CQBISUnR+L4KCgq4y5pl2Z+hoSHEYrFaxy9LS0vjjkVcXJzGCgMAmJqawtTUtFKNj1WVKFUYatWqpbEAx48fl+tB0bVrV+zbt0/ldpo2bYoBAwZg9uzZOHfuXLH1Dx8+hLOzc4nDEBf1sctIMhMmTMBvv/2GFStW4IcfflA5syLBwcH48ccf1dIWUY9hw4YhNjYWLVq00Pi+9PX1MXToUMTHx6Nt27af3I6iS15isRgCgeCTi4WNjQ2++OILvHr1SmPzAADAs2fPsHHjRvB4PIwfPx4ODg4a2xdRTOVeScHBwbC2tsY333wjt3zr1q149eoVZs+erVJ7HTp0wIYNG7jvy/KX96JFi+Du7o4zZ84UGxxM2ZtwjDEcO3asxEtSRYlEIixcuBCTJ0/G+PHjPynzh+bOnYuAgADu+4yMDPrF0DInJyc4OTmV2/7q1auHevXqqbXNhw8fYtu2bdDT08O0adM++cG08ugd9PbtWzDGuBFgSflTuVfSpk2bFF5ikU3goypDQ0O4urpyX7a2tgDeXaoRi8XFtk9PT4epqanCtlxcXDB69GjMmTOnWCGoU6cOHj9+/NHZtK5evYrCwkKlr+0OHToUtWrVwqJFi5Ta/mNEIhFMTEzkvsjn7cGDBzh79myZPiRTUlIglUqRnZ2t8PdKVW/fvsWBAwcQGRlZ5rY+VK9ePQwcOBCDBg2iqUC1ROXCkJyczH14F2VpaanWqT3d3NwUjtR68+bNUseemT9/Ph48eFCsK+mQIUOQlZWF9evXK3yd7ObzkSNH0L1791InOimKz+cjODgYGzZsKNY1lpCyys3Nxfbt23Hu3DmcPn36k9vx9vZGp06d0LdvX7WcgV65cgXXrl3DqVOnNPKgYpMmTSrdGFlVicqFwcHBAZcvXy62/PLly7Czs1NLKAAYP348Hjx4gClTpuCff/7B/fv3sWLFCuzevbvUIYytra0REBCA1atXyy339vbGrFmzMGPGDMyaNQtXrlzBs2fPcO7cOfTv3x/bt28H8G4mOmXuLxTVvXt3eHt7Y9OmTar/oISUQldXlztDLsvUuQKBAJ07d1bbxPGOjo7Q1dWFubm5XA88UjWofI9h9OjRmDZtGgoKCrjrjefOneM+dNXF2dkZFy5cwLx58+Dr64v8/HzUrVsX+/btQ5cuXUp97cyZM7Fhwwaum6jMkiVL0KxZM6xbtw4bN26EVCqFi4sLvvrqKwwfPhxxcXF49OgR/Pz8VM67ZMmSCtW1kFQNurq6mDJlCtLT01Xq6ix776t7lFUZV1dXzJ8/Hzo6OkqfXZNKhKlIKpWyWbNmMT09Pcbn8xmfz2cGBgbsxx9/VLWpCmf58uWsa9eu2o4hRywWMwBMLBZrO0q5EIvF7NGjR0wqlWo7SoV1//59tmHDBhYdHa1w/b59+5iRkREDwKpVq1bO6crH3bt32alTp9jbt2+1HaXSUOWzROUzBh6PhyVLluCHH35AbGws9PX1Ubt27SrR37hGjRqYO3eutmN8tgoKCrB69WpkZWXhiy++oPFxSnDu3Dk8e/YMycnJCi8NxcTEcP8u7Qn7u3fv4saNG2jbtm2Zn1YuT5mZmfjzzz/BGEN+fj569uyp7UhVjsr3GGSMjIzg6emJBg0aVImiAAADBgwoU99xUjYSiYR7uI+6KZasadOm0NPTQ7NmzRSu79mzJzdkRWmzsB04cACxsbE4ceKERnJqikgk4u67WFtbazlN1URz95EKQ09PD6NHj0ZCQkKJH3qfgwcPHuDy5cvw8vLixtYqytvbG97e3pBIJAgJCUFiYiKGDh0KFxcXAO+6ZhsYGMgN8/Kh2NhYbhwldXYaKQ9CoRDTpk1DVlZWmcaTIiWjwkAqlJo1a6JmzZrajqFVYWFhSElJwcuXLxUWBpn09HTExcUBAO7duwcXFxe8ePECGzdu5GZWLInsyWgej6dwCJmKTk9Pj6YX1SAqDAQAkJqaimvXrqFBgwaoUaOGtuNUaNevX0dBQQG8vb3B53/y1dgSNWjQ4KNFAXjXfbV9+/ZITEzkesS9efMGhYWFH33Sv27duhg1ahQEAsFnX4hJcTz2sXfQe8ePH0e3bt008otASpaRkQFTU1OIxWKVnoJOT0/HtWvX4O7urtQH/ebNm/H48WOYmprSDfhSxMXFISQkBAAwcOBANGnSRCP7kUqln/S7JpVKcenSJXz11Vd49eoV7O3t8eLFCw0kJJWNKp8lSr/z+vTpAwcHB8ybNw+PHj0qc0iiWQcPHsS5c+cQGhqq1PayOTBoUpTSGRsbQ1dXF3w+v8ShWdThU/8A4/P5aNeu3Wc93wcpO6UvJT158gTbtm3D9u3bsXjxYrRp0wbffvstvvrqK+jr62syI/kEsqdklX1atnfv3vD29qbC8BFWVlaYMWMGJBIJ3fgkVZbSl5KKioiIQGhoKA4cOABdXV0MGjQIo0aNgqenpyYyftY+9VKSVCpFUlISLC0t6a/Hz1CNGjWQkJCg8qWkvLw8SCQStc7jQCoGjVxKKqpDhw7Yvn07kpKSsGzZMsTExKBFixbw8PD4pMBE/fh8Puzt7akoEKWlp6djyZIl+OWXXxAfH6/tOESLynQn2djYGJ06dUKHDh1gZmaGf//9V125CCHlLDU1FdnZ2SgsLNTIiKmk8vikwpCTk4M//vgDPj4+qF27Nvbs2YOAgAAadpqQSszZ2RldunRB+/btP+sHDImKzzFER0dj69at2Lt3L/Lz89GvXz+Eh4ejQ4cOmspHCCknPB4PPj4+2o5BKgClC0O9evVw//59NGnSBMHBwRgyZIhGu+sRQgjRDqULg6+vL3bv3k03mAkhpIpTujB8OCMaIYSQqknpwqDM2Pg8Hg/nzp0rUyBCCCHapXRhKO0SUmZmJnbt2sWNpU8IIaTyUrowrFy5stiywsJCrFu3Dj///DPs7e3x008/qTUcIeTTBAQEICMjQ6Wn5QmR+aQhMQBg586dmD9/PnJycvD9999jzJgxpc4WRT7Npw6JQQghRanyWaLyJ/mpU6cwZ84cPHnyBDNnzkRAQAAMDQ0/OSwhhJCKRenCcPXqVcyePRvR0dEYN24cwsPDaXRJQgipgpS+lMTn86Gvr48xY8bAycmpxO2mTJmitnCELiURQtRDlc8SpQuDo6MjN09siY3xeHj8+LHySclHUWEghKiDRu4x0AB5hBDyeaAJnAkhhMhRujBcuXIFx48fl1v2xx9/wMnJCVZWVhgzZgw94EYIIVWA0oVh4cKFuHfvHvd9TEwMRo0aBV9fX8yZMwfHjh1DcHCwRkISQggpP0oXhtu3b6NTp07c93v27IG3tzdCQkIQEBCA1atXY+/evRoJSQghpPwoXRjS0tJgbW3NfR8VFYWuXbty33t6euL58+fqTUcIIaTcKV0YrK2t8eTJEwBAfn4+bt68iRYtWnDrMzMzIRAI1J+QEEJIuVK6u2q3bt0wZ84cLFmyBIcPH4aBgQHatm3Lrf/nn3/g4uKikZCEkPK3YsUKbiC+gIAAbcch5UjpB9xev36Nfv364dKlSzAyMsL27dvRt29fbn2nTp3QokUL/PzzzxoL+zmiB9yIttSoUQMJCQmwt7fHixcvtB2HlJFGHnCzsLDAhQsXIBaLYWRkBB0dHbn1+/btg5GR0aclJoQQUmGoPLqqqampwuXVq1cvcxhCCCHaR08+E0IIkUOFgWhU4rx5eNCyFTJOndZ2FKIBrLBQ2xGIBlBhIBrDCgogPnAQkrQ0iI8e1XYcjch78gSpW7agICmp3Pdd+OYNJGJxue9XRnzsGP7zaIxnI0dC1YkgxceO4753CyT98IOG0pGyoMLwmZNkZKDw1SuNtM0TCGAZEAD9xo1h/u0ojexD215MmoyXy35F4qzZ5brfnJgYPPLpgEedfJH/7Fm57lsmK+oCIJEg+0o0pG+zVXqt+NhRSMVipB84qHJRIZqntkma09LScOzYMXz99dfqapJoWEFyMp707gNJdjZq/v47DL291L4PizGjYTFmtNrbrSh0zc2RHxcHHQvzct1v3qM4sPx8sPx85MfHQ1irVrnuHwAsJowHy8uDYauW0DEyhEQsRmZEBAxbtoLA2qr0144eDWnWWxj7+n50nhdS/tRWGOLj4zFy5EgqDJVIQWIidyki79FDjRSGqs5hw3rk3L0H/SaN1dpu9rVr4OnpQb9hQ4XrTXt0R0FCAvj6ejBs00at+1aWyNkZNdas5r5PnDUbWVFRELm5wfnI4VJfa+DpCcddOzWckHwqpQtDRkZGqeszMzPLHIaUL4OmTWE9bx4kaW9g9tVX2o5TKfENDdVeULOiovB87DiAz4fj3r3Qb1C/2DY8gQCWkyaqdb9l8WbXLuS9HzKH8Xl4tW4dpNnZsJw6FXyhkNvu5fLlyLpwEdbffUd/iFRgShcGMzOzUk/5GGN0SlgJVR82VNsRyAek+fnv/yEFCgu0G0YJOffuIWXhTwAAkx49YOTjg8SZMwEAIicn7o8OaW4uUkN+BwCk7dxJhaECU7owGBsbY968efD29la4/uHDhxg7dqzaghHyuTLp3Bm8dWvfXUpq3FjbcT5KYGMDHXNzSMRimPbpA5GTI3RMTSHNz4fI3Z3bjq+nB7PBg/D2wkWY9acz1IpM6cLQtGlTAED79u0VrjczM6PeBYSoiXGRuU8qOl1zc7icPg2Wkw1dS0sAgGvEeTCpFDofDJNjGxSkjYhERUp3Vx0yZAj09PRKXG9jY4Mg+p9OSsGkUqTt2QPx8TBtR6mUJFlZyDhzBoVpadqOUoyOkSFXFACAb2BQrCiQykPpM4bRo0vvcmhtbU2FgZRKfOQokhf8CAAQ2NnC4P1ZKFFO4oyZyIqKgr6HBxz/t0dj+2FSKfIePdJY+6TiU9sDbunp6Vi7dq26miNVkK6VJcDjgScUQsesmrbjVDqs4N1Naen7/2pKctACPOnVG5L0dI3t48327Xg6cBDeRkdrbB/k05X5OYZz585hy5YtOHToEAwMDDBp0iR15CJVkFHr1nA+dhQ8PX0Ia9hrO06lY7d8ObLOn9f4cwt5jx8D0Ow4SC9/XQ5WUIDXmzbBsMhMkKRi+KQzhufPn2PhwoVwcnLCF198AR6Ph0OHDiE5OVnd+UgVI3J1paLwiXSrVYPZl19CUGTudU2wXfQTzL8dBZ0ShthXB7MBA8A3Noaodh3qtFIBKV0YCgoKsG/fPvj5+cHNzQ23b9/GsmXLwOfzMW/ePHTp0oXmfCakChA5OcFq5kzwNPj7bD52DFh+PtL++AOpoaFqa5cVFGht7KiqROnCYG9vjzVr1uDLL79EQkICDh48iK/oaVlCiBJYYSEyw8OR/yKhyMJ3Zwqvli5D4vffq2U/z8eORZxfF6QsXaaW9j5XSheGwsJC8Hg88Hi8YtN6VlUjRoxAnz59FK7LyclBUFAQ6tSpA5FIBAsLC/Tv3x/37t2T227BggXccSv6FR4eXg4/ASEVw8sVK/Fi0mQ8HTAALD8fAisrOP5vD4QuLgBjyDx9Ri37yf3vPgAg779YtbT3uVK6MCQmJmLMmDHYvXs3bGxs8OWXX+LQoUOf5TAYeXl58PX1xdatW7Fo0SI8ePAAJ06cQGFhIby9vRH9QU+L+vXrIykpSe6rXbt2WkpPSPljubkAAGlWFqQF74b50HN3h+3CH2HYri1sflDPGUON31ah2tfDYDN/vlra+1wpXRj09PTg7++P8+fPIyYmBu7u7pgyZQoKCwvx888/4+zZs5BIJJrMWmGsWrUKV65cwfHjxzFgwADUqlULXl5eOHDgANzd3TFq1Ci5G2q6urqwsbGR+xIWGViMkKpOv0kTAADLz8fbqChuuUGzZqi5eTNMe/VSy34MPD1h8913EDo6qqW9z9Un9UpycXHBokWL8OzZM4SFhSEvLw89evSAlVXpY7BXFbt27ULnzp3h4eEht5zP52P69On4999/cefOnU9qOy8vDxkZGXJfhFR2evXrgW9kBL6hIURubiq9Vpqbi4TAWXgxZSokNIpzuSjTcwx8Ph9du3ZF165d8fr1a/zxxx/qylWhPXjwAB06dFC4zv39oGEPHjxA4/cDoMXExMCoyPAA9erVw9WrVxW+Pjg4GD/++KN6AxOiZSJnZ9SOigRj74bPUEXWxYvIOHbs3Td8HmwXLICOmZn6QxKO0mcMaWlpWLNmjcK/YMViMXbv3o1vv/1WreEqMlX6Xsu698q+Dhw4UOK2c+fOhVgs5r6eP3+ujriEaB3f0FDlogAABo0bQ+DsDPB4yDx1GinBwRpIV7kwxjQ6ZpbShWHt2rW4cOECTExMiq0zNTXFxYsXP5shMerUqYPYWMW9HmTL69Spwy0TCoVwdXXlvhwcHEpsWyQSwcTERO6LEG0qfP0aOR/0titPupaWcAk7DsH73xsdCwu1tS3Ny4MkK0tt7ZWXhClT8bBlK7xavUYj7StdGA4cOIBx48aVuH7s2LHYt2+fWkJVdIMGDUJ4eHix+whSqRQrV65EvXr1it1/IKTSkXUmkUiQUcYRcfOfPkXCjJlI37+/1O0yTp9B0vwg5L94Ibecx+PBae//UOvPHbCaMaNMWWQK37xB3Bd+eNiqNbKvXVNLm+Ul+/2laE3lVvoeQ1xcHGrXrl3i+tq1ayMuLk4toSoSsViM27dvyy0bOnQojhw5gp49e2L58uXw9vZGSkoKfvnlF8TGxiI8PPyz7MZLVCfNy0NWZBT0PRpBYGOj7Tjy3j+vxBMIYNq3T5maerV2HTLCwpBx4gRMunYF37D4JSWWn4+EGTOAwkJIMjNQY+VK+ThmZjBo3rxMOYoqeP4chSkpAICcf2Jg4OmptrY1zXbJYmSePIXqI4ZrpH2lC4OOjg4SExNRs2ZNhesTExPB56ttsNYKIzIyEk3ed7WTGTVqFM6fP49ffvkF3333HZ49ewZjY2N06NAB0dHRaNCggZbSli/xsWN4uXwFTPv0htW0aeW+//T9+5F5NhwWkyZBv2HlPOYpixYhfd9+6NrZovb589qOA0nWWyTPn/+uKLy/j6ZTvTr0ilwa/RSGLVsiIywM+s2agmdgoHAbnlAI/fr1kXPnDgw++J3TBH0PD1jOCEBhykuYDRyo8f2pk7GPD4x9fDTWPo8peRe1Q4cO8Pb2xuLFixWunz17Nq5evYqIiAi1BvzcZWRkwNTUFGKxuMLdb3g6dChyrt8A39AQbjeul+u+GWP4r2EjoLAQhu3aoubmzeW6f3VJnDMX4sOHoWtpidoXL2g7DsRHjiBx9hwAgO/rV0hMTYW9vT1efHBpR1mFaWl4PnoMpNnZsF/9GyQZGUiYPAUiV1c4hGwG/4PneVhhISTp6dBV430E8o4qnyVKnzFMmjQJgwYNQo0aNTB+/HhuWAyJRIL169dj5cqV2LVrV9mSk0rF/Jtv8CozS20PJ6ki9fffIbCxRkFSMow7Vp5pMD9kM/8HGHh7w6BZxZi0yKB5cwjs7QEdHfAyxGVuL+fWbeTevfvu39evI//5c0hSU5GdmoqC+HiIXF3ltufp6lJRqACUPmMAgHnz5iE4OBjGxsZwdnYGADx+/BhZWVkIDAws8WyCfLqKfMagLbkPHuBJr94AAPPx42A1daqWE1VNNWrUQEJCQpnOGKQ5OUic+x2k2W9ht3gxpG/fIjloAUS1XWE1Zw7diytHqnyWqFQYAODq1avYuXMnHj16BMYY6tSpgyFDhsDLy6tMoYliVa0wZF2+jFerV8O0ew9U/3rYJ7UhyXqLp19+iYLERNTYuAFGrVurOSUB1FMYSMWhkUtJMl5eXgqLQFJSEn7++efP5lmGiir3/n2kHzgA0549od+wobbjFJO6OQS5d/5B3n/3P7kw6BgZwvlEGFh+Pvj6+mpOSAhRqRvRvXv3sHbtWoSEhCD9/Xywr1+/xvTp0+Hs7Ew3niuApO/mIe2PHUgMnKXtKAqZ9ukDHTMzmA0cUKZ2eDo6n2VRePv3VSQEzkL2deVv9kuy3iJxzlwkL/wJ7P3IpsC7PvAvf1uNgpSXmohKKjGlzxiOHj2Kr776CoXv54FdsmQJQkJCMGDAADRr1gyHDh1Cly5dNBaUKEdU1w259+5BVLeutqMoZNa3D8zK2Cf+c5YcFIT8p0+R918snGXjB31ExvHjEB8+DAAQh4XB0MsT1YYNQ/zX7/rA5/57DzU3bdJUZFIJKX3GsGjRIkycOBEZGRlYsWIFHj9+jClTpuDEiRM4deoUFYUKwvann+By+hTsl/+q7ShEAwy8vd/918tb+dc0bwYdMzPwDAwgFYuReTYcWUWGvtYxrvz3roh6KX3z2dTUFDdu3ICrqyskEglEIhFOnToFX19fTWf8rFW1m8+k7CRiMXRMTVV6DZNKkfvgIVIWLoR+w4YwHzcWKcHB4Ovpw+bHBQp7B9HN56pFIzefMzMzucZ0dHSgr6/PdVklhJQfVYsCAPD4fOjXdYPjrp3cMvulS9UZi1QhKvVKOn36NEzfvymlUinOnTuHu+8fXpHppYWHnQghJcu+dQuSN29g3KnyPghIypdKhWH4cPkBm8aOHSv3PY/H+2ym9ySkMsiLi8OzocMAiQS2wcF0458oRenCIJVKNZmDEKIJvP/vX8LTqXqDXBLNKNPUnoSQik3k7ATHPXsgSXsDo3bttB2HVBIqF4bU1FSYm5sDAJ4/f46QkBDk5OSgZ8+eaEdvPEIqnMo6JDnRHqXPLWNiYuDo6AgrKyvUrVsXt2/fhqenJ1auXInNmzejY8eOOPz+IRpCCCGVl9KFYdasWWjYsCEuXLgAHx8f9OjRA927d4dYLEZaWhrGjh1Lo6sSQkgVoPSlpGvXruH8+fNo1KgRPDw8sHnzZkyYMIGbtW3y5Mlo0aKFxoISQggpH0qfMbx58wY27+ekNTIygqGhIapVq8atr1atGjIzM9WfkBBCSLlS6ebzh4/N0yQbhFRdAQEByMjIoKFYPkMqFYYRI0ZAJBIBAHJzczFu3DgYGhoCAPLy8tSfjhCiNQEBAdqOQLRE6cLw4VPPQ4cOLbbN119/XfZEhBBCtErpwrBt2zZN5iCEEFJB0DPyhBBC5FBhIIQQIofGSqrgZPMoZWRkaDkJIaQyk32GKDM3GxWGCk72bIiDg4OWkxBCqoLMzExuXp2SKD21J9EOqVSKxMREGBsbq/TcSEZGBhwcHPD8+fNK1Q+dcpcvyl2+tJmbMYbMzEzY2dlxI1aUhM4YKjg+n48aNWp88utNTEwq1S+ODOUuX5S7fGkr98fOFGTo5jMhhBA5VBgIIYTIocJQRYlEIgQFBXFDmFQWlLt8Ue7yVVly081nQgghcuiMgRBCiBwqDIQQQuRQYSCEECKHCkMF8ebNG/j7+8PExARmZmYYNWoUsrKySn1Nbm4uJk6cCHNzcxgZGeHLL79ESkqK3Dbx8fHo3r07DAwMYGVlhcDAQBQWFsptExkZiaZNm0IkEsHV1RWhoaFy6x0dHcHj8Yp9TZw4kcutq6tbbP24ceO0mnvBggXFMtWtW7fY8RaJRBCJRDA0NFSYpbxzBwcHw9PTE8bGxjA2NoaBgQFEIhG8vb1x9epVAICPj4/C471v3z7UrVsXenp6aNiwIU6cOCHXNmMM8+fPh62tLfT19eHr64uHDx/KbaPMe/Gff/5B27ZtoaenBwcHByxdulRu/bp162BlZQU+nw8+nw8XF5diWYoqj9yRkZHo3bs3bG1tYWhoiMaNG2Pnzp1ybQwbNqzYcdXT09Nq7qdPnyr8/YuOjlYpi0oYqRC6dOnCPDw8WHR0NLt48SJzdXVlgwcPLvU148aNYw4ODuzcuXPs+vXrrEWLFqxVq1bc+sLCQtagQQPm6+vLbt26xU6cOMEsLCzY3LlzuW0eP37MDAwMWEBAAPv333/ZmjVrmI6ODjt16hS3zcuXL1lSUhL3dfbsWQaARUREcLmbNGnCevbsyZycnFjfvn1ZUlISE4vFWs0dFBTE6tevL5f91atXcse7b9++zMrKitnb2zM/P79iWbSR28/Pj23bto0tW7aMCQQC1rBhQ2Zra8tGjBjBzMzMWEpKCmvfvj0bPXq03M925swZpqOjw5YuXcr+/fdf9v333zOBQMBiYmK4thcvXsxMTU3Z4cOH2Z07d1ivXr2Yk5MTy8nJ4bb52HtRLBYza2tr5u/vz+7evct2797N9PX12aZNmxhjjO3Zs4cJBALG4/HYjBkzWP/+/Zmenh7T1dWVyyJz+fLlcsn9888/s++//55dvnyZPXr0iK1atYrx+Xx27NgxLreuri7T09NjkZGRzN/fn5mamirMXJ65nzx5wgCw8PBwuf/f+fn5KmVRBRWGCuDff/9lANi1a9e4ZSdPnmQ8Ho8lJCQofE16ejoTCARs37593LLY2FgGgF25coUxxtiJEycYn89nycnJ3DYbNmxgJiYmLC8vjzHG2KxZs1j9+vXl2h44cCDz8/MrMe/UqVOZi4sLu3fvHpe7ffv2bOrUqRUqd1BQEPPw8CiWQXa8IyIiuCyy3FFRUXJZtJFbxsvLi02cOJG9fPmSy2tnZ8eCg4O5413UgAEDWPfu3eWWeXt7s7FjxzLGGJNKpczGxoYtW7ZM7ucSiURs9+7dcsemtPfi+vXrWbVq1bifiTHGZs+ezdzc3Ljcrq6uXBaJRMLs7OyYg4MDl0UbuRXp1q0bGzlyJJe7Y8eOzNTUVC53cHCwwteWV25ZYbh161aJP8fHsqiKLiVVAFeuXIGZmRmaN2/OLfP19QWfz8fff/+t8DU3btxAQUEBfH19uWV169ZFzZo1ceXKFa7dhg0bwtramtvGz88PGRkZuHfvHrdN0TZk28ja+FB+fj7+/PNPfPPNN4iOjpbLvXPnTvj7+4MxhkmTJiE7O1vruR8+fAg7Ozs4OzvD398f8fHx3PGWSqVcFtnxTk1Nlcuirdz5+fm4ceMGfH19IRaLAQAWFhbw9fXltt25cycsLCzQoEEDzJ07F3/99VepbT958gTJycly25iamsLb21vuZ/jYe/HKlSto164dhEKh3H7u37+PlJQU3LhxA2lpadx++Hw+fH19oa+vr/B99bFjoq7ciojFYlSvXp073vXr10dWVhZq1aqFWrVqgc/n48yZMwpfW965e/XqBSsrK7Rp0wZHjx5VKYuqqDBUAMnJybCyspJbpquri+rVqyM5ObnE1wiFQpiZmcktt7a25l6TnJws9yElWy9bV9o2GRkZyMnJKbbfw4cPIz09HSNGjJDLPWTIEPz555+IjIyEiYkJzp8/r3D61/LM7e3tjdDQUJw6dQobNmzAkydP0LZtWzx79gxWVlZyWYoe76JZtJEbAF6/fg2JRAJLS0tMmzYNrVu3RoMGDbj9yY53REQE5s6dix07diAhIUFh20X3XTRTSdt87L1Y2s/533//QSKRID09XW4ba2tr5OXlKXw/l9SeunN/aO/evbh27RpGjhzJHe8GDRpg69atOHLkCP78808IhUJERUXhxYsXWsttZGSE5cuXY9++fQgLC0ObNm3Qp08fueLwsSyqokH0NGjOnDlYsmRJqdvExsaWUxrlyaZxNTAwKHGbD+eHGDNmDPdvkUiEIUOG4LfffkNcXBxcXFw0E/QDyuQ2NDRETExMueRRh19//RV3797FpUuX5JYXPd4NGzaEra0tOnXqVOKNcyIvIiICI0eOREhICOrXr4/ExEQA745ly5Ytue369OmDdevWYdOmTfjpp5+0ktXCwgIBAQHc956enkhMTMSyZcvQq1cvjeyTCoMGzZgxAyNGjCh1G2dnZ9jY2ODly5dyywsLC/HmzRvY2NgofJ2NjQ3y8/ORnp4u91dsSkoK9xobGxuuF0vR9bJ1sv9++GHSpk0bnDx5EtevX5dbnpCQgM6dO2PNmjUfze3t7Q0AePTokVxh0Ebuovz9/ZGbm4uXL1/KZTEyMuKOd9Es5ZE7JSUFJiYm0NfX55ZZWFiAx+Ph4sWLuHbtGjfCrqJsALjj/d9//xVru+i+ZctsbW3ltmncuDG3zcfeiyX9DMC7y2s6OjowMzOT2yYlJQUikUjh6J4ltafu3DJRUVHo2bMnVq5cia+//hrAu+Oto6NTLMfr169RvXp1PHr0SOu5i/L29sbZs2eVzqKyT7ozQdRKdgPq+vXr3LLTp08rdRN3//793LL//vtP4c3QlJQUbptNmzYxExMTlpubyxh7dzO0QYMGcm0PHjxY4c3QoKAgZmNjwwoKCj6a+/DhwwwAu3PnjtZzy2RmZrJq1aqxuXPnMgAsMjKSyyLL/bGbz+WRWyqVsokTJzKBQMCGDh3KLZdIJMze3l7hzdBLly4xAKxdu3Zyy1u2bFnsZuivv/7KrReLxQpvhpb2XpTdfC7aK2bu3LnFbj736NFDLnfNmjVLvPks21aTuRljLCIighkaGrK1a9cWy+Hl5cUmTZrEfS/LbWFhwaZPn67V3B/69ttvWZMmTZTOoioqDBVEly5dWJMmTdjff//NLl26xGrXri3XZe3FixfMzc2N/f3339yycePGsZo1a7Lz58+z69evs5YtW7KWLVty62XdJ7/44gt2+/ZtdurUKWZpaamw+2RgYCCLjY1l69atK9Z9krF3vyQ1a9Zks2fPLpa7Xr16bMyYMez3339njo6OrF27dszZ2Zm1a9dOq7lnzJjBIiMj2ZMnT9jly5eZr68vs7CwYC9fvuSOd9++fZm1tTWrUaMG8/Pz47JoM/f48eOZqakpmz9/PhOJROy3335jUVFR7JtvvmFmZmYsOjqaLVy4kHXr1o2NHz+eHTlyhDk7OzMPDw+mq6vLfv31VxYbG8uCgoIUdp80MzNjR44cYf/88w/r3bu3wu6Tpb0X09PTmbW1NRs2bBi7e/cu27NnDzMwMJDrrioUChmfz2eBgYFswIABct1Vhw0bxubMmcO1d/ny5XLJff78eWZgYMDmzp0r1+0zNTWVy62rq8tmzpzJTp8+zfr168cEAgETiUTs3r17WssdGhrKdu3axWJjY1lsbCz7+eefGZ/PZ1u3blUpiyqoMFQQqampbPDgwczIyIiZmJiwkSNHsszMTG69rMtaREQEtywnJ4dNmDCBVatWjRkYGHDPDxT19OlT1rVrV6avr88sLCzYjBkzuL/4ZSIiIljjxo2ZUChkzs7ObNu2bcXynT59mgFg9+/fL5a7d+/eTEdHh/F4PMbn85mzszMLDAxkYrFYq7kHDhzIbG1tmVAoZPb29mzgwIHs0aNHxY63UChkQqGQ6evrc1m0mRuAwi9nZ2cWHR3N4uPjWbt27Ziuri7j8/nM1dWVO9579+5lderUYUKhkNWvX5+FhYXJtS2VStkPP/zArK2tmUgkYp06dVL4/7S09yJjjN25c4e1adOGiUQiZm9vzxYvXiy3fs2aNczCwoLxeDzG4/GYk5MTl6V9+/Zs+PDhctuXR+7hw4crPK7t27fntvHx8WE6OjoMANPV1WWtWrViN2/e1Gru0NBQ5u7uzgwMDJiJiQnz8vKS6zatbBZV0OiqhBBC5FB3VUIIIXKoMBBCCJFDhYEQQogcKgyEEELkUGEghBAihwoDIYQQOVQYCCGEyKHCQAghRA4VBlKhLFiwgBtgTJ1k0yPevn0bwLtpHnk8HtLT0wEAoaGhxYbUVsXH2tPUz6UMHx8fTJs2TSv7JpUTFQZSZiNGjODmoRUIBLC2tkbnzp2xdetWSKXSMrfdp08f9QQtolWrVkhKSlI42qc6DBw4EA8ePNBI2+Sd0NBQhXMhlzZHszqEhISgbdu2qFatGqpVqwZfX99io+pWdlQYiFp06dIFSUlJePr0KU6ePIkOHTpg6tSp6NGjBwoLC7UdrxihUAgbGxvweDyNtK+vr19sAhYCMMbU+n4wMTFBUlKS3NezZ8/U1r4ikZGRGDx4MCIiInDlyhU4ODjgiy++QEJCgkb3W56oMBC1EIlEsLGxgb29PZo2bYrvvvsOR44cwcmTJxEaGsptl56ejm+//RaWlpYwMTFBx44dcefOHYVtLliwANu3b8eRI0e4vwYjIyMBALNnz0adOnVgYGAAZ2dn/PDDDygoKFA674eXfj706tUrNG/eHH379kVeXh6kUimCg4Ph5OQEfX19eHh4YP/+/SW2X9KlqR07dsDR0RGmpqYYNGgQMjMzuXV5eXmYMmUKrKysoKenhzZt2uDatWtyr4+KioKXlxdEIhFsbW0xZ84cuQ/at2/f4uuvv4aRkRFsbW2xfPnyjx6LO3fuoEOHDjA2NoaJiQmaNWsmN6fF5cuX4ePjAwMDA1SrVg1+fn5IS0tTKrPsOJ88eRLNmjWDSCTCpUuXVD6eJeHxeLCxsZH7ks1ktnnzZtjZ2RU7a+3duze++eYb7vsNGzbAxcUFQqEQbm5u2LFjR6n73LlzJyZMmIDGjRujbt26+P333yGVSnHu3DmV81dUVBiIxnTs2BEeHh44ePAgt6x///54+fIlTp48iRs3bqBp06bo1KkT3rx5U+z1M2fOxIABA7izkaSkJLRq1QoAYGxsjNDQUPz777/47bffEBISgpUrV6ol9/Pnz9G2bVs0aNAA+/fvh0gkQnBwMP744w9s3LgR9+7dw/Tp0zF06FBERUUp3W5cXBwOHz6M48eP4/jx44iKisLixYu59bNmzcKBAwewfft23Lx5E66urvDz8+OOTUJCArp16wZPT0/cuXMHGzZswJYtW7Bo0SKujcDAQERFReHIkSM4c+YMIiMjcfPmzVJz+fv7o0aNGrh27Rpu3LiBOXPmQCAQAABu376NTp06oV69erhy5QouXbqEnj17QiKRKJVZZs6cOVi8eDFiY2PRqFEjtRzPj+nfvz9SU1MRERHBLXvz5g1OnToFf39/AMChQ4cwdepUzJgxA3fv3sXYsWMxcuRIudd8THZ2NgoKClC9enW1Zde6Tx6XlZD3hg8fznr37q1w3cCBA5m7uztjjLGLFy/KTVoj4+Liwo3lHxQUxDw8PJRqu6hly5axZs2albheNoz2rVu3GGPvhr4GwNLS0hhjjG3bto2Zmpqy//77jzk4OLApU6YwqVTKGGMsNzeXGRgYsL/++kuuzVGjRnHj5pfUnkxQUBAzMDBgGRkZ3LLAwEDm7e3NGGMsKyuLCQQCtnPnTm59fn4+s7OzY0uXLmWMMfbdd98xNzc3LhdjjK1bt44ZGRkxiUTCMjMzmVAoZHv37uXWp6amMn19fTZ16tQSj42xsTELDQ1VuG7w4MGsdevWCtcpk1l2XA4fPsxto8zxVMa2bdsYAGZoaCj31aVLF26b3r17s2+++Yb7ftOmTczOzo5JJBLGGGOtWrVio0ePlmu3f//+rFu3bkrnGD9+PHN2dpabY6Gyo6k9iUYxxrjr+Hfu3EFWVhbMzc3ltsnJyUFcXJxK7f7vf//D6tWrERcXh6ysLBQWFsLExKRMWXNyctC2bVsMGTIEq1at4pY/evQI2dnZ6Ny5s9z2+fn5aNKkidLtOzo6wtjYmPve1taWm9YxLi4OBQUFaN26NbdeIBDAy8uLmxc8NjYWLVu2lLsv0rp1a2RlZeHFixdIS0tDfn4+N80nAFSvXh1ubm6l5goICMC3336LHTt2wNfXF/379+emY719+zb69++v8HXKZJZp3rw59291HU/g3Znjh2dERadI9ff3x+jRo7F+/XqIRCLs3LkTgwYNAp//7mJJbGys3PzZwLtj+ttvvym1/8WLF2PPnj2IjIzU+E3v8kSFgWhUbGwsnJycAABZWVmwtbXl7hMUpUpX0StXrsDf3x8//vgj/Pz8YGpqij179ih1Pb00IpEIvr6+OH78OAIDA2Fvb8/lBoCwsDBuWdHXKEt2eUaGx+OVudeWOixYsABDhgxBWFgYTp48iaCgIOzZswd9+/aV+5AtC0NDQ+7f6jqeAMDn8+Hq6lri+p49e4IxhrCwMHh6euLixYtqu+T466+/YvHixQgPD0ejRo3U0mZFQfcYiMacP38eMTEx+PLLLwEATZs2RXJyMnR1deHq6ir3ZWFhobANoVDIXc+W+euvv1CrVi3MmzcPzZs3R+3atdXSE4XP52PHjh1o1qwZOnTogMTERABAvXr1IBKJEB8fXyy3g4NDmfcLgLv5efnyZW5ZQUEBrl27hnr16gEA3N3dceXKFbAic2tdvnwZxsbGqFGjBlxcXCAQCPD3339z69PS0pTqNlunTh1Mnz4dZ86cQb9+/bBt2zYAQKNGjUq8qapMZkXK43jK6OnpoV+/fti5cyd2794NNzc3NG3alFvv7u4ulx94d0xLyw8AS5cuxU8//YRTp07JnQ1VFXTGQNQiLy8PycnJkEgkSElJwalTpxAcHIwePXrg66+/BgD4+vqiZcuW6NOnD5YuXYo6deogMTERYWFh6Nu3r8JfMEdHR5w+fRr379+Hubk5TE1NUbt2bcTHx2PPnj3w9PREWFgYDh06pJafQ0dHBzt37sTgwYPRsWNHREZGwsbGBjNnzsT06dMhlUrRpk0biMViXL58GSYmJhg+fHiZ92toaIjx48cjMDAQ1atXR82aNbF06VJkZ2dj1KhRAIAJEyZg1apVmDx5MiZNmoT79+8jKCgIAQEB4PP5MDIywqhRoxAYGAhzc3NYWVlh3rx53GUTRXJychAYGIivvvoKTk5OePHiBa5du8YV87lz56Jhw4aYMGECxo0bB6FQiIiICPTv3x8WFhYfzayIsbGx2o4nYwzJycnFlltZWXE/t7+/P3r06IF79+5h6NChctsFBgZiwIABaNKkCXx9fXHs2DEcPHgQ4eHhJe5zyZIlmD9/Pnbt2gVHR0du/0ZGRjAyMlI6e4Wm3VscpCooOpeurq4us7S0ZL6+vmzr1q3cTT6ZjIwMNnnyZGZnZ8cEAgFzcHBg/v7+LD4+njFW/Obzy5cvWefOnZmRkZHcHMyBgYHM3NycGRkZsYEDB7KVK1fK3ez9kLI3n2UKCgpYv379mLu7O0tJSWFSqZStWrWKubm5MYFAwCwtLZmfnx+LiopSqr0Pfy7GGFu5ciWrVasW931OTg6bPHkys7CwYCKRiLVu3ZpdvXpV7jWRkZHM09OTCYVCZmNjw2bPni03p3RmZiYbOnQoMzAwYNbW1mzp0qWsffv2Jd58zsvLY4MGDWIODg5MKBQyOzs7NmnSJLkbqZGRkaxVq1ZMJBIxMzMz5ufnx/2cH8v84XGR+djxZIyxWrVqsaCgIIW5ZccYJcyPXXQubolEwmxtbRkAFhcXV6yd9evXM2dnZyYQCFidOnXYH3/8UeI+ZbkU7bO0rJUNzflMCKlwsrOzYW5ujpMnT8LHx0fbcT47dI+BEFLhREREoGPHjlQUtITOGAghhMihMwZCCCFyqDAQQgiRQ4WBEEKIHCoMhBBC5FBhIIQQIocKAyGEEDlUGAghhMihwkAIIUQOFQZCCCFyqDAQQgiR83+R2L2SJJujbwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "<Figure size 400x200 with 1 Axes>" ] @@ -1493,20 +1532,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can also calculate the area under the receiver operating characteristic curve (AUROC) of this zero-shot prediction method.\n", + "We can also calculate the area under the receiver operating characteristic curve (AUROC) of this zero-shot prediction method. Note that the results are nearly random unless you are on one of the following configurations:\n", + "* `--fp8` on an fp8 enabled GPU with either the 1b or 7b models. The 40b likely works as well.\n", + "* the 7b model uniquely seems to work well without `--fp8` so if you are on an older device, the 7b model should produce\n", + " robust results. Change the `MODEL_SIZE` earlier in this tutorial and rerun for good results in that case.\n", "\n" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Zero-shot prediction AUROC: 0.4\n" + "Zero-shot prediction AUROC: 0.77\n" ] } ], @@ -1517,13 +1559,6 @@ "auroc = roc_auc_score(y_true, -brca1_df['evo2_delta_score'])\n", "print(f'Zero-shot prediction AUROC: {auroc:.2}')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 66ead7550c558c4bca56d26fb797f765621a309a Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 17:09:16 +0000 Subject: [PATCH 112/140] add missing/new NGC urls Signed-off-by: John St John <jstjohn@nvidia.com> --- .../src/bionemo/core/data/resources/evo2.yaml | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index d61b2b27e9..5b72330f08 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -1,5 +1,5 @@ - tag: 1b-8k:1.0 - ngc: null + ngc: nvidia/clara/evo2-1b-8k-nemo2:1.0 ngc_registry: model pbss: "s3://bionemo-ci/models/nemo2_evo2_1b_8k.tar.gz" sha256: d663c529ac7ae0b6f2fd3a852253a484bd8a6576992e9ec73045ce7af2365990 # pragma: allowlist secret @@ -17,6 +17,15 @@ description: > A 7b parameter evo2 model used in testing, torch_dist format. Converted from hf://arcinstitute/savanna_evo2_7b_base. +- tag: 7b-8k-zarr:1.0 + ngc: nvidia/clara/evo2-7b-8k-zarr:1.1 + ngc_registry: model + pbss: "s3://bionemo-ci/models/interleaved_hyena_7b_fix_shape_v2.tar.gz" + sha256: e08d89a1841a6aa3796c772ffe84092f20ac0a11d1b6ef7b1966ebbd8253e17e # pragma: allowlist secret + owner: John St John <jstjohn@nvidia.com> + description: > + A 7b parameter evo2 model used in testing, zarr format (deprecated but equivalent to `evo2/7b-8k:1.0`). + - tag: 7b-1m:1.0 ngc: null ngc_registry: model @@ -28,7 +37,7 @@ - tag: 7b-8k-nofp8-te-goldvalue-testdata:1.0 - ngc: null + ngc: nvidia/clara/evo2-7b-8k-nofp8-te-goldvalue-testdata:1.0 ngc_registry: resource pbss: "s3://bionemo-ci/test_data/evo2/final_7b_no_fp8_golden_value.pt" sha256: dee5372fc6011dffc3f3933440623993b1870961fec6a24d1a3a874c940259b2 # pragma: allowlist secret @@ -43,7 +52,7 @@ ATAATTTTAATTTATATAAT - tag: 1b-8k-nofp8-te-goldvalue-testdata-A6000:1.0 - ngc: null + ngc: nvidia/clara/evo2-1b-8k-nofp8-te-goldvalue-testdata-a6000:1.0 ngc_registry: resource pbss: "s3://bionemo-ci/test_data/evo2/final_1b_no_fp8_golden_value_A6000.pt" sha256: 289dc1c4c919162b467c7f068d27fa16e9670cb4a9fd15696198c6a6aac2fa21 # pragma: allowlist secret @@ -56,7 +65,9 @@ TCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGA CTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATAT ATAATTTTAATTTATATAAT - The following command was used to get logits after adding the above to a fasta file: + The following command was used to get logits after adding the above to a fasta file. Note in general --fp8 is + required for good prediction accuracy for downstream zero shot tasks for the 1b model. The 7b model is robust to + fp8 precision exclusion at inference time: ```bash predict_evo2 \ --fasta test_seq.fasta \ From 0c67976c28764219734f0d0a323c906a41e9eeca Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 17:13:29 +0000 Subject: [PATCH 113/140] Remove fasta from pre commit Signed-off-by: John St John <jstjohn@nvidia.com> --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 34918764ad..6b2c2ecd85 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -18,7 +18,7 @@ repos: hooks: - id: detect-secrets name: detect-secrets (everything but notebooks) - args: ['--baseline', '.secrets.baseline', '--exclude-files', '(.*\.ipynb|.*\.baseline|.*\.fasta)$', ] + args: ['--baseline', '.secrets.baseline', '--exclude-files', '(.*\.ipynb|.*\.baseline)$', ] exclude: package.lock.json - id: detect-secrets name: detect-secrets (notebooks only) From ae81e4d0902740d39bf5d59c2df34af074aba3e2 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 17:15:57 +0000 Subject: [PATCH 114/140] Remove TODOs related to PBSS Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-core/tests/bionemo/core/data/test_load.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py index 356b967b02..c2a3dcef0b 100644 --- a/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py +++ b/sub-packages/bionemo-core/tests/bionemo/core/data/test_load.py @@ -43,8 +43,6 @@ def test_load_raises_error_on_invalid_tag(tmp_path): def test_load_cli(): - # It looks like there's some issues with our NGC resources, but this is blocking CI. TODO: Revert to ngc when these - # resources are available. result = subprocess.run( ["download_bionemo_data", "single_cell/testdata-20240506"], stdout=subprocess.PIPE, # Capture stdout @@ -111,7 +109,6 @@ def test_load_with_file(mocked_s3_download, tmp_path): ) mocked_s3_download.side_effect = lambda _1, output_file, _2: Path(output_file).write_text("test") - # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/bar", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_file() assert file_path.read_text() == "test" @@ -134,7 +131,6 @@ def write_compressed_text(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_text - # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_file() assert file_path.read_text() == "test" @@ -158,7 +154,6 @@ def write_compressed_text(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_text - # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/baz", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") # Assert the file remained compressed. @@ -194,7 +189,6 @@ def write_compressed_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_compressed_dir - # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") assert file_path.is_dir() assert (file_path / "test_file").read_text() == "test" @@ -228,7 +222,6 @@ def write_tarfile_dir(_1, output_file: str, _2): mocked_s3_download.side_effect = write_tarfile_dir - # TODO(dorotat-nv) remove source="pbss" when NGC resources are available file_path = load("foo/dir", resources=get_all_resources(tmp_path), cache_dir=tmp_path, source="pbss") # Assert the file stays as a tarfile. From b15cc82ed34d1c2a0e8b1cca4ce3412a97372efc Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 17:21:10 +0000 Subject: [PATCH 115/140] Moved test config into the tests/config dir with the other configs Signed-off-by: John St John <jstjohn@nvidia.com> --- .../test_promotors_dataset_config.yaml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sub-packages/bionemo-evo2/tests/{bionemo/evo2/data/test_dataset_config.yaml => config/test_promotors_dataset_config.yaml} (100%) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml b/sub-packages/bionemo-evo2/tests/config/test_promotors_dataset_config.yaml similarity index 100% rename from sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_dataset_config.yaml rename to sub-packages/bionemo-evo2/tests/config/test_promotors_dataset_config.yaml From a752309c088966683618beac92e9ef2b94497d3f Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 17:32:04 +0000 Subject: [PATCH 116/140] Address yaml location feedback Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/examples/configs/README.md | 4 ++++ .../configs/full_pretrain_longphase_config.yaml} | 0 .../configs/full_pretrain_shortphase_config.yaml} | 0 .../config => examples/configs}/test_preproc_config.yaml | 0 .../configs}/test_promotors_dataset_config.yaml | 0 5 files changed, 4 insertions(+) create mode 100644 sub-packages/bionemo-evo2/examples/configs/README.md rename sub-packages/bionemo-evo2/{tests/config/longphase_dataset_config.yaml => examples/configs/full_pretrain_longphase_config.yaml} (100%) rename sub-packages/bionemo-evo2/{tests/config/test_dataset_config.yaml => examples/configs/full_pretrain_shortphase_config.yaml} (100%) rename sub-packages/bionemo-evo2/{tests/config => examples/configs}/test_preproc_config.yaml (100%) rename sub-packages/bionemo-evo2/{tests/config => examples/configs}/test_promotors_dataset_config.yaml (100%) diff --git a/sub-packages/bionemo-evo2/examples/configs/README.md b/sub-packages/bionemo-evo2/examples/configs/README.md new file mode 100644 index 0000000000..2c3f12cb94 --- /dev/null +++ b/sub-packages/bionemo-evo2/examples/configs/README.md @@ -0,0 +1,4 @@ +## Example configs +These configs are provided as examples to the user. +* `full_pretrain_shortphase_config.yaml` was used to test full scale pre-training runs of evo2 at the 8k context length. +* `full_pretrain_longphase_config.yaml` was used to test full scale context extension phase pre-training (starting from an 8k checkpoint and continuing to train at longer context lengths). \ No newline at end of file diff --git a/sub-packages/bionemo-evo2/tests/config/longphase_dataset_config.yaml b/sub-packages/bionemo-evo2/examples/configs/full_pretrain_longphase_config.yaml similarity index 100% rename from sub-packages/bionemo-evo2/tests/config/longphase_dataset_config.yaml rename to sub-packages/bionemo-evo2/examples/configs/full_pretrain_longphase_config.yaml diff --git a/sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml b/sub-packages/bionemo-evo2/examples/configs/full_pretrain_shortphase_config.yaml similarity index 100% rename from sub-packages/bionemo-evo2/tests/config/test_dataset_config.yaml rename to sub-packages/bionemo-evo2/examples/configs/full_pretrain_shortphase_config.yaml diff --git a/sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml b/sub-packages/bionemo-evo2/examples/configs/test_preproc_config.yaml similarity index 100% rename from sub-packages/bionemo-evo2/tests/config/test_preproc_config.yaml rename to sub-packages/bionemo-evo2/examples/configs/test_preproc_config.yaml diff --git a/sub-packages/bionemo-evo2/tests/config/test_promotors_dataset_config.yaml b/sub-packages/bionemo-evo2/examples/configs/test_promotors_dataset_config.yaml similarity index 100% rename from sub-packages/bionemo-evo2/tests/config/test_promotors_dataset_config.yaml rename to sub-packages/bionemo-evo2/examples/configs/test_promotors_dataset_config.yaml From b1bb99dd329559b8a77ef937f1a5ad945b94507e Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 19:03:24 +0000 Subject: [PATCH 117/140] Add new test covering padding and seq dims Signed-off-by: John St John <jstjohn@nvidia.com> --- .../tests/bionemo/llm/test_lightning.py | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py b/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py index ace58b8a35..f29d29cbb6 100644 --- a/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py +++ b/sub-packages/bionemo-llm/tests/bionemo/llm/test_lightning.py @@ -24,6 +24,34 @@ from bionemo.testing import megatron_parallel_state_utils +def test_batch_collate_seqdim_and_singleton_with_padding(batch_size=2, num_batches=5): + raw_batches = [ + # Try making the data with an unusual dtype (uint8) to verify that it is left unchanged with padding. + {"idx": torch.tensor([i] * batch_size), "seq": torch.ones(batch_size, i + 1, dtype=torch.uint8)} + for i in range(num_batches) + ] + result = batch_collator(raw_batches) + assert isinstance(result, dict), "expect output container to be the same type as input (dict)" + torch.testing.assert_close(result["idx"], torch.tensor([0, 0, 1, 1, 2, 2, 3, 3, 4, 4])) + # Make sure the padding is correct, and that the dtype is left as it was. + expected_result = torch.tensor( + [ + [1, 0, 0, 0, 0], + [1, 0, 0, 0, 0], + [1, 1, 0, 0, 0], + [1, 1, 0, 0, 0], + [1, 1, 1, 0, 0], + [1, 1, 1, 0, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 1], + [1, 1, 1, 1, 1], + ], + dtype=torch.uint8, + ) + torch.testing.assert_close(result["seq"], expected_result) + + def test_batch_collate_tuple(): result = batch_collator(tuple((torch.tensor([i]), torch.tensor([i + 1])) for i in range(10))) assert isinstance(result, tuple), "expect output container to be the same type as input (tuple)" From 4f67795a6609e2f3ddad73e7d3edfbc3936732c8 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 19:04:08 +0000 Subject: [PATCH 118/140] Address comments on documentation Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/README.md | 37 +++++++++++-------- .../bionemo-evo2/examples/configs/README.md | 6 ++- 2 files changed, 26 insertions(+), 17 deletions(-) diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index d203a9b15d..40fd147ed8 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -2,6 +2,9 @@ `bionemo-evo2` is a `pip`-installable package that contains **data preprocessing**, **training**, and **inferencing** code for Evo2, a new `Hyena`-based foundation model for genome generation and understanding. Built upon `Megatron-LM` parallelism and `NeMo2` algorithms, `bionemo-evo2` provides the remaining tools necessary to effectively fine-tune the pre-trained Evo2 model checkpoint on user-provided sequences at scale, and generate state-of-the-art life-like DNA sequences from Evo2 for downstream metagenomic tasks. +## Quickstart tutorials +Please see + ## Installation To install this package, execute the following command: @@ -161,27 +164,35 @@ As in `train_evo2`, `--ckpt-dir` points to the NeMo2 checkpoint directory for Ev ## Checkpoint conversion from hugging face to NeMo2 The following conversion script should work on any savanna formatted arc evo2 checkpoint. Make sure you match up the model size with the checkpoint you are converting. -The pyproject.toml also makes the conversion script available as a command line tool `evo2_convert_to_nemo2`, so you +The pyproject.toml makes the conversion script available as a command line tool `evo2_convert_to_nemo2`, so you can try replacing: + ```bash -python \ - sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ +evo2_convert_to_nemo2 \ ... ``` -with: + +with the following if you want to run with `-m pdb` or something: ```bash -evo2_convert_to_nemo2 \ +python \ + sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ ... ``` +### 1b-8k ```bash -python \ - sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ +evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_1b_base \ --model-size 1b --output-dir nemo2_evo2_1b_8k ``` +This new checkpoint `nemo2_evo2_1b_8k` is ready to go in nemo2 format in downstream pretraining or prediction workflows. + +#### Optional steps if you want to register the model with NGC + +If you want to register the checkpoint with NGC (typically only NVIDIA employees) then you can do the following. + To create the checkpoint for distribution in NGC, first cd into the checkpiont directory: ```bash cd nemo2_evo2_1b_8k @@ -203,29 +214,25 @@ Then register it into the loader for testing purposes by editing ### 7b-8k ```bash -python \ - sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ +evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_7b_base \ --model-size 7b --output-dir nemo2_evo2_7b_8k ``` ### 7b-1M ```bash -python \ - sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ +evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_7b \ --model-size 7b_arc_longcontext --output-dir nemo2_evo2_7b_1m ``` ### 40b-8k ```bash -python \ - sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ +evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_40b_base \ --model-size 40b --output-dir nemo2_evo2_40b_8k ``` ### 40b-1M ```bash -python \ - sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ +evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_40b \ --model-size 40b_arc_longcontext --output-dir nemo2_evo2_40b_1m ``` diff --git a/sub-packages/bionemo-evo2/examples/configs/README.md b/sub-packages/bionemo-evo2/examples/configs/README.md index 2c3f12cb94..f8aefc57ca 100644 --- a/sub-packages/bionemo-evo2/examples/configs/README.md +++ b/sub-packages/bionemo-evo2/examples/configs/README.md @@ -1,4 +1,6 @@ ## Example configs -These configs are provided as examples to the user. +These configs are provided as examples to the user. Note that the files referenced in these configs can be downloaded from [OpenGenome2 dataset on Hugging Face](https://huggingface.co/datasets/arcinstitute/opengenome2). * `full_pretrain_shortphase_config.yaml` was used to test full scale pre-training runs of evo2 at the 8k context length. -* `full_pretrain_longphase_config.yaml` was used to test full scale context extension phase pre-training (starting from an 8k checkpoint and continuing to train at longer context lengths). \ No newline at end of file +* `full_pretrain_longphase_config.yaml` was used to test full scale context extension phase pre-training (starting from an 8k checkpoint and continuing to train at longer context lengths). +* `test_preproc_config.yaml` was used to test our preprocessing scripts to generate .bin/.idx files that are used for pre-training from fasta file inputs. +* `test_promotors_dataset_config.yaml` is a smaller test file that can be used for pre-training but is one of the smaller tests. \ No newline at end of file From 97d384528b20e095cc710a234821a71553d016b0 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 19:04:40 +0000 Subject: [PATCH 119/140] Run pre-commit on docs Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/README.md | 2 +- sub-packages/bionemo-evo2/examples/configs/README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 40fd147ed8..724de20f7e 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -3,7 +3,7 @@ `bionemo-evo2` is a `pip`-installable package that contains **data preprocessing**, **training**, and **inferencing** code for Evo2, a new `Hyena`-based foundation model for genome generation and understanding. Built upon `Megatron-LM` parallelism and `NeMo2` algorithms, `bionemo-evo2` provides the remaining tools necessary to effectively fine-tune the pre-trained Evo2 model checkpoint on user-provided sequences at scale, and generate state-of-the-art life-like DNA sequences from Evo2 for downstream metagenomic tasks. ## Quickstart tutorials -Please see +Please see ## Installation diff --git a/sub-packages/bionemo-evo2/examples/configs/README.md b/sub-packages/bionemo-evo2/examples/configs/README.md index f8aefc57ca..b793e72f4e 100644 --- a/sub-packages/bionemo-evo2/examples/configs/README.md +++ b/sub-packages/bionemo-evo2/examples/configs/README.md @@ -3,4 +3,4 @@ These configs are provided as examples to the user. Note that the files referenc * `full_pretrain_shortphase_config.yaml` was used to test full scale pre-training runs of evo2 at the 8k context length. * `full_pretrain_longphase_config.yaml` was used to test full scale context extension phase pre-training (starting from an 8k checkpoint and continuing to train at longer context lengths). * `test_preproc_config.yaml` was used to test our preprocessing scripts to generate .bin/.idx files that are used for pre-training from fasta file inputs. -* `test_promotors_dataset_config.yaml` is a smaller test file that can be used for pre-training but is one of the smaller tests. \ No newline at end of file +* `test_promotors_dataset_config.yaml` is a smaller test file that can be used for pre-training but is one of the smaller tests. From 7473e14b4d488e06a80deefd83795b130c2730a8 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 19:08:38 +0000 Subject: [PATCH 120/140] Address PR feedback on test naming Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/tests/bionemo/evo2/run/test_predict.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py index e5dd2e476d..9c443a3168 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/run/test_predict.py @@ -30,7 +30,7 @@ from bionemo.testing.data.fasta import ALU_SEQUENCE, create_fasta_file -def test_train_evo2_runs( +def test_predict_evo2_runs( tmp_path, num_sequences: int = 5, target_sequence_lengths: list[int] = [3149, 3140, 1024, 3149, 3149] ): """ From 6be9801bcab28374d03a3dc69a4a422f9b7c6832 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Tue, 4 Mar 2025 11:33:59 -0800 Subject: [PATCH 121/140] Refactor out fasta dataset, add tests for it (#716) Refactor out Fasta dataset class to its own file and add tests. Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- .../src/bionemo/evo2/data/fasta_dataset.py | 64 ++++++++++++++ .../src/bionemo/evo2/run/predict.py | 45 +--------- .../bionemo/evo2/data/test_fasta_dataset.py | 87 +++++++++++++++++++ 3 files changed, 152 insertions(+), 44 deletions(-) create mode 100644 sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py create mode 100644 sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py new file mode 100644 index 0000000000..7b5181e0c7 --- /dev/null +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py @@ -0,0 +1,64 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import json +import torch +from pathlib import Path +from bionemo.noodles.nvfaidx import NvFaidx + +class SimpleFastaDataset(torch.utils.data.Dataset): + """A simple dataset for Evo2 prediction.""" + + def __init__(self, fasta_path: Path, tokenizer, prepend_bos: bool = True): + """Initialize the dataset.""" + super().__init__() + self.fasta = NvFaidx(fasta_path) + self.seqids = sorted(self.fasta.keys()) + self.tokenizer = tokenizer + self.prepend_bos = prepend_bos # needed for getting predictions for the requested set of tokens. + + def write_idx_map(self, output_dir: Path): + """Write the index map to the output directory.""" + with open(output_dir / "seq_idx_map.json", "w") as f: + json.dump({seqid: idx for idx, seqid in enumerate(self.seqids)}, f) + + def __len__(self): + """Get the length of the dataset.""" + return len(self.seqids) + + def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: + """Get an item from the dataset.""" + sequence = self.fasta[self.seqids[idx]].sequence().upper() + tokenized_seq = self.tokenizer.text_to_ids(sequence) + if self.prepend_bos: # in pretraining we use EOS to start new sequences. + tokens: list[int] = [self.tokenizer.eod] + tokenized_seq + else: + tokens: list[int] = tokenized_seq + loss_mask = torch.ones_like(torch.tensor(tokens, dtype=torch.long), dtype=torch.long) + if self.prepend_bos: + loss_mask[0] = ( + 0 # mask the eos token which we use for causal offsetting. Later in predict we take the output + ) + # for the first [:-1] tokens which align with the sequence starting after the EOS. + return { + "tokens": torch.tensor(tokens, dtype=torch.long), + "position_ids": torch.arange(len(tokens), dtype=torch.long), + "seq_idx": torch.tensor(idx, dtype=torch.long), + "loss_mask": loss_mask, + } diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py index 2c1769803c..a8e5afb9d5 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/predict.py @@ -18,7 +18,6 @@ import argparse -import json import tempfile from pathlib import Path from typing import Literal, Optional @@ -35,9 +34,9 @@ from nemo.lightning.data import WrappedDataLoader from torch import Tensor +from bionemo.evo2.data.fasta_dataset import SimpleFastaDataset from bionemo.llm.lightning import LightningPassthroughPredictionMixin from bionemo.llm.utils.callbacks import PredictionWriter -from bionemo.noodles.nvfaidx import NvFaidx CheckpointFormats = Literal["torch_dist", "zarr"] @@ -179,48 +178,6 @@ def predict_step(self, batch, batch_idx: Optional[int] = None) -> Tensor: } -class SimpleFastaDataset(torch.utils.data.Dataset): - """A simple dataset for Evo2 prediction.""" - - def __init__(self, fasta_path: Path, tokenizer, prepend_bos: bool = True): - """Initialize the dataset.""" - super().__init__() - self.fasta = NvFaidx(fasta_path) - self.seqids = sorted(self.fasta.keys()) - self.tokenizer = tokenizer - self.prepend_bos = prepend_bos # needed for getting predictions for the requested set of tokens. - - def write_idx_map(self, output_dir: Path): - """Write the index map to the output directory.""" - with open(output_dir / "seq_idx_map.json", "w") as f: - json.dump({seqid: idx for idx, seqid in enumerate(self.seqids)}, f) - - def __len__(self): - """Get the length of the dataset.""" - return len(self.seqids) - - def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: - """Get an item from the dataset.""" - sequence = self.fasta[self.seqids[idx]].sequence().upper() - tokenized_seq = self.tokenizer.text_to_ids(sequence) - if self.prepend_bos: # in pretraining we use EOS to start new sequences. - tokens: list[int] = [self.tokenizer.eod] + tokenized_seq - else: - tokens: list[int] = tokenized_seq - loss_mask = torch.ones_like(torch.tensor(tokens, dtype=torch.long), dtype=torch.long) - if self.prepend_bos: - loss_mask[0] = ( - 0 # mask the eos token which we use for causal offsetting. Later in predict we take the output - ) - # for the first [:-1] tokens which align with the sequence starting after the EOS. - return { - "tokens": torch.tensor(tokens, dtype=torch.long), - "position_ids": torch.arange(len(tokens), dtype=torch.long), - "seq_idx": torch.tensor(idx, dtype=torch.long), - "loss_mask": loss_mask, - } - - def hyena_predict_forward_step(model, batch) -> torch.Tensor: """Performs a forward step for the Hyena model. diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py new file mode 100644 index 0000000000..72458f2326 --- /dev/null +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py @@ -0,0 +1,87 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Arc Institute. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Michael Poli. All rights reserved. +# SPDX-FileCopyrightText: Copyright (c) 2024 Stanford University. All rights reserved +# SPDX-License-Identifier: LicenseRef-Apache2 +# +# 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. + + +import pytest +from pathlib import Path +import torch + +from bionemo.testing.data.fasta import create_fasta_file +from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer +from bionemo.evo2.data.fasta_dataset import SimpleFastaDataset + + +@pytest.fixture +def fasta_dataset(tmp_path: Path) -> None: + """Fixture to create a SimpleFastaDataset for testing.""" + test_fasta_file_path = create_fasta_file(tmp_path / "test.fasta", num_sequences=10, sequence_length=100) + tokenizer = get_nmt_tokenizer("byte-level") + return SimpleFastaDataset(test_fasta_file_path, tokenizer) + + +def test_simple_fasta_dataset_initialization(fasta_dataset: SimpleFastaDataset) -> None: + """Test initialization of SimpleFastaDataset.""" + # Check dataset length + assert len(fasta_dataset) == 10, "Dataset length should match number of sequences" + + # Check seqids + assert len(fasta_dataset.seqids) == 10, "Seqids should match number of sequences" + + +def test_simple_fasta_dataset_getitem(fasta_dataset: SimpleFastaDataset) -> None: + """Test __getitem__ method of SimpleFastaDataset.""" + # Test first item + item = fasta_dataset[0] + + # Check keys + expected_keys = {"tokens", "position_ids", "seq_idx", "loss_mask"} + assert set(item.keys()) == expected_keys, "Item should have correct keys" + + # Check token type + assert isinstance(item["tokens"], torch.Tensor), "Tokens should be a torch.Tensor" + assert item["tokens"].dtype == torch.long, "Tokens should be long dtype" + + # Check position_ids + assert isinstance(item["position_ids"], torch.Tensor), "Position IDs should be a torch.Tensor" + assert item["position_ids"].dtype == torch.long, "Position IDs should be long dtype" + + # Validate sequence index + assert isinstance(item["seq_idx"], torch.Tensor), "Seq_idx should be a torch.Tensor" + assert item["seq_idx"].item() == 0, "First item should have seq_idx 0" + + +def test_simple_fasta_dataset_write_idx_map(fasta_dataset: SimpleFastaDataset, tmp_path: Path) -> None: + """Test write_idx_map method of SimpleFastaDataset.""" + # Create output directory + output_dir = tmp_path / "output" + output_dir.mkdir(parents=True, exist_ok=True) + + # Write index map + fasta_dataset.write_idx_map(output_dir) + + # Check if file was created + idx_map_file = output_dir / "seq_idx_map.json" + assert idx_map_file.exists(), "seq_idx_map.json should be created" + + import json + with open(idx_map_file, 'r') as f: + idx_map = json.load(f) + + assert len(idx_map) == 10, "Index map should have an entry for each sequence" + for idx, seqid in enumerate(fasta_dataset.seqids): + assert idx_map[seqid] == idx, f"Index for {seqid} should match" From 0e13ad0420bd7dbf88546d3d753eb4c5ec058e28 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 19:45:40 +0000 Subject: [PATCH 122/140] Bump nemo commit with predict changes Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index 5afbbadf20..b7854dbeac 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit 5afbbadf20177410753eb5f241822198648818fc +Subproject commit b7854dbeac29db2d7112775f64225f26c2db2cc8 From bf0864907a48b08c2c8b693298b76686151f9b79 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 19:50:58 +0000 Subject: [PATCH 123/140] no longer needed since we do not have committed fastas Signed-off-by: John St John <jstjohn@nvidia.com> --- .secrets.baseline | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.secrets.baseline b/.secrets.baseline index d0c15aee89..c541d149be 100644 --- a/.secrets.baseline +++ b/.secrets.baseline @@ -128,7 +128,7 @@ { "path": "detect_secrets.filters.regex.should_exclude_file", "pattern": [ - "(.*\\.ipynb|.*\\.baseline|.*\\.fasta)$" + "(.*\\.ipynb|.*\\.baseline)$" ] } ], From 04914d2fa9f7b1e09e960dadb95343d6886dbce9 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 20:48:06 +0000 Subject: [PATCH 124/140] Reformat to pass pre-commit Signed-off-by: John St John <jstjohn@nvidia.com> --- .../src/bionemo/evo2/data/fasta_dataset.py | 5 +++- .../bionemo/evo2/data/test_fasta_dataset.py | 28 ++++++++++--------- 2 files changed, 19 insertions(+), 14 deletions(-) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py index 7b5181e0c7..6757f26375 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py @@ -18,10 +18,13 @@ import json -import torch from pathlib import Path + +import torch + from bionemo.noodles.nvfaidx import NvFaidx + class SimpleFastaDataset(torch.utils.data.Dataset): """A simple dataset for Evo2 prediction.""" diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py index 72458f2326..b18d011a61 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/data/test_fasta_dataset.py @@ -17,13 +17,14 @@ # limitations under the License. -import pytest from pathlib import Path -import torch -from bionemo.testing.data.fasta import create_fasta_file +import pytest +import torch from nemo.collections.nlp.modules.common.tokenizer_utils import get_nmt_tokenizer + from bionemo.evo2.data.fasta_dataset import SimpleFastaDataset +from bionemo.testing.data.fasta import create_fasta_file @pytest.fixture @@ -38,7 +39,7 @@ def test_simple_fasta_dataset_initialization(fasta_dataset: SimpleFastaDataset) """Test initialization of SimpleFastaDataset.""" # Check dataset length assert len(fasta_dataset) == 10, "Dataset length should match number of sequences" - + # Check seqids assert len(fasta_dataset.seqids) == 10, "Seqids should match number of sequences" @@ -47,19 +48,19 @@ def test_simple_fasta_dataset_getitem(fasta_dataset: SimpleFastaDataset) -> None """Test __getitem__ method of SimpleFastaDataset.""" # Test first item item = fasta_dataset[0] - + # Check keys expected_keys = {"tokens", "position_ids", "seq_idx", "loss_mask"} assert set(item.keys()) == expected_keys, "Item should have correct keys" - + # Check token type assert isinstance(item["tokens"], torch.Tensor), "Tokens should be a torch.Tensor" assert item["tokens"].dtype == torch.long, "Tokens should be long dtype" - + # Check position_ids assert isinstance(item["position_ids"], torch.Tensor), "Position IDs should be a torch.Tensor" assert item["position_ids"].dtype == torch.long, "Position IDs should be long dtype" - + # Validate sequence index assert isinstance(item["seq_idx"], torch.Tensor), "Seq_idx should be a torch.Tensor" assert item["seq_idx"].item() == 0, "First item should have seq_idx 0" @@ -70,18 +71,19 @@ def test_simple_fasta_dataset_write_idx_map(fasta_dataset: SimpleFastaDataset, t # Create output directory output_dir = tmp_path / "output" output_dir.mkdir(parents=True, exist_ok=True) - + # Write index map fasta_dataset.write_idx_map(output_dir) - + # Check if file was created idx_map_file = output_dir / "seq_idx_map.json" assert idx_map_file.exists(), "seq_idx_map.json should be created" - + import json - with open(idx_map_file, 'r') as f: + + with open(idx_map_file, "r") as f: idx_map = json.load(f) - + assert len(idx_map) == 10, "Index map should have an entry for each sequence" for idx, seqid in enumerate(fasta_dataset.seqids): assert idx_map[seqid] == idx, f"Index for {seqid} should match" From 48cab0ac370122aac3a1974ce4ddcd71d8ad7ce0 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Tue, 4 Mar 2025 14:46:20 -0800 Subject: [PATCH 125/140] update readme to mention predict (#717) Update README to mention predict functionality. I currently link to the not-yet-built docs - not sure if we want to change that or not --------- Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- sub-packages/bionemo-evo2/README.md | 35 +++++++++++++++++++ .../src/bionemo/evo2/data/fasta_dataset.py | 7 +++- 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 724de20f7e..4bef95392d 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -3,16 +3,19 @@ `bionemo-evo2` is a `pip`-installable package that contains **data preprocessing**, **training**, and **inferencing** code for Evo2, a new `Hyena`-based foundation model for genome generation and understanding. Built upon `Megatron-LM` parallelism and `NeMo2` algorithms, `bionemo-evo2` provides the remaining tools necessary to effectively fine-tune the pre-trained Evo2 model checkpoint on user-provided sequences at scale, and generate state-of-the-art life-like DNA sequences from Evo2 for downstream metagenomic tasks. ## Quickstart tutorials + Please see ## Installation To install this package, execute the following command: + ```bash pip install -e . ``` To run unit tests, execute the following command: + ```bash pytest -v . ``` @@ -161,7 +164,28 @@ As in `train_evo2`, `--ckpt-dir` points to the NeMo2 checkpoint directory for Ev [NeMo I 2025-01-06 17:22:22 infer:102] ['CTCTTCTGGTATTTGG'] ``` +## Prediction + +To run a forward pass of the Evo2 model, you can call `predict_evo2`, which processes a batch of sequences and returns either raw token logits or, if `--output-log-prob-seqs` is set, log-probability scores. + +For example, to predict the log-probability scores of a batch of sequences saved to `fasta_path`, you can run the following command: + +```bash +predict_evo2 \ + --fasta <fasta_path> \ + --ckpt-dir <PATH_TO_CHECKPOINT> \ + --output-dir <PATH_TO_OUTPUT_FILE> \ + --model-size 1b \ + --tensor-parallel-size 1 \ + ----pipeline-model-parallel-size 1 \ + --context-parallel-size 1 \ + --output-log-prob-seqs +``` + +An example of using `predict_evo2` for variant effect prediction can be found in our [Evo 2 Zeroshot BRCA1 Notebook](https://docs.nvidia.com/bionemo-framework/latest/user-guide/examples/bionemo-evo2/evo2_zeroshot_brca). This notebook demonstrates how to use Evo2 to predict whether single nucleotide variants (SNVs) in the BRCA1 gene are likely to be harmful to protein function and potentially increase cancer risk, by comparing the model's log probability scores between the reference and variant sequences. + ## Checkpoint conversion from hugging face to NeMo2 + The following conversion script should work on any savanna formatted arc evo2 checkpoint. Make sure you match up the model size with the checkpoint you are converting. The pyproject.toml makes the conversion script available as a command line tool `evo2_convert_to_nemo2`, so you @@ -173,6 +197,7 @@ evo2_convert_to_nemo2 \ ``` with the following if you want to run with `-m pdb` or something: + ```bash python \ sub-packages/bionemo-evo2/src/bionemo/evo2/utils/checkpoint/convert_to_nemo.py \ @@ -194,17 +219,20 @@ This new checkpoint `nemo2_evo2_1b_8k` is ready to go in nemo2 format in downstr If you want to register the checkpoint with NGC (typically only NVIDIA employees) then you can do the following. To create the checkpoint for distribution in NGC, first cd into the checkpiont directory: + ```bash cd nemo2_evo2_1b_8k ``` Then run the following command to make a tar of the full directory that gets unpacked into the current directory which our NGC loader expects: + ```bash tar -czvf ../nemo2_evo2_1b_8k.tar.gz . ``` Finally `sha256sum` the tar file to get the checksum: + ```bash sha256sum nemo2_evo2_1b_8k.tar.gz ``` @@ -213,24 +241,31 @@ Then register it into the loader for testing purposes by editing `sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml`. ### 7b-8k + ```bash evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_7b_base \ --model-size 7b --output-dir nemo2_evo2_7b_8k ``` + ### 7b-1M + ```bash evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_7b \ --model-size 7b_arc_longcontext --output-dir nemo2_evo2_7b_1m ``` + ### 40b-8k + ```bash evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_40b_base \ --model-size 40b --output-dir nemo2_evo2_40b_8k ``` + ### 40b-1M + ```bash evo2_convert_to_nemo2 \ --model-path hf://arcinstitute/savanna_evo2_40b \ diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py index 6757f26375..479bc185d4 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/data/fasta_dataset.py @@ -26,7 +26,12 @@ class SimpleFastaDataset(torch.utils.data.Dataset): - """A simple dataset for Evo2 prediction.""" + """A simple dataset for Evo2 prediction. + + Currently, this will not work for pre-training or fine-tuning, as that would require: + 1) including "labels" in the input and 2) offsetting/rolling either the labels or + input_ids to handle the off-by-one token prediction alignment. + """ def __init__(self, fasta_path: Path, tokenizer, prepend_bos: bool = True): """Initialize the dataset.""" From 1d19941af61dad8e3563dc10a53c1fbbe79f34a9 Mon Sep 17 00:00:00 2001 From: Jared Wilber <jwilber@nvidia.com> Date: Tue, 4 Mar 2025 14:52:47 -0800 Subject: [PATCH 126/140] Fix parallel short hyena operator test Signed-off-by: Jared Wilber <jwilber@nvidia.com> --- .../bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py index 71f237b885..5bf8f6cb8f 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py @@ -98,7 +98,7 @@ def test_initialization(self, operator: ParallelShortHyenaOperator): assert operator.pregate assert operator.postgate num_weights = sum([p.numel() for p in operator.parameters()]) - assert num_weights == 6048 + assert num_weights == 6912 def test_gpu_forward(self, operator: ParallelShortHyenaOperator): device = torch.device("cuda") From 14ef1eac0f516f6c0ec1f413f9c98aaea7b01628 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 23:10:58 +0000 Subject: [PATCH 127/140] Add slow tests for 7b Signed-off-by: John St John <jstjohn@nvidia.com> --- .../tests/bionemo/evo2/test_evo2.py | 81 +++++++++++++++++++ .../src/bionemo/testing/torch.py | 15 ++++ 2 files changed, 96 insertions(+) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index e12787c377..f260f74742 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -36,6 +36,7 @@ _munge_sharded_tensor_key_megatron_to_nemo2, ) from bionemo.testing.megatron_parallel_state_utils import distributed_model_parallel_state +from bionemo.testing.torch import check_fp8_support logger = logging.getLogger(__name__) @@ -94,7 +95,87 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): attention_mask = None outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) + is_fp8_supported, compute_capability, device_info = check_fp8_support(device.index) + if is_fp8_supported: + # Most rigurous assertion for output equivalence currently works on devices that are new enough to + # support FP8. + logger.info(f"Device {device_info} ({compute_capability}) supports FP8. Running most rigurous assertion.") + torch.testing.assert_close(outputs, gold_standard_no_fp8_tensor) + else: + logger.info( + f"Device {device_info} ({compute_capability}) does not support FP8. Running less rigurous assertions." + ) + top_2_logits_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=True, largest=True, k=2) + ambiguous_positions = ( + top_2_logits_golden.values[..., 0] - top_2_logits_golden.values[..., 1] + ).abs() < 9.9e-3 # hand tunes for observed diffs from A100 and H100 + n_ambiguous = ambiguous_positions.sum() + + assert n_ambiguous <= 19 + + our_char_indices = outputs.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy() + not_amb_positions = ~ambiguous_positions.flatten().cpu().numpy() + # Generate our string, removing the ambiguous positions. + our_generation_str = "".join([chr(idx) for idx in our_char_indices[not_amb_positions].tolist()]) + # Do the same to the golden values + gold_std_char_indices = ( + gold_standard_no_fp8_tensor.softmax(dim=-1).argmax(dim=-1).flatten().detach().cpu().numpy() + ) + # Make the string + gold_std_str = "".join([chr(idx) for idx in gold_std_char_indices[not_amb_positions].tolist()]) + + # Ensure the two strings are equal. + assert all(np.array(list(our_generation_str)) == np.array(list(gold_std_str))) + + # Verify that the top-4 from the logit vectors are the same. + # A: 65 + # C: 67 + # G: 71 + # T: 84 + # Find the corresponding ATGC and compare the two vectors with those four values. + # Ensures that the top 4 ascii characters of the output are ACGT. + top_4_inds = outputs.topk(dim=-1, sorted=False, largest=True, k=4) + assert set(top_4_inds.indices.flatten().cpu().numpy().tolist()).issubset((65, 67, 71, 84)) + output_vector = outputs[0, -1, top_4_inds.indices] + # Then its the top 4 indices of the gold standard tensor + top_4_inds_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=False, largest=True, k=4) + assert set(top_4_inds_golden.indices.flatten().cpu().numpy().tolist()).issubset((65, 67, 71, 84)) + gold_standard_no_fp8_vector = gold_standard_no_fp8_tensor[0, -1, top_4_inds_golden.indices] + + # Run cosine similarity between the two vectors. + logit_similarity = torch.nn.functional.cosine_similarity(output_vector, gold_standard_no_fp8_vector, dim=-1) + assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 9.9e-3 + + +@pytest.mark.slow +def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_192): + try: + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.0") / "weights" + gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") + except ValueError as e: + if e.args[0].endswith("does not have an NGC URL."): + raise ValueError( + "Please re-run test with `BIONEMO_DATA_SOURCE=pbss py.test ...`, " + "one or more files are missing from ngc." + ) + else: + raise e + with distributed_model_parallel_state(), torch.no_grad(): + hyena_config = llm.Hyena1bConfig(use_te=True, seq_length=seq_len) + tokenizer = get_nmt_tokenizer( + "byte-level", + ) + raw_megatron_model = hyena_config.configure_model(tokenizer).eval().cuda() + device = raw_megatron_model.parameters().__next__().device + load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "zarr") + model = Float16Module(hyena_config, raw_megatron_model) + input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAAT" + input_ids = torch.tensor(tokenizer.text_to_ids(input_seq)).int().unsqueeze(0).to(device) + position_ids = torch.arange(len(input_seq)).unsqueeze(0).to(device) + attention_mask = None + outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) + gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) top_2_logits_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=True, largest=True, k=2) ambiguous_positions = ( top_2_logits_golden.values[..., 0] - top_2_logits_golden.values[..., 1] diff --git a/sub-packages/bionemo-testing/src/bionemo/testing/torch.py b/sub-packages/bionemo-testing/src/bionemo/testing/torch.py index b722878d34..5db7d39713 100644 --- a/sub-packages/bionemo-testing/src/bionemo/testing/torch.py +++ b/sub-packages/bionemo-testing/src/bionemo/testing/torch.py @@ -18,6 +18,21 @@ import torch +def check_fp8_support(device_id: int = 0) -> tuple[bool, str, str]: + """Check if FP8 is supported on the current GPU. + + FP8 requires compute capability 8.9+ (Ada Lovelace/Hopper architecture or newer). + """ + if not torch.cuda.is_available(): + return False, "0.0", "CUDA not available" + device_props = torch.cuda.get_device_properties(device_id) + compute_capability = f"{device_props.major}.{device_props.minor}" + device_name = device_props.name + # FP8 is supported on compute capability 8.9+ (Ada Lovelace/Hopper architecture) + is_supported = (device_props.major > 8) or (device_props.major == 8 and device_props.minor >= 9) + return is_supported, compute_capability, f"Device: {device_name}, Compute Capability: {compute_capability}" + + def recursive_detach(x): """Detach all tensors in a nested structure.""" if isinstance(x, torch.Tensor): From 4f8343835ed35906531a61e8f7e92e6c7d4353cf Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 23:12:00 +0000 Subject: [PATCH 128/140] Update faster 1b test with lower precision so it passes in CI Signed-off-by: John St John <jstjohn@nvidia.com> --- .../tests/bionemo/evo2/test_evo2.py | 21 +++++++--- .../bionemo/evo2/test_hyena_operators.py | 42 +++++++++++++++++++ 2 files changed, 58 insertions(+), 5 deletions(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index f260f74742..22b53b6ef1 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -179,7 +179,7 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 top_2_logits_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=True, largest=True, k=2) ambiguous_positions = ( top_2_logits_golden.values[..., 0] - top_2_logits_golden.values[..., 1] - ).abs() < 9.9e-3 # hand tunes for observed diffs from A100 and H100 + ).abs() < 9.9e-3 # hand tunes for observed diffs from A100 and H100 with 7b model n_ambiguous = ambiguous_positions.sum() assert n_ambiguous <= 19 @@ -194,9 +194,20 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 ) # Make the string gold_std_str = "".join([chr(idx) for idx in gold_std_char_indices[not_amb_positions].tolist()]) - - # Ensure the two strings are equal. - assert all(np.array(list(our_generation_str)) == np.array(list(gold_std_str))) + array_eq = np.array(list(our_generation_str)) == np.array(list(gold_std_str)) + # Ensure the two strings are approximately equal. + if array_eq.mean() < 0.95: + array_eq = np.array(list(our_generation_str)) == np.array(list(gold_std_str)) + mismatch_positions = np.arange(outputs.shape[1])[not_amb_positions][~array_eq] + err_str = f"Fraction of expected mismatch positions exceeds 5%: {(~array_eq).mean()}" + err_str += f"Mismatch positions: {mismatch_positions}" + err_str += f"Fraction of unexpected mismatch positions: {(~array_eq).mean()}" + top_two_logits_at_mismatch = top_2_logits_golden.values[0, mismatch_positions] + top_2_logits_pred = outputs.topk(dim=-1, sorted=True, largest=True, k=2) + top_two_pred_logits_at_mismatch = top_2_logits_pred.values[0, mismatch_positions] + err_str += f"Top two logits at mismatch positions: {top_two_logits_at_mismatch}" + err_str += f"Top two pred logits at mismatch positions: {top_two_pred_logits_at_mismatch}" + raise AssertionError(err_str) # Verify that the top-4 from the logit vectors are the same. # A: 65 @@ -216,4 +227,4 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 # Run cosine similarity between the two vectors. logit_similarity = torch.nn.functional.cosine_similarity(output_vector, gold_standard_no_fp8_vector, dim=-1) - assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 9.9e-3 + assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 0.03 diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py index 71f237b885..e40a1e2bf7 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py @@ -91,6 +91,7 @@ def operator(self, transformer_config: TransformerConfig, hyena_config: HyenaCon use_fast_causal_conv=False, is_mlp=False, local_init=False, + use_conv_bias=False, ) def test_initialization(self, operator: ParallelShortHyenaOperator): @@ -118,6 +119,47 @@ def test_gpu_forward(self, operator: ParallelShortHyenaOperator): assert output.shape[2] == operator.hidden_size +class TestParallelShortHyenaOperatorWithConvBias: + @pytest.fixture + def operator(self, transformer_config: TransformerConfig, hyena_config: HyenaConfig) -> ParallelShortHyenaOperator: + with megatron_parallel_state_utils.distributed_model_parallel_state(): + yield ParallelShortHyenaOperator( + hidden_size=transformer_config.hidden_size, + transformer_config=transformer_config, + hyena_config=hyena_config, + init_method="small_init", + short_conv_class=ParallelCausalDepthwiseConv1d, + use_fast_causal_conv=False, + is_mlp=False, + local_init=False, + use_conv_bias=True, + ) + + def test_initialization(self, operator: ParallelShortHyenaOperator): + assert operator.hidden_size == 864 + assert operator.pregate + assert operator.postgate + num_weights = sum([p.numel() for p in operator.parameters()]) + assert num_weights == 6912 + + def test_gpu_forward(self, operator: ParallelShortHyenaOperator): + device = torch.device("cuda") + operator = operator.to(device) + batch_size = 2 + seq_len = 1024 + g = operator.num_groups + dg = operator.group_dim + + x1 = torch.ones((batch_size, seq_len, g, dg), device=device) + x2 = torch.ones((batch_size, seq_len, g, dg), device=device) + v = torch.ones((batch_size, seq_len, g, dg), device=device) + + output = operator(x1, x2, v) + assert output.shape[0] == batch_size + assert output.shape[1] == seq_len + assert output.shape[2] == operator.hidden_size + + class TestParallelCausalDepthwiseConv1d: @pytest.fixture def operator( From 25fefc8584ecb80f144e08761e7140dc26217e7e Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 23:13:05 +0000 Subject: [PATCH 129/140] Address formatting issues Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py index c668d02a11..3bcbb4fe1e 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py @@ -99,7 +99,7 @@ def test_initialization(self, operator: ParallelShortHyenaOperator): assert operator.pregate assert operator.postgate num_weights = sum([p.numel() for p in operator.parameters()]) - assert num_weights == 6912 + assert num_weights == 6912 def test_gpu_forward(self, operator: ParallelShortHyenaOperator): device = torch.device("cuda") From e34c44dacdad89a8aefe8ee13d6f09b395f0c5be Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 23:24:52 +0000 Subject: [PATCH 130/140] Leave megatron-lm as is and add more stringent slow test along with less stringent fast test Signed-off-by: John St John <jstjohn@nvidia.com> --- .gitignore | 1 - .../tests/bionemo/evo2/test_evo2.py | 60 +++++++++---------- 2 files changed, 30 insertions(+), 31 deletions(-) diff --git a/.gitignore b/.gitignore index 9b65a94695..5fe5a0ab48 100644 --- a/.gitignore +++ b/.gitignore @@ -187,7 +187,6 @@ dist/ coverage.xml # Jupyter Notebook -notebooks/ .ipynb_checkpoints # System files diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index 22b53b6ef1..d5de7e2ed0 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -95,16 +95,6 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): attention_mask = None outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) - is_fp8_supported, compute_capability, device_info = check_fp8_support(device.index) - if is_fp8_supported: - # Most rigurous assertion for output equivalence currently works on devices that are new enough to - # support FP8. - logger.info(f"Device {device_info} ({compute_capability}) supports FP8. Running most rigurous assertion.") - torch.testing.assert_close(outputs, gold_standard_no_fp8_tensor) - else: - logger.info( - f"Device {device_info} ({compute_capability}) does not support FP8. Running less rigurous assertions." - ) top_2_logits_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=True, largest=True, k=2) ambiguous_positions = ( top_2_logits_golden.values[..., 0] - top_2_logits_golden.values[..., 1] @@ -123,9 +113,20 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): ) # Make the string gold_std_str = "".join([chr(idx) for idx in gold_std_char_indices[not_amb_positions].tolist()]) - - # Ensure the two strings are equal. - assert all(np.array(list(our_generation_str)) == np.array(list(gold_std_str))) + array_eq = np.array(list(our_generation_str)) == np.array(list(gold_std_str)) + # Ensure the two strings are approximately equal. + if array_eq.mean() < 0.95: + array_eq = np.array(list(our_generation_str)) == np.array(list(gold_std_str)) + mismatch_positions = np.arange(outputs.shape[1])[not_amb_positions][~array_eq] + err_str = f"Fraction of expected mismatch positions exceeds 5%: {(~array_eq).mean()}" + err_str += f"Mismatch positions: {mismatch_positions}" + err_str += f"Fraction of unexpected mismatch positions: {(~array_eq).mean()}" + top_two_logits_at_mismatch = top_2_logits_golden.values[0, mismatch_positions] + top_2_logits_pred = outputs.topk(dim=-1, sorted=True, largest=True, k=2) + top_two_pred_logits_at_mismatch = top_2_logits_pred.values[0, mismatch_positions] + err_str += f"Top two logits at mismatch positions: {top_two_logits_at_mismatch}" + err_str += f"Top two pred logits at mismatch positions: {top_two_pred_logits_at_mismatch}" + raise AssertionError(err_str) # Verify that the top-4 from the logit vectors are the same. # A: 65 @@ -145,7 +146,7 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): # Run cosine similarity between the two vectors. logit_similarity = torch.nn.functional.cosine_similarity(output_vector, gold_standard_no_fp8_vector, dim=-1) - assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 9.9e-3 + assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 0.03 @pytest.mark.slow @@ -162,7 +163,7 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 else: raise e with distributed_model_parallel_state(), torch.no_grad(): - hyena_config = llm.Hyena1bConfig(use_te=True, seq_length=seq_len) + hyena_config = llm.Hyena7bConfig(use_te=True, seq_length=seq_len) tokenizer = get_nmt_tokenizer( "byte-level", ) @@ -176,6 +177,16 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 attention_mask = None outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) + is_fp8_supported, compute_capability, device_info = check_fp8_support(device.index) + if is_fp8_supported: + # Most rigurous assertion for output equivalence currently works on devices that are new enough to + # support FP8. + logger.info(f"Device {device_info} ({compute_capability}) supports FP8. Running most rigurous assertion.") + torch.testing.assert_close(outputs, gold_standard_no_fp8_tensor) + else: + logger.info( + f"Device {device_info} ({compute_capability}) does not support FP8. Running less rigurous assertions." + ) top_2_logits_golden = gold_standard_no_fp8_tensor.topk(dim=-1, sorted=True, largest=True, k=2) ambiguous_positions = ( top_2_logits_golden.values[..., 0] - top_2_logits_golden.values[..., 1] @@ -194,20 +205,9 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 ) # Make the string gold_std_str = "".join([chr(idx) for idx in gold_std_char_indices[not_amb_positions].tolist()]) - array_eq = np.array(list(our_generation_str)) == np.array(list(gold_std_str)) - # Ensure the two strings are approximately equal. - if array_eq.mean() < 0.95: - array_eq = np.array(list(our_generation_str)) == np.array(list(gold_std_str)) - mismatch_positions = np.arange(outputs.shape[1])[not_amb_positions][~array_eq] - err_str = f"Fraction of expected mismatch positions exceeds 5%: {(~array_eq).mean()}" - err_str += f"Mismatch positions: {mismatch_positions}" - err_str += f"Fraction of unexpected mismatch positions: {(~array_eq).mean()}" - top_two_logits_at_mismatch = top_2_logits_golden.values[0, mismatch_positions] - top_2_logits_pred = outputs.topk(dim=-1, sorted=True, largest=True, k=2) - top_two_pred_logits_at_mismatch = top_2_logits_pred.values[0, mismatch_positions] - err_str += f"Top two logits at mismatch positions: {top_two_logits_at_mismatch}" - err_str += f"Top two pred logits at mismatch positions: {top_two_pred_logits_at_mismatch}" - raise AssertionError(err_str) + + # Ensure the two strings are equal. + assert all(np.array(list(our_generation_str)) == np.array(list(gold_std_str))) # Verify that the top-4 from the logit vectors are the same. # A: 65 @@ -227,4 +227,4 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 # Run cosine similarity between the two vectors. logit_similarity = torch.nn.functional.cosine_similarity(output_vector, gold_standard_no_fp8_vector, dim=-1) - assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 0.03 + assert torch.mean(torch.abs(logit_similarity - torch.ones_like(logit_similarity))) < 9.9e-3 From 51a8c7a54ca7595fb3ac64cbbcaa868a2911effb Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Tue, 4 Mar 2025 23:25:22 +0000 Subject: [PATCH 131/140] Bump nemo as well Signed-off-by: John St John <jstjohn@nvidia.com> --- 3rdparty/NeMo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdparty/NeMo b/3rdparty/NeMo index b7854dbeac..0366d9d411 160000 --- a/3rdparty/NeMo +++ b/3rdparty/NeMo @@ -1 +1 @@ -Subproject commit b7854dbeac29db2d7112775f64225f26c2db2cc8 +Subproject commit 0366d9d41188a10d1c47382f35407250f9a9031a From 32048697445e6daec5e8abe8a6349cf128057219 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 00:09:29 +0000 Subject: [PATCH 132/140] Update pointer to evo2 test file Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index d5de7e2ed0..1ca0d9b2ee 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -152,7 +152,7 @@ def test_golden_values_top_k_logits_and_cosine_similarity(seq_len: int): @pytest.mark.slow def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_192): try: - evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k-zarr:1.0") / "weights" + evo2_7b_checkpoint_weights: Path = load("evo2/7b-8k:1.0") / "weights" gold_standard_no_fp8 = load("evo2/7b-8k-nofp8-te-goldvalue-testdata:1.0") except ValueError as e: if e.args[0].endswith("does not have an NGC URL."): @@ -169,7 +169,7 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 ) raw_megatron_model = hyena_config.configure_model(tokenizer).eval().cuda() device = raw_megatron_model.parameters().__next__().device - load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "zarr") + load_weights_sharded_inplace_nemo2_to_mcore(raw_megatron_model, evo2_7b_checkpoint_weights, {}, "torch_dist") model = Float16Module(hyena_config, raw_megatron_model) input_seq = "GAAATTAGCGCGTCCGGAATGATACGAGGGGAAACGAAATTTTGAATTAATGGAGAAAAAAGACGAGAAACCTTAAGCAAAAAAATTTTAGCTTCGAATATTTATTAATTTCTGAGATGTTGTTAAACGATTTTCGATTCCAAGTTGTGCGCACGAACGTTATTGCAAATAAATGCTGCTTATTCGGATGTTTCCACGATCTTTGTTGCAATGGTAGTCGAGTACCCGATAACCCAATTTCGTTACATCGGCCTATCTGTAGAATATCCAATCTATGGTTCATAAAAAATCTGATCGTTTGTTTTTAAGAAATTAAACGCGTTAAATTGAACGAATTTCGAATACCGGTCTTAGCGAAGGACCTCCCCTCTTGCTTGCGTATTGCCCCGCGAAATTTCTTTTCGGCGATGAACGATACAAAAAATTCTATCGAATGTTACTTCTATTCTCTGCCTCGTCTATGACTTGGAGATTGGTCTATGTCGTTCGTTTTCTCGCGAGTTTCCAATATGTCCGTAGTATGTGAACGCTGGTATTCGTGAAGATAAATTATTGTTTTTACAATTTCTTTCAAAAATATATAATTTTAATTTATATAAT" input_ids = torch.tensor(tokenizer.text_to_ids(input_seq)).int().unsqueeze(0).to(device) From 70b266c44736537fbe76617b8d0f6e22f699faed Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 00:25:17 +0000 Subject: [PATCH 133/140] only run most stringent comparison with h100 Signed-off-by: John St John <jstjohn@nvidia.com> --- sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py index 1ca0d9b2ee..28a8e7f182 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_evo2.py @@ -178,10 +178,13 @@ def test_golden_values_top_k_logits_and_cosine_similarity_7b(seq_len: int = 8_19 outputs = model(input_ids=input_ids, position_ids=position_ids, attention_mask=attention_mask) gold_standard_no_fp8_tensor = torch.load(gold_standard_no_fp8).to(device=outputs.device, dtype=outputs.dtype) is_fp8_supported, compute_capability, device_info = check_fp8_support(device.index) - if is_fp8_supported: + if is_fp8_supported and compute_capability == "9.0": # Most rigurous assertion for output equivalence currently works on devices that are new enough to # support FP8. - logger.info(f"Device {device_info} ({compute_capability}) supports FP8. Running most rigurous assertion.") + logger.info( + f"Device {device_info} ({compute_capability}) supports FP8 with 9.0 compute capability, the " + "same configuration as the gold standard was generated with. Running most rigurous assertion." + ) torch.testing.assert_close(outputs, gold_standard_no_fp8_tensor) else: logger.info( From 9c7e3f73279f35d6466fb75c96970a7231bd5931 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 00:31:08 +0000 Subject: [PATCH 134/140] add missing ngc link for new 7b-8k checkpoint Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-core/src/bionemo/core/data/resources/evo2.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml index 5b72330f08..1d2e5a4278 100644 --- a/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml +++ b/sub-packages/bionemo-core/src/bionemo/core/data/resources/evo2.yaml @@ -9,7 +9,7 @@ - tag: 7b-8k:1.0 - ngc: null + ngc: nvidia/clara/evo2-7b-8k-nemo2:1.0 ngc_registry: model pbss: "s3://bionemo-ci/models/nemo2_evo2_7b_8k.tar.gz" sha256: 78fc05536e1a9bd2febacea079a4beedf93ddcba1c69ac24690a5f7b649a0655 # pragma: allowlist secret From 01f8f05a6eb74f688521da06390b0bbd7d8635f1 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 01:01:44 +0000 Subject: [PATCH 135/140] Fixing sahpe issue in parallel short hyena test Signed-off-by: John St John <jstjohn@nvidia.com> --- .../bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py index 3bcbb4fe1e..e40a1e2bf7 100644 --- a/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py +++ b/sub-packages/bionemo-evo2/tests/bionemo/evo2/test_hyena_operators.py @@ -99,7 +99,7 @@ def test_initialization(self, operator: ParallelShortHyenaOperator): assert operator.pregate assert operator.postgate num_weights = sum([p.numel() for p in operator.parameters()]) - assert num_weights == 6912 + assert num_weights == 6048 def test_gpu_forward(self, operator: ParallelShortHyenaOperator): device = torch.device("cuda") From 88f2c486da596b54e3349806513c7e678c03502b Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 02:56:59 +0000 Subject: [PATCH 136/140] Address issue with pycache when there are tests with the same name in different submodules Signed-off-by: John St John <jstjohn@nvidia.com> --- ci/scripts/run_pytest.sh | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 55625c2b94..22309869eb 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -94,12 +94,21 @@ fi echo "Test directories: ${TEST_DIRS[*]}" +pyclean() { + # Use the provided base directory or default to current directory + local base_dir="${1:-.}" + echo "Cleaning Python cache files in $base_dir..." + find "$base_dir" -regex '^.*\(__pycache__\|\.py[co]\)$' -delete +} + # Run tests with coverage for dir in "${TEST_DIRS[@]}"; do echo "Running pytest in $dir" if ! pytest "${PYTEST_OPTIONS[@]}" --junitxml=$(basename $dir).junit.xml -o junit_family=legacy "$dir"; then error=true fi + # Avoid duplicated pytest cache filenames. + pyclean "$dir" done # Exit with appropriate status From 825879d9df49bf94d69f2bf7b3dc93215e7f5648 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 04:30:39 +0000 Subject: [PATCH 137/140] Move to per-package tests for slow as well as fast tests Signed-off-by: John St John <jstjohn@nvidia.com> --- .github/workflows/unit-tests.yml | 2 +- ci/scripts/run_pytest.sh | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 5e3bb91746..e94e3315fe 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -137,7 +137,7 @@ jobs: (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'INCLUDE_SLOW_TESTS')) env: BIONEMO_DATA_SOURCE: ngc - run: pytest -v -m "slow" sub-packages/ + run: ./ci/scripts/run_pytest.sh --no-nbval --only-slow - name: Run notebook tests if: | diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 22309869eb..6f12f7048d 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -50,6 +50,7 @@ declare -a coverage_files SKIP_DOCS=false NO_NBVAL=false SKIP_SLOW=false +ONLY_SLOW=false error=false # Parse command line arguments @@ -58,6 +59,7 @@ while (( $# > 0 )); do --skip-docs) SKIP_DOCS=true ;; --no-nbval) NO_NBVAL=true ;; --skip-slow) SKIP_SLOW=true ;; + --only-slow) ONLY_SLOW=true ;; -h|--help) usage ;; *) echo "Unknown option: $1" >&2; usage 1 ;; esac @@ -85,6 +87,7 @@ PYTEST_OPTIONS=( ) [[ "$NO_NBVAL" != true ]] && PYTEST_OPTIONS+=(--nbval-lax) [[ "$SKIP_SLOW" == true ]] && PYTEST_OPTIONS+=(-m "not slow") +[[ "$ONLY_SLOW" == true ]] && PYTEST_OPTIONS+=(-m "slow") # Define test directories TEST_DIRS=(./sub-packages/bionemo-*/) From 66d99f88a0b956e490bc101bd1d81558ed6966a6 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 06:57:53 +0000 Subject: [PATCH 138/140] Handle no tests found case Signed-off-by: John St John <jstjohn@nvidia.com> --- ci/scripts/run_pytest.sh | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index 6f12f7048d..f9f87a87e8 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -28,6 +28,8 @@ Options: --skip-docs Skip running tests in the docs directory --no-nbval Skip jupyter notebook validation tests --skip-slow Skip tests marked as slow (@pytest.mark.slow) + --only-slow Only run tests marked as slow (@pytest.mark.slow) + --allow-no-tests Allow sub-packages with no found tests (for example no slow tests if --only-slow is set) Note: Documentation tests (docs/) are only run when notebook validation is enabled (--no-nbval not set) and docs are not skipped @@ -51,6 +53,7 @@ SKIP_DOCS=false NO_NBVAL=false SKIP_SLOW=false ONLY_SLOW=false +ALLOW_NO_TESTS=false error=false # Parse command line arguments @@ -60,6 +63,7 @@ while (( $# > 0 )); do --no-nbval) NO_NBVAL=true ;; --skip-slow) SKIP_SLOW=true ;; --only-slow) ONLY_SLOW=true ;; + --allow-no-tests) ALLOW_NO_TESTS=true ;; -h|--help) usage ;; *) echo "Unknown option: $1" >&2; usage 1 ;; esac @@ -108,7 +112,15 @@ pyclean() { for dir in "${TEST_DIRS[@]}"; do echo "Running pytest in $dir" if ! pytest "${PYTEST_OPTIONS[@]}" --junitxml=$(basename $dir).junit.xml -o junit_family=legacy "$dir"; then - error=true + exit_code=$? # get error code + if [[ "$ALLOW_NO_TESTS" == true && $exit_code -eq 5 ]]; then + # Exit code 5 means no tests found, which is allowed if --allow-no-tests is set + echo "No tests found in $dir" + continue + else + echo "Error: pytest failed with exit code $exit_code" + error=true + fi fi # Avoid duplicated pytest cache filenames. pyclean "$dir" From a6b2a4af03933e7298048507c00e4f10a08053b8 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 07:19:35 +0000 Subject: [PATCH 139/140] Add option for allowing no slow tests for a submodule Signed-off-by: John St John <jstjohn@nvidia.com> --- .github/workflows/unit-tests.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index e94e3315fe..38254014c4 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -137,7 +137,9 @@ jobs: (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'INCLUDE_SLOW_TESTS')) env: BIONEMO_DATA_SOURCE: ngc - run: ./ci/scripts/run_pytest.sh --no-nbval --only-slow + # Not every sub-package has slow tests, and since some sub-packages have tests under the same name we need + # to run package by package like we do with the fast tests. + run: ./ci/scripts/run_pytest.sh --no-nbval --only-slow --allow-no-tests - name: Run notebook tests if: | From 70bfee4221e31508145c26a90b09891b04a29536 Mon Sep 17 00:00:00 2001 From: John St John <jstjohn@nvidia.com> Date: Wed, 5 Mar 2025 15:06:39 +0000 Subject: [PATCH 140/140] Handle exit code capturing within the context of a pipefail script properly Signed-off-by: John St John <jstjohn@nvidia.com> --- ci/scripts/run_pytest.sh | 15 +- .../examples/bionemo-evo2/.gitignore | 2 +- sub-packages/bionemo-evo2/README.md | 151 +++++++++++++----- .../src/bionemo/evo2/run/train.py | 3 - 4 files changed, 124 insertions(+), 47 deletions(-) diff --git a/ci/scripts/run_pytest.sh b/ci/scripts/run_pytest.sh index f9f87a87e8..e748c646f7 100755 --- a/ci/scripts/run_pytest.sh +++ b/ci/scripts/run_pytest.sh @@ -101,7 +101,7 @@ fi echo "Test directories: ${TEST_DIRS[*]}" -pyclean() { +clean_pycache() { # Use the provided base directory or default to current directory local base_dir="${1:-.}" echo "Cleaning Python cache files in $base_dir..." @@ -111,19 +111,22 @@ pyclean() { # Run tests with coverage for dir in "${TEST_DIRS[@]}"; do echo "Running pytest in $dir" - if ! pytest "${PYTEST_OPTIONS[@]}" --junitxml=$(basename $dir).junit.xml -o junit_family=legacy "$dir"; then - exit_code=$? # get error code + # Run pytest but don't exit on failure - we'll handle the exit code separately. This is needed because our script is + # running in pipefail mode and pytest will exit with a non-zero exit code if it finds no tests. + { pytest "${PYTEST_OPTIONS[@]}" --junitxml=$(basename $dir).junit.xml -o junit_family=legacy "$dir"; exit_code=$?; } || true + + if [[ $exit_code -ne 0 ]]; then if [[ "$ALLOW_NO_TESTS" == true && $exit_code -eq 5 ]]; then # Exit code 5 means no tests found, which is allowed if --allow-no-tests is set - echo "No tests found in $dir" - continue + echo "No tests found in $dir (exit code $exit_code) - continuing as --allow-no-tests is set" else echo "Error: pytest failed with exit code $exit_code" error=true fi fi + # Avoid duplicated pytest cache filenames. - pyclean "$dir" + clean_pycache "$dir" done # Exit with appropriate status diff --git a/docs/docs/user-guide/examples/bionemo-evo2/.gitignore b/docs/docs/user-guide/examples/bionemo-evo2/.gitignore index 465fe23294..055a26eb49 100644 --- a/docs/docs/user-guide/examples/bionemo-evo2/.gitignore +++ b/docs/docs/user-guide/examples/bionemo-evo2/.gitignore @@ -6,7 +6,7 @@ # config files *.yaml -# directories +# directories created during these notebook runs. nemo2_evo2_1b_8k/ preprocessed_data/ pretraining_demo/ diff --git a/sub-packages/bionemo-evo2/README.md b/sub-packages/bionemo-evo2/README.md index 4bef95392d..2fa307a46b 100644 --- a/sub-packages/bionemo-evo2/README.md +++ b/sub-packages/bionemo-evo2/README.md @@ -34,72 +34,149 @@ Given a preprocessed collection of preprocessed datasets, and optionally a pre-t ```bash $ train_evo2 --help -usage: train_evo2 [-h] -d DATASET_CONFIG [--num-nodes NUM_NODES] [--devices DEVICES] [--seq-length SEQ_LENGTH] [--tensor-parallel-size TENSOR_PARALLEL_SIZE] [--pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE] [--context-parallel-size CONTEXT_PARALLEL_SIZE] [--wandb-project WANDB_PROJECT] [--wandb-run-id WANDB_RUN_ID] - [--sequence-parallel] [--fp8] [--micro-batch-size MICRO_BATCH_SIZE] [--global-batch-size GLOBAL_BATCH_SIZE] [--grad-acc-batches GRAD_ACC_BATCHES] [--max-steps MAX_STEPS] [--val-check-interval VAL_CHECK_INTERVAL] [--grad-reduce-in-fp32] [--no-aligned-megatron-ddp] [--use-megatron-comm-overlap-llama3-8k] [--align-param-gather] [--straggler-detection] [--model-size {7b,40b,test}] [--experiment-dir EXPERIMENT_DIR] [--limit-val-batches LIMIT_VAL_BATCHES] [--ckpt-dir CKPT_DIR] [--restore-optimizer-from-ckpt] [--seed SEED] [--workers WORKERS] [--gc-interval GC_INTERVAL] [--enable-preemption] [--ckpt-async-save] [--nsys-profiling] [--nsys-start-step NSYS_START_STEP] [--nsys-end-step NSYS_END_STEP] [--nsys-ranks NSYS_RANKS [NSYS_RANKS ...]] +usage: train_evo2 [-h] (-d DATASET_CONFIG | --mock-data) [--dataset-dir DATASET_DIR] [--num-nodes NUM_NODES] [--devices DEVICES] [--seq-length SEQ_LENGTH] + [--tensor-parallel-size TENSOR_PARALLEL_SIZE] [--pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE] [--context-parallel-size CONTEXT_PARALLEL_SIZE] + [--no-wandb] [--wandb-project WANDB_PROJECT] [--wandb-run-id WANDB_RUN_ID] [--wandb-group WANDB_GROUP] [--wandb-job-type WANDB_JOB_TYPE] [--wandb-offline] + [--wandb-anonymous] [--sequence-parallel] [--fp8] [--micro-batch-size MICRO_BATCH_SIZE] [--global-batch-size GLOBAL_BATCH_SIZE] + [--grad-acc-batches GRAD_ACC_BATCHES] [--max-steps MAX_STEPS] [--val-check-interval VAL_CHECK_INTERVAL] [--grad-reduce-in-fp32] [--fp8-wgrad] + [--use-megatron-comm-overlap-llama3-8k] [--tp-comm-overlap-backend {nccl,mpi,gloo}] [--align-param-gather] + [--model-size {1b,1b_nv,40b,40b_arc_longcontext,40b_nv,7b,7b_arc_longcontext,7b_nv,test,test_nv}] [--add-bias-output] --experiment-dir EXPERIMENT_DIR + [--limit-val-batches LIMIT_VAL_BATCHES] [--log-every-n-steps LOG_EVERY_N_STEPS] [--ckpt-dir CKPT_DIR] [--wd WD] [--restore-optimizer-from-ckpt] + [--no-average-in-collective] [--seed SEED] [--workers WORKERS] [--gc-interval GC_INTERVAL] [--enable-preemption] [--ckpt-async-save] + [--ckpt-format {torch_dist,zarr}] [--eod-pad-in-loss-mask] [--cross-entropy-loss-fusion] [--no-fp32-residual-connection] + [--debug-ddp-parity-freq DEBUG_DDP_PARITY_FREQ] [--hybrid-override-pattern HYBRID_OVERRIDE_PATTERN] [--num-layers NUM_LAYERS] [--tflops-callback] + [--log-parameters-and-shapes] [--lr LR] [--min-lr MIN_LR] [--warmup-steps WARMUP_STEPS] [--nsys-profiling] [--nsys-start-step NSYS_START_STEP] + [--nsys-end-step NSYS_END_STEP] [--no-renormalize-loss] [--nsys-ranks NSYS_RANKS [NSYS_RANKS ...]] + [--activation-checkpoint-recompute-num-layers ACTIVATION_CHECKPOINT_RECOMPUTE_NUM_LAYERS] [--disable-checkpointing] [--clip-grad CLIP_GRAD] + [--seq-len-interpolation-factor SEQ_LEN_INTERPOLATION_FACTOR] [--overlap-param-gather] [--overlap-grad-reduce] [--hidden-dropout HIDDEN_DROPOUT] + [--attention-dropout ATTENTION_DROPOUT] [--no-activation-checkpointing | --selective-activation-checkpointing] Train a Hyena model using NeMo 2.0. options: -h, --help show this help message and exit -d DATASET_CONFIG, --dataset-config DATASET_CONFIG - Path to the blended / weighted training dataset configuration YAML. + Path to the blended / weighted training dataset configuration YAML. (default: None) + --mock-data Train with Mock data (for testing/debugging), either set this or provide a dataset config. (default: False) + --dataset-dir DATASET_DIR + Absolute path to the dataset directory. Defaults to using the absolute or relative paths (dataset_prefix) specified in the dataset config YAML. + (default: None) --num-nodes NUM_NODES - Number of nodes to use for training, defaults to 1. - --devices DEVICES Number of devices to use for training, defaults to 1. + Number of nodes to use for training, defaults to 1. (default: 1) + --devices DEVICES Number of devices to use for training, defaults to 1. (default: 1) --seq-length SEQ_LENGTH - Training sequence length + Training sequence length (default: 8192) --tensor-parallel-size TENSOR_PARALLEL_SIZE - Order of tensor parallelism. Defaults to 1. + Order of tensor parallelism. Defaults to 1. (default: 1) --pipeline-model-parallel-size PIPELINE_MODEL_PARALLEL_SIZE - Order of pipeline parallelism. Defaults to 1. + Order of pipeline parallelism. Defaults to 1. (default: 1) --context-parallel-size CONTEXT_PARALLEL_SIZE - Order of context parallelism. Defaults to 1. + Order of context parallelism. Defaults to 1. (default: 1) + --no-wandb Disable Wandb logging (default: False) --wandb-project WANDB_PROJECT - Wandb project name + Wandb project name (default: bionemo_evo2) --wandb-run-id WANDB_RUN_ID - Wandb run identifier - --sequence-parallel Set to enable sequence parallelism. - --fp8 Set to enable FP8 + Wandb run identifier (default: None) + --wandb-group WANDB_GROUP + A unique string shared by all runs in a given group (default: None) + --wandb-job-type WANDB_JOB_TYPE + A unique string representing a type of run, which is useful when you're grouping runs together into larger experiments using group. (default: None) + --wandb-offline Use wandb in offline mode (default: False) + --wandb-anonymous Enable or explicitly disable anonymous logging (default: False) + --sequence-parallel Set to enable sequence parallelism. (default: False) + --fp8 Set to enable FP8 (default: False) --micro-batch-size MICRO_BATCH_SIZE - Micro-batch size for data-parallel training. + Micro-batch size for data-parallel training. (default: 1) --global-batch-size GLOBAL_BATCH_SIZE - Global batch size for training. If set to None, infer it from the TP, CP, and PP parameters. + Global batch size for training. If set to None, infer it from the TP, CP, and PP parameters. (default: None) --grad-acc-batches GRAD_ACC_BATCHES - Number of batches to accumulate gradients over. + Number of batches to accumulate gradients over. (default: 1) --max-steps MAX_STEPS - Number of training optimizer update steps. + Number of training optimizer update steps. (default: None) --val-check-interval VAL_CHECK_INTERVAL - Number of steps between validation measurements and model checkpoints. + Number of steps between validation measurements and model checkpoints. (default: None) --grad-reduce-in-fp32 - Gradient reduce in FP32. - --no-aligned-megatron-ddp - Do not do aligned gradient updates etc. + Gradient reduce in FP32. (default: False) + --fp8-wgrad Faster option that is maybe less accurate (TBD) when using fp8. (default: False) --use-megatron-comm-overlap-llama3-8k + --tp-comm-overlap-backend {nccl,mpi,gloo} + TP communication backend to use. Defaults to 'nccl'. (default: nccl) --align-param-gather - --straggler-detection - --model-size {7b,40b,test} - Model size, choose between 7b, 40b, or test (4 layers, less than 1b). + --model-size {1b,1b_nv,40b,40b_arc_longcontext,40b_nv,7b,7b_arc_longcontext,7b_nv,test,test_nv} + Model architecture to use, choose between 7b, 40b, or test (a sub-model of 4 layers, less than 1B parameters). '_arc_1m' models have GLU / FFN + dimensions that support 1M context length when trained with TP<=8. (default: 7b) + --add-bias-output Add bias to the output layer to enable learning a simple prior. (default: False) --experiment-dir EXPERIMENT_DIR - Directory to write model checkpoints and results to. + Directory to write model checkpoints and results to. (default: None) --limit-val-batches LIMIT_VAL_BATCHES - Number of validation steps - --ckpt-dir CKPT_DIR Directory to restore an initial checkpoint from. Use this for supervised fine-tuning. + Number of validation steps (default: 20) + --log-every-n-steps LOG_EVERY_N_STEPS + Number of steps between logging. (default: 1) + --ckpt-dir CKPT_DIR Directory to restore an initial checkpoint from. Use this for supervised fine-tuning. (default: None) + --wd WD Weight decay for optimizer. (default: 0.01) --restore-optimizer-from-ckpt - Restore optimizer state from initial checkpoint. Defaults to False. - --seed SEED Set random seed for training. - --workers WORKERS Number of workers to use for data loading. + Restore optimizer state from initial checkpoint. Defaults to False. (default: False) + --no-average-in-collective + Avaerage optimizer state in collective rather than dividing by dp size and summing. (default: False) + --seed SEED Set random seed for training. (default: 1234) + --workers WORKERS Number of workers to use for data loading. (default: 8) --gc-interval GC_INTERVAL - Set to a value > 0 if you want to synchronize garbage collection, will do gc every gc-interval steps. - --enable-preemption Enable preemption hooks. If enabled this will save a checkpoint whenver slurm exits. + Set to a value > 0 if you want to synchronize garbage collection, will do gc every gc-interval steps. (default: 0) + --enable-preemption Enable preemption hooks. If enabled this will save a checkpoint whenver slurm exits. (default: False) --ckpt-async-save - --nsys-profiling Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling output you must run the whole program with `nsys`. For example: `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true --capture-range=cudaProfilerApi --capture-range-end=stop [regular python - command here]` + --ckpt-format {torch_dist,zarr} + Specify checkpoint format to use. Defaults to 'torch_dist', as 'zarr' is deprecated. Only use if resuming training from a zarr checkpoint. (default: + torch_dist) + --eod-pad-in-loss-mask + Do not predict EOD/Pad tokens (typical default, but not default in original evo2). (default: False) + --cross-entropy-loss-fusion + Use the faster, but maybe less accurate fused form of cross entropy, which also has bf16 grads internally. (default: False) + --no-fp32-residual-connection + If set, turn off fp32 residual connections which may be faster but may impact accuracy. (default: False) + --debug-ddp-parity-freq DEBUG_DDP_PARITY_FREQ + Set to value > 0 to debug DDP weight parity between ranks. (default: 0) + --hybrid-override-pattern HYBRID_OVERRIDE_PATTERN + Override the hybrid override pattern in the config (specifies hyena layer ordering and type). (default: None) + --num-layers NUM_LAYERS + If set, override the number of layers specified in the requested config. (default: None) + --tflops-callback Enable tflops calculation callback for Hyena / Evo2. Defaults to False. (default: False) + --log-parameters-and-shapes + Log training parameters shapes and dtypes for debugging. (default: False) + --lr LR Learning rate. (default: 0.0003) + --min-lr MIN_LR Min learning rate in cosine annealing. (default: 3e-05) + --warmup-steps WARMUP_STEPS + Number of warmup steps in cosine annealing (default: 2500) + --nsys-profiling Enable targeted `nsys` profiling on the training loop for a defined step range. To actually get profiling output you must run the whole program with + `nsys`. For example: `nsys profile -s none -o output_report_name -t cuda,nvtx --force-overwrite true --capture-range=cudaProfilerApi --capture-range- + end=stop [regular python command here]` (default: False) --nsys-start-step NSYS_START_STEP - Start nsys profiling after this step. + Start nsys profiling after this step. (default: 0) --nsys-end-step NSYS_END_STEP - End nsys profiling after this step. + End nsys profiling after this step. (default: None) + --no-renormalize-loss + Do not renormalize the loss weights. (default: False) --nsys-ranks NSYS_RANKS [NSYS_RANKS ...] - Enable nsys profiling for these ranks. + Enable nsys profiling for these ranks. (default: [0]) + --activation-checkpoint-recompute-num-layers ACTIVATION_CHECKPOINT_RECOMPUTE_NUM_LAYERS + If set, override the default value set in the config. (default: None) + --disable-checkpointing + Disable creating a ModelCheckpoint callback. (default: True) + --clip-grad CLIP_GRAD + Grad clip value. Note that when using DDP this may need to be inflated. (default: 1.0) + --seq-len-interpolation-factor SEQ_LEN_INTERPOLATION_FACTOR + Adjusts the linear scaling of ROPE (Rotary Position Embedding) for context extension. Set this factor relative to your base context length e.g., for + an original context length of 8192 and an extended context length of 524288, use 524288/8192 = 64. (default: None) + --overlap-param-gather + Overlap the parameter gather with the optimizer step. This is currently disabled due to a NeMo bug when using DDP. Making this an option defaulting to + False is a temporary solution until the bug is fixed. (default: False) + --overlap-grad-reduce + Overlap the gradient reduce with the optimizer step. (default: False) + --hidden-dropout HIDDEN_DROPOUT + Dropout probability for the hyena layers (default: 0.0) + --attention-dropout ATTENTION_DROPOUT + Dropout probability for the attention layers. (default: 0.0) + --no-activation-checkpointing + --selective-activation-checkpointing ``` To supply a pre-trained checkpoint, pass the NeMo2 checkpoint directory to `--ckpt-dir`, and the script will dump newly trained checkpoints and logs to `--experiment-dir`. However, if there are existing well-defined checkpoints in the directory specified by `--experiment-dir`, the script will automatically resume training from the most recent checkpoint in the experiment directory instead of starting from the checkpoint specified by `--ckpt-dir`, which streamlines long training sessions. (To disable this behavior, supply a new or clean `--experiment-dir` when restarting from `--ckpt-dir`.) diff --git a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py index a8c65a584d..8804b96e60 100644 --- a/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py +++ b/sub-packages/bionemo-evo2/src/bionemo/evo2/run/train.py @@ -130,9 +130,6 @@ def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace: default=False, help="Faster option that is maybe less accurate (TBD) when using fp8.", ) - parser.add_argument( - "--no-aligned-megatron-ddp", action="store_true", default=False, help="Do not do aligned gradient updates etc." - ) parser.add_argument("--use-megatron-comm-overlap-llama3-8k", action="store_true", default=False) parser.add_argument( "--tp-comm-overlap-backend",