Update

8 files changed, 159 insertions, 1116 deletions

diff --git a/data/dreambooth/csv.py b/data/csv.py
index abd329d..abd329d 100644
--- a/data/dreambooth/csv.py
+++ b/data/csv.py
diff --git a/data/textual_inversion/csv.py b/data/textual_inversion/csv.py
deleted file mode 100644
index 4c5e27e..0000000
--- a/data/textual_inversion/csv.py
+++ /dev/null
@@ -1,150 +0,0 @@
-import os
-import numpy as np
-import pandas as pd
-from pathlib import Path
-import math
-import pytorch_lightning as pl
-from PIL import Image
-from torch.utils.data import Dataset, DataLoader, random_split
-from torchvision import transforms
-
-
-class CSVDataModule(pl.LightningDataModule):
-    def __init__(self,
-                 batch_size,
-                 data_file,
-                 tokenizer,
-                 size=512,
-                 repeats=100,
-                 interpolation="bicubic",
-                 placeholder_token="*",
-                 center_crop=False,
-                 valid_set_size=None,
-                 generator=None):
-        super().__init__()
-
-        self.data_file = Path(data_file)
-
-        if not self.data_file.is_file():
-            raise ValueError("data_file must be a file")
-
-        self.data_root = self.data_file.parent
-        self.tokenizer = tokenizer
-        self.size = size
-        self.repeats = repeats
-        self.placeholder_token = placeholder_token
-        self.center_crop = center_crop
-        self.interpolation = interpolation
-        self.valid_set_size = valid_set_size
-        self.generator = generator
-
-        self.batch_size = batch_size
-
-    def prepare_data(self):
-        metadata = pd.read_csv(self.data_file)
-        image_paths = [os.path.join(self.data_root, f_path) for f_path in metadata['image'].values]
-        prompts = metadata['prompt'].values
-        nprompts = metadata['nprompt'].values if 'nprompt' in metadata else [""] * len(image_paths)
-        skips = metadata['skip'].values if 'skip' in metadata else [""] * len(image_paths)
-        self.data_full = [(i, p, n) for i, p, n, s in zip(image_paths, prompts, nprompts, skips) if s != "x"]
-
-    def setup(self, stage=None):
-        valid_set_size = int(len(self.data_full) * 0.2)
-        if self.valid_set_size:
-            valid_set_size = min(valid_set_size, self.valid_set_size)
-        valid_set_size = max(valid_set_size, 1)
-        train_set_size = len(self.data_full) - valid_set_size
-
-        self.data_train, self.data_val = random_split(self.data_full, [train_set_size, valid_set_size], self.generator)
-
-        train_dataset = CSVDataset(self.data_train, self.tokenizer, size=self.size, repeats=self.repeats, interpolation=self.interpolation,
-                                   placeholder_token=self.placeholder_token, center_crop=self.center_crop)
-        val_dataset = CSVDataset(self.data_val, self.tokenizer, size=self.size, repeats=self.repeats, interpolation=self.interpolation,
-                                 placeholder_token=self.placeholder_token, center_crop=self.center_crop)
-        self.train_dataloader_ = DataLoader(train_dataset, batch_size=self.batch_size, pin_memory=True, shuffle=True)
-        self.val_dataloader_ = DataLoader(val_dataset, batch_size=self.batch_size, pin_memory=True)
-
-    def train_dataloader(self):
-        return self.train_dataloader_
-
-    def val_dataloader(self):
-        return self.val_dataloader_
-
-
-class CSVDataset(Dataset):
-    def __init__(self,
-                 data,
-                 tokenizer,
-                 size=512,
-                 repeats=1,
-                 interpolation="bicubic",
-                 placeholder_token="*",
-                 center_crop=False,
-                 batch_size=1,
-                 ):
-
-        self.data = data
-        self.tokenizer = tokenizer
-        self.placeholder_token = placeholder_token
-        self.batch_size = batch_size
-        self.cache = {}
-
-        self.num_instance_images = len(self.data)
-        self._length = self.num_instance_images * repeats
-
-        self.interpolation = {"linear": transforms.InterpolationMode.NEAREST,
-                              "bilinear": transforms.InterpolationMode.BILINEAR,
-                              "bicubic": transforms.InterpolationMode.BICUBIC,
-                              "lanczos": transforms.InterpolationMode.LANCZOS,
-                              }[interpolation]
-        self.image_transforms = transforms.Compose(
-            [
-                transforms.Resize(size, interpolation=self.interpolation),
-                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
-                transforms.RandomHorizontalFlip(),
-                transforms.ToTensor(),
-                transforms.Normalize([0.5], [0.5]),
-            ]
-        )
-
-    def __len__(self):
-        return math.ceil(self._length / self.batch_size) * self.batch_size
-
-    def get_example(self, i):
-        image_path, prompt, nprompt = self.data[i % self.num_instance_images]
-
-        if image_path in self.cache:
-            return self.cache[image_path]
-
-        example = {}
-
-        instance_image = Image.open(image_path)
-        if not instance_image.mode == "RGB":
-            instance_image = instance_image.convert("RGB")
-
-        prompt = prompt.format(self.placeholder_token)
-
-        example["prompts"] = prompt
-        example["nprompts"] = nprompt
-        example["pixel_values"] = instance_image
-        example["input_ids"] = self.tokenizer(
-            prompt,
-            padding="max_length",
-            truncation=True,
-            max_length=self.tokenizer.model_max_length,
-            return_tensors="pt",
-        ).input_ids[0]
-
-        self.cache[image_path] = example
-        return example
-
-    def __getitem__(self, i):
-        example = {}
-        unprocessed_example = self.get_example(i)
-
-        example["prompts"] = unprocessed_example["prompts"]
-        example["nprompts"] = unprocessed_example["nprompts"]
-        example["input_ids"] = unprocessed_example["input_ids"]
-        example["pixel_values"] = self.image_transforms(unprocessed_example["pixel_values"])
-
-        return example
diff --git a/dreambooth.py b/dreambooth.py
index 0c5c42a..0e69d79 100644
--- a/dreambooth.py
+++ b/dreambooth.py
@@ -23,7 +23,7 @@ from slugify import slugify
 from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
 import json
 
