### Configure and launch multi-GPU training

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Setup for distributed training using HuggingFace Accelerate and the GigaGAN class.

```python
# train.py
from gigagan_pytorch import GigaGAN, ImageDataset

gan = GigaGAN(
    generator=dict(
        dim_capacity=8,
        style_network=dict(dim=64, depth=4),
        image_size=256,
        dim_max=512,
        unconditional=True
    ),
    discriminator=dict(
        dim_capacity=16,
        dim_max=512,
        image_size=256,
        unconditional=True
    ),
    amp=True,
    save_and_sample_every=1000,
    results_folder='./results',
    model_folder='./checkpoints'
).cuda()

dataset = ImageDataset(folder='/path/to/images', image_size=256)
gan.set_dataloader(dataset.get_dataloader(batch_size=4))
gan(steps=100000, grad_accum_every=8)
```

```bash
# Configure accelerate (run once)
accelerate config

# Launch distributed training
accelerate launch train.py
```

--------------------------------

### Install GigaGAN PyTorch

Source: https://github.com/lucidrains/gigagan-pytorch/blob/main/README.md

Install the GigaGAN PyTorch library using pip.

```bash
pip install gigagan-pytorch
```

--------------------------------

### Simple Unconditional GAN Usage

Source: https://github.com/lucidrains/gigagan-pytorch/blob/main/README.md

Initialize and train a simple unconditional GigaGAN model. Ensure the dataset is correctly configured and set for the GAN before starting training.

```python
import torch

from gigagan_pytorch import (
    GigaGAN,
    ImageDataset
)

gan = GigaGAN(
    generator = dict(
        dim_capacity = 8,
        style_network = dict(
            dim = 64,
            depth = 4
        ),
        image_size = 256,
        dim_max = 512,
        num_skip_layers_excite = 4,
        unconditional = True
    ),
    discriminator = dict(
        dim_capacity = 16,
        dim_max = 512,
        image_size = 256,
        num_skip_layers_excite = 4,
        unconditional = True
    ),
    amp = True
).cuda()

# dataset

dataset = ImageDataset(
    folder = '/path/to/your/data',
    image_size = 256
)

dataloader = dataset.get_dataloader(batch_size = 1)

# you must then set the dataloader for the GAN before training

gan.set_dataloader(dataloader)

# training the discriminator and generator alternating
# for 100 steps in this example, batch size 1, gradient accumulated 8 times

gan(
    steps = 100,
    grad_accum_every = 8
)

# after much training

images = gan.generate(batch_size = 4) # (4, 3, 256, 256)
```

--------------------------------

### Launch Training Script

Source: https://github.com/lucidrains/gigagan-pytorch/blob/main/README.md

Execute the training process using the configured Accelerate environment.

```bash
$ accelerate launch train.py
```

--------------------------------

### Configure Multi-GPU Training

Source: https://github.com/lucidrains/gigagan-pytorch/blob/main/README.md

Initialize the training environment settings for multi-GPU support using the Accelerate CLI.

```bash
$ accelerate config
```

--------------------------------

### Initialize and use AdaptiveConv2DMod

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Demonstrates the instantiation and forward pass of the adaptive convolution module with style and kernel modulation.

```python
# Adaptive convolution with multiple kernels
adaptive_conv = AdaptiveConv2DMod(
    dim=256,
    dim_out=256,
    kernel=3,
    demod=True,  # Demodulation for StyleGAN-style normalization
    num_conv_kernels=4  # Number of kernels to adaptively select from
).cuda()

# Forward pass
feature_map = torch.randn(4, 256, 32, 32).cuda()
style_mod = torch.randn(4, 256).cuda()      # Style modulation
kernel_mod = torch.randn(4, 4).cuda()       # Kernel selection weights

output = adaptive_conv(feature_map, mod=style_mod, kernel_mod=kernel_mod)
# output shape: (4, 256, 32, 32)
```

--------------------------------

### Initialize and Train GigaGAN

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Initializes an unconditional GigaGAN model with specified generator and discriminator configurations, sets up an image dataset and dataloader, and trains the model for a set number of steps with gradient accumulation. Enables mixed precision training.

```python
import torch
from gigagan_pytorch import GigaGAN, ImageDataset

# Initialize unconditional GigaGAN
gan = GigaGAN(
    generator=dict(
        dim_capacity=8,
        style_network=dict(dim=64, depth=4),
        image_size=256,
        dim_max=512,
        num_skip_layers_excite=4,
        unconditional=True
    ),
    discriminator=dict(
        dim_capacity=16,
        dim_max=512,
        image_size=256,
        num_skip_layers_excite=4,
        unconditional=True
    ),
    amp=True  # Enable mixed precision training
).cuda()

# Set up dataset and dataloader
dataset = ImageDataset(folder='/path/to/images', image_size=256)
dataloader = dataset.get_dataloader(batch_size=4)
gan.set_dataloader(dataloader)

# Train for 100 steps with gradient accumulation
gan(steps=100, grad_accum_every=8)

# Generate images after training
images = gan.generate(batch_size=4)  # Returns tensor of shape (4, 3, 256, 256)
```

