### Setup Python Environment and Download Data

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Sets up the Python environment by installing pip, stylegan2_pytorch, and downloading training data from an S3 bucket. The PATH is updated to include local bin executables.

```bash
mkdir data
curl -O https://bootstrap.pypa.io/get-pip.py
sudo apt-get install python3-distutils
python3 get-pip.py
pip3 install stylegan2_pytorch
export PATH=$PATH:/home/ubuntu/.local/bin
aws s3 sync s3://<Your bucket name> ~/data
cd data
tar -xf ../train.tar.gz
```

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

### AWS Deployment Setup for StyleGAN2 PyTorch Training

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

Provides bash commands for setting up an AWS EC2 instance for StyleGAN2 training. This includes installing the AWS CLI, configuring credentials, setting up the environment, downloading data from S3, and starting the training process within a screen session.

```bash
# On EC2 instance (Ubuntu AMI with GPU, e.g., p2.xlarge or p3 series)

# Install AWS CLI
sudo snap install aws-cli --classic
aws configure  # Enter your AWS access keys

# Setup environment
mkdir data
curl -O https://bootstrap.pypa.io/get-pip.py
sudo apt-get install python3-distutils
python3 get-pip.py
pip3 install stylegan2_pytorch
export PATH=$PATH:/home/ubuntu/.local/bin

# Download training data from S3
aws s3 sync s3://your-bucket-name ~/data
cd data
tar -xf train.tar.gz

# Run training in screen session (persists after SSH disconnect)
screen -S training
stylegan2_pytorch --data ./data --image-size 256 --num-train-steps 500000
# Ctrl+A, D to detach from screen
```

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

### Install AWS CLI and Configure

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Installs the AWS CLI using snap and configures it with access keys. Ensure you retrieve your keys from the AWS Management Console.

```bash
sudo snap install aws-cli --classic
aws configure
```

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

### Install StyleGAN2 PyTorch

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Install the package using pip. For Windows, ensure PyTorch and Torchvision are installed first.

```bash
$ pip install stylegan2_pytorch
```

```bash
$ conda install pytorch torchvision -c python
$ pip install stylegan2_pytorch
```

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

### Basic Training Command

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Start training a StyleGAN2 model using a specified dataset. Sample images and models are saved to default directories.

```bash
$ stylegan2_pytorch --data /path/to/images
```

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

### Install PyTorch-FID for FID Score Calculation

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Installs the pytorch-fid package, which is required for calculating FID scores during training.

```bash
$ pip install pytorch-fid
```

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

### Basic StyleGAN2 Training

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

Train a StyleGAN2 model on a dataset. Samples and models are saved to default directories. Use --new to start fresh training.

```bash
stylegan2_pytorch --data /path/to/images
```

```bash
stylegan2_pytorch --data /path/to/images \
    --name my-project \
    --results_dir /path/to/results \
    --models_dir /path/to/models
```

```bash
stylegan2_pytorch --new \
    --data /path/to/images \
    --name my-project \
    --image-size 256 \
    --batch-size 4
```

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

### Log Training Losses to Aim Experiment Tracker

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

Enable logging of training losses to the Aim experiment tracker. Requires Docker and Aim to be installed. Run the UI in a separate terminal.

```bash
# Enable logging (requires Docker and Aim)
stylegan2_pytorch --data /path/to/images --log
```

```bash
# In separate terminal, start Aim UI
aim up
```

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

### Programmatic Image Sampling with ModelLoader

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Demonstrates how to use the ModelLoader class to programmatically generate and save images. This involves loading the model, generating noise, passing it through the mapping network to get styles, and then converting styles to images.

```python
import torch
from torchvision.utils import save_image
from stylegan2_pytorch import ModelLoader

loader = ModelLoader(
    base_dir = '/path/to/directory',   # path to where you invoked the command line tool
    name = 'default'                   # the project name, defaults to 'default'
)

noise   = torch.randn(1, 512).cuda() # noise
styles  = loader.noise_to_styles(noise, trunc_psi = 0.7)  # pass through mapping network
images  = loader.styles_to_images(styles) # call the generator on intermediate style vectors

save_image(images, './sample.jpg') # save your images, or do whatever you desire
```

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

### Calculate FID Score During Training

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Starts the training process and configures it to calculate FID scores every 5000 iterations. FID results are logged to a specified file.

