Update minor bugs in all notebooks and examples for v0.3 release (Project-MONAI#40)

* [DLMED] fix bugs for v0.3 release

Signed-off-by: Nic Ma <[email protected]>

* [DLMED] fix examples

Signed-off-by: Nic Ma <[email protected]>

* Update unet_segmentation_3d_catalyst.ipynb

revert to 6 epochs as this is a simple task

Co-authored-by: Wenqi Li <[email protected]>

Author: Nic-Ma

Diff for: 3d_segmentation/brats_segmentation_3d.ipynb

@@ -53,7 +53,7 @@
    },
    "outputs": [],
    "source": [
-    "%pip install -qU \"monai[gdown, nibabel]\""
+    "%pip install -qU \"monai[nibabel]\""
    ]
   },
   {
@@ -373,20 +373,20 @@
    ],
    "source": [
     "# pick one image from DecathlonDataset to visualize and check the 4 channels\n",
-    "print(f\"image shape: {val_ds[9]['image'].shape}\")\n",
+    "print(f\"image shape: {val_ds[2]['image'].shape}\")\n",
     "plt.figure(\"image\", (24, 6))\n",
     "for i in range(4):\n",
     "    plt.subplot(1, 4, i + 1)\n",
     "    plt.title(f\"image channel {i}\")\n",
-    "    plt.imshow(val_ds[9][\"image\"][i, :, :, 20].detach().cpu(), cmap=\"gray\")\n",
+    "    plt.imshow(val_ds[2][\"image\"][i, :, :, 20].detach().cpu(), cmap=\"gray\")\n",
     "plt.show()\n",
     "# also visualize the 3 channels label corresponding to this image\n",
-    "print(f\"label shape: {val_ds[9]['label'].shape}\")\n",
+    "print(f\"label shape: {val_ds[2]['label'].shape}\")\n",
     "plt.figure(\"label\", (18, 6))\n",
     "for i in range(3):\n",
     "    plt.subplot(1, 3, i + 1)\n",
     "    plt.title(f\"label channel {i}\")\n",
-    "    plt.imshow(val_ds[9][\"label\"][i, :, :, 20].detach().cpu())\n",
+    "    plt.imshow(val_ds[2][\"label\"][i, :, :, 20].detach().cpu())\n",
     "plt.show()"
    ]
   },

Diff for: 3d_segmentation/spleen_segmentation_3d_lightning.ipynb

