8 files changed, 133 insertions, 1091 deletions

diff --git a/infer.py b/infer.py
index b29b136..507d0cf 100644
--- a/infer.py
+++ b/infer.py
@@ -28,7 +28,7 @@ from transformers import CLIPTextModel
 from models.clip.embeddings import patch_managed_embeddings
 from models.clip.tokenizer import MultiCLIPTokenizer
 from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
-from common import load_config, load_embeddings_from_dir
+from util import load_config, load_embeddings_from_dir
 
 
 torch.backends.cuda.matmul.allow_tf32 = True
@@ -192,12 +192,12 @@ def save_args(basepath, args, extra={}):
 
 
 def load_embeddings(pipeline, embeddings_dir):
-    added_tokens = load_embeddings_from_dir(
+    added_tokens, added_ids = load_embeddings_from_dir(
         pipeline.tokenizer,
         pipeline.text_encoder.text_model.embeddings,
         Path(embeddings_dir)
     )
-    print(f"Added {len(added_tokens)} tokens from embeddings dir: {added_tokens}")
+    print(f"Added {len(added_tokens)} tokens from embeddings dir: {zip(added_tokens, added_ids)}")
 
 
 def create_pipeline(model, dtype):
diff --git a/models/clip/embeddings.py b/models/clip/embeddings.py
index 1280ebd..fb639f1 100644
--- a/models/clip/embeddings.py
+++ b/models/clip/embeddings.py
@@ -53,6 +53,8 @@ class ManagedCLIPTextEmbeddings(CLIPTextEmbeddings):
         self.token_embedding = resize_embedding(self.token_embedding, size, self.initializer_factor)
 
     def add_embed(self, token_ids: Union[int, list[int]], initializer: Optional[Union[int, list[int], torch.FloatTensor]] = None):
+        init_ratio = 1.0
+
         if isinstance(token_ids, int):
             token_ids = [token_ids]
 
@@ -63,6 +65,7 @@ class ManagedCLIPTextEmbeddings(CLIPTextEmbeddings):
             initializer = [initializer]
 
         if isinstance(initializer, list):
+            init_ratio = len(initializer) / len(token_ids)
             initializer = (initializer * len(token_ids))[:len(token_ids)]
 
             with torch.no_grad():
@@ -76,6 +79,8 @@ class ManagedCLIPTextEmbeddings(CLIPTextEmbeddings):
             dtype=self.temp_token_embedding.weight.dtype,
         )
 
+        return init_ratio
+
     def load_embed(self, input_ids: list[int], filename: Path):
         with safe_open(filename, framework="pt", device="cpu") as file:
             self.add_embed(input_ids, file.get_tensor("embed"))
diff --git a/models/clip/tokenizer.py b/models/clip/tokenizer.py
index 4e97ab5..034adf9 100644
--- a/models/clip/tokenizer.py
+++ b/models/clip/tokenizer.py
@@ -55,11 +55,6 @@ def shuffle_auto(tokens: list[int]):
     return shuffle_all(tokens)
 
 
-class MultiCLIPTokenizerItem(NamedTuple):
-    token: str
-    ids: list[int]
-
-
 class MultiCLIPTokenizer(CLIPTokenizer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -96,7 +91,7 @@ class MultiCLIPTokenizer(CLIPTokenizer):
         self,
         new_tokens: Union[str, list[str]],
         num_vectors: Union[int, list[int]] = 1
-    ) -> Union[MultiCLIPTokenizerItem, list[MultiCLIPTokenizerItem]]:
+    ) -> Union[list[int], list[list[int]]]:
         if isinstance(new_tokens, list):
             if isinstance(num_vectors, int):
                 num_vectors = [num_vectors] * len(new_tokens)
@@ -119,7 +114,7 @@ class MultiCLIPTokenizer(CLIPTokenizer):
 
         self.token_map[ids[0]] = ids
 
-        return MultiCLIPTokenizerItem(new_tokens, ids)
+        return ids
 
     def expand_id(self, id: int):
         if id in self.token_map:
diff --git a/train_dreambooth.py b/train_dreambooth.py
index 2e0696b..c658ad6 100644
--- a/train_dreambooth.py
+++ b/train_dreambooth.py
@@ -4,9 +4,9 @@ import math
 import datetime
 import logging
 from pathlib import Path
+from functools import partial
 
 import torch
-import torch.nn.functional as F
 import torch.utils.checkpoint
 
 from accelerate import Accelerator
@@ -20,9 +20,10 @@ from tqdm.auto import tqdm
 from transformers import CLIPTextModel
 from slugify import slugify
 
-from common import load_config, load_embeddings_from_dir
+from util import load_config, load_embeddings_from_dir
 from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
 from data.csv import CSVDataModule, CSVDataItem
+from training.common import run_model
 from training.optimization import get_one_cycle_schedule
 from training.lr import LRFinder
 from training.util import AverageMeter, CheckpointerBase, save_args
@@ -610,8 +611,8 @@ def main():
         if not embeddings_dir.exists() or not embeddings_dir.is_dir():
             raise ValueError("--embeddings_dir must point to an existing directory")
 
-        added_tokens_from_dir = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir)
-        print(f"Added {len(added_tokens_from_dir)} tokens from embeddings dir: {added_tokens_from_dir}")
+        added_tokens, added_ids = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir)
+        print(f"Added {len(added_tokens)} tokens from embeddings dir: {zip(added_tokens, added_ids)}")
 
     if len(args.placeholder_token) != 0:
         # Convert the initializer_token, placeholder_token to ids
@@ -620,13 +621,15 @@ def main():
             for token in args.initializer_token
         ]
 