```bash
$ stylegan2_pytorch --data ./data --calculate-fid-every 5000
```

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

### Advanced Training Configuration

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Customize training with project names, output directories, network capacity, and image size. Training can be restarted with the `--new` flag.

```bash
$ stylegan2_pytorch --data /path/to/images --name my-project-name
```

```bash
$ stylegan2_pytorch --data /path/to/images --name my-project-name --results_dir /path/to/results/dir --models_dir /path/to/models/dir
```

```bash
$ stylegan2_pytorch --data /path/to/images --network-capacity 256
```

```bash
$ stylegan2_pytorch --new --data /path/to/images --name my-project-name --image-size 512 --batch-size 1 --gradient-accumulate-every 16 --network-capacity 10
```

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

### Enable Logging to Experiment Tracker (Aim)

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Enables logging of losses to an experiment tracker like Aim by passing the --log flag during training. Requires Docker and the Aim tool to be set up.

```bash
$ stylegan2_pytorch --data ./data --log
```

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

### Train with Transparent Images

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Enable support for training on images with transparency channels.

```bash
$ stylegan2_pytorch --data ./transparent/images/path --transparent
```

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

### Control Training Process with Trainer Class

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

Provides full control over the StyleGAN2 training process. Initialize the Trainer with custom settings, set the data source, load checkpoints, and run the training loop. Evaluation and interpolation can also be performed.

```python
from stylegan2_pytorch import Trainer

# Initialize trainer with custom settings
trainer = Trainer(
    name='my-experiment',
    results_dir='./results',
    models_dir='./models',
    image_size=128,
    network_capacity=16,
    batch_size=4,
    gradient_accumulate_every=6,
    learning_rate=2e-4,
    num_image_tiles=8,
    trunc_psi=0.75,
    aug_prob=0.25,
    aug_types=['translation', 'cutout'],
    attn_layers=[1],
    calculate_fid_every=5000
)

# Set data source
trainer.set_data_src('/path/to/images')

# Load existing checkpoint (optional)
trainer.load()  # Loads latest checkpoint
# trainer.load(50)  # Load specific checkpoint number

# Training loop
num_train_steps = 150000
while trainer.steps < num_train_steps:
    trainer.train()
    if trainer.steps % 50 == 0:
        trainer.print_log()

# Save final model
trainer.save(trainer.checkpoint_num)

# Generate evaluation images
trainer.evaluate(num=0, trunc=0.75)

# Generate interpolation
trainer.generate_interpolation(
    num=0,
    num_image_tiles=8,
    num_steps=100,
    save_frames=True
)
```

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

### Quantize Layers 1 and 2 with Dictionary Size 512

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

Use this command to enable feature quantization on specific layers of the discriminator. Requires specifying the layers and dictionary size.

```bash
stylegan2_pytorch --data /path/to/images \
    --fq-layers [1,2] \
    --fq-dict-size 512
```

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

### Enable Contrastive Loss Regularization

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

Activates contrastive loss regularization for training stability experiments. Specify the data path to begin.

```bash
stylegan2_pytorch --data /path/to/images --cl-reg
```

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

### Load Trained Models and Generate Images with ModelLoader

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

Demonstrates loading a trained StyleGAN2 model and generating images programmatically. Requires PyTorch and torchvision. Ensure the base directory and project name are correctly set.

```python
import torch
from torchvision.utils import save_image
from stylegan2_pytorch import ModelLoader

# Load a trained model
loader = ModelLoader(
    base_dir='/path/to/training/directory',  # Where stylegan2_pytorch was invoked
    name='default'                            # Project name (default: 'default')
)

# Generate random noise in latent space
noise = torch.randn(1, 512).cuda()

# Pass through mapping network to get style vectors
styles = loader.noise_to_styles(noise, trunc_psi=0.7)

# Generate images from style vectors
images = loader.styles_to_images(styles)

# Save generated images
save_image(images, './sample.jpg')

# Generate multiple images at once
batch_noise = torch.randn(16, 512).cuda()
batch_styles = loader.noise_to_styles(batch_noise, trunc_psi=0.75)
batch_images = loader.styles_to_images(batch_styles)
save_image(batch_images, './batch_sample.jpg', nrow=4)
```

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

