imgen-toolbox 0.1.0__tar.gz

imgen_toolbox-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simone Santoro
+
+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.

imgen_toolbox-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: imgen_toolbox
+Version: 0.1.0
+Summary: Repository containing building blocks and utilities for flexible Generative Neural Networks implementation
+Author-email: Simone Santoro <simone_santoro21@outlook.it>
+License: MIT
+Project-URL: Homepage, https://github.com/SimoneSantoro21/imgen_toolbox
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Dynamic: license-file
+
+# imgen_toolbox
+Repository containing building blocks and utilities for flexible Generative Neural Networks implementation

imgen_toolbox-0.1.0/README.md

@@ -0,0 +1,2 @@
+# imgen_toolbox
+Repository containing building blocks and utilities for flexible Generative Neural Networks implementation

imgen_toolbox-0.1.0/imgen_toolbox/__init__.py

@@ -0,0 +1,15 @@
+from .nn.embeddings import FiLM
+from .nn.blocks import conv, Downsampling, Upsampling, UnetBlock
+from .models.unet_generator import Generator_Unet3D
+from .models.patchGAN_discriminator import PatchGAN_Discriminator
+
+
+__all__ = [
+    "FiLM",
+    "conv",
+    "Downsampling",
+    "Upsampling",
+    "UnetBlock",
+    "Generator_Unet3D",
+    "PatchGAN_Discriminator"
+]

imgen_toolbox-0.1.0/imgen_toolbox/data/datasets.py

@@ -0,0 +1,99 @@
+import torch
+from torch.utils.data import Dataset
+import nibabel as nib
+import numpy as np
+import os
+import re
+
+class Dataset3D(Dataset):
+    """
+    Unified dataset over ALL center indices in one folder.
+
+    Expects two subfolders:
+      - CENTERS:   center_{patientid}_{center_idx}.nii.gz
+      - NEIGHBORS: neighbor_{patientid}_{center_idx}.nii.gz
+
+    Returns:
+      (neighbor_tensor, center_tensor)
+        neighbor_tensor: [C, D, H, W]  (C can be 1 or >1)
+        center_tensor:   [1, D, H, W]  (or [C, D, H, W] if your centers are multi-channel too)
+    """
+
+    def __init__(self, root_path: str, transform=None):
+        self.centers_dir = os.path.join(root_path, "CENTERS")
+        self.neighbors_dir = os.path.join(root_path, "NEIGHBORS")
+        self.transform = transform
+
+        pat_center   = re.compile(r'^center_([^_]+)_(\d{1,2})\.nii\.gz$')
+        pat_neighbor = re.compile(r'^neighbor_([^_]+)_(\d{1,2})\.nii\.gz$')
+
+        center_map = {}
+        neighbor_map = {}
+
+        for fname in os.listdir(self.centers_dir):
+            m = pat_center.match(fname)
+            if not m:
+                continue
+            pid, ci = m.group(1), int(m.group(2))
+            center_map[(ci, pid)] = os.path.join(self.centers_dir, fname)
+
+        for fname in os.listdir(self.neighbors_dir):
+            m = pat_neighbor.match(fname)
+            if not m:
+                continue
+            pid, ci = m.group(1), int(m.group(2))
+            neighbor_map[(ci, pid)] = os.path.join(self.neighbors_dir, fname)
+
+        self.samples = []
+        for key, cpath in center_map.items():
+            if key in neighbor_map:
+                npath = neighbor_map[key]
+                center_idx, patient_id = key
+                self.samples.append((center_idx, patient_id, cpath, npath))
+
+        self.samples.sort(key=lambda x: (x[0], x[1]))
+
+    def __len__(self):
+        return len(self.samples)
+
+    @staticmethod
+    def _load_nii(path: str) -> np.ndarray:
+        arr = nib.load(path).get_fdata().astype(np.float32)
+        return arr
+
+    @staticmethod
+    def _to_torch_volume(arr: np.ndarray) -> torch.Tensor:
+        """
+        Accepts:
+          - 3D: [H, W, D] (nibabel typical)
+          - 4D: [H, W, D, C] (channels-last, e.g. axis=-1 stacking)
+
+        Returns:
+          - 3D -> [1, D, H, W]
+          - 4D -> [C, D, H, W]
+        """
+        t = torch.from_numpy(arr)
+
+        if t.ndim == 3:
+            # [H, W, D] -> [D, H, W] -> [1, D, H, W]
+            t = t.permute(2, 0, 1).contiguous()
+            t = t.unsqueeze(0)
+            return t
+
+        if t.ndim == 4:
+            # [H, W, D, C] -> [C, D, H, W]
+            t = t.permute(3, 2, 0, 1).contiguous()
+            return t
+
+        raise ValueError(f"Expected 3D or 4D volume, got shape {tuple(t.shape)}")
+
+    def __getitem__(self, idx):
+        center_idx, patient_id, cpath, npath = self.samples[idx]
+
+        center_arr = self._load_nii(cpath)
+        neighbor_arr = self._load_nii(npath)
+
+        center_tensor = self._to_torch_volume(center_arr)
+        neighbor_tensor = self._to_torch_volume(neighbor_arr)
+
+        return neighbor_tensor, center_tensor