--------------------------------

### Load Data with ImageDataset

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Handles image loading, preprocessing, and dataloader creation for unconditional training.

```python
from gigagan_pytorch import ImageDataset

# Create dataset from folder
dataset = ImageDataset(
    folder='/path/to/images',
    image_size=256,
    exts=['jpg', 'jpeg', 'png', 'tiff'],
    augment_horizontal_flip=True,
    convert_image_to='RGB'
)

# Create dataloader
dataloader = dataset.get_dataloader(
    batch_size=8,
    num_workers=4
)

# Iterate over batches
for batch in dataloader:
    images = batch  # Tensor of shape (batch_size, 3, 256, 256)
    break
```

--------------------------------

### Save and load model checkpoints

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Methods for persisting training state and generating images using the EMA model.

```python
from gigagan_pytorch import GigaGAN

# Initialize and train
gan = GigaGAN(...)
gan(steps=1000, grad_accum_every=8)

# Save checkpoint
gan.save('./checkpoints/model-1000.ckpt')

# Load checkpoint (new instance)
gan_loaded = GigaGAN(...)
gan_loaded.load('./checkpoints/model-1000.ckpt')

# Resume training
gan_loaded(steps=1000, grad_accum_every=8)

# Generate with EMA model (smoother outputs)
images = gan_loaded.generate(batch_size=4)
```

--------------------------------

### Initialize and Train UnetUpsampler

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Configures the GigaGAN model for super-resolution training and performs upsampling on low-resolution inputs.

```python
import torch
from gigagan_pytorch import GigaGAN, ImageDataset

# Initialize GigaGAN with upsampler
gan = GigaGAN(
    train_upsampler=True,  # Enable upsampler training mode
    generator=dict(
        style_network=dict(dim=64, depth=4),
        dim=32,
        image_size=256,        # Output size
        input_image_size=64,   # Input low-res size
        unconditional=True
    ),
    discriminator=dict(
        dim_capacity=16,
        dim_max=512,
        image_size=256,
        num_skip_layers_excite=4,
        multiscale_input_resolutions=(128,),
        unconditional=True
    ),
    amp=True
).cuda()

# Set up dataset
dataset = ImageDataset(folder='/path/to/images', image_size=256)
dataloader = dataset.get_dataloader(batch_size=1)
gan.set_dataloader(dataloader)

# Train upsampler
gan(steps=100, grad_accum_every=8)

# Upsample low-resolution images
lowres = torch.randn(1, 3, 64, 64).cuda()
highres = gan.generate(lowres)  # Returns (1, 3, 256, 256)
```

--------------------------------

### Initialize and Use GigaGAN Generator

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Initializes a GigaGAN Generator for image synthesis, supporting adaptive convolutions and optional text conditioning. Generates images from latent noise and can return intermediate RGB outputs for multi-scale discrimination.

```python
import torch
from gigagan_pytorch import Generator, StyleNetwork, TextEncoder

# Unconditional generator
generator = Generator(
    image_size=256,
    dim_capacity=16,
    dim_max=512,
    style_network=StyleNetwork(dim=64, depth=4),
    self_attn_resolutions=(32, 16),
    cross_attn_resolutions=(32, 16),
    num_conv_kernels=2,  # Adaptive kernel selection (paper novelty)
    num_skip_layers_excite=4,
    unconditional=True,
    pixel_shuffle_upsample=True
).cuda()

# Generate images from random noise
batch_size = 4
noise = torch.randn(batch_size, 64).cuda()  # Latent noise matching style_network dim
styles = generator.style_network(noise)
images = generator(styles=styles, batch_size=batch_size)
# images shape: (4, 3, 256, 256)

# Get all intermediate RGB outputs for multi-scale discrimination
images, all_rgbs = generator(styles=styles, batch_size=batch_size, return_all_rgbs=True)
# all_rgbs: list of tensors at different resolutions
```

--------------------------------

### Configure VisionAidedDiscriminator

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Sets up a CLIP-based discriminator to extract multi-layer features for auxiliary discrimination loss.

```python
import torch
from gigagan_pytorch import VisionAidedDiscriminator

# Initialize vision-aided discriminator
vad = VisionAidedDiscriminator(
    depth=2,
    dim_head=64,
    heads=8,
    layer_indices=(-1, -2, -3),  # CLIP layers to extract features from
    conv_dim=512,
    unconditional=True,
    num_conv_kernels=2
).cuda()

# Forward pass
images = torch.randn(4, 3, 224, 224).cuda()  # CLIP expects 224x224
logits = vad(images)  # List of logits from each layer

# Get CLIP encodings for gradient penalty
logits, clip_encodings = vad(images, return_clip_encodings=True)
```