-from data.dreambooth.csv import CSVDataModule
+from data.csv import CSVDataModule
 
 logger = get_logger(__name__)
 
diff --git a/infer.py b/infer.py
index 3487e5a..34e570a 100644
--- a/infer.py
+++ b/infer.py
@@ -171,6 +171,18 @@ def load_embeddings(tokenizer, text_encoder, embeddings_dir):
     embeddings_dir = Path(embeddings_dir)
     embeddings_dir.mkdir(parents=True, exist_ok=True)
 
+    for file in embeddings_dir.iterdir():
+        placeholder_token = file.stem
+
+        num_added_tokens = tokenizer.add_tokens(placeholder_token)
+        if num_added_tokens == 0:
+            raise ValueError(
+                f"The tokenizer already contains the token {placeholder_token}. Please pass a different"
+                " `placeholder_token` that is not already in the tokenizer."
+            )
+
+    text_encoder.resize_token_embeddings(len(tokenizer))
+
     token_embeds = text_encoder.get_input_embeddings().weight.data
 
     for file in embeddings_dir.iterdir():
@@ -187,6 +199,8 @@ def load_embeddings(tokenizer, text_encoder, embeddings_dir):
 
         token_embeds[placeholder_token_id] = emb
 
+        print(f"Loaded embedding: {placeholder_token}")
+
 
 def create_pipeline(model, scheduler, embeddings_dir, dtype):
     print("Loading Stable Diffusion pipeline...")
diff --git a/pipelines/stable_diffusion/vlpn_stable_diffusion.py b/pipelines/stable_diffusion/vlpn_stable_diffusion.py
index 8fbe5f9..a198cf6 100644
--- a/pipelines/stable_diffusion/vlpn_stable_diffusion.py
+++ b/pipelines/stable_diffusion/vlpn_stable_diffusion.py
@@ -216,7 +216,6 @@ class VlpnStableDiffusion(DiffusionPipeline):
 
         offset = self.scheduler.config.get("steps_offset", 0)
         init_timestep = num_inference_steps + offset
-        ensure_sigma = not isinstance(latents, PIL.Image.Image)
 
         # get the initial random noise unless the user supplied it
 
@@ -246,13 +245,8 @@ class VlpnStableDiffusion(DiffusionPipeline):
             init_timestep = int(num_inference_steps * strength) + offset
             init_timestep = min(init_timestep, num_inference_steps)
 
-            if isinstance(self.scheduler, LMSDiscreteScheduler):
-                timesteps = torch.tensor(
-                    [num_inference_steps - init_timestep] * batch_size, dtype=torch.long, device=self.device
-                )
-            else:
-                timesteps = self.scheduler.timesteps[-init_timestep]
-                timesteps = torch.tensor([timesteps] * batch_size, dtype=torch.long, device=self.device)
+            timesteps = self.scheduler.timesteps[-init_timestep]
+            timesteps = torch.tensor([timesteps] * batch_size, device=self.device)
 
             # add noise to latents using the timesteps
             noise = torch.randn(latents.shape, generator=generator, device=self.device)
@@ -263,13 +257,6 @@ class VlpnStableDiffusion(DiffusionPipeline):
             if latents.device != self.device:
                 raise ValueError(f"Unexpected latents device, got {latents.device}, expected {self.device}")
 
-        # if we use LMSDiscreteScheduler, let's make sure latents are multiplied by sigmas
-        if ensure_sigma:
-            if isinstance(self.scheduler, LMSDiscreteScheduler):
-                latents = latents * self.scheduler.sigmas[0]
-            elif isinstance(self.scheduler, EulerAScheduler):
-                latents = latents * self.scheduler.sigmas[0]
-
         t_start = max(num_inference_steps - init_timestep + offset, 0)
 
         # Some schedulers like PNDM have timesteps as arrays
@@ -290,19 +277,13 @@ class VlpnStableDiffusion(DiffusionPipeline):
             extra_step_kwargs["generator"] = generator
 
         for i, t in enumerate(self.progress_bar(timesteps_tensor)):
-            t_index = t_start + i
-
             # expand the latents if we are doing classifier free guidance
             latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-
