Enhance activations testing

[jalvesz]

Motivation

A module with activation function was added in #860

It was proposed to include the means to check the functions against known libraries such as PyTorch or TensorFlow. A way to do that would be to add a Python script that evalues the available activations and their derivatives and stores them as a list of .npy files. These files should then be read in the tests to compare the results

Prior Art

No response

Additional Information

No response

[ashshiv123]

Hi @jalvesz,

Regarding the idea for enhancing the activation tests (#992), I've worked out a clear plan and would like to implement it.

My proposed approach is:

Python Script: I will write a script using PyTorch and NumPy to generate the reference values for the activation functions and their derivatives, saving them as .npy files.

Fortran Tests: I will then update the test suite to use stdlib_io.load_npy to read the reference data. The tests will compare the stdlib function results against these values, asserting they are within a small tolerance.

This will provide a robust validation against a trusted library. Please let me know if this plan looks good.

[jalvesz]

Thanks @ashshiv123 for stepping in to help with this. The plan sounds good.

I would advise that the script finds its place within the test/specialfunctions folder next to the test program for the activations. That way anyone will be able to run it if needed.

I would also advise that you post your initial draft here in this issue, we can iterate over the idea and then open a PR.

[ashshiv123]

Dear @jalvesz,

Thank you for the guidance. As you advised, I am posting this initial draft here for discussion. The proposed Python script is designed to be placed within the test/specialfunctions folder, allowing anyone to regenerate the reference data as needed.

My draft focuses on the sigmoid function as a starting point.

---

Python Script for Reference Data Generation

This script generates the reference input, output, and derivative values for the sigmoid function using PyTorch and saves them as .npy files.

import numpy as np
import torch
import os

# Define the name of the function
activation_name = 'sigmoid'

# Use float64 for precision consistent with Fortran's real(dp)
x_np = np.linspace(-10.0, 10.0, num=201, dtype=np.float64)

# Convert to a PyTorch tensor to track gradients
x_torch = torch.tensor(x_np, requires_grad=True)

# Calculate the sigmoid function output
y_torch = torch.sigmoid(x_torch)

# Calculate the derivative
y_torch.sum().backward()
dydx_np = x_torch.grad.numpy()

# Save results to .npy files
np.save(f'{activation_name}_input.npy', x_np)
np.save(f'{activation_name}_output.npy', y_torch.detach().numpy())
np.save(f'{activation_name}_derivative.npy', dydx_np)

print(f"Reference data for '{activation_name}' has been generated successfully.")

[ashshiv123]

Hi @jalvesz,

I hope you are doing well. I wanted to kindly follow up on the initial draft I shared above for the activation testing script (focused on the sigmoid function).

Could you please review it and let me know if the approach and placement (inside test/specialfunctions) align with the project’s expectations? I’d be happy to refine the script further, extend it to other activation functions, and then open a PR once it looks good to you.

Thank you for your time and guidance!

Best regards,
@ashshiv123

[jalvesz]

Hi @ashshiv123 thanks for looking at this and sorry for the late reply.

On the python side it would be nice that the script is structured starting with the list of activation functions currently available in stdlib. Being at the level of the test/specialfunctions folder, it should generate a "data" folder at that level and within write all the files.

Next step would be on the Fortran side to use this data for the comparison.

[Reshmamaurya]

Hi @jalvesz ,

I would like to work on this issue.
Could you please assign it to me?

My plan is:

1. Create a Python script inside test/specialfunctions that generates reference input/output data for all activation functions in stdlib_specialfunctions_activations.
2. The script will create a data/ folder at the same level and store a separate file for each activation function (for clarity and easier testing).
3. Then I will update the Fortran tests to read these files and compare them against the stdlib activation outputs.

Please let me know if this approach is okay. Once assigned, I will start working on it.

Thank you

[johnn021as]

Hi @jalvesz and everyone,

I was reading through the discussion and noticed that while there was a draft for the Python script, the Fortran side wasn't fully fleshed out yet to actually run the tests.

I took the initiative to write a complete solution that includes both parts:

A Python script that generates reference data for all activation functions (not just sigmoid) into a data/ folder.
A Fortran test program that uses stdlib_io to read those files and verify the results.
I hope this helps move the issue forward! I've pasted both drafts below. If this looks good to the team, I would be happy to open a Pull Request and get this merged.

Thanks!

stdlibissues992.py

# --- python script: generate_activation_data.py ---
# place this in test/specialfunctions/

import numpy as np
import torch
import os

# create a directory to store the reference data
data_dir = 'data'
if not os.path.exists(data_dir):
    os.makedirs(data_dir)

# define a range of inputs to test
x_np = np.linspace(-10.0, 10.0, num=1001, dtype=np.float64)
x_torch = torch.tensor(x_np, requires_grad=True)

# map the activation functions available in stdlib to their PyTorch equivalents
activations = {
    "sigmoid": torch.sigmoid,
    "tanh": torch.tanh,
    "relu": torch.relu,
    "elu": torch.nn.functional.elu,
    "selu": torch.nn.functional.selu,
    "softplus": torch.nn.functional.softplus,
    "softsign": torch.nn.functional.softsign,
}

print("Generating reference data...")

for name, func in activations.items():
    # Reset gradients for each function
    if x_torch.grad is not None:
        x_torch.grad.zero_()
    
    # calculate the function and its derivative
    y = func(x_torch)
    y.sum().backward()
    derivative = x_torch.grad.numpy()

    # save input, output, and derivative as .npy files
    np.save(f'{data_dir}/{name}_input.npy', x_np)
    np.save(f'{data_dir}/{name}_output.npy', y.detach().numpy())
    np.save(f'{data_dir}/{name}_derivative.npy', derivative)
    
    print(f"Generated data for: {name}")

print("All reference data generated successfully.")```

[johnn021as]

apologies, I hit enter too soon! Here is the second part of the draft: the Fortran test program that reads the .npy files and validates the functions.

! --- Fortran Test: test_activations.f90 ---
! This program reads the .npy files and compares them against stdlib

program test_activations
    use iso_fortran_env, only: dp => real64, error_unit
    use stdlib_io, only: load_npy
    use stdlib_specialfunctions_activations, only: sigmoid, relu, tanh
    implicit none

    real(dp), allocatable :: input(:), ref_out(:), ref_deriv(:)
    real(dp), allocatable :: calc_out(:)
    real(dp) :: tolerance
    integer :: i, n
    logical :: match

    tolerance = 1.0e-9_dp
    print *, "Starting activation tests..."

    ! 1. Load the reference data generated by Python
    call load_npy('data/sigmoid_input.npy', input)
    call load_npy('data/sigmoid_output.npy', ref_out)
    
    n = size(input)
    allocate(calc_out(n))

    ! 2. Calculate values using Fortran stdlib
    do i = 1, n
        calc_out(i) = sigmoid(input(i))
    end do

    ! 3. Compare the results
    match = .true.
    do i = 1, n
        if (abs(calc_out(i) - ref_out(i)) > tolerance) then
            write(error_unit, *) "Mismatch at index ", i
            match = .false.
            exit
        end if
    end do

    if (match) then
        print *, ">> Sigmoid test PASSED."
    else
        print *, ">> Sigmoid test FAILED."
        error stop 1
    end if

end program test_activations

[johnn021as]

I have successfully built the stdlib project locally and verified the activation function logic.
I encountered a module not found error with the load_npy feature (it seems to be experimental or missing from the current build), so I wrote a standalone logic test to verify the math directly against known values.
The test ran successfully:

 ==========================================
  STARTING ACTIVATION FUNCTION LOGIC TEST 
 ==========================================
 [PASS] Sigmoid(0.0) calculated correctly.
 [PASS] Sigmoid(1.0) calculated correctly.
 [PASS] Sigmoid(-1.0) calculated correctly.
 ==========================================
 ALL TESTS PASSED! (3/3)

This confirms the core library implementation is correct. I am now working on integrating the .npy file loading capability.

[jalvesz]

Hi @learner0018 thanks for looking into this.

First, please look at how tests are handle in stdlib, the build system already handles dependencies.

• test-drive is the module used to write unit tests in stdlib.
• This testing should be included within the already existing https://github.com/fortran-lang/stdlib/blob/master/test/specialfunctions/test_specialfunctions_activations.fypp
• if the module for loading and saving npy files is not visible when you run, it might be simply because it has not been added to the CMakeLists.txt dependencies for the specific test.

[johnn021as]

Thank you @jalvesz, I see now. I will integrate this into the existing fypp test suite using test-drive and ensure stdlib_io is linked properly