imgen_toolbox-0.1.0/imgen_toolbox/losses/gan_loss.py

@@ -0,0 +1,64 @@
+import torch
+import torch.nn as nn
+
+
+class GANLoss(nn.Module):
+    """
+    Implementation of GAN Loss class.
+    
+    It supports both vanilla GAN loss (using BCEWithLogitsLoss) and LSGAN (using MSELoss)
+    """
+    def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):
+        """
+        Initializing GANLoss.
+
+        Parameters:
+            gan_mode (str): Type of GAN objective ('vanilla' or 'lsgan').
+            target_real_label (float): Label for real images.
+            target_fake_label (float): Label for fake images.
+        """
+        super(GANLoss, self).__init__()
+        # Register buffers so that these tensors are part of the state but not learnable.
+        self.register_buffer('real_label', torch.tensor(target_real_label))
+        self.register_buffer('fake_label', torch.tensor(target_fake_label))
+        self.gan_mode = gan_mode
+        if gan_mode == 'lsgan':
+            self.loss = nn.MSELoss()
+        elif gan_mode == 'vanilla':
+            self.loss = nn.BCEWithLogitsLoss()
+        else:
+            raise NotImplementedError('gan mode {} not implemented'.format(gan_mode))
+    
+
+    def get_target_tensor(self, prediction, target_is_real):
+        """
+        Create label tensors with the same size as the prediction.
+        
+        Parameters:
+            prediction (torch.Tensor): The output from the discriminator.
+            target_is_real (bool): Whether the ground truth label is for real images.
+            
+        Returns:
+            torch.Tensor: Target tensor filled with either real or fake label.
+        """
+        if target_is_real:
+            target_tensor = self.real_label
+        else:
+            target_tensor = self.fake_label
+        return target_tensor.expand_as(prediction)
+    
+    
+    def forward(self, prediction, target_is_real):
+        """
+        Calculate loss given discriminator's output and ground truth labels.
+        
+        Parameters:
+            prediction (torch.Tensor): The discriminator output.
+            target_is_real (bool): True if ground truth label is for real images.
+            
+        Returns:
+            torch.Tensor: The calculated loss.
+        """
+        target_tensor = self.get_target_tensor(prediction, target_is_real)
+        loss = self.loss(prediction, target_tensor)
+        return loss

imgen_toolbox-0.1.0/imgen_toolbox/models/patchGAN_discriminator.py

@@ -0,0 +1,45 @@
+import torch.nn as nn
+from ..nn.blocks import Downsampling
+
+
+class PatchGAN_Discriminator(nn.Module):
+    """
+    PatchGAN discriminator modified for 128x128 images.
+    
+    The discriminator supports two modes:
+      - patch_size=70: A 70×70 PatchGAN variant.
+      - patch_size=16: A 16×16 PatchGAN variant.
+    """
+
+    def __init__(self, input_nc, ndf = 64, patch_size = 70, dimensionality = 3):
+        super().__init__()
+
+        if patch_size == 70:
+            self.model = nn.Sequential(
+                Downsampling(input_nc, ndf, dimensionality=dimensionality, normalization=None,
+                             activation=True, kernel_size = 4, stride = 2, padding = 1),
+                Downsampling(ndf, ndf*2, dimensionality=dimensionality, normalization='batch',
+                             activation=True, kernel_size = 4, stride = 2, padding = 1),
+                Downsampling(ndf*2, ndf*4, dimensionality=dimensionality, normalization='batch',
+                             activation=True, kernel_size = 4, stride = 2, padding = 1),
+                Downsampling(ndf*4, ndf*8, dimensionality=dimensionality, normalization='batch',
+                             activation=True, kernel_size = 4, stride = 1, padding = 1),
+                Downsampling(ndf*8, 1, dimensionality=dimensionality, normalization=None,
+                             activation=False, kernel_size = 4, stride = 1, padding = 1),
+            )
+        elif patch_size == 16:
+            self.model = nn.Sequential(
+                Downsampling(input_nc, ndf, dimensionality=dimensionality, normalization=None,
+                             activation=True, kernel_size=4, stride=2, padding=1),
+                Downsampling(ndf, ndf*2, dimensionality=dimensionality, normalization='batch',
+                             activation=True, kernel_size=4, stride=2, padding=1),
+                Downsampling(ndf*2, ndf*4, dimensionality=dimensionality, normalization='batch',
+                             activation=True, kernel_size=4, stride=2, padding=1),
+                Downsampling(ndf*4, 1, dimensionality=dimensionality, normalization=None,
+                             activation=False, kernel_size=4, stride=1, padding=1),
+            )
+        else:
+            raise ValueError("Unsupported patch size. Please choose patch_size=70 or patch_size=16.")
+    
+    def forward(self, x):
+        return self.model(x)

imgen_toolbox-0.1.0/imgen_toolbox/models/unet_generator.py

@@ -0,0 +1,86 @@
+import torch.nn as nn
+
+from ..nn.embeddings import MetaMLP
+from ..nn.blocks import UnetBlock
+
+
+class Generator_Unet3D(nn.Module):
+    """
+    3D U-Net generator (pix2pix-style) with FiLM metadata conditioning.
+
+    Input:
+      x:    (B, in_ch, D, H, W)
+      meta: (B, 6)  -> [center_dir(3), neighbor_dir(3)]
+
+    Output:
+      y: (B, out_ch, D, H, W)
+    """
+
+    def __init__(
+        self, in_ch, out_ch, ngf=64, dimensionality=3, use_dropout=True,
+        meta_dim=6, emb_dim=128, use_film=True
+    ):
+        super().__init__()
+        self.use_film = use_film
+
+        # metadata embedding
+        self.meta_mlp = MetaMLP(meta_dim=meta_dim, emb_dim=emb_dim) if use_film else None
+
+        # anisotropic-ish params
+        params = [
+            dict(kernel_size=(4,4,4), stride=(2,2,2), padding=(1,1,1)),  # 80->40, 128->64
+            dict(kernel_size=(4,4,4), stride=(2,2,2), padding=(1,1,1)),  # 40->20, 64->32
+            dict(kernel_size=(4,4,4), stride=(2,2,2), padding=(1,1,1)),  # 20->10, 32->16
+            dict(kernel_size=(4,4,4), stride=(2,2,2), padding=(1,1,1)),  # 10->5,  16->8
+            dict(kernel_size=(3,4,4), stride=(1,2,2), padding=(1,1,1)),  # keep D=5, halve H,W: 8->4
+            dict(kernel_size=(3,4,4), stride=(1,2,2), padding=(1,1,1)),  # keep D=5, 4->2
+            dict(kernel_size=(3,4,4), stride=(1,2,2), padding=(1,1,1)),  # keep D=5, 2->1
+        ]
+
+        # build from innermost outward
+        unet_block = UnetBlock(
+            ngf*8, ngf*8, input_nc=None, submodule=None,
+            is_innermost=True, dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-1]
+        )
+        unet_block = UnetBlock(
+            ngf*8, ngf*8, input_nc=None, submodule=unet_block,
+            use_dropout=use_dropout, dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-2]
+        )
+        unet_block = UnetBlock(
+            ngf*8, ngf*8, input_nc=None, submodule=unet_block,
+            use_dropout=use_dropout, dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-3]
+        )
+        unet_block = UnetBlock(
+            ngf*4, ngf*8, input_nc=None, submodule=unet_block,
+            dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-4]
+        )
+        unet_block = UnetBlock(
+            ngf*2, ngf*4, input_nc=None, submodule=unet_block,
+            dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-5]
+        )
+        unet_block = UnetBlock(
+            ngf, ngf*2, input_nc=None, submodule=unet_block,
+            dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-6]
+        )
+        unet_block = UnetBlock(
+            out_ch, ngf, input_nc=in_ch, submodule=unet_block,
+            is_outermost=True, dimensionality=dimensionality,
+            use_film=use_film, emb_dim=emb_dim, **params[-7]
+        )
+
+        self.model = unet_block
+
+    def forward(self, x, meta=None):
+        if self.use_film:
+            if meta is None:
+                raise ValueError("meta must be provided when use_film=True")
+            emb = self.meta_mlp(meta)
+            return self.model(x, emb)
+        else:
+            return self.model(x)