@@ -60,7 +60,7 @@
     }
    ],
    "source": [
-    "%pip install -q \"monai[gdown, nibabel]\""
+    "%pip install -q \"monai[nibabel, tensorboard]\""
    ]
   },
   {

Diff for: acceleration/distributed_training/brats_training_ddp.py

@@ -236,6 +236,7 @@ def main_worker(args):
 
     # create UNet, DiceLoss and Adam optimizer
     device = torch.device(f"cuda:{args.local_rank}")
+    torch.cuda.set_device(device)
     if args.network == "UNet":
         model = UNet(
             dimensions=3,
@@ -250,7 +251,7 @@ def main_worker(args):
     loss_function = DiceLoss(to_onehot_y=False, sigmoid=True, squared_pred=True)
     optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=1e-5, amsgrad=True)
     # wrap the model with DistributedDataParallel module
-    model = DistributedDataParallel(model, device_ids=[args.local_rank])
+    model = DistributedDataParallel(model, device_ids=[device])
 
     # start a typical PyTorch training
     total_epoch = args.epochs

Diff for: acceleration/fast_training_tutorial.ipynb

@@ -294,7 +294,7 @@
     "\n",
     "    train_trans, val_trans = transformations()\n",
     "    # set CacheDataset for MONAI training\n",
-    "    if monai_train:\n",
+    "    if fast:\n",
     "        train_ds = CacheDataset(data=train_files, transform=train_trans, cache_rate=1.0, num_workers=8)\n",
     "        val_ds = CacheDataset(data=val_files, transform=val_trans, cache_rate=1.0, num_workers=5)\n",
     "        # don't need many workers because already cached the data\n",
@@ -313,7 +313,7 @@
     "    loss_function = DiceLoss(to_onehot_y=True, softmax=True)\n",
     "\n",
     "    # set Novograd optimizer for MONAI training\n",
-    "    if monai_train:\n",
+    "    if fast:\n",
     "        # Novograd paper suggests to use a bigger LR than Adam,\n",
     "        # because Adam does normalization by element-wise second moments\n",
     "        optimizer = Novograd(model.parameters(), learning_rate * 10)\n",
@@ -341,7 +341,7 @@
     "            inputs, labels = batch_data['image'].to(device), batch_data['label'].to(device)\n",
     "            optimizer.zero_grad()\n",
     "            # set AMP for MONAI training\n",
-    "            if monai_train:\n",
+    "            if fast:\n",
     "                with torch.cuda.amp.autocast():\n",
     "                    outputs = model(inputs)\n",
     "                    loss = loss_function(outputs, labels)\n",
@@ -359,8 +359,6 @@
     "                  f\" step time: {(time.time() - step_start):.4f}\")\n",
     "        epoch_loss /= step\n",
     "        epoch_loss_values.append(epoch_loss)\n",
-    "        #if monai_train:\n",
-    "        #    train_ds.update_cache()\n",
     "        print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n",
     "\n",
     "        if (epoch + 1) % val_interval == 0:\n",
@@ -373,7 +371,7 @@
     "                    roi_size = (160, 160, 128)\n",
     "                    sw_batch_size = 4\n",
     "                    # set AMP for MONAI validation\n",
-    "                    if monai_train:\n",
+    "                    if fast:\n",
     "                        with torch.cuda.amp.autocast():\n",
     "                            val_outputs = sliding_window_inference(val_inputs, roi_size, sw_batch_size, model)\n",
     "                    else:\n",
@@ -396,8 +394,7 @@
     "                      f\" best mean dice: {best_metric:.4f} at epoch: {best_metric_epoch}\")\n",
     "        print(f\"time consuming of epoch {epoch + 1} is: {(time.time() - epoch_start):.4f}\")\n",
     "        epoch_times.append(time.time() - epoch_start)\n",
-    "    #if monai_train:\n",
-    "    #    train_ds.shutdown()\n",
+    "\n",
     "    print(f\"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}\"\n",
     "          f\" total time: {(time.time() - total_start):.4f}\")\n",
     "    return epoch_num, epoch_loss_values, metric_values, epoch_times, best_metrics_epochs_and_time"

Diff for: acceleration/multi_gpu_test.ipynb

@@ -53,17 +53,23 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MONAI version: 0.2.0\n",
-      "Python version: 3.6.9 |Anaconda, Inc.| (default, Jul 30 2019, 19:07:31)  [GCC 7.3.0]\n",
-      "Numpy version: 1.18.1\n",
-      "Pytorch version: 1.6.0\n",
+      "MONAI version: 0.3.0rc4\n",
+      "Python version: 3.6.10 |Anaconda, Inc.| (default, May  8 2020, 02:54:21)  [GCC 7.3.0]\n",
+      "OS version: Linux (4.4.0-131-generic)\n",
+      "Numpy version: 1.19.1\n",
+      "Pytorch version: 1.7.0a0+8deb4fe\n",
+      "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n",
       "\n",
       "Optional dependencies:\n",
-      "Pytorch Ignite version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "Pytorch Ignite version: 0.4.2\n",
       "Nibabel version: 3.1.1\n",
       "scikit-image version: 0.15.0\n",
-      "Pillow version: 7.2.0\n",
-      "Tensorboard version: 2.1.0\n",
+      "Pillow version: 7.0.0\n",
+      "Tensorboard version: 2.2.0\n",
+      "gdown version: 3.12.2\n",
+      "TorchVision version: 0.8.0a0\n",
+      "ITK version: 5.1.0\n",
+      "tqdm version: 4.50.0\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",
@@ -101,20 +107,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "lr = 1e-3\n",
-    "\n",
+    "device = torch.device(\"cuda:0\")\n",
     "net = UNet(\n",
     "    dimensions=2,\n",
     "    in_channels=1,\n",
     "    out_channels=1,\n",
     "    channels=(16, 32, 64, 128, 256),\n",
     "    strides=(2, 2, 2, 2),\n",
     "    num_res_units=2,\n",
-    ")\n",
+    ").to(device)\n",
     "\n",
     "\n",
     "def fake_loss(y_pred, y):\n",
@@ -135,7 +141,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -150,22 +156,23 @@
        "\tepoch: 2\n",
        "\tepoch_length: 2\n",
        "\tmax_epochs: 2\n",
-       "\toutput: 40707.8984375\n",
+       "\toutput: 34253.46875\n",
        "\tbatch: <class 'tuple'>\n",
        "\tmetrics: <class 'dict'>\n",
        "\tdataloader: <class 'generator'>\n",
-       "\tseed: 12"
+       "\tseed: <class 'NoneType'>\n",
+       "\ttimes: <class 'dict'>"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "opt = torch.optim.Adam(net.parameters(), lr)\n",
-    "trainer = create_multigpu_supervised_trainer(net, opt, fake_loss, [torch.device(\"cuda:0\")])\n",
-    "trainer.run(fake_data_stream(), 2, 2)\n"
+    "trainer = create_multigpu_supervised_trainer(net, opt, fake_loss, [device])\n",
+    "trainer.run(fake_data_stream(), 2, 2)"
    ]
   },
   {
@@ -177,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -193,22 +200,23 @@
        "\tepoch: 2\n",
        "\tepoch_length: 2\n",
        "\tmax_epochs: 2\n",
-       "\toutput: 35669.37109375\n",
+       "\toutput: 30694.720703125\n",
        "\tbatch: <class 'tuple'>\n",
        "\tmetrics: <class 'dict'>\n",
        "\tdataloader: <class 'generator'>\n",
-       "\tseed: 12"
+       "\tseed: <class 'NoneType'>\n",
+       "\ttimes: <class 'dict'>"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "opt = torch.optim.Adam(net.parameters(), lr)\n",
     "trainer = create_multigpu_supervised_trainer(net, opt, fake_loss, None)\n",
-    "trainer.run(fake_data_stream(), 2, 2)\n"
+    "trainer.run(fake_data_stream(), 2, 2)"
    ]
   },
   {
@@ -235,11 +243,12 @@
        "\tepoch: 2\n",
        "\tepoch_length: 2\n",
        "\tmax_epochs: 2\n",
-       "\toutput: 29662.359375\n",
+       "\toutput: 26988.939453125\n",
        "\tbatch: <class 'tuple'>\n",
        "\tmetrics: <class 'dict'>\n",
        "\tdataloader: <class 'generator'>\n",
-       "\tseed: 12"
+       "\tseed: <class 'NoneType'>\n",
+       "\ttimes: <class 'dict'>"
       ]
      },
      "execution_count": 6,