-        new_tokens = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors)
+        new_ids = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors)
         embeddings.resize(len(tokenizer))
 
-        for (new_token, init_ids) in zip(new_tokens, initializer_token_ids):
-            embeddings.add_embed(new_token.ids, init_ids)
+        init_ratios = [
+            embeddings.add_embed(new_id, init_ids)
+            for (new_id, init_ids) in zip(new_ids, initializer_token_ids)
+        ]
 
-        print(f"Added {len(new_tokens)} new tokens.")
+        print(f"Added {len(new_ids)} new tokens: {zip(args.placeholder_token, new_ids, init_ratios)}")
     else:
         placeholder_token_id = []
 
@@ -856,63 +859,16 @@ def main():
     def on_eval():
         tokenizer.eval()
 
-    def loop(step: int, batch, eval: bool = False):
-        # Convert images to latent space
-        latents = vae.encode(batch["pixel_values"]).latent_dist.sample()
-        latents = latents * 0.18215
-
-        # Sample noise that we'll add to the latents
-        noise = torch.randn_like(latents)
-        bsz = latents.shape[0]
-        # Sample a random timestep for each image
-        timesteps_gen = torch.Generator(device=latents.device).manual_seed(args.seed + step) if eval else None
-        timesteps = torch.randint(
-            0,
-            noise_scheduler.config.num_train_timesteps,
-            (bsz,),
-            generator=timesteps_gen,
-            device=latents.device,
-        )
-        timesteps = timesteps.long()
-
-        # Add noise to the latents according to the noise magnitude at each timestep
-        # (this is the forward diffusion process)
-        noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
-        noisy_latents = noisy_latents.to(dtype=unet.dtype)
-
-        # Get the text embedding for conditioning
-        encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"])
-
-        # Predict the noise residual
-        model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-        # Get the target for loss depending on the prediction type
-        if noise_scheduler.config.prediction_type == "epsilon":
-            target = noise
-        elif noise_scheduler.config.prediction_type == "v_prediction":
-            target = noise_scheduler.get_velocity(latents, noise, timesteps)
-        else:
-            raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
-
-        if args.num_class_images != 0:
-            # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
-            model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
-            target, target_prior = torch.chunk(target, 2, dim=0)
-
-            # Compute instance loss
-            loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-            # Compute prior loss
-            prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
-
-            # Add the prior loss to the instance loss.
-            loss = loss + args.prior_loss_weight * prior_loss
-        else:
-            loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-        acc = (model_pred == target).float().mean()
-
-        return loss, acc, bsz
+    loop = partial(
+        run_model,
+        vae=vae,
+        noise_scheduler=noise_scheduler,
+        unet=unet,
+        prompt_processor=prompt_processor,
+        num_class_images=args.num_class_images,
+        prior_loss_weight=args.prior_loss_weight,
+        seed=args.seed,
+    )
 
     # We need to initialize the trackers we use, and also store our configuration.
     # The trackers initializes automatically on the main process.
