`src.environment.problem.SOO.CEC2013LSGO.cec2013lsgo_torch`¶

Module Contents¶

Classes¶

`CEC2013LSGO_Torch_Problem`	CEC2013LSGO_Torch_Problem¶ A PyTorch-based implementation of the CEC2013 Large-Scale Global Optimization (LSGO) benchmark problem set. This class provides methods for loading problem-specific data, performing vector transformations, and evaluating standard benchmark functions.
`F1_Torch`
`F2_Torch`
`F3_Torch`
`F4_Torch`
`F5_Torch`
`F6_Torch`
`F7_Torch`
`F8_Torch`
`F9_Torch`
`F10_Torch`
`F11_Torch`
`F12_Torch`
`F13_Torch`
`F14_Torch`
`F15_Torch`

API¶

class src.environment.problem.SOO.CEC2013LSGO.cec2013lsgo_torch.CEC2013LSGO_Torch_Problem[source]¶

Bases: src.environment.problem.basic_problem.Basic_Problem_Torch

CEC2013LSGO_Torch_Problem¶

A PyTorch-based implementation of the CEC2013 Large-Scale Global Optimization (LSGO) benchmark problem set.
This class provides methods for loading problem-specific data, performing vector transformations, and evaluating standard benchmark functions.

Introduction¶

CEC2013LSGO proposes 15 large-scale benchmark problems to represent a wider range of realworld large-scale optimization problems.

Original paper¶

“Benchmark functions for the CEC 2013 special session and competition on large-scale global optimization.” gene 7.33 (2013): 8.

Official Implementation¶

CEC2013LSGO

License¶

GPL-3.0

Problem Suite Composition¶

CEC2013LSGO contains four major categories of large-scale problems:

Fully-separable functions (F1-F3)
Two types of partially separable functions:
1. Partially separable functions with a set of non-separable subcomponents and one fully-separable subcomponents (F4-F7)
2. Partially separable functions with only a set of non-separable subcomponents and no fullyseparable subcomponent (F8-F11)
Two types of overlapping functions:
1. Overlapping functions with conforming subcomponents (F12-F13)
2. Overlapping functions with conflicting subcomponents (F14)
Fully-nonseparable functions (F15)

Attributes:¶

data_dir (str): Directory containing problem data files.
min_dim (int): Minimum subspace dimension.
med_dim (int): Medium subspace dimension.
max_dim (int): Maximum subspace dimension.
dim (int): Problem dimension (default: 1000).
ID (int or None): Problem identifier.
s_size (int): Number of subspaces.
overlap (int or None): Overlap size between subspaces.
lb (float or None): Lower bound of the search space.
ub (float or None): Upper bound of the search space.
Ovector (torch.Tensor or None): Optimum vector.
OvectorVec (list or None): List of optimum vectors for subspaces.
Pvector (torch.Tensor or None): Permutation vector.
r_min_dim, r_med_dim, r_max_dim (int or None): Rotation matrix dimensions.
anotherz (torch.Tensor): Auxiliary tensor for transformations.
anotherz1 (torch.Tensor or None): Auxiliary tensor for transformations.
numevals (int): Number of function evaluations.
opt (float or None): Optimal value.
optimum (float): Known optimum value.

Methods:¶

get_optimal(): Returns the optimal value.
func(x): Abstract method for evaluating the objective function (must be implemented in subclasses).
readOvector(): Loads the optimum vector from file.
readOvectorVec(): Loads and splits the optimum vector into subspace vectors.
readPermVector(): Loads the permutation vector from file.
readR(sub_dim): Loads the rotation matrix for a given subspace dimension.
readS(num): Loads the subspace dimensions from file.
readW(num): Loads the weights for subspaces from file.
multiply(vector, matrix): Multiplies a vector by a matrix.
rotateVector(i, c): Rotates a subspace vector using the appropriate rotation matrix.
rotateVectorConform(i, c): Rotates a subspace vector with overlap consideration.
rotateVectorConflict(i, c, x): Rotates a subspace vector with conflict consideration.
sphere(x): Sphere benchmark function.
elliptic(x): Elliptic benchmark function.
rastrigin(x): Rastrigin benchmark function.
ackley(x): Ackley benchmark function.
schwefel(x): Schwefel benchmark function.
rosenbrock(x): Rosenbrock benchmark function.
transform_osz(z): Applies the OSZ transformation to a vector.
transform_asy(z, beta=0.2): Applies the asymmetric transformation to a vector.
Lambda(z, alpha=10): Applies the Lambda transformation to a vector.