@@ -248,6 +257,7 @@
     }
    ],
    "source": [
+    "net = net.to(torch.device(\"cpu:0\"))\n",
     "opt = torch.optim.Adam(net.parameters(), lr)\n",
     "trainer = create_multigpu_supervised_trainer(net, opt, fake_loss, [])\n",
     "trainer.run(fake_data_stream(), 2, 2)"

Diff for: modules/dynunet_tutorial.ipynb

@@ -454,6 +454,7 @@
     "    out_channels=n_class,\n",
     "    kernel_size=kernels,\n",
     "    strides=strides,\n",
+    "    upsamle_kernel_size=strides[1:],\n",
     "    norm_name=\"instance\",\n",
     "    deep_supervision=True,\n",
     "    deep_supr_num=2,\n",

Diff for: modules/engines/gan_evaluation.py

@@ -43,7 +43,7 @@ def main():
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
     # load generator
-    network_filepath = glob("./model_out/*.pth")[0]
+    network_filepath = glob("./model_out/*.pt")[0]
     data = torch.load(network_filepath)
     latent_size = 64
     gen_net = Generator(

Diff for: modules/mednist_GAN_tutorial.ipynb

@@ -115,7 +115,6 @@
     "import tarfile\n",
     "import urllib\n",
     "\n",
-    "import IPython\n",
     "import matplotlib.pyplot as plt\n",
     "import torch\n",
     "\n",
@@ -394,9 +393,7 @@
     "        step += 1\n",
     "\n",
     "    epoch_loss /= step\n",
-    "    epoch_loss_values.append((step, epoch_loss))\n",
-    "\n",
-    "    IPython.display.clear_output()"
+    "    epoch_loss_values.append((step, epoch_loss))"
    ]
   },
   {

Diff for: modules/mednist_GAN_workflow_array.ipynb

@@ -145,7 +145,6 @@
     "import sys\n",
     "import shutil\n",
     "\n",
-    "import IPython\n",
     "import matplotlib.pyplot as plt\n",
     "import torch\n",
     "\n",

Diff for: modules/public_datasets.ipynb

@@ -41,7 +41,7 @@
     }
    ],
    "source": [
-    "%pip install -qU \"monai[gdown, nibabel, ignite]\""
+    "%pip install -qU \"monai[nibabel, ignite]\""
    ]
   },
   {