--------------------------------

### Initialize and Use GigaGAN Discriminator

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Initializes a GigaGAN Discriminator for multi-scale image discrimination, supporting auxiliary reconstruction loss. Processes images at multiple resolutions and can return discrimination logits, multi-scale outputs, and auxiliary reconstruction losses.

```python
import torch
from gigagan_pytorch import Discriminator

# Initialize discriminator
discriminator = Discriminator(
    image_size=256,
    dim_capacity=16,
    dim_max=512,
    attn_resolutions=(32, 16),
    multiscale_input_resolutions=(64, 32, 16, 8),
    aux_recon_resolutions=(8,),  # Resolutions for auxiliary reconstruction
    aux_recon_patch_dims=(2,),
    aux_recon_frac_patches=(0.25,),
    num_skip_layers_excite=4,
    unconditional=True,
    predictor_depth=2
).cuda()

# Forward pass
images = torch.randn(4, 3, 256, 256).cuda()
rgbs = discriminator.real_images_to_rgbs(images)  # Generate multi-scale inputs

logits, multiscale_outputs, aux_recon_losses = discriminator(
    images,
    rgbs,
    return_multiscale_outputs=True,
    calc_aux_loss=True
)
# logits: discrimination scores
# multiscale_outputs: list of logits at different scales
# aux_recon_losses: reconstruction losses for regularization
```

--------------------------------

### Map Latents with StyleNetwork

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Implements a mapping network to transform noise into style vectors, supporting optional text conditioning.

```python
import torch
from gigagan_pytorch import StyleNetwork

# Unconditional style network
style_net = StyleNetwork(
    dim=512,
    depth=8,
    lr_mul=0.1  # Learning rate multiplier for stability
).cuda()

noise = torch.randn(4, 512).cuda()
styles = style_net(noise)  # (4, 512)

# Text-conditioned style network
style_net_cond = StyleNetwork(
    dim=512,
    depth=8,
    dim_text_latent=512,  # Must match TextEncoder dim
    lr_mul=0.1
).cuda()

text_latent = torch.randn(4, 512).cuda()  # Global text tokens
styles = style_net_cond(noise, text_latent=text_latent)  # (4, 512)
```

--------------------------------

### AdaptiveConv2DMod Implementation

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Placeholder for the adaptive convolution module that performs softmax-weighted kernel summation.

```python
import torch
from gigagan_pytorch import AdaptiveConv2DMod
```

--------------------------------

### Unconditional Unet Upsampler Usage

Source: https://github.com/lucidrains/gigagan-pytorch/blob/main/README.md

Initialize and train an unconditional Unet Upsampler using GigaGAN. This configuration is for upsampling tasks. Ensure the dataset and GAN are set up correctly before training.

```python
import torch
from gigagan_pytorch import (
    GigaGAN,
    ImageDataset
)

gan = GigaGAN(
    train_upsampler = True,     # set this to True
    generator = dict(
        style_network = dict(
            dim = 64,
            depth = 4
        ),
        dim = 32,
        image_size = 256,
        input_image_size = 64,
        unconditional = True
    ),
    discriminator = dict(
        dim_capacity = 16,
        dim_max = 512,
        image_size = 256,
        num_skip_layers_excite = 4,
        multiscale_input_resolutions = (128,),
        unconditional = True
    ),
    amp = True
).cuda()

dataset = ImageDataset(
    folder = '/path/to/your/data',
    image_size = 256
)

dataloader = dataset.get_dataloader(batch_size = 1)

gan.set_dataloader(dataloader)

# training the discriminator and generator alternating
# for 100 steps in this example, batch size 1, gradient accumulated 8 times

gan(
    steps = 100,
    grad_accum_every = 8
)

# after much training

lowres = torch.randn(1, 3, 64, 64).cuda()

images = gan.generate(lowres) # (1, 3, 256, 256)
```

--------------------------------

### Encode Text with TextEncoder

Source: https://context7.com/lucidrains/gigagan-pytorch/llms.txt

Wraps CLIP to generate global and fine-grained text tokens for generator conditioning.

```python
import torch
from gigagan_pytorch import TextEncoder

# Initialize text encoder
text_encoder = TextEncoder(
    dim=512,          # Output dimension
    depth=4,          # Transformer depth
    dim_head=64,
    heads=8
).cuda()

# Encode text prompts
texts = ["a photo of a cat", "a painting of a dog", "a sketch of a bird"]
global_tokens, fine_tokens, text_mask = text_encoder(texts=texts)
# global_tokens: (batch, dim) - for style network conditioning
# fine_tokens: (batch, seq_len, dim) - for cross-attention
# text_mask: (batch, seq_len) - attention mask
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.