# T Lora Single Image Diffusion Customization

> Personalize diffusion models to learn a concept from a single image without overfitting by using timestep-dependent rank masking and orthogonal weight initialization, enabling faithful concept reproduction while maintaining text-guided control.

- Skill: `adu2021/t-lora-single-image-diffusion-customization` (Agent Skill)
- Install (CLI): `npx skillmds@latest add adu2021/t-lora-single-image-diffusion-customization`
- Raw SKILL.md: https://api.skillmd.com/api/skills/adu2021/t-lora-single-image-diffusion-customization/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: adu2021 (https://skillmd.com/u/adu2021)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/adu2021/t-lora-single-image-diffusion-customization

---


# T-LoRA: Timestep-Dependent Personalization of Diffusion Models

Training diffusion models on a single concept image is notoriously difficult. Standard LoRA quickly overfits: the model memorizes the exact image instead of learning the concept. The root cause is that different denoising timesteps have different susceptibility to overfitting. Early timesteps (high noise) have natural regularization. Late timesteps (low noise, near-pixel level) are prone to memorizing exact pixel patterns. T-LoRA addresses this by dynamically adjusting adapter rank as a function of timestep: fewer parameters at noisy timesteps, more at clean ones.

A complementary insight: standard LoRA matrices accumulate linear dependence that undermines selective activation. T-LoRA applies orthogonal initialization using SVD components, ensuring that masked rank subsets remain effective for meaningful feature learning.

## Core Concept

The challenge is learning a visual concept (a person, object, style) from one image while keeping the model generalizable. T-LoRA exploits the fact that the denoising process has natural structure: early timesteps handle coarse structure and are hard to overfit, late timesteps handle details and are easy to overfit. By allocating fewer adapter parameters early and more late, the model can focus on learning genuine concept features rather than pixel memorization.

Orthogonal weight initialization complements this by ensuring that even when you mask out certain rank components, the remaining ones stay active and meaningful. Without orthogonality, masking can create dead components.

## Architecture Overview

- **Timestep-Dependent Rank Function**: r(t) = floor((r - r_min) * (T - t) / T) + r_min, allocating higher rank at lower timesteps
- **Rank Masking**: Diagonal matrices selectively activate adapter components during training and inference
- **Orthogonal LoRA Initialization**: Decompose random matrices via SVD, use lower singular components to avoid overfitting
- **Integrated T-LoRA**: Combines both mechanisms for optimal performance
- **Target Models**: Tested on Stable Diffusion-XL and FLUX-1.dev

## Implementation

### Step 1: Analyze Timestep-Specific Overfitting

First, diagnose which timesteps overfit most by training with fixed-rank adapters and measuring concept fidelity vs. text alignment:

```python
import torch
import torch.nn as nn
from diffusers import StableDiffusionXLPipeline
from peft import get_peft_model, LoraConfig

def diagnose_overfitting_per_timestep(concept_image, concept_name,
                                      test_prompts, num_timesteps=1000):
    """
    Train fixed-rank LoRA and measure overfitting across timesteps.
    Reveals which timesteps are most prone to memorization.
    """
    pipeline = StableDiffusionXLPipeline.from_pretrained(
        "stabilityai/stable-diffusion-xl-base-1.0"
    )
    unet = pipeline.unet

    # Create LoRA with fixed rank
    lora_config = LoraConfig(
        r=64,
        lora_alpha=128,
        target_modules=["to_q", "to_v"],
        lora_dropout=0.0,  # No dropout for diagnosis
        bias="none"
    )
    lora_unet = get_peft_model(unet, lora_config)

    # Train on single image
    optimizer = torch.optim.Adam(lora_unet.parameters(), lr=1e-4)

    for step in range(500):
        # Noisy batch sampling (random timestep per sample)
        timesteps = torch.randint(0, num_timesteps, (4,))
        noisy_image = add_noise_to_concept(concept_image, timesteps[0])

        # Forward through denoiser
        noise_pred = lora_unet(
            noisy_image,
            timesteps[0],
            encoder_hidden_states=encode_text(concept_name, pipeline)
        ).sample

        # Loss: predict noise (training objective)
        loss = F.mse_loss(noise_pred, torch.randn_like(noise_pred))
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

    # Evaluate: concept fidelity and text alignment per timestep
    fidelity_scores = {}
    alignment_scores = {}

    for t in range(0, num_timesteps, 100):
        # Sample from concept at timestep t
        samples_t = generate_from_concept(
            lora_unet, pipeline,
            concept_name,
            timestep_focus=t,
            num_samples=5
        )

        # Measure fidelity (concept recognition) via CLIP
        concept_score = measure_clip_similarity(
            samples_t, concept_image
        )
        fidelity_scores[t] = concept_score

        # Measure alignment with random prompts
        random_prompts = ["a cat", "a dog", "a car"]
        alignment = measure_prompt_alignment(samples_t, random_prompts)
        alignment_scores[t] = alignment

    # Visualize results
    print("Fidelity by timestep:", fidelity_scores)
    print("Alignment by timestep:", alignment_scores)
    print("Conclusion: higher timesteps likely show memorization")

    return fidelity_scores, alignment_scores

def add_noise_to_concept(image, timestep, scheduler_config=None):
    """Add noise at a specific timestep to the concept image."""
    from diffusers.schedulers import DDPMScheduler
    scheduler = DDPMScheduler.from_config(scheduler_config or {})

    noise = torch.randn_like(image)
    noisy = scheduler.add_noise(image, noise, timestep)
    return noisy
```

### Step 2: Implement Vanilla T-LoRA with Rank Masking

Allocate fewer parameters at high timesteps (noisy) and more at low timesteps (clean):

```python
class TLoRA(nn.Module):
    def __init__(self, base_module, r_min=4, r_max=64, num_timesteps=1000):
        super().__init__()
        self.base_module = base_module
        self.r_min = r_min
        self.r_max = r_max
        self.num_timesteps = num_timesteps

        # LoRA weight matrices (full rank)
        self.lora_a = nn.Parameter(torch.randn(base_module.in_features, r_max) * 0.01)
        self.lora_b = nn.Parameter(torch.randn(r_max, base_module.out_features) * 0.01)

        # Timestep-dependent rank function
        # Higher rank at low timesteps (clean), lower at high timesteps (noisy)
        self.timestep_to_rank = self._make_rank_schedule()

    def _make_rank_schedule(self):
        """Create mapping from timestep to active rank."""
        schedule = {}
        for t in range(self.num_timesteps):
            # Rank increases as timestep decreases (less noise = higher rank)
            r_t = int((self.r_max - self.r_min) * (1 - t / self.num_timesteps) + self.r_min)
            schedule[t] = r_t
        return schedule

    def forward(self, x, timestep):
        """Apply LoRA with timestep-dependent rank masking."""
        # Get active rank for this timestep
        r_active = self.timestep_to_rank.get(int(timestep.item()), self.r_max)

        # Create mask: only use first r_active columns/rows
        mask_a = torch.zeros(self.lora_a.shape[1], device=self.lora_a.device)
        mask_a[:r_active] = 1.0

        mask_b = torch.zeros(self.lora_b.shape[0], device=self.lora_b.device)
        mask_b[:r_active] = 1.0

        # Apply masks
        lora_a_masked = self.lora_a * mask_a
        lora_b_masked = self.lora_b * mask_b

        # LoRA computation: x + x @ A @ B
        lora_out = x @ lora_a_masked @ lora_b_masked

        # Base module + LoRA
        base_out = self.base_module(x)
        return base_out + lora_out

def apply_tora_to_unet(unet, r_min=4, r_max=64, num_timesteps=1000):
    """Replace linear layers in UNet with T-LoRA modules."""
    for name, module in unet.named_modules():
        if isinstance(module, nn.Linear) and "to_q" in name or "to_v" in name:
            tora_module = TLoRA(module, r_min, r_max, num_timesteps)
            # Replace in-place (simplified; in practice use proper module replacement)
            setattr(unet, name, tora_module)

    return unet
```

