Repository: Project-MONAI/MONAI

Issue:
add ROC AUC metric
**Is your feature request related to a problem? Please describe.**
Computes Area Under the Receiver Operating Characteristic Curve (ROC AUC).
It's very useful for medical image classification tasks.

**Describe the solution you'd like**
Add ROC AUC metric and ignite handler.

Discussion:
Nic-Ma: Hi @wyli ,

Thanks for your patch of Doc-string update, it looks good to me.

Patch:
diff --git a/docs/source/handlers.rst b/docs/source/handlers.rst
index 90897014..87ac9cec 100644
--- a/docs/source/handlers.rst
+++ b/docs/source/handlers.rst
@@ -20,6 +20,11 @@ Mean Dice metrics handler
 .. automodule:: monai.handlers.mean_dice
     :members:
 
+ROC AUC metrics handler
+-------------------------
+.. automodule:: monai.handlers.roc_auc
+    :members:
+
 Metric logger
 ---------------
 .. automodule:: monai.handlers.metric_logger
diff --git a/docs/source/metrics.rst b/docs/source/metrics.rst
index 875e6b4b..e40177c1 100644
--- a/docs/source/metrics.rst
+++ b/docs/source/metrics.rst
@@ -5,13 +5,14 @@
 Metrics
 ========
 
-Segmentation metrics
---------------------
-
 .. automodule:: monai.metrics
 .. currentmodule:: monai.metrics
 
 
-`compute_meandice`
-~~~~~~~~~~~~~~~~~~~
-.. automethod:: monai.metrics.compute_meandice
+`Mean Dice`
+-----------
+.. automethod:: monai.metrics.meandice.compute_meandice
+
+`Area under the ROC curve`
+--------------------------
+.. automethod:: monai.metrics.rocauc.compute_roc_auc
diff --git a/examples/README.md b/examples/README.md
index b6f2c9b3..9a3bec54 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -23,6 +23,7 @@ This tutorial shows how to accelerate PyTorch medical DL program based on MONAI
 #### [notebooks/mednist_tutorial](./notebooks/mednist_tutorial.ipynb)
 This notebook shows how to easily integrate MONAI features into existing PyTorch programs.
 It's based on the MedNIST dataset which is very suitable for beginners as a tutorial.
