diff --git a/generative/inferers/inferer.py b/generative/inferers/inferer.py
index d7918e79..9785c585 100644
--- a/generative/inferers/inferer.py
+++ b/generative/inferers/inferer.py
@@ -39,6 +39,7 @@ def __call__(
         inputs: torch.Tensor,
         diffusion_model: Callable[..., torch.Tensor],
         noise: torch.Tensor,
+        timesteps: torch.Tensor,
         condition: Optional[torch.Tensor] = None,
     ) -> torch.Tensor:
         """
@@ -48,10 +49,9 @@ def __call__(
             inputs: Input image to which noise is added.
             diffusion_model: diffusion model.
             noise: random noise, of the same shape as the input.
+            timesteps: random timesteps.
             condition: Conditioning for network input.
         """
-        num_timesteps = self.scheduler.num_train_timesteps
-        timesteps = torch.randint(0, num_timesteps, (inputs.shape[0],), device=inputs.device).long()
         noisy_image = self.scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
         prediction = diffusion_model(x=noisy_image, timesteps=timesteps, context=condition)
 
@@ -123,6 +123,7 @@ def __call__(
         autoencoder_model: Callable[..., torch.Tensor],
         diffusion_model: Callable[..., torch.Tensor],
         noise: torch.Tensor,
+        timesteps: torch.Tensor,
         condition: Optional[torch.Tensor] = None,
     ) -> torch.Tensor:
         """
@@ -133,6 +134,7 @@ def __call__(
             autoencoder_model: first stage model.
             diffusion_model: diffusion model.
             noise: random noise, of the same shape as the latent representation.
+            timesteps: random timesteps.
             condition: conditioning for network input.
         """
         with torch.no_grad():
@@ -142,6 +144,7 @@ def __call__(
             inputs=latent,
             diffusion_model=diffusion_model,
             noise=noise,
+            timesteps=timesteps,
             condition=condition,
         )
 