### Step 3: Implement Orthogonal Weight Initialization (Ortho-LoRA)

Initialize LoRA weights using orthogonal components from SVD to prevent linear dependence:

```python
class OrthoLoRA(nn.Module):
    """LoRA with orthogonal weight initialization to prevent overfitting."""

    def __init__(self, base_module, r=64, lora_alpha=128):
        super().__init__()
        self.base_module = base_module
        self.r = r
        self.lora_alpha = lora_alpha

        # Orthogonal initialization using SVD
        self.lora_a = nn.Parameter(self._ortho_init(base_module.in_features, r))
        self.lora_b = nn.Parameter(self._ortho_init(r, base_module.out_features))

        # Scaling factor
        self.scale = lora_alpha / r

    def _ortho_init(self, in_dim, out_dim):
        """
        Initialize with orthogonal components from SVD.
        Use lower singular components (least significant) to avoid overfitting.
        """
        # Create random matrix
        random_matrix = torch.randn(in_dim, out_dim)

        # SVD decomposition
        U, S, Vt = torch.linalg.svd(random_matrix, full_matrices=False)

        # Use lower singular components (least significant)
        # This provides regularization by using less dominant features
        if in_dim >= out_dim:
            ortho = U[:, :out_dim]
        else:
            ortho = Vt[:in_dim, :]

        return ortho * 0.01  # Small scale

    def forward(self, x):
        """Apply orthogonal LoRA."""
        lora_out = (x @ self.lora_a) @ self.lora_b * self.scale
        base_out = self.base_module(x)
        return base_out + lora_out
```

### Step 4: Integrated T-LoRA (Timestep-Dependent + Orthogonal)

Combine both mechanisms for robust single-image personalization:

```python
class IntegratedTLoRA(nn.Module):
    """Combined T-LoRA: timestep-dependent rank + orthogonal initialization."""

    def __init__(self, base_module, r_min=4, r_max=64, num_timesteps=1000):
        super().__init__()
        self.base_module = base_module
        self.r_min = r_min
        self.r_max = r_max
        self.num_timesteps = num_timesteps

        # Orthogonal LoRA matrices
        self.lora_a = nn.Parameter(self._ortho_init(base_module.in_features, r_max))
        self.lora_b = nn.Parameter(self._ortho_init(r_max, base_module.out_features))

    def _ortho_init(self, in_dim, out_dim):
        """Orthogonal initialization."""
        random_matrix = torch.randn(in_dim, out_dim)
        U, S, Vt = torch.linalg.svd(random_matrix, full_matrices=False)
        if in_dim >= out_dim:
            return U[:, :out_dim] * 0.01
        else:
            return Vt[:in_dim, :] * 0.01

    def _get_rank_for_timestep(self, timestep):
        """Get active rank based on timestep."""
        t = timestep.item() if isinstance(timestep, torch.Tensor) else timestep
        r_t = int((self.r_max - self.r_min) * (1 - t / self.num_timesteps) + self.r_min)
        return max(self.r_min, min(self.r_max, r_t))

    def forward(self, x, timestep):
        """Apply T-LoRA with timestep-dependent rank masking."""
        r_active = self._get_rank_for_timestep(timestep)

        # Mask to active rank
        mask_a = torch.zeros_like(self.lora_a)
        mask_a[:, :r_active] = 1.0
        mask_b = torch.zeros_like(self.lora_b)
        mask_b[:r_active, :] = 1.0

        lora_a_masked = self.lora_a * mask_a
        lora_b_masked = self.lora_b * mask_b

        # Forward pass
        lora_out = (x @ lora_a_masked) @ lora_b_masked
        base_out = self.base_module(x)

        return base_out + lora_out

def train_concept_with_tlora(concept_image, concept_name, model_name="stabilityai/stable-diffusion-xl-base-1.0"):
    """Train T-LoRA on a single concept image."""
    pipeline = StableDiffusionXLPipeline.from_pretrained(model_name)
    unet = pipeline.unet

    # Apply T-LoRA to UNet attention layers
    tora_modules = {}
    for name, module in unet.named_modules():
        if isinstance(module, nn.Linear) and ("to_q" in name or "to_v" in name):
            tora_mod = IntegratedTLoRA(module, r_min=4, r_max=64)
            tora_modules[name] = tora_mod

    # Training loop
    optimizer = torch.optim.Adam(
        [p for m in tora_modules.values() for p in m.parameters()],
        lr=1e-4
    )

    for step in range(800):
        # Random timestep for this step
        t = torch.randint(0, 1000, (1,))

        # Add noise to concept image
        noisy_concept = add_noise_to_concept(concept_image, t)

        # Random prompt containing concept name
        prompts = [
            f"a photo of {concept_name}",
            f"{concept_name} in the style of Van Gogh",
            f"close-up of {concept_name}",
            f"{concept_name}, professional photography"
        ]
        prompt = prompts[step % len(prompts)]

        # Encode text
        text_embeddings = pipeline.encode_prompt(prompt)

        # Forward through UNet (with T-LoRA modules intercepting)
        noise_pred = unet(
            noisy_concept,
            t,
            encoder_hidden_states=text_embeddings
        ).sample

        # Loss
        loss = F.mse_loss(noise_pred, torch.randn_like(noise_pred))
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

        if step % 100 == 0:
            print(f"Step {step}: loss = {loss.item():.4f}")

    return pipeline, tora_modules
```

## Practical Guidance

| Component | Recommended Value | Notes |
|---|---|---|
| r_min (minimum rank) | 4 | Constrains high-timestep (noisy) parameters |
| r_max (maximum rank) | 64 | Can go to 128 for complex concepts |
| Learning Rate | 1e-4 | Conservative to avoid instability |
| Training Steps | 500-800 | SD-XL; fewer for simpler models |
| Batch Size | 1 | Single image personalization |
| Optimizer | AdamW | Standard choice |
| Timestep Range | 0-1000 | Full DDPM schedule |
| Orthogonal Init | Yes | Critical for preventing overfitting |
| Rank Mask | Yes | Essential for timestep-specific control |
| CLIP Similarity | > 0.85 | Target for concept fidelity |
| Prompt Alignment | > 0.75 | Target for maintaining text control |

**When to use T-LoRA:**
- Single-image personalization (concept learning from one photo)
- Applications prioritizing concept fidelity over memory efficiency
- Fine art, illustration, or photographic style transfer
- Scenarios where both concept accuracy and text control matter

**When NOT to use T-LoRA:**
- Multi-image personalization (standard DreamBooth scales better)
- Memory-constrained deployment (LoRA still requires adapter parameters)
- Extremely complex concepts requiring hundreds of reference images
- Real-time inference (training time is acceptable, inference is fast)

**Common pitfalls:**
- Not including orthogonal initialization, causing rank masking to be ineffective
- r_min too high (> 8), losing ability to regulate overfitting
- Timestep-dependent rank too aggressive (inverted), encouraging memorization
- Training for too few steps (< 300), concept not properly learned
- Using too-high learning rate, causing instability
- Not normalizing concept image to [0, 1] range
- Forgetting to vary prompts during training, leading to prompt-specific overfitting

## Reference

Wang, X., Li, X., Chen, H., & Zhou, L. (2025). T-LoRA: Single Image Diffusion Model Customization Without Overfitting. arXiv:2507.05964. https://arxiv.org/abs/2507.05964