diff --git a/.secrets.baseline b/.secrets.baseline index 64fad9549a..f130591673 100644 --- a/.secrets.baseline +++ b/.secrets.baseline @@ -139,9 +139,9 @@ "filename": "pyproject.toml", "hashed_secret": "79670e9c9d1c7ea5b81a96a2053d81437712c78e", "is_verified": false, - "line_number": 43 + "line_number": 44 } ] }, - "generated_at": "2025-01-14T17:26:27Z" + "generated_at": "2025-01-15T19:06:19Z" } diff --git a/CODEOWNERS b/CODEOWNERS index 044d1864ad..774c575781 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -94,3 +94,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 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/pyproject.toml b/pyproject.toml index 3c66363aef..ff4908be3d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,6 +21,7 @@ dependencies = [ 'bionemo-geneformer', 'bionemo-geometric', 'bionemo-llm', + 'bionemo-moco', 'bionemo-scdl', 'bionemo-size-aware-batching', 'bionemo-testing', @@ -52,6 +53,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 } @@ -128,6 +130,7 @@ executionEnvironments = [ './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/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..a1c99eecb7 --- /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 (Markov 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 120000 index 0000000000..558194c5a5 --- /dev/null +++ b/sub-packages/bionemo-moco/VERSION @@ -0,0 +1 @@ +../../VERSION \ No newline at end of file diff --git a/sub-packages/bionemo-moco/documentation.md b/sub-packages/bionemo-moco/documentation.md new file mode 100644 index 0000000000..4b4f90968a --- /dev/null +++ b/sub-packages/bionemo-moco/documentation.md @@ -0,0 +1,4693 @@ +# 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.discrete\_noise\_schedules](#mocoschedulesdiscrete_noise_schedules) +* [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) + + + +# moco + + + +# bionemo.moco.distributions + + + +# bionemo.moco.distributions.prior.distribution + + + +## PriorDistribution Objects + +```python +class PriorDistribution(ABC) +``` + +An abstract base class representing a prior distribution. + + + +#### 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. + + + +## DiscretePriorDistribution Objects + +```python +class DiscretePriorDistribution(PriorDistribution) +``` + +An abstract base class representing a discrete prior distribution. + + + +#### \_\_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 + + + +#### get\_num\_classes + +```python +def get_num_classes() -> int +``` + +Getter for num_classes. + + + +#### get\_prior\_dist + +```python +def get_prior_dist() -> Tensor +``` + +Getter for prior_dist. + + + +# bionemo.moco.distributions.prior.discrete.uniform + + + +## DiscreteUniformPrior Objects + +```python +class DiscreteUniformPrior(DiscretePriorDistribution) +``` + +A subclass representing a discrete uniform prior distribution. + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.prior.discrete.custom + + + +## 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. + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.prior.discrete + + + +# bionemo.moco.distributions.prior.discrete.mask + + + +## DiscreteMaskedPrior Objects + +```python +class DiscreteMaskedPrior(DiscretePriorDistribution) +``` + +A subclass representing a Discrete Masked prior distribution. + + + +#### \_\_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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +# bionemo.moco.distributions.prior.continuous.harmonic + + + +## LinearHarmonicPrior Objects + +```python +class LinearHarmonicPrior(PriorDistribution) +``` + +A subclass representing a Linear Harmonic prior distribution from Jit et al. https://arxiv.org/abs/2304.02198. + + + +#### \_\_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"). + + + +#### 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. + + + +# bionemo.moco.distributions.prior.continuous + + + +# bionemo.moco.distributions.prior.continuous.gaussian + + + +## GaussianPrior Objects + +```python +class GaussianPrior(PriorDistribution) +``` + +A subclass representing a Gaussian prior distribution. + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.prior.continuous.utils + + + +#### 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). + + + +# bionemo.moco.distributions.prior + + + +# bionemo.moco.distributions.time.distribution + + + +## 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. + + + +#### \_\_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. + + + +#### 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. + + + +## 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) + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.time.uniform + + + +## UniformTimeDistribution Objects + +```python +class UniformTimeDistribution(TimeDistribution) +``` + +A class representing a uniform time distribution. + + + +#### \_\_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. + + + +#### 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. + + + +## SymmetricUniformTimeDistribution Objects + +```python +class SymmetricUniformTimeDistribution(TimeDistribution) +``` + +A class representing a uniform time distribution. + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.time.logit\_normal + + + +## LogitNormalTimeDistribution Objects + +```python +class LogitNormalTimeDistribution(TimeDistribution) +``` + +A class representing a logit normal time distribution. + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.time + + + +# bionemo.moco.distributions.time.beta + + + +## BetaTimeDistribution Objects + +```python +class BetaTimeDistribution(TimeDistribution) +``` + +A class representing a beta time distribution. + + + +#### \_\_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. + + + +#### 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. + + + +# bionemo.moco.distributions.time.utils + + + +#### 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. + + + +# bionemo.moco.schedules.discrete\_noise\_schedules + + + +## DiscreteNoiseSchedule Objects + +```python +class DiscreteNoiseSchedule(ABC) +``` + +A base class for discrete schedules. No matter the definition this class returns objects using a unified direction of time. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `nsteps` _Optional[int]_ - Number of time steps. If None, uses the value from initialization. +- `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). + + + +#### generate\_schedule + +```python +def generate_schedule(nsteps: Optional[int] = None, + device: Union[str, torch.device] = "cpu", + synchronize: Optional[TimeDirection] = None) -> Tensor +``` + +Public wrapper to generate the 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"). +- `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 of time steps + 1 unless full is False. + + + +#### 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. + + + +## DiscreteCosineNoiseSchedule Objects + +```python +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule) +``` + +A cosine noise schedule for Diffusion Models. + + + +#### \_\_init\_\_ + +```python +def __init__(nsteps: int, nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `nsteps` _int_ - Number of time steps. +- `nu` _Optional[Float]_ - Hyperparameter for the cosine schedule (default is 1.0). +- `s` _Optional[Float]_ - Hyperparameter for the cosine schedule (default is 0.008). + + + +# bionemo.moco.schedules.noise.continuous\_snr\_transforms + + + +#### 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. + + + +## ContinuousSNRTransform Objects + +```python +class ContinuousSNRTransform(ABC) +``` + +A base class for continuous SNR schedules. + + + +#### \_\_init\_\_ + +```python +def __init__(direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + +- `direction` _TimeDirection_ - required this defines in which direction the scheduler was built + + + +#### 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. + + + +#### 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. + + + +#### 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 + + + +#### 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. + + + +#### 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) + + + +#### 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. + + + +#### 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. + + + +## 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). + + + +#### \_\_init\_\_ + +```python +def __init__(nu: Float = 1.0, s: Float = 0.008) +``` + +Initialize the CosineNoiseSchedule. + + + +## LinearSNRTransform Objects + +```python +class LinearSNRTransform(ContinuousSNRTransform) +``` + +A Linear SNR schedule. + + + +#### \_\_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. + + + +## LinearLogInterpolatedSNRTransform Objects + +```python +class LinearLogInterpolatedSNRTransform(ContinuousSNRTransform) +``` + +A Linear Log space interpolated SNR schedule. + + + +#### \_\_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. + + + +# bionemo.moco.schedules.noise.discrete\_noise\_schedules + + + +## DiscreteNoiseSchedule Objects + +```python +class DiscreteNoiseSchedule(ABC) +``` + +A base class for discrete noise schedules. + + + +#### \_\_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 + + + +#### 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). + + + +#### 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. + + + +## DiscreteCosineNoiseSchedule Objects + +```python +class DiscreteCosineNoiseSchedule(DiscreteNoiseSchedule) +``` + +A cosine discrete noise schedule. + + + +#### \_\_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). + + + +## DiscreteLinearNoiseSchedule Objects + +```python +class DiscreteLinearNoiseSchedule(DiscreteNoiseSchedule) +``` + +A linear discrete noise schedule. + + + +#### \_\_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. + + + +# bionemo.moco.schedules.noise + + + +# bionemo.moco.schedules.noise.continuous\_noise\_transforms + + + +## ContinuousExpNoiseTransform Objects + +```python +class ContinuousExpNoiseTransform(ABC) +``` + +A base class for continuous schedules. + +alpha = exp(- sigma) where 1 - alpha controls the masking fraction. + + + +#### \_\_init\_\_ + +```python +def __init__(direction: TimeDirection) +``` + +Initialize the DiscreteNoiseSchedule. + +**Arguments**: + + direction : TimeDirection, required this defines in which direction the scheduler was built + + + +#### 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. + + + +#### 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. + + + +## CosineExpNoiseTransform Objects + +```python +class CosineExpNoiseTransform(ContinuousExpNoiseTransform) +``` + +A cosine Exponential noise schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(eps: Float = 1.0e-3) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `eps` _Float_ - small number to prevent numerical issues. + + + +#### 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. + + + +## LogLinearExpNoiseTransform Objects + +```python +class LogLinearExpNoiseTransform(ContinuousExpNoiseTransform) +``` + +A log linear exponential schedule. + + + +#### \_\_init\_\_ + +```python +def __init__(eps: Float = 1.0e-3) +``` + +Initialize the CosineNoiseSchedule. + +**Arguments**: + +- `eps` _Float_ - small value to prevent numerical issues. + + + +#### 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. + + + +# bionemo.moco.schedules + + + +# bionemo.moco.schedules.utils + + + +## TimeDirection Objects + +```python +class TimeDirection(Enum) +``` + +Enum for the direction of the noise schedule. + + + +#### UNIFIED + +Noise(0) --> Data(1) + + + +#### DIFFUSION + +Noise(1) --> Data(0) + + + +# bionemo.moco.schedules.inference\_time\_schedules + + + +## InferenceSchedule Objects + +```python +class InferenceSchedule(ABC) +``` + +A base class for inference time schedules. + + + +#### \_\_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"). + + + +#### 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"). + + + +#### 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. + + + +## ContinuousInferenceSchedule Objects + +```python +class ContinuousInferenceSchedule(InferenceSchedule) +``` + +A base class for continuous time inference schedules. + + + +#### \_\_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"). + + + +#### 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. + + + +## DiscreteInferenceSchedule Objects + +```python +class DiscreteInferenceSchedule(InferenceSchedule) +``` + +A base class for discrete time inference schedules. + + + +#### 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. + + + +## DiscreteLinearInferenceSchedule Objects + +```python +class DiscreteLinearInferenceSchedule(DiscreteInferenceSchedule) +``` + +A linear time schedule for discrete time inference. + + + +#### \_\_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"). + + + +#### 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. + + + +## LinearInferenceSchedule Objects + +```python +class LinearInferenceSchedule(ContinuousInferenceSchedule) +``` + +A linear time schedule for continuous time inference. + + + +#### \_\_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"). + + + +#### 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. + + + +## 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. + + + +#### \_\_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"). + + + +#### 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. + + + +## 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. + + + +#### \_\_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"). + + + +#### 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"). + + + +# bionemo.moco.interpolants.continuous\_time.discrete + + + +# bionemo.moco.interpolants.continuous\_time.discrete.mdlm + + + +## 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 + +``` + + + +#### \_\_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. + + + +#### 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 + + + +#### 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 + + + +#### 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. + + + +#### step + +```python +def step(logits, t, xt, dt) -> Tensor +``` + +Perform a single step of MDLM DDPM step. + +**Arguments**: + +- `logits` _Tensor_ - The input logits. +- `t` _float_ - The current time step. +- `xt` _Tensor_ - The current state. +- `dt` _float_ - The time step increment. + + +**Returns**: + +- `Tensor` - The updated state. + + + +#### 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) -> Tensor +``` + +Update the input sequence xt by sampling from the predicted logits and adding Gumbel noise. + +Method taken from GenMol Seul et al. + +**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 + + +**Returns**: + + Updated input sequence xt + + + +#### 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. + + + +#### 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. + + + +# bionemo.moco.interpolants.continuous\_time.discrete.discrete\_flow\_matching + + + +## DiscreteFlowMatcher Objects + +```python +class DiscreteFlowMatcher(Interpolant) +``` + +A Discrete Flow Model (DFM) interpolant. + + + +#### \_\_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. + + + +#### 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 + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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 + + + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.ot\_types + + + +## 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. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.ot\_sampler + + + +## 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 + + + +#### \_\_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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.equivariant\_ot\_sampler + + + +## 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. + + + +#### \_\_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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport.kabsch\_augmentation + + + +## KabschAugmentation Objects + +```python +class KabschAugmentation() +``` + +Point-wise Kabsch alignment. + + + +#### \_\_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. + + + +#### 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 + + + +#### 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 + + + +#### 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. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.optimal\_transport + + + +# bionemo.moco.interpolants.continuous\_time.continuous + + + +# bionemo.moco.interpolants.continuous\_time.continuous.vdm + + + +## 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 + +``` + + + +#### \_\_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. + + + +#### 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() + + + +#### 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 + + + +#### 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". + + + +#### 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". + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +# bionemo.moco.interpolants.continuous\_time.continuous.continuous\_flow\_matching + + + +## 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 + +``` + + + +#### \_\_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 + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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) + + + +#### 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. + + + +#### 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". + + + +#### 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". + + + +#### 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. + + + +#### 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 ODE step integration using Euler method. + +d x_t = [v(x_t, t) + g(t) * s(x_t, t) * sc_score_scale] dt + \sqrt{2 * g(t) * temperature} dw_t. + +At the moment we do not scale the vector field v but this can be added with sc_score_scale. + +**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 "1/t". +- `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. + + + +#### 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. + + + +#### 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]. + + + +#### 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 + + + +# bionemo.moco.interpolants.continuous\_time + + + +# bionemo.moco.interpolants + + + +# bionemo.moco.interpolants.batch\_augmentation + + + +## 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. + + + +#### \_\_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. + + + +#### 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**. + + + +# bionemo.moco.interpolants.discrete\_time.discrete.d3pm + + + +## D3PM Objects + +```python +class D3PM(Interpolant) +``` + +A Discrete Denoising Diffusion Probabilistic Model (D3PM) interpolant. + + + +#### \_\_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. + + + +#### 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`. + + + +#### 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 + + + +#### 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`. + + + +#### 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. + + + +# bionemo.moco.interpolants.discrete\_time.discrete + + + +# bionemo.moco.interpolants.discrete\_time.continuous.ddpm + + + +## 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 + +``` + + + +#### \_\_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. + + + +#### forward\_data\_schedule + +```python +@property +def forward_data_schedule() -> torch.Tensor +``` + +Returns the forward data schedule. + + + +#### forward\_noise\_schedule + +```python +@property +def forward_noise_schedule() -> torch.Tensor +``` + +Returns the forward noise schedule. + + + +#### reverse\_data\_schedule + +```python +@property +def reverse_data_schedule() -> torch.Tensor +``` + +Returns the reverse data schedule. + + + +#### reverse\_noise\_schedule + +```python +@property +def reverse_noise_schedule() -> torch.Tensor +``` + +Returns the reverse noise schedule. + + + +#### log\_var + +```python +@property +def log_var() -> torch.Tensor +``` + +Returns the log variance. + + + +#### alpha\_bar + +```python +@property +def alpha_bar() -> torch.Tensor +``` + +Returns the alpha bar values. + + + +#### alpha\_bar\_prev + +```python +@property +def alpha_bar_prev() -> torch.Tensor +``` + +Returns the previous alpha bar values. + + + +#### 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() + + + +#### 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. + + + +#### 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". + + + +#### 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". + + + +#### 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. + + + +#### 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 + + + +#### 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 + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### 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. + + + +#### loss + +```python +def loss(model_pred: Tensor, + target: Tensor, + t: Optional[Tensor] = None, + mask: Optional[Tensor] = None, + weight_type: str = "ones") +``` + +Calculate the loss given the model prediction, data sample, 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. +- `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. Defaults to "ones". + + +**Returns**: + +- `Tensor` - The calculated loss batch tensor. + + + +# bionemo.moco.interpolants.discrete\_time.continuous + + + +# bionemo.moco.interpolants.discrete\_time + + + +# bionemo.moco.interpolants.discrete\_time.utils + + + +#### 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. + + + +# bionemo.moco.interpolants.base\_interpolant + + + +#### 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. + + + +#### 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) + + + +## 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. + + + +## 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. + + + +#### \_\_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. + + + +#### 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. + + + +#### step + +```python +@abstractmethod +def step(*args, **kwargs) -> Tensor +``` + +Do one step integration. + + + +#### 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. + + + +#### 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. + + + +#### sample\_time + +```python +def sample_time(*args, **kwargs) -> Tensor +``` + +Sample from time distribution. + + + +#### 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. + + + +#### 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..a455b0c93b --- /dev/null +++ b/sub-packages/bionemo-moco/examples/continuous_data_interpolant_tutorial.ipynb @@ -0,0 +1,1844 @@ +{ + "cells": [ + { + "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 torchdyn, a PyTorch library dedicated to neural differential equations and equilibrium models, 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": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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 2.752\n", + "10000: loss 2.838\n", + "15000: loss 2.709\n", + "20000: loss 3.096\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": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 39, + "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 = 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": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "traj = torch.stack(trajectory_stoch).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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "#for i in range(0, traj.shape[0]-1):\n", + "# plt.plot(traj[i, :n, 0], traj[i, :n, 1], c=\"olive\", alpha=0.2) #, s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 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": 41, + "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 = 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": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = 2000\n", + "traj = torch.stack(trajectory2).cpu().detach().numpy()\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, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 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": 43, + "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 is typically used with a Gaussian Prior. Here we show it working with the Cusotm Moon prior as an example." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "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": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 0.320\n", + "2000: loss 0.372\n", + "3000: loss 0.330\n", + "4000: loss 0.409\n", + "5000: loss 0.338\n", + "6000: loss 0.378\n", + "7000: loss 0.355\n", + "8000: loss 0.394\n", + "9000: loss 0.359\n", + "10000: loss 0.338\n", + "11000: loss 0.257\n", + "12000: loss 0.293\n", + "13000: loss 0.333\n", + "14000: loss 0.329\n", + "15000: loss 0.322\n", + "16000: loss 0.302\n", + "17000: loss 0.282\n", + "18000: loss 0.331\n", + "19000: loss 0.289\n", + "20000: loss 0.322\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": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 47, + "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": 48, + "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": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 49, + "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": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 51, + "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": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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", + "n = 2000\n", + "traj = torch.stack(trajectory2).cpu().detach().numpy()\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, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], traj[-1, :n, 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": 54, + "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": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 0.504\n", + "2000: loss 1.002\n", + "3000: loss 0.446\n", + "4000: loss 1.014\n", + "5000: loss 0.375\n", + "6000: loss 1.849\n", + "7000: loss 0.489\n", + "8000: loss 1.577\n", + "9000: loss 0.314\n", + "10000: loss 0.468\n", + "11000: loss 0.332\n", + "12000: loss 1.729\n", + "13000: loss 0.374\n", + "14000: loss 0.779\n", + "15000: loss 0.536\n", + "16000: loss 6.597\n", + "17000: loss 1.269\n", + "18000: loss 0.501\n", + "19000: loss 0.546\n", + "20000: loss 0.490\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": 56, + "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": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 2.651\n", + "2000: loss 2.659\n", + "3000: loss 2.603\n", + "4000: loss 2.507\n", + "5000: loss 2.650\n", + "6000: loss 2.792\n", + "7000: loss 2.670\n", + "8000: loss 2.550\n", + "9000: loss 2.685\n", + "10000: loss 2.410\n", + "11000: loss 2.290\n", + "12000: loss 2.755\n", + "13000: loss 2.521\n", + "14000: loss 2.505\n", + "15000: loss 2.196\n", + "16000: loss 2.702\n", + "17000: loss 2.933\n", + "18000: loss 2.350\n", + "19000: loss 2.397\n", + "20000: loss 2.382\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": 59, + "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": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 61, + "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": 62, + "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": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1000: loss 1.251\n", + "2000: loss 1.152\n", + "3000: loss 1.156\n", + "4000: loss 0.908\n", + "5000: loss 1.174\n", + "6000: loss 1.355\n", + "7000: loss 1.008\n", + "8000: loss 1.567\n", + "9000: loss 1.092\n", + "10000: loss 1.290\n", + "11000: loss 1.149\n", + "12000: loss 1.350\n", + "13000: loss 1.480\n", + "14000: loss 1.061\n", + "15000: loss 1.223\n", + "16000: loss 1.180\n", + "17000: loss 1.127\n", + "18000: loss 1.351\n", + "19000: loss 1.059\n", + "20000: loss 1.074\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": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# DEVICE=\"cuda:1\"\n", + "# model = model.to(DEVICE)\n", + "# vdm = vdm.to_device(DEVICE)\n", + "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": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 66, + "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": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "traj = torch.stack(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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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", + "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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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", + "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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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", + "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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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", + "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", + "plt.figure(figsize=(6, 6))\n", + "\n", + "# Plot the first time point in black\n", + "plt.scatter(traj[0, :n, 0], traj[0, :n, 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, :n, 0], traj[i, :n, 1], s=0.2, alpha=0.2, c=\"olive\")\n", + "\n", + "# Plot the last time point in blue\n", + "plt.scatter(traj[-1, :n, 0], 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", + "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..364d61bae3 --- /dev/null +++ b/sub-packages/bionemo-moco/examples/discrete_data_interpolant_tutorial.ipynb @@ -0,0 +1,993 @@ +{ + "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": 30, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/50000 [00:00" + ] + }, + "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": 5, + "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": 6, + "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": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "LinearInferenceSchedule(nsteps = 100, min_t=0, inclusive_end=False).generate_schedule()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "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": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 13, + "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": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.5000, 0.5000], device='cuda:0')" + ] + }, + "execution_count": 14, + "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": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [01:03<00:00, 784.48it/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": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 17, + "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": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 20, + "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": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 21, + "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": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [01:32<00:00, 541.11it/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": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 25, + "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": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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." + ] + } + ], + "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": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "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'', lambda match: f'', 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..20b2ab26c6 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/continuous/continuous_flow_matching.py @@ -0,0 +1,547 @@ +# 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 ODE step integration using Euler method. + + d x_t = [v(x_t, t) + g(t) * s(x_t, t) * sc_score_scale] dt + \sqrt{2 * g(t) * temperature} dw_t. + + At the moment we do not scale the vector field v but this can be added with sc_score_scale. + + 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 "1/t". + 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..350950edf0 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/continuous_time/discrete/mdlm.py @@ -0,0 +1,355 @@ +# 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, t, xt, dt) -> Tensor: + """Perform a single step of MDLM DDPM step. + + Parameters: + logits (Tensor): The input logits. + t (float): The current time step. + xt (Tensor): The current state. + dt (float): The time step increment. + + 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) + if p_mask_s.ndim != log_p_x0.ndim: + raise ValueError(f"Dimension Mistmatch {p_mask_s.shape} {log_p_x0.shape}") + # Equation 6 from MDLM + prob_s_given_t = log_p_x0.exp() * (alpha_s - alpha_t) # righthand side (alpha_s - alpha_t)*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 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, + ) -> Tensor: + """Update the input sequence xt by sampling from the predicted logits and adding Gumbel noise. + + Method taken from GenMol Seul et al. + + 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 + + Returns: + Updated input sequence xt + """ + 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=1, 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..c5dabd99f6 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/continuous/ddpm.py @@ -0,0 +1,526 @@ +# 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 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) + 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: str = "ones", + ): + """Calculate the loss given the model prediction, data sample, 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. + 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. 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) + 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 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..5d1f58f8e9 --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/interpolants/discrete_time/discrete/d3pm.py @@ -0,0 +1,371 @@ +# 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. + """ + super().__init__(time_distribution, prior_distribution, device, 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(device) + self._initialize_schedules(device) + self.last_time_idx = last_time_idx + + 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] + 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) + probs = torch.einsum("b...j, bji -> b...i", [x1_hot.float(), ford]) + if torch.all((probs.sum(-1) - 1.0).abs() > 1e-4): + raise ValueError("Invalid Probability Distriubtion: distribution must some to 1.0") + 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/discrete_noise_schedules.py b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/discrete_noise_schedules.py new file mode 100644 index 0000000000..6775997cbd --- /dev/null +++ b/sub-packages/bionemo-moco/src/bionemo/moco/schedules/discrete_noise_schedules.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. + + +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 schedules. No matter the definition this class returns objects using a unified direction of time.""" + + def __init__(self, nsteps: int, direction: TimeDirection): + """Initialize the DiscreteNoiseSchedule. + + Args: + nsteps (Optional[int]): Number of time steps. If None, uses the value from initialization. + 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). + + """ + 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: + """Public wrapper to generate the 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"). + 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 of time steps + 1 unless full is False. + """ + schedule = self._generate_schedule(nsteps, device) + if synchronize is None: + return schedule + synchronize = string_to_enum(synchronize, TimeDirection) + if self.direction != synchronize: + return torch.flip(schedule, dims=[0]) + return schedule + + @abstractmethod + def _generate_schedule(self, nsteps: Optional[int] = None, device: Union[str, torch.device] = "cpu") -> Tensor: + """Generate the time schedule as a list. + + 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 + 1 unless full is False. + """ + 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 noise schedule for Diffusion Models.""" + + def __init__(self, nsteps: int, nu: Float = 1.0, s: Float = 0.008): + """Initialize the CosineNoiseSchedule. + + Args: + nsteps (int): Number of time steps. + nu (Optional[Float]): Hyperparameter for the cosine schedule (default is 1.0). + s (Optional[Float]): Hyperparameter for the cosine schedule (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"). + + Returns: + Tensor: A tensor of time steps + 1 unless full is False. + """ + if nsteps is None: + nsteps = self.nsteps + steps = nsteps + 2 + x = torch.linspace(0, steps, steps, device=device) + alphas_cumprod = torch.cos(0.5 * torch.pi * (((x / steps) ** self.nu) + self.s) / (1 + self.s)) ** 2 + alphas_cumprod_new = alphas_cumprod / alphas_cumprod[0] + alphas_cumprod_new = self._clip_noise_schedule(alphas_cumprod_new, clip_value=0.05) + alphas = alphas_cumprod_new[1:] / alphas_cumprod_new[:-1] + alphas = torch.clamp(alphas, min=0.001) + betas = 1 - alphas + betas = torch.clamp(betas, 0.0, 0.999) + result = 1.0 - betas + return result[1:] + + 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 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..d3cbb0e16c --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/continuous/test_continuous_flow_matching.py @@ -0,0 +1,270 @@ +# 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) + 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..4f9ae56bdd --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/continuous_time/discrete/test_mdlm.py @@ -0,0 +1,181 @@ +# 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 + 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..f88983f98c --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/interpolants/discrete_time/discrete/test_d3pm.py @@ -0,0 +1,136 @@ +# 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 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_continuous_noise_transforms.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_noise_transforms.py new file mode 100644 index 0000000000..f495fe8142 --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/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/test_continuous_snr_transforms.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_continuous_snr_transforms.py new file mode 100644 index 0000000000..d9633a2eee --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/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/test_discrete_noise_schedules.py b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_discrete_noise_schedules.py new file mode 100644 index 0000000000..9eb048da0f --- /dev/null +++ b/sub-packages/bionemo-moco/tests/bionemo/moco/schedules/test_discrete_noise_schedules.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 +import torch + +from bionemo.moco.schedules.discrete_noise_schedules import DiscreteCosineNoiseSchedule, 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) + 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