src.environment.problem.SOO.COCO_BBOB.kan.Symbolic_KANLayer

Module Contents

Classes

Symbolic_KANLayer

KANLayer class

API

class src.environment.problem.SOO.COCO_BBOB.kan.Symbolic_KANLayer.Symbolic_KANLayer(in_dim=3, out_dim=2, device='cpu')

Bases: torch.nn.Module

KANLayer class

Attributes:

in_dim : int
    input dimension
out_dim : int
    output dimension
funs : 2D array of torch functions (or lambda functions)
    symbolic functions (torch)
funs_avoid_singularity : 2D array of torch functions (or lambda functions) with singularity avoiding
funs_name : 2D arry of str
    names of symbolic functions
funs_sympy : 2D array of sympy functions (or lambda functions)
    symbolic functions (sympy)
affine : 3D array of floats
    affine transformations of inputs and outputs

Initialization

initialize a Symbolic_KANLayer (activation functions are initialized to be identity functions)

Args:

in_dim : int
    input dimension
out_dim : int
    output dimension
device : str
    device

Returns:

self

Example

sb = Symbolic_KANLayer(in_dim=3, out_dim=3) len(sb.funs), len(sb.funs[0])

to(device)

move to device

forward(x, singularity_avoiding=False, y_th=10.0)

forward

Args:

x : 2D array
    inputs, shape (batch, input dimension)
singularity_avoiding : bool
    if True, funs_avoid_singularity is used; if False, funs is used. 
y_th : float
    the singularity threshold

Returns:

y : 2D array
    outputs, shape (batch, output dimension)
postacts : 3D array
    activations after activation functions but before being summed on nodes

Example

sb = Symbolic_KANLayer(in_dim=3, out_dim=5) x = torch.normal(0,1,size=(100,3)) y, postacts = sb(x) y.shape, postacts.shape (torch.Size([100, 5]), torch.Size([100, 5, 3]))

get_subset(in_id, out_id)

get a smaller Symbolic_KANLayer from a larger Symbolic_KANLayer (used for pruning)

Args:

in_id : list
    id of selected input neurons
out_id : list
    id of selected output neurons

Returns:

spb : Symbolic_KANLayer

Example

sb_large = Symbolic_KANLayer(in_dim=10, out_dim=10) sb_small = sb_large.get_subset([0,9],[1,2,3]) sb_small.in_dim, sb_small.out_dim

fix_symbolic(i, j, fun_name, x=None, y=None, random=False, a_range=(-10, 10), b_range=(-10, 10), verbose=True)

fix an activation function to be symbolic

Args:

i : int
    the id of input neuron
j : int 
    the id of output neuron
fun_name : str
    the name of the symbolic functions
x : 1D array
    preactivations
y : 1D array
    postactivations
a_range : tuple
    sweeping range of a
b_range : tuple
    sweeping range of a
verbose : bool
    print more information if True

Returns:

r2 (coefficient of determination)

Example 1

when x & y are not provided. Affine parameters are set to a = 1, b = 0, c = 1, d = 0

sb = Symbolic_KANLayer(in_dim=3, out_dim=2) sb.fix_symbolic(2,1,’sin’) print(sb.funs_name) print(sb.affine)

Example 2

when x & y are provided, fit_params() is called to find the best fit coefficients

sb = Symbolic_KANLayer(in_dim=3, out_dim=2) batch = 100 x = torch.linspace(-1,1,steps=batch) noises = torch.normal(0,1,(batch,)) * 0.02 y = 5.0torch.sin(3.0x + 2.0) + 0.7 + noises sb.fix_symbolic(2,1,’sin’,x,y) print(sb.funs_name) print(sb.affine[1,2,:].data)

swap(i1, i2, mode='in')

swap the i1 neuron with the i2 neuron in input (if mode == ‘in’) or output (if mode == ‘out’)