diff --git a/generative/networks/schedulers/ddim.py b/generative/networks/schedulers/ddim.py
index c397949f..364cc592 100644
--- a/generative/networks/schedulers/ddim.py
+++ b/generative/networks/schedulers/ddim.py
@@ -55,6 +55,9 @@ class DDIMScheduler(nn.Module):
         steps_offset: an offset added to the inference steps. You can use a combination of `steps_offset=1` and
             `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
             stable diffusion.
+        prediction_type: prediction type of the scheduler function, one of `epsilon` (predicting the noise of the
+            diffusion process), `sample` (directly predicting the noisy sample`) or `v_prediction` (see section 2.4
+            https://imagen.research.google/video/paper.pdf)
     """
 
     def __init__(
@@ -66,6 +69,7 @@ def __init__(
         clip_sample: bool = True,
         set_alpha_to_one: bool = True,
         steps_offset: int = 0,
+        prediction_type: str = "epsilon",
     ) -> None:
         super().__init__()
         self.beta_schedule = beta_schedule
@@ -79,6 +83,12 @@ def __init__(
         else:
             raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
 
+        if prediction_type.lower() not in ["epsilon", "sample", "v_prediction"]:
+            raise ValueError(
+                f"prediction_type given as {prediction_type} must be one of `epsilon`, `sample`, or" " `v_prediction`"
+            )
+
+        self.prediction_type = prediction_type
         self.num_train_timesteps = num_train_timesteps
         self.alphas = 1.0 - self.betas
         self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
@@ -171,7 +181,14 @@ def step(
 
         # 3. compute predicted original sample from predicted noise also called
         # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
-        pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
+        if self.prediction_type == "epsilon":
+            pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
+        elif self.prediction_type == "sample":
+            pred_original_sample = model_output
+        elif self.prediction_type == "v_prediction":
+            pred_original_sample = (alpha_prod_t**0.5) * sample - (beta_prod_t**0.5) * model_output
+            # predict V
+            model_output = (alpha_prod_t**0.5) * model_output + (beta_prod_t**0.5) * sample
 
         # 4. Clip "predicted x_0"
         if self.clip_sample:
@@ -231,3 +248,21 @@ def add_noise(
 
         noisy_samples = sqrt_alpha_cumprod * original_samples + sqrt_one_minus_alpha_prod * noise
         return noisy_samples
+
+    def get_velocity(self, sample: torch.Tensor, noise: torch.Tensor, timesteps: torch.Tensor) -> torch.Tensor:
+        # Make sure alphas_cumprod and timestep have same device and dtype as sample
+        self.alphas_cumprod = self.alphas_cumprod.to(device=sample.device, dtype=sample.dtype)
+        timesteps = timesteps.to(sample.device)
+
+        sqrt_alpha_prod = self.alphas_cumprod[timesteps] ** 0.5
+        sqrt_alpha_prod = sqrt_alpha_prod.flatten()
+        while len(sqrt_alpha_prod.shape) < len(sample.shape):
+            sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)
+
+        sqrt_one_minus_alpha_prod = (1 - self.alphas_cumprod[timesteps]) ** 0.5
+        sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()
+        while len(sqrt_one_minus_alpha_prod.shape) < len(sample.shape):
+            sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)
+
+        velocity = sqrt_alpha_prod * noise - sqrt_one_minus_alpha_prod * sample
+        return velocity
diff --git a/generative/networks/schedulers/ddpm.py b/generative/networks/schedulers/ddpm.py
index f2ea54e2..f0a64482 100644
--- a/generative/networks/schedulers/ddpm.py
+++ b/generative/networks/schedulers/ddpm.py
@@ -61,6 +61,7 @@ def __init__(
         beta_schedule: str = "linear",
         variance_type: str = "fixed_small",
         clip_sample: bool = True,
+        prediction_type: str = "epsilon",
     ) -> None:
         super().__init__()
         self.beta_schedule = beta_schedule
@@ -74,6 +75,13 @@ def __init__(
         else:
             raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
 
+        if prediction_type.lower() not in ["epsilon", "sample", "v_prediction"]:
+            raise ValueError(
+                f"prediction_type given as {prediction_type} must be one of `epsilon`, `sample`, or" " `v_prediction`"
+            )
+
+        self.prediction_type = prediction_type
+
         self.num_train_timesteps = num_train_timesteps
         self.alphas = 1.0 - self.betas
         self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
@@ -170,10 +178,12 @@ def step(
 
         # 2. compute predicted original sample from predicted noise also called
         # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
-        if predict_epsilon:
+        if self.prediction_type == "epsilon":
             pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-        else:
+        elif self.prediction_type == "sample":
             pred_original_sample = model_output
+        elif self.prediction_type == "v_prediction":
+            pred_original_sample = (alpha_prod_t**0.5) * sample - (beta_prod_t**0.5) * model_output
 
         # 3. Clip "predicted x_0"
         if self.clip_sample:
@@ -233,3 +243,21 @@ def add_noise(
 
         noisy_samples = sqrt_alpha_cumprod * original_samples + sqrt_one_minus_alpha_prod * noise
         return noisy_samples
+
+    def get_velocity(self, sample: torch.Tensor, noise: torch.Tensor, timesteps: torch.Tensor) -> torch.Tensor:
+        # Make sure alphas_cumprod and timestep have same device and dtype as sample
+        self.alphas_cumprod = self.alphas_cumprod.to(device=sample.device, dtype=sample.dtype)
+        timesteps = timesteps.to(sample.device)
+
+        sqrt_alpha_prod = self.alphas_cumprod[timesteps] ** 0.5
+        sqrt_alpha_prod = sqrt_alpha_prod.flatten()
+        while len(sqrt_alpha_prod.shape) < len(sample.shape):
+            sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)
+
+        sqrt_one_minus_alpha_prod = (1 - self.alphas_cumprod[timesteps]) ** 0.5
+        sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()
+        while len(sqrt_one_minus_alpha_prod.shape) < len(sample.shape):
+            sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)
+
+        velocity = sqrt_alpha_prod * noise - sqrt_one_minus_alpha_prod * sample
+        return velocity
diff --git a/tests/test_diffusion_inferer.py b/tests/test_diffusion_inferer.py
index 0ceb71ef..8b3cd511 100644
--- a/tests/test_diffusion_inferer.py
+++ b/tests/test_diffusion_inferer.py
@@ -63,7 +63,8 @@ def test_call(self, model_params, input_shape):
         )
         inferer = DiffusionInferer(scheduler=scheduler)
         scheduler.set_timesteps(num_inference_steps=10)
-        sample = inferer(inputs=input, noise=noise, diffusion_model=model)
+        timesteps = torch.randint(0, scheduler.num_train_timesteps, (input_shape[0],), device=input.device).long()
+        sample = inferer(inputs=input, noise=noise, diffusion_model=model, timesteps=timesteps)
         self.assertEqual(sample.shape, input_shape)
 
     @parameterized.expand(TEST_CASES)
diff --git a/tests/test_latent_diffusion_inferer.py b/tests/test_latent_diffusion_inferer.py
index 81cb8002..450b940e 100644
--- a/tests/test_latent_diffusion_inferer.py
+++ b/tests/test_latent_diffusion_inferer.py
@@ -98,7 +98,10 @@ def test_prediction_shape(self, model_type, autoencoder_params, stage_2_params,
         )
         inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0)
         scheduler.set_timesteps(num_inference_steps=10)
-        prediction = inferer(inputs=input, autoencoder_model=autoencoder_model, diffusion_model=stage_2, noise=noise)
+        timesteps = torch.randint(0, scheduler.num_train_timesteps, (input_shape[0],), device=input.device).long()
+        prediction = inferer(
+            inputs=input, autoencoder_model=autoencoder_model, diffusion_model=stage_2, noise=noise, timesteps=timesteps
+        )
         self.assertEqual(prediction.shape, latent_shape)
 
     @parameterized.expand(TEST_CASES)
diff --git a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.ipynb b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.ipynb
index ae642e6e..8e0a1013 100644
--- a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.ipynb
+++ b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.ipynb
@@ -780,8 +780,13 @@
     "            # Generate random noise\n",
     "            noise = torch.randn_like(images).to(device)\n",
     "\n",
+    "            # Create timesteps\n",
+    "            timesteps = torch.randint(\n",
+    "                0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device\n",
+    "            ).long()\n",
+    "\n",
     "            # Get model prediction\n",
-    "            noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise)\n",
+    "            noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n",
     "\n",
     "            loss = F.mse_loss(noise_pred.float(), noise.float())\n",
     "\n",
@@ -806,7 +811,10 @@
     "            with torch.no_grad():\n",
     "                with autocast(enabled=True):\n",
     "                    noise = torch.randn_like(images).to(device)\n",
-    "                    noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise)\n",
+    "                    timesteps = torch.randint(\n",
+    "                        0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device\n",
+    "                    ).long()\n",
+    "                    noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n",
     "                    val_loss = F.mse_loss(noise_pred.float(), noise.float())\n",
     "\n",
     "            val_epoch_loss += val_loss.item()\n",
diff --git a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.py b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.py
index 4d592d4c..80db0e35 100644
--- a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.py
+++ b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial.py
@@ -207,8 +207,13 @@
             # Generate random noise
             noise = torch.randn_like(images).to(device)
 
+            # Create timesteps
+            timesteps = torch.randint(
+                0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device
+            ).long()
+
             # Get model prediction
-            noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise)
+            noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)
 
             loss = F.mse_loss(noise_pred.float(), noise.float())
 
@@ -233,7 +238,10 @@
             with torch.no_grad():
                 with autocast(enabled=True):
                     noise = torch.randn_like(images).to(device)
-                    noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise)
+                    timesteps = torch.randint(
+                        0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device
+                    ).long()
+                    noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)
                     val_loss = F.mse_loss(noise_pred.float(), noise.float())
 
             val_epoch_loss += val_loss.item()
diff --git a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb
index a3be5d84..a9f90771 100644
--- a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb
+++ b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb
@@ -394,8 +394,9 @@
     ")\n",
     "model.to(device)\n",
     "\n",
+    "num_train_timesteps = 1000\n",
     "scheduler = DDPMScheduler(\n",
-    "    num_train_timesteps=1000,\n",
+    "    num_train_timesteps=num_train_timesteps,\n",
     ")\n",
     "\n",
     "optimizer = torch.optim.Adam(params=model.parameters(), lr=2.5e-5)\n",
@@ -433,13 +434,17 @@
     "\n",
     "    \"\"\"\n",
     "\n",
-    "    def __init__(self, condition_name: Optional[str] = None):\n",
+    "    def __init__(self, num_train_timesteps: int, condition_name: Optional[str] = None):\n",
     "        self.condition_name = condition_name\n",
+    "        self.num_train_timesteps = num_train_timesteps\n",
     "\n",
     "    def get_noise(self, images):\n",
     "        \"\"\"Returns the noise tensor for input tensor `images`, override this for different noise distributions.\"\"\"\n",
     "        return torch.randn_like(images)\n",
     "\n",
+    "    def get_timesteps(self, images):\n",
+    "        return torch.randint(0, self.num_train_timesteps, (images.shape[0],), device=images.device).long()\n",
+    "\n",
     "    def __call__(\n",
     "        self,\n",
     "        batchdata: Dict[str, torch.Tensor],\n",
@@ -449,8 +454,9 @@
     "    ):\n",
     "        images, _ = default_prepare_batch(batchdata, device, non_blocking, **kwargs)\n",
     "        noise = self.get_noise(images).to(device, non_blocking=non_blocking, **kwargs)\n",
+    "        timesteps = self.get_timesteps(images).to(device, non_blocking=non_blocking, **kwargs)\n",
     "\n",
-    "        kwargs = {\"noise\": noise}\n",
+    "        kwargs = {\"noise\": noise, \"timesteps\": timesteps}\n",
     "\n",
     "        if self.condition_name is not None and isinstance(batchdata, Mapping):\n",
     "            kwargs[\"conditioning\"] = batchdata[self.condition_name].to(device, non_blocking=non_blocking, **kwargs)\n",
@@ -2159,7 +2165,7 @@
     "    val_data_loader=val_loader,\n",
     "    network=model,\n",
     "    inferer=inferer,\n",
-    "    prepare_batch=DiffusionPrepareBatch(),\n",
+    "    prepare_batch=DiffusionPrepareBatch(num_train_timesteps=num_train_timesteps),\n",
     "    key_val_metric={\"val_mean_abs_error\": MeanAbsoluteError(output_transform=from_engine([\"pred\", \"label\"]))},\n",
     "    val_handlers=val_handlers,\n",
     ")\n",
@@ -2178,7 +2184,7 @@
     "    optimizer=optimizer,\n",
     "    loss_function=torch.nn.MSELoss(),\n",
     "    inferer=inferer,\n",
-    "    prepare_batch=DiffusionPrepareBatch(),\n",
+    "    prepare_batch=DiffusionPrepareBatch(num_train_timesteps=num_train_timesteps),\n",
     "    key_train_metric={\"train_acc\": MeanSquaredError(output_transform=from_engine([\"pred\", \"label\"]))},\n",
     "    train_handlers=train_handlers,\n",
     ")\n",
diff --git a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.py b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.py
index fcb22bf8..1db6ad83 100644
--- a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.py
+++ b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_ignite.py
@@ -177,8 +177,9 @@
 )
 model.to(device)
 
+num_train_timesteps = 1000
 scheduler = DDPMScheduler(
-    num_train_timesteps=1000,
+    num_train_timesteps=num_train_timesteps,
 )
 
 optimizer = torch.optim.Adam(params=model.parameters(), lr=2.5e-5)
@@ -203,13 +204,17 @@ class DiffusionPrepareBatch(PrepareBatch):
 
     """
 
-    def __init__(self, condition_name: Optional[str] = None):
+    def __init__(self, num_train_timesteps: int, condition_name: Optional[str] = None):
         self.condition_name = condition_name
+        self.num_train_timesteps = num_train_timesteps
 
     def get_noise(self, images):
         """Returns the noise tensor for input tensor `images`, override this for different noise distributions."""
         return torch.randn_like(images)
 
+    def get_timesteps(self, images):
+        return torch.randint(0, self.num_train_timesteps, (images.shape[0],), device=images.device).long()
+
     def __call__(
         self,
         batchdata: Dict[str, torch.Tensor],
@@ -219,8 +224,9 @@ def __call__(
     ):
         images, _ = default_prepare_batch(batchdata, device, non_blocking, **kwargs)
         noise = self.get_noise(images).to(device, non_blocking=non_blocking, **kwargs)
+        timesteps = self.get_timesteps(images).to(device, non_blocking=non_blocking, **kwargs)
 
-        kwargs = {"noise": noise}
+        kwargs = {"noise": noise, "timesteps": timesteps}
 
         if self.condition_name is not None and isinstance(batchdata, Mapping):
             kwargs["conditioning"] = batchdata[self.condition_name].to(device, non_blocking=non_blocking, **kwargs)
@@ -244,7 +250,7 @@ def __call__(
     val_data_loader=val_loader,
     network=model,
     inferer=inferer,
-    prepare_batch=DiffusionPrepareBatch(),
+    prepare_batch=DiffusionPrepareBatch(num_train_timesteps=num_train_timesteps),
     key_val_metric={"val_mean_abs_error": MeanAbsoluteError(output_transform=from_engine(["pred", "label"]))},
     val_handlers=val_handlers,
 )
@@ -263,7 +269,7 @@ def __call__(
     optimizer=optimizer,
     loss_function=torch.nn.MSELoss(),
     inferer=inferer,
-    prepare_batch=DiffusionPrepareBatch(),
+    prepare_batch=DiffusionPrepareBatch(num_train_timesteps=num_train_timesteps),
     key_train_metric={"train_acc": MeanSquaredError(output_transform=from_engine(["pred", "label"]))},
     train_handlers=train_handlers,
 )
diff --git a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb
new file mode 100644
index 00000000..613a877e
--- /dev/null
+++ b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb
@@ -0,0 +1,999 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2278a8b4",
+   "metadata": {},
+   "source": [
+    "# Denoising Diffusion Probabilistic Models using v-prediction parameterization\n",
+    "\n",
+    "This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to create synthetic 2D images using v-prediction parameterization (Section 2.4 from [2]).\n",
+    "\n",
+    "[1] - Ho et al. \"Denoising Diffusion Probabilistic Models\" https://arxiv.org/abs/2006.11239\n",
+    "[2] - Ho et al. \"Imagen Video: High Definition Video Generation with Diffusion Models\" https://arxiv.org/abs/2210.02303\n",
+    "\n",
+    "TODO: Add Open in Colab\n",
+    "\n",
+    "## Setup environment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "87d63656",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python -c \"import monai\" || pip install -q \"monai-weekly[pillow, tqdm, einops]\"\n",
+    "!python -c \"import matplotlib\" || pip install -q matplotlib\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "de9a09ad",
+   "metadata": {},
+   "source": [
+    "## Setup imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e991ba58",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MONAI version: 1.1.dev2239\n",
+      "Numpy version: 1.23.3\n",
+      "Pytorch version: 1.8.0+cu111\n",
+      "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n",
+      "MONAI rev id: 13b24fa92b9d98bd0dc6d5cdcb52504fd09e297b\n",
+      "MONAI __file__: /media/walter/Storage/Projects/GenerativeModels/venv/lib/python3.8/site-packages/monai/__init__.py\n",
+      "\n",
+      "Optional dependencies:\n",
+      "Pytorch Ignite version: 0.4.10\n",
+      "Nibabel version: 4.0.2\n",
+      "scikit-image version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "Pillow version: 9.2.0\n",
+      "Tensorboard version: 2.11.0\n",
+      "gdown version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "TorchVision version: 0.9.0+cu111\n",
+      "tqdm version: 4.64.1\n",
+      "lmdb version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "psutil version: 5.9.3\n",
+      "pandas version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "einops version: 0.6.0\n",
+      "transformers version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "mlflow version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "pynrrd version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "\n",
+      "For details about installing the optional dependencies, please visit:\n",
+      "    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Copyright 2020 MONAI Consortium\n",
+    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+    "# you may not use this file except in compliance with the License.\n",
+    "# You may obtain a copy of the License at\n",
+    "#     http://www.apache.org/licenses/LICENSE-2.0\n",
+    "# Unless required by applicable law or agreed to in writing, software\n",
+    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+    "# See the License for the specific language governing permissions and\n",
+    "# limitations under the License.\n",
+    "import os\n",
+    "import shutil\n",
+    "import tempfile\n",
+    "import time\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "from monai import transforms\n",
+    "from monai.apps import MedNISTDataset\n",
+    "from monai.config import print_config\n",
+    "from monai.data import CacheDataset, DataLoader\n",
+    "from monai.utils import first, set_determinism\n",
+    "from torch.cuda.amp import GradScaler, autocast\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "from generative.inferers import DiffusionInferer\n",
+    "\n",
+    "# TODO: Add right import reference after deployed\n",
+    "from generative.networks.nets import DiffusionModelUNet\n",
+    "from generative.networks.schedulers import DDPMScheduler\n",
+    "\n",
+    "print_config()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a414cba7",
+   "metadata": {},
+   "source": [
+    "## Setup data directory\n",
+    "\n",
+    "You can specify a directory with the MONAI_DATA_DIRECTORY environment variable.\n",
+    "\n",
+    "This allows you to save results and reuse downloads.\n",
+    "\n",
+    "If not specified a temporary directory will be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "22061fd8",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/tmp/tmplcl8fv6u\n"
+     ]
+    }
+   ],
+   "source": [
+    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
+    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
+    "print(root_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8962d9b4",
+   "metadata": {},
+   "source": [
+    "## Set deterministic training for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "57bb62f0",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "set_determinism(42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21210b86",
+   "metadata": {},
+   "source": [
+    "## Setup MedNIST Dataset and training and validation dataloaders\n",
+    "In this tutorial, we will train our models on the MedNIST dataset available on MONAI\n",
+    "(https://docs.monai.io/en/stable/apps.html#monai.apps.MedNISTDataset). In order to train faster, we will select just\n",
+    "one of the available classes (\"Hand\"), resulting in a training set with 7999 2D images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "46fc4bfb",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-12-11 12:03:19,625 - INFO - Downloaded: /tmp/tmplcl8fv6u/MedNIST.tar.gz\n",
+      "2022-12-11 12:03:19,696 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2022-12-11 12:03:19,696 - INFO - Writing into directory: /tmp/tmplcl8fv6u.\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_data = MedNISTDataset(root_dir=root_dir, section=\"training\", download=True, progress=False, seed=0)\n",
+    "train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"Hand\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50c48aef",
+   "metadata": {},
+   "source": [
+    "Here we use transforms to augment the training dataset:\n",
+    "\n",
+    "1. `LoadImaged` loads the hands images from files.\n",
+    "1. `EnsureChannelFirstd` ensures the original data to construct \"channel first\" shape.\n",
+    "1. `ScaleIntensityRanged` extracts intensity range [0, 255] and scales to [0, 1].\n",
+    "1. `RandAffined` efficiently performs rotate, scale, shear, translate, etc. together based on PyTorch affine transform."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a03c3f45",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 7999/7999 [00:04<00:00, 1775.57it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_transforms = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.LoadImaged(keys=[\"image\"]),\n",
+    "        transforms.EnsureChannelFirstd(keys=[\"image\"]),\n",
+    "        transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),\n",
+    "        transforms.RandAffined(\n",
+    "            keys=[\"image\"],\n",
+    "            rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)],\n",
+    "            translate_range=[(-1, 1), (-1, 1)],\n",
+    "            scale_range=[(-0.05, 0.05), (-0.05, 0.05)],\n",
+    "            spatial_size=[64, 64],\n",
+    "            padding_mode=\"zeros\",\n",
+    "            prob=0.5,\n",
+    "        ),\n",
+    "    ]\n",
+    ")\n",
+    "train_ds = CacheDataset(data=train_datalist, transform=train_transforms)\n",
+    "train_loader = DataLoader(train_ds, batch_size=96, shuffle=True, num_workers=4, persistent_workers=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7855726e",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-12-11 12:03:42,998 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
+      "2022-12-11 12:03:42,999 - INFO - File exists: /tmp/tmplcl8fv6u/MedNIST.tar.gz, skipped downloading.\n",
+      "2022-12-11 12:03:42,999 - INFO - Non-empty folder exists in /tmp/tmplcl8fv6u/MedNIST, skipped extracting.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1005/1005 [00:00<00:00, 1831.70it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "val_data = MedNISTDataset(root_dir=root_dir, section=\"validation\", download=True, progress=False, seed=0)\n",
+    "val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"Hand\"]\n",
+    "val_transforms = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.LoadImaged(keys=[\"image\"]),\n",
+    "        transforms.EnsureChannelFirstd(keys=[\"image\"]),\n",
+    "        transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),\n",
+    "    ]\n",
+    ")\n",
+    "val_ds = CacheDataset(data=val_datalist, transform=val_transforms)\n",
+    "val_loader = DataLoader(val_ds, batch_size=96, shuffle=False, num_workers=4, persistent_workers=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01452490",
+   "metadata": {},
+   "source": [
+    "### Visualisation of the training images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3f68cdfe",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "batch shape: (96, 1, 64, 64)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "check_data = first(train_loader)\n",
+    "print(f\"batch shape: {check_data['image'].shape}\")\n",
+    "image_visualisation = torch.cat(\n",
+    "    [check_data[\"image\"][0, 0], check_data[\"image\"][1, 0], check_data[\"image\"][2, 0], check_data[\"image\"][3, 0]], dim=1\n",
+    ")\n",
+    "plt.figure(\"training images\", (12, 6))\n",
+    "plt.imshow(image_visualisation, vmin=0, vmax=1, cmap=\"gray\")\n",
+    "plt.axis(\"off\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d026c35",
+   "metadata": {},
+   "source": [
+    "### Define network, scheduler, optimizer, and inferer\n",
+    "At this step, we instantiate the MONAI components to create a DDPM, the UNET, the noise scheduler, and the inferer used for training and sampling. We are using\n",
+    "the original DDPM scheduler containing 1000 timesteps in its Markov chain, and a 2D UNET with attention mechanisms\n",
+    "in the 2nd and 3rd levels, each with 1 attention head."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f7ba0c0f",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "lines_to_next_cell": 0
+   },
+   "outputs": [],
+   "source": [
+    "device = torch.device(\"cuda\")\n",
+    "\n",
+    "model = DiffusionModelUNet(\n",
+    "    spatial_dims=2,\n",
+    "    in_channels=1,\n",
+    "    out_channels=1,\n",
+    "    num_channels=(128, 256, 256),\n",
+    "    attention_levels=(False, True, True),\n",
+    "    num_res_blocks=1,\n",
+    "    num_head_channels=256,\n",
+    ")\n",
+    "model.to(device)\n",
+    "\n",
+    "scheduler = DDPMScheduler(\n",
+    "    prediction_type=\"v_prediction\",\n",
+    "    num_train_timesteps=1000,\n",
+    "    beta_start = 0.00085,\n",
+    "    beta_end = 0.0120,\n",
+    ")\n",
+    "\n",
+    "optimizer = torch.optim.Adam(params=model.parameters(), lr=1.0e-4)\n",
+    "\n",
+    "inferer = DiffusionInferer(scheduler)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "315f8b47",
+   "metadata": {},
+   "source": [
+    "### Model training\n",
+    "Here, we are training our model for 75 epochs (training time: ~50 minutes)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f5f58b7e",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "lines_to_next_cell": 0
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0: 100%|█████████████| 84/84 [00:38<00:00,  2.17it/s, loss=0.13]\n",
+      "Epoch 1: 100%|███████████| 84/84 [00:38<00:00,  2.18it/s, loss=0.0485]\n",
+      "Epoch 2: 100%|███████████| 84/84 [00:38<00:00,  2.17it/s, loss=0.0433]\n",
+      "Epoch 3: 100%|███████████| 84/84 [00:38<00:00,  2.17it/s, loss=0.0406]\n",
+      "Epoch 4: 100%|███████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0385]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 71.19it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5: 100%|███████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0366]\n",
+      "Epoch 6: 100%|███████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0357]\n",
+      "Epoch 7: 100%|████████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.035]\n",
+      "Epoch 8: 100%|███████████| 84/84 [00:38<00:00,  2.15it/s, loss=0.0338]\n",
+      "Epoch 9: 100%|████████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.034]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 71.24it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10: 100%|██████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0332]\n",
+      "Epoch 11: 100%|██████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0325]\n",
+      "Epoch 12: 100%|███████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.032]\n",
+      "Epoch 13: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0326]\n",
+      "Epoch 14: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0315]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:13<00:00, 72.64it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15: 100%|██████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0315]\n",
+      "Epoch 16: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0313]\n",
+      "Epoch 17: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0307]\n",
+      "Epoch 18: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0309]\n",
+      "Epoch 19: 100%|████████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.03]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:13<00:00, 73.03it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0305]\n",
+      "Epoch 21: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0301]\n",
+      "Epoch 22: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0307]\n",
+      "Epoch 23: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0303]\n",
+      "Epoch 24: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0299]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.70it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 25: 100%|████████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.03]\n",
+      "Epoch 26: 100%|████████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.03]\n",
+      "Epoch 27: 100%|████████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.03]\n",
+      "Epoch 28: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0294]\n",
+      "Epoch 29: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0294]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.75it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 30: 100%|██████████| 84/84 [00:38<00:00,  2.15it/s, loss=0.0291]\n",
+      "Epoch 31: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0297]\n",
+      "Epoch 32: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0294]\n",
+      "Epoch 33: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0294]\n",
+      "Epoch 34: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0287]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.80it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 35: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0292]\n",
+      "Epoch 36: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0289]\n",
+      "Epoch 37: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0284]\n",
+      "Epoch 38: 100%|███████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.029]\n",
+      "Epoch 39: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0295]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.70it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 40: 100%|██████████| 84/84 [00:38<00:00,  2.16it/s, loss=0.0289]\n",
+      "Epoch 41: 100%|███████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.029]\n",
+      "Epoch 42: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0288]\n",
+      "Epoch 43: 100%|███████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.029]\n",
+      "Epoch 44: 100%|███████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.029]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 69.12it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 45: 100%|██████████| 84/84 [00:39<00:00,  2.13it/s, loss=0.0282]\n",
+      "Epoch 46: 100%|██████████| 84/84 [00:40<00:00,  2.06it/s, loss=0.0286]\n",
+      "Epoch 47: 100%|██████████| 84/84 [00:40<00:00,  2.09it/s, loss=0.0282]\n",
+      "Epoch 48: 100%|███████████| 84/84 [00:40<00:00,  2.09it/s, loss=0.028]\n",
+      "Epoch 49: 100%|██████████| 84/84 [00:40<00:00,  2.07it/s, loss=0.0289]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.00it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 50: 100%|██████████| 84/84 [00:41<00:00,  2.02it/s, loss=0.0282]\n",
+      "Epoch 51: 100%|██████████| 84/84 [00:39<00:00,  2.10it/s, loss=0.0285]\n",
+      "Epoch 52: 100%|██████████| 84/84 [00:40<00:00,  2.08it/s, loss=0.0283]\n",
+      "Epoch 53: 100%|██████████| 84/84 [00:42<00:00,  2.00it/s, loss=0.0281]\n",
+      "Epoch 54: 100%|██████████| 84/84 [00:42<00:00,  1.99it/s, loss=0.0285]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 67.98it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 55: 100%|██████████| 84/84 [00:39<00:00,  2.13it/s, loss=0.0287]\n",
+      "Epoch 56: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0281]\n",
+      "Epoch 57: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0288]\n",
+      "Epoch 58: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0285]\n",
+      "Epoch 59: 100%|███████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.028]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.07it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 60: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0281]\n",
+      "Epoch 61: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0282]\n",
+      "Epoch 62: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0279]\n",
+      "Epoch 63: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0283]\n",
+      "Epoch 64: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0278]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:13<00:00, 73.18it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 65: 100%|██████████| 84/84 [00:39<00:00,  2.15it/s, loss=0.0282]\n",
+      "Epoch 66: 100%|██████████| 84/84 [00:39<00:00,  2.14it/s, loss=0.0278]\n",
+      "Epoch 67: 100%|██████████| 84/84 [00:39<00:00,  2.11it/s, loss=0.0277]\n",
+      "Epoch 68: 100%|██████████| 84/84 [00:41<00:00,  2.04it/s, loss=0.0281]\n",
+      "Epoch 69: 100%|██████████| 84/84 [00:39<00:00,  2.11it/s, loss=0.0277]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 69.83it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 70: 100%|███████████| 84/84 [00:40<00:00,  2.07it/s, loss=0.028]\n",
+      "Epoch 71: 100%|██████████| 84/84 [00:40<00:00,  2.09it/s, loss=0.0275]\n",
+      "Epoch 72: 100%|██████████| 84/84 [00:41<00:00,  2.02it/s, loss=0.0274]\n",
+      "Epoch 73: 100%|██████████| 84/84 [00:40<00:00,  2.07it/s, loss=0.0276]\n",
+      "Epoch 74: 100%|██████████| 84/84 [00:39<00:00,  2.10it/s, loss=0.0278]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 70.73it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train completed, total time: 3196.6940882205963.\n"
+     ]
+    }
+   ],
+   "source": [
+    "n_epochs = 75\n",
+    "val_interval = 5\n",
+    "epoch_loss_list = []\n",
+    "val_epoch_loss_list = []\n",
+    "\n",
+    "scaler = GradScaler()\n",
+    "total_start = time.time()\n",
+    "for epoch in range(n_epochs):\n",
+    "    model.train()\n",
+    "    epoch_loss = 0\n",
+    "    progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=70)\n",
+    "    progress_bar.set_description(f\"Epoch {epoch}\")\n",
+    "    for step, batch in progress_bar:\n",
+    "        images = batch[\"image\"].to(device)\n",
+    "        optimizer.zero_grad(set_to_none=True)\n",
+    "\n",
+    "        with autocast(enabled=True):\n",
+    "            # Generate random noise\n",
+    "            noise = torch.randn_like(images).to(device)\n",
+    "            timesteps = torch.randint(\n",
+    "                0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device\n",
+    "            ).long()\n",
+    "\n",
+    "            # Get target for the v-prediction parameterization\n",
+    "            target = inferer.scheduler.get_velocity(images, noise, timesteps)\n",
+    "\n",
+    "            # Get model prediction\n",
+    "            noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n",
+    "\n",
+    "            loss = F.mse_loss(noise_pred.float(), target.float())\n",
+    "\n",
+    "        scaler.scale(loss).backward()\n",
+    "        scaler.step(optimizer)\n",
+    "        scaler.update()\n",
+    "\n",
+    "        epoch_loss += loss.item()\n",
+    "\n",
+    "        progress_bar.set_postfix(\n",
+    "            {\n",
+    "                \"loss\": epoch_loss / (step + 1),\n",
+    "            }\n",
+    "        )\n",
+    "    epoch_loss_list.append(epoch_loss / (step + 1))\n",
+    "\n",
+    "    if (epoch + 1) % val_interval == 0:\n",
+    "        model.eval()\n",
+    "        val_epoch_loss = 0\n",
+    "        for step, batch in enumerate(val_loader):\n",
+    "            images = batch[\"image\"].to(device)\n",
+    "            with torch.no_grad():\n",
+    "                with autocast(enabled=True):\n",
+    "                    noise = torch.randn_like(images).to(device)\n",
+    "                    timesteps = torch.randint(\n",
+    "                        0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device\n",
+    "                    ).long()\n",
+    "                    target = inferer.scheduler.get_velocity(images, noise, timesteps)\n",
+    "                    noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n",
+    "                    val_loss = F.mse_loss(noise_pred.float(), target.float())\n",
+    "\n",
+    "            val_epoch_loss += val_loss.item()\n",
+    "            progress_bar.set_postfix(\n",
+    "                {\n",
+    "                    \"val_loss\": val_epoch_loss / (step + 1),\n",
+    "                }\n",
+    "            )\n",
+    "        val_epoch_loss_list.append(val_epoch_loss / (step + 1))\n",
+    "\n",
+    "        # Sampling image during training\n",
+    "        noise = torch.randn((1, 1, 64, 64))\n",
+    "        noise = noise.to(device)\n",
+    "        scheduler.set_timesteps(num_inference_steps=1000)\n",
+    "        with autocast(enabled=True):\n",
+    "            image = inferer.sample(input_noise=noise, diffusion_model=model, scheduler=scheduler)\n",
+    "\n",
+    "        plt.figure(figsize=(2, 2))\n",
+    "        plt.imshow(image[0, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n",
+    "        plt.tight_layout()\n",
+    "        plt.axis(\"off\")\n",
+    "        plt.show()\n",
+    "\n",
+    "total_time = time.time() - total_start\n",
+    "print(f\"train completed, total time: {total_time}.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a70fd533",
+   "metadata": {},
+   "source": [
+    "### Learning curves"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "3db336e6",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 800x550 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.style.use(\"seaborn-v0_8\")\n",
+    "plt.title(\"Learning Curves\", fontsize=20)\n",
+    "plt.plot(np.linspace(1, n_epochs, n_epochs), epoch_loss_list, color=\"C0\", linewidth=2.0, label=\"Train\")\n",
+    "plt.plot(\n",
+    "    np.linspace(val_interval, n_epochs, int(n_epochs / val_interval)),\n",
+    "    val_epoch_loss_list,\n",
+    "    color=\"C1\",\n",
+    "    linewidth=2.0,\n",
+    "    label=\"Validation\",\n",
+    ")\n",
+    "plt.yticks(fontsize=12)\n",
+    "plt.xticks(fontsize=12)\n",
+    "plt.xlabel(\"Epochs\", fontsize=16)\n",
+    "plt.ylabel(\"Loss\", fontsize=16)\n",
+    "plt.legend(prop={\"size\": 14})\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4ce9887",
+   "metadata": {},
+   "source": [
+    "### Plotting sampling process along DDPM's Markov chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7d3fee5b",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:14<00:00, 69.29it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "noise = torch.randn((1, 1, 64, 64))\n",
+    "noise = noise.to(device)\n",
+    "scheduler.set_timesteps(num_inference_steps=1000)\n",
+    "with autocast(enabled=True):\n",
+    "    image, intermediates = inferer.sample(\n",
+    "        input_noise=noise, diffusion_model=model, scheduler=scheduler, save_intermediates=True, intermediate_steps=100\n",
+    "    )\n",
+    "\n",
+    "chain = torch.cat(intermediates, dim=-1)\n",
+    "\n",
+    "plt.style.use(\"default\")\n",
+    "plt.imshow(chain[0, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n",
+    "plt.tight_layout()\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c07a83c4",
+   "metadata": {},
+   "source": [
+    "### Cleanup data directory\n",
+    "\n",
+    "Remove directory if a temporary was used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f685296b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if directory is None:\n",
+    "    shutil.rmtree(root_dir)"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "formats": "py:percent,ipynb"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.8.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_v_prediction.py b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_v_prediction.py
new file mode 100644
index 00000000..743eb76c
--- /dev/null
+++ b/tutorials/generative/2d_ddpm/2d_ddpm_tutorial_v_prediction.py
@@ -0,0 +1,324 @@
+# ---
+# jupyter:
+#   jupytext:
+#     formats: py:percent,ipynb
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.14.1
+#   kernelspec:
+#     display_name: Python 3
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# # Denoising Diffusion Probabilistic Models using v-prediction parameterization
+#
+# This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to create synthetic 2D images using v-prediction parameterization (Section 2.4 from [2]).
+#
+# [1] - Ho et al. "Denoising Diffusion Probabilistic Models" https://arxiv.org/abs/2006.11239
+# [2] - Ho et al. "Imagen Video: High Definition Video Generation with Diffusion Models" https://arxiv.org/abs/2210.02303
+#
+# TODO: Add Open in Colab
+#
+# ## Setup environment
+
+# %%
+# !python -c "import monai" || pip install -q "monai-weekly[pillow, tqdm, einops]"
+# !python -c "import matplotlib" || pip install -q matplotlib
+# %matplotlib inline
+
+# %% [markdown]
+# ## Setup imports
+
+# %% jupyter={"outputs_hidden": false}
+# Copyright 2020 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import shutil
+import tempfile
+import time
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn.functional as F
+from monai import transforms
+from monai.apps import MedNISTDataset
+from monai.config import print_config
+from monai.data import CacheDataset, DataLoader
+from monai.utils import first, set_determinism
+from torch.cuda.amp import GradScaler, autocast
+from tqdm import tqdm
+
+from generative.inferers import DiffusionInferer
+
+# TODO: Add right import reference after deployed
+from generative.networks.nets import DiffusionModelUNet
+from generative.networks.schedulers import DDPMScheduler
+
+print_config()
+
+# %% [markdown]
+# ## Setup data directory
+#
+# You can specify a directory with the MONAI_DATA_DIRECTORY environment variable.
+#
+# This allows you to save results and reuse downloads.
+#
+# If not specified a temporary directory will be used.
+
+# %% jupyter={"outputs_hidden": false}
+directory = os.environ.get("MONAI_DATA_DIRECTORY")
+root_dir = tempfile.mkdtemp() if directory is None else directory
+print(root_dir)
+
+# %% [markdown]
+# ## Set deterministic training for reproducibility
+
+# %% jupyter={"outputs_hidden": false}
+set_determinism(42)
+
+# %% [markdown]
+# ## Setup MedNIST Dataset and training and validation dataloaders
+# In this tutorial, we will train our models on the MedNIST dataset available on MONAI
+# (https://docs.monai.io/en/stable/apps.html#monai.apps.MedNISTDataset). In order to train faster, we will select just
+# one of the available classes ("Hand"), resulting in a training set with 7999 2D images.
+
+# %% jupyter={"outputs_hidden": false}
+train_data = MedNISTDataset(root_dir=root_dir, section="training", download=True, progress=False, seed=0)
+train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "Hand"]
+
+# %% [markdown]
+# Here we use transforms to augment the training dataset:
+#
+# 1. `LoadImaged` loads the hands images from files.
+# 1. `EnsureChannelFirstd` ensures the original data to construct "channel first" shape.
+# 1. `ScaleIntensityRanged` extracts intensity range [0, 255] and scales to [0, 1].
+# 1. `RandAffined` efficiently performs rotate, scale, shear, translate, etc. together based on PyTorch affine transform.
+
+# %% jupyter={"outputs_hidden": false}
+train_transforms = transforms.Compose(
+    [
+        transforms.LoadImaged(keys=["image"]),
+        transforms.EnsureChannelFirstd(keys=["image"]),
+        transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),
+        transforms.RandAffined(
+            keys=["image"],
+            rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)],
+            translate_range=[(-1, 1), (-1, 1)],
+            scale_range=[(-0.05, 0.05), (-0.05, 0.05)],
+            spatial_size=[64, 64],
+            padding_mode="zeros",
+            prob=0.5,
+        ),
+    ]
+)
+train_ds = CacheDataset(data=train_datalist, transform=train_transforms)
+train_loader = DataLoader(train_ds, batch_size=96, shuffle=True, num_workers=4, persistent_workers=True)
+
+# %% jupyter={"outputs_hidden": false}
+val_data = MedNISTDataset(root_dir=root_dir, section="validation", download=True, progress=False, seed=0)
+val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "Hand"]
+val_transforms = transforms.Compose(
+    [
+        transforms.LoadImaged(keys=["image"]),
+        transforms.EnsureChannelFirstd(keys=["image"]),
+        transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),
+    ]
+)
+val_ds = CacheDataset(data=val_datalist, transform=val_transforms)
+val_loader = DataLoader(val_ds, batch_size=96, shuffle=False, num_workers=4, persistent_workers=True)
+
+# %% [markdown]
+# ### Visualisation of the training images
+
+# %% jupyter={"outputs_hidden": false}
+check_data = first(train_loader)
+print(f"batch shape: {check_data['image'].shape}")
+image_visualisation = torch.cat(
+    [check_data["image"][0, 0], check_data["image"][1, 0], check_data["image"][2, 0], check_data["image"][3, 0]], dim=1
+)
+plt.figure("training images", (12, 6))
+plt.imshow(image_visualisation, vmin=0, vmax=1, cmap="gray")
+plt.axis("off")
+plt.tight_layout()
+plt.show()
+
+# %% [markdown]
+# ### Define network, scheduler, optimizer, and inferer
+# At this step, we instantiate the MONAI components to create a DDPM, the UNET, the noise scheduler, and the inferer used for training and sampling. We are using
+# the original DDPM scheduler containing 1000 timesteps in its Markov chain, and a 2D UNET with attention mechanisms
+# in the 2nd and 3rd levels, each with 1 attention head.
+
+# %% jupyter={"outputs_hidden": false}
+device = torch.device("cuda")
+
+model = DiffusionModelUNet(
+    spatial_dims=2,
+    in_channels=1,
+    out_channels=1,
+    num_channels=(128, 256, 256),
+    attention_levels=(False, True, True),
+    num_res_blocks=1,
+    num_head_channels=256,
+)
+model.to(device)
+
+scheduler = DDPMScheduler(
+    prediction_type="v_prediction",
+    num_train_timesteps=1000,
+    beta_start=0.00085,
+    beta_end=0.0120,
+)
+
+optimizer = torch.optim.Adam(params=model.parameters(), lr=1.0e-4)
+
+inferer = DiffusionInferer(scheduler)
+# %% [markdown]
+# ### Model training
+# Here, we are training our model for 75 epochs (training time: ~50 minutes).
+
+# %% jupyter={"outputs_hidden": false}
+n_epochs = 75
+val_interval = 5
+epoch_loss_list = []
+val_epoch_loss_list = []
+
+scaler = GradScaler()
+total_start = time.time()
+for epoch in range(n_epochs):
+    model.train()
+    epoch_loss = 0
+    progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=70)
+    progress_bar.set_description(f"Epoch {epoch}")
+    for step, batch in progress_bar:
+        images = batch["image"].to(device)
+        optimizer.zero_grad(set_to_none=True)
+
+        with autocast(enabled=True):
+            # Generate random noise
+            noise = torch.randn_like(images).to(device)
+            timesteps = torch.randint(
+                0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device
+            ).long()
+
+            # Get target for the v-prediction parameterization
+            target = inferer.scheduler.get_velocity(images, noise, timesteps)
+
+            # Get model prediction
+            noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)
+
+            loss = F.mse_loss(noise_pred.float(), target.float())
+
+        scaler.scale(loss).backward()
+        scaler.step(optimizer)
+        scaler.update()
+
+        epoch_loss += loss.item()
+
+        progress_bar.set_postfix(
+            {
+                "loss": epoch_loss / (step + 1),
+            }
+        )
+    epoch_loss_list.append(epoch_loss / (step + 1))
+
+    if (epoch + 1) % val_interval == 0:
+        model.eval()
+        val_epoch_loss = 0
+        for step, batch in enumerate(val_loader):
+            images = batch["image"].to(device)
+            with torch.no_grad():
+                with autocast(enabled=True):
+                    noise = torch.randn_like(images).to(device)
+                    timesteps = torch.randint(
+                        0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device
+                    ).long()
+                    target = inferer.scheduler.get_velocity(images, noise, timesteps)
+                    noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)
+                    val_loss = F.mse_loss(noise_pred.float(), target.float())
+
+            val_epoch_loss += val_loss.item()
+            progress_bar.set_postfix(
+                {
+                    "val_loss": val_epoch_loss / (step + 1),
+                }
+            )
+        val_epoch_loss_list.append(val_epoch_loss / (step + 1))
+
+        # Sampling image during training
+        noise = torch.randn((1, 1, 64, 64))
+        noise = noise.to(device)
+        scheduler.set_timesteps(num_inference_steps=1000)
+        with autocast(enabled=True):
+            image = inferer.sample(input_noise=noise, diffusion_model=model, scheduler=scheduler)
+
+        plt.figure(figsize=(2, 2))
+        plt.imshow(image[0, 0].cpu(), vmin=0, vmax=1, cmap="gray")
+        plt.tight_layout()
+        plt.axis("off")
+        plt.show()
+
+total_time = time.time() - total_start
+print(f"train completed, total time: {total_time}.")
+# %% [markdown]
+# ### Learning curves
+
+# %% jupyter={"outputs_hidden": false}
+plt.style.use("seaborn-v0_8")
+plt.title("Learning Curves", fontsize=20)
+plt.plot(np.linspace(1, n_epochs, n_epochs), epoch_loss_list, color="C0", linewidth=2.0, label="Train")
+plt.plot(
+    np.linspace(val_interval, n_epochs, int(n_epochs / val_interval)),
+    val_epoch_loss_list,
+    color="C1",
+    linewidth=2.0,
+    label="Validation",
+)
+plt.yticks(fontsize=12)
+plt.xticks(fontsize=12)
+plt.xlabel("Epochs", fontsize=16)
+plt.ylabel("Loss", fontsize=16)
+plt.legend(prop={"size": 14})
+plt.show()
+
+# %% [markdown]
+# ### Plotting sampling process along DDPM's Markov chain
+
+# %% jupyter={"outputs_hidden": false}
+model.eval()
+noise = torch.randn((1, 1, 64, 64))
+noise = noise.to(device)
+scheduler.set_timesteps(num_inference_steps=1000)
+with autocast(enabled=True):
+    image, intermediates = inferer.sample(
+        input_noise=noise, diffusion_model=model, scheduler=scheduler, save_intermediates=True, intermediate_steps=100
+    )
+
+chain = torch.cat(intermediates, dim=-1)
+
+plt.style.use("default")
+plt.imshow(chain[0, 0].cpu(), vmin=0, vmax=1, cmap="gray")
+plt.tight_layout()
+plt.axis("off")
+plt.show()
+
+# %% [markdown]
+# ### Cleanup data directory
+#
+# Remove directory if a temporary was used.
+
+# %%
+if directory is None:
+    shutil.rmtree(root_dir)
diff --git a/tutorials/generative/2d_ldm/2d_ldm_tutorial.ipynb b/tutorials/generative/2d_ldm/2d_ldm_tutorial.ipynb
index 411d4c85..5f92921f 100644
--- a/tutorials/generative/2d_ldm/2d_ldm_tutorial.ipynb
+++ b/tutorials/generative/2d_ldm/2d_ldm_tutorial.ipynb
@@ -1360,7 +1360,8 @@
     "        z = autoencoderkl.sampling(z_mu, z_sigma)\n",
     "\n",
     "        noise = torch.randn_like(z).to(device)\n",
-    "        noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise)\n",
+    "        timesteps = torch.randint(0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device).long()\n",
+    "        noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise, timesteps=timesteps)\n",
     "        loss = F.mse_loss(noise_pred.float(), noise.float())\n",
     "\n",
     "        loss.backward()\n",
@@ -1386,7 +1387,10 @@
     "                z = autoencoderkl.sampling(z_mu, z_sigma)\n",
     "\n",
     "                noise = torch.randn_like(z).to(device)\n",
-    "                noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise)\n",
+    "                timesteps = torch.randint(\n",
+    "                    0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device\n",
+    "                ).long()\n",
+    "                noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise, timesteps=timesteps)\n",
     "\n",
     "                loss = F.mse_loss(noise_pred.float(), noise.float())\n",
     "\n",
@@ -1575,8 +1579,7 @@
  "metadata": {
   "jupytext": {
    "cell_metadata_filter": "-all",
-   "formats": "ipynb,py",
-   "main_language": "python"
+   "formats": "ipynb,py"
   },
   "kernelspec": {
    "display_name": "Python 3",
diff --git a/tutorials/generative/2d_ldm/2d_ldm_tutorial.py b/tutorials/generative/2d_ldm/2d_ldm_tutorial.py
index 186daff2..defb6db4 100644
--- a/tutorials/generative/2d_ldm/2d_ldm_tutorial.py
+++ b/tutorials/generative/2d_ldm/2d_ldm_tutorial.py
@@ -320,7 +320,8 @@
         z = autoencoderkl.sampling(z_mu, z_sigma)
 
         noise = torch.randn_like(z).to(device)
-        noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise)
+        timesteps = torch.randint(0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device).long()
+        noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise, timesteps=timesteps)
         loss = F.mse_loss(noise_pred.float(), noise.float())
 
         loss.backward()
@@ -346,7 +347,10 @@
                 z = autoencoderkl.sampling(z_mu, z_sigma)
 
                 noise = torch.randn_like(z).to(device)
-                noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise)
+                timesteps = torch.randint(
+                    0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device
+                ).long()
+                noise_pred = inferer(inputs=z, diffusion_model=unet, noise=noise, timesteps=timesteps)
 
                 loss = F.mse_loss(noise_pred.float(), noise.float())
 
diff --git a/tutorials/generative/3d_ldm/3d_ldm_tutorial.py b/tutorials/generative/3d_ldm/3d_ldm_tutorial.py
index 6f140606..34b2e9f0 100644
--- a/tutorials/generative/3d_ldm/3d_ldm_tutorial.py
+++ b/tutorials/generative/3d_ldm/3d_ldm_tutorial.py
@@ -321,8 +321,16 @@ def KL_loss(z_mu, z_sigma):
         with autocast(enabled=True):
             # Generate random noise
             noise = torch.randn_like(z).to(device)
+
+            # Create timesteps
+            timesteps = torch.randint(
+                0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device
+            ).long()
+
             # Get model prediction
-            noise_pred = inferer(inputs=images, autoencoder_model=autoencoder, diffusion_model=unet, noise=noise)
+            noise_pred = inferer(
+                inputs=images, autoencoder_model=autoencoder, diffusion_model=unet, noise=noise, timesteps=timesteps
+            )
 
             loss = F.mse_loss(noise_pred.float(), noise.float())