### Enable Top-k Training for Generator

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Activates top-k training for the generator, which improves learning by zeroing out gradient contributions from samples deemed fake by the discriminator. Gamma controls the decay schedule for the top-k fraction.

```bash
$ stylegan2_pytorch --data ./data --top-k-training
```

```bash
$ stylegan2_pytorch --data ./data --top-k-training --generate-top-k-frac 0.5 --generate-top-k-gamma 0.99
```

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

### Multi-GPU Training

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Enable multi-GPU training by adding the `--multi-gpus` flag. The batch size is divided among available GPUs. Use `CUDA_VISIBLE_DEVICES` to specify GPUs.

```bash
$ stylegan2_pytorch --data ./data --multi-gpus --batch-size 32 --gradient-accumulate-every 1
```

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

### Generate Images from Checkpoint

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Generate images using the latest trained checkpoint.

```bash
$ stylegan2_pytorch  --generate
```

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

### StyleGAN2 Network Capacity Configuration

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

Adjust network capacity for different GPU memory constraints and quality needs. Supports high-resolution training and transparent image training.

```bash
stylegan2_pytorch --data /path/to/images --network-capacity 256
```

```bash
stylegan2_pytorch --data /path/to/images \
    --batch-size 3 \
    --gradient-accumulate-every 5 \
    --network-capacity 16
```

```bash
stylegan2_pytorch --data /path/to/images \
    --image-size 512 \
    --num-train-steps 1000000
```

```bash
stylegan2_pytorch --data /path/to/transparent/images --transparent
```

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

### StyleGAN2 Experimental Top-k Training

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

Enable top-k training to enhance generator learning by filtering gradient contributions. Configure fraction and gamma parameters for top-k selection.

```bash
stylegan2_pytorch --data /path/to/images --top-k-training
```

```bash
stylegan2_pytorch --data /path/to/images \
    --top-k-training \
    --generate-top-k-frac 0.5 \
    --generate-top-k-gamma 0.99
```

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

### Enable Dual Contrastive Loss

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

Activates dual contrastive loss for training stability experiments. Specify the data path to begin.

```bash
stylegan2_pytorch --data /path/to/images --dual-contrast-loss
```

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

### Set Training Steps

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Adjust the total number of training steps for higher resolution images or to prevent premature divergence.

```bash
$ stylegan2_pytorch --data ./data --image-size 512 --num-train-steps 1000000
```

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

### Use Non-Constant 4x4 Block

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Enable this option to learn the initial 4x4 block from the style vector 'w' instead of using a constant learned block. This is an experimental feature.

```bash
$ stylegan2_pytorch --data ./data --no-const
```

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

### Enable Contrastive Loss Regularization

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Activates contrastive loss regularization on the discriminator, which may improve training stability and final results.

```bash
$ stylegan2_pytorch --data ./data --cl-reg
```

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

### StyleGAN2 Multi-GPU Training

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

Leverage multiple GPUs for accelerated training. The batch size is distributed across available GPUs. Can also restrict usage via CUDA_VISIBLE_DEVICES.

```bash
stylegan2_pytorch --data /path/to/images \
    --multi-gpus \
    --batch-size 32 \
    --gradient-accumulate-every 1
```

```bash
CUDA_VISIBLE_DEVICES=0,2,3 stylegan2_pytorch --data /path/to/images --multi-gpus
```

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

### Optimize Memory Usage

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Adjust batch size, gradient accumulation, and network capacity to fit the model within limited GPU memory.

```bash
$ stylegan2_pytorch --data /path/to/data \
    --batch-size 3 \
    --gradient-accumulate-every 5 \
    --network-capacity 16
```

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

### Load Specific Checkpoint for Generation

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Generate images by loading from a specific previous checkpoint number.

```bash
$ stylegan2_pytorch --generate --load-from {checkpoint number}
```

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

### Configure Differentiable Augmentation

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Apply differentiable augmentation to the discriminator to improve training with limited datasets.

```bash
# find a suitable probability between 0. -> 0.7 at maximum
$ stylegan2_pytorch --data ./data --aug-prob 0.25
```

```bash
# make sure there are no spaces between items!
$ stylegan2_pytorch --data ./data --aug-prob 0.25 --aug-types [translation,cutout,color]
```

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