imgen_toolbox-0.1.0/imgen_toolbox/nn/blocks.py

@@ -0,0 +1,253 @@
+import torch
+import torch.nn as nn
+from .embeddings import FiLM
+
+#-------------------------------- BASIC OPERATIONS -----------------------------------------
+
+def conv(dimensionality, in_channels, out_channels, **kwargs):
+    if dimensionality == 1:
+        return nn.Conv1d(in_channels, out_channels, **kwargs)
+    elif dimensionality == 2:
+        return nn.Conv2d(in_channels, out_channels, **kwargs)
+    elif dimensionality == 3:
+        return nn.Conv3d(in_channels, out_channels, **kwargs)
+    else:
+        raise ValueError("dimensionality must be 1, 2, or 3")
+
+
+
+def transposed_conv(dimensionality, in_channels, out_channels, **kwargs):
+    if dimensionality == 1:
+        return nn.ConvTranspose1d(in_channels, out_channels, **kwargs)
+    elif dimensionality == 2:
+        return nn.ConvTranspose2d(in_channels, out_channels, **kwargs)
+    elif dimensionality == 3:
+        return nn.ConvTranspose3d(in_channels, out_channels, **kwargs)
+    else:
+        raise ValueError("dimensionality must be 1, 2, or 3")
+
+
+
+#-------------------- NORMALIZATION OPTIONS AND ACTIVATION FUNCTIONS ----------------------
+
+class Normalization(nn.Module):
+    """
+    Class for defining the normalization operation to apply in network layers
+    """
+
+    def __init__(self, num_channels, normalization = "batch", dimensionality = 2, **kwargs):
+        super().__init__()
+
+        self.normalization = normalization
+
+        if normalization == "batch":
+            if dimensionality==1:
+                self.out = nn.BatchNorm1d(num_channels, **kwargs)
+            if dimensionality==2:
+                self.out = nn.BatchNorm2d(num_channels, **kwargs)
+            if dimensionality==3:
+                self.out = nn.BatchNorm3d(num_channels, **kwargs)
+
+    def forward(self, x):
+        return self.out(x)
+    
+
+class Activation(nn.Module):
+    """
+    Class for defining the Activation layer 
+    """
+
+    def __init__(self, activation, **kwargs):
+        super().__init__()
+
+        if activation == "relu":
+            self.out = nn.ReLU(*kwargs)
+        if activation == "leaky_relu":
+            self.out = nn.LeakyReLU(**kwargs)
+    
+    def forward(self, x):
+        return self.out(x)
+    
+
+#------------------------------- UPSAMPLING AND DOWNSAMPLING BLOCKS -------------------------
+
+class Downsampling(nn.Module):
+    """
+    Convolution based downsampling block. Works for both 2D and 3D images.
+    """
+
+    def __init__(self, in_ch, out_ch, dimensionality = 2, normalization = None, 
+                 activation = False, **kwargs):
+        super().__init__()
+
+        layers = []
+
+        layers.append(conv(dimensionality, in_ch, out_ch, **kwargs))
+        if normalization:
+            layers.append(Normalization(out_ch, normalization, dimensionality))
+        if activation:
+            layers.append(nn.LeakyReLU(0.2, False))
+
+        self.downsampling = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.downsampling(x)
+    
+
+class Upsampling(nn.Module):
+    """
+    Convolution based upsampling block. Works for both 2D and 3D images.
+    """
+
+    def __init__(self, in_ch, out_ch, dimensionality = 2, normalization = None, 
+                 activation = False, dropout = False, **kwargs):
+        super().__init__()
+
+        layers = []
+
+        if activation:
+            layers.append(nn.ReLU(inplace=False))
+
+        layers.append(transposed_conv(dimensionality, in_ch, out_ch, **kwargs))
+        
+        if normalization:
+            layers.append(Normalization(out_ch, normalization, dimensionality))
+
+        if dropout:
+            layers.append(nn.Dropout(0.5))
+        
+        self.upsampling = nn.Sequential(*layers)
+    
+    def forward(self, x):
+        return self.upsampling(x)
+    
+
+#--------------------------------- UNET SKIPCONNECTION BLOCK -------------------------
+
+class UnetBlock(nn.Module):
+    """
+    U-Net block with skip connection.
+    This version supports optional FiLM conditioning via an embedding vector.
+
+    Forward signatures:
+      - unconditional: y = block(x)
+      - conditional:   y = block(x, emb)
+
+    Notes:
+      - For non-outermost blocks we return cat([x, up(...)], dim=1) as usual.
+      - FiLM is applied after the DOWN path and after the UP path (when enabled).
+    """
+
+    def __init__(
+        self, outer_nc, inner_nc, input_nc=None, submodule=None,
+        is_innermost=False, is_outermost=False, norm_layer="batch",
+        use_dropout=False, dimensionality=2, kernel_size=4, stride=2, padding=1,
+        use_film=False, emb_dim=128
+    ):
+        super().__init__()
+        self.is_outermost = is_outermost
+        self.is_innermost = is_innermost
+        self.use_dropout = use_dropout
+        self.use_film = use_film
+
+        if input_nc is None:
+            input_nc = outer_nc
+
+        if dimensionality == 3:
+            if isinstance(kernel_size, int): kernel_size = (kernel_size, kernel_size, kernel_size)
+            if isinstance(stride, int):      stride = (stride, stride, stride)
+            if isinstance(padding, int):     padding = (padding, padding, padding)
+
+        # --- layers ---
+        if is_outermost:
+            self.down = Downsampling(
+                input_nc, inner_nc,
+                dimensionality=dimensionality,
+                normalization=None,
+                activation=False,
+                kernel_size=kernel_size, stride=stride, padding=padding
+            )
+            self.submodule = submodule
+            self.up = Upsampling(
+                inner_nc * 2, outer_nc,
+                dimensionality=dimensionality,
+                normalization=None,
+                activation=True,
+                dropout=False,
+                kernel_size=kernel_size, stride=stride, padding=padding
+            )
+            self.out_act = nn.Sigmoid()
+
+        elif is_innermost:
+            self.down = Downsampling(
+                input_nc, inner_nc,
+                dimensionality=dimensionality,
+                normalization=None,
+                activation=True,
+                kernel_size=kernel_size, stride=stride, padding=padding
+            )
+            self.submodule = None
+            self.up = Upsampling(
+                inner_nc, outer_nc,
+                dimensionality=dimensionality,
+                normalization=norm_layer,
+                activation=True,
+                dropout=False,
+                kernel_size=kernel_size, stride=stride, padding=padding
+            )
+            self.out_act = None
+
+        else:
+            self.down = Downsampling(
+                input_nc, inner_nc,
+                dimensionality=dimensionality,
+                normalization=norm_layer,
+                activation=True,
+                kernel_size=kernel_size, stride=stride, padding=padding
+            )
+            self.submodule = submodule
+            self.up = Upsampling(
+                inner_nc * 2, outer_nc,
+                dimensionality=dimensionality,
+                normalization=norm_layer,
+                activation=True,
+                dropout=False,
+                kernel_size=kernel_size, stride=stride, padding=padding
+            )
+            self.dropout = nn.Dropout(0.5) if use_dropout else None
+            self.out_act = None
+
+        # --- FiLM modules (optional) ---
+        if use_film:
+            self.film_down = FiLM(emb_dim=emb_dim, n_ch=inner_nc)
+            self.film_up   = FiLM(emb_dim=emb_dim, n_ch=outer_nc)
+        else:
+            self.film_down = None
+            self.film_up   = None
+
+    def forward(self, x, emb=None):
+        # Down
+        h = self.down(x)
+        if self.film_down is not None and emb is not None:
+            h = self.film_down(h, emb)
+
+        # Submodule
+        if self.submodule is not None:
+            h = self.submodule(h, emb)
+
+        # Up
+        u = self.up(h)
+        if self.film_up is not None and emb is not None:
+            u = self.film_up(u, emb)
+
+        if self.out_act is not None:
+            u = self.out_act(u)
+
+        # Skip connections
+        if self.is_outermost:
+            return u
+        else:
+            out = torch.cat([x, u], dim=1)
+            if (not self.is_innermost) and (self.dropout is not None):
+                out = self.dropout(out)
+            return out