-            if isinstance(self.scheduler, LMSDiscreteScheduler):
-                sigma = self.scheduler.sigmas[t_index]
-                # the model input needs to be scaled to match the continuous ODE formulation in K-LMS
-                latent_model_input = latent_model_input / ((sigma**2 + 1) ** 0.5)
+            latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
 
             noise_pred = None
             if isinstance(self.scheduler, EulerAScheduler):
-                sigma = self.scheduler.sigmas[t].reshape(1)
+                sigma = t.reshape(1)
                 sigma_in = torch.cat([sigma] * latent_model_input.shape[0])
                 noise_pred = CFGDenoiserForward(self.unet, latent_model_input, sigma_in,
                                                 text_embeddings, guidance_scale, quantize=True, DSsigmas=self.scheduler.DSsigmas)
@@ -316,13 +297,7 @@ class VlpnStableDiffusion(DiffusionPipeline):
                 noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
 
             # compute the previous noisy sample x_t -> x_t-1
-            if isinstance(self.scheduler, LMSDiscreteScheduler):
-                latents = self.scheduler.step(noise_pred, t_index, latents, **extra_step_kwargs).prev_sample
-            elif isinstance(self.scheduler, EulerAScheduler):
-                latents = self.scheduler.step(noise_pred, t_index, t_index + 1,
-                                              latents, **extra_step_kwargs).prev_sample
-            else:
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
+            latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
 
         # scale and decode the image latents with vae
         latents = 1 / 0.18215 * latents
diff --git a/schedulers/scheduling_euler_a.py b/schedulers/scheduling_euler_a.py
index c6436d8..13ea6b3 100644
--- a/schedulers/scheduling_euler_a.py
+++ b/schedulers/scheduling_euler_a.py
@@ -171,6 +171,9 @@ class EulerAScheduler(SchedulerMixin, ConfigMixin):
         self.alphas = 1.0 - self.betas
         self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
 
+        # standard deviation of the initial noise distribution
+        self.init_noise_sigma = 1.0
+
         # setable values
         self.num_inference_steps = None
         self.timesteps = np.arange(0, num_train_timesteps)[::-1]
