### Install x-unet

Source: https://github.com/lucidrains/x-unet/blob/main/README.md

Install the package via pip.

```bash
$ pip install x-unet
```

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

### Advanced XUnet Configuration with Attention and ConvNeXt

Source: https://context7.com/lucidrains/x-unet/llms.txt

Customize XUnet with advanced options including self-attention, ConvNeXt blocks, and fine-grained control over dimensions and block types. This example demonstrates binary segmentation.

```python
import torch
from x_unet import XUnet

# Advanced configuration with attention and ConvNeXt
unet_advanced = XUnet(
    dim = 64,
    init_dim = 64,
    out_dim = 1,
    channels = 3,
    dim_mults = (1, 2, 4, 8),
    num_blocks_per_stage = (2, 2, 2, 2),
    num_self_attn_per_stage = (0, 0, 1, 1),
    nested_unet_depths = (0, 0, 2, 4),
    nested_unet_dim = 32,
    use_convnext = True,
    skip_scale = 2 ** -0.5,
    attn_heads = (4, 4, 8, 8),
    attn_dim_head = (32, 32, 64, 64),
)

# Binary segmentation example
img = torch.randn(2, 3, 256, 256)
mask = unet_advanced(img)
print(f"Segmentation mask shape: {mask.shape}")

# Apply sigmoid for probability map
prob_map = torch.sigmoid(mask)
binary_mask = (prob_map > 0.5).float()
```

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

### Create and Use a Basic 2D XUnet Model

Source: https://context7.com/lucidrains/x-unet/llms.txt

Instantiate a 2D XUnet model for image segmentation. The model can be configured with dimensions, channels, and nested U-Net depths. Perform a forward pass to get segmentation output.

```python
import torch
from x_unet import XUnet

# Basic 2D image segmentation model
unet = XUnet(
    dim = 64,
    channels = 3,
    dim_mults = (1, 2, 4, 8),
    nested_unet_depths = (7, 4, 2, 1),
    consolidate_upsample_fmaps = True,
)

# Forward pass with 2D image
img = torch.randn(1, 3, 256, 256)
out = unet(img)
print(f"Input shape: {img.shape}, Output shape: {out.shape}")
```

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

### Initialize 3D XUnet

Source: https://github.com/lucidrains/x-unet/blob/main/README.md

Configure and run a 3D U-net model for video or volumetric data.

```python
import torch
from x_unet import XUnet

unet = XUnet(
    dim = 64,
    frame_kernel_size = 3,                 # set this to greater than 1
    channels = 3,
    dim_mults = (1, 2, 4, 8),
    nested_unet_depths = (5, 4, 2, 1),     # nested unet depths, from unet-squared paper
    consolidate_upsample_fmaps = True,     # whether to consolidate outputs from all upsample blocks, used in unet-squared paper
    weight_standardize = True
)

video = torch.randn(1, 3, 10, 128, 128)    # (batch, channels, frames, height, width)
out = unet(video) # (1, 3, 10, 128, 128)
```

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

### Initialize 2D XUnet

Source: https://github.com/lucidrains/x-unet/blob/main/README.md

Configure and run a 2D U-net model for image processing.

```python
import torch
from x_unet import XUnet

unet = XUnet(
    dim = 64,
    channels = 3,
    dim_mults = (1, 2, 4, 8),
    nested_unet_depths = (7, 4, 2, 1),     # nested unet depths, from unet-squared paper
    consolidate_upsample_fmaps = True,     # whether to consolidate outputs from all upsample blocks, used in unet-squared paper
)

img = torch.randn(1, 3, 256, 256)
out = unet(img) # (1, 3, 256, 256)
```

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

### Initialize 3D Nested U-Net

Source: https://context7.com/lucidrains/x-unet/llms.txt

Configure the NestedResidualUnet for 3D data by setting frame_kernel_size greater than 1.

```python
x_3d = torch.randn(1, 64, 8, 64, 64)
nested_unet_3d = NestedResidualUnet(
    dim = 64,
    depth = 3,
    M = 32,
    frame_kernel_size = 3,
    add_residual = True
)
out_3d = nested_unet_3d(x_3d)
print(f"3D Nested U-Net output shape: {out_3d.shape}")
```

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

### Create and Use a NestedResidualUnet Block

Source: https://context7.com/lucidrains/x-unet/llms.txt

Instantiate a standalone NestedResidualUnet module, which is a building block inspired by the U²-Net paper. It can be used for 2D or 3D data by adjusting `frame_kernel_size`. The forward pass expects 5D input.

```python
import torch
from x_unet import NestedResidualUnet

# Create a nested residual U-Net block
nested_unet = NestedResidualUnet(
    dim = 64,
    depth = 4,
    M = 32,
    frame_kernel_size = 1,
    add_residual = True,
    skip_scale = 2 ** -0.5,
    weight_standardize = False
)

# Forward pass - expects 5D input (batch, channels, frames, height, width)
# For 2D images, frames dimension should be 1
x = torch.randn(1, 64, 1, 64, 64)
out = nested_unet(x)
print(f"Nested U-Net output shape: {out.shape}")
```

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

### Create and Use a 3D XUnet Model for Volumetric Data

Source: https://context7.com/lucidrains/x-unet/llms.txt

Configure XUnet for 3D data processing by setting `frame_kernel_size` greater than 1. This enables 3D convolutions for volumetric or video segmentation. The forward pass expects 5D input.