imgen_toolbox-0.1.0/imgen_toolbox/nn/embeddings.py

@@ -0,0 +1,34 @@
+import torch.nn as nn
+
+
+#--------------------------------------- FiLM embedding -------------------------------------
+class MetaMLP(nn.Module):
+    """Encodes metadata vector to an embedding used by FiLM."""
+    def __init__(self, meta_dim=6, emb_dim=128):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(meta_dim, emb_dim),
+            nn.ReLU(inplace=True),
+            nn.Linear(emb_dim, emb_dim),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, m):  # (B,meta_dim)
+        return self.net(m) # (B,emb_dim)
+
+
+class FiLM(nn.Module):
+    """Feature-wise Linear Modulation: produces per-channel gamma/beta."""
+    def __init__(self, emb_dim, n_ch):
+        super().__init__()
+        self.to_gb = nn.Linear(emb_dim, 2 * n_ch)
+
+    def forward(self, x, emb):
+        # x: (B,C,D,H,W) or (B,C,H,W), emb: (B,emb_dim)
+        gb = self.to_gb(emb)  # (B,2C)
+        gamma, beta = gb.chunk(2, dim=1)
+        # broadcast
+        view_shape = (gamma.shape[0], gamma.shape[1]) + (1,) * (x.ndim - 2)
+        gamma = gamma.view(*view_shape)
+        beta  = beta.view(*view_shape)
+        return x * (1.0 + gamma) + beta