diff --git a/train_lora.py b/train_lora.py
deleted file mode 100644
index de878a4..0000000
--- a/train_lora.py
+++ /dev/null
@@ -1,946 +0,0 @@
-import argparse
-import itertools
-import math
-import datetime
-import logging
-import json
-from pathlib import Path
-
-import torch
-import torch.nn.functional as F
-import torch.utils.checkpoint
-
-from accelerate import Accelerator
-from accelerate.logging import get_logger
-from accelerate.utils import LoggerType, set_seed
-from diffusers import AutoencoderKL, DDPMScheduler, DPMSolverMultistepScheduler, UNet2DConditionModel
-from diffusers.optimization import get_scheduler, get_cosine_with_hard_restarts_schedule_with_warmup
-from diffusers.training_utils import EMAModel
-from tqdm.auto import tqdm
-from transformers import CLIPTextModel, CLIPTokenizer
-from slugify import slugify
-
-from common import load_text_embeddings, load_config
-from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
-from data.csv import CSVDataModule
-from training.lora import LoraAttnProcessor
-from training.optimization import get_one_cycle_schedule
-from training.util import AverageMeter, CheckpointerBase, save_args
-from models.clip.prompt import PromptProcessor
-
-logger = get_logger(__name__)
-
-
-torch.backends.cuda.matmul.allow_tf32 = True
-torch.backends.cudnn.benchmark = True
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Simple example of a training script."
-    )
-    parser.add_argument(
-        "--pretrained_model_name_or_path",
-        type=str,
-        default=None,
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-    )
-    parser.add_argument(
-        "--tokenizer_name",
-        type=str,
-        default=None,
-        help="Pretrained tokenizer name or path if not the same as model_name",
-    )
-    parser.add_argument(
-        "--train_data_file",
-        type=str,
-        default=None,
-        help="A folder containing the training data."
-    )
-    parser.add_argument(
-        "--train_data_template",
-        type=str,
-        default="template",
-    )
-    parser.add_argument(
-        "--instance_identifier",
-        type=str,
-        default=None,
-        help="A token to use as a placeholder for the concept.",
-    )
-    parser.add_argument(
-        "--class_identifier",
-        type=str,
-        default=None,
-        help="A token to use as a placeholder for the concept.",
-    )
-    parser.add_argument(
-        "--placeholder_token",
-        type=str,
-        nargs='*',
-        default=[],
-        help="A token to use as a placeholder for the concept.",
-    )
-    parser.add_argument(
-        "--initializer_token",
-        type=str,
-        nargs='*',
-        default=[],
-        help="A token to use as initializer word."
-    )
-    parser.add_argument(
-        "--tag_dropout",
-        type=float,
-        default=0.1,
-        help="Tag dropout probability.",
-    )
-    parser.add_argument(
-        "--num_class_images",
-        type=int,
-        default=400,
-        help="How many class images to generate."
-    )
-    parser.add_argument(
-        "--repeats",
-        type=int,
-        default=1,
-        help="How many times to repeat the training data."
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default="output/lora",
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--embeddings_dir",
-        type=str,
-        default=None,
-        help="The embeddings directory where Textual Inversion embeddings are stored.",
-    )
-    parser.add_argument(
-        "--mode",
-        type=str,
-        default=None,
-        help="A mode to filter the dataset.",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=None,
-        help="A seed for reproducible training."
-    )
-    parser.add_argument(
-        "--resolution",
-        type=int,
-        default=768,
-        help=(
-            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
-            " resolution"
-        ),
-    )
-    parser.add_argument(
-        "--center_crop",
-        action="store_true",
-        help="Whether to center crop images before resizing to resolution"
-    )
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=0,
-        help=(
-            "The number of subprocesses to use for data loading. 0 means that the data will be loaded in the main"
-            " process."
-        ),
-    )
-    parser.add_argument(
-        "--num_train_epochs",
-        type=int,
-        default=100
-    )
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-    parser.add_argument(
-        "--gradient_checkpointing",
-        action="store_true",
-        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=2e-6,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=True,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="one_cycle",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup", "one_cycle"]'
-        ),
-    )
-    parser.add_argument(
-        "--lr_warmup_epochs",
-        type=int,
-        default=10,
-        help="Number of steps for the warmup in the lr scheduler."
-    )
-    parser.add_argument(
-        "--lr_cycles",
-        type=int,
-        default=None,
-        help="Number of restart cycles in the lr scheduler (if supported)."
-    )
-    parser.add_argument(
-        "--use_8bit_adam",
-        action="store_true",
-        default=True,
-        help="Whether or not to use 8-bit Adam from bitsandbytes."
-    )
-    parser.add_argument(
-        "--adam_beta1",
-        type=float,
-        default=0.9,
-        help="The beta1 parameter for the Adam optimizer."
-    )
-    parser.add_argument(
-        "--adam_beta2",
-        type=float,
-        default=0.999,
-        help="The beta2 parameter for the Adam optimizer."
-    )
-    parser.add_argument(
-        "--adam_weight_decay",
-        type=float,
-        default=1e-2,
-        help="Weight decay to use."
-    )
-    parser.add_argument(
-        "--adam_epsilon",
-        type=float,
-        default=1e-08,
-        help="Epsilon value for the Adam optimizer"
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default="no",
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose"
-            "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
-            "and an Nvidia Ampere GPU."
-        ),
-    )
-    parser.add_argument(
-        "--sample_frequency",
-        type=int,
-        default=1,
-        help="How often to save a checkpoint and sample image",
-    )
-    parser.add_argument(
-        "--sample_image_size",
-        type=int,
-        default=768,
-        help="Size of sample images",
-    )
-    parser.add_argument(
-        "--sample_batches",
-        type=int,
-        default=1,
-        help="Number of sample batches to generate per checkpoint",
-    )
-    parser.add_argument(
-        "--sample_batch_size",
-        type=int,
-        default=1,
-        help="Number of samples to generate per batch",
-    )
-    parser.add_argument(
-        "--valid_set_size",
-        type=int,
-        default=None,
-        help="Number of images in the validation dataset."
-    )
-    parser.add_argument(
-        "--train_batch_size",
-        type=int,
-        default=1,
-        help="Batch size (per device) for the training dataloader."
-    )
-    parser.add_argument(
-        "--sample_steps",
-        type=int,
-        default=15,
-        help="Number of steps for sample generation. Higher values will result in more detailed samples, but longer runtimes.",
-    )
-    parser.add_argument(
-        "--prior_loss_weight",
-        type=float,
-        default=1.0,
-        help="The weight of prior preservation loss."
-    )
-    parser.add_argument(
-        "--max_grad_norm",
-        default=1.0,
-        type=float,
-        help="Max gradient norm."
-    )
-    parser.add_argument(
-        "--noise_timesteps",
-        type=int,
-        default=1000,
-    )
-    parser.add_argument(
-        "--config",
-        type=str,
-        default=None,
-        help="Path to a JSON configuration file containing arguments for invoking this script."
-    )
-
-    args = parser.parse_args()
-    if args.config is not None:
-        args = load_config(args.config)
-        args = parser.parse_args(namespace=argparse.Namespace(**args))
-
-    if args.train_data_file is None:
-        raise ValueError("You must specify --train_data_file")
-
-    if args.pretrained_model_name_or_path is None:
-        raise ValueError("You must specify --pretrained_model_name_or_path")
-
-    if args.instance_identifier is None:
-        raise ValueError("You must specify --instance_identifier")
-
-    if isinstance(args.initializer_token, str):
-        args.initializer_token = [args.initializer_token]
-
-    if isinstance(args.placeholder_token, str):
-        args.placeholder_token = [args.placeholder_token]
-
-    if len(args.placeholder_token) == 0:
-        args.placeholder_token = [f"<*{i}>" for i in range(len(args.initializer_token))]
-
-    if len(args.placeholder_token) != len(args.initializer_token):
-        raise ValueError("Number of items in --placeholder_token and --initializer_token must match")
-
-    if args.output_dir is None:
-        raise ValueError("You must specify --output_dir")
-
-    return args
-
-
-class Checkpointer(CheckpointerBase):
-    def __init__(
-        self,
-        datamodule,
-        accelerator,
-        vae,
-        unet,
-        tokenizer,
-        text_encoder,
-        unet_lora,
-        scheduler,
-        instance_identifier,
-        placeholder_token,
-        placeholder_token_id,
-        output_dir: Path,
-        sample_image_size,
-        sample_batches,
-        sample_batch_size,
-        seed
-    ):
-        super().__init__(
-            datamodule=datamodule,
-            output_dir=output_dir,
-            instance_identifier=instance_identifier,
-            placeholder_token=placeholder_token,
-            placeholder_token_id=placeholder_token_id,
-            sample_image_size=sample_image_size,
-            seed=seed or torch.random.seed(),
-            sample_batches=sample_batches,
-            sample_batch_size=sample_batch_size
-        )
-
-        self.accelerator = accelerator
-        self.vae = vae
-        self.unet = unet
-        self.tokenizer = tokenizer
-        self.text_encoder = text_encoder
-        self.unet_lora = unet_lora
-        self.scheduler = scheduler
-
-    @torch.no_grad()
-    def save_model(self):
-        print("Saving model...")
-
-        unet_lora = self.accelerator.unwrap_model(self.unet_lora)
-        unet_lora.save_pretrained(self.output_dir.joinpath("model"))
-
-        del unet_lora
-
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-    @torch.no_grad()
-    def save_samples(self, step, num_inference_steps, guidance_scale=7.5, eta=0.0):
-        # Save a sample image
-        pipeline = VlpnStableDiffusion(
-            text_encoder=self.text_encoder,
-            vae=self.vae,
-            unet=self.unet,
-            tokenizer=self.tokenizer,
-            scheduler=self.scheduler,
-        ).to(self.accelerator.device)
-        pipeline.set_progress_bar_config(dynamic_ncols=True)
-
-        super().save_samples(pipeline, step, num_inference_steps, guidance_scale, eta)
-
-        del pipeline
-        del generator
-        del stable_latents
-
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-
-def main():
-    args = parse_args()
-
-    instance_identifier = args.instance_identifier
-
-    if len(args.placeholder_token) != 0:
-        instance_identifier = instance_identifier.format(args.placeholder_token[0])
-
-    now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
-    basepath = Path(args.output_dir).joinpath(slugify(instance_identifier), now)
-    basepath.mkdir(parents=True, exist_ok=True)
-
-    accelerator = Accelerator(
-        log_with=LoggerType.TENSORBOARD,
-        logging_dir=f"{basepath}",
-        gradient_accumulation_steps=args.gradient_accumulation_steps,
-        mixed_precision=args.mixed_precision
-    )
-
-    logging.basicConfig(filename=basepath.joinpath("log.txt"), level=logging.DEBUG)
-
-    args.seed = args.seed or (torch.random.seed() >> 32)
-    set_seed(args.seed)
-
-    save_args(basepath, args)
-
-    # Load the tokenizer and add the placeholder token as a additional special token
-    if args.tokenizer_name:
-        tokenizer = CLIPTokenizer.from_pretrained(args.tokenizer_name)
-    elif args.pretrained_model_name_or_path:
-        tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='tokenizer')
-
-    # Load models and create wrapper for stable diffusion
-    text_encoder = CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder')
-    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder='vae')
-    unet = UNet2DConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='unet')
-    noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder='scheduler')
-    checkpoint_scheduler = DPMSolverMultistepScheduler.from_pretrained(
-        args.pretrained_model_name_or_path, subfolder='scheduler')
-
-    unet_lora = LoraAttnProcessor(
-        cross_attention_dim=unet.cross_attention_dim,
-        inner_dim=unet.in_channels,
-        r=4,
-    )
-
-    vae.enable_slicing()
-    vae.set_use_memory_efficient_attention_xformers(True)
-    unet.set_use_memory_efficient_attention_xformers(True)
-    unet.set_attn_processor(unet_lora)
-
-    if args.gradient_checkpointing:
-        unet.enable_gradient_checkpointing()
-        text_encoder.gradient_checkpointing_enable()
-
-    # Freeze text_encoder and vae
-    vae.requires_grad_(False)
-    unet.requires_grad_(False)
-
-    if args.embeddings_dir is not None:
-        embeddings_dir = Path(args.embeddings_dir)
-        if not embeddings_dir.exists() or not embeddings_dir.is_dir():
-            raise ValueError("--embeddings_dir must point to an existing directory")
-        added_tokens = load_text_embeddings(tokenizer, text_encoder, embeddings_dir)
-        print(f"Added {len(added_tokens)} tokens from embeddings dir: {added_tokens}")
-
-    if len(args.placeholder_token) != 0:
-        # Convert the initializer_token, placeholder_token to ids
-        initializer_token_ids = torch.stack([
-            torch.tensor(tokenizer.encode(token, add_special_tokens=False)[:1])
-            for token in args.initializer_token
-        ])
-
-        num_added_tokens = tokenizer.add_tokens(args.placeholder_token)
-        print(f"Added {num_added_tokens} new tokens.")
-
-        placeholder_token_id = tokenizer.convert_tokens_to_ids(args.placeholder_token)
-
-        # Resize the token embeddings as we are adding new special tokens to the tokenizer
-        text_encoder.resize_token_embeddings(len(tokenizer))
-
-        token_embeds = text_encoder.get_input_embeddings().weight.data
-        original_token_embeds = token_embeds.clone().to(accelerator.device)
-        initializer_token_embeddings = text_encoder.get_input_embeddings()(initializer_token_ids)
-
-        for (token_id, embeddings) in zip(placeholder_token_id, initializer_token_embeddings):
-            token_embeds[token_id] = embeddings
-    else:
-        placeholder_token_id = []
-
-    print(f"Training added text embeddings")
-
-    text_encoder.text_model.encoder.requires_grad_(False)
-    text_encoder.text_model.final_layer_norm.requires_grad_(False)
-    text_encoder.text_model.embeddings.position_embedding.requires_grad_(False)
-
-    index_fixed_tokens = torch.arange(len(tokenizer))
-    index_fixed_tokens = index_fixed_tokens[~torch.isin(index_fixed_tokens, torch.tensor(placeholder_token_id))]
-
-    prompt_processor = PromptProcessor(tokenizer, text_encoder)
-
-    if args.scale_lr:
-        args.learning_rate = (
-            args.learning_rate * args.gradient_accumulation_steps *
-            args.train_batch_size * accelerator.num_processes
-        )
-
-    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs
-    if args.use_8bit_adam:
-        try:
-            import bitsandbytes as bnb
-        except ImportError:
-            raise ImportError("To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`.")
-
-        optimizer_class = bnb.optim.AdamW8bit
-    else:
-        optimizer_class = torch.optim.AdamW
-
-    # Initialize the optimizer
-    optimizer = optimizer_class(
-        [
-            {
-                'params': unet_lora.parameters(),
-                'lr': args.learning_rate,
-            },
-        ],
-        betas=(args.adam_beta1, args.adam_beta2),
-        weight_decay=args.adam_weight_decay,
-        eps=args.adam_epsilon,
-    )
-
-    weight_dtype = torch.float32
-    if args.mixed_precision == "fp16":
-        weight_dtype = torch.float16
-    elif args.mixed_precision == "bf16":
-        weight_dtype = torch.bfloat16
-
-    def collate_fn(examples):
-        prompts = [example["prompts"] for example in examples]
-        nprompts = [example["nprompts"] for example in examples]
-        input_ids = [example["instance_prompt_ids"] for example in examples]
-        pixel_values = [example["instance_images"] for example in examples]
-
-        # concat class and instance examples for prior preservation
-        if args.num_class_images != 0 and "class_prompt_ids" in examples[0]:
-            input_ids += [example["class_prompt_ids"] for example in examples]
-            pixel_values += [example["class_images"] for example in examples]
-
-        pixel_values = torch.stack(pixel_values)
-        pixel_values = pixel_values.to(dtype=weight_dtype, memory_format=torch.contiguous_format)
-
-        inputs = prompt_processor.unify_input_ids(input_ids)
-
-        batch = {
-            "prompts": prompts,
-            "nprompts": nprompts,
-            "input_ids": inputs.input_ids,
-            "pixel_values": pixel_values,
-            "attention_mask": inputs.attention_mask,
-        }
-        return batch
-
-    datamodule = CSVDataModule(
-        data_file=args.train_data_file,
-        batch_size=args.train_batch_size,
-        prompt_processor=prompt_processor,
-        instance_identifier=instance_identifier,
-        class_identifier=args.class_identifier,
-        class_subdir="cls",
-        num_class_images=args.num_class_images,
-        size=args.resolution,
-        repeats=args.repeats,
-        mode=args.mode,
-        dropout=args.tag_dropout,
-        center_crop=args.center_crop,
-        template_key=args.train_data_template,
-        valid_set_size=args.valid_set_size,
-        num_workers=args.dataloader_num_workers,
-        collate_fn=collate_fn
-    )
-
-    datamodule.prepare_data()
-    datamodule.setup()
-
-    if args.num_class_images != 0:
-        missing_data = [item for item in datamodule.data_train if not item.class_image_path.exists()]
-
-        if len(missing_data) != 0:
-            batched_data = [
-                missing_data[i:i+args.sample_batch_size]
-                for i in range(0, len(missing_data), args.sample_batch_size)
-            ]
-
-            pipeline = VlpnStableDiffusion(
-                text_encoder=text_encoder,
-                vae=vae,
-                unet=unet,
-                tokenizer=tokenizer,
-                scheduler=checkpoint_scheduler,
-            ).to(accelerator.device)
-            pipeline.set_progress_bar_config(dynamic_ncols=True)
-
-            with torch.autocast("cuda"), torch.inference_mode():
-                for batch in batched_data:
-                    image_name = [item.class_image_path for item in batch]
-                    prompt = [item.prompt.format(identifier=args.class_identifier) for item in batch]
-                    nprompt = [item.nprompt for item in batch]
-
-                    images = pipeline(
-                        prompt=prompt,
-                        negative_prompt=nprompt,
-                        num_inference_steps=args.sample_steps
-                    ).images
-
-                    for i, image in enumerate(images):
-                        image.save(image_name[i])
-
-            del pipeline
-
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-
-    train_dataloader = datamodule.train_dataloader()
-    val_dataloader = datamodule.val_dataloader()
-
-    # Scheduler and math around the number of training steps.
-    overrode_max_train_steps = False
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
-    if args.max_train_steps is None:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-        overrode_max_train_steps = True
-    num_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    warmup_steps = args.lr_warmup_epochs * num_update_steps_per_epoch * args.gradient_accumulation_steps
-
-    if args.lr_scheduler == "one_cycle":
-        lr_scheduler = get_one_cycle_schedule(
-            optimizer=optimizer,
-            num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
-        )
-    elif args.lr_scheduler == "cosine_with_restarts":
-        lr_scheduler = get_cosine_with_hard_restarts_schedule_with_warmup(
-            optimizer=optimizer,
-            num_warmup_steps=warmup_steps,
-            num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
-            num_cycles=args.lr_cycles or math.ceil(math.sqrt(
-                ((args.max_train_steps - warmup_steps) / num_update_steps_per_epoch))),
-        )
-    else:
-        lr_scheduler = get_scheduler(
-            args.lr_scheduler,
-            optimizer=optimizer,
-            num_warmup_steps=warmup_steps,
-            num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
-        )
-
-    unet_lora, optimizer, train_dataloader, val_dataloader, lr_scheduler = accelerator.prepare(
-        unet_lora, optimizer, train_dataloader, val_dataloader, lr_scheduler
-    )
-
-    # Move text_encoder and vae to device
-    vae.to(accelerator.device, dtype=weight_dtype)
-    unet.to(accelerator.device, dtype=weight_dtype)
-    text_encoder.to(accelerator.device, dtype=weight_dtype)
-
-    # Keep text_encoder and vae in eval mode as we don't train these
-    vae.eval()
-    unet.eval()
-    text_encoder.eval()
-
-    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
-    if overrode_max_train_steps:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-
-    num_val_steps_per_epoch = len(val_dataloader)
-    num_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-    val_steps = num_val_steps_per_epoch * num_epochs
-
-    # We need to initialize the trackers we use, and also store our configuration.
-    # The trackers initializes automatically on the main process.
-    if accelerator.is_main_process:
-        config = vars(args).copy()
-        config["initializer_token"] = " ".join(config["initializer_token"])
-        config["placeholder_token"] = " ".join(config["placeholder_token"])
-        accelerator.init_trackers("lora", config=config)
-
-    # Train!
-    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
-
-    logger.info("***** Running training *****")
-    logger.info(f"  Num Epochs = {num_epochs}")
-    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
-    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
-    logger.info(f"  Total optimization steps = {args.max_train_steps}")
-    # Only show the progress bar once on each machine.
-
-    global_step = 0
-
-    avg_loss = AverageMeter()
-    avg_acc = AverageMeter()
-
-    avg_loss_val = AverageMeter()
-    avg_acc_val = AverageMeter()
-
-    max_acc_val = 0.0
-
-    checkpointer = Checkpointer(
-        datamodule=datamodule,
-        accelerator=accelerator,
-        vae=vae,
-        unet=unet,
-        tokenizer=tokenizer,
-        text_encoder=text_encoder,
-        scheduler=checkpoint_scheduler,
-        unet_lora=unet_lora,
-        output_dir=basepath,
-        instance_identifier=instance_identifier,
-        placeholder_token=args.placeholder_token,
-        placeholder_token_id=placeholder_token_id,
-        sample_image_size=args.sample_image_size,
-        sample_batch_size=args.sample_batch_size,
-        sample_batches=args.sample_batches,
-        seed=args.seed
-    )
-
-    if accelerator.is_main_process:
-        checkpointer.save_samples(0, args.sample_steps)
-
-    local_progress_bar = tqdm(
-        range(num_update_steps_per_epoch + num_val_steps_per_epoch),
-        disable=not accelerator.is_local_main_process,
-        dynamic_ncols=True
-    )
-    local_progress_bar.set_description("Epoch X / Y")
-
-    global_progress_bar = tqdm(
-        range(args.max_train_steps + val_steps),
-        disable=not accelerator.is_local_main_process,
-        dynamic_ncols=True
-    )
-    global_progress_bar.set_description("Total progress")
-
-    try:
-        for epoch in range(num_epochs):
-            local_progress_bar.set_description(f"Epoch {epoch + 1} / {num_epochs}")
-            local_progress_bar.reset()
-
-            unet_lora.train()
-
-            for step, batch in enumerate(train_dataloader):
-                with accelerator.accumulate(unet_lora):
-                    # Convert images to latent space
-                    latents = vae.encode(batch["pixel_values"]).latent_dist.sample()
-                    latents = latents * 0.18215
-
-                    # Sample noise that we'll add to the latents
-                    noise = torch.randn_like(latents)
-                    bsz = latents.shape[0]
-                    # Sample a random timestep for each image
-                    timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps,
-                                              (bsz,), device=latents.device)
-                    timesteps = timesteps.long()
-
-                    # Add noise to the latents according to the noise magnitude at each timestep
-                    # (this is the forward diffusion process)
-                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
-
-                    # Get the text embedding for conditioning
-                    encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"])
-
-                    # Predict the noise residual
-                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-                    # Get the target for loss depending on the prediction type
-                    if noise_scheduler.config.prediction_type == "epsilon":
-                        target = noise
-                    elif noise_scheduler.config.prediction_type == "v_prediction":
-                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
-                    else:
-                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
-
-                    if args.num_class_images != 0:
-                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
-                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
-                        target, target_prior = torch.chunk(target, 2, dim=0)
-
-                        # Compute instance loss
-                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-                        # Compute prior loss
-                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
-
-                        # Add the prior loss to the instance loss.
-                        loss = loss + args.prior_loss_weight * prior_loss
-                    else:
-                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-                    acc = (model_pred == latents).float().mean()
-
-                    accelerator.backward(loss)
-
-                    if accelerator.sync_gradients:
-                        accelerator.clip_grad_norm_(unet_lora.parameters(), args.max_grad_norm)
-
-                    optimizer.step()
-                    if not accelerator.optimizer_step_was_skipped:
-                        lr_scheduler.step()
-                    optimizer.zero_grad(set_to_none=True)
-
-                    with torch.no_grad():
-                        text_encoder.get_input_embeddings(
-                        ).weight[index_fixed_tokens] = original_token_embeds[index_fixed_tokens]
-
-                    avg_loss.update(loss.detach_(), bsz)
-                    avg_acc.update(acc.detach_(), bsz)
-
-                # Checks if the accelerator has performed an optimization step behind the scenes
-                if accelerator.sync_gradients:
-                    local_progress_bar.update(1)
-                    global_progress_bar.update(1)
-
-                    global_step += 1
-
-                logs = {
-                    "train/loss": avg_loss.avg.item(),
-                    "train/acc": avg_acc.avg.item(),
-                    "train/cur_loss": loss.item(),
-                    "train/cur_acc": acc.item(),
-                    "lr/unet": lr_scheduler.get_last_lr()[0],
-                    "lr/text": lr_scheduler.get_last_lr()[1]
-                }
-
-                accelerator.log(logs, step=global_step)
-
-                local_progress_bar.set_postfix(**logs)
-
-                if global_step >= args.max_train_steps:
-                    break
-
-            accelerator.wait_for_everyone()
-
-            unet_lora.eval()
-
-            with torch.inference_mode():
-                for step, batch in enumerate(val_dataloader):
-                    latents = vae.encode(batch["pixel_values"]).latent_dist.sample()
-                    latents = latents * 0.18215
-
-                    noise = torch.randn_like(latents)
-                    bsz = latents.shape[0]
-                    timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps,
-                                              (bsz,), device=latents.device)
-                    timesteps = timesteps.long()
-
-                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
-
-                    encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"])
-
-                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-                    # Get the target for loss depending on the prediction type
-                    if noise_scheduler.config.prediction_type == "epsilon":
-                        target = noise
-                    elif noise_scheduler.config.prediction_type == "v_prediction":
-                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
-                    else:
-                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
-
-                    loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-                    acc = (model_pred == latents).float().mean()
-
-                    avg_loss_val.update(loss.detach_(), bsz)
-                    avg_acc_val.update(acc.detach_(), bsz)
-
-                    if accelerator.sync_gradients:
-                        local_progress_bar.update(1)
-                        global_progress_bar.update(1)
-
-                    logs = {
-                        "val/loss": avg_loss_val.avg.item(),
-                        "val/acc": avg_acc_val.avg.item(),
-                        "val/cur_loss": loss.item(),
-                        "val/cur_acc": acc.item(),
-                    }
-                    local_progress_bar.set_postfix(**logs)
-
-            accelerator.log({
-                "val/loss": avg_loss_val.avg.item(),
-                "val/acc": avg_acc_val.avg.item(),
-            }, step=global_step)
-
-            local_progress_bar.clear()
-            global_progress_bar.clear()
-
-            if avg_acc_val.avg.item() > max_acc_val:
-                accelerator.print(
-                    f"Global step {global_step}: Validation accuracy reached new maximum: {max_acc_val:.2e} -> {avg_acc_val.avg.item():.2e}")
-                max_acc_val = avg_acc_val.avg.item()
-
-            if accelerator.is_main_process:
-                if (epoch + 1) % args.sample_frequency == 0:
-                    checkpointer.save_samples(global_step, args.sample_steps)
-
-        # Create the pipeline using using the trained modules and save it.
-        if accelerator.is_main_process:
-            print("Finished! Saving final checkpoint and resume state.")
-            checkpointer.save_model()
-
-            accelerator.end_training()
-
-    except KeyboardInterrupt:
-        if accelerator.is_main_process:
-            print("Interrupted, saving checkpoint and resume state...")
-            checkpointer.save_model()
-            accelerator.end_training()
-        quit()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/train_ti.py b/train_ti.py
index 8ada98c..5df6850 100644
--- a/train_ti.py
+++ b/train_ti.py
@@ -3,9 +3,9 @@ import math
 import datetime
 import logging
 from pathlib import Path
