Add tests for tests for logsoftmax, softplus, softsign

Talmaj · Talmaj · commit 8cbd450200cc · 2025-11-04T21:41:13.000+01:00
diff --git a/onnx2pytorch/convert/operations.py b/onnx2pytorch/convert/operations.py
@@ -271,9 +271,12 @@ def convert_operations(onnx_graph, opset_version, batch_dim=0, enable_pruning=Tr
             kwargs.update(extract_attributes(node))
             op = nn.LogSoftmax(**kwargs)
         elif node.op_type == "Softplus":
-            op = nn.Softplus(**extract_attributes(node))
+            # ONNX Softplus has no attributes: y = ln(exp(x) + 1)
+            # PyTorch Softplus with beta=1 matches ONNX spec
+            op = nn.Softplus(beta=1)
         elif node.op_type == "Softsign":
-            op = nn.Softsign(**extract_attributes(node))
+            # ONNX Softsign has no attributes: y = x / (1 + |x|)
+            op = nn.Softsign()
         elif node.op_type == "Split":
             kwargs = extract_attributes(node)
             # if the split_size_or_sections is not in node attributes,
diff --git a/tests/onnx2pytorch/operations/test_logsoftmax.py b/tests/onnx2pytorch/operations/test_logsoftmax.py
@@ -0,0 +1,135 @@
+import numpy as np
+import onnxruntime as ort
+import pytest
+import torch
+from onnx import helper, TensorProto
+
+from onnx2pytorch.convert import ConvertModel
+
+
+@pytest.mark.parametrize(
+    "axis,input_shape",
+    [
+        (-1, [2, 3, 4]),  # Default axis=-1
+        (0, [2, 3, 4]),
+        (1, [2, 3, 4]),
+        (2, [2, 3, 4]),
+        (-2, [2, 3, 4]),
+        (1, [5, 10]),  # 2D input
+        (-1, [8]),  # 1D input
+    ],
+)
+def test_logsoftmax_onnxruntime(axis, input_shape):
+    """Test LogSoftmax against onnxruntime."""
+    np.random.seed(42)
+
+    # Create input
+    X = np.random.randn(*input_shape).astype(np.float32)
+
+    # Create ONNX graph with LogSoftmax node
+    input_tensor = helper.make_tensor_value_info("X", TensorProto.FLOAT, input_shape)
+    output_tensor = helper.make_tensor_value_info("Y", TensorProto.FLOAT, input_shape)
+
+    logsoftmax_node = helper.make_node(
+        "LogSoftmax",
+        inputs=["X"],
+        outputs=["Y"],
+        axis=axis,
+    )
+
+    graph = helper.make_graph(
+        [logsoftmax_node],
+        "logsoftmax_test",
+        [input_tensor],
+        [output_tensor],
+    )
+
+    model = helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 13)], ir_version=8
+    )
+
+    # Run with onnxruntime
+    ort_session = ort.InferenceSession(model.SerializeToString())
+    ort_outputs = ort_session.run(None, {"X": X})
+    expected_Y = ort_outputs[0]
+
+    # Convert to PyTorch and run
+    o2p_model = ConvertModel(model, experimental=True)
+    X_torch = torch.from_numpy(X)
+
+    with torch.no_grad():
+        o2p_output = o2p_model(X_torch)
+
+    # Compare outputs
+    torch.testing.assert_close(
+        o2p_output,
+        torch.from_numpy(expected_Y),
+        rtol=1e-5,
+        atol=1e-5,
+    )
+
+
+def test_logsoftmax_default_axis():
+    """Test LogSoftmax with default axis=-1."""
+    np.random.seed(42)
+
+    input_shape = [2, 3, 4]
+    X = np.random.randn(*input_shape).astype(np.float32)
+
+    # Create ONNX graph WITHOUT specifying axis (should default to -1)
+    input_tensor = helper.make_tensor_value_info("X", TensorProto.FLOAT, input_shape)
+    output_tensor = helper.make_tensor_value_info("Y", TensorProto.FLOAT, input_shape)
+
+    logsoftmax_node = helper.make_node(
+        "LogSoftmax",
+        inputs=["X"],
+        outputs=["Y"],
+        # No axis specified - should default to -1
+    )
+
+    graph = helper.make_graph(
+        [logsoftmax_node],
+        "logsoftmax_test",
+        [input_tensor],
+        [output_tensor],
+    )
+
+    model = helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 13)], ir_version=8
+    )
+
+    # Run with onnxruntime
+    ort_session = ort.InferenceSession(model.SerializeToString())
+    ort_outputs = ort_session.run(None, {"X": X})
+    expected_Y = ort_outputs[0]
+
+    # Convert to PyTorch and run
+    o2p_model = ConvertModel(model, experimental=True)
+    X_torch = torch.from_numpy(X)
+
+    with torch.no_grad():
+        o2p_output = o2p_model(X_torch)
+
+    # Compare outputs
+    torch.testing.assert_close(
+        o2p_output,
+        torch.from_numpy(expected_Y),
+        rtol=1e-5,
+        atol=1e-5,
+    )
+
+
+def test_logsoftmax_properties():
+    """Test mathematical properties of LogSoftmax."""
+    # LogSoftmax(x) = log(Softmax(x))
+    X = torch.randn(2, 5)
+
+    logsoftmax_output = torch.nn.functional.log_softmax(X, dim=-1)
+    softmax_output = torch.nn.functional.softmax(X, dim=-1)
+    log_of_softmax = torch.log(softmax_output)
+
+    torch.testing.assert_close(logsoftmax_output, log_of_softmax, rtol=1e-5, atol=1e-5)
+
+    # Sum of exp(log_softmax) should be 1
+    sum_exp = torch.exp(logsoftmax_output).sum(dim=-1)
+    torch.testing.assert_close(sum_exp, torch.ones_like(sum_exp), rtol=1e-5, atol=1e-5)
diff --git a/tests/onnx2pytorch/operations/test_softplus.py b/tests/onnx2pytorch/operations/test_softplus.py
@@ -0,0 +1,127 @@
+import numpy as np
+import onnxruntime as ort
+import pytest
+import torch
+from onnx import helper, TensorProto
+
+from onnx2pytorch.convert import ConvertModel
+
+
+@pytest.mark.parametrize(
+    "input_shape",
+    [
+        [2, 3, 4],
+        [5, 10],
+        [8],
+        [1, 1, 5, 5],
+    ],
+)
+def test_softplus_default_onnxruntime(input_shape):
+    """Test Softplus with default parameters against onnxruntime."""
+    np.random.seed(42)
+
+    # Create input
+    X = np.random.randn(*input_shape).astype(np.float32)
+
+    # Create ONNX graph with Softplus node (default parameters)
+    input_tensor = helper.make_tensor_value_info("X", TensorProto.FLOAT, input_shape)
+    output_tensor = helper.make_tensor_value_info("Y", TensorProto.FLOAT, input_shape)
+
+    softplus_node = helper.make_node(
+        "Softplus",
+        inputs=["X"],
+        outputs=["Y"],
+    )
+
+    graph = helper.make_graph(
+        [softplus_node],
+        "softplus_test",
+        [input_tensor],
+        [output_tensor],
+    )
+
+    model = helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 11)], ir_version=8
+    )
+
+    # Run with onnxruntime
+    ort_session = ort.InferenceSession(model.SerializeToString())
+    ort_outputs = ort_session.run(None, {"X": X})
+    expected_Y = ort_outputs[0]
+
+    # Convert to PyTorch and run
+    o2p_model = ConvertModel(model, experimental=True)
+    X_torch = torch.from_numpy(X)
+
+    with torch.no_grad():
+        o2p_output = o2p_model(X_torch)
+
+    # Compare outputs
+    torch.testing.assert_close(
+        o2p_output,
+        torch.from_numpy(expected_Y),
+        rtol=1e-5,
+        atol=1e-5,
+    )
+
+
+def test_softplus_properties():
+    """Test mathematical properties of Softplus."""
+    # Softplus(x) = log(1 + exp(x))
+    X = torch.randn(10, 20)
+
+    softplus_output = torch.nn.functional.softplus(X)
+    manual_output = torch.log(1 + torch.exp(X))
+
+    # Note: For very large X, exp(X) overflows, so softplus uses approximation
+    # Compare only for reasonable values
+    mask = X < 10
+    torch.testing.assert_close(
+        softplus_output[mask], manual_output[mask], rtol=1e-5, atol=1e-5
+    )
+
+    # Softplus should always be positive
+    assert (softplus_output > 0).all()
+
+    # For large positive x, softplus(x) ≈ x
+    large_x = torch.tensor([10.0, 20.0, 50.0])
+    softplus_large = torch.nn.functional.softplus(large_x)
+    torch.testing.assert_close(softplus_large, large_x, rtol=1e-2, atol=1e-2)
+
+    # For large negative x, softplus(x) ≈ 0
+    small_x = torch.tensor([-10.0, -20.0, -50.0])
+    softplus_small = torch.nn.functional.softplus(small_x)
+    assert (softplus_small < 0.01).all()
+
+
+def test_softplus_vs_relu():
+    """Test that Softplus is a smooth approximation of ReLU."""
+    X = torch.linspace(-5, 5, 100)
+
+    softplus_output = torch.nn.functional.softplus(X)
+    relu_output = torch.nn.functional.relu(X)
+
+    # Softplus should be close to ReLU for large positive values
+    mask = X > 3
+    torch.testing.assert_close(
+        softplus_output[mask], relu_output[mask], rtol=0.1, atol=0.1
+    )
+
+    # Softplus should be smooth (no sharp corner at 0 like ReLU)
+    # At x=0: softplus(0) = log(2) ≈ 0.693, relu(0) = 0
+    softplus_at_zero = torch.nn.functional.softplus(torch.tensor([0.0]))
+    assert abs(softplus_at_zero.item() - 0.693) < 0.01
+
+
+def test_softplus_gradient():
+    """Test that Softplus gradient is sigmoid."""
+    # d/dx softplus(x) = sigmoid(x) = 1/(1 + exp(-x))
+    X = torch.randn(5, 5, requires_grad=True)
+
+    output = torch.nn.functional.softplus(X)
+    output.sum().backward()
+
+    # Gradient should be sigmoid(X)
+    expected_grad = torch.sigmoid(X)
+
+    torch.testing.assert_close(X.grad, expected_grad, rtol=1e-5, atol=1e-5)
diff --git a/tests/onnx2pytorch/operations/test_softsign.py b/tests/onnx2pytorch/operations/test_softsign.py
