Delete wdm-3d-initial

wdm-3d-initial/.gitignore

@@ -1,167 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# Defined folders
-./data/
-./results/
-./runs/
-
-*.npy
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/

wdm-3d-initial/DWT_IDWT/DWT_IDWT_Functions.py

@@ -1,208 +0,0 @@
-# Copyright (c) 2019, Adobe Inc. All rights reserved.
-#
-# This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
-# 4.0 International Public License. To view a copy of this license, visit
-# https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.
-
-"""
-自定义pytorch函数，实现一维、二维、三维张量的DWT和IDWT，未考虑边界延拓
-只有当图像行列数都是偶数，且重构滤波器组低频分量长度为2时，才能精确重构，否则在边界处有误差。
-"""
-import torch
-from torch.autograd import Function
-
-
-class DWTFunction_1D(Function):
-    @staticmethod
-    def forward(ctx, input, matrix_Low, matrix_High):
-        ctx.save_for_backward(matrix_Low, matrix_High)
-        L = torch.matmul(input, matrix_Low.t())
-        H = torch.matmul(input, matrix_High.t())
-        return L, H
-
-    @staticmethod
-    def backward(ctx, grad_L, grad_H):
-        matrix_L, matrix_H = ctx.saved_variables
-        grad_input = torch.add(torch.matmul(
-            grad_L, matrix_L), torch.matmul(grad_H, matrix_H))
-        return grad_input, None, None
-
-
-class IDWTFunction_1D(Function):
-    @staticmethod
-    def forward(ctx, input_L, input_H, matrix_L, matrix_H):
-        ctx.save_for_backward(matrix_L, matrix_H)
-        output = torch.add(torch.matmul(input_L, matrix_L),
-                           torch.matmul(input_H, matrix_H))
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        matrix_L, matrix_H = ctx.saved_variables
-        grad_L = torch.matmul(grad_output, matrix_L.t())
-        grad_H = torch.matmul(grad_output, matrix_H.t())
-        return grad_L, grad_H, None, None
-
-
-class DWTFunction_2D(Function):
-    @staticmethod
-    def forward(ctx, input, matrix_Low_0, matrix_Low_1, matrix_High_0, matrix_High_1):
-        ctx.save_for_backward(matrix_Low_0, matrix_Low_1,
-                              matrix_High_0, matrix_High_1)
-        L = torch.matmul(matrix_Low_0, input)
-        H = torch.matmul(matrix_High_0, input)
-        LL = torch.matmul(L, matrix_Low_1)
-        LH = torch.matmul(L, matrix_High_1)
-        HL = torch.matmul(H, matrix_Low_1)
-        HH = torch.matmul(H, matrix_High_1)
-        return LL, LH, HL, HH
-
-    @staticmethod
-    def backward(ctx, grad_LL, grad_LH, grad_HL, grad_HH):
-        matrix_Low_0, matrix_Low_1, matrix_High_0, matrix_High_1 = ctx.saved_variables
-        grad_L = torch.add(torch.matmul(grad_LL, matrix_Low_1.t()),
-                           torch.matmul(grad_LH, matrix_High_1.t()))
-        grad_H = torch.add(torch.matmul(grad_HL, matrix_Low_1.t()),
-                           torch.matmul(grad_HH, matrix_High_1.t()))
-        grad_input = torch.add(torch.matmul(
-            matrix_Low_0.t(), grad_L), torch.matmul(matrix_High_0.t(), grad_H))
-        return grad_input, None, None, None, None
-
-
-class DWTFunction_2D_tiny(Function):
-    @staticmethod
-    def forward(ctx, input, matrix_Low_0, matrix_Low_1, matrix_High_0, matrix_High_1):
-        ctx.save_for_backward(matrix_Low_0, matrix_Low_1,
-                              matrix_High_0, matrix_High_1)
-        L = torch.matmul(matrix_Low_0, input)
-        LL = torch.matmul(L, matrix_Low_1)
-        return LL
-
-    @staticmethod
-    def backward(ctx, grad_LL):
-        matrix_Low_0, matrix_Low_1, matrix_High_0, matrix_High_1 = ctx.saved_variables
-        grad_L = torch.matmul(grad_LL, matrix_Low_1.t())
-        grad_input = torch.matmul(matrix_Low_0.t(), grad_L)
-        return grad_input, None, None, None, None
-
-
-class IDWTFunction_2D(Function):
-    @staticmethod
-    def forward(ctx, input_LL, input_LH, input_HL, input_HH,
-                matrix_Low_0, matrix_Low_1, matrix_High_0, matrix_High_1):
-        ctx.save_for_backward(matrix_Low_0, matrix_Low_1,
-                              matrix_High_0, matrix_High_1)
-        L = torch.add(torch.matmul(input_LL, matrix_Low_1.t()),
-                      torch.matmul(input_LH, matrix_High_1.t()))
-        H = torch.add(torch.matmul(input_HL, matrix_Low_1.t()),
-                      torch.matmul(input_HH, matrix_High_1.t()))
-        output = torch.add(torch.matmul(matrix_Low_0.t(), L),
-                           torch.matmul(matrix_High_0.t(), H))
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        matrix_Low_0, matrix_Low_1, matrix_High_0, matrix_High_1 = ctx.saved_variables
-        grad_L = torch.matmul(matrix_Low_0, grad_output)
-        grad_H = torch.matmul(matrix_High_0, grad_output)
-        grad_LL = torch.matmul(grad_L, matrix_Low_1)
-        grad_LH = torch.matmul(grad_L, matrix_High_1)
-        grad_HL = torch.matmul(grad_H, matrix_Low_1)
-        grad_HH = torch.matmul(grad_H, matrix_High_1)
-        return grad_LL, grad_LH, grad_HL, grad_HH, None, None, None, None
-
-
-class DWTFunction_3D(Function):
-    @staticmethod
-    def forward(ctx, input,
-                matrix_Low_0, matrix_Low_1, matrix_Low_2,
-                matrix_High_0, matrix_High_1, matrix_High_2):
-        ctx.save_for_backward(matrix_Low_0, matrix_Low_1, matrix_Low_2,
-                              matrix_High_0, matrix_High_1, matrix_High_2)
-        L = torch.matmul(matrix_Low_0, input)
-        H = torch.matmul(matrix_High_0, input)
-        LL = torch.matmul(L, matrix_Low_1).transpose(dim0=2, dim1=3)
-        LH = torch.matmul(L, matrix_High_1).transpose(dim0=2, dim1=3)
-        HL = torch.matmul(H, matrix_Low_1).transpose(dim0=2, dim1=3)
-        HH = torch.matmul(H, matrix_High_1).transpose(dim0=2, dim1=3)
-        LLL = torch.matmul(matrix_Low_2, LL).transpose(dim0=2, dim1=3)
-        LLH = torch.matmul(matrix_Low_2, LH).transpose(dim0=2, dim1=3)
-        LHL = torch.matmul(matrix_Low_2, HL).transpose(dim0=2, dim1=3)
-        LHH = torch.matmul(matrix_Low_2, HH).transpose(dim0=2, dim1=3)
-        HLL = torch.matmul(matrix_High_2, LL).transpose(dim0=2, dim1=3)
-        HLH = torch.matmul(matrix_High_2, LH).transpose(dim0=2, dim1=3)
-        HHL = torch.matmul(matrix_High_2, HL).transpose(dim0=2, dim1=3)
-        HHH = torch.matmul(matrix_High_2, HH).transpose(dim0=2, dim1=3)
-        return LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH
-
-    @staticmethod
-    def backward(ctx, grad_LLL, grad_LLH, grad_LHL, grad_LHH,
-                 grad_HLL, grad_HLH, grad_HHL, grad_HHH):
-        matrix_Low_0, matrix_Low_1, matrix_Low_2, matrix_High_0, matrix_High_1, matrix_High_2 = ctx.saved_variables
-        grad_LL = torch.add(torch.matmul(matrix_Low_2.t(), grad_LLL.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), grad_HLL.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        grad_LH = torch.add(torch.matmul(matrix_Low_2.t(), grad_LLH.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), grad_HLH.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        grad_HL = torch.add(torch.matmul(matrix_Low_2.t(), grad_LHL.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), grad_HHL.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        grad_HH = torch.add(torch.matmul(matrix_Low_2.t(), grad_LHH.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), grad_HHH.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        grad_L = torch.add(torch.matmul(grad_LL, matrix_Low_1.t()),
-                           torch.matmul(grad_LH, matrix_High_1.t()))
-        grad_H = torch.add(torch.matmul(grad_HL, matrix_Low_1.t()),
-                           torch.matmul(grad_HH, matrix_High_1.t()))
-        grad_input = torch.add(torch.matmul(
-            matrix_Low_0.t(), grad_L), torch.matmul(matrix_High_0.t(), grad_H))
-        return grad_input, None, None, None, None, None, None, None, None
-
-
-class IDWTFunction_3D(Function):
-    @staticmethod
-    def forward(ctx, input_LLL, input_LLH, input_LHL, input_LHH,
-                input_HLL, input_HLH, input_HHL, input_HHH,
-                matrix_Low_0, matrix_Low_1, matrix_Low_2,
-                matrix_High_0, matrix_High_1, matrix_High_2):
-        ctx.save_for_backward(matrix_Low_0, matrix_Low_1, matrix_Low_2,
-                              matrix_High_0, matrix_High_1, matrix_High_2)
-        input_LL = torch.add(torch.matmul(matrix_Low_2.t(), input_LLL.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), input_HLL.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        input_LH = torch.add(torch.matmul(matrix_Low_2.t(), input_LLH.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), input_HLH.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        input_HL = torch.add(torch.matmul(matrix_Low_2.t(), input_LHL.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), input_HHL.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        input_HH = torch.add(torch.matmul(matrix_Low_2.t(), input_LHH.transpose(dim0=2, dim1=3)), torch.matmul(
-            matrix_High_2.t(), input_HHH.transpose(dim0=2, dim1=3))).transpose(dim0=2, dim1=3)
-        input_L = torch.add(torch.matmul(input_LL, matrix_Low_1.t()),
-                            torch.matmul(input_LH, matrix_High_1.t()))
-        input_H = torch.add(torch.matmul(input_HL, matrix_Low_1.t()),
-                            torch.matmul(input_HH, matrix_High_1.t()))
-        output = torch.add(torch.matmul(matrix_Low_0.t(), input_L),
-                           torch.matmul(matrix_High_0.t(), input_H))
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        matrix_Low_0, matrix_Low_1, matrix_Low_2, matrix_High_0, matrix_High_1, matrix_High_2 = ctx.saved_variables
-        grad_L = torch.matmul(matrix_Low_0, grad_output)
-        grad_H = torch.matmul(matrix_High_0, grad_output)
-        grad_LL = torch.matmul(grad_L, matrix_Low_1).transpose(dim0=2, dim1=3)
-        grad_LH = torch.matmul(grad_L, matrix_High_1).transpose(dim0=2, dim1=3)
-        grad_HL = torch.matmul(grad_H, matrix_Low_1).transpose(dim0=2, dim1=3)
-        grad_HH = torch.matmul(grad_H, matrix_High_1).transpose(dim0=2, dim1=3)
-        grad_LLL = torch.matmul(
-            matrix_Low_2, grad_LL).transpose(dim0=2, dim1=3)
-        grad_LLH = torch.matmul(
-            matrix_Low_2, grad_LH).transpose(dim0=2, dim1=3)
-        grad_LHL = torch.matmul(
-            matrix_Low_2, grad_HL).transpose(dim0=2, dim1=3)
-        grad_LHH = torch.matmul(
-            matrix_Low_2, grad_HH).transpose(dim0=2, dim1=3)
-        grad_HLL = torch.matmul(
-            matrix_High_2, grad_LL).transpose(dim0=2, dim1=3)
-        grad_HLH = torch.matmul(
-            matrix_High_2, grad_LH).transpose(dim0=2, dim1=3)
-        grad_HHL = torch.matmul(
-            matrix_High_2, grad_HL).transpose(dim0=2, dim1=3)
-        grad_HHH = torch.matmul(
-            matrix_High_2, grad_HH).transpose(dim0=2, dim1=3)
-        return grad_LLL, grad_LLH, grad_LHL, grad_LHH, grad_HLL, grad_HLH, grad_HHL, grad_HHH, None, None, None, None, None, None

wdm-3d-initial/DWT_IDWT/DWT_IDWT_layer.py

@@ -1,666 +0,0 @@
-"""
-自定义 pytorch 层，实现一维、二维、三维张量的 DWT 和 IDWT，未考虑边界延拓
-只有当图像行列数都是偶数，且重构滤波器组低频分量长度为 2 时，才能精确重构，否则在边界处有误差。
-"""
-import math
-
-import numpy as np
-import pywt
-import torch
-from torch.nn import Module
-
-from .DWT_IDWT_Functions import DWTFunction_1D, IDWTFunction_1D, \
-    DWTFunction_2D_tiny, DWTFunction_2D, IDWTFunction_2D, \
-    DWTFunction_3D, IDWTFunction_3D
-
-
-__all__ = ['DWT_1D', 'IDWT_1D', 'DWT_2D',
-           'IDWT_2D', 'DWT_3D', 'IDWT_3D', 'DWT_2D_tiny']
-
-
-class DWT_1D(Module):
-    """
-    input: the 1D data to be decomposed -- (N, C, Length)
-    output: lfc -- (N, C, Length/2)
-            hfc -- (N, C, Length/2)
-    """
-
-    def __init__(self, wavename):
-        """
-        1D discrete wavelet transform (DWT) for sequence decomposition
-        用于序列分解的一维离散小波变换 DWT
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(DWT_1D, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.rec_lo
-        self.band_high = wavelet.rec_hi
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        生成变换矩阵
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = self.input_height
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_h = matrix_h[:, (self.band_length_half - 1):end]
-        matrix_g = matrix_g[:, (self.band_length_half - 1):end]
-        if torch.cuda.is_available():
-            self.matrix_low = torch.Tensor(matrix_h).cuda()
-            self.matrix_high = torch.Tensor(matrix_g).cuda()
-        else:
-            self.matrix_low = torch.Tensor(matrix_h)
-            self.matrix_high = torch.Tensor(matrix_g)
-
-    def forward(self, input):
-        """
-        input_low_frequency_component = \mathcal{L} * input
-        input_high_frequency_component = \mathcal{H} * input
-        :param input: the data to be decomposed
-        :return: the low-frequency and high-frequency components of the input data
-        """
-        assert len(input.size()) == 3
-        self.input_height = input.size()[-1]
-        self.get_matrix()
-        return DWTFunction_1D.apply(input, self.matrix_low, self.matrix_high)
-
-
-class IDWT_1D(Module):
-    """
-    input:  lfc -- (N, C, Length/2)
-            hfc -- (N, C, Length/2)
-    output: the original data -- (N, C, Length)
-    """
-
-    def __init__(self, wavename):
-        """
-        1D inverse DWT (IDWT) for sequence reconstruction
-        用于序列重构的一维离散小波逆变换 IDWT
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(IDWT_1D, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.dec_lo
-        self.band_high = wavelet.dec_hi
-        self.band_low.reverse()
-        self.band_high.reverse()
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        生成变换矩阵
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = self.input_height
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_h = matrix_h[:, (self.band_length_half - 1):end]
-        matrix_g = matrix_g[:, (self.band_length_half - 1):end]
-        if torch.cuda.is_available():
-            self.matrix_low = torch.Tensor(matrix_h).cuda()
-            self.matrix_high = torch.Tensor(matrix_g).cuda()
-        else:
-            self.matrix_low = torch.Tensor(matrix_h)
-            self.matrix_high = torch.Tensor(matrix_g)
-
-    def forward(self, L, H):
-        """
-        :param L: the low-frequency component of the original data
-        :param H: the high-frequency component of the original data
-        :return: the original data
-        """
-        assert len(L.size()) == len(H.size()) == 3
-        self.input_height = L.size()[-1] + H.size()[-1]
-        self.get_matrix()
-        return IDWTFunction_1D.apply(L, H, self.matrix_low, self.matrix_high)
-
-
-class DWT_2D_tiny(Module):
-    """
-    input: the 2D data to be decomposed -- (N, C, H, W)
-    output -- lfc: (N, C, H/2, W/2)
-              #hfc_lh: (N, C, H/2, W/2)
-              #hfc_hl: (N, C, H/2, W/2)
-              #hfc_hh: (N, C, H/2, W/2)
-    DWT_2D_tiny only outputs the low-frequency component, which is used in WaveCNet;
-    the all four components could be get using DWT_2D, which is used in WaveUNet.
-    """
-
-    def __init__(self, wavename):
-        """
-        2D discrete wavelet transform (DWT) for 2D image decomposition
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(DWT_2D_tiny, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.rec_lo
-        self.band_high = wavelet.rec_hi
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        生成变换矩阵
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = np.max((self.input_height, self.input_width))
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        matrix_h_0 = matrix_h[0:(math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_h_1 = matrix_h[0:(math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_g_0 = matrix_g[0:(self.input_height - math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_g_1 = matrix_g[0:(self.input_width - math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-
-        matrix_h_0 = matrix_h_0[:, (self.band_length_half - 1):end]
-        matrix_h_1 = matrix_h_1[:, (self.band_length_half - 1):end]
-        matrix_h_1 = np.transpose(matrix_h_1)
-        matrix_g_0 = matrix_g_0[:, (self.band_length_half - 1):end]
-        matrix_g_1 = matrix_g_1[:, (self.band_length_half - 1):end]
-        matrix_g_1 = np.transpose(matrix_g_1)
-
-        if torch.cuda.is_available():
-            self.matrix_low_0 = torch.Tensor(matrix_h_0).cuda()
-            self.matrix_low_1 = torch.Tensor(matrix_h_1).cuda()
-            self.matrix_high_0 = torch.Tensor(matrix_g_0).cuda()
-            self.matrix_high_1 = torch.Tensor(matrix_g_1).cuda()
-        else:
-            self.matrix_low_0 = torch.Tensor(matrix_h_0)
-            self.matrix_low_1 = torch.Tensor(matrix_h_1)
-            self.matrix_high_0 = torch.Tensor(matrix_g_0)
-            self.matrix_high_1 = torch.Tensor(matrix_g_1)
-
-    def forward(self, input):
-        """
-        input_lfc = \mathcal{L} * input * \mathcal{L}^T
-        #input_hfc_lh = \mathcal{H} * input * \mathcal{L}^T
-        #input_hfc_hl = \mathcal{L} * input * \mathcal{H}^T
-        #input_hfc_hh = \mathcal{H} * input * \mathcal{H}^T
-        :param input: the 2D data to be decomposed
-        :return: the low-frequency component of the input 2D data
-        """
-        assert len(input.size()) == 4
-        self.input_height = input.size()[-2]
-        self.input_width = input.size()[-1]
-        self.get_matrix()
-        return DWTFunction_2D_tiny.apply(input, self.matrix_low_0, self.matrix_low_1, self.matrix_high_0, self.matrix_high_1)
-
-
-class DWT_2D(Module):
-    """
-    input: the 2D data to be decomposed -- (N, C, H, W)
-    output -- lfc: (N, C, H/2, W/2)
-              hfc_lh: (N, C, H/2, W/2)
-              hfc_hl: (N, C, H/2, W/2)
-              hfc_hh: (N, C, H/2, W/2)
-    """
-
-    def __init__(self, wavename):
-        """
-        2D discrete wavelet transform (DWT) for 2D image decomposition
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(DWT_2D, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.rec_lo
-        self.band_high = wavelet.rec_hi
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        生成变换矩阵
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = np.max((self.input_height, self.input_width))
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        matrix_h_0 = matrix_h[0:(math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_h_1 = matrix_h[0:(math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_g_0 = matrix_g[0:(self.input_height - math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_g_1 = matrix_g[0:(self.input_width - math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-
-        matrix_h_0 = matrix_h_0[:, (self.band_length_half - 1):end]
-        matrix_h_1 = matrix_h_1[:, (self.band_length_half - 1):end]
-        matrix_h_1 = np.transpose(matrix_h_1)
-        matrix_g_0 = matrix_g_0[:, (self.band_length_half - 1):end]
-        matrix_g_1 = matrix_g_1[:, (self.band_length_half - 1):end]
-        matrix_g_1 = np.transpose(matrix_g_1)
-
-        if torch.cuda.is_available():
-            self.matrix_low_0 = torch.Tensor(matrix_h_0).cuda()
-            self.matrix_low_1 = torch.Tensor(matrix_h_1).cuda()
-            self.matrix_high_0 = torch.Tensor(matrix_g_0).cuda()
-            self.matrix_high_1 = torch.Tensor(matrix_g_1).cuda()
-        else:
-            self.matrix_low_0 = torch.Tensor(matrix_h_0)
-            self.matrix_low_1 = torch.Tensor(matrix_h_1)
-            self.matrix_high_0 = torch.Tensor(matrix_g_0)
-            self.matrix_high_1 = torch.Tensor(matrix_g_1)
-
-    def forward(self, input):
-        """
-        input_lfc = \mathcal{L} * input * \mathcal{L}^T
-        input_hfc_lh = \mathcal{H} * input * \mathcal{L}^T
-        input_hfc_hl = \mathcal{L} * input * \mathcal{H}^T
-        input_hfc_hh = \mathcal{H} * input * \mathcal{H}^T
-        :param input: the 2D data to be decomposed
-        :return: the low-frequency and high-frequency components of the input 2D data
-        """
-        assert len(input.size()) == 4
-        self.input_height = input.size()[-2]
-        self.input_width = input.size()[-1]
-        self.get_matrix()
-        return DWTFunction_2D.apply(input, self.matrix_low_0, self.matrix_low_1, self.matrix_high_0, self.matrix_high_1)
-
-
-class IDWT_2D(Module):
-    """
-    input:  lfc -- (N, C, H/2, W/2)
-            hfc_lh -- (N, C, H/2, W/2)
-            hfc_hl -- (N, C, H/2, W/2)
-            hfc_hh -- (N, C, H/2, W/2)
-    output: the original 2D data -- (N, C, H, W)
-    """
-
-    def __init__(self, wavename):
-        """
-        2D inverse DWT (IDWT) for 2D image reconstruction
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(IDWT_2D, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.dec_lo
-        self.band_low.reverse()
-        self.band_high = wavelet.dec_hi
-        self.band_high.reverse()
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        生成变换矩阵
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = np.max((self.input_height, self.input_width))
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        matrix_h_0 = matrix_h[0:(math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_h_1 = matrix_h[0:(math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_g_0 = matrix_g[0:(self.input_height - math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_g_1 = matrix_g[0:(self.input_width - math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-
-        matrix_h_0 = matrix_h_0[:, (self.band_length_half - 1):end]
-        matrix_h_1 = matrix_h_1[:, (self.band_length_half - 1):end]
-        matrix_h_1 = np.transpose(matrix_h_1)
-        matrix_g_0 = matrix_g_0[:, (self.band_length_half - 1):end]
-        matrix_g_1 = matrix_g_1[:, (self.band_length_half - 1):end]
-        matrix_g_1 = np.transpose(matrix_g_1)
-        if torch.cuda.is_available():
-            self.matrix_low_0 = torch.Tensor(matrix_h_0).cuda()
-            self.matrix_low_1 = torch.Tensor(matrix_h_1).cuda()
-            self.matrix_high_0 = torch.Tensor(matrix_g_0).cuda()
-            self.matrix_high_1 = torch.Tensor(matrix_g_1).cuda()
-        else:
-            self.matrix_low_0 = torch.Tensor(matrix_h_0)
-            self.matrix_low_1 = torch.Tensor(matrix_h_1)
-            self.matrix_high_0 = torch.Tensor(matrix_g_0)
-            self.matrix_high_1 = torch.Tensor(matrix_g_1)
-
-    def forward(self, LL, LH, HL, HH):
-        """
-        recontructing the original 2D data
-        the original 2D data = \mathcal{L}^T * lfc * \mathcal{L}
-                             + \mathcal{H}^T * hfc_lh * \mathcal{L}
-                             + \mathcal{L}^T * hfc_hl * \mathcal{H}
-                             + \mathcal{H}^T * hfc_hh * \mathcal{H}
-        :param LL: the low-frequency component
-        :param LH: the high-frequency component, hfc_lh
-        :param HL: the high-frequency component, hfc_hl
-        :param HH: the high-frequency component, hfc_hh
-        :return: the original 2D data
-        """
-        assert len(LL.size()) == len(LH.size()) == len(
-            HL.size()) == len(HH.size()) == 4
-        self.input_height = LL.size()[-2] + HH.size()[-2]
-        self.input_width = LL.size()[-1] + HH.size()[-1]
-        self.get_matrix()
-        return IDWTFunction_2D.apply(LL, LH, HL, HH, self.matrix_low_0, self.matrix_low_1, self.matrix_high_0, self.matrix_high_1)
-
-
-class DWT_3D(Module):
-    """
-    input: the 3D data to be decomposed -- (N, C, D, H, W)
-    output: lfc -- (N, C, D/2, H/2, W/2)
-            hfc_llh -- (N, C, D/2, H/2, W/2)
-            hfc_lhl -- (N, C, D/2, H/2, W/2)
-            hfc_lhh -- (N, C, D/2, H/2, W/2)
-            hfc_hll -- (N, C, D/2, H/2, W/2)
-            hfc_hlh -- (N, C, D/2, H/2, W/2)
-            hfc_hhl -- (N, C, D/2, H/2, W/2)
-            hfc_hhh -- (N, C, D/2, H/2, W/2)
-    """
-
-    def __init__(self, wavename):
-        """
-        3D discrete wavelet transform (DWT) for 3D data decomposition
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(DWT_3D, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.rec_lo
-        self.band_high = wavelet.rec_hi
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        生成变换矩阵
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = np.max((self.input_height, self.input_width))
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        matrix_h_0 = matrix_h[0:(math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_h_1 = matrix_h[0:(math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-        matrix_h_2 = matrix_h[0:(math.floor(
-            self.input_depth / 2)), 0:(self.input_depth + self.band_length - 2)]
-
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_g_0 = matrix_g[0:(self.input_height - math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_g_1 = matrix_g[0:(self.input_width - math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-        matrix_g_2 = matrix_g[0:(self.input_depth - math.floor(
-            self.input_depth / 2)), 0:(self.input_depth + self.band_length - 2)]
-
-        matrix_h_0 = matrix_h_0[:, (self.band_length_half - 1):end]
-        matrix_h_1 = matrix_h_1[:, (self.band_length_half - 1):end]
-        matrix_h_1 = np.transpose(matrix_h_1)
-        matrix_h_2 = matrix_h_2[:, (self.band_length_half - 1):end]
-
-        matrix_g_0 = matrix_g_0[:, (self.band_length_half - 1):end]
-        matrix_g_1 = matrix_g_1[:, (self.band_length_half - 1):end]
-        matrix_g_1 = np.transpose(matrix_g_1)
-        matrix_g_2 = matrix_g_2[:, (self.band_length_half - 1):end]
-        if torch.cuda.is_available():
-            self.matrix_low_0 = torch.Tensor(matrix_h_0).cuda()
-            self.matrix_low_1 = torch.Tensor(matrix_h_1).cuda()
-            self.matrix_low_2 = torch.Tensor(matrix_h_2).cuda()
-            self.matrix_high_0 = torch.Tensor(matrix_g_0).cuda()
-            self.matrix_high_1 = torch.Tensor(matrix_g_1).cuda()
-            self.matrix_high_2 = torch.Tensor(matrix_g_2).cuda()
-        else:
-            self.matrix_low_0 = torch.Tensor(matrix_h_0)
-            self.matrix_low_1 = torch.Tensor(matrix_h_1)
-            self.matrix_low_2 = torch.Tensor(matrix_h_2)
-            self.matrix_high_0 = torch.Tensor(matrix_g_0)
-            self.matrix_high_1 = torch.Tensor(matrix_g_1)
-            self.matrix_high_2 = torch.Tensor(matrix_g_2)
-
-    def forward(self, input):
-        """
-        :param input: the 3D data to be decomposed
-        :return: the eight components of the input data, one low-frequency and seven high-frequency components
-        """
-        assert len(input.size()) == 5
-        self.input_depth = input.size()[-3]
-        self.input_height = input.size()[-2]
-        self.input_width = input.size()[-1]
-        self.get_matrix()
-        return DWTFunction_3D.apply(input, self.matrix_low_0, self.matrix_low_1, self.matrix_low_2,
-                                    self.matrix_high_0, self.matrix_high_1, self.matrix_high_2)
-
-
-class IDWT_3D(Module):
-    """
-    input:  lfc -- (N, C, D/2, H/2, W/2)
-            hfc_llh -- (N, C, D/2, H/2, W/2)
-            hfc_lhl -- (N, C, D/2, H/2, W/2)
-            hfc_lhh -- (N, C, D/2, H/2, W/2)
-            hfc_hll -- (N, C, D/2, H/2, W/2)
-            hfc_hlh -- (N, C, D/2, H/2, W/2)
-            hfc_hhl -- (N, C, D/2, H/2, W/2)
-            hfc_hhh -- (N, C, D/2, H/2, W/2)
-    output: the original 3D data -- (N, C, D, H, W)
-    """
-
-    def __init__(self, wavename):
-        """
-        3D inverse DWT (IDWT) for 3D data reconstruction
-        :param wavename: pywt.wavelist(); in the paper, 'chx.y' denotes 'biorx.y'.
-        """
-        super(IDWT_3D, self).__init__()
-        wavelet = pywt.Wavelet(wavename)
-        self.band_low = wavelet.dec_lo
-        self.band_high = wavelet.dec_hi
-        self.band_low.reverse()
-        self.band_high.reverse()
-        assert len(self.band_low) == len(self.band_high)
-        self.band_length = len(self.band_low)
-        assert self.band_length % 2 == 0
-        self.band_length_half = math.floor(self.band_length / 2)
-
-    def get_matrix(self):
-        """
-        生成变换矩阵
-        generating the matrices: \mathcal{L}, \mathcal{H}
-        :return: self.matrix_low = \mathcal{L}, self.matrix_high = \mathcal{H}
-        """
-        L1 = np.max((self.input_height, self.input_width))
-        L = math.floor(L1 / 2)
-        matrix_h = np.zeros((L, L1 + self.band_length - 2))
-        matrix_g = np.zeros((L1 - L, L1 + self.band_length - 2))
-        end = None if self.band_length_half == 1 else (
-            - self.band_length_half + 1)
-
-        index = 0
-        for i in range(L):
-            for j in range(self.band_length):
-                matrix_h[i, index + j] = self.band_low[j]
-            index += 2
-        matrix_h_0 = matrix_h[0:(math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_h_1 = matrix_h[0:(math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-        matrix_h_2 = matrix_h[0:(math.floor(
-            self.input_depth / 2)), 0:(self.input_depth + self.band_length - 2)]
-
-        index = 0
-        for i in range(L1 - L):
-            for j in range(self.band_length):
-                matrix_g[i, index + j] = self.band_high[j]
-            index += 2
-        matrix_g_0 = matrix_g[0:(self.input_height - math.floor(
-            self.input_height / 2)), 0:(self.input_height + self.band_length - 2)]
-        matrix_g_1 = matrix_g[0:(self.input_width - math.floor(
-            self.input_width / 2)), 0:(self.input_width + self.band_length - 2)]
-        matrix_g_2 = matrix_g[0:(self.input_depth - math.floor(
-            self.input_depth / 2)), 0:(self.input_depth + self.band_length - 2)]
-
-        matrix_h_0 = matrix_h_0[:, (self.band_length_half - 1):end]
-        matrix_h_1 = matrix_h_1[:, (self.band_length_half - 1):end]
-        matrix_h_1 = np.transpose(matrix_h_1)
-        matrix_h_2 = matrix_h_2[:, (self.band_length_half - 1):end]
-
-        matrix_g_0 = matrix_g_0[:, (self.band_length_half - 1):end]
-        matrix_g_1 = matrix_g_1[:, (self.band_length_half - 1):end]
-        matrix_g_1 = np.transpose(matrix_g_1)
-        matrix_g_2 = matrix_g_2[:, (self.band_length_half - 1):end]
-        if torch.cuda.is_available():
-            self.matrix_low_0 = torch.Tensor(matrix_h_0).cuda()
-            self.matrix_low_1 = torch.Tensor(matrix_h_1).cuda()
-            self.matrix_low_2 = torch.Tensor(matrix_h_2).cuda()
-            self.matrix_high_0 = torch.Tensor(matrix_g_0).cuda()
-            self.matrix_high_1 = torch.Tensor(matrix_g_1).cuda()
-            self.matrix_high_2 = torch.Tensor(matrix_g_2).cuda()
-        else:
-            self.matrix_low_0 = torch.Tensor(matrix_h_0)
-            self.matrix_low_1 = torch.Tensor(matrix_h_1)
-            self.matrix_low_2 = torch.Tensor(matrix_h_2)
-            self.matrix_high_0 = torch.Tensor(matrix_g_0)
-            self.matrix_high_1 = torch.Tensor(matrix_g_1)
-            self.matrix_high_2 = torch.Tensor(matrix_g_2)
-
-    def forward(self, LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH):
-        """
-        :param LLL: the low-frequency component, lfc
-        :param LLH: the high-frequency componetn, hfc_llh
-        :param LHL: the high-frequency componetn, hfc_lhl
-        :param LHH: the high-frequency componetn, hfc_lhh
-        :param HLL: the high-frequency componetn, hfc_hll
-        :param HLH: the high-frequency componetn, hfc_hlh
-        :param HHL: the high-frequency componetn, hfc_hhl
-        :param HHH: the high-frequency componetn, hfc_hhh
-        :return: the original 3D input data
-        """
-        assert len(LLL.size()) == len(LLH.size()) == len(
-            LHL.size()) == len(LHH.size()) == 5
-        assert len(HLL.size()) == len(HLH.size()) == len(
-            HHL.size()) == len(HHH.size()) == 5
-        self.input_depth = LLL.size()[-3] + HHH.size()[-3]
-        self.input_height = LLL.size()[-2] + HHH.size()[-2]
-        self.input_width = LLL.size()[-1] + HHH.size()[-1]
-        self.get_matrix()
-        return IDWTFunction_3D.apply(LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH,
-                                     self.matrix_low_0, self.matrix_low_1, self.matrix_low_2,
-                                     self.matrix_high_0, self.matrix_high_1, self.matrix_high_2)
-
-
-if __name__ == '__main__':
-    dwt = DWT_2D("haar")
-    iwt = IDWT_2D("haar")
-    x = torch.randn(3, 3, 24, 24).cuda()
-    xll = x
-    wavelet_list = []
-    for i in range(3):
-        xll, xlh, xhl, xhh = dwt(xll)
-        wavelet_list.append([xll, xlh, xhl, xhh])
-
-    # xll = wavelet_list[-1] * torch.randn(xll.shape)
-    for i in range(2)[::-1]:
-        xll, xlh, xhl, xhh = wavelet_list[i]
-        xll = iwt(xll, xlh, xhl, xhh)
-        print(xll.shape)
-
-    print(torch.sum(x - xll))
-    print(torch.sum(x - iwt(*wavelet_list[0])))

wdm-3d-initial/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Paul Friedrich
-
-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.

wdm-3d-initial/README.md

@@ -1,145 +0,0 @@
-# WDM: 3D Wavelet Diffusion Models for High-Resolution Medical Image Synthesis
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Static Badge](https://img.shields.io/badge/Project-page-blue)](https://pfriedri.github.io/wdm-3d-io/)
-[![arXiv](https://img.shields.io/badge/arXiv-2402.19043-b31b1b.svg)](https://arxiv.org/abs/2402.19043)
-
-This is the official PyTorch implementation of the paper **WDM: 3D Wavelet Diffusion Models for High-Resolution Medical Image Synthesis** by [Paul Friedrich](https://pfriedri.github.io/), [Julia Wolleb](https://dbe.unibas.ch/en/persons/julia-wolleb/), [Florentin Bieder](https://dbe.unibas.ch/en/persons/florentin-bieder/), [Alicia Durrer](https://dbe.unibas.ch/en/persons/alicia-durrer/) and [Philippe C. Cattin](https://dbe.unibas.ch/en/persons/philippe-claude-cattin/).
-
-
-If you find our work useful, please consider to :star: **star this repository** and :memo: **cite our paper**:
-```bibtex
-@inproceedings{friedrich2024wdm,
-               title={Wdm: 3d wavelet diffusion models for high-resolution medical image synthesis},
-               author={Friedrich, Paul and Wolleb, Julia and Bieder, Florentin and Durrer, Alicia and Cattin, Philippe C},
-               booktitle={MICCAI Workshop on Deep Generative Models},
-               pages={11--21},
-               year={2024},
-               organization={Springer}}
-```
-
-## Paper Abstract
-Due to the three-dimensional nature of CT- or MR-scans, generative modeling of medical images is a particularly challenging task. Existing approaches mostly apply patch-wise, slice-wise, or cascaded generation techniques to fit the high-dimensional data into the limited GPU memory. However, these approaches may introduce artifacts and potentially restrict the model's applicability for certain downstream tasks. This work presents WDM, a wavelet-based medical image synthesis framework that applies a diffusion model on wavelet decomposed images. The presented approach is a simple yet effective way of scaling diffusion models to high resolutions and can be trained on a single 40 GB GPU. Experimental results on BraTS and LIDC-IDRI unconditional image generation at a resolution of 128 x 128 x 128 show state-of-the-art image fidelity (FID) and sample diversity (MS-SSIM) scores compared to GANs, Diffusion Models, and Latent Diffusion Models. Our proposed method is the only one capable of generating high-quality images at a resolution of 256 x 256 x 256.
-
-<p>
-    <img width="750" src="assets/wdm.png"/>
-</p>
-
-
-## Dependencies
-We recommend using a [conda](https://github.com/conda-forge/miniforge#mambaforge) environment to install the required dependencies.
-You can create and activate such an environment called `wdm` by running the following commands:
-```sh
-mamba env create -f environment.yml
-mamba activate wdm
-```
-
-## Training & Sampling
-For training a new model or sampling from an already trained one, you can simply adapt and use the script `run.sh`. All relevant hyperparameters for reproducing our results are automatically set when using the correct `MODEL` in the general settings.
-For executing the script, simply use the following command:
-```sh
-bash run.sh
-```
-**Supported settings** (set in `run.sh` file):
-
-MODE: `'training'`, `'sampling'`
-
-MODEL: `'ours_unet_128'`, `'ours_unet_256'`, `'ours_wnet_128'`, `'ours_wnet_256'`
-
-DATASET: `'brats'`, `'lidc-idri'`
-
-## Conditional Image Synthesis / Image-to-Image Translation 
-To use WDM for conditional image synthesis or paired image-to-image translation check out our repository [pfriedri/cwdm](https://github.com/pfriedri/cwdm) that implements our paper **cWDM: Conditional Wavelet Diffusion Models for Cross-Modality 3D Medical Image Synthesis**.
-
-## Pretrained Models
-We released pretrained models on [HuggingFace](https://huggingface.co/pfriedri/wdm-3d).
-
-Currently available models:
-- [BraTS 128](https://huggingface.co/pfriedri/wdm-3d/blob/main/brats_unet_128_1200k.pt): BraTS, 128 x 128 x 128, U-Net backbone, 1.2M Iterations
-- [LIDC-IDRI 128](https://huggingface.co/pfriedri/wdm-3d/blob/main/lidc-idri_unet_128_1200k.pt): LIDC-IDRI, 128 x 128 x 128, U-Net backbone, 1.2M Iterations 
-
-## Data
-To ensure good reproducibility, we trained and evaluated our network on two publicly available datasets:
-* **BRATS 2023: Adult Glioma**, a dataset containing routine clinically-acquired, multi-site multiparametric magnetic resonance imaging (MRI) scans of brain tumor patients. We just used the T1-weighted images for training. The data is available [here](https://www.synapse.org/#!Synapse:syn51514105).
-
-* **LIDC-IDRI**, a dataset containing multi-site, thoracic computed tomography (CT) scans of lung cancer patients. The data is available [here](https://wiki.cancerimagingarchive.net/pages/viewpage.action?pageId=1966254).
-
-The provided code works for the following data structure (you might need to adapt the `DATA_DIR` variable in `run.sh`):
-```
-data
-└───BRATS
-    └───BraTS-GLI-00000-000
-        └───BraTS-GLI-00000-000-seg.nii.gz
-        └───BraTS-GLI-00000-000-t1c.nii.gz
-        └───BraTS-GLI-00000-000-t1n.nii.gz
-        └───BraTS-GLI-00000-000-t2f.nii.gz
-        └───BraTS-GLI-00000-000-t2w.nii.gz  
-    └───BraTS-GLI-00001-000
-    └───BraTS-GLI-00002-000
-    ...
-
-└───LIDC-IDRI
-    └───LIDC-IDRI-0001
-      └───preprocessed.nii.gz
-    └───LIDC-IDRI-0002
-    └───LIDC-IDRI-0003
-    ...
-```
-We provide a script for preprocessing LIDC-IDRI. Simply run the following command with the correct path to the downloaded DICOM files `DICOM_PATH` and the directory you want to store the processed nifti files `NIFTI_PATH`:
-```sh
-python utils/preproc_lidc-idri.py --dicom_dir DICOM_PATH --nifti_dir NIFTI_PATH
-```
-
-## Evaluation
-As our code for evaluating the model performance has slightly different dependencies, we provide a second .yml file to set up the evaluation environment.
-Simply use the following command to create and activate the new environment:
-```sh
-mamba env create -f eval/eval_environment.yml
-mamba activate eval
-```
-### FID
-For computing the FID score, you need to specify the following variables and use them in the command below:
-* DATASET: `brats` or `lidc-idri`
-* IMG_SIZE: `128` or `256`
-* REAL_DATA_DIR: path to your real data
-* FAKE_DATA_DIR: path to your generated/ fake data
-* PATH_TO_FEATURE_EXTRACTOR: path to the feature extractor weights, e.g. `./eval/pretrained/resnet_50_23dataset.pt`
-* PATH_TO_ACTIVATIONS: path to the location where you want to save mus and sigmas (in case you want to reuse them), e.g. `./eval/activations/` 
-* GPU_ID: gpu you want to use, e.g. `0`
-```sh
-python eval/fid.py --dataset DATASET --img_size IMG_SIZE --data_root_real REAL_DATA_DIR --data_root_fake FAKE_DATA_DIR --pretrain_path PATH_TO_FEATURE_EXTRACTOR --path_to_activations PATH_TO_ACTIVATIONS --gpu_id GPU_ID
-```
-### Mean MS-SSIM
-For computing the mean MS-SSIM, you need to specify the following variables and use them in the command below:
-* DATASET: `brats` or `lidc-idri`
-* IMG_SIZE: `128` or `256`
-* SAMPLE_DIR: path to the generated (or real) data
-
-```sh
-python eval/ms_ssim.py --dataset DATASET --img_size IMG_SIZE --sample_dir SAMPLE_DIR
-```
-## Implementation Details for Comparing Methods
-* **HA-GAN**: For implementing the paper [Hierarchical Amortized GAN for 3D High Resolution Medical Image Synthesis](https://ieeexplore.ieee.org/abstract/document/9770375), we use the publicly available [implementation](https://github.com/batmanlab/HA-GAN). We follow the implementation details presented in the original paper (Section E). The authors recommend cutting all zero slices from the volumes before training. To allow a fair comparison with other methods, we have omitted this step.
-* **3D-LDM**: For implementing the paper [Denoising Diffusion Probabilistic Models for 3D Medical Image Generation](https://www.nature.com/articles/s41598-023-34341-2), we use the publicly available [implementation](https://github.com/FirasGit/medicaldiffusion). We follow the implementation details presented in the Supplementary Material of the original paper (Supplementary Table 1).
-* **2.5D-LDM**: For implementing the paper [Make-A-Volume: Leveraging Latent Diffusion Models for Cross-Modality 3D Brain MRI Synthesis](https://link.springer.com/chapter/10.1007/978-3-031-43999-5_56), we adopted the method to work for image generation. We trained a VQ-VAE (downsampling factor 4, latent dimension 32) using an implementation from [MONAI Generative](https://github.com/Project-MONAI/GenerativeModels) and a diffusion model implementation from [OpenAI](https://github.com/openai/guided-diffusion). For implementing the pseudo 3D layers, we use a script provided by the authors. To allow for image generation, we sample all slices at once - meaning that the models batch size and the dimension of the 1D convolution is equal to the number of slices in the volume to be generated.
-* **3D DDPM**: For implementing a memory efficient baseline model, we use the 3D DDPM presented in the paper [Memory-Efficient 3D Denoising Diffusion Models for Medical Image Processing](https://openreview.net/forum?id=neXqIGpO-tn), and used the publicly available [implementation](https://github.com/FlorentinBieder/PatchDDM-3D). We use additive skip connections and train the model with the same hyperparameters as our models.
-
-All experiments were performed on a system with an AMD Epyc 7742 CPU and a NVIDIA A100 (40GB) GPU.
-
-## TODOs
-We plan to add further functionality to our framework:
-- [ ] Add compatibility for more datasets like MRNet, ADNI, or fastMRI
-- [x] Release pre-trained models
-- [ ] Extend the framework for 3D image inpainting
-- [x] Extend the framework for 3D image-to-image translation ([pfriedri/cwdm](https://github.com/pfriedri/cwdm))
-
-## Acknowledgements
-Our code is based on / inspired by the following repositories:
-* https://github.com/openai/guided-diffusion (published under [MIT License](https://github.com/openai/guided-diffusion/blob/main/LICENSE))
-* https://github.com/FlorentinBieder/PatchDDM-3D (published under [MIT License](https://github.com/FlorentinBieder/PatchDDM-3D/blob/master/LICENSE))
-* https://github.com/VinAIResearch/WaveDiff (published under [GNU General Public License v3.0](https://github.com/VinAIResearch/WaveDiff/blob/main/LICENSE))
-* https://github.com/LiQiufu/WaveCNet (published under [CC BY-NC-SA 4.0 License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode))
-
-For computing FID scores we use a pretrained model (`resnet_50_23dataset.pth`) from:
-* https://github.com/Tencent/MedicalNet (published uner [MIT License](https://github.com/Tencent/MedicalNet/blob/master/LICENSE))
-
-Thanks for making these projects open-source.

wdm-3d-initial/environment.yml

@@ -1,22 +0,0 @@
-name: wdm
-channels:
-  - pytorch
-  - nvidia
-  - conda-forge
-dependencies:
-  - python=3.10.13
-  - numpy=1.26.4
-  - pytorch=2.2.0=py3.10_cuda11.8_cudnn8.7.0_0
-  - pytorch-cuda=11.8
-  - pywavelets=1.4.1
-  - scipy=1.12.0
-  - torchaudio=2.2.0=py310_cu118
-  - torchvision=0.17.0=py310_cu118
-  - pip
-  - pip:
-    - nibabel==5.2.0
-    - blobfile==2.1.1
-    - tensorboard==2.16.2
-    - matplotlib==3.8.3
-    - tqdm==4.66.2
-    - dicom2nifti==2.4.10

wdm-3d-initial/eval/.ipynb_checkpoints/fid-checkpoint.py

@@ -1,214 +0,0 @@
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-import torch.nn.functional as F
-import torch.nn as nn
-import os
-import sys
-import argparse
-
-sys.path.append(".")
-sys.path.append("..")
-
-from scipy import linalg
-
-from guided_diffusion.bratsloader import BRATSVolumes
-from guided_diffusion.lidcloader import LIDCVolumes
-from model import generate_model
-
-
-def get_feature_extractor(sets):
-    model, _ = generate_model(sets)
-    checkpoint = torch.load(sets.pretrain_path)
-    model.load_state_dict(checkpoint['state_dict'])
-    model.eval()
-    print("Done. Initialized feature extraction model and loaded pretrained weights.")
-
-    return model
-
-
-def get_activations(model, data_loader, sets):
-    pred_arr = np.empty((sets.num_samples, sets.dims))
-
-    for i, batch in enumerate(data_loader):
-        if isinstance(batch, list):
-            batch = batch[0]
-        batch = batch.cuda()
-        if i % 10 == 0:
-            print('\rPropagating batch %d' % i, end='', flush=True)
-        with torch.no_grad():
-            pred = model(batch)
-
-        if i*sets.batch_size >= pred_arr.shape[0]:
-            pred_arr[i*sets.batch_size:] = pred.cpu().numpy()
-            break
-        else:
-            pred_arr[i*sets.batch_size:(i+1)*sets.batch_size] = pred.cpu().numpy()
-
-    return pred_arr
-
-
-def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
-    """
-    Numpy implementation of the Frechet Distance. The Frechet distance between two multivariate Gaussians
-    X_1 ~ N(mu_1, C_1) and X_2 ~ N(mu_2, C_2) is d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
-
-    Params:
-    -- mu1   : Numpy array containing the activations of a layer of the inception net (like returned by the function
-               'get_predictions') for generated samples.
-    -- mu2   : The sample mean over activations, precalculated on a representative data set.
-    -- sigma1: The covariance matrix over activations for generated samples.
-    -- sigma2: The covariance matrix over activations, precalculated on a representative data set.
-
-    Returns:
-    --   : The Frechet Distance.
-    """
-
-    mu1 = np.atleast_1d(mu1)
-    mu2 = np.atleast_1d(mu2)
-
-    sigma1 = np.atleast_2d(sigma1)
-    sigma2 = np.atleast_2d(sigma2)
-
-    assert mu1.shape == mu2.shape, \
-        'Training and test mean vectors have different lengths'
-    assert sigma1.shape == sigma2.shape, \
-        'Training and test covariances have different dimensions'
-
-    diff = mu1 - mu2
-
-    # Product might be almost singular
-    covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
-    if not np.isfinite(covmean).all():
-        msg = ('fid calculation produces singular product; '
-               'adding %s to diagonal of cov estimates') % eps
-        print(msg)
-        offset = np.eye(sigma1.shape[0]) * eps
-        covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
-
-    # Numerical error might give slight imaginary component
-    if np.iscomplexobj(covmean):
-        if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
-            m = np.max(np.abs(covmean.imag))
-            raise ValueError('Imaginary component {}'.format(m))
-        covmean = covmean.real
-
-    tr_covmean = np.trace(covmean)
-
-    return (diff.dot(diff) + np.trace(sigma1) +
-            np.trace(sigma2) - 2 * tr_covmean)
-
-
-def process_feature_vecs(activations):
-    mu = np.mean(activations, axis=0)
-    sigma = np.cov(activations, rowvar=False)
-
-    return mu, sigma
-
-
-def parse_opts():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--dataset', required=True, type=str, help='Dataset (brats | lidc-idri)')
-    parser.add_argument('--img_size', required=True, type=int, help='Image size')
-    parser.add_argument('--data_root_real', required=True, type=str, help='Path to real data')
-    parser.add_argument('--data_root_fake', required=True, type=str, help='Path to fake data')
-    parser.add_argument('--pretrain_path', required=True, type=str, help='Path to pretrained model')
-    parser.add_argument('--path_to_activations', required=True, type=str, help='Path to activations')
-    parser.add_argument('--n_seg_classes', default=2, type=int, help="Number of segmentation classes")
-    parser.add_argument('--learning_rate', default=0.001, type=float,
-                        help='Initial learning rate (divided by 10 while training by lr scheduler)')
-    parser.add_argument('--num_workers', default=4, type=int, help='Number of jobs')
-    parser.add_argument('--batch_size', default=1, type=int, help='Batch Size')
-    parser.add_argument('--phase', default='test', type=str, help='Phase of train or test')
-    parser.add_argument('--save_intervals', default=10, type=int, help='Interation for saving model')
-    parser.add_argument('--n_epochs', default=200, type=int, help='Number of total epochs to run')
-    parser.add_argument('--input_D', default=256, type=int, help='Input size of depth')
-    parser.add_argument('--input_H', default=256, type=int, help='Input size of height')
-    parser.add_argument('--input_W', default=256, type=int, help='Input size of width')
-    parser.add_argument('--resume_path', default='', type=str, help='Path for resume model.')
-
-    parser.add_argument('--new_layer_names', default=['conv_seg'], type=list, help='New layer except for backbone')
-    parser.add_argument('--no_cuda', action='store_true', help='If true, cuda is not used.')
-    parser.set_defaults(no_cuda=False)
-    parser.add_argument('--gpu_id', default=0, type=int, help='Gpu id')
-    parser.add_argument('--model', default='resnet', type=str,
-                        help='(resnet | preresnet | wideresnet | resnext | densenet | ')
-    parser.add_argument('--model_depth', default=50, type=int, help='Depth of resnet (10 | 18 | 34 | 50 | 101)')
-    parser.add_argument('--resnet_shortcut', default='B', type=str, help='Shortcut type of resnet (A | B)')
-    parser.add_argument('--manual_seed', default=1, type=int, help='Manually set random seed')
-    parser.add_argument('--ci_test', action='store_true', help='If true, ci testing is used.')
-    args = parser.parse_args()
-    args.save_folder = "./trails/models/{}_{}".format(args.model, args.model_depth)
-
-    return args
-
-
-if __name__ == '__main__':
-    # Model settings
-    sets = parse_opts()
-    sets.target_type = "normal"
-    sets.phase = 'test'
-    sets.batch_size = 1
-    sets.dims = 2048
-    sets.num_samples = 1000
-
-    if not sets.no_cuda:
-        dev_name = 'cuda:' + str(sets.gpu_id)
-        device = torch.device(dev_name)
-    else:
-        device = torch.device('cpu')
-
-    # getting model
-    print("Load model ...")
-    model = get_feature_extractor(sets)
-    model = model.to(device)
-
-    # Data loader
-    print("Initialize dataloader ...")
-    if sets.dataset == 'brats':
-        real_data = BRATSVolumes(sets.data_root_real, normalize=None, mode='real', img_size=sets.img_size)
-        fake_data = BRATSVolumes(sets.data_root_fake, normalize=None, mode='fake', img_size=sets.img_size)
-
-    elif sets.dataset == 'lidc-idri':
-        real_data = LIDCVolumes(sets.data_root_real, normalize=None, mode='real', img_size=sets.img_size)
-        fake_data = LIDCVolumes(sets.data_root_fake, normalize=None, mode='fake', img_size=sets.img_size)
-
-    else:
-        print("Dataloader for this dataset is not implemented. Use 'brats' or 'lidc-idri'.")
-
-    real_data_loader = DataLoader(real_data, batch_size=sets.batch_size, shuffle=False, num_workers=sets.batch_size,
-                                  pin_memory=False)
-    fake_data_loader = DataLoader(fake_data, batch_size=sets.batch_size, shuffle=False, num_workers=sets.batch_size,
-                                  pin_memory=False)
-
-
-    # Real data
-    print("Get activations from real data ...")
-    activations_real = get_activations(model, real_data_loader, sets)
-    mu_real, sigma_real = process_feature_vecs(activations_real)
-
-    path_to_mu_real = os.path.join(sets.path_to_activations, 'mu_real.npy')
-    path_to_sigma_real = os.path.join(sets.path_to_activations, 'sigma_real.npy')
-    np.save(path_to_mu_real, mu_real)
-    print("")
-    print("Saved mu_real to: " + path_to_mu_real)
-    np.save(path_to_sigma_real, sigma_real)
-    print("Saved sigma_real to: " + path_to_sigma_real)
-
-
-    # Fake data
-    print("Get activations from fake/generated data ...")
-    activations_fake = get_activations(model, fake_data_loader, sets)
-    mu_fake, sigma_fake = process_feature_vecs(activations_fake)
-
-    path_to_mu_fake = os.path.join(sets.path_to_activations, 'mu_fake.npy')
-    path_to_sigma_fake = os.path.join(sets.path_to_activations, 'sigma_fake.npy')
-    np.save(path_to_mu_fake, mu_fake)
-    print("")
-    print("Saved mu_fake to: " + path_to_mu_fake)
-    np.save(path_to_sigma_fake, sigma_fake)
-    print("Saved sigma_fake to: " + path_to_sigma_fake)
-
-    fid = calculate_frechet_distance(mu_real, sigma_real, mu_fake, sigma_fake)
-    print("The FID score is: ")
-    print(fid)

wdm-3d-initial/eval/.ipynb_checkpoints/ms_ssim-checkpoint.py

@@ -1,70 +0,0 @@
-import argparse
-import numpy as np
-import torch
-import sys
-
-sys.path.append(".")
-sys.path.append("..")
-
-from generative.metrics import MultiScaleSSIMMetric
-from monai import transforms
-from monai.config import print_config
-from monai.data import Dataset
-from monai.utils import set_determinism
-from torch.utils.data import DataLoader
-from tqdm import tqdm
-from guided_diffusion.bratsloader import BRATSVolumes
-from guided_diffusion.lidcloader import LIDCVolumes
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--seed", type=int, default=42, help="Random seed to use.")
-    parser.add_argument("--sample_dir", type=str, required=True, help="Location of the samples to evaluate.")
-    parser.add_argument("--num_workers", type=int, default=8, help="Number of loader workers")
-    parser.add_argument("--dataset", choices=['brats','lidc-idri'], required=True, help="Dataset (brats | lidc-idri)")
-    parser.add_argument("--img_size", type=int, required=True)
-
-    args = parser.parse_args()
-    return args
-
-
-def main(args):
-    set_determinism(seed=args.seed)
-    #print_config()
-
-    if args.dataset == 'brats':
-        dataset_1 = BRATSVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-        dataset_2 = BRATSVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-
-    elif args.dataset == 'lidc-idri':
-        dataset_1 = LIDCVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-        dataset_2 = LIDCVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-
-
-    dataloader_1 = DataLoader(dataset_1, batch_size=1, shuffle=False, num_workers=args.num_workers)
-    dataloader_2 = DataLoader(dataset_2, batch_size=1, shuffle=False, num_workers=args.num_workers)
-
-    device = torch.device("cuda")
-    ms_ssim = MultiScaleSSIMMetric(spatial_dims=3, data_range=1.0, kernel_size=7)
-
-    print("Computing MS-SSIM (this takes a while)...")
-    ms_ssim_list = []
-    pbar = tqdm(enumerate(dataloader_1), total=len(dataloader_1))
-    for step, batch in pbar:
-        img = batch[0]
-        for batch2 in dataloader_2:
-            img2 = batch2 [0]
-            if batch[1] == batch2[1]:
-                continue
-            ms_ssim_list.append(ms_ssim(img.to(device), img2.to(device)).item())
-        pbar.update()
-
-    ms_ssim_list = np.array(ms_ssim_list)
-    print("Calculated MS-SSIMs. Computing mean ...")
-    print(f"Mean MS-SSIM: {ms_ssim_list.mean():.6f}")
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    main(args)

wdm-3d-initial/eval/activations/activations.txt

@@ -1 +0,0 @@
-Path to store intermediate activations for computing FID scores.

wdm-3d-initial/eval/eval_environment.yml

@@ -1,19 +0,0 @@
-name: eval
-channels:
-  - pytorch
-  - nvidia
-  - conda-forge
-dependencies:
-  - numpy=1.24.4
-  - pip=24.2
-  - python=3.8.19
-  - pytorch=2.4.0=py3.8_cuda11.8_cudnn9.1.0_0
-  - pytorch-cuda=11.8
-  - scipy=1.10.1
-  - torchaudio=2.4.0=py38_cu118
-  - torchvision=0.19.0=py38_cu118
-  - pip:
-    - monai==1.3.2
-    - monai-generative==0.2.3
-    - nibabel==5.2.1
-    - tqdm==4.66.5

wdm-3d-initial/eval/fid.py

@@ -1,214 +0,0 @@
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-import torch.nn.functional as F
-import torch.nn as nn
-import os
-import sys
-import argparse
-
-sys.path.append(".")
-sys.path.append("..")
-
-from scipy import linalg
-
-from guided_diffusion.bratsloader import BRATSVolumes
-from guided_diffusion.lidcloader import LIDCVolumes
-from model import generate_model
-
-
-def get_feature_extractor(sets):
-    model, _ = generate_model(sets)
-    checkpoint = torch.load(sets.pretrain_path)
-    model.load_state_dict(checkpoint['state_dict'])
-    model.eval()
-    print("Done. Initialized feature extraction model and loaded pretrained weights.")
-
-    return model
-
-
-def get_activations(model, data_loader, sets):
-    pred_arr = np.empty((sets.num_samples, sets.dims))
-
-    for i, batch in enumerate(data_loader):
-        if isinstance(batch, list):
-            batch = batch[0]
-        batch = batch.cuda()
-        if i % 10 == 0:
-            print('\rPropagating batch %d' % i, end='', flush=True)
-        with torch.no_grad():
-            pred = model(batch)
-
-        if i*sets.batch_size >= pred_arr.shape[0]:
-            pred_arr[i*sets.batch_size:] = pred.cpu().numpy()
-            break
-        else:
-            pred_arr[i*sets.batch_size:(i+1)*sets.batch_size] = pred.cpu().numpy()
-
-    return pred_arr
-
-
-def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
-    """
-    Numpy implementation of the Frechet Distance. The Frechet distance between two multivariate Gaussians
-    X_1 ~ N(mu_1, C_1) and X_2 ~ N(mu_2, C_2) is d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
-
-    Params:
-    -- mu1   : Numpy array containing the activations of a layer of the inception net (like returned by the function
-               'get_predictions') for generated samples.
-    -- mu2   : The sample mean over activations, precalculated on a representative data set.
-    -- sigma1: The covariance matrix over activations for generated samples.
-    -- sigma2: The covariance matrix over activations, precalculated on a representative data set.
-
-    Returns:
-    --   : The Frechet Distance.
-    """
-
-    mu1 = np.atleast_1d(mu1)
-    mu2 = np.atleast_1d(mu2)
-
-    sigma1 = np.atleast_2d(sigma1)
-    sigma2 = np.atleast_2d(sigma2)
-
-    assert mu1.shape == mu2.shape, \
-        'Training and test mean vectors have different lengths'
-    assert sigma1.shape == sigma2.shape, \
-        'Training and test covariances have different dimensions'
-
-    diff = mu1 - mu2
-
-    # Product might be almost singular
-    covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)
-    if not np.isfinite(covmean).all():
-        msg = ('fid calculation produces singular product; '
-               'adding %s to diagonal of cov estimates') % eps
-        print(msg)
-        offset = np.eye(sigma1.shape[0]) * eps
-        covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
-
-    # Numerical error might give slight imaginary component
-    if np.iscomplexobj(covmean):
-        if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
-            m = np.max(np.abs(covmean.imag))
-            raise ValueError('Imaginary component {}'.format(m))
-        covmean = covmean.real
-
-    tr_covmean = np.trace(covmean)
-
-    return (diff.dot(diff) + np.trace(sigma1) +
-            np.trace(sigma2) - 2 * tr_covmean)
-
-
-def process_feature_vecs(activations):
-    mu = np.mean(activations, axis=0)
-    sigma = np.cov(activations, rowvar=False)
-
-    return mu, sigma
-
-
-def parse_opts():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--dataset', required=True, type=str, help='Dataset (brats | lidc-idri)')
-    parser.add_argument('--img_size', required=True, type=int, help='Image size')
-    parser.add_argument('--data_root_real', required=True, type=str, help='Path to real data')
-    parser.add_argument('--data_root_fake', required=True, type=str, help='Path to fake data')
-    parser.add_argument('--pretrain_path', required=True, type=str, help='Path to pretrained model')
-    parser.add_argument('--path_to_activations', required=True, type=str, help='Path to activations')
-    parser.add_argument('--n_seg_classes', default=2, type=int, help="Number of segmentation classes")
-    parser.add_argument('--learning_rate', default=0.001, type=float,
-                        help='Initial learning rate (divided by 10 while training by lr scheduler)')
-    parser.add_argument('--num_workers', default=4, type=int, help='Number of jobs')
-    parser.add_argument('--batch_size', default=1, type=int, help='Batch Size')
-    parser.add_argument('--phase', default='test', type=str, help='Phase of train or test')
-    parser.add_argument('--save_intervals', default=10, type=int, help='Interation for saving model')
-    parser.add_argument('--n_epochs', default=200, type=int, help='Number of total epochs to run')
-    parser.add_argument('--input_D', default=256, type=int, help='Input size of depth')
-    parser.add_argument('--input_H', default=256, type=int, help='Input size of height')
-    parser.add_argument('--input_W', default=256, type=int, help='Input size of width')
-    parser.add_argument('--resume_path', default='', type=str, help='Path for resume model.')
-
-    parser.add_argument('--new_layer_names', default=['conv_seg'], type=list, help='New layer except for backbone')
-    parser.add_argument('--no_cuda', action='store_true', help='If true, cuda is not used.')
-    parser.set_defaults(no_cuda=False)
-    parser.add_argument('--gpu_id', default=0, type=int, help='Gpu id')
-    parser.add_argument('--model', default='resnet', type=str,
-                        help='(resnet | preresnet | wideresnet | resnext | densenet | ')
-    parser.add_argument('--model_depth', default=50, type=int, help='Depth of resnet (10 | 18 | 34 | 50 | 101)')
-    parser.add_argument('--resnet_shortcut', default='B', type=str, help='Shortcut type of resnet (A | B)')
-    parser.add_argument('--manual_seed', default=1, type=int, help='Manually set random seed')
-    parser.add_argument('--ci_test', action='store_true', help='If true, ci testing is used.')
-    args = parser.parse_args()
-    args.save_folder = "./trails/models/{}_{}".format(args.model, args.model_depth)
-
-    return args
-
-
-if __name__ == '__main__':
-    # Model settings
-    sets = parse_opts()
-    sets.target_type = "normal"
-    sets.phase = 'test'
-    sets.batch_size = 1
-    sets.dims = 2048
-    sets.num_samples = 1000
-
-    if not sets.no_cuda:
-        dev_name = 'cuda:' + str(sets.gpu_id)
-        device = torch.device(dev_name)
-    else:
-        device = torch.device('cpu')
-
-    # getting model
-    print("Load model ...")
-    model = get_feature_extractor(sets)
-    model = model.to(device)
-
-    # Data loader
-    print("Initialize dataloader ...")
-    if sets.dataset == 'brats':
-        real_data = BRATSVolumes(sets.data_root_real, normalize=None, mode='real', img_size=sets.img_size)
-        fake_data = BRATSVolumes(sets.data_root_fake, normalize=None, mode='fake', img_size=sets.img_size)
-
-    elif sets.dataset == 'lidc-idri':
-        real_data = LIDCVolumes(sets.data_root_real, normalize=None, mode='real', img_size=sets.img_size)
-        fake_data = LIDCVolumes(sets.data_root_fake, normalize=None, mode='fake', img_size=sets.img_size)
-
-    else:
-        print("Dataloader for this dataset is not implemented. Use 'brats' or 'lidc-idri'.")
-
-    real_data_loader = DataLoader(real_data, batch_size=sets.batch_size, shuffle=False, num_workers=sets.batch_size,
-                                  pin_memory=False)
-    fake_data_loader = DataLoader(fake_data, batch_size=sets.batch_size, shuffle=False, num_workers=sets.batch_size,
-                                  pin_memory=False)
-
-
-    # Real data
-    print("Get activations from real data ...")
-    activations_real = get_activations(model, real_data_loader, sets)
-    mu_real, sigma_real = process_feature_vecs(activations_real)
-
-    path_to_mu_real = os.path.join(sets.path_to_activations, 'mu_real.npy')
-    path_to_sigma_real = os.path.join(sets.path_to_activations, 'sigma_real.npy')
-    np.save(path_to_mu_real, mu_real)
-    print("")
-    print("Saved mu_real to: " + path_to_mu_real)
-    np.save(path_to_sigma_real, sigma_real)
-    print("Saved sigma_real to: " + path_to_sigma_real)
-
-
-    # Fake data
-    print("Get activations from fake/generated data ...")
-    activations_fake = get_activations(model, fake_data_loader, sets)
-    mu_fake, sigma_fake = process_feature_vecs(activations_fake)
-
-    path_to_mu_fake = os.path.join(sets.path_to_activations, 'mu_fake.npy')
-    path_to_sigma_fake = os.path.join(sets.path_to_activations, 'sigma_fake.npy')
-    np.save(path_to_mu_fake, mu_fake)
-    print("")
-    print("Saved mu_fake to: " + path_to_mu_fake)
-    np.save(path_to_sigma_fake, sigma_fake)
-    print("Saved sigma_fake to: " + path_to_sigma_fake)
-
-    fid = calculate_frechet_distance(mu_real, sigma_real, mu_fake, sigma_fake)
-    print("The FID score is: ")
-    print(fid)

wdm-3d-initial/eval/model.py

@@ -1,101 +0,0 @@
-import torch
-from torch import nn
-from models import resnet
-
-
-def generate_model(opt):
-    assert opt.model in ['resnet']
-
-    if opt.model == 'resnet':
-        assert opt.model_depth in [10, 18, 34, 50, 101, 152, 200]
-
-        if opt.model_depth == 10:
-            model = resnet.resnet10(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-        elif opt.model_depth == 18:
-            model = resnet.resnet18(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-        elif opt.model_depth == 34:
-            model = resnet.resnet34(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-        elif opt.model_depth == 50:
-            model = resnet.resnet50(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-        elif opt.model_depth == 101:
-            model = resnet.resnet101(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-        elif opt.model_depth == 152:
-            model = resnet.resnet152(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-        elif opt.model_depth == 200:
-            model = resnet.resnet200(
-                sample_input_W=opt.input_W,
-                sample_input_H=opt.input_H,
-                sample_input_D=opt.input_D,
-                shortcut_type=opt.resnet_shortcut,
-                no_cuda=opt.no_cuda,
-                num_seg_classes=opt.n_seg_classes)
-
-    if not opt.no_cuda:
-            import os
-            os.environ["CUDA_VISIBLE_DEVICES"] = str(opt.gpu_id)
-            model = model.cuda()
-            model = nn.DataParallel(model)
-            net_dict = model.state_dict()
-    else:
-        net_dict = model.state_dict()
-
-    # load pretrain
-    if opt.phase != 'test' and opt.pretrain_path:
-        print('loading pretrained model {}'.format(opt.pretrain_path))
-        pretrain = torch.load(opt.pretrain_path)
-        pretrain_dict = {k: v for k, v in pretrain['state_dict'].items() if k in net_dict.keys()}
-
-        net_dict.update(pretrain_dict)
-        model.load_state_dict(net_dict)
-
-        new_parameters = []
-        for pname, p in model.named_parameters():
-            for layer_name in opt.new_layer_names:
-                if pname.find(layer_name) >= 0:
-                    new_parameters.append(p)
-                    break
-
-        new_parameters_id = list(map(id, new_parameters))
-        base_parameters = list(filter(lambda p: id(p) not in new_parameters_id, model.parameters()))
-        parameters = {'base_parameters': base_parameters,
-                      'new_parameters': new_parameters}
-
-        return model, parameters
-
-    return model, model.parameters()

wdm-3d-initial/eval/models/resnet.py

@@ -1,245 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.autograd import Variable
-import math
-from functools import partial
-
-__all__ = [
-    'ResNet', 'resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
-    'resnet152', 'resnet200'
-]
-
-
-def conv3x3x3(in_planes, out_planes, stride=1, dilation=1):
-    # 3x3x3 convolution with padding
-    return nn.Conv3d(
-        in_planes,
-        out_planes,
-        kernel_size=3,
-        dilation=dilation,
-        stride=stride,
-        padding=dilation,
-        bias=False)
-
-
-def downsample_basic_block(x, planes, stride, no_cuda=False):
-    out = F.avg_pool3d(x, kernel_size=1, stride=stride)
-    zero_pads = torch.Tensor(
-        out.size(0), planes - out.size(1), out.size(2), out.size(3),
-        out.size(4)).zero_()
-    if not no_cuda:
-        if isinstance(out.data, torch.cuda.FloatTensor):
-            zero_pads = zero_pads.cuda()
-
-    out = Variable(torch.cat([out.data, zero_pads], dim=1))
-
-    return out
-
-
-class BasicBlock(nn.Module):
-    expansion = 1
-
-    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None):
-        super(BasicBlock, self).__init__()
-        self.conv1 = conv3x3x3(inplanes, planes, stride=stride, dilation=dilation)
-        self.bn1 = nn.BatchNorm3d(planes)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = conv3x3x3(planes, planes, dilation=dilation)
-        self.bn2 = nn.BatchNorm3d(planes)
-        self.downsample = downsample
-        self.stride = stride
-        self.dilation = dilation
-
-    def forward(self, x):
-        residual = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-        out = self.conv2(out)
-        out = self.bn2(out)
-
-        if self.downsample is not None:
-            residual = self.downsample(x)
-
-        out += residual
-        out = self.relu(out)
-
-        return out
-
-
-class Bottleneck(nn.Module):
-    expansion = 4
-
-    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None):
-        super(Bottleneck, self).__init__()
-        self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False)
-        self.bn1 = nn.BatchNorm3d(planes)
-        self.conv2 = nn.Conv3d(
-            planes, planes, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False)
-        self.bn2 = nn.BatchNorm3d(planes)
-        self.conv3 = nn.Conv3d(planes, planes * 4, kernel_size=1, bias=False)
-        self.bn3 = nn.BatchNorm3d(planes * 4)
-        self.relu = nn.ReLU(inplace=True)
-        self.downsample = downsample
-        self.stride = stride
-        self.dilation = dilation
-
-    def forward(self, x):
-        residual = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-        out = self.relu(out)
-
-        out = self.conv3(out)
-        out = self.bn3(out)
-
-        if self.downsample is not None:
-            residual = self.downsample(x)
-
-        out += residual
-        out = self.relu(out)
-
-        return out
-
-
-class Flatten(torch.nn.Module):
-    def forward(self, inp):
-        return inp.view(inp.size(0), -1)
-
-
-class ResNet(nn.Module):
-
-    def __init__(self,
-                 block,
-                 layers,
-                 sample_input_D,
-                 sample_input_H,
-                 sample_input_W,
-                 num_seg_classes,
-                 shortcut_type='B',
-                 no_cuda=False):
-        self.inplanes = 64
-        self.no_cuda = no_cuda
-        super(ResNet, self).__init__()
-        self.conv1 = nn.Conv3d(
-            1,
-            64,
-            kernel_size=7,
-            stride=(2, 2, 2),
-            padding=(3, 3, 3),
-            bias=False)
-
-        self.bn1 = nn.BatchNorm3d(64)
-        self.relu = nn.ReLU(inplace=True)
-        self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1)
-        self.layer1 = self._make_layer(block, 64, layers[0], shortcut_type)
-        self.layer2 = self._make_layer(
-            block, 128, layers[1], shortcut_type, stride=2)
-        self.layer3 = self._make_layer(
-            block, 256, layers[2], shortcut_type, stride=1, dilation=2)
-        self.layer4 = self._make_layer(
-            block, 512, layers[3], shortcut_type, stride=1, dilation=4)
-
-        self.conv_seg = nn.Sequential(nn.AdaptiveAvgPool3d((1, 1, 1)), Flatten())
-
-        for m in self.modules():
-            if isinstance(m, nn.Conv3d):
-                m.weight = nn.init.kaiming_normal_(m.weight, mode='fan_out')
-            elif isinstance(m, nn.BatchNorm3d):
-                m.weight.data.fill_(1)
-                m.bias.data.zero_()
-
-    def _make_layer(self, block, planes, blocks, shortcut_type, stride=1, dilation=1):
-        downsample = None
-        if stride != 1 or self.inplanes != planes * block.expansion:
-            if shortcut_type == 'A':
-                downsample = partial(
-                    downsample_basic_block,
-                    planes=planes * block.expansion,
-                    stride=stride,
-                    no_cuda=self.no_cuda)
-            else:
-                downsample = nn.Sequential(
-                    nn.Conv3d(
-                        self.inplanes,
-                        planes * block.expansion,
-                        kernel_size=1,
-                        stride=stride,
-                        bias=False), nn.BatchNorm3d(planes * block.expansion))
-
-        layers = []
-        layers.append(block(self.inplanes, planes, stride=stride, dilation=dilation, downsample=downsample))
-        self.inplanes = planes * block.expansion
-        for i in range(1, blocks):
-            layers.append(block(self.inplanes, planes, dilation=dilation))
-
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.relu(x)
-        x = self.maxpool(x)
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.layer4(x)
-        x = self.conv_seg(x)
-
-        return x
-
-
-def resnet10(**kwargs):
-    """Constructs a ResNet-18 model.
-    """
-    model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)
-    return model
-
-
-def resnet18(**kwargs):
-    """Constructs a ResNet-18 model.
-    """
-    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
-    return model
-
-
-def resnet34(**kwargs):
-    """Constructs a ResNet-34 model.
-    """
-    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
-    return model
-
-
-def resnet50(**kwargs):
-    """Constructs a ResNet-50 model.
-    """
-    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
-    return model
-
-
-def resnet101(**kwargs):
-    """Constructs a ResNet-101 model.
-    """
-    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
-    return model
-
-
-def resnet152(**kwargs):
-    """Constructs a ResNet-101 model.
-    """
-    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
-    return model
-
-
-def resnet200(**kwargs):
-    """Constructs a ResNet-101 model.
-    """
-    model = ResNet(Bottleneck, [3, 24, 36, 3], **kwargs)
-    return model

wdm-3d-initial/eval/ms_ssim.py

@@ -1,70 +0,0 @@
-import argparse
-import numpy as np
-import torch
-import sys
-
-sys.path.append(".")
-sys.path.append("..")
-
-from generative.metrics import MultiScaleSSIMMetric
-from monai import transforms
-from monai.config import print_config
-from monai.data import Dataset
-from monai.utils import set_determinism
-from torch.utils.data import DataLoader
-from tqdm import tqdm
-from guided_diffusion.bratsloader import BRATSVolumes
-from guided_diffusion.lidcloader import LIDCVolumes
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--seed", type=int, default=42, help="Random seed to use.")
-    parser.add_argument("--sample_dir", type=str, required=True, help="Location of the samples to evaluate.")
-    parser.add_argument("--num_workers", type=int, default=8, help="Number of loader workers")
-    parser.add_argument("--dataset", choices=['brats','lidc-idri'], required=True, help="Dataset (brats | lidc-idri)")
-    parser.add_argument("--img_size", type=int, required=True)
-
-    args = parser.parse_args()
-    return args
-
-
-def main(args):
-    set_determinism(seed=args.seed)
-    #print_config()
-
-    if args.dataset == 'brats':
-        dataset_1 = BRATSVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-        dataset_2 = BRATSVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-
-    elif args.dataset == 'lidc-idri':
-        dataset_1 = LIDCVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-        dataset_2 = LIDCVolumes(directory=args.sample_dir, mode='fake', img_size=args.img_size)
-
-
-    dataloader_1 = DataLoader(dataset_1, batch_size=1, shuffle=False, num_workers=args.num_workers)
-    dataloader_2 = DataLoader(dataset_2, batch_size=1, shuffle=False, num_workers=args.num_workers)
-
-    device = torch.device("cuda")
-    ms_ssim = MultiScaleSSIMMetric(spatial_dims=3, data_range=1.0, kernel_size=7)
-
-    print("Computing MS-SSIM (this takes a while)...")
-    ms_ssim_list = []
-    pbar = tqdm(enumerate(dataloader_1), total=len(dataloader_1))
-    for step, batch in pbar:
-        img = batch[0]
-        for batch2 in dataloader_2:
-            img2 = batch2 [0]
-            if batch[1] == batch2[1]:
-                continue
-            ms_ssim_list.append(ms_ssim(img.to(device), img2.to(device)).item())
-        pbar.update()
-
-    ms_ssim_list = np.array(ms_ssim_list)
-    print("Calculated MS-SSIMs. Computing mean ...")
-    print(f"Mean MS-SSIM: {ms_ssim_list.mean():.6f}")
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    main(args)

wdm-3d-initial/eval/pretrained/pretrained.txt

@@ -1,3 +0,0 @@
-Path to store pretrained models.
-We used a pretrained 3D ResNet from: https://github.com/Tencent/MedicalNet
-Pretrained model weights for the model 'resnet_50_23dataset.pth' are available at: https://drive.google.com/file/d/13tnSvXY7oDIEloNFiGTsjUIYfS3g3BfG/view?usp=sharing

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/__init__-checkpoint.py

@@ -1,3 +0,0 @@
-"""
-Codebase for "Diffusion Models for Medial Anomaly Detection".
-"""

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/bratsloader-checkpoint.py

@@ -1,85 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.utils.data
-import numpy as np
-import os
-import os.path
-import nibabel
-
-
-class BRATSVolumes(torch.utils.data.Dataset):
-    def __init__(self, directory, test_flag=False, normalize=None, mode='train', img_size=256):
-        '''
-        directory is expected to contain some folder structure:
-                  if some subfolder contains only files, all of these
-                  files are assumed to have a name like
-                  brats_train_NNN_XXX_123_w.nii.gz
-                  where XXX is one of t1n, t1c, t2w, t2f, seg
-                  we assume these five files belong to the same image
-                  seg is supposed to contain the segmentation
-        '''
-        super().__init__()
-        self.mode = mode
-        self.directory = os.path.expanduser(directory)
-        self.normalize = normalize or (lambda x: x)
-        self.test_flag = test_flag
-        self.img_size = img_size
-        if test_flag:
-            self.seqtypes = ['t1n', 't1c', 't2w', 't2f']
-        else:
-            self.seqtypes = ['t1n', 't1c', 't2w', 't2f', 'seg']
-        self.seqtypes_set = set(self.seqtypes)
-        self.database = []
-
-        if not self.mode == 'fake': # Used during training and for evaluating real data
-            for root, dirs, files in os.walk(self.directory):
-                # if there are no subdirs, we have a datadir
-                if not dirs:
-                    files.sort()
-                    datapoint = dict()
-                    # extract all files as channels
-                    for f in files:
-                        seqtype = f.split('-')[4].split('.')[0]
-                        datapoint[seqtype] = os.path.join(root, f)
-                    self.database.append(datapoint)
-        else:   # Used for evaluating fake data
-            for root, dirs, files in os.walk(self.directory):
-                for f in files:
-                    datapoint = dict()
-                    datapoint['t1n'] = os.path.join(root, f)
-                    self.database.append(datapoint)
-
-    def __getitem__(self, x):
-        filedict = self.database[x]
-        name = filedict['t1n']
-        nib_img = nibabel.load(name)  # We only use t1 weighted images
-        out = nib_img.get_fdata()
-
-        if not self.mode == 'fake':
-            # CLip and normalize the images
-            out_clipped = np.clip(out, np.quantile(out, 0.001), np.quantile(out, 0.999))
-            out_normalized = (out_clipped - np.min(out_clipped)) / (np.max(out_clipped) - np.min(out_clipped))
-            out = torch.tensor(out_normalized)
-
-            # Zero pad images
-            image = torch.zeros(1, 256, 256, 256)
-            image[:, 8:-8, 8:-8, 50:-51] = out
-
-            # Downsampling
-            if self.img_size == 128:
-                downsample = nn.AvgPool3d(kernel_size=2, stride=2)
-                image = downsample(image)
-        else:
-            image = torch.tensor(out, dtype=torch.float32)
-            image = image.unsqueeze(dim=0)
-
-        # Normalization
-        image = self.normalize(image)
-
-        if self.mode == 'fake':
-            return image, name
-        else:
-            return image
-
-    def __len__(self):
-        return len(self.database)

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/dist_util-checkpoint.py

@@ -1,107 +0,0 @@
-"""
-Helpers for distributed training.
-"""
-
-import io
-import os
-import socket
-
-import blobfile as bf
-import torch as th
-import torch.distributed as dist
-
-# Change this to reflect your cluster layout.
-# The GPU for a given rank is (rank % GPUS_PER_NODE).
-GPUS_PER_NODE = 8
-
-SETUP_RETRY_COUNT = 3
-
-
-def setup_dist(devices=(0,)):
-    """
-    Setup a distributed process group.
-    """
-    if dist.is_initialized():
-        return
-    try:
-        device_string = ','.join(map(str, devices))
-    except TypeError:
-        device_string = str(devices)
-    os.environ["CUDA_VISIBLE_DEVICES"] = device_string #f"{MPI.COMM_WORLD.Get_rank() % GPUS_PER_NODE}"
-
-    #comm = MPI.COMM_WORLD
-  #  print('commworld, 'f"{MPI.COMM_WORLD.Get_rank() % GPUS_PER_NODE}", comm)
-    backend = "gloo" if not th.cuda.is_available() else "nccl"
-   # print('commrank', comm.rank)
-   # print('commsize', comm.size)
-
-    if backend == "gloo":
-        hostname = "localhost"
-    else:
-        hostname = socket.gethostbyname(socket.getfqdn())
-    os.environ["MASTER_ADDR"] = '127.0.1.1'#comm.bcast(hostname, root=0)
-    os.environ["RANK"] = '0'#str(comm.rank)
-    os.environ["WORLD_SIZE"] = '1'#str(comm.size)
-
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.bind(("", 0))
-    s.listen(1)
-    port = s.getsockname()[1]
-    s.close()
-    # print('port2', port)
-    os.environ["MASTER_PORT"] = str(port)
-    dist.init_process_group(backend=backend, init_method="env://")
-
-
-def dev(device_number=0):
-    """
-    Get the device to use for torch.distributed.
-    """
-    if isinstance(device_number, (list, tuple)):  # multiple devices specified
-        return [dev(k) for k in device_number]    # recursive call
-    if th.cuda.is_available():
-        device_count = th.cuda.device_count()
-        if device_count == 1:
-            return th.device(f"cuda")
-        else:
-            if device_number < device_count:  # if we specify multiple devices, we have to be specific
-                return th.device(f'cuda:{device_number}')
-            else:
-                raise ValueError(f'requested device number {device_number} (0-indexed) but only {device_count} devices available')
-    return th.device("cpu")
-
-
-def load_state_dict(path, **kwargs):
-    """
-    Load a PyTorch file without redundant fetches across MPI ranks.
-    """
-    #print('mpicommworldgetrank', MPI.COMM_WORLD.Get_rank())
-    mpigetrank=0
-   # if MPI.COMM_WORLD.Get_rank() == 0:
-    if mpigetrank==0:
-        with bf.BlobFile(path, "rb") as f:
-            data = f.read()
-    else:
-        data = None
-   # data = MPI.COMM_WORLD.bcast(data)
-  #  print('mpibacst', MPI.COMM_WORLD.bcast(data))
-    return th.load(io.BytesIO(data), **kwargs)
-
-
-def sync_params(params):
-    """
-    Synchronize a sequence of Tensors across ranks from rank 0.
-    """
-    #for p in params:
-    #    with th.no_grad():
-    #        dist.broadcast(p, 0)
-
-
-def _find_free_port():
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.bind(("", 0))
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        return s.getsockname()[1]
-    finally:
-        s.close()

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/gaussian_diffusion-checkpoint.py

@@ -1,1185 +0,0 @@
-"""
-This code started out as a PyTorch port of Ho et al's diffusion models:
-https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py
-
-Docstrings have been added, as well as DDIM sampling and a new collection of beta schedules.
-"""
-from PIL import Image
-from torch.autograd import Variable
-import enum
-import torch.nn.functional as F
-from torchvision.utils import save_image
-import torch
-import math
-import numpy as np
-import torch as th
-from .train_util import visualize
-from .nn import mean_flat
-from .losses import normal_kl, discretized_gaussian_log_likelihood
-from scipy import ndimage
-from torchvision import transforms
-import matplotlib.pyplot as plt
-from scipy.interpolate import interp1d
-
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-dwt = DWT_3D('haar')
-idwt = IDWT_3D('haar')
-
-
-def get_named_beta_schedule(schedule_name, num_diffusion_timesteps):
-    """
-    Get a pre-defined beta schedule for the given name.
-
-    The beta schedule library consists of beta schedules which remain similar
-    in the limit of num_diffusion_timesteps.
-    Beta schedules may be added, but should not be removed or changed once
-    they are committed to maintain backwards compatibility.
-    """
-    if schedule_name == "linear":
-        # Linear schedule from Ho et al, extended to work for any number of
-        # diffusion steps.
-        scale = 1000 / num_diffusion_timesteps
-        beta_start = scale * 0.0001
-        beta_end = scale * 0.02
-        return np.linspace(
-            beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64
-        )
-    elif schedule_name == "cosine":
-        return betas_for_alpha_bar(
-            num_diffusion_timesteps,
-            lambda t: math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2,
-        )
-    else:
-        raise NotImplementedError(f"unknown beta schedule: {schedule_name}")
-
-
-def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function,
-    which defines the cumulative product of (1-beta) over time from t = [0,1].
-
-    :param num_diffusion_timesteps: the number of betas to produce.
-    :param alpha_bar: a lambda that takes an argument t from 0 to 1 and
-                      produces the cumulative product of (1-beta) up to that
-                      part of the diffusion process.
-    :param max_beta: the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-    """
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
-    return np.array(betas)
-
-
-class ModelMeanType(enum.Enum):
-    """
-    Which type of output the model predicts.
-    """
-
-    PREVIOUS_X = enum.auto()  # the model predicts x_{t-1}
-    START_X = enum.auto()  # the model predicts x_0
-    EPSILON = enum.auto()  # the model predicts epsilon
-
-
-class ModelVarType(enum.Enum):
-    """
-    What is used as the model's output variance.
-
-    The LEARNED_RANGE option has been added to allow the model to predict
-    values between FIXED_SMALL and FIXED_LARGE, making its job easier.
-    """
-
-    LEARNED = enum.auto()
-    FIXED_SMALL = enum.auto()
-    FIXED_LARGE = enum.auto()
-    LEARNED_RANGE = enum.auto()
-
-
-class LossType(enum.Enum):
-    MSE = enum.auto()  # use raw MSE loss (and KL when learning variances)
-    RESCALED_MSE = (
-        enum.auto()
-    )  # use raw MSE loss (with RESCALED_KL when learning variances)
-    KL = enum.auto()  # use the variational lower-bound
-    RESCALED_KL = enum.auto()  # like KL, but rescale to estimate the full VLB
-
-    def is_vb(self):
-        return self == LossType.KL or self == LossType.RESCALED_KL
-
-
-class GaussianDiffusion:
-    """
-    Utilities for training and sampling diffusion models.
-
-    Ported directly from here, and then adapted over time to further experimentation.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py#L42
-
-    :param betas: a 1-D numpy array of betas for each diffusion timestep,
-                  starting at T and going to 1.
-    :param model_mean_type: a ModelMeanType determining what the model outputs.
-    :param model_var_type: a ModelVarType determining how variance is output.
-    :param loss_type: a LossType determining the loss function to use.
-    :param rescale_timesteps: if True, pass floating point timesteps into the
-                              model so that they are always scaled like in the
-                              original paper (0 to 1000).
-    """
-
-    def __init__(
-        self,
-        *,
-        betas,
-        model_mean_type,
-        model_var_type,
-        loss_type,
-        rescale_timesteps=False,
-        mode='default',
-        loss_level='image'
-    ):
-        self.model_mean_type = model_mean_type
-        self.model_var_type = model_var_type
-        self.loss_type = loss_type
-        self.rescale_timesteps = rescale_timesteps
-        self.mode = mode
-        self.loss_level=loss_level
-
-        # Use float64 for accuracy.
-        betas = np.array(betas, dtype=np.float64)
-        self.betas = betas
-        assert len(betas.shape) == 1, "betas must be 1-D"
-        assert (betas > 0).all() and (betas <= 1).all()
-
-        self.num_timesteps = int(betas.shape[0])
-
-        alphas = 1.0 - betas
-        self.alphas_cumprod = np.cumprod(alphas, axis=0)                     # t
-        self.alphas_cumprod_prev = np.append(1.0, self.alphas_cumprod[:-1])  # t-1
-        self.alphas_cumprod_next = np.append(self.alphas_cumprod[1:], 0.0)   # t+1
-        assert self.alphas_cumprod_prev.shape == (self.num_timesteps,)
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.sqrt_alphas_cumprod = np.sqrt(self.alphas_cumprod)
-        self.sqrt_one_minus_alphas_cumprod = np.sqrt(1.0 - self.alphas_cumprod)
-        self.log_one_minus_alphas_cumprod = np.log(1.0 - self.alphas_cumprod)
-        self.sqrt_recip_alphas_cumprod = np.sqrt(1.0 / self.alphas_cumprod)
-        self.sqrt_recipm1_alphas_cumprod = np.sqrt(1.0 / self.alphas_cumprod - 1)
-
-        # calculations for posterior q(x_{t-1} | x_t, x_0)
-        self.posterior_variance = (
-            betas * (1.0 - self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)
-        )
-        # log calculation clipped because the posterior variance is 0 at the
-        # beginning of the diffusion chain.
-        self.posterior_log_variance_clipped = np.log(
-            np.append(self.posterior_variance[1], self.posterior_variance[1:])
-        )
-        self.posterior_mean_coef1 = (
-            betas * np.sqrt(self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)
-        )
-        self.posterior_mean_coef2 = (
-            (1.0 - self.alphas_cumprod_prev)
-            * np.sqrt(alphas)
-            / (1.0 - self.alphas_cumprod)
-        )
-
-    def q_mean_variance(self, x_start, t):
-        """
-        Get the distribution q(x_t | x_0).
-
-        :param x_start: the [N x C x ...] tensor of noiseless inputs.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :return: A tuple (mean, variance, log_variance), all of x_start's shape.
-        """
-        mean = (
-            _extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start
-        )
-        variance = _extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
-        log_variance = _extract_into_tensor(
-            self.log_one_minus_alphas_cumprod, t, x_start.shape
-        )
-        return mean, variance, log_variance
-
-    def q_sample(self, x_start, t, noise=None):
-        """
-        Diffuse the data for a given number of diffusion steps.
-
-        In other words, sample from q(x_t | x_0).
-
-        :param x_start: the initial data batch.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :param noise: if specified, the split-out normal noise.
-        :return: A noisy version of x_start.
-        """
-        if noise is None:
-            noise = th.randn_like(x_start)
-        assert noise.shape == x_start.shape
-        return (
-                _extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start
-                + _extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape)
-                * noise
-        )
-
-    def q_posterior_mean_variance(self, x_start, x_t, t):
-        """
-        Compute the mean and variance of the diffusion posterior:
-
-            q(x_{t-1} | x_t, x_0)
-
-        """
-       
-        assert x_start.shape == x_t.shape
-        posterior_mean = (
-            _extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start
-            + _extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
-        )
-        posterior_variance = _extract_into_tensor(self.posterior_variance, t, x_t.shape)
-        posterior_log_variance_clipped = _extract_into_tensor(
-            self.posterior_log_variance_clipped, t, x_t.shape
-        )
-        assert (
-            posterior_mean.shape[0]
-            == posterior_variance.shape[0]
-            == posterior_log_variance_clipped.shape[0]
-            == x_start.shape[0]
-        )
-        return posterior_mean, posterior_variance, posterior_log_variance_clipped
-
-    def p_mean_variance(self, model, x, t, clip_denoised=True, denoised_fn=None, model_kwargs=None):
-        """
-        Apply the model to get p(x_{t-1} | x_t), as well as a prediction of
-        the initial x, x_0.
-        :param model: the model, which takes a signal and a batch of timesteps
-                      as input.
-        :param x: the [N x C x ...] tensor at time t.
-        :param t: a 1-D Tensor of timesteps.
-        :param clip_denoised: if True, clip the denoised signal into [-1, 1].
-        :param denoised_fn: if not None, a function which applies to the
-            x_start prediction before it is used to sample. Applies before
-            clip_denoised.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :return: a dict with the following keys:
-                 - 'mean': the model mean output.
-                 - 'variance': the model variance output.
-                 - 'log_variance': the log of 'variance'.
-                 - 'pred_xstart': the prediction for x_0.
-        """
-        if model_kwargs is None:
-            model_kwargs = {}
-
-        B, C = x.shape[:2]
-        
-        assert t.shape == (B,)
-        model_output = model(x, self._scale_timesteps(t), **model_kwargs)
-        
-        if self.model_var_type in [ModelVarType.LEARNED, ModelVarType.LEARNED_RANGE]:
-            assert model_output.shape == (B, C * 2, *x.shape[2:])
-            model_output, model_var_values = th.split(model_output, C, dim=1)
-            if self.model_var_type == ModelVarType.LEARNED:
-                model_log_variance = model_var_values
-                model_variance = th.exp(model_log_variance)
-            else:
-                min_log = _extract_into_tensor(
-                    self.posterior_log_variance_clipped, t, x.shape
-                )
-                max_log = _extract_into_tensor(np.log(self.betas), t, x.shape)
-                # The model_var_values is [-1, 1] for [min_var, max_var].
-                frac = (model_var_values + 1) / 2
-                model_log_variance = frac * max_log + (1 - frac) * min_log
-                model_variance = th.exp(model_log_variance)
-        else:
-            model_variance, model_log_variance = {
-                # for fixedlarge, we set the initial (log-)variance like so
-                # to get a better decoder log likelihood.
-                ModelVarType.FIXED_LARGE: (
-                    np.append(self.posterior_variance[1], self.betas[1:]),
-                    np.log(np.append(self.posterior_variance[1], self.betas[1:])),
-                ),
-                ModelVarType.FIXED_SMALL: (
-                    self.posterior_variance,
-                    self.posterior_log_variance_clipped,
-                ),
-            }[self.model_var_type]
-            model_variance = _extract_into_tensor(model_variance, t, x.shape)
-            model_log_variance = _extract_into_tensor(model_log_variance, t, x.shape)
-
-        def process_xstart(x):
-            if denoised_fn is not None:
-                x = denoised_fn(x)
-            if clip_denoised:
-                B, _, H, W, D = x.size()
-                x_idwt = idwt(x[:, 0, :, :, :].view(B, 1, H, W, D) * 3.,
-                              x[:, 1, :, :, :].view(B, 1, H, W, D),
-                              x[:, 2, :, :, :].view(B, 1, H, W, D),
-                              x[:, 3, :, :, :].view(B, 1, H, W, D),
-                              x[:, 4, :, :, :].view(B, 1, H, W, D),
-                              x[:, 5, :, :, :].view(B, 1, H, W, D),
-                              x[:, 6, :, :, :].view(B, 1, H, W, D),
-                              x[:, 7, :, :, :].view(B, 1, H, W, D))
-
-                x_idwt_clamp = x_idwt.clamp(-1, 1)
-
-                LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = dwt(x_idwt_clamp)
-                x = th.cat([LLL / 3., LLH, LHL, LHH, HLL, HLH, HHL, HHH], dim=1)
-
-                return x
-            return x
-
-        if self.model_mean_type == ModelMeanType.PREVIOUS_X:
-            pred_xstart = process_xstart(
-                self._predict_xstart_from_xprev(x_t=x, t=t, xprev=model_output)
-            )
-            model_mean = model_output
-        elif self.model_mean_type in [ModelMeanType.START_X, ModelMeanType.EPSILON]:
-            if self.model_mean_type == ModelMeanType.START_X:
-                pred_xstart = process_xstart(model_output)
-            else:
-                pred_xstart = process_xstart(
-                    self._predict_xstart_from_eps(x_t=x, t=t, eps=model_output)
-                )
-            model_mean, _, _ = self.q_posterior_mean_variance(
-                x_start=pred_xstart, x_t=x, t=t
-            )
-        else:
-            raise NotImplementedError(self.model_mean_type)
-
-        assert (model_mean.shape == model_log_variance.shape == pred_xstart.shape == x.shape)
-
-
-        return {
-            "mean": model_mean,
-            "variance": model_variance,
-            "log_variance": model_log_variance,
-            "pred_xstart": pred_xstart,
-        }
-  
-    def _predict_xstart_from_eps(self, x_t, t, eps):
-        assert x_t.shape == eps.shape
-        return (
-            _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t
-            - _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * eps
-        )
-
-    def _predict_xstart_from_xprev(self, x_t, t, xprev):
-        assert x_t.shape == xprev.shape
-        return (  # (xprev - coef2*x_t) / coef1
-            _extract_into_tensor(1.0 / self.posterior_mean_coef1, t, x_t.shape) * xprev
-            - _extract_into_tensor(
-                self.posterior_mean_coef2 / self.posterior_mean_coef1, t, x_t.shape
-            )
-            * x_t
-        )
-
-    def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
-        if self.mode == 'segmentation':
-            x_t = x_t[:, -pred_xstart.shape[1]:, ...]
-        assert pred_xstart.shape == x_t.shape
-        eps =  (
-            _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t
-            - pred_xstart
-        ) / _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
-        return eps
-
-    def _scale_timesteps(self, t):
-        if self.rescale_timesteps:
-            return t.float() * (1000.0 / self.num_timesteps)
-        return t
-
-    def condition_mean(self, cond_fn, p_mean_var, x, t, update=None, model_kwargs=None):
-        """
-        Compute the mean for the previous step, given a function cond_fn that
-        computes the gradient of a conditional log probability with respect to
-        x. In particular, cond_fn computes grad(log(p(y|x))), and we want to
-        condition on y.
-
-        This uses the conditioning strategy from Sohl-Dickstein et al. (2015).
-        """
-
-
-        if update is not None:
-            print('CONDITION MEAN UPDATE NOT NONE')
-
-            new_mean = (
-                p_mean_var["mean"].detach().float() + p_mean_var["variance"].detach() * update.float()
-                )
-            a=update
-
-        else:
-           a, gradient = cond_fn(x, self._scale_timesteps(t), **model_kwargs)
-           new_mean = (
-                p_mean_var["mean"].float() + p_mean_var["variance"] * gradient.float()
-            )
-
-        return a, new_mean
-
-
-
-    def condition_score2(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
-        """
-        Compute what the p_mean_variance output would have been, should the
-        model's score function be conditioned by cond_fn.
-        See condition_mean() for details on cond_fn.
-        Unlike condition_mean(), this instead uses the conditioning strategy
-        from Song et al (2020).
-        """
-        t=t.long()
-        alpha_bar = _extract_into_tensor(self.alphas_cumprod, t, x.shape)
-
-        eps = self._predict_eps_from_xstart(x, t, p_mean_var["pred_xstart"])
-        a, cfn= cond_fn(
-            x, self._scale_timesteps(t).long(), **model_kwargs
-        )
-        eps = eps - (1 - alpha_bar).sqrt() * cfn
-
-        out = p_mean_var.copy()
-        out["pred_xstart"] = self._predict_xstart_from_eps(x, t, eps)
-        out["mean"], _, _ = self.q_posterior_mean_variance(
-            x_start=out["pred_xstart"], x_t=x, t=t
-        )
-        return out, cfn
-
-    def sample_known(self, img, batch_size = 1):
-        image_size = self.image_size
-        channels = self.channels
-        return self.p_sample_loop_known(model,(batch_size, channels, image_size, image_size), img)
-
-
-    def p_sample_loop(
-        self,
-        model,
-        shape,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=True,
-    ):
-        """
-        Generate samples from the model.
-
-        :param model: the model module.
-        :param shape: the shape of the samples, (N, C, H, W).
-        :param noise: if specified, the noise from the encoder to sample.
-                      Should be of the same shape as `shape`.
-        :param clip_denoised: if True, clip x_start predictions to [-1, 1].
-        :param denoised_fn: if not None, a function which applies to the
-            x_start prediction before it is used to sample.
-        :param cond_fn: if not None, this is a gradient function that acts
-                        similarly to the model.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :param device: if specified, the device to create the samples on.
-                       If not specified, use a model parameter's device.
-        :param progress: if True, show a tqdm progress bar.
-        :return: a non-differentiable batch of samples.
-        """
-        final = None
-        for sample in self.p_sample_loop_progressive(
-            model,
-            shape,
-            noise=noise,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-        ):
-            final = sample
-        return final["sample"]
-
-    def p_sample(
-            self,
-            model,
-            x,
-            t,
-            clip_denoised=True,
-            denoised_fn=None,
-            cond_fn=None,
-            model_kwargs=None,
-    ):
-        """
-        Sample x_{t-1} from the model at the given timestep.
-        :param model: the model to sample from.
-        :param x: the current tensor at x_{t-1}.
-        :param t: the value of t, starting at 0 for the first diffusion step.
-        :param clip_denoised: if True, clip the x_start prediction to [-1, 1].
-        :param denoised_fn: if not None, a function which applies to the
-            x_start prediction before it is used to sample.
-        :param cond_fn: if not None, this is a gradient function that acts
-                        similarly to the model.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :return: a dict containing the following keys:
-                 - 'sample': a random sample from the model.
-                 - 'pred_xstart': a prediction of x_0.
-        """
-        out = self.p_mean_variance(
-            model,
-            x,
-            t,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            model_kwargs=model_kwargs,
-        )
-        noise = th.randn_like(x)
-        nonzero_mask = (
-            (t != 0).float().view(-1, *([1] * (len(x.shape) - 1)))
-        )  # no noise when t == 0
-        if cond_fn is not None:
-            out["mean"] = self.condition_mean(
-                cond_fn, out, x, t, model_kwargs=model_kwargs
-            )
-        sample = out["mean"] + nonzero_mask * th.exp(0.5 * out["log_variance"]) * noise
-        return {"sample": sample, "pred_xstart": out["pred_xstart"]}
-
-    def p_sample_loop_known(
-        self,
-        model,
-        shape,
-        img,
-        org=None,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        noise_level=500,
-        progress=False,
-        classifier=None
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-
-
-        t = th.randint(499,500, (b,), device=device).long().to(device)
-
-        org=img[0].to(device)
-        img=img[0].to(device)
-        indices = list(range(t))[::-1]
-        noise = th.randn_like(img[:, :4, ...]).to(device)
-        x_noisy = self.q_sample(x_start=img[:, :4, ...], t=t, noise=noise).to(device)
-        x_noisy = torch.cat((x_noisy, img[:, 4:, ...]), dim=1)
-        
-        
-        for sample in self.p_sample_loop_progressive(
-            model,
-            shape,
-            time=noise_level,
-            noise=x_noisy,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            org=org,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-            classifier=classifier
-        ):
-            final = sample
-      
-        return final["sample"], x_noisy, img
-
-    def p_sample_loop_interpolation(
-        self,
-        model,
-        shape,
-        img1,
-        img2,
-        lambdaint,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        t = th.randint(299,300, (b,), device=device).long().to(device)
-        img1=torch.tensor(img1).to(device)
-        img2 = torch.tensor(img2).to(device)
-        noise = th.randn_like(img1).to(device)
-        x_noisy1 = self.q_sample(x_start=img1, t=t, noise=noise).to(device)
-        x_noisy2 = self.q_sample(x_start=img2, t=t, noise=noise).to(device)
-        interpol=lambdaint*x_noisy1+(1-lambdaint)*x_noisy2
-        for sample in self.p_sample_loop_progressive(
-            model,
-            shape,
-            time=t,
-            noise=interpol,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-        ):
-            final = sample
-        return final["sample"], interpol, img1, img2
-
-
-    def p_sample_loop_progressive(
-        self,
-        model,
-        shape,
-        time=1000,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=True,
-    ):
-        """
-        Generate samples from the model and yield intermediate samples from
-        each timestep of diffusion.
-
-        Arguments are the same as p_sample_loop().
-        Returns a generator over dicts, where each dict is the return value of
-        p_sample().
-        """
-
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        if noise is not None:
-            img = noise
-        else:
-            img = th.randn(*shape, device=device)
-      
-        indices = list(range(time))[::-1]
-        if progress:
-            # Lazy import so that we don't depend on tqdm.
-            from tqdm.auto import tqdm
-            indices = tqdm(indices)
-
-        for i in indices:
-            t = th.tensor([i] * shape[0], device=device)
-            with th.no_grad():
-                out = self.p_sample(
-                    model,
-                    img,
-                    t,
-                    clip_denoised=clip_denoised,
-                    denoised_fn=denoised_fn,
-                    cond_fn=cond_fn,
-                    model_kwargs=model_kwargs,
-                )
-                yield out
-                img = out["sample"]
-
-    def ddim_sample(
-            self,
-            model,
-            x,
-            t,  # index of current step
-            t_cpu=None,
-            t_prev=None,  # index of step that we are going to compute,  only used for heun
-            t_prev_cpu=None,
-            clip_denoised=True,
-            denoised_fn=None,
-            cond_fn=None,
-            model_kwargs=None,
-            eta=0.0,
-            sampling_steps=0,
-    ):
-        """
-        Sample x_{t-1} from the model using DDIM.
-        Same usage as p_sample().
-        """
-        relerr = lambda x, y: (x-y).abs().sum() / y.abs().sum()
-        if cond_fn is not None:
-            out, saliency = self.condition_score2(cond_fn, out, x, t, model_kwargs=model_kwargs)
-        out = self.p_mean_variance(
-            model,
-            x,
-            t,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            model_kwargs=model_kwargs,
-        )
-        eps_orig = self._predict_eps_from_xstart(x_t=x, t=t, pred_xstart=out["pred_xstart"]) 
-        if self.mode == 'default':
-            shape = x.shape
-        elif self.mode == 'segmentation':
-            shape = eps_orig.shape
-        else:
-            raise NotImplementedError(f'mode "{self.mode}" not implemented')
-
-        if not sampling_steps:
-            alpha_bar_orig = _extract_into_tensor(self.alphas_cumprod, t, shape)          
-            alpha_bar_prev_orig = _extract_into_tensor(self.alphas_cumprod_prev, t, shape)
-        else:
-            xp = np.arange(0, 1000, 1, dtype=np.float)
-            alpha_cumprod_fun = interp1d(xp, self.alphas_cumprod,
-                                         bounds_error=False,
-                                         fill_value=(self.alphas_cumprod[0], self.alphas_cumprod[-1]),
-                                         )
-            alpha_bar_orig      = alpha_cumprod_fun(t_cpu).item()
-            alpha_bar_prev_orig = alpha_cumprod_fun(t_prev_cpu).item()
-        sigma = (
-                eta
-                * ((1 - alpha_bar_prev_orig) / (1 - alpha_bar_orig))**.5
-                * (1 - alpha_bar_orig / alpha_bar_prev_orig)**.5
-        )
-        noise = th.randn(size=shape, device=x.device)
-        mean_pred = (
-                out["pred_xstart"] * alpha_bar_prev_orig**.5
-                + (1 - alpha_bar_prev_orig - sigma ** 2)**.5 * eps_orig
-        )
-        nonzero_mask = (
-            (t != 0).float().view(-1, *([1] * (len(shape) - 1)))
-        )
-        sample = mean_pred + nonzero_mask * sigma * noise
-        return {"sample": mean_pred, "pred_xstart": out["pred_xstart"]}
-
-
-    def ddim_reverse_sample(
-        self,
-        model,
-        x,
-        t,
-        clip_denoised=True,
-        denoised_fn=None,
-        model_kwargs=None,
-        eta=0.0,
-    ):
-        """
-        Sample x_{t+1} from the model using DDIM reverse ODE.
-        """
-        assert eta == 0.0, "Reverse ODE only for deterministic path"
-        out = self.p_mean_variance(
-            model,
-            x,
-            t,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            model_kwargs=model_kwargs,
-        )
-        # Usually our model outputs epsilon, but we re-derive it
-        # in case we used x_start or x_prev prediction.
-        eps = (
-            _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x.shape) * x
-            - out["pred_xstart"]
-        ) / _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x.shape)
-        alpha_bar_next = _extract_into_tensor(self.alphas_cumprod_next, t, x.shape)
-
-        # Equation 12. reversed
-        mean_pred = (
-            out["pred_xstart"] * th.sqrt(alpha_bar_next)
-            + th.sqrt(1 - alpha_bar_next) * eps
-        )
-
-        return {"sample": mean_pred, "pred_xstart": out["pred_xstart"]}
-
-
-
-    def ddim_sample_loop_interpolation(
-        self,
-        model,
-        shape,
-        img1,
-        img2,
-        lambdaint,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        t = th.randint(199,200, (b,), device=device).long().to(device)
-        img1=torch.tensor(img1).to(device)
-        img2 = torch.tensor(img2).to(device)
-        noise = th.randn_like(img1).to(device)
-        x_noisy1 = self.q_sample(x_start=img1, t=t, noise=noise).to(device)
-        x_noisy2 = self.q_sample(x_start=img2, t=t, noise=noise).to(device)
-        interpol=lambdaint*x_noisy1+(1-lambdaint)*x_noisy2
-        for sample in self.ddim_sample_loop_progressive(
-            model,
-            shape,
-            time=t,
-            noise=interpol,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-        ):
-            final = sample
-        return final["sample"], interpol, img1, img2
-
-    def ddim_sample_loop(
-        self,
-        model,
-        shape,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-        eta=0.0,
-        sampling_steps=0,
-    ):
-        """
-        Generate samples from the model using DDIM.
-
-        Same usage as p_sample_loop().
-        """
-        final = None
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        #t = th.randint(0,1, (b,), device=device).long().to(device)
-        t = 1000
-        for sample in self.ddim_sample_loop_progressive(
-            model,
-            shape,
-            time=t,
-            noise=noise,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-            eta=eta,
-            sampling_steps=sampling_steps,
-        ):
-
-            final = sample
-        return final["sample"]
-
-
-
-    def ddim_sample_loop_known(
-            self,
-            model,
-            shape,
-            img,
-            mode='default',
-            org=None,
-            noise=None,
-            clip_denoised=True,
-            denoised_fn=None,
-            cond_fn=None,
-            model_kwargs=None,
-            device=None,
-            noise_level=1000, # must be same as in training
-            progress=False,
-            conditioning=False,
-            conditioner=None,
-            classifier=None,
-            eta=0.0,
-            sampling_steps=0,
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        t = th.randint(0,1, (b,), device=device).long().to(device)
-        img = img.to(device)
-        
-        indices = list(range(t))[::-1]
-        if mode == 'segmentation':
-            noise = None
-            x_noisy = None
-        elif mode == 'default':
-            noise = None
-            x_noisy = None
-        else:
-            raise NotImplementedError(f'mode "{mode}" not implemented')
-
-        final = None
-        # pass images to be segmented as condition
-        for sample in self.ddim_sample_loop_progressive(
-            model,
-            shape,
-            segmentation_img=img,  # image to be segmented
-            time=noise_level,
-            noise=x_noisy,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-            eta=eta,
-            sampling_steps=sampling_steps,
-        ):
-            final = sample
-
-        return final["sample"], x_noisy, img
-
-
-    def ddim_sample_loop_progressive(
-        self,
-        model,
-        shape,
-        segmentation_img=None,  # define to perform segmentation
-        time=1000,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-        eta=0.0,
-        sampling_steps=0,
-    ):
-        """
-        Use DDIM to sample from the model and yield intermediate samples from
-        each timestep of DDIM.
-
-        Same usage as p_sample_loop_progressive().
-        """
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        if noise is not None:
-            img = noise
-        else:
-            if segmentation_img is None:  # normal sampling
-                img = th.randn(*shape, device=device)
-            else:                         # segmentation mode
-                label_shape = (segmentation_img.shape[0], model.out_channels, *segmentation_img.shape[2:])
-                img = th.randn(label_shape, dtype=segmentation_img.dtype, device=segmentation_img.device)
-
-        indices = list(range(time))[::-1] # klappt nur für batch_size == 1
-
-
-        if sampling_steps:
-            tmp = np.linspace(999, 0, sampling_steps)
-            tmp = np.append(tmp, -tmp[-2])
-            indices = tmp[:-1].round().astype(np.int)
-            indices_prev = tmp[1:].round().astype(np.int)
-        else:
-            indices_prev = [i-1 for i in indices]
-
-        if True: #progress:
-            # Lazy import so that we don't depend on tqdm.
-            from tqdm.auto import tqdm
-
-            indices = tqdm(indices)
-
-        for i, i_prev in zip(indices, indices_prev): # 1000 -> 0
-            if segmentation_img is not None:
-                prev_img = img
-                img = th.cat((segmentation_img, img), dim=1)
-            t = th.tensor([i] * shape[0], device=device)
-            t_prev = th.tensor([i_prev] * shape[0], device=device)
-            with th.no_grad():
-                out = self.ddim_sample(
-                   model,
-                   img,
-                   t,
-                   t_cpu=i,
-                   t_prev=t_prev,
-                   t_prev_cpu=i_prev,
-                   clip_denoised=clip_denoised,
-                   denoised_fn=denoised_fn,
-                   cond_fn=cond_fn,
-                   model_kwargs=model_kwargs,
-                   eta=eta,
-                   sampling_steps=sampling_steps,
-                )
-                yield out
-                img = out["sample"]
-
-    def _vb_terms_bpd(
-        self, model, x_start, x_t, t, clip_denoised=True, model_kwargs=None
-    ):
-        """
-        Get a term for the variational lower-bound.
-
-        The resulting units are bits (rather than nats, as one might expect).
-        This allows for comparison to other papers.
-
-        :return: a dict with the following keys:
-                 - 'output': a shape [N] tensor of NLLs or KLs.
-                 - 'pred_xstart': the x_0 predictions.
-        """
-        true_mean, _, true_log_variance_clipped = self.q_posterior_mean_variance(
-            x_start=x_start, x_t=x_t, t=t
-        )
-        out = self.p_mean_variance(
-            model, x_t, t, clip_denoised=clip_denoised, model_kwargs=model_kwargs
-        )
-        kl = normal_kl(
-            true_mean, true_log_variance_clipped, out["mean"], out["log_variance"]
-        )
-        kl = mean_flat(kl) / np.log(2.0)
-
-        decoder_nll = -discretized_gaussian_log_likelihood(
-            x_start, means=out["mean"], log_scales=0.5 * out["log_variance"]
-        )
-        assert decoder_nll.shape == x_start.shape
-        decoder_nll = mean_flat(decoder_nll) / np.log(2.0)
-
-        # At the first timestep return the decoder NLL,
-        # otherwise return KL(q(x_{t-1}|x_t,x_0) || p(x_{t-1}|x_t))
-        output = th.where((t == 0), decoder_nll, kl)
-        return {"output": output, "pred_xstart": out["pred_xstart"]}
-
-    def training_losses(self, model,  x_start, t, classifier=None, model_kwargs=None, noise=None, labels=None,
-                        mode='default'):
-        """
-        Compute training losses for a single timestep.
-        :param model: the model to evaluate loss on.
-        :param x_start: the [N x C x ...] tensor of inputs - original image resolution.
-        :param t: a batch of timestep indices.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :param noise: if specified, the specific Gaussian noise to try to remove.
-        :param labels: must be specified for mode='segmentation'
-        :param mode:  can be default (image generation), segmentation
-        :return: a dict with the key "loss" containing a tensor of shape [N].
-                 Some mean or variance settings may also have other keys.
-        """
-        if model_kwargs is None:
-            model_kwargs = {}
-
-        # Wavelet transform the input image
-        LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = dwt(x_start)
-        x_start_dwt = th.cat([LLL / 3., LLH, LHL, LHH, HLL, HLH, HHL, HHH], dim=1)
-
-        if mode == 'default':
-            noise = th.randn_like(x_start)  # Sample noise - original image resolution.
-            LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = dwt(noise)
-            noise_dwt = th.cat([LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH], dim=1)  # Wavelet transformed noise
-            x_t = self.q_sample(x_start_dwt, t, noise=noise_dwt)  # Sample x_t
-
-        else:
-            raise ValueError(f'Invalid mode {mode=}, needs to be "default"')
-
-        model_output = model(x_t, self._scale_timesteps(t), **model_kwargs)  # Model outputs denoised wavelet subbands
-
-        # Inverse wavelet transform the model output
-        B, _, H, W, D = model_output.size()
-        model_output_idwt = idwt(model_output[:, 0, :, :, :].view(B, 1, H, W, D) * 3.,
-                                 model_output[:, 1, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 2, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 3, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 4, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 5, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 6, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 7, :, :, :].view(B, 1, H, W, D))
-
-        terms = {"mse_wav": th.mean(mean_flat((x_start_dwt - model_output) ** 2), dim=0)}
-
-        return terms, model_output, model_output_idwt
-
-
-    def _prior_bpd(self, x_start):
-        """
-        Get the prior KL term for the variational lower-bound, measured in
-        bits-per-dim.
-
-        This term can't be optimized, as it only depends on the encoder.
-
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :return: a batch of [N] KL values (in bits), one per batch element.
-        """
-        batch_size = x_start.shape[0]
-        t = th.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
-        qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
-        kl_prior = normal_kl(
-            mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0
-        )
-        return mean_flat(kl_prior) / np.log(2.0)
-
-    def calc_bpd_loop(self, model, x_start, clip_denoised=True, model_kwargs=None):
-        """
-        Compute the entire variational lower-bound, measured in bits-per-dim,
-        as well as other related quantities.
-
-        :param model: the model to evaluate loss on.
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :param clip_denoised: if True, clip denoised samples.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-
-        :return: a dict containing the following keys:
-                 - total_bpd: the total variational lower-bound, per batch element.
-                 - prior_bpd: the prior term in the lower-bound.
-                 - vb: an [N x T] tensor of terms in the lower-bound.
-                 - xstart_mse: an [N x T] tensor of x_0 MSEs for each timestep.
-                 - mse: an [N x T] tensor of epsilon MSEs for each timestep.
-        """
-        device = x_start.device
-        batch_size = x_start.shape[0]
-
-        vb = []
-        xstart_mse = []
-        mse = []
-        for t in list(range(self.num_timesteps))[::-1]:
-            t_batch = th.tensor([t] * batch_size, device=device)
-            noise = th.randn_like(x_start)
-            x_t = self.q_sample(x_start=x_start, t=t_batch, noise=noise)
-
-            # Calculate VLB term at the current timestep
-            with th.no_grad():
-                out = self._vb_terms_bptimestepsd(
-                    model,
-                    x_start=x_start,
-                    x_t=x_t,
-                    t=t_batch,
-                    clip_denoised=clip_denoised,
-                    model_kwargs=model_kwargs,
-                )
-            vb.append(out["output"])
-            xstart_mse.append(mean_flat((out["pred_xstart"] - x_start) ** 2))
-            eps = self._predict_eps_from_xstart(x_t, t_batch, out["pred_xstart"])
-            mse.append(mean_flat((eps - noise) ** 2))
-
-        vb = th.stack(vb, dim=1)
-        xstart_mse = th.stack(xstart_mse, dim=1)
-        mse = th.stack(mse, dim=1)
-
-        prior_bpd = self._prior_bpd(x_start)
-        total_bpd = vb.sum(dim=1) + prior_bpd
-        return {
-            "total_bpd": total_bpd,
-            "prior_bpd": prior_bpd,
-            "vb": vb,
-            "xstart_mse": xstart_mse,
-            "mse": mse,
-        }
-
-
-def _extract_into_tensor(arr, timesteps, broadcast_shape):
-    """
-    Extract values from a 1-D numpy array for a batch of indices.
-
-    :param arr: the 1-D numpy array.
-    :param timesteps: a tensor of indices into the array to extract.
-    :param broadcast_shape: a larger shape of K dimensions with the batch
-                            dimension equal to the length of timesteps.
-    :return: a tensor of shape [batch_size, 1, ...] where the shape has K dims.
-    """
-    res = th.from_numpy(arr).to(device=timesteps.device)[timesteps].float()
-    while len(res.shape) < len(broadcast_shape):
-        res = res[..., None]
-    return res.expand(broadcast_shape)

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/inpaintloader-checkpoint.py

@@ -1,131 +0,0 @@
-import os, nibabel, torch, numpy as np
-import torch.nn as nn
-from torch.utils.data import Dataset
-import pandas as pd
-import re
-
-
-class InpaintVolumes(Dataset):
-    """
-    Y  : float32  [C, D, H, W]   full multi-modal MRI stack
-    M  : float32  [1, D, H, W]   binary in-painting mask (shared by all mods)
-    Y_void = Y * (1 - M)         context with lesion region blanked
-    name : identifier string
-    """
-
-    # ------------------------------------------------------------
-    def __init__(self,
-                 root_dir: str,
-                 subset: str = 'train',          # 'train' | 'val'
-                 img_size: int = 256,            # 128 or 256 cube
-                 modalities: tuple = ('T1w',),    # order defines channel order
-                 normalize=None):
-        super().__init__()
-        self.root_dir   = os.path.expanduser(root_dir)
-        self.subset     = subset
-        self.img_size   = img_size
-        self.modalities = modalities           
-        self.normalize  = normalize or (lambda x: x)
-        self.cases      = self._index_cases()   # ⇒ list[dict]
-
-    # ------------------------------------------------------------
-    def _index_cases(self):
-        """
-        Build a list like:
-            {'img': {'T1w': path, 'FLAIR': path, ...},
-             'mask': path,
-             'name': case_id}
-        Edit only this block to suit your folder / filename scheme.
-        """
-        cases = []
-        
-        # metadata
-        df = pd.read_csv(f"{self.root_dir}/participants.tsv", sep="\t") 
-        # update with new splits
-        
-        # filter FCD samples
-        fcd_df = df[df['group'] == 'fcd'].copy()
-        # shuffle indices
-        fcd_df = fcd_df.sample(frac=1, random_state=42).reset_index(drop=True)
-        # compute split index
-        n_train = int(len(fcd_df) * 0.9)
-        # assign split labels
-        fcd_df.loc[:n_train-1, 'split'] = 'train'
-        fcd_df.loc[n_train:, 'split'] = 'val'
-        #update
-        df.loc[fcd_df.index, 'split'] = fcd_df['split']
-
-        missing = []
-        
-        for participant_id in df[(df['split']==self.subset) & (df['group']=='fcd')]['participant_id']:
-            case_dir = f"{self.root_dir}/{participant_id}/anat/"
-            files = os.listdir(case_dir)
-            
-            img_dict = {}
-            for mod in self.modalities:
-                pattern = re.compile(rf"^{re.escape(participant_id)}.*{re.escape(mod)}\.nii\.gz$")
-                matches = [f for f in files if pattern.match(f)]
-                assert matches, f"Missing {mod} for {participant_id} in {case_dir}"
-                img_dict[mod] = os.path.join(case_dir, matches[0])
-
-            mask_matches = [f for f in files if re.match(rf"^{re.escape(participant_id)}.*roi\.nii\.gz$", f)]
-            mask_path = os.path.join(case_dir, mask_matches[0])
-
-            cases.append({'img': img_dict, 'mask': mask_path, 'name': participant_id})
-        
-        return cases
-
-    # ------------------------------------------------------------
-    def _pad_to_cube(self, vol, fill=0.0):
-        """Symmetric 3-D pad to [img_size³].  `vol` is [*, D, H, W]."""
-        D, H, W = vol.shape[-3:]
-        pad_D, pad_H, pad_W = self.img_size - D, self.img_size - H, self.img_size - W
-        pad = (pad_W // 2, pad_W - pad_W // 2,
-               pad_H // 2, pad_H - pad_H // 2,
-               pad_D // 2, pad_D - pad_D // 2)
-        return nn.functional.pad(vol, pad, value=fill)
-
-    # ------------------------------------------------------------
-    def __getitem__(self, idx):
-        rec  = self.cases[idx]
-        name = rec['name']
-
-        # ---------- load C modalities --------------------------
-        vols = []
-        for mod in self.modalities:                       
-            mod_path = rec['img'][mod]                    
-            arr = nibabel.load(mod_path).get_fdata().astype(np.float32)
-            
-            # robust min-max clipping and normalization
-            lo, hi = np.quantile(arr, [0.001, 0.999])
-            arr = np.clip(arr, lo, hi)
-            arr = (arr - lo) / (hi - lo + 1e-6)
-        
-            vols.append(torch.from_numpy(arr))
-
-        first_mod = self.modalities[0]
-        nii_obj   = nibabel.load(rec['img'][first_mod])
-        affine    = nii_obj.affine
-        
-        Y = torch.stack(vols, dim=0)            # [C, D, H, W]
-
-        # ---------- load mask ----------------------------------
-        M_arr = nibabel.load(rec['mask']).get_fdata().astype(np.uint8)
-        M = torch.from_numpy(M_arr).unsqueeze(0)      # [1, D, H, W]
-        M = (M > 0).to(Y.dtype)
-
-        # ---------- pad (and optional downsample) --------------
-        Y = self._pad_to_cube(Y, fill=0.0)
-        M = self._pad_to_cube(M, fill=0.0)
-        if self.img_size == 128:
-            pool = nn.AvgPool3d(2, 2)
-            Y = pool(Y);  M = pool(M)
-
-        # ---------- derive context image -----------------------
-        Y_void = Y * (1 - M)
-
-        return Y, M, Y_void, name, affine    # shapes: [C, D, H, W], [1, D, H, W], [C, D, H, W], ...
-
-    # ------------------------------------------------------------
-    def __len__(self):
-        return len(self.cases)

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/lidcloader-checkpoint.py

@@ -1,70 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.utils.data
-import os
-import os.path
-import nibabel
-
-
-class LIDCVolumes(torch.utils.data.Dataset):
-    def __init__(self, directory, test_flag=False, normalize=None, mode='train', img_size=256):
-        '''
-        directory is expected to contain some folder structure:
-                  if some subfolder contains only files, all of these
-                  files are assumed to have the name: processed.nii.gz
-        '''
-        super().__init__()
-        self.mode = mode
-        self.directory = os.path.expanduser(directory)
-        self.normalize = normalize or (lambda x: x)
-        self.test_flag = test_flag
-        self.img_size = img_size
-        self.database = []
-
-        if not self.mode == 'fake':
-            for root, dirs, files in os.walk(self.directory):
-                # if there are no subdirs, we have a datadir
-                if not dirs:
-                    files.sort()
-                    datapoint = dict()
-                    # extract all files as channels
-                    for f in files:
-                        datapoint['image'] = os.path.join(root, f)
-                    if len(datapoint) != 0:
-                        self.database.append(datapoint)
-        else:
-            for root, dirs, files in os.walk(self.directory):
-                for f in files:
-                    datapoint = dict()
-                    datapoint['image'] = os.path.join(root, f)
-                    self.database.append(datapoint)
-
-    def __getitem__(self, x):
-        filedict = self.database[x]
-        name = filedict['image']
-        nib_img = nibabel.load(name)
-        out = nib_img.get_fdata()
-
-        if not self.mode == 'fake':
-            out = torch.Tensor(out)
-
-            image = torch.zeros(1, 256, 256, 256)
-            image[:, :, :, :] = out
-
-            if self.img_size == 128:
-                downsample = nn.AvgPool3d(kernel_size=2, stride=2)
-                image = downsample(image)
-        else:
-            image = torch.tensor(out, dtype=torch.float32)
-            image = image.unsqueeze(dim=0)
-
-        # normalization
-        image = self.normalize(image)
-
-        if self.mode == 'fake':
-            return image, name
-        else:
-            return image
-
-    def __len__(self):
-        return len(self.database)

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/logger-checkpoint.py

@@ -1,495 +0,0 @@
-"""
-Logger copied from OpenAI baselines to avoid extra RL-based dependencies:
-https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/logger.py
-"""
-
-import os
-import sys
-import shutil
-import os.path as osp
-import json
-import time
-import datetime
-import tempfile
-import warnings
-from collections import defaultdict
-from contextlib import contextmanager
-
-DEBUG = 10
-INFO = 20
-WARN = 30
-ERROR = 40
-
-DISABLED = 50
-
-
-class KVWriter(object):
-    def writekvs(self, kvs):
-        raise NotImplementedError
-
-
-class SeqWriter(object):
-    def writeseq(self, seq):
-        raise NotImplementedError
-
-
-class HumanOutputFormat(KVWriter, SeqWriter):
-    def __init__(self, filename_or_file):
-        if isinstance(filename_or_file, str):
-            self.file = open(filename_or_file, "wt")
-            self.own_file = True
-        else:
-            assert hasattr(filename_or_file, "read"), (
-                "expected file or str, got %s" % filename_or_file
-            )
-            self.file = filename_or_file
-            self.own_file = False
-
-    def writekvs(self, kvs):
-        # Create strings for printing
-        key2str = {}
-        for (key, val) in sorted(kvs.items()):
-            if hasattr(val, "__float__"):
-                valstr = "%-8.3g" % val
-            else:
-                valstr = str(val)
-            key2str[self._truncate(key)] = self._truncate(valstr)
-
-        # Find max widths
-        if len(key2str) == 0:
-            print("WARNING: tried to write empty key-value dict")
-            return
-        else:
-            keywidth = max(map(len, key2str.keys()))
-            valwidth = max(map(len, key2str.values()))
-
-        # Write out the data
-        dashes = "-" * (keywidth + valwidth + 7)
-        lines = [dashes]
-        for (key, val) in sorted(key2str.items(), key=lambda kv: kv[0].lower()):
-            lines.append(
-                "| %s%s | %s%s |"
-                % (key, " " * (keywidth - len(key)), val, " " * (valwidth - len(val)))
-            )
-        lines.append(dashes)
-        self.file.write("\n".join(lines) + "\n")
-
-        # Flush the output to the file
-        self.file.flush()
-
-    def _truncate(self, s):
-        maxlen = 30
-        return s[: maxlen - 3] + "..." if len(s) > maxlen else s
-
-    def writeseq(self, seq):
-        seq = list(seq)
-        for (i, elem) in enumerate(seq):
-            self.file.write(elem)
-            if i < len(seq) - 1:  # add space unless this is the last one
-                self.file.write(" ")
-        self.file.write("\n")
-        self.file.flush()
-
-    def close(self):
-        if self.own_file:
-            self.file.close()
-
-
-class JSONOutputFormat(KVWriter):
-    def __init__(self, filename):
-        self.file = open(filename, "wt")
-
-    def writekvs(self, kvs):
-        for k, v in sorted(kvs.items()):
-            if hasattr(v, "dtype"):
-                kvs[k] = float(v)
-        self.file.write(json.dumps(kvs) + "\n")
-        self.file.flush()
-
-    def close(self):
-        self.file.close()
-
-
-class CSVOutputFormat(KVWriter):
-    def __init__(self, filename):
-        self.file = open(filename, "w+t")
-        self.keys = []
-        self.sep = ","
-
-    def writekvs(self, kvs):
-        # Add our current row to the history
-        extra_keys = list(kvs.keys() - self.keys)
-        extra_keys.sort()
-        if extra_keys:
-            self.keys.extend(extra_keys)
-            self.file.seek(0)
-            lines = self.file.readlines()
-            self.file.seek(0)
-            for (i, k) in enumerate(self.keys):
-                if i > 0:
-                    self.file.write(",")
-                self.file.write(k)
-            self.file.write("\n")
-            for line in lines[1:]:
-                self.file.write(line[:-1])
-                self.file.write(self.sep * len(extra_keys))
-                self.file.write("\n")
-        for (i, k) in enumerate(self.keys):
-            if i > 0:
-                self.file.write(",")
-            v = kvs.get(k)
-            if v is not None:
-                self.file.write(str(v))
-        self.file.write("\n")
-        self.file.flush()
-
-    def close(self):
-        self.file.close()
-
-
-class TensorBoardOutputFormat(KVWriter):
-    """
-    Dumps key/value pairs into TensorBoard's numeric format.
-    """
-
-    def __init__(self, dir):
-        os.makedirs(dir, exist_ok=True)
-        self.dir = dir
-        self.step = 1
-        prefix = "events"
-        path = osp.join(osp.abspath(dir), prefix)
-        import tensorflow as tf
-        from tensorflow.python import pywrap_tensorflow
-        from tensorflow.core.util import event_pb2
-        from tensorflow.python.util import compat
-
-        self.tf = tf
-        self.event_pb2 = event_pb2
-        self.pywrap_tensorflow = pywrap_tensorflow
-        self.writer = pywrap_tensorflow.EventsWriter(compat.as_bytes(path))
-
-    def writekvs(self, kvs):
-        def summary_val(k, v):
-            kwargs = {"tag": k, "simple_value": float(v)}
-            return self.tf.Summary.Value(**kwargs)
-
-        summary = self.tf.Summary(value=[summary_val(k, v) for k, v in kvs.items()])
-        event = self.event_pb2.Event(wall_time=time.time(), summary=summary)
-        event.step = (
-            self.step
-        )  # is there any reason why you'd want to specify the step?
-        self.writer.WriteEvent(event)
-        self.writer.Flush()
-        self.step += 1
-
-    def close(self):
-        if self.writer:
-            self.writer.Close()
-            self.writer = None
-
-
-def make_output_format(format, ev_dir, log_suffix=""):
-    os.makedirs(ev_dir, exist_ok=True)
-    if format == "stdout":
-        return HumanOutputFormat(sys.stdout)
-    elif format == "log":
-        return HumanOutputFormat(osp.join(ev_dir, "log%s.txt" % log_suffix))
-    elif format == "json":
-        return JSONOutputFormat(osp.join(ev_dir, "progress%s.json" % log_suffix))
-    elif format == "csv":
-        return CSVOutputFormat(osp.join(ev_dir, "progress%s.csv" % log_suffix))
-    elif format == "tensorboard":
-        return TensorBoardOutputFormat(osp.join(ev_dir, "tb%s" % log_suffix))
-    else:
-        raise ValueError("Unknown format specified: %s" % (format,))
-
-
-# ================================================================
-# API
-# ================================================================
-
-
-def logkv(key, val):
-    """
-    Log a value of some diagnostic
-    Call this once for each diagnostic quantity, each iteration
-    If called many times, last value will be used.
-    """
-    get_current().logkv(key, val)
-
-
-def logkv_mean(key, val):
-    """
-    The same as logkv(), but if called many times, values averaged.
-    """
-    get_current().logkv_mean(key, val)
-
-
-def logkvs(d):
-    """
-    Log a dictionary of key-value pairs
-    """
-    for (k, v) in d.items():
-        logkv(k, v)
-
-
-def dumpkvs():
-    """
-    Write all of the diagnostics from the current iteration
-    """
-    return get_current().dumpkvs()
-
-
-def getkvs():
-    return get_current().name2val
-
-
-def log(*args, level=INFO):
-    """
-    Write the sequence of args, with no separators, to the console and output files (if you've configured an output file).
-    """
-    get_current().log(*args, level=level)
-
-
-def debug(*args):
-    log(*args, level=DEBUG)
-
-
-def info(*args):
-    log(*args, level=INFO)
-
-
-def warn(*args):
-    log(*args, level=WARN)
-
-
-def error(*args):
-    log(*args, level=ERROR)
-
-
-def set_level(level):
-    """
-    Set logging threshold on current logger.
-    """
-    get_current().set_level(level)
-
-
-def set_comm(comm):
-    get_current().set_comm(comm)
-
-
-def get_dir():
-    """
-    Get directory that log files are being written to.
-    will be None if there is no output directory (i.e., if you didn't call start)
-    """
-    return get_current().get_dir()
-
-
-record_tabular = logkv
-dump_tabular = dumpkvs
-
-
-@contextmanager
-def profile_kv(scopename):
-    logkey = "wait_" + scopename
-    tstart = time.time()
-    try:
-        yield
-    finally:
-        get_current().name2val[logkey] += time.time() - tstart
-
-
-def profile(n):
-    """
-    Usage:
-    @profile("my_func")
-    def my_func(): code
-    """
-
-    def decorator_with_name(func):
-        def func_wrapper(*args, **kwargs):
-            with profile_kv(n):
-                return func(*args, **kwargs)
-
-        return func_wrapper
-
-    return decorator_with_name
-
-
-# ================================================================
-# Backend
-# ================================================================
-
-
-def get_current():
-    if Logger.CURRENT is None:
-        _configure_default_logger()
-
-    return Logger.CURRENT
-
-
-class Logger(object):
-    DEFAULT = None  # A logger with no output files. (See right below class definition)
-    # So that you can still log to the terminal without setting up any output files
-    CURRENT = None  # Current logger being used by the free functions above
-
-    def __init__(self, dir, output_formats, comm=None):
-        self.name2val = defaultdict(float)  # values this iteration
-        self.name2cnt = defaultdict(int)
-        self.level = INFO
-        self.dir = dir
-        self.output_formats = output_formats
-        self.comm = comm
-
-    # Logging API, forwarded
-    # ----------------------------------------
-    def logkv(self, key, val):
-        self.name2val[key] = val
-
-    def logkv_mean(self, key, val):
-        oldval, cnt = self.name2val[key], self.name2cnt[key]
-        self.name2val[key] = oldval * cnt / (cnt + 1) + val / (cnt + 1)
-        self.name2cnt[key] = cnt + 1
-
-    def dumpkvs(self):
-        if self.comm is None:
-            d = self.name2val
-        else:
-            d = mpi_weighted_mean(
-                self.comm,
-                {
-                    name: (val, self.name2cnt.get(name, 1))
-                    for (name, val) in self.name2val.items()
-                },
-            )
-            if self.comm.rank != 0:
-                d["dummy"] = 1  # so we don't get a warning about empty dict
-        out = d.copy()  # Return the dict for unit testing purposes
-        for fmt in self.output_formats:
-            if isinstance(fmt, KVWriter):
-                fmt.writekvs(d)
-        self.name2val.clear()
-        self.name2cnt.clear()
-        return out
-
-    def log(self, *args, level=INFO):
-        if self.level <= level:
-            self._do_log(args)
-
-    # Configuration
-    # ----------------------------------------
-    def set_level(self, level):
-        self.level = level
-
-    def set_comm(self, comm):
-        self.comm = comm
-
-    def get_dir(self):
-        return self.dir
-
-    def close(self):
-        for fmt in self.output_formats:
-            fmt.close()
-
-    # Misc
-    # ----------------------------------------
-    def _do_log(self, args):
-        for fmt in self.output_formats:
-            if isinstance(fmt, SeqWriter):
-                fmt.writeseq(map(str, args))
-
-
-def get_rank_without_mpi_import():
-    # check environment variables here instead of importing mpi4py
-    # to avoid calling MPI_Init() when this module is imported
-    for varname in ["PMI_RANK", "OMPI_COMM_WORLD_RANK"]:
-        if varname in os.environ:
-            return int(os.environ[varname])
-    return 0
-
-
-def mpi_weighted_mean(comm, local_name2valcount):
-    """
-    Copied from: https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/mpi_util.py#L110
-    Perform a weighted average over dicts that are each on a different node
-    Input: local_name2valcount: dict mapping key -> (value, count)
-    Returns: key -> mean
-    """
-    all_name2valcount = comm.gather(local_name2valcount)
-    if comm.rank == 0:
-        name2sum = defaultdict(float)
-        name2count = defaultdict(float)
-        for n2vc in all_name2valcount:
-            for (name, (val, count)) in n2vc.items():
-                try:
-                    val = float(val)
-                except ValueError:
-                    if comm.rank == 0:
-                        warnings.warn(
-                            "WARNING: tried to compute mean on non-float {}={}".format(
-                                name, val
-                            )
-                        )
-                else:
-                    name2sum[name] += val * count
-                    name2count[name] += count
-        return {name: name2sum[name] / name2count[name] for name in name2sum}
-    else:
-        return {}
-
-
-def configure(dir='./results', format_strs=None, comm=None, log_suffix=""):
-    """
-    If comm is provided, average all numerical stats across that comm
-    """
-    if dir is None:
-        dir = os.getenv("OPENAI_LOGDIR")
-    if dir is None:
-        dir = osp.join(
-            tempfile.gettempdir(),
-            datetime.datetime.now().strftime("openai-%Y-%m-%d-%H-%M-%S-%f"),
-        )
-    assert isinstance(dir, str)
-    dir = os.path.expanduser(dir)
-    os.makedirs(os.path.expanduser(dir), exist_ok=True)
-
-    rank = get_rank_without_mpi_import()
-    if rank > 0:
-        log_suffix = log_suffix + "-rank%03i" % rank
-
-    if format_strs is None:
-        if rank == 0:
-            format_strs = os.getenv("OPENAI_LOG_FORMAT", "stdout,log,csv").split(",")
-        else:
-            format_strs = os.getenv("OPENAI_LOG_FORMAT_MPI", "log").split(",")
-    format_strs = filter(None, format_strs)
-    output_formats = [make_output_format(f, dir, log_suffix) for f in format_strs]
-
-    Logger.CURRENT = Logger(dir=dir, output_formats=output_formats, comm=comm)
-    if output_formats:
-        log("Logging to %s" % dir)
-
-
-def _configure_default_logger():
-    configure()
-    Logger.DEFAULT = Logger.CURRENT
-
-
-def reset():
-    if Logger.CURRENT is not Logger.DEFAULT:
-        Logger.CURRENT.close()
-        Logger.CURRENT = Logger.DEFAULT
-        log("Reset logger")
-
-
-@contextmanager
-def scoped_configure(dir=None, format_strs=None, comm=None):
-    prevlogger = Logger.CURRENT
-    configure(dir=dir, format_strs=format_strs, comm=comm)
-    try:
-        yield
-    finally:
-        Logger.CURRENT.close()
-        Logger.CURRENT = prevlogger
-

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/losses-checkpoint.py

@@ -1,77 +0,0 @@
-"""
-Helpers for various likelihood-based losses. These are ported from the original
-Ho et al. diffusion models codebase:
-https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/utils.py
-"""
-
-import numpy as np
-
-import torch as th
-
-
-def normal_kl(mean1, logvar1, mean2, logvar2):
-    """
-    Compute the KL divergence between two gaussians.
-
-    Shapes are automatically broadcasted, so batches can be compared to
-    scalars, among other use cases.
-    """
-    tensor = None
-    for obj in (mean1, logvar1, mean2, logvar2):
-        if isinstance(obj, th.Tensor):
-            tensor = obj
-            break
-    assert tensor is not None, "at least one argument must be a Tensor"
-
-    # Force variances to be Tensors. Broadcasting helps convert scalars to
-    # Tensors, but it does not work for th.exp().
-    logvar1, logvar2 = [
-        x if isinstance(x, th.Tensor) else th.tensor(x).to(tensor)
-        for x in (logvar1, logvar2)
-    ]
-
-    return 0.5 * (
-        -1.0
-        + logvar2
-        - logvar1
-        + th.exp(logvar1 - logvar2)
-        + ((mean1 - mean2) ** 2) * th.exp(-logvar2)
-    )
-
-
-def approx_standard_normal_cdf(x):
-    """
-    A fast approximation of the cumulative distribution function of the
-    standard normal.
-    """
-    return 0.5 * (1.0 + th.tanh(np.sqrt(2.0 / np.pi) * (x + 0.044715 * th.pow(x, 3))))
-
-
-def discretized_gaussian_log_likelihood(x, *, means, log_scales):
-    """
-    Compute the log-likelihood of a Gaussian distribution discretizing to a
-    given image.
-
-    :param x: the target images. It is assumed that this was uint8 values,
-              rescaled to the range [-1, 1].
-    :param means: the Gaussian mean Tensor.
-    :param log_scales: the Gaussian log stddev Tensor.
-    :return: a tensor like x of log probabilities (in nats).
-    """
-    assert x.shape == means.shape == log_scales.shape
-    centered_x = x - means
-    inv_stdv = th.exp(-log_scales)
-    plus_in = inv_stdv * (centered_x + 1.0 / 255.0)
-    cdf_plus = approx_standard_normal_cdf(plus_in)
-    min_in = inv_stdv * (centered_x - 1.0 / 255.0)
-    cdf_min = approx_standard_normal_cdf(min_in)
-    log_cdf_plus = th.log(cdf_plus.clamp(min=1e-12))
-    log_one_minus_cdf_min = th.log((1.0 - cdf_min).clamp(min=1e-12))
-    cdf_delta = cdf_plus - cdf_min
-    log_probs = th.where(
-        x < -0.999,
-        log_cdf_plus,
-        th.where(x > 0.999, log_one_minus_cdf_min, th.log(cdf_delta.clamp(min=1e-12))),
-    )
-    assert log_probs.shape == x.shape
-    return log_probs

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/nn-checkpoint.py

@@ -1,170 +0,0 @@
-"""
-Various utilities for neural networks.
-"""
-
-import math
-
-import torch as th
-import torch.nn as nn
-
-
-# PyTorch 1.7 has SiLU, but we support PyTorch 1.5.
-class SiLU(nn.Module):
-    def forward(self, x):
-        return x * th.sigmoid(x)
-
-
-class GroupNorm32(nn.GroupNorm):
-    def forward(self, x):
-        return super().forward(x.float()).type(x.dtype)
-
-
-def conv_nd(dims, *args, **kwargs):
-    """
-    Create a 1D, 2D, or 3D convolution module.
-    """
-    if dims == 1:
-        return nn.Conv1d(*args, **kwargs)
-    elif dims == 2:
-        return nn.Conv2d(*args, **kwargs)
-    elif dims == 3:
-        return nn.Conv3d(*args, **kwargs)
-    raise ValueError(f"unsupported dimensions: {dims}")
-
-
-def linear(*args, **kwargs):
-    """
-    Create a linear module.
-    """
-    return nn.Linear(*args, **kwargs)
-
-
-def avg_pool_nd(dims, *args, **kwargs):
-    """
-    Create a 1D, 2D, or 3D average pooling module.
-    """
-    if dims == 1:
-        return nn.AvgPool1d(*args, **kwargs)
-    elif dims == 2:
-        return nn.AvgPool2d(*args, **kwargs)
-    elif dims == 3:
-        return nn.AvgPool3d(*args, **kwargs)
-    raise ValueError(f"unsupported dimensions: {dims}")
-
-
-def update_ema(target_params, source_params, rate=0.99):
-    """
-    Update target parameters to be closer to those of source parameters using
-    an exponential moving average.
-
-    :param target_params: the target parameter sequence.
-    :param source_params: the source parameter sequence.
-    :param rate: the EMA rate (closer to 1 means slower).
-    """
-    for targ, src in zip(target_params, source_params):
-        targ.detach().mul_(rate).add_(src, alpha=1 - rate)
-
-
-def zero_module(module):
-    """
-    Zero out the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().zero_()
-    return module
-
-
-def scale_module(module, scale):
-    """
-    Scale the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().mul_(scale)
-    return module
-
-
-def mean_flat(tensor):
-    """
-    Take the mean over all non-batch dimensions.
-    """
-    return tensor.mean(dim=list(range(2, len(tensor.shape))))
-
-
-def normalization(channels, groups=32):
-    """
-    Make a standard normalization layer.
-
-    :param channels: number of input channels.
-    :return: an nn.Module for normalization.
-    """
-    return GroupNorm32(groups, channels)
-
-
-def timestep_embedding(timesteps, dim, max_period=10000):
-    """
-    Create sinusoidal timestep embeddings.
-
-    :param timesteps: a 1-D Tensor of N indices, one per batch element.
-                      These may be fractional.
-    :param dim: the dimension of the output.
-    :param max_period: controls the minimum frequency of the embeddings.
-    :return: an [N x dim] Tensor of positional embeddings.
-    """
-    half = dim // 2
-    freqs = th.exp(
-        -math.log(max_period) * th.arange(start=0, end=half, dtype=th.float32) / half
-    ).to(device=timesteps.device)
-    args = timesteps[:, None].float() * freqs[None]
-    embedding = th.cat([th.cos(args), th.sin(args)], dim=-1)
-    if dim % 2:
-        embedding = th.cat([embedding, th.zeros_like(embedding[:, :1])], dim=-1)
-    return embedding
-
-
-def checkpoint(func, inputs, params, flag):
-    """
-    Evaluate a function without caching intermediate activations, allowing for
-    reduced memory at the expense of extra compute in the backward pass.
-
-    :param func: the function to evaluate.
-    :param inputs: the argument sequence to pass to `func`.
-    :param params: a sequence of parameters `func` depends on but does not
-                   explicitly take as arguments.
-    :param flag: if False, disable gradient checkpointing.
-    """
-    if flag:
-        args = tuple(inputs) + tuple(params)
-        return CheckpointFunction.apply(func, len(inputs), *args)
-    else:
-        return func(*inputs)
-
-
-class CheckpointFunction(th.autograd.Function):
-    @staticmethod
-    def forward(ctx, run_function, length, *args):
-        ctx.run_function = run_function
-        ctx.input_tensors = list(args[:length])
-        ctx.input_params = list(args[length:])
-        with th.no_grad():
-            output_tensors = ctx.run_function(*ctx.input_tensors)
-        return output_tensors
-
-    @staticmethod
-    def backward(ctx, *output_grads):
-        ctx.input_tensors = [x.detach().requires_grad_(True) for x in ctx.input_tensors]
-        with th.enable_grad():
-            # Fixes a bug where the first op in run_function modifies the
-            # Tensor storage in place, which is not allowed for detach()'d
-            # Tensors.
-            shallow_copies = [x.view_as(x) for x in ctx.input_tensors]
-            output_tensors = ctx.run_function(*shallow_copies)
-        input_grads = th.autograd.grad(
-            output_tensors,
-            ctx.input_tensors + ctx.input_params,
-            output_grads,
-            allow_unused=True,
-        )
-        del ctx.input_tensors
-        del ctx.input_params
-        del output_tensors
-        return (None, None) + input_grads

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/resample-checkpoint.py

@@ -1,154 +0,0 @@
-from abc import ABC, abstractmethod
-
-import numpy as np
-import torch as th
-import torch.distributed as dist
-
-
-def create_named_schedule_sampler(name, diffusion, maxt):
-    """
-    Create a ScheduleSampler from a library of pre-defined samplers.
-
-    :param name: the name of the sampler.
-    :param diffusion: the diffusion object to sample for.
-    """
-    if name == "uniform":
-        return UniformSampler(diffusion, maxt)
-    elif name == "loss-second-moment":
-        return LossSecondMomentResampler(diffusion)
-    else:
-        raise NotImplementedError(f"unknown schedule sampler: {name}")
-
-
-class ScheduleSampler(ABC):
-    """
-    A distribution over timesteps in the diffusion process, intended to reduce
-    variance of the objective.
-
-    By default, samplers perform unbiased importance sampling, in which the
-    objective's mean is unchanged.
-    However, subclasses may override sample() to change how the resampled
-    terms are reweighted, allowing for actual changes in the objective.
-    """
-
-    @abstractmethod
-    def weights(self):
-        """
-        Get a numpy array of weights, one per diffusion step.
-
-        The weights needn't be normalized, but must be positive.
-        """
-
-    def sample(self, batch_size, device):
-        """
-        Importance-sample timesteps for a batch.
-
-        :param batch_size: the number of timesteps.
-        :param device: the torch device to save to.
-        :return: a tuple (timesteps, weights):
-                 - timesteps: a tensor of timestep indices.
-                 - weights: a tensor of weights to scale the resulting losses.
-        """
-        w = self.weights()
-        p = w / np.sum(w)
-        indices_np = np.random.choice(len(p), size=(batch_size,), p=p)
-        indices = th.from_numpy(indices_np).long().to(device)
-        weights_np = 1 / (len(p) * p[indices_np])
-        weights = th.from_numpy(weights_np).float().to(device)
-        return indices, weights
-
-
-class UniformSampler(ScheduleSampler):
-    def __init__(self, diffusion, maxt):
-        self.diffusion = diffusion
-        self._weights = np.ones([maxt])
-
-    def weights(self):
-        return self._weights
-
-
-class LossAwareSampler(ScheduleSampler):
-    def update_with_local_losses(self, local_ts, local_losses):
-        """
-        Update the reweighting using losses from a model.
-
-        Call this method from each rank with a batch of timesteps and the
-        corresponding losses for each of those timesteps.
-        This method will perform synchronization to make sure all of the ranks
-        maintain the exact same reweighting.
-
-        :param local_ts: an integer Tensor of timesteps.
-        :param local_losses: a 1D Tensor of losses.
-        """
-        batch_sizes = [
-            th.tensor([0], dtype=th.int32, device=local_ts.device)
-            for _ in range(dist.get_world_size())
-        ]
-        dist.all_gather(
-            batch_sizes,
-            th.tensor([len(local_ts)], dtype=th.int32, device=local_ts.device),
-        )
-
-        # Pad all_gather batches to be the maximum batch size.
-        batch_sizes = [x.item() for x in batch_sizes]
-        max_bs = max(batch_sizes)
-
-        timestep_batches = [th.zeros(max_bs).to(local_ts) for bs in batch_sizes]
-        loss_batches = [th.zeros(max_bs).to(local_losses) for bs in batch_sizes]
-        dist.all_gather(timestep_batches, local_ts)
-        dist.all_gather(loss_batches, local_losses)
-        timesteps = [
-            x.item() for y, bs in zip(timestep_batches, batch_sizes) for x in y[:bs]
-        ]
-        losses = [x.item() for y, bs in zip(loss_batches, batch_sizes) for x in y[:bs]]
-        self.update_with_all_losses(timesteps, losses)
-
-    @abstractmethod
-    def update_with_all_losses(self, ts, losses):
-        """
-        Update the reweighting using losses from a model.
-
-        Sub-classes should override this method to update the reweighting
-        using losses from the model.
-
-        This method directly updates the reweighting without synchronizing
-        between workers. It is called by update_with_local_losses from all
-        ranks with identical arguments. Thus, it should have deterministic
-        behavior to maintain state across workers.
-
-        :param ts: a list of int timesteps.
-        :param losses: a list of float losses, one per timestep.
-        """
-
-
-class LossSecondMomentResampler(LossAwareSampler):
-    def __init__(self, diffusion, history_per_term=10, uniform_prob=0.001):
-        self.diffusion = diffusion
-        self.history_per_term = history_per_term
-        self.uniform_prob = uniform_prob
-        self._loss_history = np.zeros(
-            [diffusion.num_timesteps, history_per_term], dtype=np.float64
-        )
-        self._loss_counts = np.zeros([diffusion.num_timesteps], dtype=np.int)
-
-    def weights(self):
-        if not self._warmed_up():
-            return np.ones([self.diffusion.num_timesteps], dtype=np.float64)
-        weights = np.sqrt(np.mean(self._loss_history ** 2, axis=-1))
-        weights /= np.sum(weights)
-        weights *= 1 - self.uniform_prob
-        weights += self.uniform_prob / len(weights)
-        return weights
-
-    def update_with_all_losses(self, ts, losses):
-        for t, loss in zip(ts, losses):
-            if self._loss_counts[t] == self.history_per_term:
-                # Shift out the oldest loss term.
-                self._loss_history[t, :-1] = self._loss_history[t, 1:]
-                self._loss_history[t, -1] = loss
-            else:
-                self._loss_history[t, self._loss_counts[t]] = loss
-                self._loss_counts[t] += 1
-
-    def _warmed_up(self):
-        return (self._loss_counts == self.history_per_term).all()

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/respace-checkpoint.py

@@ -1,135 +0,0 @@
-import numpy as np
-import torch as th
-
-from .gaussian_diffusion import GaussianDiffusion
-
-
-def space_timesteps(num_timesteps, section_counts):
-    """
-    Create a list of timesteps to use from an original diffusion process,
-    given the number of timesteps we want to take from equally-sized portions
-    of the original process.
-
-    For example, if there's 300 timesteps and the section counts are [10,15,20]
-    then the first 100 timesteps are strided to be 10 timesteps, the second 100
-    are strided to be 15 timesteps, and the final 100 are strided to be 20.
-
-    If the stride is a string starting with "ddim", then the fixed striding
-    from the DDIM paper is used, and only one section is allowed.
-
-    :param num_timesteps: the number of diffusion steps in the original
-                          process to divide up.
-    :param section_counts: either a list of numbers, or a string containing
-                           comma-separated numbers, indicating the step count
-                           per section. As a special case, use "ddimN" where N
-                           is a number of steps to use the striding from the
-                           DDIM paper.
-    :return: a set of diffusion steps from the original process to use.
-    """
-    if isinstance(section_counts, str):
-        if section_counts.startswith("ddim"):
-            desired_count = int(section_counts[len("ddim") :])
-            print('desired_cound', desired_count )
-            for i in range(1, num_timesteps):
-                if len(range(0, num_timesteps, i)) == desired_count:
-                    return set(range(0, num_timesteps, i))
-            raise ValueError(
-                f"cannot create exactly {num_timesteps} steps with an integer stride"
-            )
-        section_counts = [int(x) for x in section_counts.split(",")]
-    # print('sectioncount', section_counts)
-    size_per = num_timesteps // len(section_counts)
-    extra = num_timesteps % len(section_counts)
-    start_idx = 0
-    all_steps = []
-    for i, section_count in enumerate(section_counts):
-        size = size_per + (1 if i < extra else 0)
-        if size < section_count:
-            raise ValueError(
-                f"cannot divide section of {size} steps into {section_count}"
-            )
-        if section_count <= 1:
-            frac_stride = 1
-        else:
-            frac_stride = (size - 1) / (section_count - 1)
-        cur_idx = 0.0
-        taken_steps = []
-        for _ in range(section_count):
-            taken_steps.append(start_idx + round(cur_idx))
-            cur_idx += frac_stride
-        all_steps += taken_steps
-        start_idx += size
-    return set(all_steps)
-
-
-class SpacedDiffusion(GaussianDiffusion):
-    """
-    A diffusion process which can skip steps in a base diffusion process.
-
-    :param use_timesteps: a collection (sequence or set) of timesteps from the
-                          original diffusion process to retain.
-    :param kwargs: the kwargs to create the base diffusion process.
-    """
-
-    def __init__(self, use_timesteps, **kwargs):
-        self.use_timesteps = set(use_timesteps)
-        self.timestep_map = []
-        self.original_num_steps = len(kwargs["betas"])
-
-        base_diffusion = GaussianDiffusion(**kwargs)  # pylint: disable=missing-kwoa
-        last_alpha_cumprod = 1.0
-        new_betas = []
-        for i, alpha_cumprod in enumerate(base_diffusion.alphas_cumprod):
-            if i in self.use_timesteps:
-                new_betas.append(1 - alpha_cumprod / last_alpha_cumprod)
-                last_alpha_cumprod = alpha_cumprod
-                self.timestep_map.append(i)
-        kwargs["betas"] = np.array(new_betas)
-        super().__init__(**kwargs)
-
-    def p_mean_variance(
-        self, model, *args, **kwargs
-    ):  # pylint: disable=signature-differs
-        return super().p_mean_variance(self._wrap_model(model), *args, **kwargs)
-
-    def training_losses(
-        self, model, *args, **kwargs
-    ):  # pylint: disable=signature-differs
-        return super().training_losses(self._wrap_model(model), *args, **kwargs)
-
-    def condition_mean(self, cond_fn, *args, **kwargs):
-        return super().condition_mean(self._wrap_model(cond_fn), *args, **kwargs)
-
-    def condition_score(self, cond_fn, *args, **kwargs):
-        return super().condition_score(self._wrap_model(cond_fn), *args, **kwargs)
-
-    def _wrap_model(self, model):
-        if isinstance(model, _WrappedModel):
-            return model
-        return _WrappedModel(
-            model, self.timestep_map, self.rescale_timesteps, self.original_num_steps
-        )
-   
-
-    def _scale_timesteps(self, t):
-        # Scaling is done by the wrapped model.
-        return t
-
-
-class _WrappedModel:
-    def __init__(self, model, timestep_map, rescale_timesteps, original_num_steps):
-        self.model = model
-        self.timestep_map = timestep_map
-        self.rescale_timesteps = rescale_timesteps
-        self.original_num_steps = original_num_steps
-
-
-    def __call__(self, x, ts, **kwargs):
-        map_tensor = th.tensor(self.timestep_map, device=ts.device, dtype=ts.dtype)
-        new_ts = map_tensor[ts]
-        if self.rescale_timesteps:
-            new_ts = new_ts.float() * (1000.0 / self.original_num_steps)
-        return self.model(x, new_ts, **kwargs)
-
-
-

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/train_util-checkpoint.py

@@ -1,376 +0,0 @@
-import copy
-import functools
-import os
-
-import blobfile as bf
-import torch as th
-import torch.distributed as dist
-import torch.utils.tensorboard
-from torch.optim import AdamW
-import torch.cuda.amp as amp
-
-import itertools
-
-from . import dist_util, logger
-from .resample import LossAwareSampler, UniformSampler
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-INITIAL_LOG_LOSS_SCALE = 20.0
-
-def visualize(img):
-    _min = img.min()
-    _max = img.max()
-    normalized_img = (img - _min)/ (_max - _min)
-    return normalized_img
-
-class TrainLoop:
-    def __init__(
-        self,
-        *,
-        model,
-        diffusion,
-        data,
-        batch_size,
-        in_channels,
-        image_size,
-        microbatch,
-        lr,
-        ema_rate,
-        log_interval,
-        save_interval,
-        resume_checkpoint,
-        resume_step,
-        use_fp16=False,
-        fp16_scale_growth=1e-3,
-        schedule_sampler=None,
-        weight_decay=0.0,
-        lr_anneal_steps=0,
-        dataset='brats',
-        summary_writer=None,
-        mode='default',
-        loss_level='image',
-    ):
-        self.summary_writer = summary_writer
-        self.mode = mode
-        self.model = model
-        self.diffusion = diffusion
-        self.datal = data
-        self.dataset = dataset
-        self.iterdatal = iter(data)
-        self.batch_size = batch_size
-        self.in_channels = in_channels
-        self.image_size = image_size
-        self.microbatch = microbatch if microbatch > 0 else batch_size
-        self.lr = lr
-        self.ema_rate = (
-            [ema_rate]
-            if isinstance(ema_rate, float)
-            else [float(x) for x in ema_rate.split(",")]
-        )
-        self.log_interval = log_interval
-        self.save_interval = save_interval
-        self.resume_checkpoint = resume_checkpoint
-        self.use_fp16 = use_fp16
-        if self.use_fp16:
-            self.grad_scaler = amp.GradScaler()
-        else:
-            self.grad_scaler = amp.GradScaler(enabled=False)
-
-        self.schedule_sampler = schedule_sampler or UniformSampler(diffusion)
-        self.weight_decay = weight_decay
-        self.lr_anneal_steps = lr_anneal_steps
-
-        self.dwt = DWT_3D('haar')
-        self.idwt = IDWT_3D('haar')
-
-        self.loss_level = loss_level
-
-        self.step = 1
-        self.resume_step = resume_step
-        self.global_batch = self.batch_size * dist.get_world_size()
-
-        self.sync_cuda = th.cuda.is_available()
-
-        self._load_and_sync_parameters()
-
-        self.opt = AdamW(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
-        if self.resume_step:
-            print("Resume Step: " + str(self.resume_step))
-            self._load_optimizer_state()
-
-        if not th.cuda.is_available():
-            logger.warn(
-                "Training requires CUDA. "
-            )
-
-    def _load_and_sync_parameters(self):
-        resume_checkpoint = find_resume_checkpoint() or self.resume_checkpoint
-
-        if resume_checkpoint:
-            print('resume model ...')
-            self.resume_step = parse_resume_step_from_filename(resume_checkpoint)
-            if dist.get_rank() == 0:
-                logger.log(f"loading model from checkpoint: {resume_checkpoint}...")
-                self.model.load_state_dict(
-                    dist_util.load_state_dict(
-                        resume_checkpoint, map_location=dist_util.dev()
-                    )
-                )
-
-        dist_util.sync_params(self.model.parameters())
-
-
-    def _load_optimizer_state(self):
-        main_checkpoint = find_resume_checkpoint() or self.resume_checkpoint
-        opt_checkpoint = bf.join(
-            bf.dirname(main_checkpoint), f"opt{self.resume_step:06}.pt"
-        )
-        if bf.exists(opt_checkpoint):
-            logger.log(f"loading optimizer state from checkpoint: {opt_checkpoint}")
-            state_dict = dist_util.load_state_dict(
-                opt_checkpoint, map_location=dist_util.dev()
-            )
-            self.opt.load_state_dict(state_dict)
-        else:
-            print('no optimizer checkpoint exists')
-
-    def run_loop(self):
-        import time
-        t = time.time()
-        while not self.lr_anneal_steps or self.step + self.resume_step < self.lr_anneal_steps:
-            t_total = time.time() - t
-            t = time.time()
-            if self.dataset in ['brats', 'lidc-idri']:
-                try:
-                    batch = next(self.iterdatal)
-                    cond = {}
-                except StopIteration:
-                    self.iterdatal = iter(self.datal)
-                    batch = next(self.iterdatal)
-                    cond = {}
-
-            batch = batch.to(dist_util.dev())
-
-            t_fwd = time.time()
-            t_load = t_fwd-t
-
-            lossmse, sample, sample_idwt = self.run_step(batch, cond)
-
-            t_fwd = time.time()-t_fwd
-
-            names = ["LLL", "LLH", "LHL", "LHH", "HLL", "HLH", "HHL", "HHH"]
-
-            if self.summary_writer is not None:
-                self.summary_writer.add_scalar('time/load', t_load, global_step=self.step + self.resume_step)
-                self.summary_writer.add_scalar('time/forward', t_fwd, global_step=self.step + self.resume_step)
-                self.summary_writer.add_scalar('time/total', t_total, global_step=self.step + self.resume_step)
-                self.summary_writer.add_scalar('loss/MSE', lossmse.item(), global_step=self.step + self.resume_step)
-
-            if self.step % 200 == 0:
-                image_size = sample_idwt.size()[2]
-                midplane = sample_idwt[0, 0, :, :, image_size // 2]
-                self.summary_writer.add_image('sample/x_0', midplane.unsqueeze(0),
-                                              global_step=self.step + self.resume_step)
-
-                image_size = sample.size()[2]
-                for ch in range(8):
-                    midplane = sample[0, ch, :, :, image_size // 2]
-                    self.summary_writer.add_image('sample/{}'.format(names[ch]), midplane.unsqueeze(0),
-                                                  global_step=self.step + self.resume_step)
-
-            if self.step % self.log_interval == 0:
-                logger.dumpkvs()
-
-            if self.step % self.save_interval == 0:
-                self.save()
-                # Run for a finite amount of time in integration tests.
-                if os.environ.get("DIFFUSION_TRAINING_TEST", "") and self.step > 0:
-                    return
-            self.step += 1
-
-        # Save the last checkpoint if it wasn't already saved.
-        if (self.step - 1) % self.save_interval != 0:
-            self.save()
-
-    def run_step(self, batch, cond, label=None, info=dict()):
-        lossmse, sample, sample_idwt = self.forward_backward(batch, cond, label)
-
-        if self.use_fp16:
-            self.grad_scaler.unscale_(self.opt)  # check self.grad_scaler._per_optimizer_states
-
-        # compute norms
-        with torch.no_grad():
-            param_max_norm = max([p.abs().max().item() for p in self.model.parameters()])
-            grad_max_norm = max([p.grad.abs().max().item() for p in self.model.parameters()])
-            info['norm/param_max'] = param_max_norm
-            info['norm/grad_max'] = grad_max_norm
-
-        if not torch.isfinite(lossmse): #infinite
-            if not torch.isfinite(torch.tensor(param_max_norm)):
-                logger.log(f"Model parameters contain non-finite value {param_max_norm}, entering breakpoint", level=logger.ERROR)
-                breakpoint()
-            else:
-                logger.log(f"Model parameters are finite, but loss is not: {lossmse}"
-                           "\n -> update will be skipped in grad_scaler.step()", level=logger.WARN)
-
-        if self.use_fp16:
-            print("Use fp16 ...")
-            self.grad_scaler.step(self.opt)
-            self.grad_scaler.update()
-            info['scale'] = self.grad_scaler.get_scale()
-        else:
-            self.opt.step()
-        self._anneal_lr()
-        self.log_step()
-        return lossmse, sample, sample_idwt
-
-    def forward_backward(self, batch, cond, label=None):
-        for p in self.model.parameters():  # Zero out gradient
-            p.grad = None
-
-        for i in range(0, batch.shape[0], self.microbatch):
-            micro = batch[i: i + self.microbatch].to(dist_util.dev())
-
-            if label is not None:
-                micro_label = label[i: i + self.microbatch].to(dist_util.dev())
-            else:
-                micro_label = None
-
-            micro_cond = None
-
-            last_batch = (i + self.microbatch) >= batch.shape[0]
-            t, weights = self.schedule_sampler.sample(micro.shape[0], dist_util.dev())
-
-            compute_losses = functools.partial(self.diffusion.training_losses,
-                                               self.model,
-                                               x_start=micro,
-                                               t=t,
-                                               model_kwargs=micro_cond,
-                                               labels=micro_label,
-                                               mode=self.mode,
-                                               )
-            losses1 = compute_losses()
-
-            if isinstance(self.schedule_sampler, LossAwareSampler):
-                self.schedule_sampler.update_with_local_losses(
-                    t, losses1["loss"].detach()
-                )
-
-            losses = losses1[0]         # Loss value
-            sample = losses1[1]         # Denoised subbands at t=0
-            sample_idwt = losses1[2]    # Inverse wavelet transformed denoised subbands at t=0
-
-            # Log wavelet level loss
-            self.summary_writer.add_scalar('loss/mse_wav_lll', losses["mse_wav"][0].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_llh', losses["mse_wav"][1].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_lhl', losses["mse_wav"][2].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_lhh', losses["mse_wav"][3].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hll', losses["mse_wav"][4].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hlh', losses["mse_wav"][5].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hhl', losses["mse_wav"][6].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hhh', losses["mse_wav"][7].item(),
-                                           global_step=self.step + self.resume_step)
-
-            weights = th.ones(len(losses["mse_wav"])).cuda()  # Equally weight all wavelet channel losses
-
-            loss = (losses["mse_wav"] * weights).mean()
-            lossmse = loss.detach()
-
-            log_loss_dict(self.diffusion, t, {k: v * weights for k, v in losses.items()})
-
-            # perform some finiteness checks
-            if not torch.isfinite(loss):
-                logger.log(f"Encountered non-finite loss {loss}")
-            if self.use_fp16:
-                self.grad_scaler.scale(loss).backward()
-            else:
-                loss.backward()
-
-            return lossmse.detach(), sample, sample_idwt
-
-    def _anneal_lr(self):
-        if not self.lr_anneal_steps:
-            return
-        frac_done = (self.step + self.resume_step) / self.lr_anneal_steps
-        lr = self.lr * (1 - frac_done)
-        for param_group in self.opt.param_groups:
-            param_group["lr"] = lr
-
-    def log_step(self):
-        logger.logkv("step", self.step + self.resume_step)
-        logger.logkv("samples", (self.step + self.resume_step + 1) * self.global_batch)
-
-    def save(self):
-        def save_checkpoint(rate, state_dict):
-            if dist.get_rank() == 0:
-                logger.log("Saving model...")
-                if self.dataset == 'brats':
-                    filename = f"brats_{(self.step+self.resume_step):06d}.pt"
-                elif self.dataset == 'lidc-idri':
-                    filename = f"lidc-idri_{(self.step+self.resume_step):06d}.pt"
-                else:
-                    raise ValueError(f'dataset {self.dataset} not implemented')
-
-                with bf.BlobFile(bf.join(get_blob_logdir(), 'checkpoints', filename), "wb") as f:
-                    th.save(state_dict, f)
-
-        save_checkpoint(0, self.model.state_dict())
-
-        if dist.get_rank() == 0:
-            checkpoint_dir = os.path.join(logger.get_dir(), 'checkpoints')
-            with bf.BlobFile(
-                bf.join(checkpoint_dir, f"opt{(self.step+self.resume_step):06d}.pt"),
-                "wb",
-            ) as f:
-                th.save(self.opt.state_dict(), f)
-
-
-def parse_resume_step_from_filename(filename):
-    """
-    Parse filenames of the form path/to/modelNNNNNN.pt, where NNNNNN is the
-    checkpoint's number of steps.
-    """
-
-    split = os.path.basename(filename)
-    split = split.split(".")[-2]  # remove extension
-    split = split.split("_")[-1]  # remove possible underscores, keep only last word
-    # extract trailing number
-    reversed_split = []
-    for c in reversed(split):
-        if not c.isdigit():
-            break
-        reversed_split.append(c)
-    split = ''.join(reversed(reversed_split))
-    split = ''.join(c for c in split if c.isdigit())  # remove non-digits
-    try:
-        return int(split)
-    except ValueError:
-        return 0
-
-
-def get_blob_logdir():
-    # You can change this to be a separate path to save checkpoints to
-    # a blobstore or some external drive.
-    return logger.get_dir()
-
-
-def find_resume_checkpoint():
-    # On your infrastructure, you may want to override this to automatically
-    # discover the latest checkpoint on your blob storage, etc.
-    return None
-
-
-def log_loss_dict(diffusion, ts, losses):
-    for key, values in losses.items():
-        logger.logkv_mean(key, values.mean().item())
-        # Log the quantiles (four quartiles, in particular).
-        for sub_t, sub_loss in zip(ts.cpu().numpy(), values.detach().cpu().numpy()):
-            quartile = int(4 * sub_t / diffusion.num_timesteps)
-            logger.logkv_mean(f"{key}_q{quartile}", sub_loss)

wdm-3d-initial/guided_diffusion/.ipynb_checkpoints/wunet-checkpoint.py

@@ -1,795 +0,0 @@
-from abc import abstractmethod
-
-import math
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .nn import checkpoint, conv_nd, linear, avg_pool_nd, zero_module, normalization, timestep_embedding
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    A wavelet upsampling layer with an optional convolution on the skip connections used to perform upsampling.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, resample_2d=True, use_freq=True):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        self.resample_2d = resample_2d
-
-        self.use_freq = use_freq
-        self.idwt = IDWT_3D("haar")
-
-        # Grouped convolution on 7 high frequency subbands (skip connections)
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels * 7, self.out_channels * 7, 3, padding=1, groups=7)
-
-    def forward(self, x):
-        if isinstance(x, tuple):
-            skip = x[1]
-            x = x[0]
-        assert x.shape[1] == self.channels
-
-        if self.use_conv:
-            skip = self.conv(th.cat(skip, dim=1) / 3.) * 3.
-            skip = tuple(th.chunk(skip, 7, dim=1))
-
-        if self.use_freq:
-            x = self.idwt(3. * x, skip[0], skip[1], skip[2], skip[3], skip[4], skip[5], skip[6])
-        else:
-            if self.dims == 3 and self.resample_2d:
-                x = F.interpolate(
-                    x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-                )
-            else:
-                x = F.interpolate(x, scale_factor=2, mode="nearest")
-
-        return x, None
-
-
-class Downsample(nn.Module):
-    """
-    A wavelet downsampling layer with an optional convolution.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, resample_2d=True, use_freq=True):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-
-        self.use_freq = use_freq
-        self.dwt = DWT_3D("haar")
-
-        stride = (1, 2, 2) if dims == 3 and resample_2d else 2
-
-        if use_conv:
-            self.op = conv_nd(dims, self.channels, self.out_channels, 3, stride=stride, padding=1)
-        elif self.use_freq:
-            self.op = self.dwt
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        if self.use_freq:
-            LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = self.op(x)
-            x = (LLL / 3., (LLH, LHL, LHH, HLL, HLH, HHL, HHH))
-        else:
-            x = self.op(x)
-        return x
-
-
-class WaveletDownsample(nn.Module):
-    """
-    Implements the wavelet downsampling blocks used to generate the input residuals.
-
-    :param in_ch: number of input channels.
-    :param out_ch: number of output channels (should match the feature size of the corresponding U-Net level)
-    """
-    def __init__(self, in_ch=None, out_ch=None):
-        super().__init__()
-        out_ch = out_ch if out_ch else in_ch
-        self.in_ch = in_ch
-        self.out_ch = out_ch
-        self.conv = conv_nd(3, self.in_ch * 8, self.out_ch, 3, stride=1, padding=1)
-        self.dwt = DWT_3D('haar')
-
-    def forward(self, x):
-        LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = self.dwt(x)
-        x = th.cat((LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH), dim=1) / 3.
-        return self.conv(x)
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels via up- or downsampling.
-
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels, otherwise out_channels = channels.
-    :param use_conv: if True and out_channels is specified, use a spatial convolution instead of a smaller 1x1
-                     convolution to change the channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    :param num_groups: if specified, the number of groups in the (adaptive) group normalization layers.
-    :param use_freq: specifies if frequency aware up- or downsampling should be used.
-    :param z_emb_dim: the dimension of the z-embedding.
-
-    """
-
-    def __init__(self, channels, emb_channels, dropout, out_channels=None, use_conv=True, use_scale_shift_norm=False,
-                 dims=2, use_checkpoint=False, up=False, down=False, num_groups=32, resample_2d=True, use_freq=False):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_scale_shift_norm = use_scale_shift_norm
-        self.use_checkpoint = use_checkpoint
-        self.up = up
-        self.down = down
-        self.num_groups = num_groups
-        self.use_freq = use_freq
-
-
-        # Define (adaptive) group normalization layers
-        self.in_layers = nn.Sequential(
-            normalization(channels, self.num_groups),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        # Check if up- or downsampling should be performed by this ResBlock
-        self.updown = up or down
-        if up:
-            self.h_upd = Upsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-            self.x_upd = Upsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-            self.x_upd = Downsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        # Define the timestep embedding layers
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(emb_channels, 2 * self.out_channels if use_scale_shift_norm else self.out_channels),
-        )
-
-        # Define output layers including (adaptive) group normalization
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels, self.num_groups),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)),
-        )
-
-        # Define skip branch
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-
-    def forward(self, x, temb):
-        # Make sure to pipe skip connections
-        if isinstance(x, tuple):
-            hSkip = x[1]
-        else:
-            hSkip = None
-
-        # Forward pass for ResBlock with up- or downsampling
-        if self.updown:
-            if self.up:
-                x = x[0]
-            h = self.in_layers(x)
-
-            if self.up:
-                h = (h, hSkip)
-                x = (x, hSkip)
-
-            h, hSkip = self.h_upd(h)   # Updown in main branch (ResBlock)
-            x, xSkip = self.x_upd(x)   # Updown in skip-connection (ResBlock)
-
-        # Forward pass for standard ResBlock
-        else:
-            if isinstance(x, tuple):  # Check for skip connection tuple
-                x = x[0]
-            h = self.in_layers(x)
-
-        # Common layers for both standard and updown ResBlocks
-        emb_out = self.emb_layers(temb)
-
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-
-        else:
-            h = h + emb_out  # Add timestep embedding
-            h = self.out_layers(h)  # Forward pass out layers
-
-        # Add skip connections
-        out = self.skip_connection(x) + h
-        out = out, hSkip
-
-        return out
-
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-            self,
-            channels,
-            num_heads=1,
-            num_head_channels=-1,
-            use_checkpoint=False,
-            use_new_attention_order=False,
-            num_groups=32,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                    channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels, num_groups)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class WavUNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which attention will take place. May be a set,
-                                  list, or tuple. For example, if this contains 4, then at 4x downsampling, attention
-                                  will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially increased efficiency.
-    """
-
-    def __init__(self, image_size, in_channels, model_channels, out_channels, num_res_blocks, attention_resolutions,
-                 dropout=0, channel_mult=(1, 2, 4, 8), conv_resample=True, dims=2, num_classes=None,
-                 use_checkpoint=False, use_fp16=False, num_heads=1, num_head_channels=-1, num_heads_upsample=-1,
-                 use_scale_shift_norm=False, resblock_updown=False, use_new_attention_order=False, num_groups=32,
-                 bottleneck_attention=True, resample_2d=True, additive_skips=False, decoder_device_thresh=0,
-                 use_freq=False, progressive_input='residual'):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        # self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        # self.num_heads = num_heads
-        # self.num_head_channels = num_head_channels
-        # self.num_heads_upsample = num_heads_upsample
-        self.num_groups = num_groups
-        self.bottleneck_attention = bottleneck_attention
-        self.devices = None
-        self.decoder_device_thresh = decoder_device_thresh
-        self.additive_skips = additive_skips
-        self.use_freq = use_freq
-        self.progressive_input = progressive_input
-
-        #############################
-        # TIMESTEP EMBEDDING layers #
-        #############################
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim))
-
-        ###############
-        # INPUT block #
-        ###############
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        input_pyramid_channels =in_channels
-        ds = 1
-
-        ######################################
-        # DOWNWARD path - Feature extraction #
-        ######################################
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):                                         # Adding Residual blocks
-                layers = [
-                    ResBlock(
-                        channels=ch,
-                        emb_channels=time_embed_dim,
-                        dropout=dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                        use_freq=self.use_freq,
-                    )
-                ]
-                ch = mult * model_channels  # New input channels = channel_mult * base_channels
-                                            # (first ResBlock performs channel adaption)
-
-                if ds in attention_resolutions:                                     # Adding Attention layers
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                            num_groups=self.num_groups,
-                        )
-                    )
-
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-
-            # Adding downsampling operation
-            out_ch = ch
-            layers = []
-            layers.append(
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=out_ch,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        down=True,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                        use_freq=self.use_freq,
-                    )
-                    if resblock_updown
-                    else Downsample(
-                        ch,
-                        conv_resample,
-                        dims=dims,
-                        out_channels=out_ch,
-                        resample_2d=resample_2d,
-                    )
-                )
-            self.input_blocks.append(TimestepEmbedSequential(*layers))
-
-            layers = []
-            if self.progressive_input == 'residual':
-                layers.append(WaveletDownsample(in_ch=input_pyramid_channels, out_ch=out_ch))
-                input_pyramid_channels = out_ch
-
-            self.input_blocks.append(TimestepEmbedSequential(*layers))
-
-            ch = out_ch
-            input_block_chans.append(ch)
-            ds *= 2
-            self._feature_size += ch
-
-        self.input_block_chans_bk = input_block_chans[:]
-
-        #########################
-        # LATENT/ MIDDLE blocks #
-        #########################
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-                use_freq=self.use_freq,
-            ),
-            *([AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-                num_groups=self.num_groups,
-            )] if self.bottleneck_attention else [])
-            ,
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-                use_freq=self.use_freq,
-            ),
-        )
-        self._feature_size += ch
-
-        #################################
-        # UPWARD path - feature mapping #
-        #################################
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks+1):                                          # Adding Residual blocks
-                if not i == num_res_blocks:
-                    mid_ch = model_channels * mult
-
-                    layers = [
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=mid_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                            use_freq=self.use_freq,
-                        )
-                    ]
-                    if ds in attention_resolutions:                                         # Adding Attention layers
-                        layers.append(
-                            AttentionBlock(
-                                mid_ch,
-                                use_checkpoint=use_checkpoint,
-                                num_heads=num_heads_upsample,
-                                num_head_channels=num_head_channels,
-                                use_new_attention_order=use_new_attention_order,
-                                num_groups=self.num_groups,
-                            )
-                        )
-                    ch = mid_ch
-                else:                                                                       # Adding upsampling operation
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            mid_ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                            use_freq=self.use_freq,
-                        )
-                        if resblock_updown
-                        else Upsample(
-                            mid_ch,
-                            conv_resample,
-                            dims=dims,
-                            out_channels=out_ch,
-                            resample_2d=resample_2d
-                        )
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                mid_ch = ch
-
-        ################
-        # Out ResBlock #
-        ################
-        self.out_res = nn.ModuleList([])
-        for i in range(num_res_blocks):
-            layers = [
-                ResBlock(
-                    ch,
-                    time_embed_dim,
-                    dropout,
-                    out_channels=ch,
-                    dims=dims,
-                    use_checkpoint=use_checkpoint,
-                    use_scale_shift_norm=use_scale_shift_norm,
-                    num_groups=self.num_groups,
-                    resample_2d=resample_2d,
-                    use_freq=self.use_freq,
-                )
-            ]
-            self.out_res.append(TimestepEmbedSequential(*layers))
-
-        ################
-        # OUTPUT block #
-        ################
-        self.out = nn.Sequential(
-            normalization(ch, self.num_groups),
-            nn.SiLU(),
-            conv_nd(dims, model_channels, out_channels, 3, padding=1),
-        )
-
-    def to(self, *args, **kwargs):
-        """
-        we overwrite the to() method for the case where we
-        distribute parts of our model to different devices
-        """
-        if isinstance(args[0], (list, tuple)) and len(args[0]) > 1:
-            assert not kwargs and len(args) == 1
-            # distribute to multiple devices
-            self.devices = args[0]
-            # move first half to first device, second half to second device
-            self.input_blocks.to(self.devices[0])
-            self.time_embed.to(self.devices[0])
-            self.middle_block.to(self.devices[0])  # maybe devices 0
-            for k, b in enumerate(self.output_blocks):
-                if k < self.decoder_device_thresh:
-                    b.to(self.devices[0])
-                else:  # after threshold
-                    b.to(self.devices[1])
-            self.out.to(self.devices[0])
-            print(f"distributed UNet components to devices {self.devices}")
-
-        else:  # default behaviour
-            super().to(*args, **kwargs)
-            if self.devices is None:  # if self.devices has not been set yet, read it from params
-                p = next(self.parameters())
-                self.devices = [p.device, p.device]
-
-    def forward(self, x, timesteps):
-        """
-        Apply the model to an input batch.
-
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :param zemb: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        hs = []  # Save skip-connections here
-        input_pyramid = x
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))  # Gen sinusoidal timestep embedding
-        h = x
-        self.hs_shapes = []
-
-        for module in self.input_blocks:
-            if not isinstance(module[0], WaveletDownsample):
-                h = module(h, emb)  # Run a downstream module
-                skip = None
-                if isinstance(h, tuple):  # Check for skip features (tuple of high frequency subbands) and store in hs
-                    h, skip = h
-                hs.append(skip)
-                self.hs_shapes.append(h.shape)
-            else:
-                input_pyramid = module(input_pyramid, emb)
-                input_pyramid = input_pyramid + h
-                h = input_pyramid
-
-        for module in self.middle_block:
-            h = module(h, emb)
-            if isinstance(h, tuple):
-                h, skip = h
-
-        for module in self.output_blocks:
-            new_hs = hs.pop()
-            if new_hs:
-                skip = new_hs
-
-            # Use additive skip connections
-            if self.additive_skips:
-                h = (h + new_hs) / np.sqrt(2)
-
-            # Use frequency aware skip connections
-            elif self.use_freq:  # You usually want to use the frequency aware upsampling
-                if isinstance(h, tuple):  # Replace None with the stored skip features
-                    l = list(h)
-                    l[1] = skip
-                    h = tuple(l)
-                else:
-                    h = (h, skip)
-
-            # Use concatenation
-            else:
-                h = th.cat([h, new_hs], dim=1)
-
-            h = module(h, emb)  # Run an upstream module
-
-        for module in self.out_res:
-            h = module(h, emb)
-
-        h, _ = h
-        return self.out(h)

wdm-3d-initial/guided_diffusion/__init__.py

@@ -1,3 +0,0 @@
-"""
-Codebase for "Diffusion Models for Medial Anomaly Detection".
-"""

wdm-3d-initial/guided_diffusion/bratsloader.py

@@ -1,85 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.utils.data
-import numpy as np
-import os
-import os.path
-import nibabel
-
-
-class BRATSVolumes(torch.utils.data.Dataset):
-    def __init__(self, directory, test_flag=False, normalize=None, mode='train', img_size=256):
-        '''
-        directory is expected to contain some folder structure:
-                  if some subfolder contains only files, all of these
-                  files are assumed to have a name like
-                  brats_train_NNN_XXX_123_w.nii.gz
-                  where XXX is one of t1n, t1c, t2w, t2f, seg
-                  we assume these five files belong to the same image
-                  seg is supposed to contain the segmentation
-        '''
-        super().__init__()
-        self.mode = mode
-        self.directory = os.path.expanduser(directory)
-        self.normalize = normalize or (lambda x: x)
-        self.test_flag = test_flag
-        self.img_size = img_size
-        if test_flag:
-            self.seqtypes = ['t1n', 't1c', 't2w', 't2f']
-        else:
-            self.seqtypes = ['t1n', 't1c', 't2w', 't2f', 'seg']
-        self.seqtypes_set = set(self.seqtypes)
-        self.database = []
-
-        if not self.mode == 'fake': # Used during training and for evaluating real data
-            for root, dirs, files in os.walk(self.directory):
-                # if there are no subdirs, we have a datadir
-                if not dirs:
-                    files.sort()
-                    datapoint = dict()
-                    # extract all files as channels
-                    for f in files:
-                        seqtype = f.split('-')[4].split('.')[0]
-                        datapoint[seqtype] = os.path.join(root, f)
-                    self.database.append(datapoint)
-        else:   # Used for evaluating fake data
-            for root, dirs, files in os.walk(self.directory):
-                for f in files:
-                    datapoint = dict()
-                    datapoint['t1n'] = os.path.join(root, f)
-                    self.database.append(datapoint)
-
-    def __getitem__(self, x):
-        filedict = self.database[x]
-        name = filedict['t1n']
-        nib_img = nibabel.load(name)  # We only use t1 weighted images
-        out = nib_img.get_fdata()
-
-        if not self.mode == 'fake':
-            # CLip and normalize the images
-            out_clipped = np.clip(out, np.quantile(out, 0.001), np.quantile(out, 0.999))
-            out_normalized = (out_clipped - np.min(out_clipped)) / (np.max(out_clipped) - np.min(out_clipped))
-            out = torch.tensor(out_normalized)
-
-            # Zero pad images
-            image = torch.zeros(1, 256, 256, 256)
-            image[:, 8:-8, 8:-8, 50:-51] = out
-
-            # Downsampling
-            if self.img_size == 128:
-                downsample = nn.AvgPool3d(kernel_size=2, stride=2)
-                image = downsample(image)
-        else:
-            image = torch.tensor(out, dtype=torch.float32)
-            image = image.unsqueeze(dim=0)
-
-        # Normalization
-        image = self.normalize(image)
-
-        if self.mode == 'fake':
-            return image, name
-        else:
-            return image
-
-    def __len__(self):
-        return len(self.database)

wdm-3d-initial/guided_diffusion/dist_util.py

@@ -1,107 +0,0 @@
-"""
-Helpers for distributed training.
-"""
-
-import io
-import os
-import socket
-
-import blobfile as bf
-import torch as th
-import torch.distributed as dist
-
-# Change this to reflect your cluster layout.
-# The GPU for a given rank is (rank % GPUS_PER_NODE).
-GPUS_PER_NODE = 8
-
-SETUP_RETRY_COUNT = 3
-
-
-def setup_dist(devices=(0,)):
-    """
-    Setup a distributed process group.
-    """
-    if dist.is_initialized():
-        return
-    try:
-        device_string = ','.join(map(str, devices))
-    except TypeError:
-        device_string = str(devices)
-    os.environ["CUDA_VISIBLE_DEVICES"] = device_string #f"{MPI.COMM_WORLD.Get_rank() % GPUS_PER_NODE}"
-
-    #comm = MPI.COMM_WORLD
-  #  print('commworld, 'f"{MPI.COMM_WORLD.Get_rank() % GPUS_PER_NODE}", comm)
-    backend = "gloo" if not th.cuda.is_available() else "nccl"
-   # print('commrank', comm.rank)
-   # print('commsize', comm.size)
-
-    if backend == "gloo":
-        hostname = "localhost"
-    else:
-        hostname = socket.gethostbyname(socket.getfqdn())
-    os.environ["MASTER_ADDR"] = '127.0.1.1'#comm.bcast(hostname, root=0)
-    os.environ["RANK"] = '0'#str(comm.rank)
-    os.environ["WORLD_SIZE"] = '1'#str(comm.size)
-
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.bind(("", 0))
-    s.listen(1)
-    port = s.getsockname()[1]
-    s.close()
-    # print('port2', port)
-    os.environ["MASTER_PORT"] = str(port)
-    dist.init_process_group(backend=backend, init_method="env://")
-
-
-def dev(device_number=0):
-    """
-    Get the device to use for torch.distributed.
-    """
-    if isinstance(device_number, (list, tuple)):  # multiple devices specified
-        return [dev(k) for k in device_number]    # recursive call
-    if th.cuda.is_available():
-        device_count = th.cuda.device_count()
-        if device_count == 1:
-            return th.device(f"cuda")
-        else:
-            if device_number < device_count:  # if we specify multiple devices, we have to be specific
-                return th.device(f'cuda:{device_number}')
-            else:
-                raise ValueError(f'requested device number {device_number} (0-indexed) but only {device_count} devices available')
-    return th.device("cpu")
-
-
-def load_state_dict(path, **kwargs):
-    """
-    Load a PyTorch file without redundant fetches across MPI ranks.
-    """
-    #print('mpicommworldgetrank', MPI.COMM_WORLD.Get_rank())
-    mpigetrank=0
-   # if MPI.COMM_WORLD.Get_rank() == 0:
-    if mpigetrank==0:
-        with bf.BlobFile(path, "rb") as f:
-            data = f.read()
-    else:
-        data = None
-   # data = MPI.COMM_WORLD.bcast(data)
-  #  print('mpibacst', MPI.COMM_WORLD.bcast(data))
-    return th.load(io.BytesIO(data), **kwargs)
-
-
-def sync_params(params):
-    """
-    Synchronize a sequence of Tensors across ranks from rank 0.
-    """
-    #for p in params:
-    #    with th.no_grad():
-    #        dist.broadcast(p, 0)
-
-
-def _find_free_port():
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.bind(("", 0))
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        return s.getsockname()[1]
-    finally:
-        s.close()

wdm-3d-initial/guided_diffusion/gaussian_diffusion.py

@@ -1,1185 +0,0 @@
-"""
-This code started out as a PyTorch port of Ho et al's diffusion models:
-https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py
-
-Docstrings have been added, as well as DDIM sampling and a new collection of beta schedules.
-"""
-from PIL import Image
-from torch.autograd import Variable
-import enum
-import torch.nn.functional as F
-from torchvision.utils import save_image
-import torch
-import math
-import numpy as np
-import torch as th
-from .train_util import visualize
-from .nn import mean_flat
-from .losses import normal_kl, discretized_gaussian_log_likelihood
-from scipy import ndimage
-from torchvision import transforms
-import matplotlib.pyplot as plt
-from scipy.interpolate import interp1d
-
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-dwt = DWT_3D('haar')
-idwt = IDWT_3D('haar')
-
-
-def get_named_beta_schedule(schedule_name, num_diffusion_timesteps):
-    """
-    Get a pre-defined beta schedule for the given name.
-
-    The beta schedule library consists of beta schedules which remain similar
-    in the limit of num_diffusion_timesteps.
-    Beta schedules may be added, but should not be removed or changed once
-    they are committed to maintain backwards compatibility.
-    """
-    if schedule_name == "linear":
-        # Linear schedule from Ho et al, extended to work for any number of
-        # diffusion steps.
-        scale = 1000 / num_diffusion_timesteps
-        beta_start = scale * 0.0001
-        beta_end = scale * 0.02
-        return np.linspace(
-            beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64
-        )
-    elif schedule_name == "cosine":
-        return betas_for_alpha_bar(
-            num_diffusion_timesteps,
-            lambda t: math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2,
-        )
-    else:
-        raise NotImplementedError(f"unknown beta schedule: {schedule_name}")
-
-
-def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function,
-    which defines the cumulative product of (1-beta) over time from t = [0,1].
-
-    :param num_diffusion_timesteps: the number of betas to produce.
-    :param alpha_bar: a lambda that takes an argument t from 0 to 1 and
-                      produces the cumulative product of (1-beta) up to that
-                      part of the diffusion process.
-    :param max_beta: the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-    """
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
-    return np.array(betas)
-
-
-class ModelMeanType(enum.Enum):
-    """
-    Which type of output the model predicts.
-    """
-
-    PREVIOUS_X = enum.auto()  # the model predicts x_{t-1}
-    START_X = enum.auto()  # the model predicts x_0
-    EPSILON = enum.auto()  # the model predicts epsilon
-
-
-class ModelVarType(enum.Enum):
-    """
-    What is used as the model's output variance.
-
-    The LEARNED_RANGE option has been added to allow the model to predict
-    values between FIXED_SMALL and FIXED_LARGE, making its job easier.
-    """
-
-    LEARNED = enum.auto()
-    FIXED_SMALL = enum.auto()
-    FIXED_LARGE = enum.auto()
-    LEARNED_RANGE = enum.auto()
-
-
-class LossType(enum.Enum):
-    MSE = enum.auto()  # use raw MSE loss (and KL when learning variances)
-    RESCALED_MSE = (
-        enum.auto()
-    )  # use raw MSE loss (with RESCALED_KL when learning variances)
-    KL = enum.auto()  # use the variational lower-bound
-    RESCALED_KL = enum.auto()  # like KL, but rescale to estimate the full VLB
-
-    def is_vb(self):
-        return self == LossType.KL or self == LossType.RESCALED_KL
-
-
-class GaussianDiffusion:
-    """
-    Utilities for training and sampling diffusion models.
-
-    Ported directly from here, and then adapted over time to further experimentation.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py#L42
-
-    :param betas: a 1-D numpy array of betas for each diffusion timestep,
-                  starting at T and going to 1.
-    :param model_mean_type: a ModelMeanType determining what the model outputs.
-    :param model_var_type: a ModelVarType determining how variance is output.
-    :param loss_type: a LossType determining the loss function to use.
-    :param rescale_timesteps: if True, pass floating point timesteps into the
-                              model so that they are always scaled like in the
-                              original paper (0 to 1000).
-    """
-
-    def __init__(
-        self,
-        *,
-        betas,
-        model_mean_type,
-        model_var_type,
-        loss_type,
-        rescale_timesteps=False,
-        mode='default',
-        loss_level='image'
-    ):
-        self.model_mean_type = model_mean_type
-        self.model_var_type = model_var_type
-        self.loss_type = loss_type
-        self.rescale_timesteps = rescale_timesteps
-        self.mode = mode
-        self.loss_level=loss_level
-
-        # Use float64 for accuracy.
-        betas = np.array(betas, dtype=np.float64)
-        self.betas = betas
-        assert len(betas.shape) == 1, "betas must be 1-D"
-        assert (betas > 0).all() and (betas <= 1).all()
-
-        self.num_timesteps = int(betas.shape[0])
-
-        alphas = 1.0 - betas
-        self.alphas_cumprod = np.cumprod(alphas, axis=0)                     # t
-        self.alphas_cumprod_prev = np.append(1.0, self.alphas_cumprod[:-1])  # t-1
-        self.alphas_cumprod_next = np.append(self.alphas_cumprod[1:], 0.0)   # t+1
-        assert self.alphas_cumprod_prev.shape == (self.num_timesteps,)
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.sqrt_alphas_cumprod = np.sqrt(self.alphas_cumprod)
-        self.sqrt_one_minus_alphas_cumprod = np.sqrt(1.0 - self.alphas_cumprod)
-        self.log_one_minus_alphas_cumprod = np.log(1.0 - self.alphas_cumprod)
-        self.sqrt_recip_alphas_cumprod = np.sqrt(1.0 / self.alphas_cumprod)
-        self.sqrt_recipm1_alphas_cumprod = np.sqrt(1.0 / self.alphas_cumprod - 1)
-
-        # calculations for posterior q(x_{t-1} | x_t, x_0)
-        self.posterior_variance = (
-            betas * (1.0 - self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)
-        )
-        # log calculation clipped because the posterior variance is 0 at the
-        # beginning of the diffusion chain.
-        self.posterior_log_variance_clipped = np.log(
-            np.append(self.posterior_variance[1], self.posterior_variance[1:])
-        )
-        self.posterior_mean_coef1 = (
-            betas * np.sqrt(self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)
-        )
-        self.posterior_mean_coef2 = (
-            (1.0 - self.alphas_cumprod_prev)
-            * np.sqrt(alphas)
-            / (1.0 - self.alphas_cumprod)
-        )
-
-    def q_mean_variance(self, x_start, t):
-        """
-        Get the distribution q(x_t | x_0).
-
-        :param x_start: the [N x C x ...] tensor of noiseless inputs.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :return: A tuple (mean, variance, log_variance), all of x_start's shape.
-        """
-        mean = (
-            _extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start
-        )
-        variance = _extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
-        log_variance = _extract_into_tensor(
-            self.log_one_minus_alphas_cumprod, t, x_start.shape
-        )
-        return mean, variance, log_variance
-
-    def q_sample(self, x_start, t, noise=None):
-        """
-        Diffuse the data for a given number of diffusion steps.
-
-        In other words, sample from q(x_t | x_0).
-
-        :param x_start: the initial data batch.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :param noise: if specified, the split-out normal noise.
-        :return: A noisy version of x_start.
-        """
-        if noise is None:
-            noise = th.randn_like(x_start)
-        assert noise.shape == x_start.shape
-        return (
-                _extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start
-                + _extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape)
-                * noise
-        )
-
-    def q_posterior_mean_variance(self, x_start, x_t, t):
-        """
-        Compute the mean and variance of the diffusion posterior:
-
-            q(x_{t-1} | x_t, x_0)
-
-        """
-       
-        assert x_start.shape == x_t.shape
-        posterior_mean = (
-            _extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start
-            + _extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
-        )
-        posterior_variance = _extract_into_tensor(self.posterior_variance, t, x_t.shape)
-        posterior_log_variance_clipped = _extract_into_tensor(
-            self.posterior_log_variance_clipped, t, x_t.shape
-        )
-        assert (
-            posterior_mean.shape[0]
-            == posterior_variance.shape[0]
-            == posterior_log_variance_clipped.shape[0]
-            == x_start.shape[0]
-        )
-        return posterior_mean, posterior_variance, posterior_log_variance_clipped
-
-    def p_mean_variance(self, model, x, t, clip_denoised=True, denoised_fn=None, model_kwargs=None):
-        """
-        Apply the model to get p(x_{t-1} | x_t), as well as a prediction of
-        the initial x, x_0.
-        :param model: the model, which takes a signal and a batch of timesteps
-                      as input.
-        :param x: the [N x C x ...] tensor at time t.
-        :param t: a 1-D Tensor of timesteps.
-        :param clip_denoised: if True, clip the denoised signal into [-1, 1].
-        :param denoised_fn: if not None, a function which applies to the
-            x_start prediction before it is used to sample. Applies before
-            clip_denoised.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :return: a dict with the following keys:
-                 - 'mean': the model mean output.
-                 - 'variance': the model variance output.
-                 - 'log_variance': the log of 'variance'.
-                 - 'pred_xstart': the prediction for x_0.
-        """
-        if model_kwargs is None:
-            model_kwargs = {}
-
-        B, C = x.shape[:2]
-        
-        assert t.shape == (B,)
-        model_output = model(x, self._scale_timesteps(t), **model_kwargs)
-        
-        if self.model_var_type in [ModelVarType.LEARNED, ModelVarType.LEARNED_RANGE]:
-            assert model_output.shape == (B, C * 2, *x.shape[2:])
-            model_output, model_var_values = th.split(model_output, C, dim=1)
-            if self.model_var_type == ModelVarType.LEARNED:
-                model_log_variance = model_var_values
-                model_variance = th.exp(model_log_variance)
-            else:
-                min_log = _extract_into_tensor(
-                    self.posterior_log_variance_clipped, t, x.shape
-                )
-                max_log = _extract_into_tensor(np.log(self.betas), t, x.shape)
-                # The model_var_values is [-1, 1] for [min_var, max_var].
-                frac = (model_var_values + 1) / 2
-                model_log_variance = frac * max_log + (1 - frac) * min_log
-                model_variance = th.exp(model_log_variance)
-        else:
-            model_variance, model_log_variance = {
-                # for fixedlarge, we set the initial (log-)variance like so
-                # to get a better decoder log likelihood.
-                ModelVarType.FIXED_LARGE: (
-                    np.append(self.posterior_variance[1], self.betas[1:]),
-                    np.log(np.append(self.posterior_variance[1], self.betas[1:])),
-                ),
-                ModelVarType.FIXED_SMALL: (
-                    self.posterior_variance,
-                    self.posterior_log_variance_clipped,
-                ),
-            }[self.model_var_type]
-            model_variance = _extract_into_tensor(model_variance, t, x.shape)
-            model_log_variance = _extract_into_tensor(model_log_variance, t, x.shape)
-
-        def process_xstart(x):
-            if denoised_fn is not None:
-                x = denoised_fn(x)
-            if clip_denoised:
-                B, _, H, W, D = x.size()
-                x_idwt = idwt(x[:, 0, :, :, :].view(B, 1, H, W, D) * 3.,
-                              x[:, 1, :, :, :].view(B, 1, H, W, D),
-                              x[:, 2, :, :, :].view(B, 1, H, W, D),
-                              x[:, 3, :, :, :].view(B, 1, H, W, D),
-                              x[:, 4, :, :, :].view(B, 1, H, W, D),
-                              x[:, 5, :, :, :].view(B, 1, H, W, D),
-                              x[:, 6, :, :, :].view(B, 1, H, W, D),
-                              x[:, 7, :, :, :].view(B, 1, H, W, D))
-
-                x_idwt_clamp = x_idwt.clamp(-1, 1)
-
-                LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = dwt(x_idwt_clamp)
-                x = th.cat([LLL / 3., LLH, LHL, LHH, HLL, HLH, HHL, HHH], dim=1)
-
-                return x
-            return x
-
-        if self.model_mean_type == ModelMeanType.PREVIOUS_X:
-            pred_xstart = process_xstart(
-                self._predict_xstart_from_xprev(x_t=x, t=t, xprev=model_output)
-            )
-            model_mean = model_output
-        elif self.model_mean_type in [ModelMeanType.START_X, ModelMeanType.EPSILON]:
-            if self.model_mean_type == ModelMeanType.START_X:
-                pred_xstart = process_xstart(model_output)
-            else:
-                pred_xstart = process_xstart(
-                    self._predict_xstart_from_eps(x_t=x, t=t, eps=model_output)
-                )
-            model_mean, _, _ = self.q_posterior_mean_variance(
-                x_start=pred_xstart, x_t=x, t=t
-            )
-        else:
-            raise NotImplementedError(self.model_mean_type)
-
-        assert (model_mean.shape == model_log_variance.shape == pred_xstart.shape == x.shape)
-
-
-        return {
-            "mean": model_mean,
-            "variance": model_variance,
-            "log_variance": model_log_variance,
-            "pred_xstart": pred_xstart,
-        }
-  
-    def _predict_xstart_from_eps(self, x_t, t, eps):
-        assert x_t.shape == eps.shape
-        return (
-            _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t
-            - _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * eps
-        )
-
-    def _predict_xstart_from_xprev(self, x_t, t, xprev):
-        assert x_t.shape == xprev.shape
-        return (  # (xprev - coef2*x_t) / coef1
-            _extract_into_tensor(1.0 / self.posterior_mean_coef1, t, x_t.shape) * xprev
-            - _extract_into_tensor(
-                self.posterior_mean_coef2 / self.posterior_mean_coef1, t, x_t.shape
-            )
-            * x_t
-        )
-
-    def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
-        if self.mode == 'segmentation':
-            x_t = x_t[:, -pred_xstart.shape[1]:, ...]
-        assert pred_xstart.shape == x_t.shape
-        eps =  (
-            _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t
-            - pred_xstart
-        ) / _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
-        return eps
-
-    def _scale_timesteps(self, t):
-        if self.rescale_timesteps:
-            return t.float() * (1000.0 / self.num_timesteps)
-        return t
-
-    def condition_mean(self, cond_fn, p_mean_var, x, t, update=None, model_kwargs=None):
-        """
-        Compute the mean for the previous step, given a function cond_fn that
-        computes the gradient of a conditional log probability with respect to
-        x. In particular, cond_fn computes grad(log(p(y|x))), and we want to
-        condition on y.
-
-        This uses the conditioning strategy from Sohl-Dickstein et al. (2015).
-        """
-
-
-        if update is not None:
-            print('CONDITION MEAN UPDATE NOT NONE')
-
-            new_mean = (
-                p_mean_var["mean"].detach().float() + p_mean_var["variance"].detach() * update.float()
-                )
-            a=update
-
-        else:
-           a, gradient = cond_fn(x, self._scale_timesteps(t), **model_kwargs)
-           new_mean = (
-                p_mean_var["mean"].float() + p_mean_var["variance"] * gradient.float()
-            )
-
-        return a, new_mean
-
-
-
-    def condition_score2(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
-        """
-        Compute what the p_mean_variance output would have been, should the
-        model's score function be conditioned by cond_fn.
-        See condition_mean() for details on cond_fn.
-        Unlike condition_mean(), this instead uses the conditioning strategy
-        from Song et al (2020).
-        """
-        t=t.long()
-        alpha_bar = _extract_into_tensor(self.alphas_cumprod, t, x.shape)
-
-        eps = self._predict_eps_from_xstart(x, t, p_mean_var["pred_xstart"])
-        a, cfn= cond_fn(
-            x, self._scale_timesteps(t).long(), **model_kwargs
-        )
-        eps = eps - (1 - alpha_bar).sqrt() * cfn
-
-        out = p_mean_var.copy()
-        out["pred_xstart"] = self._predict_xstart_from_eps(x, t, eps)
-        out["mean"], _, _ = self.q_posterior_mean_variance(
-            x_start=out["pred_xstart"], x_t=x, t=t
-        )
-        return out, cfn
-
-    def sample_known(self, img, batch_size = 1):
-        image_size = self.image_size
-        channels = self.channels
-        return self.p_sample_loop_known(model,(batch_size, channels, image_size, image_size), img)
-
-
-    def p_sample_loop(
-        self,
-        model,
-        shape,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=True,
-    ):
-        """
-        Generate samples from the model.
-
-        :param model: the model module.
-        :param shape: the shape of the samples, (N, C, H, W).
-        :param noise: if specified, the noise from the encoder to sample.
-                      Should be of the same shape as `shape`.
-        :param clip_denoised: if True, clip x_start predictions to [-1, 1].
-        :param denoised_fn: if not None, a function which applies to the
-            x_start prediction before it is used to sample.
-        :param cond_fn: if not None, this is a gradient function that acts
-                        similarly to the model.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :param device: if specified, the device to create the samples on.
-                       If not specified, use a model parameter's device.
-        :param progress: if True, show a tqdm progress bar.
-        :return: a non-differentiable batch of samples.
-        """
-        final = None
-        for sample in self.p_sample_loop_progressive(
-            model,
-            shape,
-            noise=noise,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-        ):
-            final = sample
-        return final["sample"]
-
-    def p_sample(
-            self,
-            model,
-            x,
-            t,
-            clip_denoised=True,
-            denoised_fn=None,
-            cond_fn=None,
-            model_kwargs=None,
-    ):
-        """
-        Sample x_{t-1} from the model at the given timestep.
-        :param model: the model to sample from.
-        :param x: the current tensor at x_{t-1}.
-        :param t: the value of t, starting at 0 for the first diffusion step.
-        :param clip_denoised: if True, clip the x_start prediction to [-1, 1].
-        :param denoised_fn: if not None, a function which applies to the
-            x_start prediction before it is used to sample.
-        :param cond_fn: if not None, this is a gradient function that acts
-                        similarly to the model.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :return: a dict containing the following keys:
-                 - 'sample': a random sample from the model.
-                 - 'pred_xstart': a prediction of x_0.
-        """
-        out = self.p_mean_variance(
-            model,
-            x,
-            t,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            model_kwargs=model_kwargs,
-        )
-        noise = th.randn_like(x)
-        nonzero_mask = (
-            (t != 0).float().view(-1, *([1] * (len(x.shape) - 1)))
-        )  # no noise when t == 0
-        if cond_fn is not None:
-            out["mean"] = self.condition_mean(
-                cond_fn, out, x, t, model_kwargs=model_kwargs
-            )
-        sample = out["mean"] + nonzero_mask * th.exp(0.5 * out["log_variance"]) * noise
-        return {"sample": sample, "pred_xstart": out["pred_xstart"]}
-
-    def p_sample_loop_known(
-        self,
-        model,
-        shape,
-        img,
-        org=None,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        noise_level=500,
-        progress=False,
-        classifier=None
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-
-
-        t = th.randint(499,500, (b,), device=device).long().to(device)
-
-        org=img[0].to(device)
-        img=img[0].to(device)
-        indices = list(range(t))[::-1]
-        noise = th.randn_like(img[:, :4, ...]).to(device)
-        x_noisy = self.q_sample(x_start=img[:, :4, ...], t=t, noise=noise).to(device)
-        x_noisy = torch.cat((x_noisy, img[:, 4:, ...]), dim=1)
-        
-        
-        for sample in self.p_sample_loop_progressive(
-            model,
-            shape,
-            time=noise_level,
-            noise=x_noisy,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            org=org,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-            classifier=classifier
-        ):
-            final = sample
-      
-        return final["sample"], x_noisy, img
-
-    def p_sample_loop_interpolation(
-        self,
-        model,
-        shape,
-        img1,
-        img2,
-        lambdaint,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        t = th.randint(299,300, (b,), device=device).long().to(device)
-        img1=torch.tensor(img1).to(device)
-        img2 = torch.tensor(img2).to(device)
-        noise = th.randn_like(img1).to(device)
-        x_noisy1 = self.q_sample(x_start=img1, t=t, noise=noise).to(device)
-        x_noisy2 = self.q_sample(x_start=img2, t=t, noise=noise).to(device)
-        interpol=lambdaint*x_noisy1+(1-lambdaint)*x_noisy2
-        for sample in self.p_sample_loop_progressive(
-            model,
-            shape,
-            time=t,
-            noise=interpol,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-        ):
-            final = sample
-        return final["sample"], interpol, img1, img2
-
-
-    def p_sample_loop_progressive(
-        self,
-        model,
-        shape,
-        time=1000,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=True,
-    ):
-        """
-        Generate samples from the model and yield intermediate samples from
-        each timestep of diffusion.
-
-        Arguments are the same as p_sample_loop().
-        Returns a generator over dicts, where each dict is the return value of
-        p_sample().
-        """
-
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        if noise is not None:
-            img = noise
-        else:
-            img = th.randn(*shape, device=device)
-      
-        indices = list(range(time))[::-1]
-        if progress:
-            # Lazy import so that we don't depend on tqdm.
-            from tqdm.auto import tqdm
-            indices = tqdm(indices)
-
-        for i in indices:
-            t = th.tensor([i] * shape[0], device=device)
-            with th.no_grad():
-                out = self.p_sample(
-                    model,
-                    img,
-                    t,
-                    clip_denoised=clip_denoised,
-                    denoised_fn=denoised_fn,
-                    cond_fn=cond_fn,
-                    model_kwargs=model_kwargs,
-                )
-                yield out
-                img = out["sample"]
-
-    def ddim_sample(
-            self,
-            model,
-            x,
-            t,  # index of current step
-            t_cpu=None,
-            t_prev=None,  # index of step that we are going to compute,  only used for heun
-            t_prev_cpu=None,
-            clip_denoised=True,
-            denoised_fn=None,
-            cond_fn=None,
-            model_kwargs=None,
-            eta=0.0,
-            sampling_steps=0,
-    ):
-        """
-        Sample x_{t-1} from the model using DDIM.
-        Same usage as p_sample().
-        """
-        relerr = lambda x, y: (x-y).abs().sum() / y.abs().sum()
-        if cond_fn is not None:
-            out, saliency = self.condition_score2(cond_fn, out, x, t, model_kwargs=model_kwargs)
-        out = self.p_mean_variance(
-            model,
-            x,
-            t,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            model_kwargs=model_kwargs,
-        )
-        eps_orig = self._predict_eps_from_xstart(x_t=x, t=t, pred_xstart=out["pred_xstart"]) 
-        if self.mode == 'default':
-            shape = x.shape
-        elif self.mode == 'segmentation':
-            shape = eps_orig.shape
-        else:
-            raise NotImplementedError(f'mode "{self.mode}" not implemented')
-
-        if not sampling_steps:
-            alpha_bar_orig = _extract_into_tensor(self.alphas_cumprod, t, shape)          
-            alpha_bar_prev_orig = _extract_into_tensor(self.alphas_cumprod_prev, t, shape)
-        else:
-            xp = np.arange(0, 1000, 1, dtype=np.float)
-            alpha_cumprod_fun = interp1d(xp, self.alphas_cumprod,
-                                         bounds_error=False,
-                                         fill_value=(self.alphas_cumprod[0], self.alphas_cumprod[-1]),
-                                         )
-            alpha_bar_orig      = alpha_cumprod_fun(t_cpu).item()
-            alpha_bar_prev_orig = alpha_cumprod_fun(t_prev_cpu).item()
-        sigma = (
-                eta
-                * ((1 - alpha_bar_prev_orig) / (1 - alpha_bar_orig))**.5
-                * (1 - alpha_bar_orig / alpha_bar_prev_orig)**.5
-        )
-        noise = th.randn(size=shape, device=x.device)
-        mean_pred = (
-                out["pred_xstart"] * alpha_bar_prev_orig**.5
-                + (1 - alpha_bar_prev_orig - sigma ** 2)**.5 * eps_orig
-        )
-        nonzero_mask = (
-            (t != 0).float().view(-1, *([1] * (len(shape) - 1)))
-        )
-        sample = mean_pred + nonzero_mask * sigma * noise
-        return {"sample": mean_pred, "pred_xstart": out["pred_xstart"]}
-
-
-    def ddim_reverse_sample(
-        self,
-        model,
-        x,
-        t,
-        clip_denoised=True,
-        denoised_fn=None,
-        model_kwargs=None,
-        eta=0.0,
-    ):
-        """
-        Sample x_{t+1} from the model using DDIM reverse ODE.
-        """
-        assert eta == 0.0, "Reverse ODE only for deterministic path"
-        out = self.p_mean_variance(
-            model,
-            x,
-            t,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            model_kwargs=model_kwargs,
-        )
-        # Usually our model outputs epsilon, but we re-derive it
-        # in case we used x_start or x_prev prediction.
-        eps = (
-            _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x.shape) * x
-            - out["pred_xstart"]
-        ) / _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x.shape)
-        alpha_bar_next = _extract_into_tensor(self.alphas_cumprod_next, t, x.shape)
-
-        # Equation 12. reversed
-        mean_pred = (
-            out["pred_xstart"] * th.sqrt(alpha_bar_next)
-            + th.sqrt(1 - alpha_bar_next) * eps
-        )
-
-        return {"sample": mean_pred, "pred_xstart": out["pred_xstart"]}
-
-
-
-    def ddim_sample_loop_interpolation(
-        self,
-        model,
-        shape,
-        img1,
-        img2,
-        lambdaint,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        t = th.randint(199,200, (b,), device=device).long().to(device)
-        img1=torch.tensor(img1).to(device)
-        img2 = torch.tensor(img2).to(device)
-        noise = th.randn_like(img1).to(device)
-        x_noisy1 = self.q_sample(x_start=img1, t=t, noise=noise).to(device)
-        x_noisy2 = self.q_sample(x_start=img2, t=t, noise=noise).to(device)
-        interpol=lambdaint*x_noisy1+(1-lambdaint)*x_noisy2
-        for sample in self.ddim_sample_loop_progressive(
-            model,
-            shape,
-            time=t,
-            noise=interpol,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-        ):
-            final = sample
-        return final["sample"], interpol, img1, img2
-
-    def ddim_sample_loop(
-        self,
-        model,
-        shape,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-        eta=0.0,
-        sampling_steps=0,
-    ):
-        """
-        Generate samples from the model using DDIM.
-
-        Same usage as p_sample_loop().
-        """
-        final = None
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        #t = th.randint(0,1, (b,), device=device).long().to(device)
-        t = 1000
-        for sample in self.ddim_sample_loop_progressive(
-            model,
-            shape,
-            time=t,
-            noise=noise,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-            eta=eta,
-            sampling_steps=sampling_steps,
-        ):
-
-            final = sample
-        return final["sample"]
-
-
-
-    def ddim_sample_loop_known(
-            self,
-            model,
-            shape,
-            img,
-            mode='default',
-            org=None,
-            noise=None,
-            clip_denoised=True,
-            denoised_fn=None,
-            cond_fn=None,
-            model_kwargs=None,
-            device=None,
-            noise_level=1000, # must be same as in training
-            progress=False,
-            conditioning=False,
-            conditioner=None,
-            classifier=None,
-            eta=0.0,
-            sampling_steps=0,
-    ):
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        b = shape[0]
-        t = th.randint(0,1, (b,), device=device).long().to(device)
-        img = img.to(device)
-        
-        indices = list(range(t))[::-1]
-        if mode == 'segmentation':
-            noise = None
-            x_noisy = None
-        elif mode == 'default':
-            noise = None
-            x_noisy = None
-        else:
-            raise NotImplementedError(f'mode "{mode}" not implemented')
-
-        final = None
-        # pass images to be segmented as condition
-        for sample in self.ddim_sample_loop_progressive(
-            model,
-            shape,
-            segmentation_img=img,  # image to be segmented
-            time=noise_level,
-            noise=x_noisy,
-            clip_denoised=clip_denoised,
-            denoised_fn=denoised_fn,
-            cond_fn=cond_fn,
-            model_kwargs=model_kwargs,
-            device=device,
-            progress=progress,
-            eta=eta,
-            sampling_steps=sampling_steps,
-        ):
-            final = sample
-
-        return final["sample"], x_noisy, img
-
-
-    def ddim_sample_loop_progressive(
-        self,
-        model,
-        shape,
-        segmentation_img=None,  # define to perform segmentation
-        time=1000,
-        noise=None,
-        clip_denoised=True,
-        denoised_fn=None,
-        cond_fn=None,
-        model_kwargs=None,
-        device=None,
-        progress=False,
-        eta=0.0,
-        sampling_steps=0,
-    ):
-        """
-        Use DDIM to sample from the model and yield intermediate samples from
-        each timestep of DDIM.
-
-        Same usage as p_sample_loop_progressive().
-        """
-        if device is None:
-            device = next(model.parameters()).device
-        assert isinstance(shape, (tuple, list))
-        if noise is not None:
-            img = noise
-        else:
-            if segmentation_img is None:  # normal sampling
-                img = th.randn(*shape, device=device)
-            else:                         # segmentation mode
-                label_shape = (segmentation_img.shape[0], model.out_channels, *segmentation_img.shape[2:])
-                img = th.randn(label_shape, dtype=segmentation_img.dtype, device=segmentation_img.device)
-
-        indices = list(range(time))[::-1] # klappt nur für batch_size == 1
-
-
-        if sampling_steps:
-            tmp = np.linspace(999, 0, sampling_steps)
-            tmp = np.append(tmp, -tmp[-2])
-            indices = tmp[:-1].round().astype(np.int)
-            indices_prev = tmp[1:].round().astype(np.int)
-        else:
-            indices_prev = [i-1 for i in indices]
-
-        if True: #progress:
-            # Lazy import so that we don't depend on tqdm.
-            from tqdm.auto import tqdm
-
-            indices = tqdm(indices)
-
-        for i, i_prev in zip(indices, indices_prev): # 1000 -> 0
-            if segmentation_img is not None:
-                prev_img = img
-                img = th.cat((segmentation_img, img), dim=1)
-            t = th.tensor([i] * shape[0], device=device)
-            t_prev = th.tensor([i_prev] * shape[0], device=device)
-            with th.no_grad():
-                out = self.ddim_sample(
-                   model,
-                   img,
-                   t,
-                   t_cpu=i,
-                   t_prev=t_prev,
-                   t_prev_cpu=i_prev,
-                   clip_denoised=clip_denoised,
-                   denoised_fn=denoised_fn,
-                   cond_fn=cond_fn,
-                   model_kwargs=model_kwargs,
-                   eta=eta,
-                   sampling_steps=sampling_steps,
-                )
-                yield out
-                img = out["sample"]
-
-    def _vb_terms_bpd(
-        self, model, x_start, x_t, t, clip_denoised=True, model_kwargs=None
-    ):
-        """
-        Get a term for the variational lower-bound.
-
-        The resulting units are bits (rather than nats, as one might expect).
-        This allows for comparison to other papers.
-
-        :return: a dict with the following keys:
-                 - 'output': a shape [N] tensor of NLLs or KLs.
-                 - 'pred_xstart': the x_0 predictions.
-        """
-        true_mean, _, true_log_variance_clipped = self.q_posterior_mean_variance(
-            x_start=x_start, x_t=x_t, t=t
-        )
-        out = self.p_mean_variance(
-            model, x_t, t, clip_denoised=clip_denoised, model_kwargs=model_kwargs
-        )
-        kl = normal_kl(
-            true_mean, true_log_variance_clipped, out["mean"], out["log_variance"]
-        )
-        kl = mean_flat(kl) / np.log(2.0)
-
-        decoder_nll = -discretized_gaussian_log_likelihood(
-            x_start, means=out["mean"], log_scales=0.5 * out["log_variance"]
-        )
-        assert decoder_nll.shape == x_start.shape
-        decoder_nll = mean_flat(decoder_nll) / np.log(2.0)
-
-        # At the first timestep return the decoder NLL,
-        # otherwise return KL(q(x_{t-1}|x_t,x_0) || p(x_{t-1}|x_t))
-        output = th.where((t == 0), decoder_nll, kl)
-        return {"output": output, "pred_xstart": out["pred_xstart"]}
-
-    def training_losses(self, model,  x_start, t, classifier=None, model_kwargs=None, noise=None, labels=None,
-                        mode='default'):
-        """
-        Compute training losses for a single timestep.
-        :param model: the model to evaluate loss on.
-        :param x_start: the [N x C x ...] tensor of inputs - original image resolution.
-        :param t: a batch of timestep indices.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-        :param noise: if specified, the specific Gaussian noise to try to remove.
-        :param labels: must be specified for mode='segmentation'
-        :param mode:  can be default (image generation), segmentation
-        :return: a dict with the key "loss" containing a tensor of shape [N].
-                 Some mean or variance settings may also have other keys.
-        """
-        if model_kwargs is None:
-            model_kwargs = {}
-
-        # Wavelet transform the input image
-        LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = dwt(x_start)
-        x_start_dwt = th.cat([LLL / 3., LLH, LHL, LHH, HLL, HLH, HHL, HHH], dim=1)
-
-        if mode == 'default':
-            noise = th.randn_like(x_start)  # Sample noise - original image resolution.
-            LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = dwt(noise)
-            noise_dwt = th.cat([LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH], dim=1)  # Wavelet transformed noise
-            x_t = self.q_sample(x_start_dwt, t, noise=noise_dwt)  # Sample x_t
-
-        else:
-            raise ValueError(f'Invalid mode {mode=}, needs to be "default"')
-
-        model_output = model(x_t, self._scale_timesteps(t), **model_kwargs)  # Model outputs denoised wavelet subbands
-
-        # Inverse wavelet transform the model output
-        B, _, H, W, D = model_output.size()
-        model_output_idwt = idwt(model_output[:, 0, :, :, :].view(B, 1, H, W, D) * 3.,
-                                 model_output[:, 1, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 2, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 3, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 4, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 5, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 6, :, :, :].view(B, 1, H, W, D),
-                                 model_output[:, 7, :, :, :].view(B, 1, H, W, D))
-
-        terms = {"mse_wav": th.mean(mean_flat((x_start_dwt - model_output) ** 2), dim=0)}
-
-        return terms, model_output, model_output_idwt
-
-
-    def _prior_bpd(self, x_start):
-        """
-        Get the prior KL term for the variational lower-bound, measured in
-        bits-per-dim.
-
-        This term can't be optimized, as it only depends on the encoder.
-
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :return: a batch of [N] KL values (in bits), one per batch element.
-        """
-        batch_size = x_start.shape[0]
-        t = th.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
-        qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
-        kl_prior = normal_kl(
-            mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0
-        )
-        return mean_flat(kl_prior) / np.log(2.0)
-
-    def calc_bpd_loop(self, model, x_start, clip_denoised=True, model_kwargs=None):
-        """
-        Compute the entire variational lower-bound, measured in bits-per-dim,
-        as well as other related quantities.
-
-        :param model: the model to evaluate loss on.
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :param clip_denoised: if True, clip denoised samples.
-        :param model_kwargs: if not None, a dict of extra keyword arguments to
-            pass to the model. This can be used for conditioning.
-
-        :return: a dict containing the following keys:
-                 - total_bpd: the total variational lower-bound, per batch element.
-                 - prior_bpd: the prior term in the lower-bound.
-                 - vb: an [N x T] tensor of terms in the lower-bound.
-                 - xstart_mse: an [N x T] tensor of x_0 MSEs for each timestep.
-                 - mse: an [N x T] tensor of epsilon MSEs for each timestep.
-        """
-        device = x_start.device
-        batch_size = x_start.shape[0]
-
-        vb = []
-        xstart_mse = []
-        mse = []
-        for t in list(range(self.num_timesteps))[::-1]:
-            t_batch = th.tensor([t] * batch_size, device=device)
-            noise = th.randn_like(x_start)
-            x_t = self.q_sample(x_start=x_start, t=t_batch, noise=noise)
-
-            # Calculate VLB term at the current timestep
-            with th.no_grad():
-                out = self._vb_terms_bptimestepsd(
-                    model,
-                    x_start=x_start,
-                    x_t=x_t,
-                    t=t_batch,
-                    clip_denoised=clip_denoised,
-                    model_kwargs=model_kwargs,
-                )
-            vb.append(out["output"])
-            xstart_mse.append(mean_flat((out["pred_xstart"] - x_start) ** 2))
-            eps = self._predict_eps_from_xstart(x_t, t_batch, out["pred_xstart"])
-            mse.append(mean_flat((eps - noise) ** 2))
-
-        vb = th.stack(vb, dim=1)
-        xstart_mse = th.stack(xstart_mse, dim=1)
-        mse = th.stack(mse, dim=1)
-
-        prior_bpd = self._prior_bpd(x_start)
-        total_bpd = vb.sum(dim=1) + prior_bpd
-        return {
-            "total_bpd": total_bpd,
-            "prior_bpd": prior_bpd,
-            "vb": vb,
-            "xstart_mse": xstart_mse,
-            "mse": mse,
-        }
-
-
-def _extract_into_tensor(arr, timesteps, broadcast_shape):
-    """
-    Extract values from a 1-D numpy array for a batch of indices.
-
-    :param arr: the 1-D numpy array.
-    :param timesteps: a tensor of indices into the array to extract.
-    :param broadcast_shape: a larger shape of K dimensions with the batch
-                            dimension equal to the length of timesteps.
-    :return: a tensor of shape [batch_size, 1, ...] where the shape has K dims.
-    """
-    res = th.from_numpy(arr).to(device=timesteps.device)[timesteps].float()
-    while len(res.shape) < len(broadcast_shape):
-        res = res[..., None]
-    return res.expand(broadcast_shape)

wdm-3d-initial/guided_diffusion/inpaintloader.py

@@ -1,131 +0,0 @@
-import os, nibabel, torch, numpy as np
-import torch.nn as nn
-from torch.utils.data import Dataset
-import pandas as pd
-import re
-
-
-class InpaintVolumes(Dataset):
-    """
-    Y  : float32  [C, D, H, W]   full multi-modal MRI stack
-    M  : float32  [1, D, H, W]   binary in-painting mask (shared by all mods)
-    Y_void = Y * (1 - M)         context with lesion region blanked
-    name : identifier string
-    """
-
-    # ------------------------------------------------------------
-    def __init__(self,
-                 root_dir: str,
-                 subset: str = 'train',          # 'train' | 'val'
-                 img_size: int = 256,            # 128 or 256 cube
-                 modalities: tuple = ('T1w',),    # order defines channel order
-                 normalize=None):
-        super().__init__()
-        self.root_dir   = os.path.expanduser(root_dir)
-        self.subset     = subset
-        self.img_size   = img_size
-        self.modalities = modalities           
-        self.normalize  = normalize or (lambda x: x)
-        self.cases      = self._index_cases()   # ⇒ list[dict]
-
-    # ------------------------------------------------------------
-    def _index_cases(self):
-        """
-        Build a list like:
-            {'img': {'T1w': path, 'FLAIR': path, ...},
-             'mask': path,
-             'name': case_id}
-        Edit only this block to suit your folder / filename scheme.
-        """
-        cases = []
-        
-        # metadata
-        df = pd.read_csv(f"{self.root_dir}/participants.tsv", sep="\t") 
-        # update with new splits
-        
-        # filter FCD samples
-        fcd_df = df[df['group'] == 'fcd'].copy()
-        # shuffle indices
-        fcd_df = fcd_df.sample(frac=1, random_state=42).reset_index(drop=True)
-        # compute split index
-        n_train = int(len(fcd_df) * 0.9)
-        # assign split labels
-        fcd_df.loc[:n_train-1, 'split'] = 'train'
-        fcd_df.loc[n_train:, 'split'] = 'val'
-        #update
-        df.loc[fcd_df.index, 'split'] = fcd_df['split']
-
-        missing = []
-        
-        for participant_id in df[(df['split']==self.subset) & (df['group']=='fcd')]['participant_id']:
-            case_dir = f"{self.root_dir}/{participant_id}/anat/"
-            files = os.listdir(case_dir)
-            
-            img_dict = {}
-            for mod in self.modalities:
-                pattern = re.compile(rf"^{re.escape(participant_id)}.*{re.escape(mod)}\.nii\.gz$")
-                matches = [f for f in files if pattern.match(f)]
-                assert matches, f"Missing {mod} for {participant_id} in {case_dir}"
-                img_dict[mod] = os.path.join(case_dir, matches[0])
-
-            mask_matches = [f for f in files if re.match(rf"^{re.escape(participant_id)}.*roi\.nii\.gz$", f)]
-            mask_path = os.path.join(case_dir, mask_matches[0])
-
-            cases.append({'img': img_dict, 'mask': mask_path, 'name': participant_id})
-        
-        return cases
-
-    # ------------------------------------------------------------
-    def _pad_to_cube(self, vol, fill=0.0):
-        """Symmetric 3-D pad to [img_size³].  `vol` is [*, D, H, W]."""
-        D, H, W = vol.shape[-3:]
-        pad_D, pad_H, pad_W = self.img_size - D, self.img_size - H, self.img_size - W
-        pad = (pad_W // 2, pad_W - pad_W // 2,
-               pad_H // 2, pad_H - pad_H // 2,
-               pad_D // 2, pad_D - pad_D // 2)
-        return nn.functional.pad(vol, pad, value=fill)
-
-    # ------------------------------------------------------------
-    def __getitem__(self, idx):
-        rec  = self.cases[idx]
-        name = rec['name']
-
-        # ---------- load C modalities --------------------------
-        vols = []
-        for mod in self.modalities:                       
-            mod_path = rec['img'][mod]                    
-            arr = nibabel.load(mod_path).get_fdata().astype(np.float32)
-            
-            # robust min-max clipping and normalization
-            lo, hi = np.quantile(arr, [0.001, 0.999])
-            arr = np.clip(arr, lo, hi)
-            arr = (arr - lo) / (hi - lo + 1e-6)
-        
-            vols.append(torch.from_numpy(arr))
-
-        first_mod = self.modalities[0]
-        nii_obj   = nibabel.load(rec['img'][first_mod])
-        affine    = nii_obj.affine
-        
-        Y = torch.stack(vols, dim=0)            # [C, D, H, W]
-
-        # ---------- load mask ----------------------------------
-        M_arr = nibabel.load(rec['mask']).get_fdata().astype(np.uint8)
-        M = torch.from_numpy(M_arr).unsqueeze(0)      # [1, D, H, W]
-        M = (M > 0).to(Y.dtype)
-
-        # ---------- pad (and optional downsample) --------------
-        Y = self._pad_to_cube(Y, fill=0.0)
-        M = self._pad_to_cube(M, fill=0.0)
-        if self.img_size == 128:
-            pool = nn.AvgPool3d(2, 2)
-            Y = pool(Y);  M = pool(M)
-
-        # ---------- derive context image -----------------------
-        Y_void = Y * (1 - M)
-
-        return Y, M, Y_void, name, affine    # shapes: [C, D, H, W], [1, D, H, W], [C, D, H, W], ...
-
-    # ------------------------------------------------------------
-    def __len__(self):
-        return len(self.cases)

wdm-3d-initial/guided_diffusion/lidcloader.py

@@ -1,70 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.utils.data
-import os
-import os.path
-import nibabel
-
-
-class LIDCVolumes(torch.utils.data.Dataset):
-    def __init__(self, directory, test_flag=False, normalize=None, mode='train', img_size=256):
-        '''
-        directory is expected to contain some folder structure:
-                  if some subfolder contains only files, all of these
-                  files are assumed to have the name: processed.nii.gz
-        '''
-        super().__init__()
-        self.mode = mode
-        self.directory = os.path.expanduser(directory)
-        self.normalize = normalize or (lambda x: x)
-        self.test_flag = test_flag
-        self.img_size = img_size
-        self.database = []
-
-        if not self.mode == 'fake':
-            for root, dirs, files in os.walk(self.directory):
-                # if there are no subdirs, we have a datadir
-                if not dirs:
-                    files.sort()
-                    datapoint = dict()
-                    # extract all files as channels
-                    for f in files:
-                        datapoint['image'] = os.path.join(root, f)
-                    if len(datapoint) != 0:
-                        self.database.append(datapoint)
-        else:
-            for root, dirs, files in os.walk(self.directory):
-                for f in files:
-                    datapoint = dict()
-                    datapoint['image'] = os.path.join(root, f)
-                    self.database.append(datapoint)
-
-    def __getitem__(self, x):
-        filedict = self.database[x]
-        name = filedict['image']
-        nib_img = nibabel.load(name)
-        out = nib_img.get_fdata()
-
-        if not self.mode == 'fake':
-            out = torch.Tensor(out)
-
-            image = torch.zeros(1, 256, 256, 256)
-            image[:, :, :, :] = out
-
-            if self.img_size == 128:
-                downsample = nn.AvgPool3d(kernel_size=2, stride=2)
-                image = downsample(image)
-        else:
-            image = torch.tensor(out, dtype=torch.float32)
-            image = image.unsqueeze(dim=0)
-
-        # normalization
-        image = self.normalize(image)
-
-        if self.mode == 'fake':
-            return image, name
-        else:
-            return image
-
-    def __len__(self):
-        return len(self.database)

wdm-3d-initial/guided_diffusion/logger.py

@@ -1,495 +0,0 @@
-"""
-Logger copied from OpenAI baselines to avoid extra RL-based dependencies:
-https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/logger.py
-"""
-
-import os
-import sys
-import shutil
-import os.path as osp
-import json
-import time
-import datetime
-import tempfile
-import warnings
-from collections import defaultdict
-from contextlib import contextmanager
-
-DEBUG = 10
-INFO = 20
-WARN = 30
-ERROR = 40
-
-DISABLED = 50
-
-
-class KVWriter(object):
-    def writekvs(self, kvs):
-        raise NotImplementedError
-
-
-class SeqWriter(object):
-    def writeseq(self, seq):
-        raise NotImplementedError
-
-
-class HumanOutputFormat(KVWriter, SeqWriter):
-    def __init__(self, filename_or_file):
-        if isinstance(filename_or_file, str):
-            self.file = open(filename_or_file, "wt")
-            self.own_file = True
-        else:
-            assert hasattr(filename_or_file, "read"), (
-                "expected file or str, got %s" % filename_or_file
-            )
-            self.file = filename_or_file
-            self.own_file = False
-
-    def writekvs(self, kvs):
-        # Create strings for printing
-        key2str = {}
-        for (key, val) in sorted(kvs.items()):
-            if hasattr(val, "__float__"):
-                valstr = "%-8.3g" % val
-            else:
-                valstr = str(val)
-            key2str[self._truncate(key)] = self._truncate(valstr)
-
-        # Find max widths
-        if len(key2str) == 0:
-            print("WARNING: tried to write empty key-value dict")
-            return
-        else:
-            keywidth = max(map(len, key2str.keys()))
-            valwidth = max(map(len, key2str.values()))
-
-        # Write out the data
-        dashes = "-" * (keywidth + valwidth + 7)
-        lines = [dashes]
-        for (key, val) in sorted(key2str.items(), key=lambda kv: kv[0].lower()):
-            lines.append(
-                "| %s%s | %s%s |"
-                % (key, " " * (keywidth - len(key)), val, " " * (valwidth - len(val)))
-            )
-        lines.append(dashes)
-        self.file.write("\n".join(lines) + "\n")
-
-        # Flush the output to the file
-        self.file.flush()
-
-    def _truncate(self, s):
-        maxlen = 30
-        return s[: maxlen - 3] + "..." if len(s) > maxlen else s
-
-    def writeseq(self, seq):
-        seq = list(seq)
-        for (i, elem) in enumerate(seq):
-            self.file.write(elem)
-            if i < len(seq) - 1:  # add space unless this is the last one
-                self.file.write(" ")
-        self.file.write("\n")
-        self.file.flush()
-
-    def close(self):
-        if self.own_file:
-            self.file.close()
-
-
-class JSONOutputFormat(KVWriter):
-    def __init__(self, filename):
-        self.file = open(filename, "wt")
-
-    def writekvs(self, kvs):
-        for k, v in sorted(kvs.items()):
-            if hasattr(v, "dtype"):
-                kvs[k] = float(v)
-        self.file.write(json.dumps(kvs) + "\n")
-        self.file.flush()
-
-    def close(self):
-        self.file.close()
-
-
-class CSVOutputFormat(KVWriter):
-    def __init__(self, filename):
-        self.file = open(filename, "w+t")
-        self.keys = []
-        self.sep = ","
-
-    def writekvs(self, kvs):
-        # Add our current row to the history
-        extra_keys = list(kvs.keys() - self.keys)
-        extra_keys.sort()
-        if extra_keys:
-            self.keys.extend(extra_keys)
-            self.file.seek(0)
-            lines = self.file.readlines()
-            self.file.seek(0)
-            for (i, k) in enumerate(self.keys):
-                if i > 0:
-                    self.file.write(",")
-                self.file.write(k)
-            self.file.write("\n")
-            for line in lines[1:]:
-                self.file.write(line[:-1])
-                self.file.write(self.sep * len(extra_keys))
-                self.file.write("\n")
-        for (i, k) in enumerate(self.keys):
-            if i > 0:
-                self.file.write(",")
-            v = kvs.get(k)
-            if v is not None:
-                self.file.write(str(v))
-        self.file.write("\n")
-        self.file.flush()
-
-    def close(self):
-        self.file.close()
-
-
-class TensorBoardOutputFormat(KVWriter):
-    """
-    Dumps key/value pairs into TensorBoard's numeric format.
-    """
-
-    def __init__(self, dir):
-        os.makedirs(dir, exist_ok=True)
-        self.dir = dir
-        self.step = 1
-        prefix = "events"
-        path = osp.join(osp.abspath(dir), prefix)
-        import tensorflow as tf
-        from tensorflow.python import pywrap_tensorflow
-        from tensorflow.core.util import event_pb2
-        from tensorflow.python.util import compat
-
-        self.tf = tf
-        self.event_pb2 = event_pb2
-        self.pywrap_tensorflow = pywrap_tensorflow
-        self.writer = pywrap_tensorflow.EventsWriter(compat.as_bytes(path))
-
-    def writekvs(self, kvs):
-        def summary_val(k, v):
-            kwargs = {"tag": k, "simple_value": float(v)}
-            return self.tf.Summary.Value(**kwargs)
-
-        summary = self.tf.Summary(value=[summary_val(k, v) for k, v in kvs.items()])
-        event = self.event_pb2.Event(wall_time=time.time(), summary=summary)
-        event.step = (
-            self.step
-        )  # is there any reason why you'd want to specify the step?
-        self.writer.WriteEvent(event)
-        self.writer.Flush()
-        self.step += 1
-
-    def close(self):
-        if self.writer:
-            self.writer.Close()
-            self.writer = None
-
-
-def make_output_format(format, ev_dir, log_suffix=""):
-    os.makedirs(ev_dir, exist_ok=True)
-    if format == "stdout":
-        return HumanOutputFormat(sys.stdout)
-    elif format == "log":
-        return HumanOutputFormat(osp.join(ev_dir, "log%s.txt" % log_suffix))
-    elif format == "json":
-        return JSONOutputFormat(osp.join(ev_dir, "progress%s.json" % log_suffix))
-    elif format == "csv":
-        return CSVOutputFormat(osp.join(ev_dir, "progress%s.csv" % log_suffix))
-    elif format == "tensorboard":
-        return TensorBoardOutputFormat(osp.join(ev_dir, "tb%s" % log_suffix))
-    else:
-        raise ValueError("Unknown format specified: %s" % (format,))
-
-
-# ================================================================
-# API
-# ================================================================
-
-
-def logkv(key, val):
-    """
-    Log a value of some diagnostic
-    Call this once for each diagnostic quantity, each iteration
-    If called many times, last value will be used.
-    """
-    get_current().logkv(key, val)
-
-
-def logkv_mean(key, val):
-    """
-    The same as logkv(), but if called many times, values averaged.
-    """
-    get_current().logkv_mean(key, val)
-
-
-def logkvs(d):
-    """
-    Log a dictionary of key-value pairs
-    """
-    for (k, v) in d.items():
-        logkv(k, v)
-
-
-def dumpkvs():
-    """
-    Write all of the diagnostics from the current iteration
-    """
-    return get_current().dumpkvs()
-
-
-def getkvs():
-    return get_current().name2val
-
-
-def log(*args, level=INFO):
-    """
-    Write the sequence of args, with no separators, to the console and output files (if you've configured an output file).
-    """
-    get_current().log(*args, level=level)
-
-
-def debug(*args):
-    log(*args, level=DEBUG)
-
-
-def info(*args):
-    log(*args, level=INFO)
-
-
-def warn(*args):
-    log(*args, level=WARN)
-
-
-def error(*args):
-    log(*args, level=ERROR)
-
-
-def set_level(level):
-    """
-    Set logging threshold on current logger.
-    """
-    get_current().set_level(level)
-
-
-def set_comm(comm):
-    get_current().set_comm(comm)
-
-
-def get_dir():
-    """
-    Get directory that log files are being written to.
-    will be None if there is no output directory (i.e., if you didn't call start)
-    """
-    return get_current().get_dir()
-
-
-record_tabular = logkv
-dump_tabular = dumpkvs
-
-
-@contextmanager
-def profile_kv(scopename):
-    logkey = "wait_" + scopename
-    tstart = time.time()
-    try:
-        yield
-    finally:
-        get_current().name2val[logkey] += time.time() - tstart
-
-
-def profile(n):
-    """
-    Usage:
-    @profile("my_func")
-    def my_func(): code
-    """
-
-    def decorator_with_name(func):
-        def func_wrapper(*args, **kwargs):
-            with profile_kv(n):
-                return func(*args, **kwargs)
-
-        return func_wrapper
-
-    return decorator_with_name
-
-
-# ================================================================
-# Backend
-# ================================================================
-
-
-def get_current():
-    if Logger.CURRENT is None:
-        _configure_default_logger()
-
-    return Logger.CURRENT
-
-
-class Logger(object):
-    DEFAULT = None  # A logger with no output files. (See right below class definition)
-    # So that you can still log to the terminal without setting up any output files
-    CURRENT = None  # Current logger being used by the free functions above
-
-    def __init__(self, dir, output_formats, comm=None):
-        self.name2val = defaultdict(float)  # values this iteration
-        self.name2cnt = defaultdict(int)
-        self.level = INFO
-        self.dir = dir
-        self.output_formats = output_formats
-        self.comm = comm
-
-    # Logging API, forwarded
-    # ----------------------------------------
-    def logkv(self, key, val):
-        self.name2val[key] = val
-
-    def logkv_mean(self, key, val):
-        oldval, cnt = self.name2val[key], self.name2cnt[key]
-        self.name2val[key] = oldval * cnt / (cnt + 1) + val / (cnt + 1)
-        self.name2cnt[key] = cnt + 1
-
-    def dumpkvs(self):
-        if self.comm is None:
-            d = self.name2val
-        else:
-            d = mpi_weighted_mean(
-                self.comm,
-                {
-                    name: (val, self.name2cnt.get(name, 1))
-                    for (name, val) in self.name2val.items()
-                },
-            )
-            if self.comm.rank != 0:
-                d["dummy"] = 1  # so we don't get a warning about empty dict
-        out = d.copy()  # Return the dict for unit testing purposes
-        for fmt in self.output_formats:
-            if isinstance(fmt, KVWriter):
-                fmt.writekvs(d)
-        self.name2val.clear()
-        self.name2cnt.clear()
-        return out
-
-    def log(self, *args, level=INFO):
-        if self.level <= level:
-            self._do_log(args)
-
-    # Configuration
-    # ----------------------------------------
-    def set_level(self, level):
-        self.level = level
-
-    def set_comm(self, comm):
-        self.comm = comm
-
-    def get_dir(self):
-        return self.dir
-
-    def close(self):
-        for fmt in self.output_formats:
-            fmt.close()
-
-    # Misc
-    # ----------------------------------------
-    def _do_log(self, args):
-        for fmt in self.output_formats:
-            if isinstance(fmt, SeqWriter):
-                fmt.writeseq(map(str, args))
-
-
-def get_rank_without_mpi_import():
-    # check environment variables here instead of importing mpi4py
-    # to avoid calling MPI_Init() when this module is imported
-    for varname in ["PMI_RANK", "OMPI_COMM_WORLD_RANK"]:
-        if varname in os.environ:
-            return int(os.environ[varname])
-    return 0
-
-
-def mpi_weighted_mean(comm, local_name2valcount):
-    """
-    Copied from: https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/common/mpi_util.py#L110
-    Perform a weighted average over dicts that are each on a different node
-    Input: local_name2valcount: dict mapping key -> (value, count)
-    Returns: key -> mean
-    """
-    all_name2valcount = comm.gather(local_name2valcount)
-    if comm.rank == 0:
-        name2sum = defaultdict(float)
-        name2count = defaultdict(float)
-        for n2vc in all_name2valcount:
-            for (name, (val, count)) in n2vc.items():
-                try:
-                    val = float(val)
-                except ValueError:
-                    if comm.rank == 0:
-                        warnings.warn(
-                            "WARNING: tried to compute mean on non-float {}={}".format(
-                                name, val
-                            )
-                        )
-                else:
-                    name2sum[name] += val * count
-                    name2count[name] += count
-        return {name: name2sum[name] / name2count[name] for name in name2sum}
-    else:
-        return {}
-
-
-def configure(dir='./results', format_strs=None, comm=None, log_suffix=""):
-    """
-    If comm is provided, average all numerical stats across that comm
-    """
-    if dir is None:
-        dir = os.getenv("OPENAI_LOGDIR")
-    if dir is None:
-        dir = osp.join(
-            tempfile.gettempdir(),
-            datetime.datetime.now().strftime("openai-%Y-%m-%d-%H-%M-%S-%f"),
-        )
-    assert isinstance(dir, str)
-    dir = os.path.expanduser(dir)
-    os.makedirs(os.path.expanduser(dir), exist_ok=True)
-
-    rank = get_rank_without_mpi_import()
-    if rank > 0:
-        log_suffix = log_suffix + "-rank%03i" % rank
-
-    if format_strs is None:
-        if rank == 0:
-            format_strs = os.getenv("OPENAI_LOG_FORMAT", "stdout,log,csv").split(",")
-        else:
-            format_strs = os.getenv("OPENAI_LOG_FORMAT_MPI", "log").split(",")
-    format_strs = filter(None, format_strs)
-    output_formats = [make_output_format(f, dir, log_suffix) for f in format_strs]
-
-    Logger.CURRENT = Logger(dir=dir, output_formats=output_formats, comm=comm)
-    if output_formats:
-        log("Logging to %s" % dir)
-
-
-def _configure_default_logger():
-    configure()
-    Logger.DEFAULT = Logger.CURRENT
-
-
-def reset():
-    if Logger.CURRENT is not Logger.DEFAULT:
-        Logger.CURRENT.close()
-        Logger.CURRENT = Logger.DEFAULT
-        log("Reset logger")
-
-
-@contextmanager
-def scoped_configure(dir=None, format_strs=None, comm=None):
-    prevlogger = Logger.CURRENT
-    configure(dir=dir, format_strs=format_strs, comm=comm)
-    try:
-        yield
-    finally:
-        Logger.CURRENT.close()
-        Logger.CURRENT = prevlogger
-

wdm-3d-initial/guided_diffusion/losses.py

@@ -1,77 +0,0 @@
-"""
-Helpers for various likelihood-based losses. These are ported from the original
-Ho et al. diffusion models codebase:
-https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/utils.py
-"""
-
-import numpy as np
-
-import torch as th
-
-
-def normal_kl(mean1, logvar1, mean2, logvar2):
-    """
-    Compute the KL divergence between two gaussians.
-
-    Shapes are automatically broadcasted, so batches can be compared to
-    scalars, among other use cases.
-    """
-    tensor = None
-    for obj in (mean1, logvar1, mean2, logvar2):
-        if isinstance(obj, th.Tensor):
-            tensor = obj
-            break
-    assert tensor is not None, "at least one argument must be a Tensor"
-
-    # Force variances to be Tensors. Broadcasting helps convert scalars to
-    # Tensors, but it does not work for th.exp().
-    logvar1, logvar2 = [
-        x if isinstance(x, th.Tensor) else th.tensor(x).to(tensor)
-        for x in (logvar1, logvar2)
-    ]
-
-    return 0.5 * (
-        -1.0
-        + logvar2
-        - logvar1
-        + th.exp(logvar1 - logvar2)
-        + ((mean1 - mean2) ** 2) * th.exp(-logvar2)
-    )
-
-
-def approx_standard_normal_cdf(x):
-    """
-    A fast approximation of the cumulative distribution function of the
-    standard normal.
-    """
-    return 0.5 * (1.0 + th.tanh(np.sqrt(2.0 / np.pi) * (x + 0.044715 * th.pow(x, 3))))
-
-
-def discretized_gaussian_log_likelihood(x, *, means, log_scales):
-    """
-    Compute the log-likelihood of a Gaussian distribution discretizing to a
-    given image.
-
-    :param x: the target images. It is assumed that this was uint8 values,
-              rescaled to the range [-1, 1].
-    :param means: the Gaussian mean Tensor.
-    :param log_scales: the Gaussian log stddev Tensor.
-    :return: a tensor like x of log probabilities (in nats).
-    """
-    assert x.shape == means.shape == log_scales.shape
-    centered_x = x - means
-    inv_stdv = th.exp(-log_scales)
-    plus_in = inv_stdv * (centered_x + 1.0 / 255.0)
-    cdf_plus = approx_standard_normal_cdf(plus_in)
-    min_in = inv_stdv * (centered_x - 1.0 / 255.0)
-    cdf_min = approx_standard_normal_cdf(min_in)
-    log_cdf_plus = th.log(cdf_plus.clamp(min=1e-12))
-    log_one_minus_cdf_min = th.log((1.0 - cdf_min).clamp(min=1e-12))
-    cdf_delta = cdf_plus - cdf_min
-    log_probs = th.where(
-        x < -0.999,
-        log_cdf_plus,
-        th.where(x > 0.999, log_one_minus_cdf_min, th.log(cdf_delta.clamp(min=1e-12))),
-    )
-    assert log_probs.shape == x.shape
-    return log_probs

wdm-3d-initial/guided_diffusion/nn.py

@@ -1,170 +0,0 @@
-"""
-Various utilities for neural networks.
-"""
-
-import math
-
-import torch as th
-import torch.nn as nn
-
-
-# PyTorch 1.7 has SiLU, but we support PyTorch 1.5.
-class SiLU(nn.Module):
-    def forward(self, x):
-        return x * th.sigmoid(x)
-
-
-class GroupNorm32(nn.GroupNorm):
-    def forward(self, x):
-        return super().forward(x.float()).type(x.dtype)
-
-
-def conv_nd(dims, *args, **kwargs):
-    """
-    Create a 1D, 2D, or 3D convolution module.
-    """
-    if dims == 1:
-        return nn.Conv1d(*args, **kwargs)
-    elif dims == 2:
-        return nn.Conv2d(*args, **kwargs)
-    elif dims == 3:
-        return nn.Conv3d(*args, **kwargs)
-    raise ValueError(f"unsupported dimensions: {dims}")
-
-
-def linear(*args, **kwargs):
-    """
-    Create a linear module.
-    """
-    return nn.Linear(*args, **kwargs)
-
-
-def avg_pool_nd(dims, *args, **kwargs):
-    """
-    Create a 1D, 2D, or 3D average pooling module.
-    """
-    if dims == 1:
-        return nn.AvgPool1d(*args, **kwargs)
-    elif dims == 2:
-        return nn.AvgPool2d(*args, **kwargs)
-    elif dims == 3:
-        return nn.AvgPool3d(*args, **kwargs)
-    raise ValueError(f"unsupported dimensions: {dims}")
-
-
-def update_ema(target_params, source_params, rate=0.99):
-    """
-    Update target parameters to be closer to those of source parameters using
-    an exponential moving average.
-
-    :param target_params: the target parameter sequence.
-    :param source_params: the source parameter sequence.
-    :param rate: the EMA rate (closer to 1 means slower).
-    """
-    for targ, src in zip(target_params, source_params):
-        targ.detach().mul_(rate).add_(src, alpha=1 - rate)
-
-
-def zero_module(module):
-    """
-    Zero out the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().zero_()
-    return module
-
-
-def scale_module(module, scale):
-    """
-    Scale the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().mul_(scale)
-    return module
-
-
-def mean_flat(tensor):
-    """
-    Take the mean over all non-batch dimensions.
-    """
-    return tensor.mean(dim=list(range(2, len(tensor.shape))))
-
-
-def normalization(channels, groups=32):
-    """
-    Make a standard normalization layer.
-
-    :param channels: number of input channels.
-    :return: an nn.Module for normalization.
-    """
-    return GroupNorm32(groups, channels)
-
-
-def timestep_embedding(timesteps, dim, max_period=10000):
-    """
-    Create sinusoidal timestep embeddings.
-
-    :param timesteps: a 1-D Tensor of N indices, one per batch element.
-                      These may be fractional.
-    :param dim: the dimension of the output.
-    :param max_period: controls the minimum frequency of the embeddings.
-    :return: an [N x dim] Tensor of positional embeddings.
-    """
-    half = dim // 2
-    freqs = th.exp(
-        -math.log(max_period) * th.arange(start=0, end=half, dtype=th.float32) / half
-    ).to(device=timesteps.device)
-    args = timesteps[:, None].float() * freqs[None]
-    embedding = th.cat([th.cos(args), th.sin(args)], dim=-1)
-    if dim % 2:
-        embedding = th.cat([embedding, th.zeros_like(embedding[:, :1])], dim=-1)
-    return embedding
-
-
-def checkpoint(func, inputs, params, flag):
-    """
-    Evaluate a function without caching intermediate activations, allowing for
-    reduced memory at the expense of extra compute in the backward pass.
-
-    :param func: the function to evaluate.
-    :param inputs: the argument sequence to pass to `func`.
-    :param params: a sequence of parameters `func` depends on but does not
-                   explicitly take as arguments.
-    :param flag: if False, disable gradient checkpointing.
-    """
-    if flag:
-        args = tuple(inputs) + tuple(params)
-        return CheckpointFunction.apply(func, len(inputs), *args)
-    else:
-        return func(*inputs)
-
-
-class CheckpointFunction(th.autograd.Function):
-    @staticmethod
-    def forward(ctx, run_function, length, *args):
-        ctx.run_function = run_function
-        ctx.input_tensors = list(args[:length])
-        ctx.input_params = list(args[length:])
-        with th.no_grad():
-            output_tensors = ctx.run_function(*ctx.input_tensors)
-        return output_tensors
-
-    @staticmethod
-    def backward(ctx, *output_grads):
-        ctx.input_tensors = [x.detach().requires_grad_(True) for x in ctx.input_tensors]
-        with th.enable_grad():
-            # Fixes a bug where the first op in run_function modifies the
-            # Tensor storage in place, which is not allowed for detach()'d
-            # Tensors.
-            shallow_copies = [x.view_as(x) for x in ctx.input_tensors]
-            output_tensors = ctx.run_function(*shallow_copies)
-        input_grads = th.autograd.grad(
-            output_tensors,
-            ctx.input_tensors + ctx.input_params,
-            output_grads,
-            allow_unused=True,
-        )
-        del ctx.input_tensors
-        del ctx.input_params
-        del output_tensors
-        return (None, None) + input_grads

wdm-3d-initial/guided_diffusion/resample.py

@@ -1,154 +0,0 @@
-from abc import ABC, abstractmethod
-
-import numpy as np
-import torch as th
-import torch.distributed as dist
-
-
-def create_named_schedule_sampler(name, diffusion, maxt):
-    """
-    Create a ScheduleSampler from a library of pre-defined samplers.
-
-    :param name: the name of the sampler.
-    :param diffusion: the diffusion object to sample for.
-    """
-    if name == "uniform":
-        return UniformSampler(diffusion, maxt)
-    elif name == "loss-second-moment":
-        return LossSecondMomentResampler(diffusion)
-    else:
-        raise NotImplementedError(f"unknown schedule sampler: {name}")
-
-
-class ScheduleSampler(ABC):
-    """
-    A distribution over timesteps in the diffusion process, intended to reduce
-    variance of the objective.
-
-    By default, samplers perform unbiased importance sampling, in which the
-    objective's mean is unchanged.
-    However, subclasses may override sample() to change how the resampled
-    terms are reweighted, allowing for actual changes in the objective.
-    """
-
-    @abstractmethod
-    def weights(self):
-        """
-        Get a numpy array of weights, one per diffusion step.
-
-        The weights needn't be normalized, but must be positive.
-        """
-
-    def sample(self, batch_size, device):
-        """
-        Importance-sample timesteps for a batch.
-
-        :param batch_size: the number of timesteps.
-        :param device: the torch device to save to.
-        :return: a tuple (timesteps, weights):
-                 - timesteps: a tensor of timestep indices.
-                 - weights: a tensor of weights to scale the resulting losses.
-        """
-        w = self.weights()
-        p = w / np.sum(w)
-        indices_np = np.random.choice(len(p), size=(batch_size,), p=p)
-        indices = th.from_numpy(indices_np).long().to(device)
-        weights_np = 1 / (len(p) * p[indices_np])
-        weights = th.from_numpy(weights_np).float().to(device)
-        return indices, weights
-
-
-class UniformSampler(ScheduleSampler):
-    def __init__(self, diffusion, maxt):
-        self.diffusion = diffusion
-        self._weights = np.ones([maxt])
-
-    def weights(self):
-        return self._weights
-
-
-class LossAwareSampler(ScheduleSampler):
-    def update_with_local_losses(self, local_ts, local_losses):
-        """
-        Update the reweighting using losses from a model.
-
-        Call this method from each rank with a batch of timesteps and the
-        corresponding losses for each of those timesteps.
-        This method will perform synchronization to make sure all of the ranks
-        maintain the exact same reweighting.
-
-        :param local_ts: an integer Tensor of timesteps.
-        :param local_losses: a 1D Tensor of losses.
-        """
-        batch_sizes = [
-            th.tensor([0], dtype=th.int32, device=local_ts.device)
-            for _ in range(dist.get_world_size())
-        ]
-        dist.all_gather(
-            batch_sizes,
-            th.tensor([len(local_ts)], dtype=th.int32, device=local_ts.device),
-        )
-
-        # Pad all_gather batches to be the maximum batch size.
-        batch_sizes = [x.item() for x in batch_sizes]
-        max_bs = max(batch_sizes)
-
-        timestep_batches = [th.zeros(max_bs).to(local_ts) for bs in batch_sizes]
-        loss_batches = [th.zeros(max_bs).to(local_losses) for bs in batch_sizes]
-        dist.all_gather(timestep_batches, local_ts)
-        dist.all_gather(loss_batches, local_losses)
-        timesteps = [
-            x.item() for y, bs in zip(timestep_batches, batch_sizes) for x in y[:bs]
-        ]
-        losses = [x.item() for y, bs in zip(loss_batches, batch_sizes) for x in y[:bs]]
-        self.update_with_all_losses(timesteps, losses)
-
-    @abstractmethod
-    def update_with_all_losses(self, ts, losses):
-        """
-        Update the reweighting using losses from a model.
-
-        Sub-classes should override this method to update the reweighting
-        using losses from the model.
-
-        This method directly updates the reweighting without synchronizing
-        between workers. It is called by update_with_local_losses from all
-        ranks with identical arguments. Thus, it should have deterministic
-        behavior to maintain state across workers.
-
-        :param ts: a list of int timesteps.
-        :param losses: a list of float losses, one per timestep.
-        """
-
-
-class LossSecondMomentResampler(LossAwareSampler):
-    def __init__(self, diffusion, history_per_term=10, uniform_prob=0.001):
-        self.diffusion = diffusion
-        self.history_per_term = history_per_term
-        self.uniform_prob = uniform_prob
-        self._loss_history = np.zeros(
-            [diffusion.num_timesteps, history_per_term], dtype=np.float64
-        )
-        self._loss_counts = np.zeros([diffusion.num_timesteps], dtype=np.int)
-
-    def weights(self):
-        if not self._warmed_up():
-            return np.ones([self.diffusion.num_timesteps], dtype=np.float64)
-        weights = np.sqrt(np.mean(self._loss_history ** 2, axis=-1))
-        weights /= np.sum(weights)
-        weights *= 1 - self.uniform_prob
-        weights += self.uniform_prob / len(weights)
-        return weights
-
-    def update_with_all_losses(self, ts, losses):
-        for t, loss in zip(ts, losses):
-            if self._loss_counts[t] == self.history_per_term:
-                # Shift out the oldest loss term.
-                self._loss_history[t, :-1] = self._loss_history[t, 1:]
-                self._loss_history[t, -1] = loss
-            else:
-                self._loss_history[t, self._loss_counts[t]] = loss
-                self._loss_counts[t] += 1
-
-    def _warmed_up(self):
-        return (self._loss_counts == self.history_per_term).all()

wdm-3d-initial/guided_diffusion/respace.py

@@ -1,135 +0,0 @@
-import numpy as np
-import torch as th
-
-from .gaussian_diffusion import GaussianDiffusion
-
-
-def space_timesteps(num_timesteps, section_counts):
-    """
-    Create a list of timesteps to use from an original diffusion process,
-    given the number of timesteps we want to take from equally-sized portions
-    of the original process.
-
-    For example, if there's 300 timesteps and the section counts are [10,15,20]
-    then the first 100 timesteps are strided to be 10 timesteps, the second 100
-    are strided to be 15 timesteps, and the final 100 are strided to be 20.
-
-    If the stride is a string starting with "ddim", then the fixed striding
-    from the DDIM paper is used, and only one section is allowed.
-
-    :param num_timesteps: the number of diffusion steps in the original
-                          process to divide up.
-    :param section_counts: either a list of numbers, or a string containing
-                           comma-separated numbers, indicating the step count
-                           per section. As a special case, use "ddimN" where N
-                           is a number of steps to use the striding from the
-                           DDIM paper.
-    :return: a set of diffusion steps from the original process to use.
-    """
-    if isinstance(section_counts, str):
-        if section_counts.startswith("ddim"):
-            desired_count = int(section_counts[len("ddim") :])
-            print('desired_cound', desired_count )
-            for i in range(1, num_timesteps):
-                if len(range(0, num_timesteps, i)) == desired_count:
-                    return set(range(0, num_timesteps, i))
-            raise ValueError(
-                f"cannot create exactly {num_timesteps} steps with an integer stride"
-            )
-        section_counts = [int(x) for x in section_counts.split(",")]
-    # print('sectioncount', section_counts)
-    size_per = num_timesteps // len(section_counts)
-    extra = num_timesteps % len(section_counts)
-    start_idx = 0
-    all_steps = []
-    for i, section_count in enumerate(section_counts):
-        size = size_per + (1 if i < extra else 0)
-        if size < section_count:
-            raise ValueError(
-                f"cannot divide section of {size} steps into {section_count}"
-            )
-        if section_count <= 1:
-            frac_stride = 1
-        else:
-            frac_stride = (size - 1) / (section_count - 1)
-        cur_idx = 0.0
-        taken_steps = []
-        for _ in range(section_count):
-            taken_steps.append(start_idx + round(cur_idx))
-            cur_idx += frac_stride
-        all_steps += taken_steps
-        start_idx += size
-    return set(all_steps)
-
-
-class SpacedDiffusion(GaussianDiffusion):
-    """
-    A diffusion process which can skip steps in a base diffusion process.
-
-    :param use_timesteps: a collection (sequence or set) of timesteps from the
-                          original diffusion process to retain.
-    :param kwargs: the kwargs to create the base diffusion process.
-    """
-
-    def __init__(self, use_timesteps, **kwargs):
-        self.use_timesteps = set(use_timesteps)
-        self.timestep_map = []
-        self.original_num_steps = len(kwargs["betas"])
-
-        base_diffusion = GaussianDiffusion(**kwargs)  # pylint: disable=missing-kwoa
-        last_alpha_cumprod = 1.0
-        new_betas = []
-        for i, alpha_cumprod in enumerate(base_diffusion.alphas_cumprod):
-            if i in self.use_timesteps:
-                new_betas.append(1 - alpha_cumprod / last_alpha_cumprod)
-                last_alpha_cumprod = alpha_cumprod
-                self.timestep_map.append(i)
-        kwargs["betas"] = np.array(new_betas)
-        super().__init__(**kwargs)
-
-    def p_mean_variance(
-        self, model, *args, **kwargs
-    ):  # pylint: disable=signature-differs
-        return super().p_mean_variance(self._wrap_model(model), *args, **kwargs)
-
-    def training_losses(
-        self, model, *args, **kwargs
-    ):  # pylint: disable=signature-differs
-        return super().training_losses(self._wrap_model(model), *args, **kwargs)
-
-    def condition_mean(self, cond_fn, *args, **kwargs):
-        return super().condition_mean(self._wrap_model(cond_fn), *args, **kwargs)
-
-    def condition_score(self, cond_fn, *args, **kwargs):
-        return super().condition_score(self._wrap_model(cond_fn), *args, **kwargs)
-
-    def _wrap_model(self, model):
-        if isinstance(model, _WrappedModel):
-            return model
-        return _WrappedModel(
-            model, self.timestep_map, self.rescale_timesteps, self.original_num_steps
-        )
-   
-
-    def _scale_timesteps(self, t):
-        # Scaling is done by the wrapped model.
-        return t
-
-
-class _WrappedModel:
-    def __init__(self, model, timestep_map, rescale_timesteps, original_num_steps):
-        self.model = model
-        self.timestep_map = timestep_map
-        self.rescale_timesteps = rescale_timesteps
-        self.original_num_steps = original_num_steps
-
-
-    def __call__(self, x, ts, **kwargs):
-        map_tensor = th.tensor(self.timestep_map, device=ts.device, dtype=ts.dtype)
-        new_ts = map_tensor[ts]
-        if self.rescale_timesteps:
-            new_ts = new_ts.float() * (1000.0 / self.original_num_steps)
-        return self.model(x, new_ts, **kwargs)
-
-
-

wdm-3d-initial/guided_diffusion/script_util.py

@@ -1,574 +0,0 @@
-import argparse
-import inspect
-
-from . import gaussian_diffusion as gd
-from .respace import SpacedDiffusion, space_timesteps
-from .unet import SuperResModel, UNetModel, EncoderUNetModel
-from .wunet import WavUNetModel
-
-NUM_CLASSES = 2
-
-
-def diffusion_defaults():
-    """
-    Defaults for image and classifier training.
-    """
-    return dict(
-        learn_sigma=False,
-        diffusion_steps=1000,
-        noise_schedule="linear",
-        timestep_respacing="",
-        use_kl=False,
-        predict_xstart=False,
-        rescale_timesteps=False,
-        rescale_learned_sigmas=False,
-        dataset='brats',
-        dims=2,
-        num_groups=32,
-        in_channels=1,
-    )
-
-
-def classifier_defaults():
-    """
-    Defaults for classifier models.
-    """
-    return dict(
-        image_size=64,
-        classifier_use_fp16=False,
-        classifier_width=128,
-        classifier_depth=2,
-        classifier_attention_resolutions="32,16,8",  # 16
-        classifier_num_head_channels=64,
-        classifier_use_scale_shift_norm=True,  # False
-        classifier_resblock_updown=True,  # False
-        classifier_pool="spatial",
-        classifier_channel_mult="1,1,2,2,4,4",
-        dataset='brats'
-    )
-
-
-def model_and_diffusion_defaults():
-    """
-    Defaults for image training.
-    """
-    res = dict(
-        image_size=64,
-        num_channels=128,
-        num_res_blocks=2,
-        num_heads=4,
-        num_heads_upsample=-1,
-        num_head_channels=-1,
-        attention_resolutions="16,8",
-        channel_mult="",
-        dropout=0.0,
-        class_cond=False,
-        use_checkpoint=False,
-        use_scale_shift_norm=True,
-        resblock_updown=True,
-        use_fp16=False,
-        use_new_attention_order=False,
-        dims=2,
-        num_groups=32,
-        in_channels=1,
-        out_channels=0,  # automatically determine if 0
-        bottleneck_attention=True,
-        resample_2d=True,
-        additive_skips=False,
-        mode='default',
-        use_freq=False,
-        predict_xstart=False,
-    )
-    res.update(diffusion_defaults())
-    return res
-
-
-def classifier_and_diffusion_defaults():
-    res = classifier_defaults()
-    res.update(diffusion_defaults())
-    return res
-
-
-def create_model_and_diffusion(
-    image_size,
-    class_cond,
-    learn_sigma,
-    num_channels,
-    num_res_blocks,
-    channel_mult,
-    num_heads,
-    num_head_channels,
-    num_heads_upsample,
-    attention_resolutions,
-    dropout,
-    diffusion_steps,
-    noise_schedule,
-    timestep_respacing,
-    use_kl,
-    predict_xstart,
-    rescale_timesteps,
-    rescale_learned_sigmas,
-    use_checkpoint,
-    use_scale_shift_norm,
-    resblock_updown,
-    use_fp16,
-    use_new_attention_order,
-    dims,
-    num_groups,
-    in_channels,
-    out_channels,
-    bottleneck_attention,
-    resample_2d,
-    additive_skips,
-    mode,
-    use_freq,
-    dataset,
-):
-    model = create_model(
-        image_size,
-        num_channels,
-        num_res_blocks,
-        channel_mult=channel_mult,
-        learn_sigma=learn_sigma,
-        class_cond=class_cond,
-        use_checkpoint=use_checkpoint,
-        attention_resolutions=attention_resolutions,
-        num_heads=num_heads,
-        num_head_channels=num_head_channels,
-        num_heads_upsample=num_heads_upsample,
-        use_scale_shift_norm=use_scale_shift_norm,
-        dropout=dropout,
-        resblock_updown=resblock_updown,
-        use_fp16=use_fp16,
-        use_new_attention_order=use_new_attention_order,
-        dims=dims,
-        num_groups=num_groups,
-        in_channels=in_channels,
-        out_channels=out_channels,
-        bottleneck_attention=bottleneck_attention,
-        resample_2d=resample_2d,
-        additive_skips=additive_skips,
-        use_freq=use_freq,
-    )
-    diffusion = create_gaussian_diffusion(
-        steps=diffusion_steps,
-        learn_sigma=learn_sigma,
-        noise_schedule=noise_schedule,
-        use_kl=use_kl,
-        predict_xstart=predict_xstart,
-        rescale_timesteps=rescale_timesteps,
-        rescale_learned_sigmas=rescale_learned_sigmas,
-        timestep_respacing=timestep_respacing,
-        mode=mode,
-    )
-    return model, diffusion
-
-
-def create_model(
-    image_size,
-    num_channels,
-    num_res_blocks,
-    channel_mult="",
-    learn_sigma=False,
-    class_cond=False,
-    use_checkpoint=False,
-    attention_resolutions="16",
-    num_heads=1,
-    num_head_channels=-1,
-    num_heads_upsample=-1,
-    use_scale_shift_norm=False,
-    dropout=0,
-    resblock_updown=True,
-    use_fp16=False,
-    use_new_attention_order=False,
-    num_groups=32,
-    dims=2,
-    in_channels=1,
-    out_channels=0,  # automatically determine if 0
-    bottleneck_attention=True,
-    resample_2d=True,
-    additive_skips=False,
-    use_freq=False,
-):
-    if not channel_mult:
-        if image_size == 512:
-            channel_mult = (1, 1, 2, 2, 4, 4)
-        elif image_size == 256:
-            channel_mult = (1, 2, 2, 4, 4, 4)
-        elif image_size == 128:
-            channel_mult = (1, 2, 2, 4, 4)
-        elif image_size == 64:
-            channel_mult = (1, 2, 3, 4)
-        else:
-            raise ValueError(f"[MODEL] Unsupported image size: {image_size}")
-    else:
-        if isinstance(channel_mult, str):
-            from ast import literal_eval
-            channel_mult = literal_eval(channel_mult)
-        elif isinstance(channel_mult, tuple):  # do nothing
-            pass
-        else:
-            raise ValueError(f"[MODEL] Value for {channel_mult=} not supported")
-
-    attention_ds = []
-    if attention_resolutions:
-        for res in attention_resolutions.split(","):
-            attention_ds.append(image_size // int(res))
-    if out_channels == 0:
-        out_channels = (2*in_channels if learn_sigma else in_channels)
-
-    if not use_freq:
-        return UNetModel(
-            image_size=image_size,
-            in_channels=in_channels,
-            model_channels=num_channels,
-            out_channels=out_channels * (1 if not learn_sigma else 2),
-            num_res_blocks=num_res_blocks,
-            attention_resolutions=tuple(attention_ds),
-            dropout=dropout,
-            channel_mult=channel_mult,
-            num_classes=(NUM_CLASSES if class_cond else None),
-            use_checkpoint=use_checkpoint,
-            use_fp16=use_fp16,
-            num_heads=num_heads,
-            num_head_channels=num_head_channels,
-            num_heads_upsample=num_heads_upsample,
-            use_scale_shift_norm=use_scale_shift_norm,
-            resblock_updown=resblock_updown,
-            use_new_attention_order=use_new_attention_order,
-            dims=dims,
-            num_groups=num_groups,
-            bottleneck_attention=bottleneck_attention,
-            additive_skips=additive_skips,
-            resample_2d=resample_2d,
-        )
-    else:
-        return WavUNetModel(
-            image_size=image_size,
-            in_channels=in_channels,
-            model_channels=num_channels,
-            out_channels=out_channels * (1 if not learn_sigma else 2),
-            num_res_blocks=num_res_blocks,
-            attention_resolutions=tuple(attention_ds),
-            dropout=dropout,
-            channel_mult=channel_mult,
-            num_classes=(NUM_CLASSES if class_cond else None),
-            use_checkpoint=use_checkpoint,
-            use_fp16=use_fp16,
-            num_heads=num_heads,
-            num_head_channels=num_head_channels,
-            num_heads_upsample=num_heads_upsample,
-            use_scale_shift_norm=use_scale_shift_norm,
-            resblock_updown=resblock_updown,
-            use_new_attention_order=use_new_attention_order,
-            dims=dims,
-            num_groups=num_groups,
-            bottleneck_attention=bottleneck_attention,
-            additive_skips=additive_skips,
-            use_freq=use_freq,
-        )
-
-
-def create_classifier_and_diffusion(
-    image_size,
-    classifier_use_fp16,
-    classifier_width,
-    classifier_depth,
-    classifier_attention_resolutions,
-    classifier_num_head_channels,
-    classifier_use_scale_shift_norm,
-    classifier_resblock_updown,
-    classifier_pool,
-    classifier_channel_mult,
-    learn_sigma,
-    diffusion_steps,
-    noise_schedule,
-    timestep_respacing,
-    use_kl,
-    predict_xstart,
-    rescale_timesteps,
-    rescale_learned_sigmas,
-    dataset,
-    dims,
-    num_groups,
-    in_channels,
-):
-    print('timestepresp2', timestep_respacing)
-    classifier = create_classifier(
-        image_size,
-        classifier_use_fp16,
-        classifier_width,
-        classifier_depth,
-        classifier_attention_resolutions,
-        classifier_use_scale_shift_norm,
-        classifier_resblock_updown,
-        classifier_pool,
-        dataset,
-        dims=dims,
-        num_groups=num_groups,
-        in_channels=in_channels,
-        num_head_channels=classifier_num_head_channels,
-        classifier_channel_mult=classifier_channel_mult,
-    )
-    diffusion = create_gaussian_diffusion(
-        steps=diffusion_steps,
-        learn_sigma=learn_sigma,
-        noise_schedule=noise_schedule,
-        use_kl=use_kl,
-        predict_xstart=predict_xstart,
-        rescale_timesteps=rescale_timesteps,
-        rescale_learned_sigmas=rescale_learned_sigmas,
-        timestep_respacing=timestep_respacing,
-    )
-    return classifier, diffusion
-
-
-def create_classifier(
-    image_size,
-    classifier_use_fp16,
-    classifier_width,
-    classifier_depth,
-    classifier_attention_resolutions,
-    classifier_use_scale_shift_norm,
-    classifier_resblock_updown,
-    classifier_pool,
-    dataset,
-    num_groups=32,
-    dims=2,
-    in_channels=1,
-    num_head_channels=64,
-    classifier_channel_mult="",
-):
-    channel_mult = classifier_channel_mult
-    if not channel_mult:
-        if image_size == 256:
-            channel_mult = (1, 1, 2, 2, 4, 4)
-        elif image_size == 128:
-            channel_mult = (1, 1, 2, 3, 4)
-        elif image_size == 64:
-            channel_mult = (1, 2, 3, 4)
-        else:
-            raise ValueError(f"unsupported image size: {image_size}")
-    else:
-        if isinstance(channel_mult, str):
-            #channel_mult = tuple(int(ch_mult) for ch_mult in channel_mult.split(","))
-            from ast import literal_eval
-            channel_mult = literal_eval(channel_mult)
-        elif isinstance(channel_mult, tuple):  # do nothing
-            pass
-        else:
-            raise ValueError(f"value for {channel_mult=} not supported")
-
-    attention_ds = []
-    if classifier_attention_resolutions:
-        for res in classifier_attention_resolutions.split(","):
-            attention_ds.append(image_size // int(res))
-
-    print('number_in_channels classifier', in_channels)
-      
-
-    return EncoderUNetModel(
-        image_size=image_size,
-        in_channels=in_channels,
-        model_channels=classifier_width,
-        out_channels=2,
-        num_res_blocks=classifier_depth,
-        attention_resolutions=tuple(attention_ds),
-        channel_mult=channel_mult,
-        use_fp16=classifier_use_fp16,
-        num_head_channels=num_head_channels,
-        use_scale_shift_norm=classifier_use_scale_shift_norm,
-        resblock_updown=classifier_resblock_updown,
-        pool=classifier_pool,
-        num_groups=num_groups,
-        dims=dims,
-    )
-
-
-def sr_model_and_diffusion_defaults():
-    res = model_and_diffusion_defaults()
-    res["large_size"] = 256
-    res["small_size"] = 64
-    arg_names = inspect.getfullargspec(sr_create_model_and_diffusion)[0]
-    for k in res.copy().keys():
-        if k not in arg_names:
-            del res[k]
-    return res
-
-
-def sr_create_model_and_diffusion(
-    large_size,
-    small_size,
-    class_cond,
-    learn_sigma,
-    num_channels,
-    num_res_blocks,
-    num_heads,
-    num_head_channels,
-    num_heads_upsample,
-    attention_resolutions,
-    dropout,
-    diffusion_steps,
-    noise_schedule,
-    timestep_respacing,
-    use_kl,
-    predict_xstart,
-    rescale_timesteps,
-    rescale_learned_sigmas,
-    use_checkpoint,
-    use_scale_shift_norm,
-    resblock_updown,
-    use_fp16,
-):
-    print('timestepresp3', timestep_respacing)
-    model = sr_create_model(
-        large_size,
-        small_size,
-        num_channels,
-        num_res_blocks,
-        learn_sigma=learn_sigma,
-        class_cond=class_cond,
-        use_checkpoint=use_checkpoint,
-        attention_resolutions=attention_resolutions,
-        num_heads=num_heads,
-        num_head_channels=num_head_channels,
-        num_heads_upsample=num_heads_upsample,
-        use_scale_shift_norm=use_scale_shift_norm,
-        dropout=dropout,
-        resblock_updown=resblock_updown,
-        use_fp16=use_fp16,
-    )
-    diffusion = create_gaussian_diffusion(
-        steps=diffusion_steps,
-        learn_sigma=learn_sigma,
-        noise_schedule=noise_schedule,
-        use_kl=use_kl,
-        predict_xstart=predict_xstart,
-        rescale_timesteps=rescale_timesteps,
-        rescale_learned_sigmas=rescale_learned_sigmas,
-        timestep_respacing=timestep_respacing,
-    )
-    return model, diffusion
-
-
-def sr_create_model(
-    large_size,
-    small_size,
-    num_channels,
-    num_res_blocks,
-    learn_sigma,
-    class_cond,
-    use_checkpoint,
-    attention_resolutions,
-    num_heads,
-    num_head_channels,
-    num_heads_upsample,
-    use_scale_shift_norm,
-    dropout,
-    resblock_updown,
-    use_fp16,
-):
-    _ = small_size  # hack to prevent unused variable
-
-    if large_size == 512:
-        channel_mult = (1, 1, 2, 2, 4, 4)
-    elif large_size == 256:
-        channel_mult = (1, 1, 2, 2, 4, 4)
-    elif large_size == 64:
-        channel_mult = (1, 2, 3, 4)
-    else:
-        raise ValueError(f"unsupported large size: {large_size}")
-
-    attention_ds = []
-    for res in attention_resolutions.split(","):
-        attention_ds.append(large_size // int(res))
-
-    return SuperResModel(
-        image_size=large_size,
-        in_channels=3,
-        model_channels=num_channels,
-        out_channels=(3 if not learn_sigma else 6),
-        num_res_blocks=num_res_blocks,
-        attention_resolutions=tuple(attention_ds),
-        dropout=dropout,
-        channel_mult=channel_mult,
-        num_classes=(NUM_CLASSES if class_cond else None),
-        use_checkpoint=use_checkpoint,
-        num_heads=num_heads,
-        num_head_channels=num_head_channels,
-        num_heads_upsample=num_heads_upsample,
-        use_scale_shift_norm=use_scale_shift_norm,
-        resblock_updown=resblock_updown,
-        use_fp16=use_fp16,
-    )
-
-
-def create_gaussian_diffusion(
-    *,
-    steps=1000,
-    learn_sigma=False,
-    sigma_small=False,
-    noise_schedule="linear",
-    use_kl=False,
-    predict_xstart=False,
-    rescale_timesteps=False,
-    rescale_learned_sigmas=False,
-    timestep_respacing="",
-    mode='default',
-):
-    betas = gd.get_named_beta_schedule(noise_schedule, steps)
-    if use_kl:
-        loss_type = gd.LossType.RESCALED_KL
-    elif rescale_learned_sigmas:
-        loss_type = gd.LossType.RESCALED_MSE
-    else:
-        loss_type = gd.LossType.MSE
-
-    if not timestep_respacing:
-        timestep_respacing = [steps]
-
-    return SpacedDiffusion(
-        use_timesteps=space_timesteps(steps, timestep_respacing),
-        betas=betas,
-        model_mean_type=(gd.ModelMeanType.EPSILON if not predict_xstart else gd.ModelMeanType.START_X),
-        model_var_type=(
-            (
-                gd.ModelVarType.FIXED_LARGE
-                if not sigma_small
-                else gd.ModelVarType.FIXED_SMALL
-            )
-            if not learn_sigma
-            else gd.ModelVarType.LEARNED_RANGE
-        ),
-        loss_type=loss_type,
-        rescale_timesteps=rescale_timesteps,
-        mode=mode,
-    )
-
-
-def add_dict_to_argparser(parser, default_dict):
-    for k, v in default_dict.items():
-        v_type = type(v)
-        if v is None:
-            v_type = str
-        elif isinstance(v, bool):
-            v_type = str2bool
-        parser.add_argument(f"--{k}", default=v, type=v_type)
-
-
-def args_to_dict(args, keys):
-    return {k: getattr(args, k) for k in keys}
-
-
-def str2bool(v):
-    """
-    https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse
-    """
-    if isinstance(v, bool):
-        return v
-    if v.lower() in ("yes", "true", "t", "y", "1"):
-        return True
-    elif v.lower() in ("no", "false", "f", "n", "0"):
-        return False
-    else:
-        raise argparse.ArgumentTypeError("boolean value expected")

wdm-3d-initial/guided_diffusion/train_util.py

@@ -1,376 +0,0 @@
-import copy
-import functools
-import os
-
-import blobfile as bf
-import torch as th
-import torch.distributed as dist
-import torch.utils.tensorboard
-from torch.optim import AdamW
-import torch.cuda.amp as amp
-
-import itertools
-
-from . import dist_util, logger
-from .resample import LossAwareSampler, UniformSampler
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-INITIAL_LOG_LOSS_SCALE = 20.0
-
-def visualize(img):
-    _min = img.min()
-    _max = img.max()
-    normalized_img = (img - _min)/ (_max - _min)
-    return normalized_img
-
-class TrainLoop:
-    def __init__(
-        self,
-        *,
-        model,
-        diffusion,
-        data,
-        batch_size,
-        in_channels,
-        image_size,
-        microbatch,
-        lr,
-        ema_rate,
-        log_interval,
-        save_interval,
-        resume_checkpoint,
-        resume_step,
-        use_fp16=False,
-        fp16_scale_growth=1e-3,
-        schedule_sampler=None,
-        weight_decay=0.0,
-        lr_anneal_steps=0,
-        dataset='brats',
-        summary_writer=None,
-        mode='default',
-        loss_level='image',
-    ):
-        self.summary_writer = summary_writer
-        self.mode = mode
-        self.model = model
-        self.diffusion = diffusion
-        self.datal = data
-        self.dataset = dataset
-        self.iterdatal = iter(data)
-        self.batch_size = batch_size
-        self.in_channels = in_channels
-        self.image_size = image_size
-        self.microbatch = microbatch if microbatch > 0 else batch_size
-        self.lr = lr
-        self.ema_rate = (
-            [ema_rate]
-            if isinstance(ema_rate, float)
-            else [float(x) for x in ema_rate.split(",")]
-        )
-        self.log_interval = log_interval
-        self.save_interval = save_interval
-        self.resume_checkpoint = resume_checkpoint
-        self.use_fp16 = use_fp16
-        if self.use_fp16:
-            self.grad_scaler = amp.GradScaler()
-        else:
-            self.grad_scaler = amp.GradScaler(enabled=False)
-
-        self.schedule_sampler = schedule_sampler or UniformSampler(diffusion)
-        self.weight_decay = weight_decay
-        self.lr_anneal_steps = lr_anneal_steps
-
-        self.dwt = DWT_3D('haar')
-        self.idwt = IDWT_3D('haar')
-
-        self.loss_level = loss_level
-
-        self.step = 1
-        self.resume_step = resume_step
-        self.global_batch = self.batch_size * dist.get_world_size()
-
-        self.sync_cuda = th.cuda.is_available()
-
-        self._load_and_sync_parameters()
-
-        self.opt = AdamW(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
-        if self.resume_step:
-            print("Resume Step: " + str(self.resume_step))
-            self._load_optimizer_state()
-
-        if not th.cuda.is_available():
-            logger.warn(
-                "Training requires CUDA. "
-            )
-
-    def _load_and_sync_parameters(self):
-        resume_checkpoint = find_resume_checkpoint() or self.resume_checkpoint
-
-        if resume_checkpoint:
-            print('resume model ...')
-            self.resume_step = parse_resume_step_from_filename(resume_checkpoint)
-            if dist.get_rank() == 0:
-                logger.log(f"loading model from checkpoint: {resume_checkpoint}...")
-                self.model.load_state_dict(
-                    dist_util.load_state_dict(
-                        resume_checkpoint, map_location=dist_util.dev()
-                    )
-                )
-
-        dist_util.sync_params(self.model.parameters())
-
-
-    def _load_optimizer_state(self):
-        main_checkpoint = find_resume_checkpoint() or self.resume_checkpoint
-        opt_checkpoint = bf.join(
-            bf.dirname(main_checkpoint), f"opt{self.resume_step:06}.pt"
-        )
-        if bf.exists(opt_checkpoint):
-            logger.log(f"loading optimizer state from checkpoint: {opt_checkpoint}")
-            state_dict = dist_util.load_state_dict(
-                opt_checkpoint, map_location=dist_util.dev()
-            )
-            self.opt.load_state_dict(state_dict)
-        else:
-            print('no optimizer checkpoint exists')
-
-    def run_loop(self):
-        import time
-        t = time.time()
-        while not self.lr_anneal_steps or self.step + self.resume_step < self.lr_anneal_steps:
-            t_total = time.time() - t
-            t = time.time()
-            if self.dataset in ['brats', 'lidc-idri']:
-                try:
-                    batch = next(self.iterdatal)
-                    cond = {}
-                except StopIteration:
-                    self.iterdatal = iter(self.datal)
-                    batch = next(self.iterdatal)
-                    cond = {}
-
-            batch = batch.to(dist_util.dev())
-
-            t_fwd = time.time()
-            t_load = t_fwd-t
-
-            lossmse, sample, sample_idwt = self.run_step(batch, cond)
-
-            t_fwd = time.time()-t_fwd
-
-            names = ["LLL", "LLH", "LHL", "LHH", "HLL", "HLH", "HHL", "HHH"]
-
-            if self.summary_writer is not None:
-                self.summary_writer.add_scalar('time/load', t_load, global_step=self.step + self.resume_step)
-                self.summary_writer.add_scalar('time/forward', t_fwd, global_step=self.step + self.resume_step)
-                self.summary_writer.add_scalar('time/total', t_total, global_step=self.step + self.resume_step)
-                self.summary_writer.add_scalar('loss/MSE', lossmse.item(), global_step=self.step + self.resume_step)
-
-            if self.step % 200 == 0:
-                image_size = sample_idwt.size()[2]
-                midplane = sample_idwt[0, 0, :, :, image_size // 2]
-                self.summary_writer.add_image('sample/x_0', midplane.unsqueeze(0),
-                                              global_step=self.step + self.resume_step)
-
-                image_size = sample.size()[2]
-                for ch in range(8):
-                    midplane = sample[0, ch, :, :, image_size // 2]
-                    self.summary_writer.add_image('sample/{}'.format(names[ch]), midplane.unsqueeze(0),
-                                                  global_step=self.step + self.resume_step)
-
-            if self.step % self.log_interval == 0:
-                logger.dumpkvs()
-
-            if self.step % self.save_interval == 0:
-                self.save()
-                # Run for a finite amount of time in integration tests.
-                if os.environ.get("DIFFUSION_TRAINING_TEST", "") and self.step > 0:
-                    return
-            self.step += 1
-
-        # Save the last checkpoint if it wasn't already saved.
-        if (self.step - 1) % self.save_interval != 0:
-            self.save()
-
-    def run_step(self, batch, cond, label=None, info=dict()):
-        lossmse, sample, sample_idwt = self.forward_backward(batch, cond, label)
-
-        if self.use_fp16:
-            self.grad_scaler.unscale_(self.opt)  # check self.grad_scaler._per_optimizer_states
-
-        # compute norms
-        with torch.no_grad():
-            param_max_norm = max([p.abs().max().item() for p in self.model.parameters()])
-            grad_max_norm = max([p.grad.abs().max().item() for p in self.model.parameters()])
-            info['norm/param_max'] = param_max_norm
-            info['norm/grad_max'] = grad_max_norm
-
-        if not torch.isfinite(lossmse): #infinite
-            if not torch.isfinite(torch.tensor(param_max_norm)):
-                logger.log(f"Model parameters contain non-finite value {param_max_norm}, entering breakpoint", level=logger.ERROR)
-                breakpoint()
-            else:
-                logger.log(f"Model parameters are finite, but loss is not: {lossmse}"
-                           "\n -> update will be skipped in grad_scaler.step()", level=logger.WARN)
-
-        if self.use_fp16:
-            print("Use fp16 ...")
-            self.grad_scaler.step(self.opt)
-            self.grad_scaler.update()
-            info['scale'] = self.grad_scaler.get_scale()
-        else:
-            self.opt.step()
-        self._anneal_lr()
-        self.log_step()
-        return lossmse, sample, sample_idwt
-
-    def forward_backward(self, batch, cond, label=None):
-        for p in self.model.parameters():  # Zero out gradient
-            p.grad = None
-
-        for i in range(0, batch.shape[0], self.microbatch):
-            micro = batch[i: i + self.microbatch].to(dist_util.dev())
-
-            if label is not None:
-                micro_label = label[i: i + self.microbatch].to(dist_util.dev())
-            else:
-                micro_label = None
-
-            micro_cond = None
-
-            last_batch = (i + self.microbatch) >= batch.shape[0]
-            t, weights = self.schedule_sampler.sample(micro.shape[0], dist_util.dev())
-
-            compute_losses = functools.partial(self.diffusion.training_losses,
-                                               self.model,
-                                               x_start=micro,
-                                               t=t,
-                                               model_kwargs=micro_cond,
-                                               labels=micro_label,
-                                               mode=self.mode,
-                                               )
-            losses1 = compute_losses()
-
-            if isinstance(self.schedule_sampler, LossAwareSampler):
-                self.schedule_sampler.update_with_local_losses(
-                    t, losses1["loss"].detach()
-                )
-
-            losses = losses1[0]         # Loss value
-            sample = losses1[1]         # Denoised subbands at t=0
-            sample_idwt = losses1[2]    # Inverse wavelet transformed denoised subbands at t=0
-
-            # Log wavelet level loss
-            self.summary_writer.add_scalar('loss/mse_wav_lll', losses["mse_wav"][0].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_llh', losses["mse_wav"][1].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_lhl', losses["mse_wav"][2].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_lhh', losses["mse_wav"][3].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hll', losses["mse_wav"][4].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hlh', losses["mse_wav"][5].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hhl', losses["mse_wav"][6].item(),
-                                           global_step=self.step + self.resume_step)
-            self.summary_writer.add_scalar('loss/mse_wav_hhh', losses["mse_wav"][7].item(),
-                                           global_step=self.step + self.resume_step)
-
-            weights = th.ones(len(losses["mse_wav"])).cuda()  # Equally weight all wavelet channel losses
-
-            loss = (losses["mse_wav"] * weights).mean()
-            lossmse = loss.detach()
-
-            log_loss_dict(self.diffusion, t, {k: v * weights for k, v in losses.items()})
-
-            # perform some finiteness checks
-            if not torch.isfinite(loss):
-                logger.log(f"Encountered non-finite loss {loss}")
-            if self.use_fp16:
-                self.grad_scaler.scale(loss).backward()
-            else:
-                loss.backward()
-
-            return lossmse.detach(), sample, sample_idwt
-
-    def _anneal_lr(self):
-        if not self.lr_anneal_steps:
-            return
-        frac_done = (self.step + self.resume_step) / self.lr_anneal_steps
-        lr = self.lr * (1 - frac_done)
-        for param_group in self.opt.param_groups:
-            param_group["lr"] = lr
-
-    def log_step(self):
-        logger.logkv("step", self.step + self.resume_step)
-        logger.logkv("samples", (self.step + self.resume_step + 1) * self.global_batch)
-
-    def save(self):
-        def save_checkpoint(rate, state_dict):
-            if dist.get_rank() == 0:
-                logger.log("Saving model...")
-                if self.dataset == 'brats':
-                    filename = f"brats_{(self.step+self.resume_step):06d}.pt"
-                elif self.dataset == 'lidc-idri':
-                    filename = f"lidc-idri_{(self.step+self.resume_step):06d}.pt"
-                else:
-                    raise ValueError(f'dataset {self.dataset} not implemented')
-
-                with bf.BlobFile(bf.join(get_blob_logdir(), 'checkpoints', filename), "wb") as f:
-                    th.save(state_dict, f)
-
-        save_checkpoint(0, self.model.state_dict())
-
-        if dist.get_rank() == 0:
-            checkpoint_dir = os.path.join(logger.get_dir(), 'checkpoints')
-            with bf.BlobFile(
-                bf.join(checkpoint_dir, f"opt{(self.step+self.resume_step):06d}.pt"),
-                "wb",
-            ) as f:
-                th.save(self.opt.state_dict(), f)
-
-
-def parse_resume_step_from_filename(filename):
-    """
-    Parse filenames of the form path/to/modelNNNNNN.pt, where NNNNNN is the
-    checkpoint's number of steps.
-    """
-
-    split = os.path.basename(filename)
-    split = split.split(".")[-2]  # remove extension
-    split = split.split("_")[-1]  # remove possible underscores, keep only last word
-    # extract trailing number
-    reversed_split = []
-    for c in reversed(split):
-        if not c.isdigit():
-            break
-        reversed_split.append(c)
-    split = ''.join(reversed(reversed_split))
-    split = ''.join(c for c in split if c.isdigit())  # remove non-digits
-    try:
-        return int(split)
-    except ValueError:
-        return 0
-
-
-def get_blob_logdir():
-    # You can change this to be a separate path to save checkpoints to
-    # a blobstore or some external drive.
-    return logger.get_dir()
-
-
-def find_resume_checkpoint():
-    # On your infrastructure, you may want to override this to automatically
-    # discover the latest checkpoint on your blob storage, etc.
-    return None
-
-
-def log_loss_dict(diffusion, ts, losses):
-    for key, values in losses.items():
-        logger.logkv_mean(key, values.mean().item())
-        # Log the quantiles (four quartiles, in particular).
-        for sub_t, sub_loss in zip(ts.cpu().numpy(), values.detach().cpu().numpy()):
-            quartile = int(4 * sub_t / diffusion.num_timesteps)
-            logger.logkv_mean(f"{key}_q{quartile}", sub_loss)

wdm-3d-initial/guided_diffusion/unet.py

@@ -1,1044 +0,0 @@
-from abc import abstractmethod
-
-import math
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .nn import checkpoint, conv_nd, linear, avg_pool_nd, zero_module, normalization, timestep_embedding
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, resample_2d=True):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        self.resample_2d = resample_2d
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=1)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3 and self.resample_2d:
-            x = F.interpolate(
-                x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-            )
-        else:
-            x = F.interpolate(x, scale_factor=2, mode="nearest")
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, resample_2d=True):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = (1, 2, 2) if dims == 3 and resample_2d else 2
-        if use_conv:
-            self.op = conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=1
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-
-
-class WaveletGatingDownsample(nn.Module):
-    """
-    A wavelet gated downsampling operation.
-
-    This layer takes some input features and a timestep embedding vector as input and
-    outputs the sum over gated wavelet coefficients, thus performing a downsampling.
-
-    :param channels: channels in the inputs and outputs.
-    :param temb_dim: timestep embedding dimension.
-    """
-
-    def __init__(self, channels, temb_dim):
-        super().__init__()
-        # Define wavelet transform
-        self.dwt = DWT_3D('haar')
-
-        # Define gating network
-        self.pooling = nn.AdaptiveAvgPool3d(1)
-        self.fnn = nn.Sequential(
-            nn.Linear(channels + temb_dim, 128),
-            nn.SiLU(),
-            nn.Linear(128, 8),
-        )
-        self.act = nn.Sigmoid()
-
-    def forward(self, x, temb):
-        # Get gating values
-        p = self.pooling(x).squeeze(-1).squeeze(-1).squeeze(-1)  # Average pool over feature dimension
-        c = th.cat((p, temb), dim=1)                             # Combine pooled input features and temb
-        gating_values = self.act(self.fnn(c))                    # Obtain gating values
-
-        wavelet_subbands = self.dwt(x)
-        scaled_wavelet_subbands = [band * gating.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
-                                   for band, gating in zip(wavelet_subbands, th.split(gating_values, 1, dim=1))]
-        return sum(scaled_wavelet_subbands)
-
-
-class WaveletGatingUpsample(nn.Module):
-    """
-    A wavelet gated upsampling operation.
-
-    This layer takes some input features and a timestep embedding vector as input and
-    outputs gated inverse wavelet transformed bands, thus performing upsampling.
-
-    :param channels: channels in the inputs and outputs.
-    :param temb_dim: timestep embedding dimension.
-    """
-
-    def __init__(self, channels, temb_dim):
-        super().__init__()
-        # Define inverse wavelet transform
-        self.idwt = IDWT_3D('haar')
-
-        # Define gating network
-        self.pooling = nn.AdaptiveAvgPool3d(1)
-        self.fnn = nn.Sequential(
-            nn.Linear(channels + temb_dim, 128),
-            nn.SiLU(),
-            nn.Linear(128, 8),
-        )
-        self.act = nn.Sigmoid()
-
-        # Define conv for channel expansion
-        self.conv_exp = nn.Conv3d(channels, channels * 8, kernel_size=1)
-
-    def forward(self, x, temb):
-        # Get gating values
-        p = self.pooling(x).squeeze(-1).squeeze(-1).squeeze(-1)  # Average pool over feature dimension
-        c = th.cat((p, temb), dim=1)                             # Combine pooled input features and temb
-        gating_values = self.act(self.fnn(c))                    # Obtain gating values
-
-        # Perform a channel expansion and chunk into 8 wavelet subbands
-        wavelet_subbands = self.conv_exp(x)
-        wavelet_subbands = wavelet_subbands.chunk(8, dim=1)
-
-        scaled_wavelet_subbands = [band * gating.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
-                                   for band, gating in zip(wavelet_subbands, th.split(gating_values, 1, dim=1))]
-
-        return self.idwt(*scaled_wavelet_subbands[:8])
-
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    :param use_wgupdown: if True, use wavelet gated up- and downsampling.
-    """
-
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_conv=False,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        up=False,
-        down=False,
-        num_groups=32,
-        resample_2d=True,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-        self.num_groups = num_groups
-
-        self.in_layers = nn.Sequential(
-            normalization(channels, self.num_groups),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        self.updown = up or down
-
-        if up:
-            # when using "standard" upsampling
-            self.h_upd = Upsample(channels, False, dims, resample_2d=resample_2d)
-            self.x_upd = Upsample(channels, False, dims, resample_2d=resample_2d)
-
-        elif down:
-            # when using "standard" downsampling
-            self.h_upd = Downsample(channels, False, dims, resample_2d=resample_2d)
-            self.x_upd = Downsample(channels, False, dims, resample_2d=resample_2d)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels, self.num_groups),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(
-                conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
-            ),
-        )
-
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = conv_nd(
-                dims, channels, self.out_channels, 3, padding=1
-            )
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-    def forward(self, x, emb):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        return checkpoint(
-            self._forward, (x, emb), self.parameters(), self.use_checkpoint
-        )
-
-    def _forward(self, x, emb):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-
-        emb_out = self.emb_layers(emb).type(h.dtype)
-
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-
-        if self.use_scale_shift_norm:
-            print("You use scale-shift norm")
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-
-        return self.skip_connection(x) + h
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-        self,
-        channels,
-        num_heads=1,
-        num_head_channels=-1,
-        use_checkpoint=False,
-        use_new_attention_order=False,
-        num_groups=32,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels, num_groups)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        num_classes=None,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        num_groups=32,
-        bottleneck_attention=True,
-        resample_2d=True,
-        additive_skips=False,
-        decoder_device_thresh=0,
-    ):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        self.num_groups = num_groups
-        self.bottleneck_attention = bottleneck_attention
-        self.devices = None
-        self.decoder_device_thresh = decoder_device_thresh
-        self.additive_skips = additive_skips
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        if self.num_classes is not None:
-            self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-
-        ###############################################################
-        # INPUT block
-        ###############################################################
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        channels=ch,
-                        emb_channels=time_embed_dim,
-                        dropout=dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                            num_groups=self.num_groups,
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, 
-                            conv_resample, 
-                            dims=dims, 
-                            out_channels=out_ch, 
-                            resample_2d=resample_2d,
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        self.input_block_chans_bk = input_block_chans[:]
-        ################################################################
-        # Middle block
-        ################################################################
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-            ),
-            *([AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-                num_groups=self.num_groups,
-            )] if self.bottleneck_attention else [])
-            ,
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-            ),
-        )
-        self._feature_size += ch
-
-        ####################################################################
-        # OUTPUT BLOCKS
-        ####################################################################
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks + 1):
-                ich = input_block_chans.pop()
-                mid_ch = model_channels * mult if not self.additive_skips else (
-                        input_block_chans[-1] if input_block_chans else model_channels
-                        )
-                layers = [
-                    ResBlock(
-                        ch + ich if not self.additive_skips else ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mid_ch,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                    )
-                ]
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            mid_ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads_upsample,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                            num_groups=self.num_groups,
-                        )
-                    )
-                ch = mid_ch
-                if level and i == num_res_blocks:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            mid_ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                        )
-                        if resblock_updown
-                        else Upsample(
-                            mid_ch, 
-                            conv_resample, 
-                            dims=dims, 
-                            out_channels=out_ch, 
-                            resample_2d=resample_2d
-                            )
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                mid_ch = ch
-
-        self.out = nn.Sequential(
-            normalization(ch, self.num_groups),
-            nn.SiLU(),
-            zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
-        )
-
-    def to(self, *args, **kwargs):
-        """
-        we overwrite the to() method for the case where we
-        distribute parts of our model to different devices
-        """
-        if isinstance(args[0], (list, tuple)) and len(args[0]) > 1:
-            assert not kwargs and len(args) == 1
-            # distribute to multiple devices
-            self.devices = args[0]
-            # move first half to first device, second half to second device
-            self.input_blocks.to(self.devices[0])
-            self.time_embed.to(self.devices[0])
-            self.middle_block.to(self.devices[0])  # maybe devices 0
-            for k, b in enumerate(self.output_blocks):
-                if k < self.decoder_device_thresh:
-                    b.to(self.devices[0])
-                else:  # after threshold
-                    b.to(self.devices[1])
-            self.out.to(self.devices[0])
-            print(f"distributed UNet components to devices {self.devices}")
-
-        else:  # default behaviour
-            super().to(*args, **kwargs)
-            if self.devices is None:  # if self.devices has not been set yet, read it from params
-                p = next(self.parameters())
-                self.devices = [p.device, p.device]
-
-    def forward(self, x, timesteps, y=None):
-        """
-        Apply the model to an input batch.
-
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :param y: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        assert (y is not None) == (
-            self.num_classes is not None
-        ), "must specify y if and only if the model is class-conditional"
-        assert x.device == self.devices[0], f"{x.device=} does not match {self.devices[0]=}"
-        assert timesteps.device == self.devices[0], f"{timesteps.device=} does not match {self.devices[0]=}"
-
-        hs = []
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-
-        if self.num_classes is not None:
-            assert y.shape == (x.shape[0],)
-            emb = emb + self.label_emb(y)
-
-        h = x
-        self.hs_shapes = []
-        for module in self.input_blocks:
-            h = module(h, emb)
-            hs.append(h)
-            self.hs_shapes.append(h.shape)
-
-        h = self.middle_block(h, emb)
-
-        for k, module in enumerate(self.output_blocks):
-            new_hs = hs.pop()
-            if k == self.decoder_device_thresh:
-                h = h.to(self.devices[1])
-                emb = emb.to(self.devices[1])
-            if k >= self.decoder_device_thresh:
-                new_hs = new_hs.to(self.devices[1])
-
-            if self.additive_skips:
-                h = (h + new_hs) / 2
-            else:
-                h = th.cat([h, new_hs], dim=1)
-
-            h = module(h, emb)
-        h = h.to(self.devices[0])
-        return self.out(h)
-
-
-class SuperResModel(UNetModel):
-    """
-    A UNetModel that performs super-resolution.
-
-    Expects an extra kwarg `low_res` to condition on a low-resolution image.
-    """
-
-    def __init__(self, image_size, in_channels, *args, **kwargs):
-        super().__init__(image_size, in_channels * 2, *args, **kwargs)
-
-    def forward(self, x, timesteps, low_res=None, **kwargs):
-        _, _, new_height, new_width = x.shape
-        upsampled = F.interpolate(low_res, (new_height, new_width), mode="bilinear")
-        x = th.cat([x, upsampled], dim=1)
-        return super().forward(x, timesteps, **kwargs)
-
-
-class EncoderUNetModel(nn.Module):
-    """
-    The half UNet model with attention and timestep embedding.
-
-    For usage, see UNet.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        pool="adaptive",
-        num_groups=32,
-        resample_2d=True,
-    ):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        self.num_groups = num_groups
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                            num_groups=self.num_groups,
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch,
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-                num_groups=self.num_groups,
-            ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-            ),
-        )
-        self._feature_size += ch
-        self.pool = pool
-        # global average pooling
-        spatial_dims = (2, 3, 4, 5)[:dims]
-        self.gap = lambda x: x.mean(dim=spatial_dims)
-        self.cam_feature_maps = None
-        print('pool', pool)
-        if pool == "adaptive":
-            self.out = nn.Sequential(
-                normalization(ch, self.num_groups),
-                nn.SiLU(),
-                nn.AdaptiveAvgPool2d((1, 1)),
-                zero_module(conv_nd(dims, ch, out_channels, 1)),
-                nn.Flatten(),
-            )
-        elif pool == "attention":
-            assert num_head_channels != -1
-            self.out = nn.Sequential(
-                normalization(ch, self.num_groups),
-                nn.SiLU(),
-                AttentionPool2d(
-                    (image_size // ds), ch, num_head_channels, out_channels
-                ),
-            )
-        elif pool == "spatial":
-            print('spatial')
-            self.out = nn.Linear(256, self.out_channels)
-        elif pool == "spatial_v2":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                normalization(2048, self.num_groups),
-                nn.SiLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        else:
-            raise NotImplementedError(f"Unexpected {pool} pooling")
-
-
-
-    def forward(self, x, timesteps):
-        """
-        Apply the model to an input batch.
-
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :return: an [N x K] Tensor of outputs.
-        """
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-
-        results = []
-        h = x.type(self.dtype)
-        for module in self.input_blocks:
-            h = module(h, emb)
-            if self.pool.startswith("spatial"):
-                results.append(h.type(x.dtype).mean(dim=(2, 3)))
-        h = self.middle_block(h, emb)
-
-
-        if self.pool.startswith("spatial"):
-            self.cam_feature_maps = h
-            h = self.gap(h)
-            N = h.shape[0]
-            h = h.reshape(N, -1)
-            print('h1', h.shape)
-            return self.out(h)
-        else:
-            h = h.type(x.dtype)
-            self.cam_feature_maps = h
-            return self.out(h)

wdm-3d-initial/guided_diffusion/wunet.py

@@ -1,795 +0,0 @@
-from abc import abstractmethod
-
-import math
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .nn import checkpoint, conv_nd, linear, avg_pool_nd, zero_module, normalization, timestep_embedding
-from DWT_IDWT.DWT_IDWT_layer import DWT_3D, IDWT_3D
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    A wavelet upsampling layer with an optional convolution on the skip connections used to perform upsampling.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, resample_2d=True, use_freq=True):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        self.resample_2d = resample_2d
-
-        self.use_freq = use_freq
-        self.idwt = IDWT_3D("haar")
-
-        # Grouped convolution on 7 high frequency subbands (skip connections)
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels * 7, self.out_channels * 7, 3, padding=1, groups=7)
-
-    def forward(self, x):
-        if isinstance(x, tuple):
-            skip = x[1]
-            x = x[0]
-        assert x.shape[1] == self.channels
-
-        if self.use_conv:
-            skip = self.conv(th.cat(skip, dim=1) / 3.) * 3.
-            skip = tuple(th.chunk(skip, 7, dim=1))
-
-        if self.use_freq:
-            x = self.idwt(3. * x, skip[0], skip[1], skip[2], skip[3], skip[4], skip[5], skip[6])
-        else:
-            if self.dims == 3 and self.resample_2d:
-                x = F.interpolate(
-                    x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-                )
-            else:
-                x = F.interpolate(x, scale_factor=2, mode="nearest")
-
-        return x, None
-
-
-class Downsample(nn.Module):
-    """
-    A wavelet downsampling layer with an optional convolution.
-
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, resample_2d=True, use_freq=True):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-
-        self.use_freq = use_freq
-        self.dwt = DWT_3D("haar")
-
-        stride = (1, 2, 2) if dims == 3 and resample_2d else 2
-
-        if use_conv:
-            self.op = conv_nd(dims, self.channels, self.out_channels, 3, stride=stride, padding=1)
-        elif self.use_freq:
-            self.op = self.dwt
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        if self.use_freq:
-            LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = self.op(x)
-            x = (LLL / 3., (LLH, LHL, LHH, HLL, HLH, HHL, HHH))
-        else:
-            x = self.op(x)
-        return x
-
-
-class WaveletDownsample(nn.Module):
-    """
-    Implements the wavelet downsampling blocks used to generate the input residuals.
-
-    :param in_ch: number of input channels.
-    :param out_ch: number of output channels (should match the feature size of the corresponding U-Net level)
-    """
-    def __init__(self, in_ch=None, out_ch=None):
-        super().__init__()
-        out_ch = out_ch if out_ch else in_ch
-        self.in_ch = in_ch
-        self.out_ch = out_ch
-        self.conv = conv_nd(3, self.in_ch * 8, self.out_ch, 3, stride=1, padding=1)
-        self.dwt = DWT_3D('haar')
-
-    def forward(self, x):
-        LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH = self.dwt(x)
-        x = th.cat((LLL, LLH, LHL, LHH, HLL, HLH, HHL, HHH), dim=1) / 3.
-        return self.conv(x)
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels via up- or downsampling.
-
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels, otherwise out_channels = channels.
-    :param use_conv: if True and out_channels is specified, use a spatial convolution instead of a smaller 1x1
-                     convolution to change the channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    :param num_groups: if specified, the number of groups in the (adaptive) group normalization layers.
-    :param use_freq: specifies if frequency aware up- or downsampling should be used.
-    :param z_emb_dim: the dimension of the z-embedding.
-
-    """
-
-    def __init__(self, channels, emb_channels, dropout, out_channels=None, use_conv=True, use_scale_shift_norm=False,
-                 dims=2, use_checkpoint=False, up=False, down=False, num_groups=32, resample_2d=True, use_freq=False):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_scale_shift_norm = use_scale_shift_norm
-        self.use_checkpoint = use_checkpoint
-        self.up = up
-        self.down = down
-        self.num_groups = num_groups
-        self.use_freq = use_freq
-
-
-        # Define (adaptive) group normalization layers
-        self.in_layers = nn.Sequential(
-            normalization(channels, self.num_groups),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        # Check if up- or downsampling should be performed by this ResBlock
-        self.updown = up or down
-        if up:
-            self.h_upd = Upsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-            self.x_upd = Upsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-            self.x_upd = Downsample(channels, False, dims, resample_2d=resample_2d, use_freq=self.use_freq)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        # Define the timestep embedding layers
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(emb_channels, 2 * self.out_channels if use_scale_shift_norm else self.out_channels),
-        )
-
-        # Define output layers including (adaptive) group normalization
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels, self.num_groups),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)),
-        )
-
-        # Define skip branch
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-
-    def forward(self, x, temb):
-        # Make sure to pipe skip connections
-        if isinstance(x, tuple):
-            hSkip = x[1]
-        else:
-            hSkip = None
-
-        # Forward pass for ResBlock with up- or downsampling
-        if self.updown:
-            if self.up:
-                x = x[0]
-            h = self.in_layers(x)
-
-            if self.up:
-                h = (h, hSkip)
-                x = (x, hSkip)
-
-            h, hSkip = self.h_upd(h)   # Updown in main branch (ResBlock)
-            x, xSkip = self.x_upd(x)   # Updown in skip-connection (ResBlock)
-
-        # Forward pass for standard ResBlock
-        else:
-            if isinstance(x, tuple):  # Check for skip connection tuple
-                x = x[0]
-            h = self.in_layers(x)
-
-        # Common layers for both standard and updown ResBlocks
-        emb_out = self.emb_layers(temb)
-
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-
-        else:
-            h = h + emb_out  # Add timestep embedding
-            h = self.out_layers(h)  # Forward pass out layers
-
-        # Add skip connections
-        out = self.skip_connection(x) + h
-        out = out, hSkip
-
-        return out
-
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-            self,
-            channels,
-            num_heads=1,
-            num_head_channels=-1,
-            use_checkpoint=False,
-            use_new_attention_order=False,
-            num_groups=32,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                    channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels, num_groups)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class WavUNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which attention will take place. May be a set,
-                                  list, or tuple. For example, if this contains 4, then at 4x downsampling, attention
-                                  will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially increased efficiency.
-    """
-
-    def __init__(self, image_size, in_channels, model_channels, out_channels, num_res_blocks, attention_resolutions,
-                 dropout=0, channel_mult=(1, 2, 4, 8), conv_resample=True, dims=2, num_classes=None,
-                 use_checkpoint=False, use_fp16=False, num_heads=1, num_head_channels=-1, num_heads_upsample=-1,
-                 use_scale_shift_norm=False, resblock_updown=False, use_new_attention_order=False, num_groups=32,
-                 bottleneck_attention=True, resample_2d=True, additive_skips=False, decoder_device_thresh=0,
-                 use_freq=False, progressive_input='residual'):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        # self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        # self.num_heads = num_heads
-        # self.num_head_channels = num_head_channels
-        # self.num_heads_upsample = num_heads_upsample
-        self.num_groups = num_groups
-        self.bottleneck_attention = bottleneck_attention
-        self.devices = None
-        self.decoder_device_thresh = decoder_device_thresh
-        self.additive_skips = additive_skips
-        self.use_freq = use_freq
-        self.progressive_input = progressive_input
-
-        #############################
-        # TIMESTEP EMBEDDING layers #
-        #############################
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim))
-
-        ###############
-        # INPUT block #
-        ###############
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        input_pyramid_channels =in_channels
-        ds = 1
-
-        ######################################
-        # DOWNWARD path - Feature extraction #
-        ######################################
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):                                         # Adding Residual blocks
-                layers = [
-                    ResBlock(
-                        channels=ch,
-                        emb_channels=time_embed_dim,
-                        dropout=dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                        use_freq=self.use_freq,
-                    )
-                ]
-                ch = mult * model_channels  # New input channels = channel_mult * base_channels
-                                            # (first ResBlock performs channel adaption)
-
-                if ds in attention_resolutions:                                     # Adding Attention layers
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                            num_groups=self.num_groups,
-                        )
-                    )
-
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-
-            # Adding downsampling operation
-            out_ch = ch
-            layers = []
-            layers.append(
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=out_ch,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                        down=True,
-                        num_groups=self.num_groups,
-                        resample_2d=resample_2d,
-                        use_freq=self.use_freq,
-                    )
-                    if resblock_updown
-                    else Downsample(
-                        ch,
-                        conv_resample,
-                        dims=dims,
-                        out_channels=out_ch,
-                        resample_2d=resample_2d,
-                    )
-                )
-            self.input_blocks.append(TimestepEmbedSequential(*layers))
-
-            layers = []
-            if self.progressive_input == 'residual':
-                layers.append(WaveletDownsample(in_ch=input_pyramid_channels, out_ch=out_ch))
-                input_pyramid_channels = out_ch
-
-            self.input_blocks.append(TimestepEmbedSequential(*layers))
-
-            ch = out_ch
-            input_block_chans.append(ch)
-            ds *= 2
-            self._feature_size += ch
-
-        self.input_block_chans_bk = input_block_chans[:]
-
-        #########################
-        # LATENT/ MIDDLE blocks #
-        #########################
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-                use_freq=self.use_freq,
-            ),
-            *([AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-                num_groups=self.num_groups,
-            )] if self.bottleneck_attention else [])
-            ,
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-                num_groups=self.num_groups,
-                resample_2d=resample_2d,
-                use_freq=self.use_freq,
-            ),
-        )
-        self._feature_size += ch
-
-        #################################
-        # UPWARD path - feature mapping #
-        #################################
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks+1):                                          # Adding Residual blocks
-                if not i == num_res_blocks:
-                    mid_ch = model_channels * mult
-
-                    layers = [
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=mid_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                            use_freq=self.use_freq,
-                        )
-                    ]
-                    if ds in attention_resolutions:                                         # Adding Attention layers
-                        layers.append(
-                            AttentionBlock(
-                                mid_ch,
-                                use_checkpoint=use_checkpoint,
-                                num_heads=num_heads_upsample,
-                                num_head_channels=num_head_channels,
-                                use_new_attention_order=use_new_attention_order,
-                                num_groups=self.num_groups,
-                            )
-                        )
-                    ch = mid_ch
-                else:                                                                       # Adding upsampling operation
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            mid_ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                            num_groups=self.num_groups,
-                            resample_2d=resample_2d,
-                            use_freq=self.use_freq,
-                        )
-                        if resblock_updown
-                        else Upsample(
-                            mid_ch,
-                            conv_resample,
-                            dims=dims,
-                            out_channels=out_ch,
-                            resample_2d=resample_2d
-                        )
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                mid_ch = ch
-
-        ################
-        # Out ResBlock #
-        ################
-        self.out_res = nn.ModuleList([])
-        for i in range(num_res_blocks):
-            layers = [
-                ResBlock(
-                    ch,
-                    time_embed_dim,
-                    dropout,
-                    out_channels=ch,
-                    dims=dims,
-                    use_checkpoint=use_checkpoint,
-                    use_scale_shift_norm=use_scale_shift_norm,
-                    num_groups=self.num_groups,
-                    resample_2d=resample_2d,
-                    use_freq=self.use_freq,
-                )
-            ]
-            self.out_res.append(TimestepEmbedSequential(*layers))
-
-        ################
-        # OUTPUT block #
-        ################
-        self.out = nn.Sequential(
-            normalization(ch, self.num_groups),
-            nn.SiLU(),
-            conv_nd(dims, model_channels, out_channels, 3, padding=1),
-        )
-
-    def to(self, *args, **kwargs):
-        """
-        we overwrite the to() method for the case where we
-        distribute parts of our model to different devices
-        """
-        if isinstance(args[0], (list, tuple)) and len(args[0]) > 1:
-            assert not kwargs and len(args) == 1
-            # distribute to multiple devices
-            self.devices = args[0]
-            # move first half to first device, second half to second device
-            self.input_blocks.to(self.devices[0])
-            self.time_embed.to(self.devices[0])
-            self.middle_block.to(self.devices[0])  # maybe devices 0
-            for k, b in enumerate(self.output_blocks):
-                if k < self.decoder_device_thresh:
-                    b.to(self.devices[0])
-                else:  # after threshold
-                    b.to(self.devices[1])
-            self.out.to(self.devices[0])
-            print(f"distributed UNet components to devices {self.devices}")
-
-        else:  # default behaviour
-            super().to(*args, **kwargs)
-            if self.devices is None:  # if self.devices has not been set yet, read it from params
-                p = next(self.parameters())
-                self.devices = [p.device, p.device]
-
-    def forward(self, x, timesteps):
-        """
-        Apply the model to an input batch.
-
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :param zemb: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        hs = []  # Save skip-connections here
-        input_pyramid = x
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))  # Gen sinusoidal timestep embedding
-        h = x
-        self.hs_shapes = []
-
-        for module in self.input_blocks:
-            if not isinstance(module[0], WaveletDownsample):
-                h = module(h, emb)  # Run a downstream module
-                skip = None
-                if isinstance(h, tuple):  # Check for skip features (tuple of high frequency subbands) and store in hs
-                    h, skip = h
-                hs.append(skip)
-                self.hs_shapes.append(h.shape)
-            else:
-                input_pyramid = module(input_pyramid, emb)
-                input_pyramid = input_pyramid + h
-                h = input_pyramid
-
-        for module in self.middle_block:
-            h = module(h, emb)
-            if isinstance(h, tuple):
-                h, skip = h
-
-        for module in self.output_blocks:
-            new_hs = hs.pop()
-            if new_hs:
-                skip = new_hs
-
-            # Use additive skip connections
-            if self.additive_skips:
-                h = (h + new_hs) / np.sqrt(2)
-
-            # Use frequency aware skip connections
-            elif self.use_freq:  # You usually want to use the frequency aware upsampling
-                if isinstance(h, tuple):  # Replace None with the stored skip features
-                    l = list(h)
-                    l[1] = skip
-                    h = tuple(l)
-                else:
-                    h = (h, skip)
-
-            # Use concatenation
-            else:
-                h = th.cat([h, new_hs], dim=1)
-
-            h = module(h, emb)  # Run an upstream module
-
-        for module in self.out_res:
-            h = module(h, emb)
-
-        h, _ = h
-        return self.out(h)

wdm-3d-initial/run.sh

@@ -1,124 +0,0 @@
-# general settings
-GPU=0;                    # gpu to use
-SEED=42;                  # randomness seed for sampling
-CHANNELS=64;              # number of model base channels (we use 64 for all experiments)
-MODE='train';             # train vs sample
-DATASET='brats';          # brats or lidc-idri
-MODEL='ours_unet_128';    # 'ours_unet_256', 'ours_wnet_128', 'ours_wnet_256'
-
-# settings for sampling/inference
-ITERATIONS=0;             # training iteration (as a multiple of 1k) checkpoint to use for sampling
-SAMPLING_STEPS=0;         # number of steps for accelerated sampling, 0 for the default 1000
-RUN_DIR="";               # tensorboard dir to be set for the evaluation
-
-# detailed settings (no need to change for reproducing)
-if [[ $MODEL == 'ours_unet_128' ]]; then
-  echo "MODEL: WDM (U-Net) 128 x 128 x 128";
-  CHANNEL_MULT=1,2,2,4,4;
-  IMAGE_SIZE=128;
-  ADDITIVE_SKIP=True;
-  USE_FREQ=False;
-  BATCH_SIZE=10;
-elif [[ $MODEL == 'ours_unet_256' ]]; then
-  echo "MODEL: WDM (U-Net) 256 x 256 x 256";
-  CHANNEL_MULT=1,2,2,4,4,4;
-  IMAGE_SIZE=256;
-  ADDITIVE_SKIP=True;
-  USE_FREQ=False;
-  BATCH_SIZE=1;
-elif [[ $MODEL == 'ours_wnet_128' ]]; then
-  echo "MODEL: WDM (WavU-Net) 128 x 128 x 128";
-  CHANNEL_MULT=1,2,2,4,4;
-  IMAGE_SIZE=128;
-  ADDITIVE_SKIP=False;
-  USE_FREQ=True;
-  BATCH_SIZE=10;
-elif [[ $MODEL == 'ours_wnet_256' ]]; then
-  echo "MODEL: WDM (WavU-Net) 256 x 256 x 256";
-  CHANNEL_MULT=1,2,2,4,4,4;
-  IMAGE_SIZE=256;
-  ADDITIVE_SKIP=False;
-  USE_FREQ=True;
-  BATCH_SIZE=1;
-else
-  echo "MODEL TYPE NOT FOUND -> Check the supported configurations again";
-fi
-
-# some information and overwriting batch size for sampling
-# (overwrite in case you want to sample with a higher batch size)
-# no need to change for reproducing
-if [[ $MODE == 'sample' ]]; then
-  echo "MODE: sample"
-  BATCH_SIZE=1;
-elif [[ $MODE == 'train' ]]; then
-  if [[ $DATASET == 'brats' ]]; then
-    echo "MODE: training";
-    echo "DATASET: BRATS";
-    DATA_DIR=~/wdm-3d/data/BRATS/;
-  elif [[ $DATASET == 'lidc-idri' ]]; then
-    echo "MODE: training";
-    echo "Dataset: LIDC-IDRI";
-    DATA_DIR=~/wdm-3d/data/LIDC-IDRI/;
-  else
-    echo "DATASET NOT FOUND -> Check the supported datasets again";
-  fi
-fi
-
-COMMON="
---dataset=${DATASET}
---num_channels=${CHANNELS}
---class_cond=False
---num_res_blocks=2
---num_heads=1
---learn_sigma=False
---use_scale_shift_norm=False
---attention_resolutions=
---channel_mult=${CHANNEL_MULT}
---diffusion_steps=1000
---noise_schedule=linear
---rescale_learned_sigmas=False
---rescale_timesteps=False
---dims=3
---batch_size=${BATCH_SIZE}
---num_groups=32
---in_channels=8
---out_channels=8
---bottleneck_attention=False
---resample_2d=False
---renormalize=True
---additive_skips=${ADDITIVE_SKIP}
---use_freq=${USE_FREQ}
---predict_xstart=True
-"
-TRAIN="
---data_dir=${DATA_DIR}
---resume_checkpoint=
---resume_step=0
---image_size=${IMAGE_SIZE}
---use_fp16=False
---lr=1e-5
---save_interval=100000
---num_workers=24
---devices=${GPU}
-"
-SAMPLE="
---data_dir=${DATA_DIR}
---data_mode=${DATA_MODE}
---seed=${SEED}
---image_size=${IMAGE_SIZE}
---use_fp16=False
---model_path=./${RUN_DIR}/checkpoints/${DATASET}_${ITERATIONS}000.pt
---devices=${GPU}
---output_dir=./results/${RUN_DIR}/${DATASET}_${MODEL}_${ITERATIONS}000/
---num_samples=1000
---use_ddim=False
---sampling_steps=${SAMPLING_STEPS}
---clip_denoised=True
-"
-
-# run the python scripts
-if [[ $MODE == 'train' ]]; then
-  python scripts/generation_train.py $TRAIN $COMMON;
-else
-  python scripts/generation_sample.py $SAMPLE $COMMON;
-fi

wdm-3d-initial/scripts/.ipynb_checkpoints/generation_train-checkpoint.py

@@ -1,153 +0,0 @@
-"""
-A script for training a diffusion model to unconditional image generation.
-"""
-
-import argparse
-import numpy as np
-import random
-import sys
-import torch as th
-
-sys.path.append(".")
-sys.path.append("..")
-
-from guided_diffusion import (dist_util,
-                              logger)
-from guided_diffusion.bratsloader import BRATSVolumes
-from guided_diffusion.lidcloader import LIDCVolumes
-from guided_diffusion.inpaintloader import InpaintVolumes
-from guided_diffusion.resample import create_named_schedule_sampler
-from guided_diffusion.script_util import (model_and_diffusion_defaults,
-                                          create_model_and_diffusion,
-                                          args_to_dict,
-                                          add_dict_to_argparser)
-from guided_diffusion.train_util import TrainLoop
-from torch.utils.tensorboard import SummaryWriter
-
-
-def main():
-    args = create_argparser().parse_args()
-    seed = args.seed
-    th.manual_seed(seed)
-    np.random.seed(seed)
-    random.seed(seed)
-
-    summary_writer = None
-    if args.use_tensorboard:
-        logdir = None
-        if args.tensorboard_path:
-            logdir = args.tensorboard_path
-        summary_writer = SummaryWriter(log_dir=logdir)
-        summary_writer.add_text(
-            'config',
-            '\n'.join([f'--{k}={repr(v)} <br/>' for k, v in vars(args).items()])
-        )
-        logger.configure(dir=summary_writer.get_logdir())
-    else:
-        logger.configure()
-
-    dist_util.setup_dist(devices=args.devices)
-
-    logger.log("Creating model and diffusion...")
-    arguments = args_to_dict(args, model_and_diffusion_defaults().keys())
-    model, diffusion = create_model_and_diffusion(**arguments)
-
-    # logger.log("Number of trainable parameters: {}".format(np.array([np.array(p.shape).prod() for p in model.parameters()]).sum()))
-    model.to(dist_util.dev([0, 1]) if len(args.devices) > 1 else dist_util.dev())  # allow for 2 devices
-    schedule_sampler = create_named_schedule_sampler(args.schedule_sampler, diffusion,  maxt=1000)
-
-    if args.dataset == 'brats':
-        assert args.image_size in [128, 256], "We currently just support image sizes: 128, 256"
-        ds = BRATSVolumes(args.data_dir, test_flag=False,
-                          normalize=(lambda x: 2*x - 1) if args.renormalize else None,
-                          mode='train',
-                          img_size=args.image_size)
-
-    elif args.dataset == 'lidc-idri':
-        assert args.image_size in [128, 256], "We currently just support image sizes: 128, 256"
-        ds = LIDCVolumes(args.data_dir, test_flag=False,
-                         normalize=(lambda x: 2*x - 1) if args.renormalize else None,
-                         mode='train',
-                         img_size=args.image_size)
-
-    elif args.dataset == 'inpaint':
-        assert args.image_size in [128, 256], "We currently just support image sizes: 128, 256"
-        ds = InpaintVolumes(args.data_dir,
-                         normalize=(lambda x: 2*x - 1) if args.renormalize else None,
-                         mode='train',
-                         img_size=args.image_size)
-
-    datal = th.utils.data.DataLoader(ds,
-                                     batch_size=args.batch_size,
-                                     num_workers=args.num_workers,
-                                     shuffle=True,
-                                     )
-
-    logger.log("Start training...")
-    TrainLoop(
-        model=model,
-        diffusion=diffusion,
-        data=datal,
-        batch_size=args.batch_size,
-        in_channels=args.in_channels,
-        image_size=args.image_size,
-        microbatch=args.microbatch,
-        lr=args.lr,
-        ema_rate=args.ema_rate,
-        log_interval=args.log_interval,
-        save_interval=args.save_interval,
-        resume_checkpoint=args.resume_checkpoint,
-        resume_step=args.resume_step,
-        use_fp16=args.use_fp16,
-        fp16_scale_growth=args.fp16_scale_growth,
-        schedule_sampler=schedule_sampler,
-        weight_decay=args.weight_decay,
-        lr_anneal_steps=args.lr_anneal_steps,
-        dataset=args.dataset,
-        summary_writer=summary_writer,
-        mode='default',
-    ).run_loop()
-
-
-def create_argparser():
-    defaults = dict(
-        seed=0,
-        data_dir="",
-        schedule_sampler="uniform",
-        lr=1e-4,
-        weight_decay=0.0,
-        lr_anneal_steps=0,
-        batch_size=1,
-        microbatch=-1,
-        ema_rate="0.9999",
-        log_interval=100,
-        save_interval=5000,
-        resume_checkpoint='',
-        resume_step=0,
-        use_fp16=False,
-        fp16_scale_growth=1e-3,
-        dataset='inpaint',
-        use_tensorboard=True,
-        tensorboard_path='',  # set path to existing logdir for resuming
-        devices=[0],
-        dims=3,
-        learn_sigma=False,
-        num_groups=32,
-        channel_mult="1,2,2,4,4",
-        in_channels=8,
-        out_channels=8,
-        bottleneck_attention=False,
-        num_workers=0,
-        mode='default',
-        renormalize=True,
-        additive_skips=False,
-        use_freq=False,
-    )
-    defaults.update(model_and_diffusion_defaults())
-    parser = argparse.ArgumentParser()
-    add_dict_to_argparser(parser, defaults)
-    return parser
-
-
-if __name__ == "__main__":
-    main()

wdm-3d-initial/scripts/generation_sample.py

@@ -1,136 +0,0 @@
-"""
-A script for sampling from a diffusion model for unconditional image generation.
-"""
-
-import argparse
-import nibabel as nib
-import numpy as np
-import os
-import pathlib
-import random
-import sys
-import torch as th
-
-sys.path.append(".")
-
-from guided_diffusion import (dist_util,
-                              logger)
-from guided_diffusion.script_util import (model_and_diffusion_defaults,
-                                          create_model_and_diffusion,
-                                          add_dict_to_argparser,
-                                          args_to_dict,
-                                          )
-from DWT_IDWT.DWT_IDWT_layer import IDWT_3D
-
-
-def visualize(img):
-    _min = img.min()
-    _max = img.max()
-    normalized_img = (img - _min)/ (_max - _min)
-    return normalized_img
-
-
-def dice_score(pred, targs):
-    pred = (pred>0).float()
-    return 2. * (pred*targs).sum() / (pred+targs).sum()
-
-
-def main():
-    args = create_argparser().parse_args()
-    seed = args.seed
-    dist_util.setup_dist(devices=args.devices)
-    logger.configure()
-
-    logger.log("Creating model and diffusion...")
-    model, diffusion = create_model_and_diffusion(
-        **args_to_dict(args, model_and_diffusion_defaults().keys())
-    )
-    logger.log("Load model from: {}".format(args.model_path))
-    model.load_state_dict(dist_util.load_state_dict(args.model_path, map_location="cpu"))
-    model.to(dist_util.dev([0, 1]) if len(args.devices) > 1 else dist_util.dev())  # allow for 2 devices
-
-    if args.use_fp16:
-        raise ValueError("fp16 currently not implemented")
-
-    model.eval()
-    idwt = IDWT_3D("haar")
-
-    for ind in range(args.num_samples // args.batch_size):
-        th.manual_seed(seed)
-        np.random.seed(seed)
-        random.seed(seed)
-        # print(f"Reseeded (in for loop) to {seed}")
-
-        seed += 1
-
-        img = th.randn(args.batch_size,         # Batch size
-                       8,                       # 8 wavelet coefficients
-                       args.image_size//2,      # Half spatial resolution (D)
-                       args.image_size//2,      # Half spatial resolution (H)
-                       args.image_size//2,      # Half spatial resolution (W)
-                       ).to(dist_util.dev())
-
-        model_kwargs = {}
-
-        sample_fn = diffusion.p_sample_loop
-
-        sample = sample_fn(model=model,
-                           shape=img.shape,
-                           noise=img,
-                           clip_denoised=args.clip_denoised,
-                           model_kwargs=model_kwargs,
-                           )
-
-        B, _, D, H, W = sample.size()
-
-        sample = idwt(sample[:, 0, :, :, :].view(B, 1, D, H, W) * 3.,
-                      sample[:, 1, :, :, :].view(B, 1, D, H, W),
-                      sample[:, 2, :, :, :].view(B, 1, D, H, W),
-                      sample[:, 3, :, :, :].view(B, 1, D, H, W),
-                      sample[:, 4, :, :, :].view(B, 1, D, H, W),
-                      sample[:, 5, :, :, :].view(B, 1, D, H, W),
-                      sample[:, 6, :, :, :].view(B, 1, D, H, W),
-                      sample[:, 7, :, :, :].view(B, 1, D, H, W))
-
-        sample = (sample + 1) / 2.
-
-
-        if len(sample.shape) == 5:
-            sample = sample.squeeze(dim=1)  # don't squeeze batch dimension for bs 1
-
-        pathlib.Path(args.output_dir).mkdir(parents=True, exist_ok=True)
-        for i in range(sample.shape[0]):
-            output_name = os.path.join(args.output_dir, f'sample_{ind}_{i}.nii.gz')
-            img = nib.Nifti1Image(sample.detach().cpu().numpy()[i, :, :, :], np.eye(4))
-            nib.save(img=img, filename=output_name)
-            print(f'Saved to {output_name}')
-
-
-def create_argparser():
-    defaults = dict(
-        seed=0,
-        data_dir="",
-        data_mode='validation',
-        clip_denoised=True,
-        num_samples=1,
-        batch_size=1,
-        use_ddim=False,
-        class_cond=False,
-        sampling_steps=0,
-        model_path="",
-        devices=[0],
-        output_dir='./results',
-        mode='default',
-        renormalize=False,
-        image_size=256,
-        half_res_crop=False,
-        concat_coords=False, # if true, add 3 (for 3d) or 2 (for 2d) to in_channels
-    )
-    defaults.update({k:v for k, v in model_and_diffusion_defaults().items() if k not in defaults})
-    parser = argparse.ArgumentParser()
-    add_dict_to_argparser(parser, defaults)
-    return parser
-
-
-if __name__ == "__main__":
-    main()

wdm-3d-initial/scripts/generation_train.py

@@ -1,153 +0,0 @@
-"""
-A script for training a diffusion model to unconditional image generation.
-"""
-
-import argparse
-import numpy as np
-import random
-import sys
-import torch as th
-
-sys.path.append(".")
-sys.path.append("..")
-
-from guided_diffusion import (dist_util,
-                              logger)
-from guided_diffusion.bratsloader import BRATSVolumes
-from guided_diffusion.lidcloader import LIDCVolumes
-from guided_diffusion.inpaintloader import InpaintVolumes
-from guided_diffusion.resample import create_named_schedule_sampler
-from guided_diffusion.script_util import (model_and_diffusion_defaults,
-                                          create_model_and_diffusion,
-                                          args_to_dict,
-                                          add_dict_to_argparser)
-from guided_diffusion.train_util import TrainLoop
-from torch.utils.tensorboard import SummaryWriter
-
-
-def main():
-    args = create_argparser().parse_args()
-    seed = args.seed
-    th.manual_seed(seed)
-    np.random.seed(seed)
-    random.seed(seed)
-
-    summary_writer = None
-    if args.use_tensorboard:
-        logdir = None
-        if args.tensorboard_path:
-            logdir = args.tensorboard_path
-        summary_writer = SummaryWriter(log_dir=logdir)
-        summary_writer.add_text(
-            'config',
-            '\n'.join([f'--{k}={repr(v)} <br/>' for k, v in vars(args).items()])
-        )
-        logger.configure(dir=summary_writer.get_logdir())
-    else:
-        logger.configure()
-
-    dist_util.setup_dist(devices=args.devices)
-
-    logger.log("Creating model and diffusion...")
-    arguments = args_to_dict(args, model_and_diffusion_defaults().keys())
-    model, diffusion = create_model_and_diffusion(**arguments)
-
-    # logger.log("Number of trainable parameters: {}".format(np.array([np.array(p.shape).prod() for p in model.parameters()]).sum()))
-    model.to(dist_util.dev([0, 1]) if len(args.devices) > 1 else dist_util.dev())  # allow for 2 devices
-    schedule_sampler = create_named_schedule_sampler(args.schedule_sampler, diffusion,  maxt=1000)
-
-    if args.dataset == 'brats':
-        assert args.image_size in [128, 256], "We currently just support image sizes: 128, 256"
-        ds = BRATSVolumes(args.data_dir, test_flag=False,
-                          normalize=(lambda x: 2*x - 1) if args.renormalize else None,
-                          mode='train',
-                          img_size=args.image_size)
-
-    elif args.dataset == 'lidc-idri':
-        assert args.image_size in [128, 256], "We currently just support image sizes: 128, 256"
-        ds = LIDCVolumes(args.data_dir, test_flag=False,
-                         normalize=(lambda x: 2*x - 1) if args.renormalize else None,
-                         mode='train',
-                         img_size=args.image_size)
-
-    elif args.dataset == 'inpaint':
-        assert args.image_size in [128, 256], "We currently just support image sizes: 128, 256"
-        ds = InpaintVolumes(args.data_dir,
-                         normalize=(lambda x: 2*x - 1) if args.renormalize else None,
-                         mode='train',
-                         img_size=args.image_size)
-
-    datal = th.utils.data.DataLoader(ds,
-                                     batch_size=args.batch_size,
-                                     num_workers=args.num_workers,
-                                     shuffle=True,
-                                     )
-
-    logger.log("Start training...")
-    TrainLoop(
-        model=model,
-        diffusion=diffusion,
-        data=datal,
-        batch_size=args.batch_size,
-        in_channels=args.in_channels,
-        image_size=args.image_size,
-        microbatch=args.microbatch,
-        lr=args.lr,
-        ema_rate=args.ema_rate,
-        log_interval=args.log_interval,
-        save_interval=args.save_interval,
-        resume_checkpoint=args.resume_checkpoint,
-        resume_step=args.resume_step,
-        use_fp16=args.use_fp16,
-        fp16_scale_growth=args.fp16_scale_growth,
-        schedule_sampler=schedule_sampler,
-        weight_decay=args.weight_decay,
-        lr_anneal_steps=args.lr_anneal_steps,
-        dataset=args.dataset,
-        summary_writer=summary_writer,
-        mode='default',
-    ).run_loop()
-
-
-def create_argparser():
-    defaults = dict(
-        seed=0,
-        data_dir="",
-        schedule_sampler="uniform",
-        lr=1e-4,
-        weight_decay=0.0,
-        lr_anneal_steps=0,
-        batch_size=1,
-        microbatch=-1,
-        ema_rate="0.9999",
-        log_interval=100,
-        save_interval=5000,
-        resume_checkpoint='',
-        resume_step=0,
-        use_fp16=False,
-        fp16_scale_growth=1e-3,
-        dataset='inpaint',
-        use_tensorboard=True,
-        tensorboard_path='',  # set path to existing logdir for resuming
-        devices=[0],
-        dims=3,
-        learn_sigma=False,
-        num_groups=32,
-        channel_mult="1,2,2,4,4",
-        in_channels=8,
-        out_channels=8,
-        bottleneck_attention=False,
-        num_workers=0,
-        mode='default',
-        renormalize=True,
-        additive_skips=False,
-        use_freq=False,
-    )
-    defaults.update(model_and_diffusion_defaults())
-    parser = argparse.ArgumentParser()
-    add_dict_to_argparser(parser, defaults)
-    return parser
-
-
-if __name__ == "__main__":
-    main()