+from functools import partial
 
 import torch
-import torch.nn.functional as F
 import torch.utils.checkpoint
 
 from accelerate import Accelerator
@@ -18,9 +18,10 @@ from tqdm.auto import tqdm
 from transformers import CLIPTextModel
 from slugify import slugify
 
-from common import load_config, load_embeddings_from_dir
+from util import load_config, load_embeddings_from_dir
 from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
 from data.csv import CSVDataModule, CSVDataItem
+from training.common import run_model
 from training.optimization import get_one_cycle_schedule
 from training.lr import LRFinder
 from training.util import AverageMeter, CheckpointerBase, save_args
@@ -570,8 +571,8 @@ def main():
         if not embeddings_dir.exists() or not embeddings_dir.is_dir():
             raise ValueError("--embeddings_dir must point to an existing directory")
 
-        added_tokens_from_dir = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir)
-        print(f"Added {len(added_tokens_from_dir)} tokens from embeddings dir: {added_tokens_from_dir}")
+        added_tokens, added_ids = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir)
+        print(f"Added {len(added_tokens)} tokens from embeddings dir: {zip(added_tokens, added_ids)}")
 
     # Convert the initializer_token, placeholder_token to ids
     initializer_token_ids = [
@@ -579,13 +580,15 @@ def main():
         for token in args.initializer_token
     ]
 