@@ -190,13 +193,33 @@ class EulerAScheduler(SchedulerMixin, ConfigMixin):
         self.num_inference_steps = num_inference_steps
         self.DSsigmas = ((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5
         self.sigmas = get_sigmas(self.DSsigmas, self.num_inference_steps).to(device=device)
-        self.timesteps = np.arange(0, self.num_inference_steps)
+        self.timesteps = self.sigmas[:-1]
+        self.is_scale_input_called = False
+
+    def scale_model_input(self, sample: torch.FloatTensor, timestep: int) -> torch.FloatTensor:
+        """
+        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+        current timestep.
+        Args:
+            sample (`torch.FloatTensor`): input sample
+            timestep (`int`, optional): current timestep
+        Returns:
+            `torch.FloatTensor`: scaled input sample
+        """
+        if isinstance(timestep, torch.Tensor):
+            timestep = timestep.to(self.timesteps.device)
+        if self.is_scale_input_called:
+            return sample
+        step_index = (self.timesteps == timestep).nonzero().item()
+        sigma = self.sigmas[step_index]
+        sample = sample * sigma
+        self.is_scale_input_called = True
+        return sample
 
     def step(
         self,
         model_output: torch.FloatTensor,
-        timestep: int,
-        timestep_prev: int,
+        timestep: Union[float, torch.FloatTensor],
         sample: torch.FloatTensor,
         generator: torch.Generator = None,
         return_dict: bool = True,
@@ -219,8 +242,13 @@ class EulerAScheduler(SchedulerMixin, ConfigMixin):
             returning a tuple, the first element is the sample tensor.
 
         """
-        s = self.sigmas[timestep]
-        s_prev = self.sigmas[timestep_prev]
+        if isinstance(timestep, torch.Tensor):
+            timestep = timestep.to(self.timesteps.device)
+        step_index = (self.timesteps == timestep).nonzero().item()
+        step_prev_index = step_index + 1
+
+        s = self.sigmas[step_index]
+        s_prev = self.sigmas[step_prev_index]
         latents = sample
 
         sigma_down, sigma_up = get_ancestral_step(s, s_prev)
@@ -271,14 +299,17 @@ class EulerAScheduler(SchedulerMixin, ConfigMixin):
         self,
         original_samples: torch.FloatTensor,
         noise: torch.FloatTensor,
-        timesteps: torch.IntTensor,
+        timesteps: torch.FloatTensor,
     ) -> torch.FloatTensor:
         sigmas = self.sigmas.to(original_samples.device)
+        schedule_timesteps = self.timesteps.to(original_samples.device)
         timesteps = timesteps.to(original_samples.device)
+        step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
 
-        sigma = sigmas[timesteps].flatten()
+        sigma = sigmas[step_indices].flatten()
         while len(sigma.shape) < len(original_samples.shape):
             sigma = sigma.unsqueeze(-1)
 
         noisy_samples = original_samples + noise * sigma
+        self.is_scale_input_called = True
         return noisy_samples
diff --git a/textual_dreambooth.py b/textual_dreambooth.py
deleted file mode 100644
index c07d98b..0000000
--- a/textual_dreambooth.py
+++ /dev/null
@@ -1,917 +0,0 @@
-import argparse
-import itertools
-import math
-import os
-import datetime
-import logging
-from pathlib import Path
-
-import numpy as np
-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, UNet2DConditionModel
-from schedulers.scheduling_euler_a import EulerAScheduler
-from diffusers.optimization import get_scheduler
-from PIL import Image
-from tqdm.auto import tqdm
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-from slugify import slugify
-from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
-import json
-import os
-
-from data.dreambooth.csv import CSVDataModule
-
-logger = get_logger(__name__)
-
-
-torch.backends.cuda.matmul.allow_tf32 = 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 CSV file containing the training data."
-    )
-    parser.add_argument(
-        "--placeholder_token",
-        type=str,
-        default=None,
-        help="A token to use as a placeholder for the concept.",
-    )
-    parser.add_argument(
-        "--initializer_token",
-        type=str,
-        default=None,
-        help="A token to use as initializer word."
-    )
-    parser.add_argument(
-        "--use_class_images",
-        action="store_true",
-        default=True,
-        help="Include class images in the loss calculation a la Dreambooth.",
-    )
-    parser.add_argument(
-        "--repeats",
-        type=int,
-        default=100,
-        help="How many times to repeat the training data.")
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default="output/text-inversion",
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=None,
-        help="A seed for reproducible training.")
-    parser.add_argument(
-        "--resolution",
-        type=int,
-        default=512,
-        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(
-        "--num_train_epochs",
-        type=int,
-        default=100)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=5000,
-        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=1e-4,
-        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="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument(
-        "--lr_warmup_steps",
-        type=int,
-        default=500,
-        help="Number of steps for the warmup in the lr scheduler."
-    )
-    parser.add_argument(
-        "--use_8bit_adam",
-        action="store_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(
-        "--local_rank",
-        type=int,
-        default=-1,
-        help="For distributed training: local_rank"
-    )
-    parser.add_argument(
-        "--checkpoint_frequency",
-        type=int,
-        default=500,
-        help="How often to save a checkpoint and sample image",
-    )
-    parser.add_argument(
-        "--sample_image_size",
-        type=int,
-        default=512,
-        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(
-        "--train_batch_size",
-        type=int,
-        default=1,
-        help="Batch size (per device) for the training dataloader."
-    )
-    parser.add_argument(
-        "--sample_steps",
-        type=int,
-        default=30,
-        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(
-        "--resume_from",
-        type=str,
-        default=None,
-        help="Path to a directory to resume training from (ie, logs/token_name/2022-09-22T23-36-27)"
-    )
-    parser.add_argument(
-        "--resume_checkpoint",
-        type=str,
-        default=None,
-        help="Path to a specific checkpoint to resume training from (ie, logs/token_name/2022-09-22T23-36-27/checkpoints/something.bin)."
-    )
-    parser.add_argument(
-        "--config",
-        type=str,
-        default=None,
-        help="Path to a JSON configuration file containing arguments for invoking this script. If resume_from is given, its resume.json takes priority over this."
-    )
-
-    args = parser.parse_args()
-    if args.resume_from is not None:
-        with open(f"{args.resume_from}/resume.json", 'rt') as f:
-            args = parser.parse_args(
-                namespace=argparse.Namespace(**json.load(f)["args"]))
-    elif args.config is not None:
-        with open(args.config, 'rt') as f:
-            args = parser.parse_args(
-                namespace=argparse.Namespace(**json.load(f)["args"]))
-
-    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
-    if env_local_rank != -1 and env_local_rank != args.local_rank:
-        args.local_rank = env_local_rank
-
-    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.placeholder_token is None:
-        raise ValueError("You must specify --placeholder_token")
-
-    if args.initializer_token is None:
-        raise ValueError("You must specify --initializer_token")
-
-    if args.output_dir is None:
-        raise ValueError("You must specify --output_dir")
-
-    return args
-
-
-def freeze_params(params):
-    for param in params:
-        param.requires_grad = False
-
-
-def save_resume_file(basepath, args, extra={}):
-    info = {"args": vars(args)}
-    info["args"].update(extra)
-    with open(f"{basepath}/resume.json", "w") as f:
-        json.dump(info, f, indent=4)
-
-
-def make_grid(images, rows, cols):
-    w, h = images[0].size
-    grid = Image.new('RGB', size=(cols*w, rows*h))
-    for i, image in enumerate(images):
-        grid.paste(image, box=(i % cols*w, i//cols*h))
-    return grid
-
-
-class Checkpointer:
-    def __init__(
-        self,
-        datamodule,
-        accelerator,
-        vae,
-        unet,
-        tokenizer,
-        placeholder_token,
-        placeholder_token_id,
-        output_dir,
-        sample_image_size,
-        sample_batches,
-        sample_batch_size,
-        seed
-    ):
-        self.datamodule = datamodule
-        self.accelerator = accelerator
-        self.vae = vae
-        self.unet = unet
-        self.tokenizer = tokenizer
-        self.placeholder_token = placeholder_token
-        self.placeholder_token_id = placeholder_token_id
-        self.output_dir = output_dir
-        self.sample_image_size = sample_image_size
-        self.seed = seed or torch.random.seed()
-        self.sample_batches = sample_batches
-        self.sample_batch_size = sample_batch_size
-
-    @torch.no_grad()
-    def checkpoint(self, step, postfix, text_encoder, save_samples=True, path=None):
-        print("Saving checkpoint for step %d..." % step)
-
-        if path is None:
-            checkpoints_path = f"{self.output_dir}/checkpoints"
-            os.makedirs(checkpoints_path, exist_ok=True)
-
-        unwrapped = self.accelerator.unwrap_model(text_encoder)
-
-        # Save a checkpoint
-        learned_embeds = unwrapped.get_input_embeddings().weight[self.placeholder_token_id]
-        learned_embeds_dict = {self.placeholder_token: learned_embeds.detach().cpu()}
-
-        filename = f"%s_%d_%s.bin" % (slugify(self.placeholder_token), step, postfix)
-        if path is not None:
-            torch.save(learned_embeds_dict, path)
-        else:
-            torch.save(learned_embeds_dict, f"{checkpoints_path}/{filename}")
-            torch.save(learned_embeds_dict, f"{checkpoints_path}/last.bin")
-
-        del unwrapped
-        del learned_embeds
-
-    @torch.no_grad()
-    def save_samples(self, step, text_encoder, height, width, guidance_scale, eta, num_inference_steps):
-        samples_path = Path(self.output_dir).joinpath("samples")
-
-        unwrapped = self.accelerator.unwrap_model(text_encoder)
-        scheduler = EulerAScheduler(
-            beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear"
-        )
-
-        # Save a sample image
-        pipeline = VlpnStableDiffusion(
-            text_encoder=unwrapped,
-            vae=self.vae,
-            unet=self.unet,
-            tokenizer=self.tokenizer,
-            scheduler=scheduler,
-        ).to(self.accelerator.device)
-        pipeline.enable_attention_slicing()
-
-        train_data = self.datamodule.train_dataloader()
-        val_data = self.datamodule.val_dataloader()
-
-        generator = torch.Generator(device=pipeline.device).manual_seed(self.seed)
-        stable_latents = torch.randn(
-            (self.sample_batch_size, pipeline.unet.in_channels, height // 8, width // 8),
-            device=pipeline.device,
-            generator=generator,
-        )
-
-        for pool, data, latents in [("stable", val_data, stable_latents), ("val", val_data, None), ("train", train_data, None)]:
-            all_samples = []
-            file_path = samples_path.joinpath(pool, f"step_{step}.png")
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-
-            data_enum = enumerate(data)
-
-            for i in range(self.sample_batches):
-                batches = [batch for j, batch in data_enum if j * data.batch_size < self.sample_batch_size]
-                prompt = [prompt.format(self.placeholder_token)
-                          for batch in batches for prompt in batch["prompts"]][:self.sample_batch_size]
-                nprompt = [prompt for batch in batches for prompt in batch["nprompts"]][:self.sample_batch_size]
-
-                with self.accelerator.autocast():
-                    samples = pipeline(
-                        prompt=prompt,
-                        negative_prompt=nprompt,
-                        height=self.sample_image_size,
-                        width=self.sample_image_size,
-                        latents=latents[:len(prompt)] if latents is not None else None,
-                        generator=generator if latents is not None else None,
-                        guidance_scale=guidance_scale,
-                        eta=eta,
-                        num_inference_steps=num_inference_steps,
-                        output_type='pil'
-                    )["sample"]
-
-                all_samples += samples
-
-                del samples
-
-            image_grid = make_grid(all_samples, self.sample_batches, self.sample_batch_size)
-            image_grid.save(file_path)
-
-            del all_samples
-            del image_grid
-
-        del unwrapped
-        del scheduler
-        del pipeline
-        del generator
-        del stable_latents
-
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-
-def main():
-    args = parse_args()
-
-    global_step_offset = 0
-    if args.resume_from is not None:
-        basepath = Path(args.resume_from)
-        print("Resuming state from %s" % args.resume_from)
-        with open(basepath.joinpath("resume.json"), 'r') as f:
-            state = json.load(f)
-        global_step_offset = state["args"].get("global_step", 0)
-
-        print("We've trained %d steps so far" % global_step_offset)
-    else:
-        now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
-        basepath = Path(args.output_dir).joinpath(slugify(args.placeholder_token), 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)
-
-    # If passed along, set the training seed now.
-    if args.seed is not None:
-        set_seed(args.seed)
-
-    # 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 + '/tokenizer'
-        )
-
-    # Add the placeholder token in tokenizer
-    num_added_tokens = tokenizer.add_tokens(args.placeholder_token)
-    if num_added_tokens == 0:
-        raise ValueError(
-            f"The tokenizer already contains the token {args.placeholder_token}. Please pass a different"
-            " `placeholder_token` that is not already in the tokenizer."
-        )
-
-    # Convert the initializer_token, placeholder_token to ids
-    initializer_token_ids = tokenizer.encode(args.initializer_token, add_special_tokens=False)
-    # Check if initializer_token is a single token or a sequence of tokens
-    if len(initializer_token_ids) > 1:
-        raise ValueError(
-            f"initializer_token_ids must not have more than 1 vector, but it's {len(initializer_token_ids)}.")
-
-    initializer_token_ids = torch.tensor(initializer_token_ids)
-    placeholder_token_id = tokenizer.convert_tokens_to_ids(args.placeholder_token)
-
-    # Load models and create wrapper for stable diffusion
-    text_encoder = CLIPTextModel.from_pretrained(
-        args.pretrained_model_name_or_path + '/text_encoder',
-    )
-    vae = AutoencoderKL.from_pretrained(
-        args.pretrained_model_name_or_path + '/vae',
-    )
-    unet = UNet2DConditionModel.from_pretrained(
-        args.pretrained_model_name_or_path + '/unet',
-    )
-
-    if args.gradient_checkpointing:
-        unet.enable_gradient_checkpointing()
-
-    slice_size = unet.config.attention_head_dim // 2
-    unet.set_attention_slice(slice_size)
-
-    # Resize the token embeddings as we are adding new special tokens to the tokenizer
-    text_encoder.resize_token_embeddings(len(tokenizer))
-
-    # Initialise the newly added placeholder token with the embeddings of the initializer token
-    token_embeds = text_encoder.get_input_embeddings().weight.data
-
-    initializer_token_embeddings = text_encoder.get_input_embeddings()(initializer_token_ids)
-
-    if args.resume_checkpoint is not None:
-        token_embeds[placeholder_token_id] = torch.load(args.resume_checkpoint)[
-            args.placeholder_token]
-    else:
-        token_embeds[placeholder_token_id] = initializer_token_embeddings
-
-    # Freeze vae and unet
-    freeze_params(vae.parameters())
-    freeze_params(unet.parameters())
-    # Freeze all parameters except for the token embeddings in text encoder
-    params_to_freeze = itertools.chain(
-        text_encoder.text_model.encoder.parameters(),
-        text_encoder.text_model.final_layer_norm.parameters(),
-        text_encoder.text_model.embeddings.position_embedding.parameters(),
-    )
-    freeze_params(params_to_freeze)
-
-    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(
-        text_encoder.get_input_embeddings().parameters(),  # only optimize the embeddings
-        lr=args.learning_rate,
-        betas=(args.adam_beta1, args.adam_beta2),
-        weight_decay=args.adam_weight_decay,
-        eps=args.adam_epsilon,
-    )
-
-    noise_scheduler = DDPMScheduler(
-        beta_start=0.00085,
-        beta_end=0.012,
-        beta_schedule="scaled_linear",
-        num_train_timesteps=1000
-    )
-
-    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.use_class_images 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=torch.float32, memory_format=torch.contiguous_format)
-
-        input_ids = tokenizer.pad({"input_ids": input_ids}, padding=True, return_tensors="pt").input_ids
-
-        batch = {
-            "prompts": prompts,
-            "nprompts": nprompts,
-            "input_ids": input_ids,
-            "pixel_values": pixel_values,
-        }
-        return batch
-
-    datamodule = CSVDataModule(
-        data_file=args.train_data_file,
-        batch_size=args.train_batch_size,
-        tokenizer=tokenizer,
-        instance_identifier=args.placeholder_token,
-        class_identifier=args.initializer_token if args.use_class_images else None,
-        class_subdir="ti_cls",
-        size=args.resolution,
-        repeats=args.repeats,
-        center_crop=args.center_crop,
-        valid_set_size=args.sample_batch_size*args.sample_batches,
-        collate_fn=collate_fn
-    )
-
-    datamodule.prepare_data()
-    datamodule.setup()
-
-    if args.use_class_images:
-        missing_data = [item for item in datamodule.data if not item[1].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)]
-
-            scheduler = EulerAScheduler(
-                beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear"
-            )
-
-            pipeline = VlpnStableDiffusion(
-                text_encoder=text_encoder,
-                vae=vae,
-                unet=unet,
-                tokenizer=tokenizer,
-                scheduler=scheduler,
-            ).to(accelerator.device)
-            pipeline.enable_attention_slicing()
-
-            for batch in batched_data:
-                image_name = [p[1] for p in batch]
-                prompt = [p[2].format(args.initializer_token) for p in batch]
-                nprompt = [p[3] for p in batch]
-
-                with accelerator.autocast():
-                    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()
-
-    checkpointer = Checkpointer(
-        datamodule=datamodule,
-        accelerator=accelerator,
-        vae=vae,
-        unet=unet,
-        tokenizer=tokenizer,
-        placeholder_token=args.placeholder_token,
-        placeholder_token_id=placeholder_token_id,
-        output_dir=basepath,
-        sample_image_size=args.sample_image_size,
-        sample_batch_size=args.sample_batch_size,
-        sample_batches=args.sample_batches,
-        seed=args.seed
-    )
-
-    # 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
-
-    lr_scheduler = get_scheduler(
-        args.lr_scheduler,
-        optimizer=optimizer,
-        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
-        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
-    )
-
-    text_encoder, optimizer, train_dataloader, val_dataloader, lr_scheduler = accelerator.prepare(
-        text_encoder, optimizer, train_dataloader, val_dataloader, lr_scheduler
-    )
-
-    # Move vae and unet to device
-    vae.to(accelerator.device)
-    unet.to(accelerator.device)
-
-    # Keep vae and unet in eval mode as we don't train these
-    vae.eval()
-    unet.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:
-        accelerator.init_trackers("textual_inversion", config=vars(args))
-
-    # 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
-    min_val_loss = np.inf
-
-    if accelerator.is_main_process:
-        checkpointer.save_samples(
-            0,
-            text_encoder,
-            args.resolution, args.resolution, 7.5, 0.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)
-    local_progress_bar.set_description("Batch X out of Y")
-
-    global_progress_bar = tqdm(range(args.max_train_steps + val_steps), disable=not accelerator.is_local_main_process)
-    global_progress_bar.set_description("Total progress")
-
-    try:
-        for epoch in range(num_epochs):
-            local_progress_bar.set_description(f"Batch {epoch + 1} out of {num_epochs}")
-            local_progress_bar.reset()
-
-            text_encoder.train()
-            train_loss = 0.0
-
-            for step, batch in enumerate(train_dataloader):
-                with accelerator.accumulate(text_encoder):
-                    # Convert images to latent space
-                    with torch.no_grad():
-                        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(latents.shape).to(latents.device)
-                    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 = text_encoder(batch["input_ids"])[0]
-
-                    # Predict the noise residual
-                    noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-                    if args.use_class_images:
-                        # Chunk the noise and noise_pred into two parts and compute the loss on each part separately.
-                        noise_pred, noise_pred_prior = torch.chunk(noise_pred, 2, dim=0)
-                        noise, noise_prior = torch.chunk(noise, 2, dim=0)
-
-                        # Compute instance loss
-                        loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
-
-                        # Compute prior loss
-                        prior_loss = F.mse_loss(noise_pred_prior, noise_prior, reduction="none").mean([1, 2, 3]).mean()
-
-                        # Add the prior loss to the instance loss.
-                        loss = loss + args.prior_loss_weight * prior_loss
-                    else:
-                        loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
-
-                    accelerator.backward(loss)
-
-                    # Zero out the gradients for all token embeddings except the newly added
-                    # embeddings for the concept, as we only want to optimize the concept embeddings
-                    if accelerator.num_processes > 1:
-                        grads = text_encoder.module.get_input_embeddings().weight.grad
-                    else:
-                        grads = text_encoder.get_input_embeddings().weight.grad
-                    # Get the index for tokens that we want to zero the grads for
-                    index_grads_to_zero = torch.arange(len(tokenizer)) != placeholder_token_id
-                    grads.data[index_grads_to_zero, :] = grads.data[index_grads_to_zero, :].fill_(0)
-
-                    optimizer.step()
-                    if not accelerator.optimizer_step_was_skipped:
-                        lr_scheduler.step()
-                    optimizer.zero_grad(set_to_none=True)
-
-                    loss = loss.detach().item()
-                    train_loss += loss
-
-                # 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
-
-                    if global_step % args.checkpoint_frequency == 0 and global_step > 0 and accelerator.is_main_process:
-                        local_progress_bar.clear()
-                        global_progress_bar.clear()
-
-                        checkpointer.checkpoint(global_step + global_step_offset, "training", text_encoder)
-                        save_resume_file(basepath, args, {
-                            "global_step": global_step + global_step_offset,
-                            "resume_checkpoint": f"{basepath}/checkpoints/last.bin"
-                        })
-
-                logs = {"mode": "training", "loss": loss, "lr": lr_scheduler.get_last_lr()[0]}
-                local_progress_bar.set_postfix(**logs)
-
-                if global_step >= args.max_train_steps:
-                    break
-
-            train_loss /= len(train_dataloader)
-
-            accelerator.wait_for_everyone()
-
-            text_encoder.eval()
-            val_loss = 0.0
-
-            for step, batch in enumerate(val_dataloader):
-                with torch.no_grad():
-                    latents = vae.encode(batch["pixel_values"]).latent_dist.sample()
-                    latents = latents * 0.18215
-
-                    noise = torch.randn(latents.shape).to(latents.device)
-                    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 = text_encoder(batch["input_ids"])[0]
-
-                    noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-                    noise_pred, noise = accelerator.gather_for_metrics((noise_pred, noise))
-
-                    loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
-
-                    loss = loss.detach().item()
-                    val_loss += loss
-
-                if accelerator.sync_gradients:
-                    local_progress_bar.update(1)
-                    global_progress_bar.update(1)
-
-                logs = {"mode": "validation", "loss": loss}
-                local_progress_bar.set_postfix(**logs)
-
-            val_loss /= len(val_dataloader)
-
-            accelerator.log({"train/loss": train_loss, "val/loss": val_loss}, step=global_step)
-
-            local_progress_bar.clear()
-            global_progress_bar.clear()
-
-            if min_val_loss > val_loss:
-                accelerator.print(f"Validation loss reached new minimum: {min_val_loss:.2e} -> {val_loss:.2e}")
-                checkpointer.checkpoint(global_step + global_step_offset, "milestone", text_encoder)
-                min_val_loss = val_loss
-
-            if accelerator.is_main_process:
-                checkpointer.save_samples(
-                    global_step + global_step_offset,
-                    text_encoder,
-                    args.resolution, args.resolution, 7.5, 0.0, 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.checkpoint(
-                global_step + global_step_offset,
-                "end",
-                text_encoder,
-                path=f"{basepath}/learned_embeds.bin"
-            )
-
-            save_resume_file(basepath, args, {
-                "global_step": global_step + global_step_offset,
-                "resume_checkpoint": f"{basepath}/checkpoints/last.bin"
-            })
-
-            accelerator.end_training()
-
-    except KeyboardInterrupt:
-        if accelerator.is_main_process:
-            print("Interrupted, saving checkpoint and resume state...")
-            checkpointer.checkpoint(global_step + global_step_offset, "end", text_encoder)
-            save_resume_file(basepath, args, {
-                "global_step": global_step + global_step_offset,
-                "resume_checkpoint": f"{basepath}/checkpoints/last.bin"
-            })
-            accelerator.end_training()
-        quit()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/textual_inversion.py b/textual_inversion.py
index 7919ebd..11c324d 100644
--- a/textual_inversion.py
+++ b/textual_inversion.py
@@ -25,7 +25,7 @@ from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
 import json
 import os
 
-from data.textual_inversion.csv import CSVDataModule
+from data.csv import CSVDataModule
 
 logger = get_logger(__name__)
 
@@ -68,10 +68,10 @@ def parse_args():
         help="A token to use as initializer word."
     )
     parser.add_argument(
-        "--vectors_per_token",
-        type=int,
-        default=1,
-        help="Vectors per token."
+        "--use_class_images",
+        action="store_true",
+        default=True,
+        help="Include class images in the loss calculation a la Dreambooth.",
     )
     parser.add_argument(
         "--repeats",
@@ -234,6 +234,12 @@ def parse_args():
         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(
         "--resume_from",
         type=str,
         default=None,
@@ -395,7 +401,8 @@ class Checkpointer:
 
             for i in range(self.sample_batches):
                 batches = [batch for j, batch in data_enum if j * data.batch_size < self.sample_batch_size]
-                prompt = [prompt for batch in batches for prompt in batch["prompts"]][:self.sample_batch_size]
+                prompt = [prompt.format(self.placeholder_token)
+                          for batch in batches for prompt in batch["prompts"]][:self.sample_batch_size]
                 nprompt = [prompt for batch in batches for prompt in batch["nprompts"]][:self.sample_batch_size]
 
                 with self.accelerator.autocast():
@@ -556,25 +563,94 @@ def main():
         eps=args.adam_epsilon,
     )
 
-    # TODO (patil-suraj): laod scheduler using args
     noise_scheduler = DDPMScheduler(
-        beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", num_train_timesteps=1000
+        beta_start=0.00085,
+        beta_end=0.012,
+        beta_schedule="scaled_linear",
+        num_train_timesteps=1000
     )
 
+    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.use_class_images 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=torch.float32, memory_format=torch.contiguous_format)
+
+        input_ids = tokenizer.pad({"input_ids": input_ids}, padding=True, return_tensors="pt").input_ids
+
+        batch = {
+            "prompts": prompts,
+            "nprompts": nprompts,
+            "input_ids": input_ids,
+            "pixel_values": pixel_values,
+        }
+        return batch
+
     datamodule = CSVDataModule(
         data_file=args.train_data_file,
         batch_size=args.train_batch_size,
         tokenizer=tokenizer,
+        instance_identifier=args.placeholder_token,
+        class_identifier=args.initializer_token if args.use_class_images else None,
+        class_subdir="ti_cls",
         size=args.resolution,
-        placeholder_token=args.placeholder_token,
         repeats=args.repeats,
         center_crop=args.center_crop,
-        valid_set_size=args.sample_batch_size*args.sample_batches
+        valid_set_size=args.sample_batch_size*args.sample_batches,
+        collate_fn=collate_fn
     )
 
     datamodule.prepare_data()
     datamodule.setup()
 
+    if args.use_class_images:
+        missing_data = [item for item in datamodule.data if not item[1].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)]
+
+            scheduler = EulerAScheduler(
+                beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear"
+            )
+
+            pipeline = VlpnStableDiffusion(
+                text_encoder=text_encoder,
+                vae=vae,
+                unet=unet,
+                tokenizer=tokenizer,
+                scheduler=scheduler,
+            ).to(accelerator.device)
+            pipeline.enable_attention_slicing()
+
+            for batch in batched_data:
+                image_name = [p[1] for p in batch]
+                prompt = [p[2].format(args.initializer_token) for p in batch]
+                nprompt = [p[3] for p in batch]
+
+                with accelerator.autocast():
+                    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()
 
@@ -693,7 +769,21 @@ def main():
                     # Predict the noise residual
                     noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
 
-                    loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
+                    if args.use_class_images:
+                        # Chunk the noise and noise_pred into two parts and compute the loss on each part separately.
+                        noise_pred, noise_pred_prior = torch.chunk(noise_pred, 2, dim=0)
+                        noise, noise_prior = torch.chunk(noise, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(noise_pred_prior, noise_prior, reduction="none").mean([1, 2, 3]).mean()
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
 
                     accelerator.backward(loss)