From 94de023c4d7a0510f882c4f5b393c7f69620f744 Mon Sep 17 00:00:00 2001 From: Giorgio Giannone Date: Mon, 12 Sep 2022 17:03:47 +0200 Subject: [PATCH] feat: integrate diffusion models in gt4sd (#128) * wip: skeleton diffusion * wip: add implementation, core * wip: add diffusion models and noise scheduler support * wip: add tests * fix: fix imports * wip: black files * feat: add modality, minor fix * fix: minor fix tests * fix tests * add tests * add training_pipeline for diffusion * minor change * remove double reqs * set ubuntu version ci * ci: relax latest, fix examples * add diffusion-trainer, test diffusion training_pipeline * skip high-memory tests * minor change * fix: segfaults on ulinux for rdkit/torchvision conflicts * fix tests, add demo * fix model_types * improve tests * feat: add notebook for text2image, improve testing * fix tests, skip auth_token, skip slow_sampling * separate tests unconditional and text-conditional * fix reqs * add tests for diffusion training_pipeline * add stable-diffusion in notebook, use conditional reqs * fix conda.yml path * minor changes, explicit name training_pipeline for image generation * fix reqs * change training_pipeline name for consistency * use common interface for sampling, add target, improve notebook, fix issue with hashable * feat: simplifying sampling logic. Signed-off-by: Matteo Manica * fix: pass prompt in configuration * fix style, update notebook * black files * refactor sample Signed-off-by: Matteo Manica Co-authored-by: Jannis Born Co-authored-by: Matteo Manica --- .github/conda_ci.yml | 16 - .github/requirements_ci.txt | 34 -- .github/workflows/tests.yaml | 2 +- .gitignore | 2 +- README.md | 2 + .../example_train_ae_and_mlp.py | 6 +- notebooks/diffusion-demo.ipynb | 489 ++++++++++++++++++ requirements.txt | 24 +- setup.cfg | 17 +- src/gt4sd/algorithms/__init__.py | 8 + src/gt4sd/algorithms/core.py | 40 +- .../generation/diffusion/__init__.py | 45 ++ .../algorithms/generation/diffusion/core.py | 320 ++++++++++++ .../generation/diffusion/implementation.py | 157 ++++++ .../generation/tests/test_diffusion.py | 244 +++++++++ src/gt4sd/domains/materials/__init__.py | 2 +- src/gt4sd/training_pipelines/__init__.py | 14 + .../training_pipelines/diffusion/__init__.py | 24 + .../training_pipelines/diffusion/core.py | 421 +++++++++++++++ .../tests/test_training_diffusion.py | 118 +++++ 20 files changed, 1905 insertions(+), 80 deletions(-) delete mode 100644 .github/conda_ci.yml delete mode 100644 .github/requirements_ci.txt create mode 100644 notebooks/diffusion-demo.ipynb create mode 100644 src/gt4sd/algorithms/generation/diffusion/__init__.py create mode 100644 src/gt4sd/algorithms/generation/diffusion/core.py create mode 100644 src/gt4sd/algorithms/generation/diffusion/implementation.py create mode 100644 src/gt4sd/algorithms/generation/tests/test_diffusion.py create mode 100644 src/gt4sd/training_pipelines/diffusion/__init__.py create mode 100644 src/gt4sd/training_pipelines/diffusion/core.py create mode 100644 src/gt4sd/training_pipelines/tests/test_training_diffusion.py diff --git a/.github/conda_ci.yml b/.github/conda_ci.yml deleted file mode 100644 index 8124e6671..000000000 --- a/.github/conda_ci.yml +++ /dev/null @@ -1,16 +0,0 @@ -name: gt4sd -channels: - - https://conda.anaconda.org/pytorch - - https://conda.anaconda.org/nvidia - - https://conda.anaconda.org/pyg - - https://conda.anaconda.org/conda-forge -dependencies: - - python>=3.7,<3.8 - - pip>=19.1,<20.3 - - pytorch>=1.0 - - pytorch-scatter>=2.0.9 - - pip: - - -r ./requirements_ci.txt - - -r ../vcs_requirements.txt - # development - - -r ../dev_requirements.txt diff --git a/.github/requirements_ci.txt b/.github/requirements_ci.txt deleted file mode 100644 index fb67a5cb7..000000000 --- a/.github/requirements_ci.txt +++ /dev/null @@ -1,34 +0,0 @@ -# pypi requirements for ci -datasets>=1.11.0 -joblib>=1.1.0 -keras==2.3.1 -torchmetrics<0.7 -keybert==0.2.0 -minio==7.0.1 -modlamp>=4.0.0 -scikit-learn<0.24.0 -numpy>=1.16.5 -pytorch_lightning<=1.5.0 -pydantic>=1.7.3,<=1.9.2 -PyTDC>=0.3.6 -pyyaml>=5.4.1 -rdkit-pypi>=2020.9.5.2,<=2021.9.4 -regex>=2.5.91 -reinvent-chemistry==0.0.38 -sacremoses>=0.0.41 -scikit-optimize>=0.8.1 -sentencepiece>=0.1.95 -sympy>=1.10.1 -tables>=3.7.0 -tape-proteins>=0.4 -protobuf<3.20 -tensorboard!=2.5.0,>=2.2.0 -tensorflow==2.1.0 -torch>=1.0 -torch-cluster>=1.6.0+cpu -torch-geometric>=2.0.4+cpu -torch-sparse>=0.6.14+cpu -torchdrug>=0.1.2 -transformers>=4.2.1 -typing_extensions>=3.7.4.3 -wheel>=0.26 \ No newline at end of file diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index 185a8b524..0769af3b8 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -24,7 +24,7 @@ jobs: - uses: conda-incubator/setup-miniconda@v2 with: activate-environment: gt4sd - environment-file: .github/conda_ci.yml + environment-file: conda.yml auto-activate-base: false use-only-tar-bz2: true - name: Install gt4sd from source diff --git a/.gitignore b/.gitignore index 788a942f3..e751cf998 100644 --- a/.gitignore +++ b/.gitignore @@ -145,5 +145,5 @@ oracle # local tests _main_* -# data +# data folder data/ diff --git a/README.md b/README.md index 3e4f9141a..3010a332d 100644 --- a/README.md +++ b/README.md @@ -210,6 +210,7 @@ The trainer currently supports the following training pipelines: - `moses-vae-trainer`: Moses VAE models. - `torchdrug-gcpn-trainer`: TorchDrug Graph Convolutional Policy Network model. - `torchdrug-graphaf-trainer`: TorchDrug autoregressive GraphAF model. +- `diffusion-trainer`: Diffusers model. - `gflownet-trainer`: GFlowNet model. ```console @@ -337,6 +338,7 @@ Beyond implementing various generative modeling inference and training pipelines - [TAPE](https://github.com/songlab-cal/tape): encoder modules compatible with the protein language models. - [PaccMann](https://github.com/PaccMann/): inference pipelines for all algorithms of the PaccMann family as well as training pipelines for the generative VAEs. - [transformers](https://huggingface.co/transformers): training and inference pipelines for generative models from [HuggingFace Models](https://huggingface.co/models) +- [diffusers](https://github.com/huggingface/diffusers): training and inference pipelines for generative models from [Diffusers Models](https://github.com/huggingface/diffusers) - [GFlowNets](https://github.com/recursionpharma/gflownet): training and inference pipeline for [Generative Flow Networks](https://yoshuabengio.org/2022/03/05/generative-flow-networks/) ## References diff --git a/examples/granular/ae_mlp_example/example_train_ae_and_mlp.py b/examples/granular/ae_mlp_example/example_train_ae_and_mlp.py index 7d1382c22..37fd524d2 100644 --- a/examples/granular/ae_mlp_example/example_train_ae_and_mlp.py +++ b/examples/granular/ae_mlp_example/example_train_ae_and_mlp.py @@ -1,6 +1,8 @@ -from gt4sd.frameworks.granular.train.core import parse_arguments_from_config, train_granular +from gt4sd.frameworks.granular.train.core import ( + parse_arguments_from_config, + train_granular, +) args = parse_arguments_from_config("config_ae.ini") train_granular(vars(args)) - diff --git a/notebooks/diffusion-demo.ipynb b/notebooks/diffusion-demo.ipynb new file mode 100644 index 000000000..f87963522 --- /dev/null +++ b/notebooks/diffusion-demo.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Inference using Conditional Diffusion Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this notebook we show how to perform inference using GT4SD and the models implemented in Diffusers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how we can use a latent diffusion model (LDM) to generate images conditioning on text. \n", + "The first time you run this cell a bunch of tokenizers, encoders, unet models will be downloaded." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "NOTE: Redirects are currently not supported in Windows or MacOs.\n", + "Using TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:toxsmi.utils.wrappers:Class weights are (1, 1).\n", + "15:11:41 Class weights are (1, 1).\n", + "INFO:toxsmi.utils.wrappers:Class weights are (1, 1).\n", + "15:11:41 Class weights are (1, 1).\n", + "INFO:tape.models.modeling_utils:Better speed can be achieved with apex installed from https://www.github.com/nvidia/apex .\n", + "15:11:43 Better speed can be achieved with apex installed from https://www.github.com/nvidia/apex .\n" + ] + } + ], + "source": [ + "from gt4sd.algorithms.registry import ApplicationsRegistry" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:gt4sd.algorithms.core:runnning DiffusersGenerationAlgorithm with configuration=LDMTextToImageGenerator(algorithm_version='CompVis/ldm-text2im-large-256', modality='token2image', model_type='latent_diffusion_conditional', scheduler_type='discrete', prompt='Generative models are cool!')\n", + "15:11:54 runnning DiffusersGenerationAlgorithm with configuration=LDMTextToImageGenerator(algorithm_version='CompVis/ldm-text2im-large-256', modality='token2image', model_type='latent_diffusion_conditional', scheduler_type='discrete', prompt='Generative models are cool!')\n", + "INFO:gt4sd.algorithms.generation.diffusion.core:ensure artifacts for the application are present.\n", + "15:11:54 ensure artifacts for the application are present.\n", + "INFO:gt4sd.s3:starting syncing\n", + "15:11:54 starting syncing\n", + "INFO:gt4sd.s3:syncing complete\n", + "15:11:55 syncing complete\n", + "INFO:gt4sd.s3:starting syncing\n", + "15:11:55 starting syncing\n", + "INFO:gt4sd.s3:syncing complete\n", + "15:11:55 syncing complete\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "{'cross_attention_dim'} was not found in config. Values will be initialized to default values.\n", + "{'set_alpha_to_one'} was not found in config. Values will be initialized to default values.\n" + ] + } + ], + "source": [ + "prompt = \"Generative models are cool!\"\n", + "\n", + "algorithm = ApplicationsRegistry.get_application_instance(\n", + " target=None,\n", + " algorithm_type='generation',\n", + " domain='vision',\n", + " algorithm_name='DiffusersGenerationAlgorithm',\n", + " algorithm_application='LDMTextToImageGenerator',\n", + " prompt=prompt\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6982969d472a48b2a2a4fa5969f65940", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "642d3b8ee4554728879a95b4f75def19", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c20ec76608ca43dd90b3715d9ec04807", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Changing diffusion model is as easy as changing one line of code with `StableDiffusionGenerator`. Here we use stable-diffusion to generate images conditioning on text. You will have to accept the license [here](https://huggingface.co/CompVis/stable-diffusion-v1-4) and authenticate on [huggingface](https://huggingface.co) to use this model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "huggingface-cli login" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:gt4sd.algorithms.core:runnning DiffusersGenerationAlgorithm with configuration=StableDiffusionGenerator(algorithm_version='CompVis/stable-diffusion-v1-4', modality='token2image', model_type='stable_diffusion', scheduler_type='discrete')\n", + "14:16:40 runnning DiffusersGenerationAlgorithm with configuration=StableDiffusionGenerator(algorithm_version='CompVis/stable-diffusion-v1-4', modality='token2image', model_type='stable_diffusion', scheduler_type='discrete')\n", + "INFO:gt4sd.algorithms.generation.diffusion.core:ensure artifacts for the application are present.\n", + "14:16:40 ensure artifacts for the application are present.\n", + "INFO:gt4sd.s3:starting syncing\n", + "14:16:40 starting syncing\n", + "INFO:gt4sd.s3:syncing complete\n", + "14:16:41 syncing complete\n", + "INFO:gt4sd.s3:starting syncing\n", + "14:16:41 starting syncing\n", + "INFO:gt4sd.s3:syncing complete\n", + "14:16:41 syncing complete\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c19c08958dfa43d18858228831354ebd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading: 0%| | 0.00/14.9k [00:00" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ca715dd89f964aa1b937dcfda2a3610d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prompt = \"Draw a logo for the Generative Toolkit for Scientific Discovery (GT4SD) project!\"\n", + "\n", + "algorithm = ApplicationsRegistry.get_application_instance(\n", + " target=None,\n", + " algorithm_type='generation',\n", + " domain='vision',\n", + " algorithm_name='DiffusersGenerationAlgorithm',\n", + " algorithm_application='StableDiffusionGenerator', # authenticate on huggingface\n", + " prompt=prompt\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "image = list(algorithm.sample(1))[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('gt4sd')", + "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.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "7f6df040e92be56c42e1ba5ffdd58832f97e24eff2af0498cbc88845f2e95a48" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/requirements.txt b/requirements.txt index ee703a9a0..048162ff7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,13 +1,14 @@ # pypi requirements +accelerate>=0.12 datasets>=1.11.0 +diffusers>=0.2.4 joblib>=1.1.0 keras==2.3.1 -torchmetrics<0.7 keybert==0.2.0 minio==7.0.1 modlamp>=4.0.0 -scikit-learn<0.24.0 numpy>=1.16.5 +protobuf<3.20 pytorch_lightning<=1.5.0 pydantic>=1.7.3,<=1.9.2 PyTDC>=0.3.6 @@ -16,19 +17,26 @@ rdkit-pypi>=2020.9.5.2,<=2021.9.4 regex>=2.5.91 reinvent-chemistry==0.0.38 sacremoses>=0.0.41 +scikit-learn<0.24.0 scikit-optimize>=0.8.1 sentencepiece>=0.1.95 sympy>=1.10.1 tables>=3.7.0 tape-proteins>=0.4 -protobuf<3.20 tensorboard!=2.5.0,>=2.2.0 tensorflow==2.1.0 -torch>=1.0 -torch-cluster>=1.6.0 -torch-geometric>=2.0.4 -torch-sparse>=0.6.14 +# cpu for ci tests +torch>=1.0+cpu; sys_platform == "linux" +torch>=1.0; sys_platform != "linux" +torch-cluster>=1.6.0+cpu; sys_platform == 'linux' +torch-cluster>=1.6.0; sys_platform != 'linux' +torch-geometric>=2.0.4+cpu; sys_platform == 'linux' +torch-geometric>=2.0.4; sys_platform != 'linux' +torch-sparse>=0.6.14+cpu; sys_platform == 'linux' +torch-sparse>=0.6.14; sys_platform != 'linux' torchdrug>=0.1.2 +torchmetrics<0.7 +torchvision>=0.12.0 transformers>=4.2.1 typing_extensions>=3.7.4.3 -wheel>=0.26 \ No newline at end of file +wheel>=0.26 diff --git a/setup.cfg b/setup.cfg index ea38a6e13..e7c97226c 100644 --- a/setup.cfg +++ b/setup.cfg @@ -188,6 +188,21 @@ ignore_missing_imports = True [mypy-modlamp.*] ignore_missing_imports = True +[mypy-diffusers.*] +ignore_missing_imports = True + +[mypy-accelerate.*] +ignore_missing_imports = True + +[mypy-tqdm.*] +ignore_missing_imports = True + +[mypy-torchvision.*] +ignore_missing_imports = True + +[mypy-PIL.*] +ignore_missing_imports = True + [mypy-scipy.*] ignore_missing_imports = True @@ -204,4 +219,4 @@ ignore_missing_imports = True ignore_missing_imports = True [mypy-sympy.*] -ignore_missing_imports = True \ No newline at end of file +ignore_missing_imports = True diff --git a/src/gt4sd/algorithms/__init__.py b/src/gt4sd/algorithms/__init__.py index a376aee26..4cd07a18c 100644 --- a/src/gt4sd/algorithms/__init__.py +++ b/src/gt4sd/algorithms/__init__.py @@ -50,6 +50,14 @@ CatalystGenerator, ) from .controlled_sampling.paccmann_gp.core import PaccMannGPGenerator # noqa: F401 +from .generation.diffusion.core import ( # noqa: F401 + DDIMGenerator, + DDPMGenerator, + LDMGenerator, + LDMTextToImageGenerator, + ScoreSdeGenerator, + StableDiffusionGenerator, +) from .generation.hugging_face.core import ( # noqa: F401 HuggingFaceCTRLGenerator, HuggingFaceGPT2Generator, diff --git a/src/gt4sd/algorithms/core.py b/src/gt4sd/algorithms/core.py index d93275d0d..1df168c53 100644 --- a/src/gt4sd/algorithms/core.py +++ b/src/gt4sd/algorithms/core.py @@ -25,6 +25,7 @@ from __future__ import annotations +import collections import logging import os import shutil @@ -224,23 +225,30 @@ def raise_if_none_sampled(items: set, detail: str): try: while True: generated_items = self.generate() # type:ignore - for item in generated_items: - if item in item_set: - continue - else: - try: - valid_item = self.configuration.validate_item(item) + for index, item in enumerate(generated_items): + try: + valid_item = self.configuration.validate_item(item) + # check if sample is hashable + if not isinstance(item, collections.Hashable): yield valid_item - item_set.add(item) - if len(item_set) == number_of_items: - signal.alarm(0) - return - except InvalidItem as error: - logger.debug( - f"item {item} could not be validated, " - f"raising {error.title}: {error.detail}" - ) - continue + item_set.add(str(index)) + else: + # validation for samples represented as strings + if item in item_set: + continue + else: + yield valid_item + item_set.add(item) # type:ignore + if len(item_set) == number_of_items: + signal.alarm(0) + return + except InvalidItem as error: + logger.debug( + f"item {item} could not be validated, " + f"raising {error.title}: {error.detail}" + ) + continue + # make sure we don't keep sampling more than a given number of times, # in case no new items are generated. if len(item_set) == item_set_length: diff --git a/src/gt4sd/algorithms/generation/diffusion/__init__.py b/src/gt4sd/algorithms/generation/diffusion/__init__.py new file mode 100644 index 000000000..042076d81 --- /dev/null +++ b/src/gt4sd/algorithms/generation/diffusion/__init__.py @@ -0,0 +1,45 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +"""DiffusersGenerationAlgorithm initialization.""" + +from .core import ( + DDIMGenerator, + DDPMGenerator, + DiffusersGenerationAlgorithm, + LDMGenerator, + LDMTextToImageGenerator, + ScoreSdeGenerator, + StableDiffusionGenerator, +) + +__all__ = [ + "DiffusersGenerationAlgorithm", + "DDPMGenerator", + "DDIMGenerator", + "DiffusionGenerator", + "StableDiffusionGenerator", + "ScoreSdeGenerator", + "LDMGenerator", + "LDMTextToImageGenerator", +] diff --git a/src/gt4sd/algorithms/generation/diffusion/core.py b/src/gt4sd/algorithms/generation/diffusion/core.py new file mode 100644 index 000000000..a87c393ee --- /dev/null +++ b/src/gt4sd/algorithms/generation/diffusion/core.py @@ -0,0 +1,320 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +"""HuggingFace Diffusers generation algorithm. Code and models adapted from https://github.com/huggingface/diffusers.""" + +import logging +from dataclasses import field +from typing import ClassVar, Dict, Optional, Set, TypeVar + +from ...core import ( + AlgorithmConfiguration, + GeneratorAlgorithm, + Untargeted, + get_configuration_class_with_attributes, +) +from ...registry import ApplicationsRegistry +from .implementation import MODEL_TYPES, SCHEDULER_TYPES, Generator + +logger = logging.getLogger(__name__) +logger.addHandler(logging.NullHandler()) + +T = type(None) +S = TypeVar("S", bound=str) + + +class DiffusersGenerationAlgorithm(GeneratorAlgorithm[S, T]): + def __init__( + self, configuration: AlgorithmConfiguration, target: Optional[S] = None + ): + """Diffusers generation algorithm. + + Args: + configuration: domain and application + specification, defining types and validations. + target: none for untargeted generation. + + Example: + An example for using a generative algorithm from Diffusers:: + + configuration = GeneratorConfiguration() + algorithm = DiffusersGenerationAlgorithm(configuration=configuration) + items = list(algorithm.sample(1)) + print(items) + """ + + configuration = self.validate_configuration(configuration) + # TODO there might also be a validation/check on the target input + + super().__init__( + configuration=configuration, + target=None, # type:ignore + ) + + def get_generator( + self, + configuration: AlgorithmConfiguration[S, T], + target: Optional[T], + ) -> Untargeted: + """Get the function to sample batches. + + Args: + configuration: helps to set up the application. + target: context or condition for the generation. + + Returns: + callable generating a batch of items. + """ + logger.info("ensure artifacts for the application are present.") + self.local_artifacts = configuration.ensure_artifacts() + implementation: Generator = configuration.get_conditional_generator( # type: ignore + self.local_artifacts + ) + return implementation.sample + + def validate_configuration( + self, configuration: AlgorithmConfiguration + ) -> AlgorithmConfiguration: + assert isinstance(configuration, AlgorithmConfiguration) + return configuration + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class DiffusersConfiguration(AlgorithmConfiguration[str, None]): + """Basic configuration for a diffusion algorithm.""" + + algorithm_type: ClassVar[str] = "generation" + domain: ClassVar[str] = "vision" + + modality: str = field( + default="image", + metadata=dict( + description="Model domain. Supported: 'image', 'text', 'audio', 'molecule'." + ), + ) + + model_type: str = field( + default="diffusion", + metadata=dict( + description=f"Type of the model. Supported: {', '.join(MODEL_TYPES.keys())}" + ), + ) + + scheduler_type: str = field( + default="discrete", + metadata=dict( + description=f"Type of the noise scheduler. Supported: {', '.join(SCHEDULER_TYPES.keys())}" + ), + ) + + prompt: str = field( # type: ignore + default=None, + metadata=dict(description="Prompt for text generation."), + ) + + def get_target_description(self) -> Optional[Dict[str, str]]: + """Get description of the target for generation. + + Returns: + target description, returns None in case no target is used. + """ + return None + + def get_conditional_generator(self, resources_path: str, **kwargs) -> Generator: + return Generator( + resources_path=resources_path, + model_type=self.model_type, + model_name=self.algorithm_version, + scheduler_type=self.scheduler_type, + prompt=self.prompt, + ) + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class DDPMGenerator(DiffusersConfiguration): + """DDPM - Configuration to generate using unconditional denoising diffusion models.""" + + algorithm_version: str = "google/ddpm-cifar10-32" + model_type: str = "diffusion" + scheduler_type: str = "ddpm" + modality: str = "image" + + @classmethod + def list_versions(cls) -> Set[str]: + """Get possible algorithm versions. + + Standard S3 and cache search adding the version used in the configuration. + + Returns: + viable values as :attr:`algorithm_version` for the environment. + """ + logger.warning( + "more algorithm versions can be found on https://github.com/huggingface/diffusers" + ) + return ( + get_configuration_class_with_attributes(cls) + .list_versions() + .union({cls.algorithm_version}) + ) + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class DDIMGenerator(DiffusersConfiguration): + """DDIM - Configuration to generate using a denoising diffusion implicit model.""" + + algorithm_version: str = "dboshardy/ddim-butterflies-128" + model_type: str = "diffusion_implicit" + scheduler_type: str = "ddim" + modality: str = "image" + + @classmethod + def list_versions(cls) -> Set[str]: + """Get possible algorithm versions. + + Standard S3 and cache search adding the version used in the configuration. + + Returns: + viable values as :attr:`algorithm_version` for the environment. + """ + logger.warning( + "more algorithm versions can be found on https://github.com/huggingface/diffusers" + ) + return ( + get_configuration_class_with_attributes(cls) + .list_versions() + .union({cls.algorithm_version}) + ) + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class LDMGenerator(DiffusersConfiguration): + """Unconditional Latent Diffusion Model - Configuration to generate using a latent diffusion model.""" + + algorithm_version: str = "CompVis/ldm-celebahq-256" + model_type: str = "latent_diffusion" + scheduler_type: str = "discrete" + modality: str = "image" + + @classmethod + def list_versions(cls) -> Set[str]: + """Get possible algorithm versions. + + Standard S3 and cache search adding the version used in the configuration. + + Returns: + viable values as :attr:`algorithm_version` for the environment. + """ + logger.warning( + "more algorithm versions can be found on https://github.com/huggingface/diffusers" + ) + return ( + get_configuration_class_with_attributes(cls) + .list_versions() + .union({cls.algorithm_version}) + ) + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class ScoreSdeGenerator(DiffusersConfiguration): + """Score SDE Generative Model - Configuration to generate using a score-based diffusion generative model.""" + + algorithm_version: str = "google/ncsnpp-celebahq-256" + model_type: str = "score_sde" + scheduler_type: str = "continuous" + modality: str = "image" + + @classmethod + def list_versions(cls) -> Set[str]: + """Get possible algorithm versions. + + Standard S3 and cache search adding the version used in the configuration. + + Returns: + viable values as :attr:`algorithm_version` for the environment. + """ + logger.warning( + "more algorithm versions can be found on https://github.com/huggingface/diffusers" + ) + return ( + get_configuration_class_with_attributes(cls) + .list_versions() + .union({cls.algorithm_version}) + ) + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class LDMTextToImageGenerator(DiffusersConfiguration): + """Conditional Latent Diffusion Model - Configuration for conditional text2image generation using a latent diffusion model.""" + + algorithm_version: str = "CompVis/ldm-text2im-large-256" + model_type: str = "latent_diffusion_conditional" + scheduler_type: str = "discrete" + modality: str = "token2image" + + @classmethod + def list_versions(cls) -> Set[str]: + """Get possible algorithm versions. + + Standard S3 and cache search adding the version used in the configuration. + + Returns: + viable values as :attr:`algorithm_version` for the environment. + """ + logger.warning( + "more algorithm versions can be found on https://github.com/huggingface/diffusers" + ) + return ( + get_configuration_class_with_attributes(cls) + .list_versions() + .union({cls.algorithm_version}) + ) + + +@ApplicationsRegistry.register_algorithm_application(DiffusersGenerationAlgorithm) +class StableDiffusionGenerator(DiffusersConfiguration): + """Stable Diffusion Model - Configuration for conditional text2image generation using a stable diffusion model. + You have to provide authentication credentials to use this model. + """ + + algorithm_version: str = "CompVis/stable-diffusion-v1-4" + model_type: str = "stable_diffusion" + scheduler_type: str = "discrete" + modality: str = "token2image" + + @classmethod + def list_versions(cls) -> Set[str]: + """Get possible algorithm versions. + + Standard S3 and cache search adding the version used in the configuration. + + Returns: + viable values as :attr:`algorithm_version` for the environment. + """ + logger.warning( + "more algorithm versions can be found on https://github.com/huggingface/diffusers" + ) + return ( + get_configuration_class_with_attributes(cls) + .list_versions() + .union({cls.algorithm_version}) + ) diff --git a/src/gt4sd/algorithms/generation/diffusion/implementation.py b/src/gt4sd/algorithms/generation/diffusion/implementation.py new file mode 100644 index 000000000..e52385216 --- /dev/null +++ b/src/gt4sd/algorithms/generation/diffusion/implementation.py @@ -0,0 +1,157 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +""" +Implementation details for huggingface diffusers generation algorithms. + +Parts of the implementation inspired by: https://github.com/huggingface/diffusers/blob/main/examples/train_unconditional.py. +""" + +import logging +import os +from typing import Any, List, Optional, Union + +import numpy as np +import torch +from diffusers import ( + DDIMPipeline, + DDIMScheduler, + DDPMPipeline, + DDPMScheduler, + LDMPipeline, + LDMTextToImagePipeline, + LMSDiscreteScheduler, + ScoreSdeVePipeline, + ScoreSdeVeScheduler, + StableDiffusionPipeline, +) + +from ....frameworks.torch import device_claim + +logger = logging.getLogger(__name__) +logger.addHandler(logging.NullHandler()) + + +def set_seed(seed: int = 42) -> None: + """Set seed for all random number generators. + + Args: + seed: seed to set. Defaults to 42. + """ + np.random.seed(seed) + torch.manual_seed(seed) + if torch.cuda.is_available: + torch.cuda.manual_seed_all(seed) # type:ignore + + +MODEL_TYPES = { + "diffusion": DDPMPipeline, + "diffusion_implicit": DDIMPipeline, + "latent_diffusion": LDMPipeline, + "latent_diffusion_conditional": LDMTextToImagePipeline, + "stable_diffusion": StableDiffusionPipeline, + "score_sde": ScoreSdeVePipeline, +} + +SCHEDULER_TYPES = { + "ddpm": DDPMScheduler, + "ddim": DDIMScheduler, + "discrete": LMSDiscreteScheduler, + "continuous": ScoreSdeVeScheduler, +} + + +class Generator: + """Implementation of a generator.""" + + def __init__( + self, + resources_path: str, + model_type: str, + model_name: str, + scheduler_type: str, + auth_token: bool = True, + prompt: Optional[str] = None, + device: Optional[Union[torch.device, str]] = None, + ): + """A Diffusers generation algorithm. + + Args: + resources_path: path to the cache. + model_type: type of the model. + model_name: name of the model weights/version. + scheduler_type: type of the schedule. + auth_token: authentication token for private models. + prompt: target text to use for conditional generation. + device: device where the inference + is running either as a dedicated class or a string. If not provided is inferred. + """ + self.device = device_claim(device) + self.resources_path = resources_path + self.model_type = model_type + self.model_name = model_name + self.scheduler_type = scheduler_type + self.prompt = prompt + self.auth_token = auth_token + self.load_model() + + def load_model(self) -> None: + """Load a pretrained diffusion generative model.""" + + try: + model_class = MODEL_TYPES[self.model_type] + except KeyError: + raise KeyError(f"model type: {self.model_type} not supported") + + if ( + os.path.exists(self.resources_path) + and len(os.listdir(self.resources_path)) > 0 + ): + model_name_or_path = self.resources_path + else: + model_name_or_path = self.model_name + + if self.model_type == "stable_diffusion": + self.model = model_class.from_pretrained( + model_name_or_path, + use_auth_token=self.auth_token, + ) + else: + self.model = model_class.from_pretrained(model_name_or_path) + self.model.to(self.device) + + def sample(self, number_samples: int = 1) -> List[Any]: + """Sample images with optional conditioning. + + Args: + number_samples: number of images to generate. + Returns: + generated samples. + """ + # if prompt is provided, use it + if self.prompt: + item = self.model(batch_size=number_samples, prompt=self.prompt) + else: + item = self.model(batch_size=number_samples) + item = item["sample"] + return item diff --git a/src/gt4sd/algorithms/generation/tests/test_diffusion.py b/src/gt4sd/algorithms/generation/tests/test_diffusion.py new file mode 100644 index 000000000..cbdf092c8 --- /dev/null +++ b/src/gt4sd/algorithms/generation/tests/test_diffusion.py @@ -0,0 +1,244 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +"""Diffusers tests.""" + +from typing import ClassVar, Type + +import PIL +import pytest + +from gt4sd.algorithms.core import AlgorithmConfiguration +from gt4sd.algorithms.generation.diffusion import ( + DDIMGenerator, + DDPMGenerator, + DiffusersGenerationAlgorithm, + LDMGenerator, + LDMTextToImageGenerator, + ScoreSdeGenerator, + StableDiffusionGenerator, +) +from gt4sd.algorithms.registry import ApplicationsRegistry +from gt4sd.tests.utils import GT4SDTestSettings + +test_settings = GT4SDTestSettings.get_instance() + + +def get_classvar_type(class_var): + """Extract type from ClassVar type annotation: `ClassVar[T]] -> T`.""" + return class_var.__args__[0] + + +@pytest.mark.parametrize( + "config_class, algorithm_type, domain, algorithm_name", + [ + ( + DDPMGenerator, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + ( + DDIMGenerator, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + ( + ScoreSdeGenerator, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + ( + LDMGenerator, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + ( + LDMTextToImageGenerator, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + ( + StableDiffusionGenerator, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + ], +) +def test_config_class( + config_class: Type[AlgorithmConfiguration], + algorithm_type: str, + domain: str, + algorithm_name: str, +): + assert config_class.algorithm_type == algorithm_type + assert config_class.domain == domain + assert config_class.algorithm_name == algorithm_name + + for keyword, type_annotation in config_class.__annotations__.items(): + if keyword in ("algorithm_type", "domain", "algorithm_name"): + assert type_annotation.__origin__ is ClassVar # type: ignore + assert str == get_classvar_type(type_annotation) + + +@pytest.mark.parametrize( + "config_class", + [ + (DDPMGenerator), + (DDIMGenerator), + (ScoreSdeGenerator), + (LDMGenerator), + (LDMTextToImageGenerator), + (StableDiffusionGenerator), + ], +) +def test_config_instance(config_class: Type[AlgorithmConfiguration]): + config = config_class() # type:ignore + assert config.algorithm_application == config_class.__name__ + + +@pytest.mark.parametrize( + "config_class", + [ + (DDPMGenerator), + (DDIMGenerator), + (ScoreSdeGenerator), + (LDMGenerator), + (LDMTextToImageGenerator), + (StableDiffusionGenerator), + ], +) +def test_available_versions(config_class: Type[AlgorithmConfiguration]): + versions = config_class.list_versions() + assert len(versions) > 0 + + +@pytest.mark.parametrize( + "config, algorithm", + [ + pytest.param( + DDPMGenerator, + DiffusersGenerationAlgorithm, + ), + pytest.param( + DDIMGenerator, + DiffusersGenerationAlgorithm, + marks=pytest.mark.skip(reason="slow_sampling"), + ), + pytest.param( + ScoreSdeGenerator, + DiffusersGenerationAlgorithm, + marks=pytest.mark.skip(reason="slow_sampling"), + ), + pytest.param( + LDMGenerator, + DiffusersGenerationAlgorithm, + marks=pytest.mark.skip(reason="high_memory"), + ), + ], +) +def test_generation_via_import(config, algorithm): + configuration = config() + algorithm = algorithm(configuration=configuration) + samples = list(algorithm.sample(1)) + assert len(samples) == 1 + sample = samples[0] + assert isinstance(sample, PIL.Image.Image) + + +@pytest.mark.parametrize( + "config, algorithm", + [ + pytest.param( + LDMTextToImageGenerator, + DiffusersGenerationAlgorithm, + marks=pytest.mark.skip(reason="high_memory"), + ), + pytest.param( + StableDiffusionGenerator, + DiffusersGenerationAlgorithm, + marks=pytest.mark.skip(reason="auth_token"), + ), + ], +) +def test_conditional_generation_via_import(config, algorithm): + prompt = "generative models" + configuration = config(prompt=prompt) + algorithm = algorithm(configuration=configuration) + samples = list(algorithm.sample(1)) + assert len(samples) == 1 + sample = samples[0] + assert isinstance(sample, PIL.Image.Image) + + +@pytest.mark.parametrize( + "algorithm_application, algorithm_type, domain, algorithm_name", + [ + pytest.param( + DDPMGenerator.__name__, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + ), + pytest.param( + DDIMGenerator.__name__, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + marks=pytest.mark.skip(reason="slow_sampling"), + ), + pytest.param( + ScoreSdeGenerator.__name__, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + marks=pytest.mark.skip(reason="slow_sampling"), + ), + pytest.param( + LDMGenerator.__name__, + "generation", + "vision", + DiffusersGenerationAlgorithm.__name__, + marks=pytest.mark.skip(reason="slow_sampling"), + ), + ], +) +def test_generation_via_registry( + algorithm_type, domain, algorithm_name, algorithm_application +): + algorithm = ApplicationsRegistry.get_application_instance( + target=None, + algorithm_type=algorithm_type, + domain=domain, + algorithm_name=algorithm_name, + algorithm_application=algorithm_application, + ) + samples = list(algorithm.sample(1)) + assert len(samples) == 1 + sample = samples[0] + assert isinstance(sample, PIL.Image.Image) diff --git a/src/gt4sd/domains/materials/__init__.py b/src/gt4sd/domains/materials/__init__.py index 2f528a40c..3a653b84f 100644 --- a/src/gt4sd/domains/materials/__init__.py +++ b/src/gt4sd/domains/materials/__init__.py @@ -23,7 +23,7 @@ # """Types, classes, validation, etc. for the material domain.""" -from typing import Any, Dict, List, NewType, Tuple, Union +from typing import List, NewType, Tuple, Union import numpy as np import pandas as pd diff --git a/src/gt4sd/training_pipelines/__init__.py b/src/gt4sd/training_pipelines/__init__.py index 3c742999d..c4676d9d5 100644 --- a/src/gt4sd/training_pipelines/__init__.py +++ b/src/gt4sd/training_pipelines/__init__.py @@ -30,6 +30,13 @@ import pkg_resources from ..cli.load_arguments_from_dataclass import extract_fields_from_class +from .diffusion.core import ( + DiffusionDataArguments, + DiffusionForVisionTrainingPipeline, + DiffusionModelArguments, + DiffusionSavingArguments, + DiffusionTrainingArguments, +) from .guacamol_baselines.core import GuacaMolDataArguments, GuacaMolSavingArguments from .guacamol_baselines.smiles_lstm.core import ( GuacaMolLSTMModelArguments, @@ -151,6 +158,11 @@ RegressionTransformerDataArguments, RegressionTransformerModelArguments, ), + "diffusion-trainer": ( + DiffusionTrainingArguments, + DiffusionDataArguments, + DiffusionModelArguments, + ), "gflownet-trainer": ( GFlowNetPytorchLightningTrainingArguments, GFlowNetDataArguments, @@ -168,6 +180,7 @@ "moses-organ-trainer": MosesOrganTrainingPipeline, "moses-vae-trainer": MosesVAETrainingPipeline, "regression-transformer-trainer": RegressionTransformerTrainingPipeline, + "diffusion-trainer": DiffusionForVisionTrainingPipeline, "gflownet-trainer": GFlowNetTrainingPipeline, } @@ -181,6 +194,7 @@ "moses-organ-trainer": MosesSavingArguments, "moses-vae-trainer": MosesSavingArguments, "regression-transformer-trainer": RegressionTransformerSavingArguments, + "diffusion-trainer": DiffusionSavingArguments, "gflownet-trainer": GFlowNetSavingArguments, } diff --git a/src/gt4sd/training_pipelines/diffusion/__init__.py b/src/gt4sd/training_pipelines/diffusion/__init__.py new file mode 100644 index 000000000..8af942fcc --- /dev/null +++ b/src/gt4sd/training_pipelines/diffusion/__init__.py @@ -0,0 +1,24 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +"""Diffusion training pipeline initialization.""" diff --git a/src/gt4sd/training_pipelines/diffusion/core.py b/src/gt4sd/training_pipelines/diffusion/core.py new file mode 100644 index 000000000..1f4a55d79 --- /dev/null +++ b/src/gt4sd/training_pipelines/diffusion/core.py @@ -0,0 +1,421 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +"""Diffusion training utilities. Code adapted from: https://github.com/huggingface/diffusers/blob/main/examples/unconditional_image_generation/train_unconditional.py""" + +import logging +import os +from dataclasses import dataclass, field +from typing import Any, Dict + +import torch +import torch.nn.functional as F +from accelerate import Accelerator +from datasets import load_dataset +from diffusers import DDPMPipeline, DDPMScheduler, UNet2DModel +from diffusers.optimization import get_scheduler +from diffusers.training_utils import EMAModel +from rdkit.Chem import Descriptors +from torchvision.transforms import ( + CenterCrop, + Compose, + InterpolationMode, + Normalize, + RandomHorizontalFlip, + Resize, + ToTensor, +) +from tqdm.auto import tqdm + +from ..core import TrainingPipeline, TrainingPipelineArguments + +logger = logging.getLogger(__name__) +logger.addHandler(logging.NullHandler()) + +# NOTE: This import is needed because importing torchvision before rdkit Descriptors +# can cause segmentation faults. +Descriptors + + +class DiffusionForVisionTrainingPipeline(TrainingPipeline): + """Diffusion training pipelines for image generation.""" + + def train( # type: ignore + self, + training_args: Dict[str, Any], + model_args: Dict[str, Any], + dataset_args: Dict[str, Any], + ) -> None: + """Generic training function for Diffusion models. + + Args: + training_args: training arguments passed to the configuration. + model_args: model arguments passed to the configuration. + dataset_args: dataset arguments passed to the configuration. + + Raises: + NotImplementedError: the generic trainer does not implement the pipeline. + """ + params = {**training_args, **dataset_args, **model_args} + + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != params["local_rank"]: + params["local_rank"] = env_local_rank + + logging_dir = os.path.join(params["output_dir"], params["logging_dir"]) + model_path = params["model_path"] + training_name = params["training_name"] + + accelerator = Accelerator( + mixed_precision=params["mixed_precision"], + log_with="tensorboard", + logging_dir=logging_dir, + ) + logger.info(f"Model with name {training_name} starts.") + + model_dir = os.path.join(model_path, training_name) + log_path = os.path.join(model_dir, "logs") + val_dir = os.path.join(log_path, "val_logs") + + os.makedirs(os.path.join(model_dir, "weights"), exist_ok=True) + os.makedirs(os.path.join(model_dir, "results"), exist_ok=True) + os.makedirs(log_path, exist_ok=True) + os.makedirs(val_dir, exist_ok=True) + + # unet decoder + model = UNet2DModel( + sample_size=params["resolution"], + in_channels=params["in_channels"], + out_channels=params["out_channels"], + layers_per_block=params["layers_per_block"], + block_out_channels=(128, 128, 256, 256, 512, 512), + down_block_types=( + "DownBlock2D", + "DownBlock2D", + "DownBlock2D", + "DownBlock2D", + "AttnDownBlock2D", + "DownBlock2D", + ), + up_block_types=( + "UpBlock2D", + "AttnUpBlock2D", + "UpBlock2D", + "UpBlock2D", + "UpBlock2D", + "UpBlock2D", + ), + ) + # ddpm noise schedule + noise_scheduler = DDPMScheduler( + num_train_timesteps=params["num_train_timesteps"], tensor_format="pt" + ) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=params["learning_rate"], + betas=(params["adam_beta1"], params["adam_beta2"]), + weight_decay=params["adam_weight_decay"], + eps=params["adam_epsilon"], + ) + + augmentations = Compose( + [ + Resize(params["resolution"], interpolation=InterpolationMode.BILINEAR), + CenterCrop(params["resolution"]), + RandomHorizontalFlip(), + ToTensor(), + Normalize([0.5], [0.5]), + ] + ) + # specify dataset by name or path + if params["dataset_name"] is not None: + dataset = load_dataset( + params["dataset_name"], + params["dataset_config_name"], + cache_dir=params["cache_dir"], + use_auth_token=True if params["use_auth_token"] else None, + split="train", + ) + logger.info("dataset name: " + params["dataset_name"]) + else: + if params["train_data_dir"] is None: + raise ValueError( + "You must specify either a dataset name from the hub or a train data directory." + ) + dataset = load_dataset( + "imagefolder", + data_dir=params["train_data_dir"], + cache_dir=params["cache_dir"], + split="train", + ) + logger.info("dataset path: " + params["train_data_dir"]) + + def transforms(examples): + try: + images = [ + augmentations(image.convert("RGB")) for image in examples["img"] + ] + except KeyError: + images = [ + augmentations(image.convert("RGB")) for image in examples["image"] + ] + return {"input": images} + + dataset.set_transform(transforms) # type: ignore + train_dataloader = torch.utils.data.DataLoader( # type: ignore + dataset, batch_size=params["train_batch_size"], shuffle=True # type: ignore + ) + + # specify learning rate scheduler + lr_scheduler = get_scheduler( + params["lr_scheduler"], + optimizer=optimizer, + num_warmup_steps=params["lr_warmup_steps"], + num_training_steps=(len(train_dataloader) * params["num_epochs"]) + // params["gradient_accumulation_steps"], + ) + + # preparare for distributed training if neeeded + model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + model, optimizer, train_dataloader, lr_scheduler + ) + + # initialize the ema model + ema_model = EMAModel( + model, + inv_gamma=params["ema_inv_gamma"], + power=params["ema_power"], + max_value=params["ema_max_decay"], + ) + + if accelerator.is_main_process: + run = os.path.split(__file__)[-1].split(".")[0] + accelerator.init_trackers(run) + + global_step = 0 + # start training + for epoch in range(params["num_epochs"]): + + model.train() + # progress bar visualization + progress_bar = tqdm( + total=len(train_dataloader), + disable=not accelerator.is_local_main_process, + ) + progress_bar.set_description(f"Epoch {epoch}") + + for _, batch in enumerate(train_dataloader): + + clean_images = batch["input"] + # Sample noise that we'll add to the images + noise = torch.randn(clean_images.shape).to(clean_images.device) + bsz = clean_images.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, + noise_scheduler.num_train_timesteps, + (bsz,), + device=clean_images.device, + ).long() + + # Add noise to the clean images according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_images = noise_scheduler.add_noise(clean_images, noise, timesteps) + + with accelerator.accumulate(model): + # Predict the noise residual + noise_pred = model(noisy_images, timesteps)["sample"] + loss = F.mse_loss(noise_pred, noise) + accelerator.backward(loss) + + accelerator.clip_grad_norm_(model.parameters(), 1.0) + optimizer.step() + lr_scheduler.step() + if params["use_ema"]: + ema_model.step(model) + optimizer.zero_grad() + + progress_bar.update(1) + logs = { + "loss": loss.detach().item(), + "lr": lr_scheduler.get_last_lr()[0], + "step": global_step, + } + if params["use_ema"]: + logs["ema_decay"] = ema_model.decay + progress_bar.set_postfix(**logs) + + accelerator.log(logs, step=global_step) + global_step += 1 + + if params["dummy_training"]: + break + + progress_bar.close() + # wait for all the processes to finish + accelerator.wait_for_everyone() + + # Generate sample images for visual inspection + if accelerator.is_main_process and params["is_sampling"]: + if ( + epoch % params["save_images_epochs"] == 0 + or epoch == params["num_epochs"] - 1 + ): + # inference/sampling + pipeline = DDPMPipeline( + unet=accelerator.unwrap_model( + ema_model.averaged_model if params["use_ema"] else model + ), + scheduler=noise_scheduler, + ) + + generator = torch.manual_seed(0) + # run pipeline in inference (sample random noise and denoise) + images = pipeline( + generator=generator, + batch_size=params["eval_batch_size"], + output_type="numpy", + )["sample"] + + # denormalize the images and save to tensorboard + images_processed = (images * 255).round().astype("uint8") + accelerator.trackers[0].writer.add_images( + "test_samples", + images_processed.transpose(0, 3, 1, 2), + epoch, + ) + + if ( + epoch % params["save_model_epochs"] == 0 + or epoch == params["num_epochs"] - 1 + ): + pipeline.save_pretrained(params["output_dir"]) + accelerator.wait_for_everyone() + + if params["dummy_training"]: + break + + accelerator.end_training() + logger.info("Training done, shutting down.") + + +@dataclass +class DiffusionDataArguments(TrainingPipelineArguments): + """Data arguments related to diffusion trainer.""" + + __name__ = "dataset_args" + + dataset_name: str = field(default="", metadata={"help": "Dataset name."}) + dataset_config_name: str = field( + default="", metadata={"help": "Dataset config name."} + ) + train_data_dir: str = field(default="", metadata={"help": "Train data directory."}) + resolution: int = field(default=64, metadata={"help": "Resolution."}) + train_batch_size: int = field(default=16, metadata={"help": "Train batch size."}) + eval_batch_size: int = field(default=16, metadata={"help": "Eval batch size."}) + num_epochs: int = field(default=100, metadata={"help": "Number of epochs."}) + + +@dataclass +class DiffusionModelArguments(TrainingPipelineArguments): + """Model arguments related to Diffusion trainer.""" + + __name__ = "model_args" + + model_path: str = field(metadata={"help": "Path to the model file."}) + training_name: str = field(metadata={"help": "Name of the training run."}) + + num_train_timesteps: int = field( + default=1000, metadata={"help": "Number of noise steps."} + ) + learning_rate: float = field(default=1e-4, metadata={"help": "Learning rate."}) + lr_scheduler: str = field( + default="cosine", metadata={"help": "Learning rate scheduler."} + ) + lr_warm_up_steps: int = field( + default=500, metadata={"help": "Learning rate warm up steps."} + ) + adam_beta1: float = field(default=0.95, metadata={"help": "Adam beta1."}) + adam_beta2: float = field(default=0.999, metadata={"help": "Adam beta2."}) + adam_weight_decay: float = field( + default=1e-6, metadata={"help": "Adam weights decay."} + ) + adam_epsilon: float = field(default=1e-8, metadata={"help": "Adam eps."}) + gradient_accumulation_steps: int = field( + default=1, metadata={"help": "Gradient accumulation steps."} + ) + in_channels: int = field(default=3, metadata={"help": "Input channels."}) + out_channels: int = field(default=3, metadata={"help": "Output channels."}) + layers_per_block: int = field(default=2, metadata={"help": "Layers per block."}) + + +@dataclass +class DiffusionTrainingArguments(TrainingPipelineArguments): + """Training arguments related to Diffusion trainer.""" + + __name__ = "training_args" + + local_rank: int = field(default=-1, metadata={"help": "Local rank of the process."}) + output_dir: str = field( + default="ddpm-cifar10-32", metadata={"help": "Output directory."} + ) + logging_dir: str = field(default="logs/", metadata={"help": "Logging directory."}) + overwrite_output_dir: bool = field( + default=False, metadata={"help": "Overwrite output directory."} + ) + cache_dir: str = field(default=".cache/", metadata={"help": "Cache directory."}) + save_images_epochs: int = field( + default=10, metadata={"help": "Save images every n epochs."} + ) + save_model_epochs: int = field( + default=10, metadata={"help": "Save model every n epochs."} + ) + use_ema: bool = field(default=True, metadata={"help": "Use ema."}) + ema_inv_gamma: float = field(default=1.0, metadata={"help": "Ema inverse gamma."}) + ema_power: float = field(default=0.75, metadata={"help": "Ema power."}) + ema_max_decay: float = field(default=0.9999, metadata={"help": "Ema max delay."}) + mixed_precision: str = field( + default="no", + metadata={"help": "Mixed precision. Choose from 'no', 'fp16', 'bf16'."}, + ) + use_auth_token: bool = field( + default=False, + metadata={ + "help": "Use the token generated when using huggingface-hub (necessary to use this script with private models)." + }, + ) + dummy_training: bool = field( + default=False, + metadata={"help": "Run dummy training to test the pipeline."}, + ) + is_sampling: bool = field( + default=True, + metadata={"help": "Run sampling."}, + ) + + +@dataclass +class DiffusionSavingArguments(TrainingPipelineArguments): + """Saving arguments related to Diffusion trainer.""" + + __name__ = "saving_args" diff --git a/src/gt4sd/training_pipelines/tests/test_training_diffusion.py b/src/gt4sd/training_pipelines/tests/test_training_diffusion.py new file mode 100644 index 000000000..7747d4381 --- /dev/null +++ b/src/gt4sd/training_pipelines/tests/test_training_diffusion.py @@ -0,0 +1,118 @@ +# +# MIT License +# +# Copyright (c) 2022 GT4SD team +# +# 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. +# +"""Diffusion trainer unit tests.""" + +import os +import shutil +import tempfile +from typing import Any, Dict, cast + +import pkg_resources + +from gt4sd.training_pipelines import ( + TRAINING_PIPELINE_MAPPING, + DiffusionForVisionTrainingPipeline, +) + +TEST_DATA_DIRECTORY = pkg_resources.resource_filename( + "gt4sd", + "training_pipelines/tests/", +) + + +def _create_training_output_filepaths(directory: str) -> Dict[str, str]: + """Create output filepath from directory. + + Args: + directory: output directory. + + Returns: + a dictionary containing the output files. + """ + return { + "config_save": os.path.join(directory, "config.pt"), + } + + +template_config = { + "model_args": { + "model_path": "", + "training_name": "ddpm", + "num_train_timesteps": 1000, + "learning_rate": 1e-4, + "lr_scheduler": "cosine", + "lr_warmup_steps": 500, + "adam_beta1": 0.95, + "adam_beta2": 0.999, + "adam_weight_decay": 1e-6, + "adam_epsilon": 1e-8, + "gradient_accumulation_steps": 1, + "in_channels": 3, + "out_channels": 3, + "layers_per_block": 2, + }, + "training_args": { + "local_rank": -1, + "output_dir": "./outputs/", + "save_images_epochs": 10, + "save_model_epochs": 10, + "mixed_precision": "no", + "logging_dir": "./logs/", + "cache_dir": "./cifar10/", + "use_auth_token": False, + "ema_inv_gamma": 1.0, + "ema_power": 0.75, + "ema_max_decay": 0.9999, + "use_ema": True, + "dummy_training": True, + "is_sampling": False, + }, + "dataset_args": { + "dataset_name": "cifar10", + "dataset_config_name": None, + "resolution": 32, + "train_batch_size": 16, + "eval_batch_size": 16, + "num_epochs": 1, + }, +} + + +def test_train(): + + pipeline = TRAINING_PIPELINE_MAPPING.get("diffusion-trainer") + + assert pipeline is not None + + TEMPORARY_DIRECTORY = tempfile.mkdtemp() + + test_pipeline = cast(DiffusionForVisionTrainingPipeline, pipeline()) + + config: Dict[str, Any] = template_config.copy() + for key, value in _create_training_output_filepaths(TEMPORARY_DIRECTORY).items(): + config["training_args"][key] = value + + test_pipeline.train(**config) + + shutil.rmtree(TEMPORARY_DIRECTORY)