-    new_tokens = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors)
+    new_ids = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors)
     embeddings.resize(len(tokenizer))
 
-    for (new_token, init_ids) in zip(new_tokens, initializer_token_ids):
-        embeddings.add_embed(new_token.ids, init_ids)
+    init_ratios = [
+        embeddings.add_embed(new_id, init_ids)
+        for (new_id, init_ids) in zip(new_ids, initializer_token_ids)
+    ]
 
-    print(f"Added {len(new_tokens)} new tokens.")
+    print(f"Added {len(new_ids)} new tokens: {zip(args.placeholder_token, new_ids, init_ratios)}")
 
     vae.requires_grad_(False)
     unet.requires_grad_(False)
@@ -807,63 +810,16 @@ def main():
     def on_eval():
         tokenizer.eval()
 
-    def loop(step: int, batch, eval: bool = False):
-        # Convert images to latent space
-        latents = vae.encode(batch["pixel_values"]).latent_dist.sample().detach()
-        latents = latents * 0.18215
-
-        # Sample noise that we'll add to the latents
-        noise = torch.randn_like(latents)
-        bsz = latents.shape[0]
-        # Sample a random timestep for each image
-        timesteps_gen = torch.Generator(device=latents.device).manual_seed(args.seed + step) if eval else None
-        timesteps = torch.randint(
-            0,
-            noise_scheduler.config.num_train_timesteps,
-            (bsz,),
-            generator=timesteps_gen,
-            device=latents.device,
-        )
-        timesteps = timesteps.long()
-
-        # Add noise to the latents according to the noise magnitude at each timestep
-        # (this is the forward diffusion process)
-        noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
-
-        # Get the text embedding for conditioning
-        encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"])
-        encoder_hidden_states = encoder_hidden_states.to(dtype=weight_dtype)
-
-        # Predict the noise residual
-        model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-        # Get the target for loss depending on the prediction type
-        if noise_scheduler.config.prediction_type == "epsilon":
-            target = noise
-        elif noise_scheduler.config.prediction_type == "v_prediction":
-            target = noise_scheduler.get_velocity(latents, noise, timesteps)
-        else:
-            raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
-
-        if args.num_class_images != 0:
-            # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
-            model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
-            target, target_prior = torch.chunk(target, 2, dim=0)
-
-            # Compute instance loss
-            loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-            # Compute prior loss
-            prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
-
-            # Add the prior loss to the instance loss.
-            loss = loss + args.prior_loss_weight * prior_loss
-        else:
-            loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-
-        acc = (model_pred == target).float().mean()
-
-        return loss, acc, bsz
+    loop = partial(
+        run_model,
+        vae=vae,
+        noise_scheduler=noise_scheduler,
+        unet=unet,
+        prompt_processor=prompt_processor,
+        num_class_images=args.num_class_images,
+        prior_loss_weight=args.prior_loss_weight,
+        seed=args.seed,
+    )
 
     # We need to initialize the trackers we use, and also store our configuration.
     # The trackers initializes automatically on the main process.
