unimodal tests

ayrna · Jan 18, 2024 · 41d1056 · 41d1056
1 parent 8662a9d
commit 41d1056
Show file tree

Hide file tree

Showing 4 changed files with 397 additions and 4 deletions.
diff --git a/dlordinal/losses/general_triangular_loss.py b/dlordinal/losses/general_triangular_loss.py
@@ -63,7 +63,7 @@ def __init__(
         label_smoothing: float = 0.0,
     ):
         # Precompute class probabilities for each label
-        r = get_general_triangular_probabilities(num_classes, alphas, verbose=3)
+        r = get_general_triangular_probabilities(num_classes, alphas, verbose=0)
         cls_probs = torch.tensor(r)
 
         super().__init__(

diff --git a/dlordinal/losses/tests/test_beta_loss.py b/dlordinal/losses/tests/test_beta_loss.py
@@ -1,3 +1,4 @@
+import pytest
 import torch
 
 from ..beta_loss import BetaCrossEntropyLoss
@@ -8,7 +9,7 @@ def test_beta_loss_creation():
     assert isinstance(loss, BetaCrossEntropyLoss)
 
 
-def test_beta_loss_output():
+def test_beta_loss_basic():
     loss = BetaCrossEntropyLoss(num_classes=6)
 
     input_data = torch.tensor(
@@ -28,3 +29,102 @@ def test_beta_loss_output():
 
     # Verifies that the loss is greater than zero
     assert output.item() > 0
+
+
+def test_beta_loss_exactvalue():
+    loss = BetaCrossEntropyLoss(num_classes=6)
+
+    input_data = torch.tensor(
+        [
+            [0.8, 0.1, 0.1, 0.0, 0.0, 0.0],
+            [0.1, 0.8, 0.1, 0.0, 0.0, 0.0],
+            [0.0, 0.1, 0.8, 0.1, 0.0, 0.0],
+        ]
+    )
+    target = torch.tensor([0, 1, 2])
+
+    # Compute the loss
+    output = loss(input_data, target)
+
+    # Verifies that the output is a tensor
+    assert isinstance(output, torch.Tensor)
+
+    # Verifies that the loss is greater than zero
+    assert output.item() == pytest.approx(1.3925, rel=1e-3)
+
+
+def test_beta_loss_relative():
+    loss = BetaCrossEntropyLoss(num_classes=6)
+
+    input_data = torch.tensor(
+        [
+            [100.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        ]
+    )
+
+    input_data2 = torch.tensor(
+        [
+            [0.0, 0.0, 100.0, 0.0, 0.0, 0.0],
+        ]
+    )
+
+    input_data3 = torch.tensor(
+        [
+            [0.0, 0.0, 0.0, 0.0, 100.0, 0.0],
+        ]
+    )
+
+    target = torch.tensor([0])
+
+    # Compute the loss
+    output = loss(input_data, target)
+    output2 = loss(input_data2, target)
+    output3 = loss(input_data3, target)
+
+    # Verifies that the output is a tensor
+    assert isinstance(output, torch.Tensor)
+
+    assert output3.item() > output2.item() > output.item()
+
+
+def test_beta_loss_eta():
+    input_data = torch.tensor(
+        [
+            [0.0, 0.0, 100.0, 0.0, 0.0, 0.0],
+        ]
+    )
+
+    target = torch.tensor([0])
+
+    last_loss = None
+    for eta in [0.1, 0.3, 0.5, 0.7, 1.0]:
+        loss = BetaCrossEntropyLoss(num_classes=6, eta=eta)
+
+        # Compute the loss
+        output = loss(input_data, target)
+
+        if last_loss is not None:
+            assert output.item() < last_loss.item()
+
+        last_loss = output
+
+
+def test_beta_loss_weights():
+    weights = torch.tensor([5.0, 2.0, 1.0, 0.5, 0.1, 0.1])
+    loss = BetaCrossEntropyLoss(num_classes=6, weight=weights)
+
+    input_data = torch.tensor(
+        [
+            [0.0, 0.0, 100.0, 0.0, 0.0, 0.0],
+        ]
+    )
+
+    target = torch.tensor([0])
+    target2 = torch.tensor([1])
+    target3 = torch.tensor([3])
+
+    loss1 = loss(input_data, target)
+    loss2 = loss(input_data, target2)
+    loss3 = loss(input_data, target3)
+
+    assert loss1.item() > loss2.item() > loss3.item()
diff --git a/dlordinal/losses/tests/test_general_triangular_loss.py b/dlordinal/losses/tests/test_general_triangular_loss.py
@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 import torch
 
 from ..general_triangular_loss import GeneralTriangularCrossEntropyLoss
@@ -29,7 +30,7 @@ def test_general_triangular_loss_creation():
     assert isinstance(loss, GeneralTriangularCrossEntropyLoss)
 
 
-def test_general_triangular_loss_output():
+def test_general_triangular_loss_basic():
     alphas = np.array(
         [
             0.11073934,
@@ -68,3 +69,173 @@ def test_general_triangular_loss_output():
 
     # Verifies that the loss is greater than zero
     assert output.item() > 0
+
+
+def test_general_triangular_loss_exactvalue():
+    alphas = np.array(
+        [
+            0.11073934,
+            0.10117434,
+            0.01966654,
+            0.04475356,
+            0.02453978,
+            0.07121018,
+            0.1535088,
+            0.01083356,
+            0.05561108,
+            0.04605048,
+            0.02095387,
+            0.15887076,
+        ]
+    )
+
+    num_classes = 6
+
+    loss = GeneralTriangularCrossEntropyLoss(num_classes=num_classes, alphas=alphas)
+
+    input_data = torch.tensor(
+        [
+            [-1.6488, -2.5838, -2.8312, -1.9495, -2.4759, -3.4682],
+            [-1.7872, -3.9560, -6.2586, -8.3967, -7.9779, -8.0079],
+            [-2.4078, -2.5133, -2.5584, -1.7485, -2.3675, -2.6099],
+        ]
+    )
+    target = torch.tensor([4, 0, 5])
+
+    # Compute the loss
+    output = loss(input_data, target)
+
+    # Verifies that the output is a tensor
+    assert isinstance(output, torch.Tensor)
+
+    # Verifies that the loss is greater than zero
+    assert output.item() == pytest.approx(1.3814, rel=1e-3)
+
+
+def test_general_triangular_loss_relative():
+    alphas = np.array(
+        [
+            0.11073934,
+            0.10117434,
+            0.01966654,
+            0.04475356,
+            0.02453978,
+            0.07121018,
+            0.1535088,
+            0.01083356,
+            0.05561108,
+            0.04605048,
+            0.02095387,
+            0.15887076,
+        ]
+    )
+
+    num_classes = 6
+
+    loss = GeneralTriangularCrossEntropyLoss(num_classes=num_classes, alphas=alphas)
+
+    input_data = torch.tensor(
+        [
+            [100.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        ]
+    )
+    input_data2 = torch.tensor(
+        [
+            [0.0, 0.0, 0.0, 100.0, 0.0, 0.0],
+        ]
+    )
+    input_data3 = torch.tensor(
+        [
+            [0.0, 0.0, 0.0, 0.0, 100.0, 0.0],
+        ]
+    )
+    target = torch.tensor([1])
+
+    # Compute the loss
+    output = loss(input_data, target)
+    output2 = loss(input_data2, target)
+    output3 = loss(input_data3, target)
+
+    assert output3.item() >= output2.item() > output.item()
+
+
+def test_general_triangular_loss_same_alphas():
+    alphas = np.array(
+        [
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+        ]
+    )
+
+    num_classes = 6
+
+    loss = GeneralTriangularCrossEntropyLoss(num_classes=num_classes, alphas=alphas)
+
+    input_data = torch.tensor(
+        [
+            [100.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        ]
+    )
+    input_data2 = torch.tensor(
+        [
+            [0.0, 0.0, 100.0, 0.0, 0.0, 0.0],
+        ]
+    )
+    target = torch.tensor([1])
+
+    # Compute the loss
+    output = loss(input_data, target)
+    output2 = loss(input_data2, target)
+
+    assert output2.item() == output.item()
+
+
+def test_general_triangular_loss_different_alphas():
+    alphas = np.array(
+        [
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.15,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+            0.05,
+        ]
+    )
+
+    num_classes = 6
+
+    loss = GeneralTriangularCrossEntropyLoss(num_classes=num_classes, alphas=alphas)
+
+    input_data = torch.tensor(
+        [
+            [100.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+        ]
+    )
+    input_data2 = torch.tensor(
+        [
+            [0.0, 0.0, 100.0, 0.0, 0.0, 0.0],
+        ]
+    )
+    target = torch.tensor([1])
+
+    # Compute the loss
+    output = loss(input_data, target)
+    output2 = loss(input_data2, target)
+
+    assert output2.item() < output.item()