From d8fc34290cd1bb1f242749c4bede8f6ab4b9388b Mon Sep 17 00:00:00 2001
From: YunLiu <55491388+KumoLiu@users.noreply.github.com>
Date: Fri, 19 Jan 2024 23:35:57 +0800
Subject: [PATCH] Add `torch.compile` benchmark tutorial (#1607)

Fixes # .

### Description
Add a tutorial about how to use `torch.compile`.

### Checks
<!--- Put an `x` in all the boxes that apply, and remove the not
applicable items -->
- [ ] Avoid including large-size files in the PR.
- [ ] Clean up long text outputs from code cells in the notebook.
- [ ] For security purposes, please check the contents and remove any
sensitive info such as user names and private key.
- [ ] Ensure (1) hyperlinks and markdown anchors are working (2) use
relative paths for tutorial repo files (3) put figure and graphs in the
`./figure` folder
- [ ] Notebook runs automatically `./runner.sh -t <path to .ipynb file>`

---------

Signed-off-by: YunLiu <55491388+KumoLiu@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
---
 modules/torch_compile.ipynb | 607 ++++++++++++++++++++++++++++++++++++
 1 file changed, 607 insertions(+)
 create mode 100644 modules/torch_compile.ipynb

diff --git a/modules/torch_compile.ipynb b/modules/torch_compile.ipynb
new file mode 100644
index 0000000000..ac85eaa652
--- /dev/null
+++ b/modules/torch_compile.ipynb
@@ -0,0 +1,607 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "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",
+    "&nbsp;&nbsp;&nbsp;&nbsp;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."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# MONAI pipeline with PyTorch 2.0 Features\n",
+    "\n",
+    "This notebook introduces how to use `torch.compile` in the MONAI pipeline. `torch.compile` is the main API for PyTorch 2.0, which wraps your model and returns a compiled model. It is a fully additive (and optional) feature and hence 2.0 is 100% backward compatible by definition. We also run an end-to-end pipeline based on [\"fast_training_tutorial.ipynb\"](https://github.com/Project-MONAI/tutorials/blob/main/acceleration/fast_training_tutorial.ipynb), and the speed up is 1.16x."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup environment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, matplotlib]\"\n",
+    "# %pip install -q torch==2.1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import shutil\n",
+    "import tempfile\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import monai\n",
+    "import monai.transforms as mt\n",
+    "from monai.config import print_config\n",
+    "from monai.utils import set_determinism\n",
+    "from monai.bundle import download, create_workflow\n",
+    "from monai.engines import SupervisedTrainer\n",
+    "\n",
+    "print_config()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup data directory\n",
+    "\n",
+    "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable.  \n",
+    "This allows you to save results and reuse downloads.  \n",
+    "If not specified, a temporary directory will be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/workspace/data\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",
+   "metadata": {},
+   "source": [
+    "## Download dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-01-19 06:02:08,535 - INFO - Expected md5 is None, skip md5 check for file samples.zip.\n",
+      "2024-01-19 06:02:08,536 - INFO - File exists: samples.zip, skipped downloading.\n",
+      "2024-01-19 06:02:08,537 - INFO - Writing into directory: /workspace/data.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sample_url = \"https://github.com/Project-MONAI/MONAI-extra-test-data/releases\"\n",
+    "sample_url += \"/download/0.8.1/totalSegmentator_mergedLabel_samples.zip\"\n",
+    "monai.apps.download_and_extract(sample_url, output_dir=root_dir, filepath=\"samples.zip\")\n",
+    "\n",
+    "base_name = os.path.join(root_dir, \"totalSegmentator_mergedLabel_samples\")\n",
+    "input_data = []\n",
+    "for filename in os.listdir(os.path.join(base_name, \"imagesTr\")):\n",
+    "    input_data.append(\n",
+    "        {\n",
+    "            \"image\": os.path.join(base_name, \"imagesTr\", filename),\n",
+    "            \"label\": os.path.join(base_name, \"labelsTr\", filename),\n",
+    "        }\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set deterministic for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "set_determinism(seed=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set up timing and training functions\n",
+    "\n",
+    "For best accuracies, we use CUDA events and synchronization to measure the forward and backward propagations in training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def timed(fn):\n",
+    "    start = torch.cuda.Event(enable_timing=True)\n",
+    "    end = torch.cuda.Event(enable_timing=True)\n",
+    "    start.record()\n",
+    "    result = fn()\n",
+    "    end.record()\n",
+    "    torch.cuda.synchronize()\n",
+    "    return result, start.elapsed_time(end) / 1000\n",
+    "\n",
+    "\n",
+    "def train(model, inputs, labels):\n",
+    "    outputs = model(inputs)\n",
+    "    loss_function = monai.losses.DiceCELoss(to_onehot_y=True, softmax=True)\n",
+    "    loss = loss_function(outputs, labels)\n",
+    "    loss.backward()\n",
+    "    return loss"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set up model\n",
+    "\n",
+    "Here we used `create_workflow` to get the network instance from the bundle. You can also initialize your own network."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-01-19 06:02:11,869 - INFO - --- input summary of monai.bundle.scripts.download ---\n",
+      "2024-01-19 06:02:11,870 - INFO - > name: 'wholeBody_ct_segmentation'\n",
+      "2024-01-19 06:02:11,872 - INFO - > bundle_dir: './bundle'\n",
+      "2024-01-19 06:02:11,872 - INFO - > source: 'monaihosting'\n",
+      "2024-01-19 06:02:11,873 - INFO - > remove_prefix: 'monai_'\n",
+      "2024-01-19 06:02:11,874 - INFO - > progress: True\n",
+      "2024-01-19 06:02:11,875 - INFO - ---\n",
+      "\n",
+      "\n",
+      "2024-01-19 06:02:12,098 - INFO - Expected md5 is None, skip md5 check for file bundle/wholeBody_ct_segmentation_v0.2.1.zip.\n",
+      "2024-01-19 06:02:12,099 - INFO - File exists: bundle/wholeBody_ct_segmentation_v0.2.1.zip, skipped downloading.\n",
+      "2024-01-19 06:02:12,100 - INFO - Writing into directory: bundle.\n",
+      "2024-01-19 06:02:13,092 - INFO - --- input summary of monai.bundle.scripts.run ---\n",
+      "2024-01-19 06:02:13,095 - INFO - > config_file: './bundle/wholeBody_ct_segmentation/configs/train.json'\n",
+      "2024-01-19 06:02:13,095 - INFO - > workflow_type: 'train'\n",
+      "2024-01-19 06:02:13,096 - INFO - ---\n",
+      "\n",
+      "\n",
+      "2024-01-19 06:02:13,097 - INFO - Setting logging properties based on config: bundle/wholeBody_ct_segmentation/configs/logging.conf.\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
+    "bundle_dir = \"./bundle\"\n",
+    "os.makedirs(bundle_dir, exist_ok=True)\n",
+    "\n",
+    "bundle = download(\"wholeBody_ct_segmentation\", bundle_dir=bundle_dir)\n",
+    "config_file = os.path.join(bundle_dir, \"wholeBody_ct_segmentation/configs/train.json\")\n",
+    "train_workflow = create_workflow(config_file=str(config_file), workflow_type=\"train\")\n",
+    "\n",
+    "\n",
+    "def init_model(device):\n",
+    "    return train_workflow.network_def.to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set up DataLoader and train transforms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset:   0%|          | 0/20 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading dataset: 100%|██████████| 20/20 [00:05<00:00,  3.80it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "transform = mt.Compose(\n",
+    "    [\n",
+    "        mt.LoadImageD(keys=(\"image\", \"label\"), image_only=True, ensure_channel_first=True),\n",
+    "        mt.SpacingD(keys=(\"image\", \"label\"), pixdim=1.5),\n",
+    "        mt.EnsureTypeD(keys=(\"image\", \"label\"), device=device),\n",
+    "        mt.RandRotateD(\n",
+    "            keys=(\"image\", \"label\"),\n",
+    "            prob=1.0,\n",
+    "            range_x=0.1,\n",
+    "            range_y=0.1,\n",
+    "            range_z=0.3,\n",
+    "            mode=(\"bilinear\", \"nearest\"),\n",
+    "        ),\n",
+    "        mt.RandZoomD(keys=(\"image\", \"label\"), prob=1.0, min_zoom=0.8, max_zoom=1.2, mode=(\"trilinear\", \"nearest\")),\n",
+    "        mt.ResizeWithPadOrCropD(keys=(\"image\", \"label\"), spatial_size=(96, 96, 96)),\n",
+    "        # add `FromMetaTensorD` to convert `MetaTensor` to `torch.Tensor`\n",
+    "        mt.FromMetaTensorD(keys=(\"image\", \"label\")),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "dataset = monai.data.CacheDataset(data=input_data, transform=transform, cache_rate=1.0, num_workers=4)\n",
+    "data_loader = monai.data.DataLoader(dataset, batch_size=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training in eager mode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1/50 average loss: 5.3744, time: 4.4076\n",
+      "epoch 2/50 average loss: 4.9032, time: 1.6782\n",
+      "epoch 3/50 average loss: 4.2364, time: 1.6784\n",
+      "epoch 4/50 average loss: 3.7725, time: 1.6777\n",
+      "epoch 5/50 average loss: 3.4782, time: 1.6766\n",
+      "mean training time per iteration: 0.0866 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "# start a typical PyTorch training\n",
+    "epoch_num = 50\n",
+    "model = init_model(device)\n",
+    "optimizer = torch.optim.Adam(model.parameters(), 1e-3)\n",
+    "\n",
+    "epoch_loss_values = []\n",
+    "eager_time = []\n",
+    "for epoch in range(epoch_num):\n",
+    "    model.train()\n",
+    "    epoch_loss = 0\n",
+    "    step = 0\n",
+    "    for batch_data in data_loader:\n",
+    "        step += 1\n",
+    "        inputs, labels = batch_data[\"image\"].to(device), batch_data[\"label\"].to(device)\n",
+    "        optimizer.zero_grad()\n",
+    "        loss, train_time = timed(lambda: train(model, inputs, labels))  # noqa: B023\n",
+    "        optimizer.step()\n",
+    "        epoch_loss += loss.item()\n",
+    "        eager_time.append(train_time)\n",
+    "    epoch_loss /= step\n",
+    "    epoch_loss_values.append(epoch_loss)\n",
+    "    if epoch < 5:\n",
+    "        print(\n",
+    "            f\"epoch {epoch + 1}/{epoch_num} average loss: {epoch_loss:.4f}, \"\n",
+    "            f\"time: {sum(eager_time[epoch*step: epoch*step+step]):.4f}\"\n",
+    "        )\n",
+    "print(f\"mean training time per iteration: {np.mean(eager_time):.4f} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train the model with torch.compile\n",
+    "\n",
+    "The only difference is that we wrap the model with `torch.compile`. You may also see different speedup results depending on the chosen mode argument. The \"reduce-overhead\" mode uses CUDA graphs to further reduce the overhead of Python. For your own models, you may need to experiment with different modes to maximize speedup. You can read more about modes [here](https://pytorch.org/get-started/pytorch-2.0/#user-experience)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_opt = torch.compile(init_model(device), mode=\"reduce-overhead\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using FallbackKernel: aten.upsample_trilinear3d\n",
+      "Using FallbackKernel: aten.upsample_trilinear3d_backward\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1/50 average loss: 2.6362, time: 24.4882\n",
+      "epoch 2/50 average loss: 2.5796, time: 1.0590\n",
+      "epoch 3/50 average loss: 2.5479, time: 1.0595\n",
+      "epoch 4/50 average loss: 2.5509, time: 1.0593\n",
+      "epoch 5/50 average loss: 2.5566, time: 1.0595\n",
+      "mean training time per iteration after compilation: 0.0765 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "# start a typical PyTorch training\n",
+    "optimizer = torch.optim.Adam(model_opt.parameters(), 1e-3)\n",
+    "\n",
+    "epoch_loss_values = []\n",
+    "compile_time = []\n",
+    "for epoch in range(epoch_num):\n",
+    "    model_opt.train()\n",
+    "    epoch_loss = 0\n",
+    "    step = 0\n",
+    "    for batch_data in data_loader:\n",
+    "        step += 1\n",
+    "        inputs, labels = batch_data[\"image\"].to(device), batch_data[\"label\"].to(device)\n",
+    "        optimizer.zero_grad()\n",
+    "        loss, train_time = timed(lambda: train(model_opt, inputs, labels))  # noqa: B023\n",
+    "        optimizer.step()\n",
+    "        epoch_loss += loss.item()\n",
+    "        compile_time.append(train_time)\n",
+    "    epoch_loss /= step\n",
+    "    epoch_loss_values.append(epoch_loss)\n",
+    "    if epoch < 5:\n",
+    "        print(\n",
+    "            f\"epoch {epoch + 1}/{epoch_num} average loss: {epoch_loss:.4f}, \"\n",
+    "            f\"time: {sum(compile_time[epoch*step: epoch*step+step]):.4f}\"\n",
+    "        )\n",
+    "print(f\"mean training time per iteration after compilation: {np.mean(compile_time):.4f} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Demonstrate the speedups\n",
+    "As [torch](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) mentioned, we can see that `torch.compile` takes longer in the first epoch, as it must compile the model, but in subsequent iterations, we can see a significant improvement compared to eager. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first iteration: 2.814s(eager mode) vs. 22.228s(compile mode)\n",
+      "eager mean: 0.08661233669281006, compile mean: 0.07646919039535521, speedup: 1.1326435685406568x\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"first iteration: {eager_time[0]:.3f}s(eager mode) vs. {compile_time[0]:.3f}s(compile mode)\")\n",
+    "\n",
+    "speedup = np.mean(eager_time) / np.mean(compile_time)\n",
+    "print(f\"eager mean: {np.mean(eager_time)}, compile mean: {np.mean(compile_time)}, speedup: {speedup}x\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot total time and every epoch time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f3774c0eec0>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(\"train\", (12, 6))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.title(\"Total Train Time(300 epochs)\")\n",
+    "plt.bar(\"Compile\", sum(compile_time), 1, label=\"Compile training\", color=\"red\")\n",
+    "plt.bar(\"Fast\", sum(eager_time), 1, label=\"Fast training\", color=\"green\")\n",
+    "plt.ylabel(\"secs\")\n",
+    "plt.yscale(\"log\")\n",
+    "plt.grid(alpha=0.4, linestyle=\":\")\n",
+    "plt.legend(loc=\"best\")\n",
+    "\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.title(\"Epoch Time\")\n",
+    "x = [i + 1 for i in range(int(len(compile_time) / step))]\n",
+    "plt.xlabel(\"epoch\")\n",
+    "plt.ylabel(\"secs\")\n",
+    "plt.plot(\n",
+    "    x,\n",
+    "    [sum(compile_time[i * step : (i + 1) * step]) for i in range(int(len(compile_time) / step))],\n",
+    "    label=\"Compile training\",\n",
+    "    color=\"red\",\n",
+    ")\n",
+    "plt.plot(\n",
+    "    x,\n",
+    "    [sum(eager_time[i * step : (i + 1) * step]) for i in range(int(len(eager_time) / step))],\n",
+    "    label=\"Fast training\",\n",
+    "    color=\"green\",\n",
+    ")\n",
+    "plt.yscale(\"log\")\n",
+    "plt.grid(alpha=0.4, linestyle=\":\")\n",
+    "plt.legend(loc=\"best\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also tried `torch.compile` in [fast_training_tutorial.ipynb](https://github.com/Project-MONAI/tutorials/blob/main/acceleration/fast_training_tutorial.ipynb).\n",
+    "The total training time for fast and compile is as follows: 354.9534s and 305.6460s, speedup: 1.16x."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use `torch.compile` with Engine Classes\n",
+    "\n",
+    "We can simply set `compile=True` in the `SupervisedTrainer` and `SupervisedEvaluator`. Here we convert data to `torch.Tensor` internally if set `compile=True`. Here is the [ticket](https://github.com/pytorch/pytorch/issues/117026) we can track."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_function = monai.losses.DiceCELoss(to_onehot_y=True, softmax=True)\n",
+    "trainer = SupervisedTrainer(\n",
+    "    device=device,\n",
+    "    max_epochs=epoch_num,\n",
+    "    train_data_loader=data_loader,\n",
+    "    network=model,\n",
+    "    optimizer=optimizer,\n",
+    "    loss_function=loss_function,\n",
+    "    # postprocessing=post_transform,\n",
+    "    # amp=args.amp,\n",
+    "    # key_train_metric={\n",
+    "    #     \"train_dice\": MeanDice(\n",
+    "    #         include_background=False,\n",
+    "    #         output_transform=from_engine([\"pred\", \"label\"]),\n",
+    "    #     )\n",
+    "    # },\n",
+    "    compile=True,\n",
+    "    # you can also add `compile_kwargs` dict of the args for `torch.compile()` API\n",
+    "    compile_kwargs={},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Cleanup data directory\n",
+    "Remove directory if a temporary was used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if directory is None:\n",
+    "    shutil.rmtree(root_dir)"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}