### Generate Interpolation Video

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Create a video by interpolating between two random points in the latent space. Individual frames can be saved.

```bash
$ stylegan2_pytorch --generate-interpolation --interpolation-num-steps 100
```

```bash
$ stylegan2_pytorch --generate-interpolation --save-frames
```

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

### StyleGAN2 Image Generation

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

Generate images from trained StyleGAN2 checkpoints. Supports loading specific checkpoints and applying truncation for quality vs. variety trade-off. Can also generate interpolation videos.

```bash
stylegan2_pytorch --generate
```

```bash
stylegan2_pytorch --generate --load-from 50
```

```bash
stylegan2_pytorch --generate --trunc-psi 0.5
```

```bash
stylegan2_pytorch --generate-interpolation --interpolation-num-steps 100
```

```bash
stylegan2_pytorch --generate-interpolation --save-frames
```

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

### Enable Dual Contrastive Loss

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Activate the dual contrastive loss between real and fake logits to potentially improve image quality. The default loss is hinge loss.

```bash
$ stylegan2_pytorch --data ./data --dual-contrast-loss
```

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

### Enable Feature Quantization

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Enables feature quantization for intermediate discriminator representations. Specify the layers to quantize and the dictionary size for each layer.

```bash
# feature quantize layers 1 and 2, with a dictionary size of 512 each
# do not put a space after the comma in the list!
$ stylegan2_pytorch --data ./data --fq-layers [1,2] --fq-dict-size 512
```

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

### Combine Multiple Augmentation Types in StyleGAN2 PyTorch

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

Demonstrates how to combine multiple augmentation types for image processing. Ensure 'images' is a pre-defined variable containing the image data.

```python
augmented = DiffAugment(images, types=['translation', 'cutout', 'color'])
```

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

### Disable Non-constant 4x4 Initial Block

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

Disables the non-constant 4x4 initial block for training stability experiments. Specify the data path to begin.

```bash
stylegan2_pytorch --data /path/to/images --no-const
```

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

### Enable Relativistic Discriminator Loss

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Enables the relativistic discriminator loss, proposed to stabilize GAN training. Mixed results have been reported, but it is available for experimentation.

```bash
$ stylegan2_pytorch --data ./data --rel-disc-loss
```

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

### Access StyleGAN2 Model Components Directly

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

Allows direct access to the underlying StyleGAN2 model components (Vectorizer, Generator, Discriminator) for advanced use cases. Requires PyTorch. Latent vectors, noise, and style vectors are generated and passed through the model to produce images.

```python
import torch
from stylegan2_pytorch import StyleGAN2

# Initialize StyleGAN2 model
model = StyleGAN2(
    image_size=128,
    latent_dim=512,
    network_capacity=16,
    style_depth=8,
    transparent=False,
    attn_layers=[1, 2],
    fq_layers=[],
    fq_dict_size=256,
    fp16=False
)

# Model components:
# model.S  - Style Vectorizer (mapping network)
# model.G  - Generator
# model.D  - Discriminator
# model.SE - EMA Style Vectorizer
# model.GE - EMA Generator
# model.D_aug - Augmented Discriminator wrapper

# Generate images manually
batch_size = 4
latent_dim = 512
num_layers = model.G.num_layers
image_size = model.G.image_size

# Create latent vectors and noise
z = torch.randn(batch_size, latent_dim).cuda()
input_noise = torch.FloatTensor(batch_size, image_size, image_size, 1).uniform_(0., 1.).cuda()

# Pass through mapping network
w = model.S(z)
w_broadcast = w.unsqueeze(1).expand(-1, num_layers, -1)

# Generate images
images = model.G(w_broadcast, input_noise)
images = images.clamp_(0., 1.)
```

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

### Enable Relativistic Discriminator Loss

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

Activates relativistic discriminator loss for training stability experiments. Specify the data path to begin.

```bash
stylegan2_pytorch --data /path/to/images --rel-disc-loss
```

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

### Trainer Class

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

The Trainer class provides full control over the training process, including configuration, data loading, and checkpoint management.

```APIDOC
## Trainer Class

### Description
Handles the training loop, model saving/loading, and evaluation metrics for StyleGAN2.

### Methods
- **set_data_src(path)**: Sets the directory for training images.
- **train()**: Executes a single training step.
- **save(checkpoint_num)**: Saves the current model state.
- **load(checkpoint_num)**: Loads a model checkpoint.
- **evaluate(num, trunc)**: Generates evaluation images.

### Request Example
```python
from stylegan2_pytorch import Trainer
trainer = Trainer(name='my-experiment', image_size=128, batch_size=4)
trainer.set_data_src('/path/to/images')
trainer.train()
```
```

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

### StyleGAN2 Attention Layer Configuration

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

Incorporate self-attention mechanisms into the network architecture to enhance generation quality, especially for structured datasets. Specify layers by index.

```bash
stylegan2_pytorch --data /path/to/images --attn-layers 1
```

```bash
stylegan2_pytorch --data /path/to/images --attn-layers [1,2]
```

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

### StyleGAN2 Differentiable Augmentation

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

Enable differentiable augmentation for training with limited datasets. Control augmentation probability and specify augmentation types like translation, cutout, or color transforms.

```bash
stylegan2_pytorch --data /path/to/images --aug-prob 0.25
```

```bash
stylegan2_pytorch --data /path/to/images \
    --aug-prob 0.25 \
    --aug-types [translation,cutout,color]
```

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

### Latent Space Truncation for Generation

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Control sample quality versus variety by truncating latent values. Lower `--trunc-psi` values improve sample appearance but reduce variety.

```bash
$ stylegan2_pytorch --generate --trunc-psi 0.5
```

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

### Enable Self-Attention Layers

Source: https://github.com/lucidrains/stylegan2-pytorch/blob/master/README.md

Add self-attention to specific discriminator and generator layers to improve generation quality.

```python
# add self attention after the output of layer 1
$ stylegan2_pytorch --data ./data --attn-layers 1
```

```python
# add self attention after the output of layers 1 and 2
# do not put a space after the comma in the list!
$ stylegan2_pytorch --data ./data --attn-layers [1,2]
```

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

### StyleGAN2 Model Class

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

Direct access to the underlying StyleGAN2 model components for advanced customization and manual generation.

```APIDOC
## StyleGAN2 Model Class

### Description
Provides access to the mapping network (S), generator (G), and discriminator (D) components.

### Components
- **model.S**: Style Vectorizer (mapping network)
- **model.G**: Generator
- **model.D**: Discriminator

### Request Example
```python
from stylegan2_pytorch import StyleGAN2
model = StyleGAN2(image_size=128, latent_dim=512)
z = torch.randn(4, 512).cuda()
w = model.S(z)
images = model.G(w.unsqueeze(1), input_noise)
```
```

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

### Apply Differentiable Augmentations with DiffAugment

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

Applies differentiable augmentations to image batches during training. Requires PyTorch. Supports various augmentation types like 'translation' and 'color'.

```python
from stylegan2_pytorch.diff_augment import DiffAugment
import torch

# Create sample image batch (B, C, H, W)
images = torch.randn(4, 3, 128, 128).cuda()

# Apply translation and cutout augmentations
augmented = DiffAugment(images, types=['translation', 'cutout'])

# Apply color augmentations (brightness, saturation, contrast)
augmented = DiffAugment(images, types=['color'])

# Available augmentation types:
# 'translation' - Random translation

```

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

### ModelLoader Class

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

The ModelLoader class is used to load trained StyleGAN2 models and perform inference, such as generating images from latent noise.

```APIDOC
## ModelLoader Class

### Description
Provides an interface to load trained models from a directory and generate images from latent space vectors.

### Methods
- **ModelLoader(base_dir, name)**: Initializes the loader.
- **noise_to_styles(noise, trunc_psi)**: Maps random noise to style vectors.
- **styles_to_images(styles)**: Generates images from style vectors.

### Request Example
```python
from stylegan2_pytorch import ModelLoader
loader = ModelLoader(base_dir='/path/to/training', name='default')
noise = torch.randn(1, 512).cuda()
styles = loader.noise_to_styles(noise, trunc_psi=0.7)
images = loader.styles_to_images(styles)
```
```

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

### StyleGAN2 FID Score Calculation

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

Periodically calculate the Fréchet Inception Distance (FID) during training to monitor image generation quality. Requires the 'pytorch-fid' package.

```bash
pip install pytorch-fid
```

```bash
stylegan2_pytorch --data /path/to/images --calculate-fid-every 5000
```

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