```python
import torch
from x_unet import XUnet

# 3D volumetric/video segmentation model
unet_3d = XUnet(
    dim = 64,
    frame_kernel_size = 3,
    channels = 3,
    dim_mults = (1, 2, 4, 8),
    nested_unet_depths = (5, 4, 2, 1),
    consolidate_upsample_fmaps = True,
    weight_standardize = True
)

# Forward pass with 3D video/volume data
# Shape: (batch, channels, frames, height, width)
video = torch.randn(1, 3, 10, 128, 128)
out = unet_3d(video)
print(f"Input shape: {video.shape}, Output shape: {out.shape}")
```

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

### Train XUnet for Medical Segmentation

Source: https://context7.com/lucidrains/x-unet/llms.txt

Complete training loop for binary segmentation using BCEWithLogitsLoss and AdamW optimizer.

```python
import torch
import torch.nn as nn
import torch.optim as optim
from x_unet import XUnet

# Initialize model for binary segmentation
model = XUnet(
    dim = 64,
    channels = 1,                          # Grayscale medical images
    out_dim = 1,                           # Binary segmentation output
    dim_mults = (1, 2, 4, 8),
    nested_unet_depths = (4, 3, 2, 1),
    consolidate_upsample_fmaps = True,
    weight_standardize = True,
    num_self_attn_per_stage = (0, 0, 0, 1),
)

# Setup training
optimizer = optim.AdamW(model.parameters(), lr=1e-4)
criterion = nn.BCEWithLogitsLoss()

# Training step
model.train()
for epoch in range(10):
    # Simulated batch: grayscale images and binary masks
    images = torch.randn(4, 1, 256, 256)
    masks = torch.randint(0, 2, (4, 1, 256, 256)).float()

    optimizer.zero_grad()
    predictions = model(images)
    loss = criterion(predictions, masks)
    loss.backward()
    optimizer.step()

    # Calculate metrics
    with torch.no_grad():
        pred_binary = (torch.sigmoid(predictions) > 0.5).float()
        dice = (2 * (pred_binary * masks).sum()) / (pred_binary.sum() + masks.sum() + 1e-8)

    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}, Dice: {dice.item():.4f}")
```

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

### Perform Model Inference

Source: https://context7.com/lucidrains/x-unet/llms.txt

Apply a trained model to input tensors with sigmoid activation and thresholding for binary mask generation.

```python
import torch
from x_unet import XUnet

# Load trained model
model = XUnet(
    dim = 64,
    channels = 3,
    out_dim = 1,
    dim_mults = (1, 2, 4, 8),
    nested_unet_depths = (4, 3, 2, 1),
    consolidate_upsample_fmaps = True,
)
model.eval()

# Inference function
@torch.no_grad()
def predict_segmentation(model, image_tensor, threshold=0.5):
    """
    Perform segmentation inference.

    Args:
        model: Trained XUnet model
        image_tensor: Input tensor of shape (B, C, H, W)
        threshold: Binary threshold for segmentation

    Returns:
        Binary segmentation mask
    """
    logits = model(image_tensor)
    probabilities = torch.sigmoid(logits)
    binary_mask = (probabilities > threshold).float()
    return binary_mask, probabilities

# Example inference
test_image = torch.randn(1, 3, 256, 256)
binary_mask, prob_map = predict_segmentation(model, test_image)

print(f"Input shape: {test_image.shape}")
print(f"Binary mask shape: {binary_mask.shape}")
print(f"Probability range: [{prob_map.min():.3f}, {prob_map.max():.3f}]")
```

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

### Research Citations

Source: https://github.com/lucidrains/x-unet/blob/main/README.md

BibTeX citations for the research papers implemented or referenced in the project.

```bibtex
@article{Ronneberger2015UNetCN,
    title   = {U-Net: Convolutional Networks for Biomedical Image Segmentation},
    author  = {Olaf Ronneberger and Philipp Fischer and Thomas Brox},
    journal = {ArXiv},
    year    = {2015},
    volume  = {abs/1505.04597}
}
```

```bibtex
@article{Qin2020U2NetGD,
    title   = {U2-Net: Going Deeper with Nested U-Structure for Salient Object Detection},
    author  = {Xuebin Qin and Zichen Vincent Zhang and Chenyang Huang and Masood Dehghan and Osmar R Zaiane and Martin J{"a}gersand},
    journal = {ArXiv},
    year    = {2020},
    volume  = {abs/2005.09007}
}
```

```bibtex
@inproceedings{Henry2020QueryKeyNF,
    title   = {Query-Key Normalization for Transformers},
    author  = {Alex Henry and Prudhvi Raj Dachapally and Shubham Vivek Pawar and Yuxuan Chen},
    booktitle = {FINDINGS},
    year    = {2020}
}
```

```bibtex
@article{Qiao2019WeightS,
    title   = {Weight Standardization},
    author  = {Siyuan Qiao and Huiyu Wang and Chenxi Liu and Wei Shen and Alan Loddon Yuille},
    journal = {ArXiv},
    year    = {2019},
    volume  = {abs/1903.10520}
}
```

```bibtex
@article{Shleifer2021NormFormerIT,
    title   = {NormFormer: Improved Transformer Pretraining with Extra Normalization},
    author  = {Sam Shleifer and Jason Weston and Myle Ott},
    journal = {ArXiv},
    year    = {2021},
    volume  = {abs/2110.09456}
}
```

```bibtex
@article{Sunkara2022NoMS,
    title   = {No More Strided Convolutions or Pooling: A New CNN Building Block for Low-Resolution Images and Small Objects},
    author  = {Raja Sunkara and Tie Luo},
    journal = {ArXiv},
    year    = {2022},
    volume  = {abs/2208.03641}
}
```

```bibtex
@inproceedings{Woo2023ConvNeXtVC,
    title   = {ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders},
    author  = {Sanghyun Woo and Shoubhik Debnath and Ronghang Hu and Xinlei Chen and Zhuang Liu and In-So Kweon and Saining Xie},
    year    = {2023}
}
```

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