imgen_toolbox-0.1.0/imgen_toolbox.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: imgen_toolbox
+Version: 0.1.0
+Summary: Repository containing building blocks and utilities for flexible Generative Neural Networks implementation
+Author-email: Simone Santoro <simone_santoro21@outlook.it>
+License: MIT
+Project-URL: Homepage, https://github.com/SimoneSantoro21/imgen_toolbox
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Dynamic: license-file
+
+# imgen_toolbox
+Repository containing building blocks and utilities for flexible Generative Neural Networks implementation

imgen_toolbox-0.1.0/imgen_toolbox.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+imgen_toolbox/__init__.py
+imgen_toolbox.egg-info/PKG-INFO
+imgen_toolbox.egg-info/SOURCES.txt
+imgen_toolbox.egg-info/dependency_links.txt
+imgen_toolbox.egg-info/requires.txt
+imgen_toolbox.egg-info/top_level.txt
+imgen_toolbox/data/__init__.py
+imgen_toolbox/data/datasets.py
+imgen_toolbox/losses/__init__.py
+imgen_toolbox/losses/gan_loss.py
+imgen_toolbox/models/__init__.py
+imgen_toolbox/models/patchGAN_discriminator.py
+imgen_toolbox/models/unet_generator.py
+imgen_toolbox/nn/__init__.py
+imgen_toolbox/nn/blocks.py
+imgen_toolbox/nn/embeddings.py
+tests/test_blocks.py
+tests/test_init.py
+tests/test_lossess.py

imgen_toolbox-0.1.0/imgen_toolbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

imgen_toolbox-0.1.0/imgen_toolbox.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+nibabel

imgen_toolbox-0.1.0/imgen_toolbox.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+dist
+imgen_toolbox
+tests

imgen_toolbox-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "imgen_toolbox"
+version = "0.1.0"
+description = "Repository containing building blocks and utilities for flexible Generative Neural Networks implementation"
+readme = "README.md"
+requires-python = ">=3.11"
+
+authors = [
+  { name = "Simone Santoro", email = "simone_santoro21@outlook.it" }
+]
+
+license = { text = "MIT" }
+
+dependencies = [
+  "numpy",
+  "nibabel"
+]
+
+classifiers = [
+  "Development Status :: 1 - Planning",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3.11"
+]
+
+[project.urls]
+Homepage = "https://github.com/SimoneSantoro21/imgen_toolbox"
+
+[tool.setuptools.packages.find]
+where = ["."]

imgen_toolbox-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+