Esempio n. 1
0
    def test_compute(self):
        auc_metric = ROCAUC()
        act = Activations(softmax=True)
        to_onehot = AsDiscrete(to_onehot=2)

        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available(
        ) else "cpu"
        if dist.get_rank() == 0:
            y_pred = [
                torch.tensor([0.1, 0.9], device=device),
                torch.tensor([0.3, 1.4], device=device)
            ]
            y = [
                torch.tensor([0], device=device),
                torch.tensor([1], device=device)
            ]

        if dist.get_rank() == 1:
            y_pred = [
                torch.tensor([0.2, 0.1], device=device),
                torch.tensor([0.1, 0.5], device=device),
                torch.tensor([0.3, 0.4], device=device),
            ]
            y = [
                torch.tensor([0], device=device),
                torch.tensor([1], device=device),
                torch.tensor([1], device=device)
            ]

        y_pred = [act(p) for p in y_pred]
        y = [to_onehot(y_) for y_ in y]
        auc_metric.update([y_pred, y])

        result = auc_metric.compute()
        np.testing.assert_allclose(0.66667, result, rtol=1e-4)
Esempio n. 2
0
    def test_compute(self):
        auc_metric = ROCAUC(to_onehot_y=True, 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)
Esempio n. 3
0
    def test_compute(self):
        auc_metric = ROCAUC(to_onehot_y=True, softmax=True)
        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available(
        ) else "cpu"
        if dist.get_rank() == 0:
            y_pred = torch.tensor([[0.1, 0.9], [0.3, 1.4]], device=device)
            y = torch.tensor([[0], [1]], device=device)
            auc_metric.update([y_pred, y])

        if dist.get_rank() == 1:
            y_pred = torch.tensor([[0.2, 0.1], [0.1, 0.5]], device=device)
            y = torch.tensor([[0], [1]], device=device)
            auc_metric.update([y_pred, y])

        result = auc_metric.compute()
        np.testing.assert_allclose(0.75, result)
Esempio n. 4
0
    def test_compute(self):
        auc_metric = ROCAUC()
        act = Activations(softmax=True)
        to_onehot = AsDiscrete(to_onehot=True, n_classes=2)

        y_pred = torch.Tensor([[0.1, 0.9], [0.3, 1.4]])
        y = torch.Tensor([[0], [1]])
        y_pred = act(y_pred)
        y = to_onehot(y)
        auc_metric.update([y_pred, y])

        y_pred = torch.Tensor([[0.2, 0.1], [0.1, 0.5]])
        y = torch.Tensor([[0], [1]])
        y_pred = act(y_pred)
        y = to_onehot(y)
        auc_metric.update([y_pred, y])

        auc = auc_metric.compute()
        np.testing.assert_allclose(0.75, auc)
Esempio n. 5
0
    def test_compute(self):
        auc_metric = ROCAUC()
        act = Activations(softmax=True)
        to_onehot = AsDiscrete(to_onehot=True, num_classes=2)

        y_pred = [torch.Tensor([0.1, 0.9]), torch.Tensor([0.3, 1.4])]
        y = [torch.Tensor([0]), torch.Tensor([1])]
        y_pred = [act(p) for p in y_pred]
        y = [to_onehot(y_) for y_ in y]
        auc_metric.update([y_pred, y])

        y_pred = [torch.Tensor([0.2, 0.1]), torch.Tensor([0.1, 0.5])]
        y = [torch.Tensor([0]), torch.Tensor([1])]
        y_pred = [act(p) for p in y_pred]
        y = [to_onehot(y_) for y_ in y]

        auc_metric.update([y_pred, y])

        auc = auc_metric.compute()
        np.testing.assert_allclose(0.75, auc)
Esempio n. 6
0
def main():
    dist.init_process_group(backend="nccl", init_method="env://")

    auc_metric = ROCAUC(to_onehot_y=True, softmax=True)

    if dist.get_rank() == 0:
        y_pred = torch.tensor([[0.1, 0.9], [0.3, 1.4]],
                              device=torch.device("cuda:0"))
        y = torch.tensor([[0], [1]], device=torch.device("cuda:0"))
        auc_metric.update([y_pred, y])

    if dist.get_rank() == 1:
        y_pred = torch.tensor([[0.2, 0.1], [0.1, 0.5]],
                              device=torch.device("cuda:1"))
        y = torch.tensor([[0], [1]], device=torch.device("cuda:1"))
        auc_metric.update([y_pred, y])

    result = auc_metric.compute()
    np.testing.assert_allclose(0.75, result)

    dist.destroy_process_group()
    def test_compute(self):
        auc_metric = ROCAUC()
        act = Activations(softmax=True)
        to_onehot = AsDiscrete(to_onehot=True, n_classes=2)

        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available(
        ) else "cpu"
        if dist.get_rank() == 0:
            y_pred = torch.tensor([[0.1, 0.9], [0.3, 1.4]], device=device)
            y = torch.tensor([[0], [1]], device=device)

        if dist.get_rank() == 1:
            y_pred = torch.tensor([[0.2, 0.1], [0.1, 0.5], [0.3, 0.4]],
                                  device=device)
            y = torch.tensor([[0], [1], [1]], device=device)

        y_pred = act(y_pred)
        y = to_onehot(y)
        auc_metric.update([y_pred, y])

        result = auc_metric.compute()
        np.testing.assert_allclose(0.66667, result, rtol=1e-4)