+The content is also available as [a Colab tutorial](https://colab.research.google.com/drive/1wy8XUSnNWlhDNazFdvGBHLfdkGvOHBKe).
 #### [notebooks/multi_gpu_test](./notebooks/multi_gpu_test.ipynb)
 This notebook is a quick demo for devices, run the Ignite trainer engine on CPU, GPU and multiple GPUs.
 #### [notebooks/nifti_read_example](./notebooks/nifti_read_example.ipynb)
diff --git a/examples/classification_3d/densenet_training_dict.py b/examples/classification_3d/densenet_training_dict.py
index 14600436..4cd9b909 100644
--- a/examples/classification_3d/densenet_training_dict.py
+++ b/examples/classification_3d/densenet_training_dict.py
@@ -18,6 +18,7 @@ from torch.utils.tensorboard import SummaryWriter
 
 import monai
 from monai.transforms import Compose, LoadNiftid, AddChanneld, ScaleIntensityd, Resized, RandRotate90d, ToTensord
+from monai.metrics import compute_roc_auc
 
 monai.config.print_config()
 logging.basicConfig(stream=sys.stdout, level=logging.INFO)
@@ -97,8 +98,6 @@ optimizer = torch.optim.Adam(model.parameters(), 1e-5)
 val_interval = 2
 best_metric = -1
 best_metric_epoch = -1
-epoch_loss_values = list()
-metric_values = list()
 writer = SummaryWriter()
 for epoch in range(5):
     print('-' * 10)
@@ -119,29 +118,28 @@ for epoch in range(5):
         print("%d/%d, train_loss:%0.4f" % (step, epoch_len, loss.item()))
         writer.add_scalar('train_loss', loss.item(), epoch_len * epoch + step)
     epoch_loss /= step
-    epoch_loss_values.append(epoch_loss)
     print("epoch %d average loss:%0.4f" % (epoch + 1, epoch_loss))
 
     if (epoch + 1) % val_interval == 0:
         model.eval()
         with torch.no_grad():
-            num_correct = 0.
-            metric_count = 0
+            y_pred = torch.tensor([], dtype=torch.float32, device=device)
+            y = torch.tensor([], dtype=torch.long, device=device)
             for val_data in val_loader:
                 val_images, val_labels = val_data['img'].to(device), val_data['label'].to(device)
-                val_outputs = model(val_images)
-                value = torch.eq(val_outputs.argmax(dim=1), val_labels)
-                metric_count += len(value)
-                num_correct += value.sum().item()
-            metric = num_correct / metric_count
-            metric_values.append(metric)
-            if metric > best_metric:
-                best_metric = metric
+                y_pred = torch.cat([y_pred, model(val_images)], dim=0)
+                y = torch.cat([y, val_labels], dim=0)
+
+            acc_value = torch.eq(y_pred.argmax(dim=1), y)
+            acc_metric = acc_value.sum().item() / len(acc_value)
+            auc_metric = compute_roc_auc(y_pred, y, to_onehot_y=True, add_softmax=True)
+            if acc_metric > best_metric:
+                best_metric = acc_metric
                 best_metric_epoch = epoch + 1
                 torch.save(model.state_dict(), 'best_metric_model.pth')
                 print('saved new best metric model')
-            print("current epoch %d current accuracy: %0.4f best accuracy: %0.4f at epoch %d"
-                  % (epoch + 1, metric, best_metric, best_metric_epoch))
-            writer.add_scalar('val_accuracy', metric, epoch + 1)
+            print("current epoch %d current accuracy: %0.4f current AUC: %0.4f best accuracy: %0.4f at epoch %d"
+                  % (epoch + 1, acc_metric, auc_metric, best_metric, best_metric_epoch))
+            writer.add_scalar('val_accuracy', acc_metric, epoch + 1)
 print('train completed, best_metric: %0.4f  at epoch: %d' % (best_metric, best_metric_epoch))
 writer.close()
diff --git a/examples/classification_3d_ignite/densenet_training_dict.py b/examples/classification_3d_ignite/densenet_training_dict.py
index fee2a04d..f7efaf6b 100644
--- a/examples/classification_3d_ignite/densenet_training_dict.py
+++ b/examples/classification_3d_ignite/densenet_training_dict.py
@@ -20,7 +20,7 @@ from torch.utils.data import DataLoader
 
 import monai
 from monai.transforms import Compose, LoadNiftid, AddChanneld, ScaleIntensityd, Resized, RandRotate90d, ToTensord
-from monai.handlers import StatsHandler, TensorBoardStatsHandler, stopping_fn_from_metric
+from monai.handlers import StatsHandler, TensorBoardStatsHandler, stopping_fn_from_metric, ROCAUC
 
 monai.config.print_config()
 logging.basicConfig(stream=sys.stdout, level=logging.INFO)
@@ -119,7 +119,7 @@ validation_every_n_epochs = 1
 
 metric_name = 'Accuracy'
 # add evaluation metric to the evaluator engine
-val_metrics = {metric_name: Accuracy()}
+val_metrics = {metric_name: Accuracy(), 'AUC': ROCAUC(to_onehot_y=True, add_softmax=True)}
 # ignite evaluator expects batch=(img, label) and returns output=(y_pred, y) at every iteration,
 # user can add output_transform to return other values
 evaluator = create_supervised_evaluator(net, val_metrics, device, True, prepare_batch=prepare_batch)
diff --git a/examples/notebooks/mednist_tutorial.ipynb b/examples/notebooks/mednist_tutorial.ipynb
index c705cb7c..0dbcaa47 100644
--- a/examples/notebooks/mednist_tutorial.ipynb
+++ b/examples/notebooks/mednist_tutorial.ipynb
@@ -82,6 +82,7 @@
     "from monai.transforms import \\\n",
     "    Compose, LoadPNG, AddChannel, ScaleIntensity, ToTensor, RandRotate, RandFlip, RandZoom, Resize\n",
     "from monai.networks.nets import densenet121\n",
+    "from monai.metrics import compute_roc_auc\n",
     "\n",
     "np.random.seed(0)"
    ]
@@ -225,11 +226,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
-    "train_transforms = compose.Compose([\n",
+    "train_transforms = Compose([\n",
     "    LoadPNG(),\n",
     "    AddChannel(),\n",
     "    ScaleIntensity(),\n",
@@ -240,7 +241,7 @@
     "    ToTensor()\n",
     "])\n",
     "\n",
-    "val_transforms = compose.Compose([\n",
+    "val_transforms = Compose([\n",
     "    LoadPNG(),\n",
     "    AddChannel(),\n",
     "    ScaleIntensity(),\n",
@@ -250,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -292,7 +293,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -351,23 +352,23 @@
     "    if (epoch + 1) % val_interval == 0:\n",
     "        model.eval()\n",
     "        with torch.no_grad():\n",
-    "            num_correct = 0.\n",
-    "            metric_count = 0\n",
+    "            y_pred = torch.tensor([], dtype=torch.float32, device=device)\n",
+    "            y = torch.tensor([], dtype=torch.long, device=device)\n",
     "            for val_data in val_loader:\n",
     "                val_images, val_labels = val_data[0].to(device), val_data[1].to(device)\n",
-    "                val_outputs = model(val_images)\n",
-    "                value = torch.eq(val_outputs.argmax(dim=1), val_labels)\n",
-    "                metric_count += len(value)\n",
-    "                num_correct += value.sum().item()\n",
-    "            metric = num_correct / metric_count\n",
-    "            metric_values.append(metric)\n",
-    "            if metric > best_metric:\n",
-    "                best_metric = metric\n",
+    "                y_pred = torch.cat([y_pred, model(val_images)], dim=0)\n",
+    "                y = torch.cat([y, val_labels], dim=0)\n",
+    "            auc_metric = compute_roc_auc(y_pred, y, to_onehot_y=True, add_softmax=True)\n",
+    "            metric_values.append(auc_metric)\n",
+    "            acc_value = torch.eq(y_pred.argmax(dim=1), y)\n",
+    "            acc_metric = acc_value.sum().item() / len(acc_value)\n",
+    "            if auc_metric > best_metric:\n",
+    "                best_metric = auc_metric\n",
     "                best_metric_epoch = epoch + 1\n",
     "                torch.save(model.state_dict(), 'best_metric_model.pth')\n",
     "                print('saved new best metric model')\n",
-    "            print(\"current epoch %d current accuracy: %0.4f best accuracy: %0.4f at epoch %d\"\n",
-    "                  % (epoch + 1, metric, best_metric, best_metric_epoch))\n",
+    "            print(\"current epoch %d current AUC: %0.4f current accuracy: %0.4f best AUC: %0.4f at epoch %d\"\n",
+    "                  % (epoch + 1, auc_metric, acc_metric, best_metric, best_metric_epoch))\n",
     "print('train completed, best_metric: %0.4f  at epoch: %d' % (best_metric, best_metric_epoch))"
    ]
   },
@@ -380,12 +381,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x432 with 2 Axes>"
       ]
@@ -405,7 +406,7 @@
     "plt.xlabel('epoch')\n",
     "plt.plot(x, y)\n",
     "plt.subplot(1, 2, 2)\n",
-    "plt.title(\"Val Accuracy\")\n",
+    "plt.title(\"Val AUC\")\n",
     "x = [val_interval * (i + 1) for i in range(len(metric_values))]\n",
     "y = metric_values\n",
     "plt.xlabel('epoch')\n",
@@ -425,7 +426,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -448,7 +449,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "pip install -U sklearn"
+    "! pip install -U sklearn"
    ]
   },
   {
@@ -462,16 +463,16 @@
      "text": [
       "              precision    recall  f1-score   support\n",
       "\n",
-      "        Hand     0.9969    0.9959    0.9964       969\n",
-      "   AbdomenCT     0.9904    0.9904    0.9904      1046\n",
-      "         CXR     0.9969    0.9969    0.9969       961\n",
-      "     ChestCT     0.9939    1.0000    0.9969       980\n",
+      "        Hand     0.9928    0.9959    0.9943       969\n",
+      "   AbdomenCT     0.9830    0.9952    0.9891      1046\n",
+      "         CXR     0.9979    0.9927    0.9953       961\n",
+      "     ChestCT     0.9969    1.0000    0.9985       980\n",
       "   BreastMRI     1.0000    0.9905    0.9952       944\n",
-      "      HeadCT     0.9919    0.9959    0.9939       985\n",
+      "      HeadCT     0.9959    0.9909    0.9934       985\n",
       "\n",
-      "    accuracy                         0.9949      5885\n",
-      "   macro avg     0.9950    0.9949    0.9950      5885\n",
-      "weighted avg     0.9949    0.9949    0.9949      5885\n",
+      "    accuracy                         0.9942      5885\n",
+      "   macro avg     0.9944    0.9942    0.9943      5885\n",
+      "weighted avg     0.9943    0.9942    0.9942      5885\n",
       "\n"
      ]
     }
@@ -498,9 +499,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.6"
+   "version": "3.6.9"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/monai/handlers/__init__.py b/monai/handlers/__init__.py
index d65612f9..9c649147 100644
--- a/monai/handlers/__init__.py
+++ b/monai/handlers/__init__.py
@@ -12,6 +12,7 @@
 from .checkpoint_loader import CheckpointLoader
 from .classification_saver import ClassificationSaver
 from .mean_dice import MeanDice
+from .roc_auc import ROCAUC
 from .metric_logger import *
 from .segmentation_saver import SegmentationSaver
 from .stats_handler import StatsHandler
diff --git a/monai/handlers/mean_dice.py b/monai/handlers/mean_dice.py
index 9e0d6794..d83606fc 100644
--- a/monai/handlers/mean_dice.py
+++ b/monai/handlers/mean_dice.py
@@ -18,8 +18,6 @@ from ignite.metrics.metric import reinit__is_reduced, sync_all_reduce
 
 from monai.metrics import compute_meandice
 
-__all__ = ['MeanDice']
-
 
 class MeanDice(Metric):
     """Computes dice score metric from full size Tensor and collects average over batch, class-channels, iterations.
diff --git a/monai/handlers/roc_auc.py b/monai/handlers/roc_auc.py
new file mode 100644
index 00000000..e4bb14a3
--- /dev/null
+++ b/monai/handlers/roc_auc.py
@@ -0,0 +1,78 @@
+# 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.
+
+from typing import Sequence
+
+import torch
+from ignite.metrics import Metric
+
+from monai.metrics import compute_roc_auc
+
+
+class ROCAUC(Metric):
+    """Computes Area Under the Receiver Operating Characteristic Curve (ROC AUC).
+    accumulating predictions and the ground-truth during an epoch and applying `compute_roc_auc`.
+
+    Args:
+        to_onehot_y (bool): whether to convert `y` into the one-hot format. Defaults to False.
+        add_softmax (bool): whether to add softmax function to `y_pred` before computation. Defaults to False.
+        add_sigmoid (bool): whether to add sigmoid function to `y_pred` before computation. Defaults to False.
+        average (`macro|weighted|micro|None`): type of averaging performed if not binary classification. default is 'macro'.
+
+            - 'macro': calculate metrics for each label, and find their unweighted mean.
+              this does not take label imbalance into account.
+            - 'weighted': calculate metrics for each label, and find their average,
+              weighted by support (the number of true instances for each label).
+            - 'micro': calculate metrics globally by considering each element of the label
+              indicator matrix as a label.
+            - None: the scores for each class are returned.
+
+        output_transform (callable, optional): a callable that is used to transform the
+            :class:`~ignite.engine.Engine` `process_function` output into the
+            form expected by the metric. This can be useful if, for example, you have a multi-output model and
+            you want to compute the metric with respect to one of the outputs.
+
+    Note:
+        ROCAUC expects y to be comprised of 0's and 1's.  y_pred must either be probability estimates or confidence values.
+
+    """
+    def __init__(self,
+                 to_onehot_y=False,
+                 add_softmax=False,
+                 add_sigmoid=False,
+                 average='macro',
+                 output_transform=lambda x: x):
+        super().__init__(output_transform=output_transform)
+        self.to_onehot_y = to_onehot_y
+        self.add_softmax = add_softmax
+        self.add_sigmoid = add_sigmoid
+        self.average = average
+
+    def reset(self):
+        self._predictions = torch.tensor([], dtype=torch.float32)
+        self._targets = torch.tensor([], dtype=torch.long)
+
+    def update(self, output: Sequence[torch.Tensor]):
+        y_pred, y = output
+        if y_pred.ndimension() not in (1, 2):
+            raise ValueError("predictions should be of shape (batch_size, n_classes) or (batch_size, ).")
+        if y.ndimension() not in (1, 2):
+            raise ValueError("targets should be of shape (batch_size, n_classes) or (batch_size, ).")
+
+        y_pred = y_pred.to(self._predictions)
+        y = y.to(self._targets)
+
+        self._predictions = torch.cat([self._predictions, y_pred], dim=0)
+        self._targets = torch.cat([self._targets, y], dim=0)
+
+    def compute(self):
+        return compute_roc_auc(self._predictions, self._targets, self.to_onehot_y,
+                               self.add_softmax, self.add_sigmoid, self.average)
diff --git a/monai/metrics/__init__.py b/monai/metrics/__init__.py
index 9e37eac2..0e72dfe5 100644
--- a/monai/metrics/__init__.py
+++ b/monai/metrics/__init__.py
@@ -10,3 +10,4 @@
 # limitations under the License.
 
 from .meandice import compute_meandice
+from .rocauc import compute_roc_auc
diff --git a/monai/metrics/rocauc.py b/monai/metrics/rocauc.py
new file mode 100644
index 00000000..d82f83a2
--- /dev/null
+++ b/monai/metrics/rocauc.py
@@ -0,0 +1,117 @@
+# 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 torch
+import warnings
+import numpy as np
+from monai.networks.utils import one_hot
+
+
+def _calculate(y, y_pred):
+    assert y.ndimension() == y_pred.ndimension() == 1 and len(y) == len(y_pred), \
+        'y and y_pred must be 1 dimension data with same length.'
+    assert y.unique().equal(torch.tensor([0, 1])), 'y values must be 0 or 1, can not be all 0 or all 1.'
+    pos_indexes, neg_indexes = list(), list()
+    for index, y_ in enumerate(y):
+        if y_ == 1:
+            pos_indexes.append(index)
+        elif y_ == 0:
+            neg_indexes.append(index)
+        else:
+            raise ValueError('labels should be binary values.')
+
+    def compare(a, b):
+        if a > b:
+            return 1
+        elif a == b:
+            return 0.5
+        else:
+            return 0
+    auc = sum([sum([compare(y_pred[i], y_pred[j]) for j in neg_indexes]) for i in pos_indexes])
+
+    return auc / (len(pos_indexes) * len(neg_indexes))
+
+
+def compute_roc_auc(y_pred, y, to_onehot_y=False, add_softmax=False, add_sigmoid=False, average='macro'):
+    """Computes Area Under the Receiver Operating Characteristic Curve (ROC AUC) based on:
+    `sklearn.metrics.roc_auc_score <http://scikit-learn.org/stable/modules/generated/
+    sklearn.metrics.roc_auc_score.html#sklearn.metrics.roc_auc_score>`_ .
+
+    Args:
+        y_pred (torch.Tensor): input data to compute, typical classification model output.
+            it must be One-Hot format and first dim is batch, example shape: [16] or [16, 2].
+        y (torch.Tensor): ground truth to compute ROC AUC metric, the first dim is batch.
+            example shape: [16, 1] will be converted into [16, 3].
+        to_onehot_y (bool): whether to convert `y` into the one-hot format. Defaults to False.
+        add_softmax (bool): whether to add softmax function to y_pred before computation. Defaults to False.
+        add_sigmoid (bool): whether to add sigmoid function to y_pred before computation. Defaults to False.
+        average (`macro|weighted|micro|None`): type of averaging performed if not binary
+            classification. default is 'macro'.
+
+            - 'macro': calculate metrics for each label, and find their unweighted mean.
+              this does not take label imbalance into account.
+            - 'weighted': calculate metrics for each label, and find their average,
+              weighted by support (the number of true instances for each label).
+            - 'micro': calculate metrics globally by considering each element of the label
+              indicator matrix as a label.
+            - None: the scores for each class are returned.
+
+    Note:
+        ROCAUC expects y to be comprised of 0's and 1's. y_pred must be either prob. estimates or confidence values.
+
+    """
+    if add_softmax and add_sigmoid:
+        raise ValueError('add_softmax=True and add_sigmoid=True are not compatible.')
+
+    y_pred_ndim = y_pred.ndimension()
+    y_ndim = y.ndimension()
+    if y_pred_ndim not in (1, 2):
+        raise ValueError("predictions should be of shape (batch_size, n_classes) or (batch_size, ).")
+    if y_ndim not in (1, 2):
+        raise ValueError("targets should be of shape (batch_size, n_classes) or (batch_size, ).")
+    if y_pred_ndim == 2 and y_pred.shape[1] == 1:
+        y_pred = y_pred.squeeze(dim=-1)
+        y_pred_ndim = 1
+    if y_ndim == 2 and y.shape[1] == 1:
+        y = y.squeeze(dim=-1)
+        y_ndim = 1
+
+    if add_sigmoid:
+        y_pred = y_pred.float().sigmoid()
+
+    if y_pred_ndim == 1:
+        if to_onehot_y:
+            warnings.warn('y_pred has only one channel, to_onehot_y=True ignored.')
+        if add_softmax:
+            warnings.warn('y_pred has only one channel, add_softmax=True ignored.')
+        return _calculate(y, y_pred)
+    else:
+        n_classes = y_pred.shape[1]
+        if to_onehot_y:
+            y = one_hot(y, n_classes)
+        if add_softmax:
+            y_pred = y_pred.float().softmax(dim=1)
+
+        assert y.shape == y_pred.shape, 'data shapes of y_pred and y do not match.'
+
+        if average == 'micro':
+            return _calculate(y.flatten(), y_pred.flatten())
+        else:
+            y, y_pred = y.transpose(0, 1), y_pred.transpose(0, 1)
+            auc_values = [_calculate(y_, y_pred_) for y_, y_pred_ in zip(y, y_pred)]
+            if average is None:
+                return auc_values
+            if average == 'macro':
+                return np.mean(auc_values)
+            if average == 'weighted':
+                weights = [sum(y_) for y_ in y]
+                return np.average(auc_values, weights=weights)
+            raise ValueError('unsupported average method.')
diff --git a/monai/networks/utils.py b/monai/networks/utils.py
index 1d7a8ed5..69fdb392 100644
--- a/monai/networks/utils.py
+++ b/monai/networks/utils.py
@@ -28,10 +28,9 @@ def one_hot(labels, num_classes):
         Note that this will include the background label, thus a binary mask should be treated as having 2 classes.
     """
     num_dims = labels.dim()
-    if num_dims < 2 or labels.shape[1] != 1:
-        raise ValueError('labels should have a channel with length equals to one.')
-
-    labels = torch.squeeze(labels, 1)
+    if num_dims > 1:
+        assert labels.shape[1] == 1, 'labels should have a channel with length equals to one.'
+        labels = torch.squeeze(labels, 1)
     labels = f.one_hot(labels.long(), num_classes)
     new_axes = [0, -1] + list(range(1, num_dims - 1))
     labels = labels.permute(*new_axes)
diff --git a/monai/transforms/composables.py b/monai/transforms/composables.py
index e2f3947e..27326a8d 100644
--- a/monai/transforms/composables.py
+++ b/monai/transforms/composables.py
@@ -938,7 +938,7 @@ class RandCropByPosNegLabeld(Randomizable, MapTransform):
             if key in self.keys:
                 img = d[key]
                 for i, center in enumerate(self.centers):
-                    cropper = SpatialCrop(roi_center=tuple(center), roi_size=self.size, copy=True)
+                    cropper = SpatialCrop(roi_center=tuple(center), roi_size=self.size)
                     results[i][key] = cropper(img)
             else:
                 for i in range(self.num_samples):
diff --git a/monai/transforms/transforms.py b/monai/transforms/transforms.py
index f79402ad..8853130f 100644
--- a/monai/transforms/transforms.py
+++ b/monai/transforms/transforms.py
@@ -976,14 +976,13 @@ class SpatialCrop(Transform):
     Note: This transform will not work if the crop region is larger than the image itself.
     """
 
-    def __init__(self, roi_center=None, roi_size=None, roi_start=None, roi_end=None, copy=False):
+    def __init__(self, roi_center=None, roi_size=None, roi_start=None, roi_end=None):
         """
         Args:
             roi_center (list or tuple): voxel coordinates for center of the crop ROI.
             roi_size (list or tuple): size of the crop ROI.
             roi_start (list or tuple): voxel coordinates for start of the crop ROI.
             roi_end (list or tuple): voxel coordinates for end of the crop ROI.
-            copy (bool): whether copy the cropped slices to a new array, default is False.
         """
         if roi_center is not None and roi_size is not None:
             roi_center = np.asarray(roi_center, dtype=np.uint16)
@@ -994,7 +993,6 @@ class SpatialCrop(Transform):
             assert roi_start is not None and roi_end is not None, 'roi_start and roi_end must be provided.'
             self.roi_start = np.asarray(roi_start, dtype=np.uint16)
             self.roi_end = np.asarray(roi_end, dtype=np.uint16)
-        self.copy = copy
 
         assert np.all(self.roi_start >= 0), 'all elements of roi_start must be greater than or equal to 0.'
         assert np.all(self.roi_end > 0), 'all elements of roi_end must be positive.'
@@ -1007,8 +1005,7 @@ class SpatialCrop(Transform):
         assert np.all(max_end[:sd] >= self.roi_end[:sd]), 'roi end out of image space.'
 
         slices = [slice(None)] + [slice(s, e) for s, e in zip(self.roi_start[:sd], self.roi_end[:sd])]
-        data = img[tuple(slices)]
-        return data.copy() if self.copy else data
+        return img[tuple(slices)]
 
 
 class CenterSpatialCrop(Transform):
@@ -1024,7 +1021,7 @@ class CenterSpatialCrop(Transform):
 
     def __call__(self, img):
         center = [i // 2 for i in img.shape[1:]]
-        cropper = SpatialCrop(roi_center=center, roi_size=self.roi_size, copy=False)
+        cropper = SpatialCrop(roi_center=center, roi_size=self.roi_size)
         return cropper(img)
 
 


Test patch:
diff --git a/tests/test_compute_roc_auc.py b/tests/test_compute_roc_auc.py
new file mode 100644
index 00000000..b9d17042
--- /dev/null
+++ b/tests/test_compute_roc_auc.py
@@ -0,0 +1,98 @@
+# 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 unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.metrics import compute_roc_auc
+
+TEST_CASE_1 = [
+    {
+        'y_pred': torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+        'y': torch.tensor([[0], [1], [0], [1]]),
+        'to_onehot_y': True,
+        'add_softmax': True,
+    },
+    0.75
+]
+
+TEST_CASE_2 = [
+    {
+        'y_pred': torch.tensor([[0.5], [0.5], [0.2], [8.3]]),
+        'y': torch.tensor([[0], [1], [0], [1]]),
+        'add_sigmoid': True
+    },
+    0.875
+]
+
+TEST_CASE_3 = [
+    {
+        'y_pred': torch.tensor([[0.5], [0.5], [0.2], [8.3]]),
+        'y': torch.tensor([0, 1, 0, 1]),
+        'add_sigmoid': True
+    },
+    0.875
+]
+
+TEST_CASE_4 = [
+    {
+        'y_pred': torch.tensor([0.5, 0.5, 0.2, 8.3]),
+        'y': torch.tensor([0, 1, 0, 1]),
+        'add_sigmoid': True
+    },
+    0.875
+]
+
+TEST_CASE_5 = [
+    {
+        'y_pred': torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+        'y': torch.tensor([[0], [1], [0], [1]]),
+        'to_onehot_y': True,
+        'add_softmax': True,
+        'average': None
+    },
+    [0.75, 0.75]
+]
+
+TEST_CASE_6 = [
+    {
+        'y_pred': torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5], [0.1, 0.5]]),
+        'y': torch.tensor([[1, 0], [0, 1], [0, 0], [1, 1], [0, 1]]),
+        'add_softmax': True,
+        'average': 'weighted'
+    },
+    0.56667
+]
+
+TEST_CASE_7 = [
+    {
+        'y_pred': torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5], [0.1, 0.5]]),
+        'y': torch.tensor([[1, 0], [0, 1], [0, 0], [1, 1], [0, 1]]),
+        'add_softmax': True,
+        'average': 'micro'
+    },
+    0.62
+]
+
+
+class TestComputeROCAUC(unittest.TestCase):
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4, TEST_CASE_5, TEST_CASE_6, TEST_CASE_7])
+    def test_value(self, input_data, expected_value):
+        result = compute_roc_auc(**input_data)
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/test_handler_rocauc.py b/tests/test_handler_rocauc.py
new file mode 100644
index 00000000..c36af720
--- /dev/null
+++ b/tests/test_handler_rocauc.py
@@ -0,0 +1,37 @@
+# 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 unittest
+import numpy as np
+import torch
+
+from monai.handlers import ROCAUC
+
+
+class TestHandlerROCAUC(unittest.TestCase):
+
+    def test_compute(self):
+        auc_metric = ROCAUC(to_onehot_y=True, add_softmax=True)
+
+        y_pred = torch.Tensor([[0.1, 0.9], [0.3, 1.4]])
+        y = torch.Tensor([[0], [1]])
+        auc_metric.update([y_pred, y])
+
+        y_pred = torch.Tensor([[0.2, 0.1], [0.1, 0.5]])
+        y = torch.Tensor([[0], [1]])
+        auc_metric.update([y_pred, y])
+
+        auc = auc_metric.compute()
+        np.testing.assert_allclose(0.75, auc)
+
+
+if __name__ == '__main__':
+    unittest.main()