diff --git a/training/common.py b/training/common.py
new file mode 100644
index 0000000..99a6e67
--- /dev/null
+++ b/training/common.py
@@ -0,0 +1,75 @@
+import torch
+import torch.nn.functional as F
+
+from diffusers import AutoencoderKL, DDPMScheduler, UNet2DConditionModel
+
+
+def run_model(
+    vae: AutoencoderKL,
+    noise_scheduler: DDPMScheduler,
+    unet: UNet2DConditionModel,
+    prompt_processor,
+    num_class_images: int,
+    prior_loss_weight: float,
+    seed: int,
+    step: int,
+    batch,
+    eval: bool = False
+):
+    # Convert images to latent space
+    latents = vae.encode(batch["pixel_values"]).latent_dist.sample().detach()
+    latents = latents * 0.18215
+
+    # Sample noise that we'll add to the latents
+    noise = torch.randn_like(latents)
+    bsz = latents.shape[0]
+    # Sample a random timestep for each image
+    timesteps_gen = torch.Generator(device=latents.device).manual_seed(seed + step) if eval else None
+    timesteps = torch.randint(
+        0,
+        noise_scheduler.config.num_train_timesteps,
+        (bsz,),
+        generator=timesteps_gen,
+        device=latents.device,
+    )
+    timesteps = timesteps.long()
+
+    # Add noise to the latents according to the noise magnitude at each timestep
+    # (this is the forward diffusion process)
+    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+    noisy_latents = noisy_latents.to(dtype=unet.dtype)
+
+    # Get the text embedding for conditioning
+    encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"])
+    encoder_hidden_states = encoder_hidden_states.to(dtype=unet.dtype)
+
+    # Predict the noise residual
+    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+    # Get the target for loss depending on the prediction type
+    if noise_scheduler.config.prediction_type == "epsilon":
+        target = noise
+    elif noise_scheduler.config.prediction_type == "v_prediction":
+        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+    else:
+        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+    if num_class_images != 0:
+        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+        target, target_prior = torch.chunk(target, 2, dim=0)
+
+        # Compute instance loss
+        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+        # Compute prior loss
+        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+        # Add the prior loss to the instance loss.
+        loss = loss + prior_loss_weight * prior_loss
+    else:
+        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+    acc = (model_pred == target).float().mean()
+
+    return loss, acc, bsz
diff --git a/common.py b/util.py
index 0887197..545bcb5 100644
--- a/common.py
+++ b/util.py
@@ -24,8 +24,9 @@ def load_embeddings_from_dir(tokenizer: MultiCLIPTokenizer, embeddings: ManagedC
         return []
 
     filenames = [filename for filename in embeddings_dir.iterdir() if filename.is_file()]
+    tokens = [filename.stem for filename in filenames]
 
-    new_tokens = []
+    new_ids: list[list[int]] = []
     new_embeds = []
 
     for filename in filenames:
@@ -33,12 +34,12 @@ def load_embeddings_from_dir(tokenizer: MultiCLIPTokenizer, embeddings: ManagedC
             embed = file.get_tensor("embed")
 
         added = tokenizer.add_multi_tokens(filename.stem, embed.shape[0])
-        new_tokens.append(added)
+        new_ids.append(added)
         new_embeds.append(embed)
 
     embeddings.resize(len(tokenizer))
 
-    for (new_token, embeds) in zip(new_tokens, new_embeds):
-        embeddings.add_embed(new_token.ids, embeds)
+    for (new_id, embeds) in zip(new_ids, new_embeds):
+        embeddings.add_embed(new_id, embeds)
 
-    return new_tokens
+    return tokens, new_ids