diff --git a/generation/2d_diffusion_autoencoder/2d_diffusion_autoencoder_tutorial.ipynb b/generation/2d_diffusion_autoencoder/2d_diffusion_autoencoder_tutorial.ipynb
new file mode 100644
index 000000000..30a098fe9
--- /dev/null
+++ b/generation/2d_diffusion_autoencoder/2d_diffusion_autoencoder_tutorial.ipynb
@@ -0,0 +1,883 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "1d4911a3-a66f-4c2f-8a4d-170cd178ed5c",
+ "metadata": {},
+ "source": [
+ "Copyright (c) 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."
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "63d95da6",
+ "metadata": {},
+ "source": [
+ "# Diffusion Autoencoder Tutorial with Image Manipulation\n",
+ "\n",
+ "This tutorial illustrates how to use MONAI Generative Models for training a 2D Diffusion Autoencoder model [1].\n",
+ "\n",
+ "In summary, the tutorial will cover the following:\n",
+ "1. Training a 2D diffusion model and semantic encoder with a ResNet18 backbone;\n",
+ "2. Evaluate the learned latent space by applying a Logistic Regression classifier and manipulating images with using the direction learned by the classifier.\n",
+ "\n",
+ "We will us the 2D MRI slices from 3D BraTS volumes [2].\n",
+ "\n",
+ "\n",
+ "During inference, the model encodes the image to latent space which is used as conditioning for the U-Net=based diffusion model. [1] trains a latent diffusion model for being able to generate unconditional images, which we do not do in this tutorial. Here, we are interested in checking wether the latent space contains classification information or not and if can be used to manipulate the images.\n",
+ "\n",
+ "[1] Preechakul et al. [Diffusion Autoencoders: Toward a Meaningful and Decodable Representation](https://arxiv.org/abs/2111.15640). CVPR 2022
\n",
+ "[2] Menze, B. H., Jakab, A., Bauer, S., Kalpathy-Cramer, J., Farahani, K., Kirby, J., Burren, Y., Porz, N., Slotboom, J., Wiest, R., Lanczi, L., Gerstner, E., Weber, M.-A., Arbel, T., Avants, B. B., Ayache, N., Buendia, P., Collins, D. L., Cordier, N., … van Leemput, K. (2015). The Multimodal Brain Tumor Image Segmentation Benchmark (BRATS). IEEE Transactions on Medical Imaging, 34(10), 1993–2024. https://doi.org/10.1109/TMI.2014.2377694\n",
+ "\n",
+ "![image.png](https://diff-ae.github.io/images/diffae_overview.jpg)\n",
+ "\n",
+ "In this tutorial, then, we train an image encoder and DDPM jointly, so that the generative process is always guided by the latent representation of the encoder. The latent space can then be manipulated in the direction of specific clusters (e.g. anomaly, healthy) using logistic regression, forcing the DDPM sample to lean more towards a specific phenotype conveyed by the latent space.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2838db54-6fff-4655-8341-f0c89921ed62",
+ "metadata": {},
+ "source": [
+ "## Setup environment "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "0425c5fb-0fa7-4bd5-b435-2c6a6a50a99d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.1.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.3.1\u001b[0m\n",
+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
+ ]
+ }
+ ],
+ "source": [
+ "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm]\"\n",
+ "!python -c \"import matplotlib\" || pip install -q matplotlib\n",
+ "!pip install -q scikit-learn\n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b766027",
+ "metadata": {},
+ "source": [
+ "## Setup imports"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "972ed3f3",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ },
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import tempfile\n",
+ "import time\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "import torch.nn.functional as F\n",
+ "import torchvision\n",
+ "from monai import transforms\n",
+ "from monai.apps import DecathlonDataset\n",
+ "from monai.config import print_config\n",
+ "from monai.data import DataLoader\n",
+ "from monai.utils import set_determinism\n",
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "from monai.inferers import DiffusionInferer\n",
+ "from monai.networks.nets.diffusion_model_unet import DiffusionModelUNet\n",
+ "from monai.networks.schedulers.ddim import DDIMScheduler\n",
+ "\n",
+ "torch.multiprocessing.set_sharing_strategy(\"file_system\")\n",
+ "\n",
+ "print_config()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d4ff515",
+ "metadata": {},
+ "source": [
+ "## Setup data directory"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "8b4323e7",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
+ "root_dir = tempfile.mkdtemp() if directory is None else directory"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99175d50",
+ "metadata": {},
+ "source": [
+ "## Set deterministic training for reproducibility"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "34ea510f",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "set_determinism(42)"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "c3f70dd1-236a-47ff-a244-575729ad92ba",
+ "metadata": {},
+ "source": [
+ "## Setup BRATS Dataset - Transforms for extracting 2D slices from 3D volumes\n",
+ "\n",
+ "We now download the BraTS dataset and extract the 2D slices from the 3D volumes. The `slice_label` is used to indicate whether the slice contains an anomaly or not."
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "6986f55c",
+ "metadata": {},
+ "source": [
+ "Here we use transforms to augment the training dataset, as usual:\n",
+ "\n",
+ "1. `LoadImaged` loads the brain images from files.\n",
+ "2. `EnsureChannelFirstd` ensures the original data to construct \"channel first\" shape.\n",
+ "3. The first `Lambdad` transform chooses the first channel of the image, which is the Flair image.\n",
+ "4. `Spacingd` resamples the image to the specified voxel spacing, we use 3,3,2 mm.\n",
+ "5. `CenterSpatialCropd`: we crop the 3D images to a specific size\n",
+ "6. `ScaleIntensityRangePercentilesd` Apply range scaling to a numpy array based on the intensity distribution of the input. Transform is very common with MRI images.\n",
+ "7. `RandSpatialCropd` randomly crop out a 2D patch from the 3D image.\n",
+ "6. The last `Lambdad` transform obtains `slice_label` by summing up the label to have a single scalar value (healthy `=1` or not `=2` )."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "c68d2d91-9a0b-4ac1-ae49-f4a64edbd82a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "channel = 0 # 0 = Flair\n",
+ "assert channel in [0, 1, 2, 3], \"Choose a valid channel\"\n",
+ "\n",
+ "train_transforms = transforms.Compose(\n",
+ " [\n",
+ " transforms.LoadImaged(keys=[\"image\", \"label\"]),\n",
+ " transforms.EnsureChannelFirstd(keys=[\"image\", \"label\"]),\n",
+ " transforms.Lambdad(keys=[\"image\"], func=lambda x: x[channel, None, :, :, :]),\n",
+ " transforms.EnsureTyped(keys=[\"image\", \"label\"]),\n",
+ " transforms.Orientationd(keys=[\"image\", \"label\"], axcodes=\"RAS\"),\n",
+ " transforms.Spacingd(keys=[\"image\", \"label\"], pixdim=(3.0, 3.0, 2.0), mode=(\"bilinear\", \"nearest\")),\n",
+ " transforms.CenterSpatialCropd(keys=[\"image\", \"label\"], roi_size=(64, 64, 44)),\n",
+ " transforms.ScaleIntensityRangePercentilesd(keys=\"image\", lower=0, upper=99.5, b_min=0, b_max=1),\n",
+ " transforms.RandSpatialCropd(keys=[\"image\", \"label\"], roi_size=(64, 64, 1), random_size=False),\n",
+ " transforms.Lambdad(keys=[\"image\", \"label\"], func=lambda x: x.squeeze(-1)),\n",
+ " transforms.CopyItemsd(keys=[\"label\"], times=1, names=[\"slice_label\"]),\n",
+ " transforms.Lambdad(keys=[\"slice_label\"], func=lambda x: 1.0 if x.sum() > 0 else 0.0),\n",
+ " ]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9d378ac6",
+ "metadata": {},
+ "source": [
+ "### Load Training and Validation Datasets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "f5bb1c17-60d6-4a76-aef7-adf615a7675c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Parameters\n",
+ "batch_size = 12"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "da1927b0",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 388/388 [01:57<00:00, 3.30it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Length of training data: 388\n",
+ "Train image shape torch.Size([1, 64, 64])\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "train_ds = DecathlonDataset(\n",
+ " root_dir=root_dir,\n",
+ " task=\"Task01_BrainTumour\",\n",
+ " section=\"training\",\n",
+ " cache_rate=1.0, # you may need a few Gb of RAM... Set to 0 otherwise\n",
+ " num_workers=4,\n",
+ " download=True, # Set download to True if the dataset hasnt been downloaded yet\n",
+ " seed=0,\n",
+ " transform=train_transforms,\n",
+ ")\n",
+ "print(f\"Length of training data: {len(train_ds)}\")\n",
+ "print(f'Train image shape {train_ds[0][\"image\"].shape}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "5e39c256",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 96/96 [00:29<00:00, 3.22it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Length of training data: 96\n",
+ "Validation Image shape torch.Size([1, 64, 64])\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "val_ds = DecathlonDataset(\n",
+ " root_dir=root_dir,\n",
+ " task=\"Task01_BrainTumour\",\n",
+ " section=\"validation\",\n",
+ " cache_rate=1, # you may need a few Gb of RAM... Set to 0 otherwise\n",
+ " num_workers=4,\n",
+ " download=True, # Set download to True if the dataset hasnt been downloaded yet\n",
+ " seed=0,\n",
+ " transform=train_transforms,\n",
+ ")\n",
+ "print(f\"Length of training data: {len(val_ds)}\")\n",
+ "print(f'Validation Image shape {val_ds[0][\"image\"].shape}')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "33f7af0d-c0e0-4d42-ad53-775b72d3a694",
+ "metadata": {},
+ "source": [
+ "We create the dataloaders:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "b1f94e74-dfae-4c50-bf16-d791c589732a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "train_loader = DataLoader(\n",
+ " train_ds, batch_size=batch_size, shuffle=True, num_workers=4, drop_last=True, persistent_workers=True\n",
+ ")\n",
+ "val_loader = DataLoader(\n",
+ " val_ds, batch_size=batch_size, shuffle=False, num_workers=4, drop_last=True, persistent_workers=True\n",
+ ")"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "08428bc6",
+ "metadata": {},
+ "source": [
+ "## Define network, scheduler, optimizer, and inferer\n",
+ "\n",
+ "At this step, we instantiate the MONAI components to create a DDIM, the U-Net with conditioning, the noise scheduler, and the inferer used for training and sampling. We are using\n",
+ "the deterministic DDIM scheduler containing 1000 timesteps, and a 2D U-Net with attention mechanisms.\n",
+ "\n",
+ "The `attention` mechanism is essential for ensuring good conditioning and images manipulation here.\n",
+ "\n",
+ "The `embedding_dimension` parameter controls the dimension of the latent dimension learned by the semantic encoder.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "bee5913e",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ },
+ "lines_to_next_cell": 2
+ },
+ "outputs": [],
+ "source": [
+ "class DiffusionAE(torch.nn.Module):\n",
+ " def __init__(self, embedding_dimension=64):\n",
+ " super().__init__()\n",
+ " self.unet = DiffusionModelUNet(\n",
+ " spatial_dims=2,\n",
+ " in_channels=1,\n",
+ " out_channels=1,\n",
+ " channels=(64, 128, 256),\n",
+ " attention_levels=(False, False, True),\n",
+ " num_res_blocks=1,\n",
+ " num_head_channels=[64, 128, 256],\n",
+ " with_conditioning=True,\n",
+ " cross_attention_dim=1,\n",
+ " )\n",
+ " self.semantic_encoder = torchvision.models.resnet18()\n",
+ " self.semantic_encoder.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)\n",
+ " self.semantic_encoder.fc = torch.nn.Linear(512, embedding_dimension)\n",
+ "\n",
+ " def forward(self, xt, x_cond, t):\n",
+ " latent = self.semantic_encoder(x_cond)\n",
+ " noise_pred = self.unet(x=xt, timesteps=t, context=latent.unsqueeze(2))\n",
+ " return noise_pred, latent\n",
+ "\n",
+ "\n",
+ "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ "model = DiffusionAE(embedding_dimension=512).to(device)\n",
+ "scheduler = DDIMScheduler(num_train_timesteps=1000)\n",
+ "optimizer = torch.optim.Adam(params=model.parameters(), lr=1e-5)\n",
+ "inferer = DiffusionInferer(scheduler)"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "f815ff34",
+ "metadata": {},
+ "source": [
+ "## Training the diffusion model and the semantic encoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "9a4fc901",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Iteration 0/1000 - train Loss 0.9465\n",
+ "Iteration 0 - Interval Loss 0.3134, Interval Loss Val 0.9484\n",
+ "Iteration 50/1000 - train Loss 0.0050\n",
+ "Iteration 100/1000 - train Loss 0.0565\n",
+ "Iteration 100 - Interval Loss 3.7005, Interval Loss Val 0.0101\n",
+ "Iteration 150/1000 - train Loss 0.0092\n",
+ "Iteration 200/1000 - train Loss 0.0124\n",
+ "Iteration 200 - Interval Loss 0.5862, Interval Loss Val 0.0161\n",
+ "Iteration 250/1000 - train Loss 0.0138\n",
+ "Iteration 300/1000 - train Loss 0.0226\n",
+ "Iteration 300 - Interval Loss 0.5498, Interval Loss Val 0.0215\n",
+ "Iteration 350/1000 - train Loss 0.0175\n",
+ "Iteration 400/1000 - train Loss 0.0308\n",
+ "Iteration 400 - Interval Loss 0.5473, Interval Loss Val 0.0150\n",
+ "Iteration 450/1000 - train Loss 0.0021\n",
+ "Iteration 500/1000 - train Loss 0.0102\n",
+ "Iteration 500 - Interval Loss 0.5300, Interval Loss Val 0.0249\n",
+ "Iteration 550/1000 - train Loss 0.0159\n",
+ "Iteration 600/1000 - train Loss 0.0838\n",
+ "Iteration 600 - Interval Loss 0.5258, Interval Loss Val 0.0223\n",
+ "Iteration 650/1000 - train Loss 0.0290\n",
+ "Iteration 700/1000 - train Loss 0.0062\n",
+ "Iteration 700 - Interval Loss 0.5236, Interval Loss Val 0.0262\n",
+ "Iteration 750/1000 - train Loss 0.0294\n",
+ "Iteration 800/1000 - train Loss 0.0064\n",
+ "Iteration 800 - Interval Loss 0.5162, Interval Loss Val 0.0124\n",
+ "Iteration 850/1000 - train Loss 0.0097\n",
+ "Iteration 900/1000 - train Loss 0.0135\n",
+ "Iteration 900 - Interval Loss 0.5090, Interval Loss Val 0.0178\n",
+ "Iteration 950/1000 - train Loss 0.0021\n",
+ "train diffusion completed, total time: 2672.74955368042.\n"
+ ]
+ }
+ ],
+ "source": [
+ "max_epochs = (\n",
+ " 1000 # training for longer (1e4 ~ 3h) helps a lot with reconstruction quality, even if the loss is already low\n",
+ ")\n",
+ "val_interval = 100\n",
+ "print_interval = 50\n",
+ "iter_loss_list, val_iter_loss_list = [], []\n",
+ "iter_loss = 0\n",
+ "\n",
+ "total_start = time.time()\n",
+ "\n",
+ "for epoch in range(max_epochs):\n",
+ " for step, batch in enumerate(train_loader):\n",
+ " model.train()\n",
+ " optimizer.zero_grad(set_to_none=True)\n",
+ " images = batch[\"image\"].to(device)\n",
+ " noise = torch.randn_like(images).to(device)\n",
+ " # Create timesteps\n",
+ " timesteps = torch.randint(0, inferer.scheduler.num_train_timesteps, (batch_size,)).to(device).long()\n",
+ " # Get model prediction\n",
+ " # cross attention expects shape [batch size, sequence length, channels], \n",
+ " #we are use channels = latent dimension and sequence length = 1\n",
+ " latent = model.semantic_encoder(images)\n",
+ " noise_pred = inferer(\n",
+ " inputs=images, diffusion_model=model.unet, noise=noise, timesteps=timesteps, condition=latent.unsqueeze(2)\n",
+ " )\n",
+ " loss = F.mse_loss(noise_pred.float(), noise.float())\n",
+ "\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " iter_loss += loss.item()\n",
+ " if epoch % print_interval == 0 and step == len(train_loader) - 1:\n",
+ " print(f\"Iteration {epoch}/{max_epochs} - train Loss {loss.item():.4f}\" + \"\\r\")\n",
+ "\n",
+ " if epoch % val_interval == 0:\n",
+ " model.eval()\n",
+ " val_iter_loss = 0\n",
+ " for _, val_batch in enumerate(val_loader):\n",
+ " with torch.no_grad():\n",
+ " images = val_batch[\"image\"].to(device)\n",
+ " timesteps = torch.randint(0, inferer.scheduler.num_train_timesteps, (batch_size,)).to(device).long()\n",
+ " noise = torch.randn_like(images).to(device)\n",
+ " latent = model.semantic_encoder(images)\n",
+ " noise_pred = inferer(\n",
+ " inputs=images,\n",
+ " diffusion_model=model.unet,\n",
+ " noise=noise,\n",
+ " timesteps=timesteps,\n",
+ " condition=latent.unsqueeze(2),\n",
+ " )\n",
+ " val_loss = F.mse_loss(noise_pred.float(), noise.float())\n",
+ "\n",
+ " val_iter_loss += val_loss.item()\n",
+ " iter_loss_list.append(iter_loss / val_interval)\n",
+ " val_iter_loss_list.append(val_iter_loss / len(val_loader))\n",
+ " iter_loss = 0\n",
+ " print(\n",
+ " f\"Iteration {epoch} - Interval Loss {iter_loss_list[-1]:.4f}, \n",
+ " Interval Loss Val {val_iter_loss_list[-1]:.4f}\"\n",
+ " )\n",
+ "\n",
+ "total_time = time.time() - total_start\n",
+ "\n",
+ "print(f\"train diffusion completed, total time: {total_time}.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8e00670a-a807-4570-ba74-5453b1e3f841",
+ "metadata": {},
+ "source": [
+ "We plot the learning curves:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "cdbd04f4-f212-43b0-b2a3-5376bda07c84",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "