{ "cells": [ { "cell_type": "markdown", "id": "7bc6e627-f856-4ead-8239-79eb24907eed", "metadata": {}, "source": [ "# Consistency Trajectory Models (CTM)\n", "\n", "[![arXiv](https://img.shields.io/badge/arXiv-2310.02279-.svg)](https://arxiv.org/abs/2310.02279) [![GitHub Repo stars](https://img.shields.io/github/stars/sony/ctm?style=social) ](https://github.com/sony/ctm)" ] }, { "cell_type": "markdown", "id": "bedc506f-44f9-4131-b042-4f0cf8c23164", "metadata": {}, "source": [ "## 📖 Introduction\n", "\n", "[A Consistency Trajectory Model (CTM)](https://consistencytrajectorymodel.github.io/CTM/) is a novel generative model that generalizes existing approaches like [Consistency Models](https://github.com/openai/consistency_models) and score-based diffusion models. It trains a single neural network to learn the entire trajectory of the Probability Flow Ordinary Differential Equation (ODE) in a diffusion process. This allows the model to output both scores (gradients of log-density) and enable movement between any points along the ODE solution curve in a single forward pass. By learning the full ODE trajectory, CTM offers fast, high-quality, and flexible sampling, overcoming limitations of previous approaches. The integration of GAN loss for performance enhancement and the introduction of γ-sampling for controlling stochasticity and semantic preservation are particularly noteworthy contributions.\n", "\n", "\"CTM\"\n", "\n", "### Key Idea\n", "\n", "_Learn a model that directly parameterizes the entire probability flow ODE trajectory of diffusion models, enabling efficient sampling at arbitrary noise levels while preserving trajectory consistency. Essentially, CTM learns to represent the entire trajectory of the diffusion process, allowing for flexible and efficient sampling and generation._\n", "\n", "### Definition of Consistency Trajectory Models (CTM)\n", "\n", "CTM estimates the \"anytime-to-anytime jump\" along the PF ODE, meaning it can predict both infinitesimally small jumps (related to the score function) and long jumps (the integral over any time horizon). This provides increased flexibility during inference.\n", "\n", "The true solution of the PF ODE from initial time $t$ to final time $s \\leq t $ is defined as:\n", "\n", "$G(x_t, t, s) := x_t + \\int_{t}^{s} \\frac{x_u - E[x|x_u]}{u} \\, du $\n", "\n", "The trajectory function of models:\n", "- teacher trajectory:= $G_{sg}(\\theta) (G_{sg}(\\theta)(TeacherSolver(x_t,t,u),u,s),s,0)$\n", "- student trajectory:= $G_{sg}(\\theta) (G_{sg}(\\theta)((x_t,t,s),s,0))$\n", "\n", "### Key features and Contributions\n", "\n", "- High-quality and fast sampling (single step or with a few steps)\n", "- Flexible Sampling Schemes (γ-sampling) - Controllable Semantic Information in Generation (inpainting)\n", "- Clear Trade-off between Speed and Quality\n", "- Student model beats teacher model\n", "\n", "\"γ-sampling\" \n", "\"CTM\"\n", "\n", "\n", "## Training Methodology:\n", "\n", "![CTM Training](assets/ctm_model.svg)\n", "\n", "CTMs (the \"student model\") are typically trained by distilling knowledge from a pre-trained diffusion model (the \"teacher model\").\n", "\n", "- The CTM is trained to replicate the trajectory of the teacher model's ODE solution\n", "- The training involves defining an initial state (x_t), a start time (t), and an end time (s). An intermediate time (u) is used to split the teacher's trajectory.\n", "- Knowledge Distillation: TThe model then learns to map from x_t to x_s directly, while also ensuring consistency by comparing this direct path to a path that goes from x_t to x_u using the teacher model and then from x_u to x_s using the CTM. \n", "- Consistency Loss: The CTM aims to make the point reached by applying only the CTM from t to s consistent with the point reached by applying the teacher from t to u and then the CTM from u to s. \"CTM tries to match these two points.\"\n", "- Perceptual Alignment: To improve the perceived quality of generations, the trajectory is also extended back to time 0 (the clean image).\n", "- GAN Loss for Quality Improvement (\"Student Beats Teacher\"): CTM incorporates a GAN loss by directly comparing the output of the CTM at time 0 (x_student) with the true data (x_true). This allows the CTM's performance to exceed that of the teacher model, overcoming the limitations of purely distilling the teacher's knowledge which may have inherent errors. \n", "\n", "### γ-sampling in CTMs\n", "γ-sampling is a new sampling method enabled by CTM's knowledge of the entire solution trajectory. γ is a hyperparameter that allows users to adjust the stochasticity of the sampling process. \n", "\n", "![CTM](assets/cat.png)\n", "\n", "- When γ=1, the sampling is fully stochastic and similar to baseline methods. \n", "- When γ=0, the sampling is deterministic and unique to CTM. \n", "\n", "By setting γ to values between 0 and 1, users can introduce a desired level of stochasticity. This flexibility allows for controlling the degree to which the generated image retains semantic information from the initial state, making it useful for tasks like inpainting where semantic preservation is important, or for generating diverse images where meaning change is desired.\n", "\n", "### Advantages over prior Distillation models\n", "\n", "- More efficient learning of the entire probability flow trajectory\n", "- Better preservation of trajectory consistency\n", "- Higher Single-Step Performance\n", "- More flexible control over the generation process\n", "- Enhanced distillation of diffusion model knowledge\n", "\n", "## Cross domain application of CTM\n", "\n", "Consistency Trajectory Models provide a powerful framework for generative modeling across various domains. While we've explored the theoretical foundations and applications of CTM in image domain, the concept generalizes beyond image domain, like audio. For example - SoundCTM.\n", "\n", "Sound generation represents an ideal application domain for CTM's unique capabilities. The temporal nature of audio, with its complex frequency relationships and phase coherence requirements, benefits tremendously from CTM's trajectory-based approach. \n", "\n", "#### SoundCTM resources\n", "\n", "- https://arxiv.org/pdf/2405.18503\n", "- https://github.com/sony/soundctm\n", "\n", "\n", "## CTM - Author's words:\n", "[![Youtube](https://i.ytimg.com/vi/Bp2t8IFmDGU/hq720.jpg?sqp=-oaymwEnCNAFEJQDSFryq4qpAxkIARUAAIhCGAHYAQHiAQoIGBACGAY4AUAB&rs=AOn4CLCuGZOY3BOVZAiQAbZT6KzU2nZQ3A)](https://www.youtube.com/watch?v=Bp2t8IFmDGU&pp=ygVMQ1RNOiBBZHZhbmNlZCBTaW5nbGUtU3RlcCBESWZmdXNpb24gTW9kZWwgZm9yIEZhc3QgYW5kIEhpZ2gtUXVhbGl0eSBTYW1wbGluZw%3D%3D)\n", "\n", "\n", "### References\n", "\n", "[1] Yang, Y., et al. (2023). Consistency Trajectory Models: Learning Probability Flow ODE Trajectory of Diffusion. arXiv.org. https://arxiv.org/abs/2310.02279\n", "\n", "[2] Song, Y., Dhariwal, P., Chen, M., & Sutskever, I. (2023). Consistency models. arXiv.org. https://arxiv.org/abs/2303.01469\n", "\n", "[3] Karras, T., Aittala, M., Aila, T., & Laine, S. (2022). Elucidating the design space of diffusion-based Generative Models. arXiv.org. https://arxiv.org/abs/2206.00364" ] }, { "cell_type": "markdown", "id": "2089bdab-7fa5-4508-8acc-4138039cac28", "metadata": {}, "source": [ "## 🛠️ Setup" ] }, { "cell_type": "markdown", "id": "322a9a7e-c6f8-4e6e-b7dd-a1478f51c965", "metadata": {}, "source": [ "### Imports" ] }, { "cell_type": "code", "execution_count": 1, "id": "24266393-2204-4426-bba2-bc09aa97f233", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cuda\n", "cuda\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/root/miniforge3/envs/ctm/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] } ], "source": [ "import torch as th\n", "import numpy as np\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "\n", "# Importing all the classes for distillation training from other scripts\n", "\n", "from utils import *\n", "from distillation_utils import *\n", "from model import *\n", "import argparse\n", "import sys " ] }, { "cell_type": "markdown", "id": "e6503092-3316-4976-9b5a-8de121f47eb5", "metadata": {}, "source": [ "## 🧠 Implementation" ] }, { "cell_type": "markdown", "id": "26cf5a8b-84b4-4e1f-8a7e-c33d26437df8", "metadata": {}, "source": [ "### Download and extract the dataset" ] }, { "cell_type": "code", "execution_count": null, "id": "0c556562-d6ac-4d76-8b87-4bbf4b9ef264", "metadata": {}, "outputs": [], "source": [ "!gdown https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz && tar -xf cifar-10-python.tar.gz" ] }, { "cell_type": "markdown", "id": "59627d8f-389d-42ec-a379-b8a248aef1e9", "metadata": {}, "source": [ "### Unpickle and save the dataset" ] }, { "cell_type": "code", "execution_count": null, "id": "bba74e06-eba2-47e1-ac24-a94fdc8a5e5e", "metadata": {}, "outputs": [], "source": [ "import pickle\n", "import os\n", "from PIL import Image\n", "\n", "def unpickle(file):\n", " with open(file, 'rb') as fo:\n", " dict = pickle.load(fo, encoding='bytes')\n", " return dict\n", "\n", "def save_cifar10_as_images(cifar_dir, output_dir):\n", " # Load class names\n", " meta = unpickle(os.path.join(cifar_dir, 'batches.meta'))\n", " class_names = [label.decode('utf-8') for label in meta[b'label_names']]\n", " \n", " # Create directories for each class\n", " for class_name in class_names:\n", " os.makedirs(os.path.join(output_dir, class_name), exist_ok=True)\n", " \n", " # Process training data\n", " for batch_id in range(1, 6):\n", " batch_file = os.path.join(cifar_dir, f'data_batch_{batch_id}')\n", " batch_data = unpickle(batch_file)\n", " images = batch_data[b'data']\n", " labels = batch_data[b'labels']\n", " \n", " for i, (image, label) in enumerate(zip(images, labels)):\n", " # Reshape and convert to RGB image\n", " image = image.reshape(3, 32, 32).transpose(1, 2, 0)\n", " img = Image.fromarray(image)\n", " # Save image\n", " img_path = os.path.join(output_dir, class_names[label], f'train_batch{batch_id}_{i}.png')\n", " img.save(img_path)\n", " \n", " # Process test data\n", " test_batch = unpickle(os.path.join(cifar_dir, 'test_batch'))\n", " test_images = test_batch[b'data']\n", " test_labels = test_batch[b'labels']\n", " \n", " for i, (image, label) in enumerate(zip(test_images, test_labels)):\n", " # Reshape and convert to RGB image\n", " image = image.reshape(3, 32, 32).transpose(1, 2, 0)\n", " img = Image.fromarray(image)\n", " # Save image\n", " img_path = os.path.join(output_dir, class_names[label], f'test_{i}.png')\n", " img.save(img_path)\n", "\n", "# Usage\n", "cifar_dir = 'cifar-10-batches-py' # Path to your extracted CIFAR-10 directory\n", "output_dir = 'cifar10_images' # Where to save the images in folder structure\n", "save_cifar10_as_images(cifar_dir, output_dir)" ] }, { "cell_type": "markdown", "id": "12985434-f2f5-4df9-b3d5-23eb2a06a496", "metadata": {}, "source": [ "#### Initialize Arguments" ] }, { "cell_type": "code", "execution_count": 13, "id": "472c0984-303a-4fd6-98de-3e0be1c9cd44", "metadata": {}, "outputs": [], "source": [ "def create_argparser():\n", "\n", " defaults = dict(\n", " generator=\"determ\",\n", " eval_batch=16,\n", " sampler=\"heun\",\n", " s_churn=0.0,\n", " s_tmin=0.0,\n", " s_tmax=float(\"inf\"),\n", " s_noise=1.0,\n", " sampling_steps=40,\n", " model_path=\"\",\n", " eval_seed=42,\n", " save_format='png',\n", " stochastic_seed=False,\n", " data_name='cifar10',\n", " ind_1=0,\n", " ind_2=0,\n", " gamma=0.5,\n", " )\n", " defaults.update(train_defaults(defaults['data_name']))\n", " defaults.update(model_and_diffusion_defaults(defaults['data_name']))\n", " defaults.update(cm_train_defaults(defaults['data_name']))\n", " defaults.update(ctm_train_defaults(defaults['data_name']))\n", " defaults.update(ctm_eval_defaults(defaults['data_name']))\n", " defaults.update(ctm_loss_defaults(defaults['data_name']))\n", " defaults.update(ctm_data_defaults(defaults['data_name']))\n", " parser = argparse.ArgumentParser()\n", " add_dict_to_argparser(parser, defaults)\n", " return parser" ] }, { "cell_type": "code", "execution_count": 14, "id": "624e1ac0-921b-49fe-b0ef-d6bc30b50940", "metadata": {}, "outputs": [], "source": [ "MODEL_FLAGS=\"--start_ema=0.999 --save_check_period=1000 --eval_interval=5000 --eval_fid=True --eval_similarity=False --check_dm_performance=False --compute_ema_fids=True --gan_fake_inner_type=model --gan_fake_outer_type=target_model_sg --gan_training=True --g_learning_period=2 \"\n", "CKPT_FLAGS = \"--out_dir=./ --model_path=./model095000.pt --eval_num_samples=8 --batch_size=8 --ind_1=1 --ind_2=0 --class_cond=False --sampler=exact --sampling_steps=100 --device_id=1\"" ] }, { "cell_type": "code", "execution_count": 15, "id": "5e233d73-c641-4431-a40c-1d296e7186f6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Logging to ./\n" ] } ], "source": [ "# Prepend a dummy program name and split the flag strings:\n", "sys.argv = [\"notebook\"] + MODEL_FLAGS.split() + CKPT_FLAGS.split()\n", "\n", "# Now your existing argument parsing code should work:\n", "args = create_argparser().parse_args()\n", "configure(args, dir=args.out_dir)" ] }, { "cell_type": "markdown", "id": "c6fd8141-d4e3-4598-ae3b-e364be4fe518", "metadata": {}, "source": [ "### Modules" ] }, { "cell_type": "markdown", "id": "afb9b8cc", "metadata": {}, "source": [ "#### DataModule" ] }, { "cell_type": "code", "execution_count": 16, "id": "1819bb38", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cuda\n" ] } ], "source": [ "if th.cuda.is_available():\n", " dev = th.device(\"cuda\")\n", " print(dev)\n", "else:\n", " dev = th.device(\"cpu\")" ] }, { "cell_type": "code", "execution_count": 17, "id": "ec2f3f39", "metadata": {}, "outputs": [], "source": [ "\n", "class KarrasDenoiser_custom(KarrasDenoiser):\n", " \"\"\"This class consists of all the proposed concepts related to CTM\n", " \n", " \"\"\"\n", " def __init__(\n", " self,\n", " args,\n", " schedule_sampler,\n", " diffusion_schedule_sampler,\n", " feature_extractor=None,\n", " discriminator_feature_extractor=None,\n", " ):\n", " self.args = args\n", " self.schedule_sampler = schedule_sampler\n", " self.diffusion_schedule_sampler = diffusion_schedule_sampler\n", " self.feature_extractor = feature_extractor\n", " self.discriminator_feature_extractor = discriminator_feature_extractor\n", " self.num_timesteps = args.start_scales\n", " self.dist = nn.MSELoss(reduction='none')\n", "\n", " def get_num_heun_step(self, start_scales=-1, num_heun_step=-1, num_heun_step_random=None, heun_step_strategy='', time_continuous=None):\n", " \n", " # Random heun steps = True, Time continuous = False, Heun step strategy = uniform\n", " num_heun_step = np.random.randint(1,1+self.args.num_heun_step)\n", " return num_heun_step\n", "\n", " def ctm_losses(\n", " self,\n", " step,\n", " model,\n", " x_start,\n", " model_kwargs=None,\n", " target_model=None,\n", " noise=None,\n", " discriminator=None,\n", " init_step=0,\n", " ctm=True,\n", " num_heun_step=-1,\n", " gan_num_heun_step=-1,\n", " diffusion_training_=False,\n", " gan_training_=False,\n", " ):\n", " if model_kwargs is None:\n", " model_kwargs = {}\n", " if noise is None:\n", " noise = th.randn_like(x_start)\n", "\n", " # Getting the timesteps for s and t\n", " dims = x_start.ndim\n", " s = None\n", " terms = {}\n", "\n", " # Get the number of heun step: \n", " # This step selects random heun step OR timestep t\n", " num_heun_step = self.get_num_heun_step(num_heun_step=self.args.num_heun_step)\n", " \n", " # Get the indexes for timestep\n", " indices, _ = self.schedule_sampler.sample_t(x_start.shape[0], x_start.device, num_heun_step,\n", " self.args.time_continuous)\n", " # Get the EDM mapped t timestep \n", " t = self.get_t(indices)\n", "\n", " # Get the EDM mapped u timestep --> only used with teacher\n", " t_dt = self.get_t(indices + num_heun_step)\n", " if ctm:\n", " # Get the index for s timestep\n", " new_indices = self.schedule_sampler.sample_s(self.args, x_start.shape[0], x_start.device, indices,\n", " num_heun_step, self.args.time_continuous,\n", " N=self.args.start_scales)\n", " # Get the EDM mapped s timestep \n", " s = self.get_t(new_indices)\n", " \n", " # Add noise to image\n", " x_t = x_start + noise * append_dims(t, dims)\n", " \n", " dropout_state = th.get_rng_state()\n", " th.set_rng_state(dropout_state)\n", "\n", " # Get the output/estimate of student model\n", " if self.args.ctm_training:\n", " # The student model tries to predict denoisified version of x_t at timestep s given timestep t\n", " ctm_estimate = self.get_ctm_estimate(x_t, t, s, model, target_model, ctm=ctm,\n", " outer_type=self.args.ctm_estimate_outer_type,\n", " **model_kwargs)\n", " \n", " # If Adversarial training is enabled (gan_training = True)\n", " # we update Generator only at certain frequencies decided by argument g_learning_period\n", " # Generator update stage\n", " # If Gan training is enabled\n", " # loss = CTM loss + DSM loss + Generator loss(If gan training is enabled)\n", " # else\n", " # loss = CTM loss + DSM loss\n", " if step % self.args.g_learning_period == 0 or not self.args.gan_training:\n", " x_t_dt = self.heun_solver(target_model, x_t, indices, dims, t, t_dt, ctm=ctm, num_step=num_heun_step,\n", " **model_kwargs).detach()\n", " ctm_target = self.get_ctm_target(x_t_dt, t_dt, s, model, target_model, ctm=ctm,\n", " inner_type=self.args.ctm_target_inner_type, **model_kwargs)\n", "\n", " snrs = self.get_snr(t)\n", " weights = get_weightings(self.args.weight_schedule, snrs, self.args.sigma_data, t, s, self.args.weight_schedule_multiplier)\n", "\n", " terms[\"consistency_loss\"] = self.get_CTM_loss(ctm_estimate, ctm_target, weights, step - init_step,)\n", "\n", " terms['denoising_loss'] = self.get_DSM_loss(model, x_start, model_kwargs,\n", " terms[\"consistency_loss\"] if self.args.ctm_training else None,\n", " step, init_step)\n", "\n", " if self.args.gan_training and step - init_step >= self.args.discriminator_start_itr:\n", " if gan_training_:\n", " gan_x_t, gan_t, gan_t_dt, gan_s, _, _ = self.get_gan_time(x_start, noise, x_t, t, t_dt, s, indices,\n", " num_heun_step, gan_num_heun_step)\n", " gan_fake = self.get_gan_fake(ctm_estimate, gan_x_t, gan_t, gan_t_dt, gan_s, model, target_model, ctm,\n", " step - init_step, **model_kwargs)\n", " terms['d_loss'] = self.get_GAN_loss(model, fake=gan_fake,\n", " consistency_loss=terms[\"consistency_loss\"],\n", " discriminator=discriminator,\n", " step=step, init_step=init_step)\n", " # Discriminator update stage\n", " # loss = Adversarial GAN loss\n", " else:\n", " gan_x_t, gan_t, gan_t_dt, gan_s, gan_indices, gan_num_heun_step = \\\n", " self.get_gan_time(x_start, noise, x_t, t, t_dt, s, indices, num_heun_step, gan_num_heun_step)\n", " gan_real = self.get_gan_real(x_start, gan_x_t, gan_t, gan_t_dt, gan_s, gan_indices, dims, gan_num_heun_step,\n", " model, target_model, ctm, step - init_step, **model_kwargs)\n", " gan_fake = self.get_gan_fake(ctm_estimate, gan_x_t, gan_t, gan_t_dt, gan_s, model, target_model, ctm,\n", " step - init_step, **model_kwargs)\n", " terms['d_loss'] = self.get_GAN_loss(model, fake=gan_fake, real=gan_real,\n", " learn_generator=False, discriminator=discriminator,\n", " step=step, init_step=init_step, **model_kwargs)\n", " return terms\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "id": "1055949c", "metadata": {}, "outputs": [], "source": [ "def create_model_and_diffusion(args, feature_extractor=None, discriminator_feature_extractor=None, teacher=False):\n", " \"\"\"Creates Model architecture skeleton and distillation class(Karras denoiser)\"\"\"\n", " schedule_sampler = create_named_schedule_sampler(args, args.schedule_sampler, args.start_scales)\n", " diffusion_schedule_sampler = create_named_schedule_sampler(args, args.diffusion_schedule_sampler, args.start_scales)\n", " model = EDMPrecond_CTM(img_resolution=args.image_size, img_channels=3,\n", " label_dim=1000 if args.data_name.lower() == 'imagenet64' else 10 if args.class_cond else 0, use_fp16=args.use_fp16,\n", " sigma_min=args.sigma_min, sigma_max=args.sigma_max,\n", " sigma_data=args.sigma_data, model_type='SongUNet' if args.data_name.lower() == 'cifar10' else 'DhariwalUNet',\n", " teacher=teacher, teacher_model_path=args.teacher_model_path or args.model_path,\n", " training_mode=args.training_mode, arch='ddpmpp' if args.data_name.lower() == 'cifar10' else 'adm',\n", " linear_probing=args.linear_probing)\n", "\n", " diffusion = KarrasDenoiser(\n", " args=args, schedule_sampler=schedule_sampler,\n", " diffusion_schedule_sampler=diffusion_schedule_sampler,\n", " feature_extractor=feature_extractor,\n", " discriminator_feature_extractor=discriminator_feature_extractor,\n", " )\n", " return model, diffusion" ] }, { "cell_type": "code", "execution_count": 19, "id": "880c64ae", "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/root/miniforge3/envs/ctm/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", " warnings.warn(\n", "/root/miniforge3/envs/ctm/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n", " warnings.warn(msg)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "printing the name of backbone::::: deit_base_distilled_patch16_224\n", "printing the name of backbone::::: tf_efficientnet_lite0\n" ] }, { "data": { "text/plain": [ "EDMPrecond_CTM(\n", " (model): SongUNet(\n", " (map_noise): PositionalEmbedding()\n", " (map_layer0): Linear()\n", " (map_layer1): Linear()\n", " (map_layer0_s): Linear()\n", " (map_layer1_s): Linear()\n", " (enc): ModuleDict(\n", " (32x32_conv): Conv2d()\n", " (32x32_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (32x32_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (32x32_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (16x16_down): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (16x16_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (16x16_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (16x16_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (8x8_down): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " )\n", " (dec): ModuleDict(\n", " (8x8_in0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (8x8_in1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block4): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_up): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block4): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (32x32_up): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block4): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_aux_norm): GroupNorm()\n", " (32x32_aux_conv): Conv2d()\n", " )\n", " )\n", ")" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ema_scale_fn = create_ema_and_scales_fn( \n", " target_ema_mode=args.target_ema_mode,\n", " start_ema=args.start_ema,\n", " scale_mode=args.scale_mode,\n", " start_scales=args.start_scales,\n", " end_scales=args.end_scales,\n", " total_steps=args.total_training_steps,\n", " distill_steps_per_iter=args.distill_steps_per_iter,\n", " )\n", "\n", "# Load Feature Extractor\n", "feature_extractor = load_feature_extractor(args, eval=True)\n", "\n", "# Load Discriminator\n", "discriminator, discriminator_feature_extractor = load_discriminator_and_d_feature_extractor(args)\n", "\n", "\n", "# Load Model\n", "model, diffusion = create_model_and_diffusion(args, feature_extractor, discriminator_feature_extractor)\n", "model.to(dev)" ] }, { "cell_type": "markdown", "id": "bb333bec-8640-43df-8d4c-8f6309847345", "metadata": {}, "source": [ "## Sampling" ] }, { "cell_type": "code", "execution_count": 20, "id": "5d0b3c7a", "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "EDMPrecond_CTM(\n", " (model): SongUNet(\n", " (map_noise): PositionalEmbedding()\n", " (map_layer0): Linear()\n", " (map_layer1): Linear()\n", " (map_layer0_s): Linear()\n", " (map_layer1_s): Linear()\n", " (enc): ModuleDict(\n", " (32x32_conv): Conv2d()\n", " (32x32_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (32x32_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (32x32_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (16x16_down): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (16x16_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (16x16_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (16x16_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (8x8_down): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " )\n", " (dec): ModuleDict(\n", " (8x8_in0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (8x8_in1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " )\n", " (8x8_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (8x8_block4): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_up): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (16x16_block4): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " (norm2): GroupNorm()\n", " (qkv): Conv2d()\n", " (proj): Conv2d()\n", " )\n", " (32x32_up): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block0): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block1): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block2): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block3): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_block4): UNetBlock(\n", " (norm0): GroupNorm()\n", " (conv0): Conv2d()\n", " (affine): Linear()\n", " (affine_s): Linear()\n", " (norm1): GroupNorm()\n", " (conv1): Conv2d()\n", " (skip): Conv2d()\n", " )\n", " (32x32_aux_norm): GroupNorm()\n", " (32x32_aux_conv): Conv2d()\n", " )\n", " )\n", ")" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.load_state_dict(\n", " load_state_dict(args.model_path, map_location=dev)\n", ")\n", "\n", "model.to(dev)\n", "\n", "model.convert_to_fp16()\n", "model.eval()" ] }, { "cell_type": "code", "execution_count": 21, "id": "352b91c6-5a24-4897-9a49-77dda638d276", "metadata": {}, "outputs": [], "source": [ "# using stochastic seed\n", "args.eval_seed = np.random.randint(1000000)\n", "generator = get_generator(args.generator, args.eval_num_samples, args.eval_seed)\n", "\n", "step = args.model_path.split('.')[-2][-6:]" ] }, { "cell_type": "code", "execution_count": 22, "id": "92674a04-5c22-44c7-b18a-b9f85914096b", "metadata": {}, "outputs": [], "source": [ "ts = []\n", "# sampler used is exact\n", "out_dir = os.path.join(args.out_dir, f'{args.training_mode}_{args.sampler}_sampler_{args.sampling_steps}_steps_{step}_itrs_model_ema_{\"\".join([str(i) for i in ts])}')" ] }, { "cell_type": "code", "execution_count": 23, "id": "3b6e2662-dd1b-4675-842f-a2e858e27645", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x_T: tensor(-97.1085, device='cuda:0')\n", "-8 sampling complete...\n", "x range: tensor(-1., device='cuda:0') tensor(1., device='cuda:0')\n", "./ctm_exact_sampler_100_steps_095090_itrs_model_ema_\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "sample 8 time 2.4459054470062256 sec\n", "sampling complete\n" ] } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "os.makedirs(out_dir, exist_ok=True)\n", "itr = 0\n", "eval_num_samples = 0\n", "while itr * args.batch_size < args.eval_num_samples:\n", " x_T = generator.randn(\n", " *(args.batch_size, args.in_channels, args.image_size, args.image_size),\n", " device=dev) * args.sigma_max\n", " print(\"x_T: \", x_T[0][0][0][0])\n", " current = time.time()\n", " model_kwargs = {}\n", "\n", " with th.no_grad():\n", " x = karras_sample(\n", " diffusion=diffusion,\n", " model=model,\n", " shape=(args.batch_size, args.in_channels, args.image_size, args.image_size),\n", " steps=args.sampling_steps,\n", " model_kwargs=model_kwargs,\n", " device=dev,\n", " clip_denoised=False if args.data_name in ['church'] else True if args.training_mode=='edm' else args.clip_denoised,\n", " sampler=args.sampler,\n", " sigma_min=args.sigma_min,\n", " sigma_max=args.sigma_max,\n", " s_churn=args.s_churn,\n", " s_tmin=args.s_tmin,\n", " s_tmax=args.s_tmax,\n", " s_noise=args.s_noise,\n", " generator=None,\n", " ts=ts,\n", " teacher = True if args.training_mode == 'edm' else False,\n", " clip_output=args.clip_output,\n", " ctm=True if args.training_mode.lower() == 'ctm' else False,\n", " x_T=x_T if args.stochastic_seed == False else None,\n", " ind_1=args.ind_1,\n", " ind_2=args.ind_2,\n", " gamma=args.gamma,\n", " )\n", "\n", " sample = ((x + 1) * 127.5).clamp(0, 255).to(th.uint8)\n", " sample = sample.permute(0, 2, 3, 1)\n", " sample = sample.contiguous()\n", "\n", " sample = sample.cpu().detach()\n", " print(f\"{(itr-1) * args.batch_size} sampling complete...\")\n", " r = np.random.randint(1000000)\n", "\n", " # save format is png\n", " print(\"x range: \", x.min(), x.max())\n", " print(out_dir)\n", " nrow = int(np.sqrt(sample.shape[0]))\n", " image_grid = make_grid((x + 1.) / 2., nrow, padding=2)\n", " \n", " # Convert the image grid to a format suitable for imshow\n", " np_image = image_grid.permute(1, 2, 0).cpu().numpy() # CxHxW -> HxWxC\n", " \n", " plt.figure(figsize=(4, 4))\n", " plt.axis('off')\n", " plt.imshow(np_image)\n", " plt.show()\n", "\n", " eval_num_samples += sample.shape[0]\n", " print(f\"sample {eval_num_samples} time {time.time() - current} sec\")\n", " itr += 1\n", "\n", "print(\"sampling complete\")" ] }, { "cell_type": "markdown", "id": "887657cc-928e-4178-9ef7-2df988bb94d5", "metadata": {}, "source": [ "## Acknowledgment\n", "\n", "This notebook on the Consistency Trajectory Model (CTM) is inspired by the work on the [Consistency Model (CM)](https://colab.research.google.com/github/Kinyugo/consistency_models/blob/main/notebooks/consistency_models_training_example.ipynb). " ] }, { "cell_type": "code", "execution_count": null, "id": "0ec65800-a86f-4b03-9844-349fa315b332", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 5 }