Paper deep dive
Towards Efficient Evaluation of Evolutionary Transfer Optimization: Case Studies on Task-Parameterized Applications
Yanchen Li, Xiaoming Xue, Kay Chen Tan
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 9/8/2026, 1:36:18 AM
Summary
This paper addresses the scalability issues in Evolutionary Transfer Optimization (ETO) by reformulating serial problem evaluations into parallelizable matrix operations. It presents two case studies: 1) Multi-task optimization (MTO) for kinematic arms, using an accumulation-matrix representation to achieve a 256.72x speedup, and 2) Sequential transfer optimization (STO) for B-spline trajectories, using a blending-matrix representation to achieve a 93.91x speedup. Both methods maintain numerical accuracy while significantly reducing runtime.
Entities (8)
Relation Signals (6)
Accumulation-Matrix → achievesspeedup → 256.72x
confidence 98% · yielding 256.72x and 93.91x end-to-end speedups, respectively.
Blending-Matrix → achievesspeedup → 93.91x
confidence 98% · yielding 256.72x and 93.91x end-to-end speedups, respectively.
Accumulation-Matrix → usedin → Kinematic-Arm Optimization
confidence 95% · In multi-task optimization, matrix-recursive kinematic-arm evaluation is reformulated using an accumulation-matrix representation
Blending-Matrix → usedin → B-Spline Trajectory Optimization
confidence 95% · In sequential transfer optimization, pointwise B-spline trajectory evaluation is reformulated using a blending-matrix representation
Kinematic-Arm Optimization → istypeof → Multi-Task Optimization
confidence 90% · For cross-task evaluation scaling, we study kinematic-arm MTO
B-Spline Trajectory Optimization → istypeof → Sequential Transfer Optimization
confidence 90% · For within-task evaluation scaling, we study B-spline trajectory STO
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:As evolutionary transfer optimization (ETO) scales to larger collections of related tasks, problem evaluation can become a major source of runtime growth. This work studies problem-side evaluation scaling in task-parameterized applications and reformulates application-specific serial computations into forms suitable for parallel execution. We organize evaluation scaling into two levels: the number of evaluated tasks and the workload within each task. In multi-task optimization, matrix-recursive kinematic-arm evaluation is reformulated using an accumulation-matrix representation of cumulative link directions. In sequential transfer optimization, pointwise B-spline trajectory evaluation is reformulated using a blending-matrix representation for trajectory and collision computations. Both reformulations maintain close numerical agreement with their reference evaluations and substantially reduce runtime, yielding $256.72\times$ and $93.91\times$ end-to-end speedups, respectively. These results demonstrate problem-side reformulation as a practical route toward scalable ETO. Both application implementations and experimental scripts are released as open source to support reproducibility and reuse.
Tags
Links
- Source: https://arxiv.org/abs/2609.05040v1
- Canonical: https://arxiv.org/abs/2609.05040v1
Trouble viewing inline? Open PDF directly →
Full Text
37,754 characters extracted from source content.
Expand or collapse full text
Towards Efficient Evaluation of Evolutionary Transfer Optimization: Case Studies on Task-Parameterized Applications Yanchen Li1 , Xiaoming Xue2 , and Kay Chen Tan1 Affiliation: 1Department of Data Science and Artificial Intelligence, The Hong Kong Polytechnic University, Hong Kong SAR, China Affiliation: 2School of Petroleum Engineering, China University of Petroleum (East China), Qingdao, China Affiliation: Emails: yanchen.li@connect.polyu.hk, xuexm@upc.edu.cn, kctan@polyu.edu.hk (corresponding author: Kay Chen Tan) Abstract As evolutionary transfer optimization (ETO) scales to larger collections of related tasks, problem evaluation can become a major source of runtime growth. This work studies problem-side evaluation scaling in task-parameterized applications and reformulates application-specific serial computations into forms suitable for parallel execution. We organize evaluation scaling into two levels: the number of evaluated tasks and the workload within each task. In multi-task optimization, matrix-recursive kinematic-arm evaluation is reformulated using an accumulation-matrix representation of cumulative link directions. In sequential transfer optimization, pointwise B-spline trajectory evaluation is reformulated using a blending-matrix representation for trajectory and collision computations. Both reformulations maintain close numerical agreement with their reference evaluations and substantially reduce runtime, yielding 256.72×256.72× and 93.91×93.91× end-to-end speedups, respectively. These results demonstrate problem-side reformulation as a practical route toward scalable ETO. Both application implementations and experimental scripts are released as open source to support reproducibility and reuse. Index Terms: evolutionary computation, evolutionary transfer optimization, multi-task optimization, sequential transfer optimization, parallel computing. I Introduction Evolutionary computation has established a versatile population-based foundation for solving optimization problems across a wide range of scientific and engineering domains [1, 2]. As optimization research expanded from single-task search to settings involving multiple related tasks, the transfer of knowledge across tasks became a natural extension of evolutionary search. Cross-task evolutionary research has since been explored through representative paradigms such as multi-task optimization (MTO) and sequential transfer optimization (STO), with notable studies spanning both settings [3, 4, 5]. With continued advances in cross-task optimization, evolutionary transfer optimization (ETO) has emerged as a broader and increasingly systematic framework for studying knowledge transfer across optimization tasks [6, 7, 8]. As ETO has progressed toward many-task and large-scale settings, scalability with respect to the number of tasks has received increasing attention [9, 10, 11, 12]. At such scales, runtime growth can arise not only from optimization operations, but also from the repeated evaluation of application problems across populations and tasks. Meanwhile, application-oriented ETO increasingly involves task-parameterized problems, where related tasks share the same evaluation procedure while differing in task-specific parameters [13]. In these settings, increasing the number of tasks or the internal workload of each evaluation can make application evaluation itself a substantial source of runtime growth. This motivates a practical question: Can the internal structure of some task-parameterized evaluations be reformulated so that increasing workload does not translate directly into increasing wall-clock time on parallel hardware? To characterize this scaling, we consider task-parameterized applications through the shared evaluation form illustrated in Fig. 1. For task k, the parameters k θ_k deterministically define the task, while η denotes application-dependent evaluation-workload parameters, e.g., evaluation resolution or internal sample count used within one evaluation. The cost of evaluating a candidate solution is then repeatedly incurred over a population of size N and, when multiple tasks are evaluated, across the task count K. This characterization helps us separate two scaling regimes. Cross-task evaluation scaling arises as the number of tasks K increases, whereas within-task evaluation scaling arises when the evaluation workload increases at a fixed task count. In both cases, application-level computation can become increasingly expensive when repeatedly applied throughout population-based optimization. fk():=ℰ(,k⏟task-definingparameters,⏟evaluation-workloadparameters),Teval∝K⏟number oftasks×N⏟individualsper task×(k,)⏟per-individualevaluation cost. aligned f_k(x)&:=E (x; θ_k_ subarrayctask-defining\\ parameters subarray, η_ subarraycevaluation-workload\\ parameters subarray ),\\[3.55658pt] T_eval& K_ subarraycnumber of\\ tasks subarray× N_ subarraycindividuals\\ per task subarray× 4.25006pt C\! ( θ_k, η )_ subarraycper-individual\\ evaluation cost subarray. aligned Fig. 1: Conceptual formulation of evaluation scaling in task-parameterized applications. For task k, x denotes a candidate solution and fk()f_k(x) is evaluated through the shared evaluator structure ℰE, instantiated by the parameters k θ_k and η. The total evaluation time TevalT_eval is further amplified by the number of evaluated tasks K and the number of individuals per task N, while (k,)C( θ_k, η) denotes the cost of evaluating one individual on task k. Fig. 2: Illustration and comparison of kinematic-arm evaluation for a single task with three joints. The joint angles α1 _1, α2 _2, and α3 _3 are the decision variables, giving a decision dimension of D=3D=3; the three links have equal length L/DL/D, where L is the total arm length. The target position is marked by the star, and the fitness is determined by the distance between the target and the end point of the final link. (a) Matrix-recursive evaluation, which computes the arm configuration joint by joint: at step i, the current orientation is rotated by αi _i and then extended by one link of length L/DL/D. (b) Accumulation-matrix reformulation, which obtains the link directions from the cumulative joint angles and their horizontal and vertical link projections, eliminating the joint-wise recursive traversal regardless of the number of joints. These two scaling regimes suggest a practical guideline for identifying suitable applications: evaluation cost increases under either cross-task or within-task scaling, and the evaluation procedure contains repeated serial calculations that can be reformulated into a mathematically equivalent form suitable for parallel execution. Following this guideline, this paper considers two representative task-parameterized ETO cases: • For cross-task evaluation scaling, we study kinematic-arm MTO, where the same type of evaluation is repeatedly performed across a large number of parameterized tasks. We derive an equivalent accumulation-matrix reformulation that reduces the serial work within each evaluation and consequently limits the runtime growth as the task count increases. • For within-task evaluation scaling, we study B-spline trajectory STO, where online optimization focuses on a target task while increasing the number of trajectory samples raises the workload within each evaluation. We derive an equivalent blending-matrix reformulation that reduces the sample-wise serial workload. In both cases, we verify close numerical agreement between the reformulations and their corresponding reference evaluation forms and evaluate the runtime reduction achieved through parallel execution as the relevant evaluation scale increases. I Case Study I: Cross-Task Evaluation Scaling in Kinematic-Arm Optimization In multi-task optimization (MTO), multiple optimization tasks are solved simultaneously, making the number of tasks K a natural source of evaluation scaling in ETO. We study this cross-task scaling through kinematic-arm optimization, where the evaluation of candidate joint configurations is repeatedly performed across different tasks and can become increasingly costly as K grows. We first formulate the kinematic-arm problem and its matrix-recursive evaluation, then derive an accumulation-matrix reformulation that enables parallel evaluation across tasks, and finally validate the reformulation through evaluation and end-to-end MTO experiments. I-A Problem Formulation and Matrix-Recursive Evaluation Inspired by the parametrized planar-arm setting in [14], we consider a kinematic-arm optimization problem in which the joint angles are optimized to bring the end point of the final link as close as possible to a fixed target =[1,1]t=[1,1] T. Each task k is distinguished by the task parameters k=[Lk,αmax,k] θ_k=[L_k, _max,k] T, where LkL_k specifies the total arm length and αmax,k _max,k controls the joint-angle range. The arm contains D rotational joints and D equal-length links, while a candidate ∈[0,1]Dx∈[0,1]^D encodes the joint angles. For task k, its i-th joint angle is αi:=2παmax,kD⋅(xi−12). _i:= 2π _max,kD\!·\! (x_i- 12 ). (1) Each link consequently has length Lk/DL_k/D. Therefore, all tasks share the same evaluation procedure and differ only through the task parameters k θ_k. As illustrated in Fig. 2(a), the matrix-recursive evaluation constructs the arm joint by joint. For i=1,…,Di=1,…,D, step i first rotates the current orientation by αi _i and then extends the arm by one link of length Lk/DL_k/D. Using planar homogeneous coordinates, this recursion is written as 0:=3,i:=i−1⋅[cos(αi)−sin(αi)LkDcos(αi)sin(αi)cos(αi)LkDsin(αi)001],[i1]:=i⋅[01]. \ aligned M_0&:=I_3,\\ M_i&:=M_i-1·\! bmatrix ( _i)&- ( _i)& L_kD ( _i)\\[2.15277pt] ( _i)& - ( _i)& L_kD ( _i)\\[2.15277pt] 0&0&1 bmatrix,\\ bmatrixr_i\\ 1 bmatrix&:=M_i· bmatrix0&\!\!0\!\!&1 bmatrix T. aligned . (2) Here, 3I_3 denotes the 3×33× 3 identity matrix, and i∈ℝ2r_i ^2 is the end point after the i-th link is added. Consistent with the maximization formulation adopted in previous kinematic-arm work [14], the fitness of task k is defined as fk():=−‖D−‖2.f_k(x):=- \|r_D-t \|_2. (3) Since each iM_i depends on i−1M_i-1, the evaluation follows a sequential path over the D joints. This joint-wise recursion is repeated for every individual in a population, so its evaluation cost is first amplified by the population size N and further amplified in MTO as the number of tasks K increases. Fig. 3: Evaluation and end-to-end runtime results for the kinematic-arm optimization case study. All runtime values are reported as the mean over three repeated measurements, with error bars indicating the standard deviation. (a) Evaluation runtime for one individual under increasing arm joint counts D, comparing the matrix-recursive evaluation with its accumulation-matrix reformulation. (b) Evaluation runtime under increasing task counts K, where K denotes the number of evaluated tasks, comparing the same two forms at a fixed joint count. (c) One-generation end-to-end runtime of MA-MTO under increasing K; the annotated multiplier denotes the runtime speedup obtained by the accumulation-matrix reformulation over the matrix-recursive evaluation at the largest tested task count. I-B Accumulation-Matrix Reformulation The matrix-recursive evaluation requires each transformation iM_i to depend on i−1M_i-1. However, the absolute orientation of the i-th link is simply the cumulative angle α1+⋯+αi _1+·s+ _i. Therefore, the recursive transformation chain can be removed by computing all cumulative link directions jointly, as illustrated in Fig. 2(b). Let =[α1,…,αD] α=[ _1,…, _D] T collect the relative joint angles and ϕ=[ϕ1,…,ϕD] φ=[ _1,…, _D] T collect the resulting link directions. Their relation can be expressed by the fixed prefix-sum matrix [ϕ1ϕ2ϕD]⏟ϕ:=[10⋯011⋱011⋯1]⋅[α1α2αD]⏟. bmatrix _1\\ _2\\ \\ _D bmatrix_ φ:= bmatrix1&0&·s&0\\[-4.30554pt] 1&1& & \\[-4.30554pt] & & &0\\ 1&1&·s&1 bmatrix\!·\! bmatrix _1\\ _2\\ \\ _D bmatrix_ α. (4) This replaces the joint-wise transformation recursion in Eq. (2) with a bulk cumulative-sum operation. Once the cumulative directions are obtained, each link contributes directly through its horizontal and vertical projections. The final end point is therefore computed as D:=LkD⋅[∑i=1Dcos(ϕi)∑i=1Dsin(ϕi)].r_D:= L_kD\!·\! bmatrix _i=1^D ( _i)& _i=1^D ( _i) bmatrix T. (5) This expression directly produces the same final position used in Eq. (3), without constructing the intermediate transformation matrices 1,…,DM_1,…,M_D. The cumulative directions, trigonometric projections, and reductions can consequently be performed as joint operations that are well suited to modern parallel processors. For population-based MTO, additional candidate and task axes can be introduced directly to the same operations, allowing the N candidates across K tasks to be evaluated jointly without restoring the joint-wise recursion. I-C Experimental Validation We construct a reproducible task-parameterized kinematic-arm testbed, where task parameters [Lk,αmax,k][L_k, _max,k] T are generated using a scrambled Sobol sequence [15, 16]. All experiments are conducted on a single NVIDIA GeForce RTX 3090 GPU with an Intel(R) Xeon(R) Platinum 8350C CPU @ 2.60 GHz. We first verify the numerical agreement between the accumulation-matrix reformulation and the matrix-recursive evaluation using identical candidate solutions. Across 10 random seeds with K=5000K=5000, N=16N=16, and D=60D=60, the two evaluation forms achieved a mean absolute fitness discrepancy of 2.561×10−8±1.600×10−102.561× 10^-8± 1.600× 10^-10, where each seed-level value equally averages the task-wise discrepancies over all 5000 tasks. The maximum absolute discrepancy over all seeds, tasks, and individuals was 3.576×10−73.576× 10^-7. We then isolate the two primary scaling factors in Fig. 3(a) and Fig. 3(b). Fig. 3(a) evaluates one individual on one task while increasing the number of joints D. The runtime of the matrix-recursive evaluation grows markedly with D, whereas the accumulation-matrix reformulation remains low and nearly constant over the tested range. Fig. 3(b) fixes N=16N=16 and D=60D=60 while increasing the number of evaluated tasks K. A similar trend is observed across tasks: the matrix-recursive evaluation scales rapidly with K, while the accumulation-matrix reformulation shows little runtime growth over the tested task counts, demonstrating the benefit of exposing the evaluation to parallel execution. For the end-to-end validation, we use mean alignment multi-task optimization (MA-MTO), which adopts a mean-aligned elite-injection strategy inspired by previous transfer work [17] and is implemented with EvoX [18] for population-level parallel computation while retaining task-wise execution. Each task evolves through GA-based evolution, while transferred elites are aligned to the mean of the receiving population before injection. As shown in Fig. 3(c), the runtime advantage of the accumulation-matrix reformulation is retained within the complete optimization process, reaching a 256.72×256.72× speedup at K=5000K=5000. Across 10 independent runs with K=5000K=5000, N=16N=16, D=60D=60, and a 100-generation budget, MA-MTO achieved a median final fitness of −0.985±3.368×10−4-0.985± 3.368× 10^-4 and a 95th-percentile final fitness of −0.541±3.948×10−4-0.541± 3.948× 10^-4. For each run, the median and 95th percentile are computed across the 5000 tasks, while the reported mean and standard deviation summarize the 10 independent runs. I Case Study I: Within-Task Evaluation Scaling in B-Spline Trajectory Optimization In sequential transfer optimization (STO), optimization of a target task reuses knowledge accumulated from previously solved source tasks, while online evaluation primarily focuses on the current target task. Nevertheless, a single target task can still incur substantial evaluation cost when the application requires an increasingly high evaluation resolution. We study this setting through trajectory optimization parameterized by a B-spline, i.e., a smooth trajectory curve whose shape is controlled by a compact set of control points and whose evaluation resolution can be increased independently of the decision dimension. We first formulate the trajectory problem and its direct pointwise evaluation, then derive a blending-matrix reformulation that enables parallel computation, and finally validate the reformulation through standalone evaluation and end-to-end STO experiments. I-A Problem Formulation and Pointwise Evaluation We consider a continuous-variable trajectory optimization problem in a normalized two-dimensional workspace. For task k, the start and goal positions are fixed at (0,0)(0,0) and (1,1)(1,1), respectively, while the task is distinguished by M axis-aligned square obstacles k,mm=1M\O_k,m\_m=1^M. The objective is to generate a short trajectory from the start to the goal without intersecting these obstacles. A candidate solution =[y1,…,yD]∈[0,1]Dy=[y_1,…,y_D] T∈[0,1]^D determines the vertical coordinates of D internal control points, while their horizontal coordinates are uniformly fixed. Together with the two endpoints, the C=D+2C=D+2 control points are i:=[0,0],i=0,[i/(D+1),yi],1≤i≤D,[1,1],i=D+1.p_i:= cases[0,0] T,&i=0,\\[2.84526pt] [i/(D+1),\,y_i ] T,&1≤ i≤ D,\\[2.84526pt] [1,1] T,&i=D+1. cases (6) A B-spline forms a smooth trajectory by assigning position-dependent coefficients to neighboring control points and combining them according to these coefficients. We use a cubic B-spline with degree δ=3δ=3. For a normalized curve parameter ranging from 00 at the start to 11 at the goal, the coefficient bi,δ(⋅)b_i,δ(·) specifies the contribution of control point ip_i and is computed using the Cox–de Boor recursion [19, 20]. The recursion uses a fixed sequence over [0,1][0,1]: the two boundary values 00 and 11 are each repeated δ+1δ+1 times, while the intermediate values are uniformly placed at j/(C−δ)j/(C-δ) for j=1,…,C−δ−1j=1,…,C-δ-1. This configuration makes the resulting curve pass through the prescribed start and goal points. Using R equally spaced sampling positions along the trajectory, the pointwise evaluation moves a local window along the control points and forms each trajectory sample as r:=∑i=⌊r(C−δ)R−1⌋⌊r(C−δ)R−1⌋+δbi,δ(rR−1)⋅i,0≤r≤R−2,C−1,r=R−1.q_r:= cases _i= \! r(C-δ)R-1\! \! r(C-δ)R-1\! +δ\!b_i,δ\! ( rR-1 )·p_i,&0≤ r≤ R-2,\\[8.53581pt] p_C-1,&r=R-1. cases (7) Here, R instantiates the evaluation-workload parameter η introduced in Fig. 1: increasing R evaluates the same candidate using more trajectory samples without changing the decision dimension D. As r increases, the summation bounds move the local window along the control points. Each sampling position therefore combines only δ+1=4δ+1=4 neighboring control points in the cubic case. The pointwise evaluation performs these local combinations sequentially over the R trajectory samples. Since the objective is to obtain a short trajectory while avoiding obstacles, its fitness combines the sampled path length with collision penalties. We regard k,mO_k,m as the closed square region occupied by the m-th obstacle of task k. Accordingly, the fitness is defined by fk():= f_k(y):= ∑r=0R−2‖r+1−r‖2 _r=0^R-2 \|q_r+1-q_r \|_2 (8) +ρ⋅∑m=1M[∃r:rr+1¯∩k,m≠∅]. +ρ· _m=1^M 1\! [∃\,r: q_rq_r+1 _k,m≠ ]. Here, ρ denotes the penalty assigned to each collided obstacle, and [⋅] 1[·] denotes the indicator function. The line segment rr+1¯ q_rq_r+1 connects two consecutive trajectory samples. An obstacle contributes the penalty once if any trajectory segment intersects its square region, and boundary contact is also treated as an intersection. The pointwise evaluation follows this construction directly. For each candidate, the R trajectory samples are formed sequentially, and each newly formed segment is tested jointly against all M obstacles. Although the local control-point combination and the obstacle checks at each sampling position are already performed jointly, traversal over the R trajectory samples remains sequential. Consequently, increasing R enlarges the serial within-task evaluation workload and can lead to substantially higher evaluation time. I-B Blending-Matrix Reformulation The pointwise evaluation retains a sequential traversal over the R trajectory samples because each sampling position operates on a different local window of control points. To remove this traversal, we first align the local coefficients of all sampling positions to a common control-point axis. Specifically, the coefficient matrix ∈ℝR×CB\!∈\!R^R× C is defined element-wise as r,i:=bi,δ(rR−1),⌊r(C−δ)R−1⌋≤i≤⌊r(C−δ)R−1⌋+δ0≤r≤R−2,1,i=C−1,r=R−1,0,otherwise.B_r,i:= cases b_i,δ\! ( rR-1 ),& aligned \! r(C-δ)R-1\! &≤ i≤ \! r(C-δ)R-1\! \!\!+\!δ\\[-1.42262pt] 0&≤ r≤ R-2, aligned\\[14.22636pt] 1,&i=C-1,\;r=R-1,\\[2.84526pt] 0,&otherwise. cases (9) Each of the first R−1R-1 rows therefore places the δ+1δ+1 coefficients of one local control-point window into their corresponding columns, with all remaining entries set to zero. The final row selects the prescribed goal point. In this way, the moving local windows of the pointwise evaluation are represented within a common matrix structure. Fig. 4: Evaluation and end-to-end results for the B-spline trajectory optimization case study. Runtime values in (a) and (b) are reported as the mean over three repeated measurements, with error bars indicating the standard deviation. (a) Evaluation runtime under increasing numbers of trajectory sample points R, where R denotes the number of points used to discretize each B-spline trajectory for evaluation, comparing the pointwise evaluation with its blending-matrix reformulation. (b) One-generation end-to-end runtime of MS-STO under increasing R; the annotated multiplier denotes the runtime speedup obtained by the blending-matrix reformulation over the pointwise evaluation at the largest tested R. (c) Best feasible trajectory obtained over ten independent MS-STO runs under the fixed 100-generation budget, where x and y denote the normalized horizontal and vertical spatial coordinates, respectively. Stacking the control points and trajectory samples by rows then allows the complete trajectory to be obtained through a single matrix multiplication, schematically written as [0R−2R−1]⏟:=[b0,δ⋯bδ,δ0⋱0⋯bC−δ−1,δ⋯bC−1,δ001]⏟⋅[0C−1]⏟. bmatrixq_0 T\\[4.30554pt] \\[2.15277pt] q_R-2 T\\[4.30554pt] q_R-1 T bmatrix_Q\!:=\! bmatrixb_0,δ&\!\!·s\!\!&b_δ,δ&\!\!0\!\!&0\\[0.0pt] 0&\!\! \!\!& &\!\! \!\!&0\\[4.30554pt] 0&\!\!·s\!\!&b_C-δ-1,δ&\!\!·s\!\!&b_C-1,δ\\[4.30554pt] 0&\!\!0\!\!&0&\!\!0\!\!&1 bmatrix_B\!·\! bmatrixp_0 T\\[4.30554pt] \\[4.30554pt] p_C-1 T bmatrix_P. (10) For readability, the sampling-position arguments are omitted from the schematic coefficients; their exact values and positions are given by Eq. (9). Each of the first R−1R-1 rows contains only δ+1δ+1 consecutive nonzero coefficients, while 0 denotes an all-zero block. Compared with processing the local windows sample by sample, this form replaces the sequential traversal over the R sampling positions with a unified matrix computation that is well suited to modern parallel processors. The path-length term in Eq. (8) can also be computed from the complete trajectory matrix Q without a pointwise traversal. All consecutive-point differences are formed jointly through [(1−0)(2−1)(R−1−R−2)]=[−110⋯00−11⋱⋮⋱00⋯0−11]⋅. bmatrix(q_1-q_0) T\\[1.07639pt] (q_2-q_1) T\\[1.07639pt] \\[1.07639pt] (q_R-1-q_R-2) T bmatrix\!=\! bmatrix-1& -1&0&·s&0\\[-2.15277pt] -0&-1&1& & \\[-3.22916pt] - & & & &0\\[0.0pt] -0&·s&0&-1&1 bmatrix\!·Q. (11) The Euclidean norms of the resulting rows are then computed jointly and summed to obtain the complete path length. For collision evaluation, the pointwise form already evaluates the current trajectory segment against all M obstacles jointly. Its sequential execution therefore arises from traversing the R−1R-1 trajectory segments. We remove this traversal by organizing all segment–obstacle relations into k:=[[r,:r+1,:¯∩k,m≠∅]]0≤r≤R−2, 1≤m≤M∈0,1(R−1)×M.H_k:= 0≤ r≤ R-2,\;1≤ m≤ M [ 1\! [ Q_r,:Q_r+1,: _k,m≠ ] ]\!∈\!\0,1\^(R-1)× M. (12) This form evaluates the segment–obstacle relations for all R−1R-1 trajectory segments jointly while preserving the existing joint computation over the M obstacles. A column-wise logical reduction then determines whether each obstacle is intersected by any trajectory segment, yielding the collision term in Eq. (8). Although the reformulation above is described for one candidate on one task, its matrix structure extends naturally to population-based evaluation. Multiple candidates can be handled jointly by introducing an additional candidate axis to the same matrix operations. These extensions are natural for modern parallel processors and do not change the underlying evaluation formulation. Consequently, reducing the sequential workload of a single evaluation is particularly important because this cost is repeatedly amplified by the population size and, where applicable, by the number of evaluated tasks. I-C Experimental Validation Inspired by the B-spline trajectory optimization settings in prior evolutionary transfer optimization studies [21, 17], we construct a reproducible task-parameterized trajectory optimization testbed with explicitly specified spline, obstacle, and evaluation configurations. Each task uses D=60D=60 decision variables and M=20M=20 square obstacles of side length 0.050.05, with the collision penalty set to ρ=20ρ=20. To examine within-task evaluation scaling independently of the decision dimension, we vary the number of trajectory sample points as R∈60,200,600,2000,6000R∈\60,200,600,2000,6000\ while keeping D fixed. For reproducibility and to avoid trivial or infeasible layouts, obstacle centers are generated using a scrambled Sobol sequence [15, 16] and retained only when the obstacles stay away from the start and goal, remain separated from one another, block the straight start–goal path, and still leave at least one collision-free route verified by a simple grid search. All experiments are conducted on a single NVIDIA GeForce RTX 3090 GPU with an Intel(R) Xeon(R) Platinum 8350C CPU @ 2.60 GHz. We first verify the numerical agreement between the matrix reformulation and the pointwise evaluation using identical candidate solutions. Across 10 random seeds with K=1K=1 task, population size N=16N=16, D=60D=60, and R=6000R=6000, the pointwise evaluation and its matrix reformulation achieved a mean absolute fitness discrepancy of 1.101×10−5±3.011×10−61.101× 10^-5± 3.011× 10^-6, where each seed-level value averages the 16 paired individual discrepancies. The maximum absolute discrepancy over all seeds and individuals was 3.052×10−53.052× 10^-5. We then isolate the effect of R through single-individual evaluation on a single task, as shown in Fig. 4(a). The runtime of the pointwise evaluation increases markedly with R, whereas the matrix reformulation remains low and nearly constant over the tested range. This behavior reflects the parallel execution exposed along the sampling-point dimension: while sufficient parallel processing capacity is available, increasing R need not translate into a comparable increase in wall-clock time. For the end-to-end validation, we adopt mean similarity sequential transfer optimization (MS-STO) [5], which reuses source solutions according to their mean-based similarity to the target population and is implemented with EvoX [18] for population-level parallel computation. GA-based evolution is used for both offline source-knowledge construction and online target optimization. The experiment uses a target population size of N=16N=16 and a knowledge database constructed from K=5000K=5000 previously solved source tasks; the offline source construction is excluded from the reported online runtime. As shown in Fig. 4(b), the pointwise end-to-end runtime grows rapidly with R, while the matrix reformulation remains nearly unchanged, yielding a 93.91×93.91× speedup at R=6000R=6000. Across 10 independent runs with D=60D=60, R=6000R=6000, and a 100-generation budget, MS-STO obtained collision-free trajectories in 4/104/10 runs. Among the feasible runs, the final trajectory length was 3.365±0.5873.365± 0.587, with a best feasible length of 2.5862.586, as illustrated in Fig. 4(c). IV Conclusion This paper studied problem-side evaluation scaling in task-parameterized evolutionary transfer optimization. The two case studies have exposed two key scaling regimes: cross-task scaling in kinematic-arm optimization and within-task scaling in B-spline trajectory optimization. In both cases, mathematically equivalent reformulations replace recursive or sample-wise serial computation with structured matrix forms suitable for parallel execution, while maintaining close numerical agreement and substantially reducing isolated evaluation and end-to-end runtime. The results have shown that application evaluation itself provides a practical opportunity for improving ETO efficiency at increasing task scales. The present study is limited to two continuous task-parameterized applications, and the reformulations remain application-specific. Some matrix forms may also trade additional intermediate storage for lower runtime, making memory another consideration at larger scales. Future work should identify reusable evaluation-reformulation principles across broader problem classes and further address algorithm-side scaling in transfer, variation, selection, and other optimization operations. Combining efficient problem evaluation with scalable algorithmic execution is supposed to ultimately enable ETO systems to handle substantially larger collections of tasks. Code Availability The implementations of both application case studies and all experimental scripts used in this paper are publicly available at https://github.com/liyc5929/task-parameterized-eto-evaluation. References [1] T. Bäck and H. Schwefel (1993) An overview of evolutionary algorithms for parameter optimization. Evol. Comput. 1 (1), p. 1–23. Cited by: §I. [2] T. Bäck, U. Hammel, and H. Schwefel (1997) Evolutionary computation: Comments on the history and current state. IEEE Trans. Evol. Comput. 1 (1), p. 3–17. Cited by: §I. [3] A. Gupta, Y. Ong, and L. Feng (2016) Multifactorial evolution: Toward evolutionary multitasking. IEEE Trans. Evol. Comput. 20 (3), p. 343–357. Cited by: §I. [4] L. Feng, L. Zhou, J. Zhong, A. Gupta, Y. Ong, K. C. Tan, and A. K. Qin (2019) Evolutionary multitasking via explicit autoencoding. IEEE Trans. Cybern. 49 (9), p. 3457–3470. Cited by: §I. [5] X. Xue, C. Yang, L. Feng, K. Zhang, L. Song, and K. C. Tan (2024) Solution transfer in evolutionary optimization: An empirical study on sequential transfer. IEEE Trans. Evol. Comput. 28 (6), p. 1776–1793. Cited by: §I, §I-C. [6] K. C. Tan, L. Feng, and M. Jiang (2021) Evolutionary transfer optimization - A new frontier in evolutionary computation research. IEEE Comput. Intell. Mag. 16 (1), p. 22–33. External Links: Document Cited by: §I. [7] A. Gupta, Y. Ong, and L. Feng (2018) Insights on transfer optimization: Because experience is the best teacher. IEEE Trans. Emerg. Top. Comput. Intell. 2 (1), p. 51–64. Cited by: §I. [8] X. Xue, L. Feng, Y. Feng, R. Liu, K. Zhang, and K. C. Tan (2025) A theoretical analysis of analogy-based evolutionary transfer optimization. In IEEE Congress on Evolutionary Computation, CEC, p. 1–8. Cited by: §I. [9] A. Gupta, L. Zhou, Y. Ong, Z. Chen, and Y. Hou (2022) Half a dozen real-world applications of evolutionary multitasking, and more. IEEE Comput. Intell. Mag. 17 (2), p. 49–66. Cited by: §I. [10] Y. Huang, L. Feng, A. K. Qin, M. Chen, and K. C. Tan (2022) Toward large-scale evolutionary multitasking: A GPU-based paradigm. IEEE Trans. Evol. Comput. 26 (3), p. 585–598. External Links: Document Cited by: §I. [11] X. Xue, C. Yang, L. Feng, K. Zhang, L. Song, and K. C. Tan (2025) A scalable test problem generator for sequential transfer optimization. IEEE Trans. Cybern. 55 (5), p. 2110–2123. Cited by: §I. [12] J. Zhao, X. Chen, and L. Feng (2025) An efficient index-based source task selection approach for large-scale evolutionary sequential transfer optimization. In International Conference on Machine Intelligence and Nature-Inspired Computing (MIND), Vol. , p. 229–230. Cited by: §I. [13] T. Wei, J. Liu, A. Gupta, P. S. Tan, and Y. Ong (2026) (θlCLOSE(θ_l,OPENθu)θ_u)-parametric multitask optimization: Joint search in solution and infinite task spaces. IEEE Trans. Evol. Comput. 30 (3), p. 1270–1283. Cited by: §I. [14] J. Mouret and G. Maguire (2020) Quality diversity for multi-task optimization. In Genetic and Evolutionary Computation Conference, GECCO, p. 121–129. Cited by: §I-A, §I-A. [15] I. Sobol’ (1967) On the distribution of points in a cube and the approximate evaluation of integrals. USSR Computational Mathematics and Mathematical Physics 7 (4), p. 86–112. External Links: ISSN 0041-5553 Cited by: §I-C, §I-C. [16] A. B. Owen (1998) Scrambling Sobol’ and Niederreiter–Xing points. Journal of Complexity 14 (4), p. 466–489. External Links: ISSN 0885-064X Cited by: §I-C, §I-C. [17] J. Li, Z. Zhan, K. C. Tan, and J. Zhang (2022) A meta-knowledge transfer-based differential evolution for multitask optimization. IEEE Trans. Evol. Comput. 26 (4), p. 719–734. Cited by: §I-C, §I-C. [18] B. Huang, R. Cheng, Z. Li, Y. Jin, and K. C. Tan (2025) EvoX: A distributed GPU-accelerated framework for scalable evolutionary computation. IEEE Trans. Evol. Comput. 29 (5), p. 1649–1662. Cited by: §I-C, §I-C. [19] M. G. COX (1972) The numerical evaluation of B-splines. IMA Journal of Applied Mathematics 10 (2), p. 134–149. External Links: ISSN 0272-4960 Cited by: §I-A. [20] C. de Boor (1972) On calculating with B-splines. Journal of Approximation Theory 6 (1), p. 50–62. External Links: ISSN 0021-9045 Cited by: §I-A. [21] W. Lin, Q. Lin, X. Xue, and K. C. Tan (2024) Sequential transfer via clustering-based similarity measurement for faster trajectory optimization. In IEEE Conference on Artificial Intelligence, CAI, p. 1296–1301. Cited by: §I-C.