Datasets:

NBayer

/

20_observations_test

like 0

Conflict-driven Structural Learning Towards Higher Coverage Rate in ATPG Hui-Ling Zhen1, Naixing Wang2, Junhua Huang1, Xinyue Huang2, Mingxuan Yuan1and Yu Huang2 1. Noah’s Ark Lab, Huawei; 2. Hisilicon, Huawei Abstract —Due to the increasing challenges posed by the relentless rise in the design complexity of integrated circuits, Boolean Satisfiability (SAT) has emerged as a robust alternative to structural APTG techniques. However, the high cost of trans- forming a circuit testing problem to a Conjunctive Normal Form (CNF) limits the application of SAT in industrial ATPG scenarios, resulting in a loss of test coverage. In Order to address this problem, this paper proposes a conflict-driven structural learning (CDSL) ATPG algorithm firstly, in which the conflict-driven heuristic methods in modern SAT solver are implemented on the logic cone of fault propagation and activation directly. The pro- posed CDSL algorithm is composed of three parts: (1) According to the implication graph, various conflict constraints have been learned to prune search space. (2) Conflict-driven implication and justification have been applied to increase decision accuracy and solving efficiency. (3) A conflict-based diagnosis method is further proposed in the case of low coverage debug, leading to making the aborted faults testable by relaxing or modifying some constraints on primary inputs. Extensive experimental results on industrial circuits demonstrate the effectiveness and efficiency of the proposed CDSL algorithm. It is shown that compared with the SAT-based ATPG, the proposed CDSL can on average decrease 25:6%aborted faults with 94:51% less run time. With a two-stage computational flow, it has shown that the proposed CDSL can lead to 46:37% less aborted faults than a one-stage structural algorithm, further with the 3:19% improvement on fault coverage. In addition, the conflict diagnosis can lead to 8:89% less aborted faults on average, and 0:271% improvement in fault coverage rate. Index Terms —Conflict-driven, ATPG, Conflict Diagnosis I. I NTRODUCTION Continuous progress in decreasing device sizes and in- creasing design complexity has brought increasing demand for high product quality and low defective parts-per-million (DPPM) goals. Thus, scan-based structural testing has become even more important than ever, and Automatic Test Pattern Generation (ATPG) has served as an essential procedure for generating appropriate test patterns for testing logical faults that model physical defects. Given a targeted fault of the circuit-under-test, the goal of ATPG is to either generate a test pattern for the targeted fault (i.e., finding the test vector that can differentiate the good and faulty machines and that such fault is detectable) or prove that it is undetectable (i.e. there is no test vector that can differentiate the good and faulty machines). There have been several structural algorithms for ATPG, such as D- algorithm [1] and its advanced variants [2], [3]. There are two core problems in ATPG. One is how to improve decision efficiency under a given backtrack limit, especially considering a large number of hard-to-detect faults in today’s complex designs. There mainly exist two methods to solve this problem. One is to utilize Boolean Satisfiability (SAT) solver directly [4], [5]. Unlike structural ATPG working on a circuit network, SAT-based ATPG makes use of symboliccalculation techniques to implement efficient conflict-driven search on the Conjunctive Normal Form (CNF). Many SAT- based ATPG algorithms have been proposed, such as TG- Pro [6], TIGUAN [7], and PASSAT [8]. Similar SAT-based techniques have been applied, so as to insert test points for low-capture-power testing while maintaining the same fault coverage [9]. Fig. 1. A hybrid computational flow in ATPG, which begins at the struc- tural ATPG and ends with the SAT.A hybrid computational flow composed of struc- tural ATPG and SAT-based algorithms has been pro- posed, as shown in Fig- ure 1 [4]. Here, the struc- tural ATPG algorithm is adopted firstly under a given backtrack limit and it targets relatively easy- to-detect faults, which can be detected via a test pattern or proved to be undetectable. Then SAT targets the hard-to-detect faults which are aborted by the structural ATPG. Unlike structural ATPG, which is performed directly on the circuit, SAT-based algo- rithms rely on the CNF transformed from the logic cone of fault propagation and activation. This transformation is an extra step in SAT-based algorithms. Fig. 2. Comparison between the CNF generation time vs. solving time (in CPU microseconds). The horizontal axis is the fault index, while the vertical axis is the respective runtime. Take one circuit Stuck 4as an example (with additional details provided in Section IV), we demonstrate a significant challenge for SAT in Figure 2. The figure examines the time required for the transformation from the circuit to CNF in comparison to the related solving time. All targeted faults are stuck-at, and the SAT-based framework follows TG-Pro [6]. The chosen SAT Solver is Kissat [10], a reference SAT solverarXiv:2303.02290v1 [cs.AI] 4 Mar 2023 in SAT competition 2022. It is revealed that the transforma- tion process requires more runtime than solving itself. This indicates that despite the significant advancements made in SAT solver, which have displayed considerable potential in solving ATPG problems [5], the additional overhead required for CNF transformation limits SAT’s applications in industrial ATPG. Several works have been done to alleviate this problem. An incremental SAT-based framework has been proposed which aims to generate CNF incrementally and find the final solutions, or prove UNSAT, via partial CNF, hence decreasing the transformation time as well as solving time on average [4]. Preprocessing methods have been utilized to simplify the logic cone of fault propagation and activation, leading to a decrease in the generation and solving time by solving an equivalent substitute [11]. Nevertheless, the CNF transformation on large-scale circuits remains a big bottleneck, resulting in utilizing SAT solver being directly limited. Thus, the second method is to attempt to utilize SAT’s heuristics on the circuit. A conflict-driven recursive learning which combines with a dynamic decision ordering technique has been proposed to resolve hard-to- resolve faults [12]. A conflict-driven implication method has been proposed to improve the justification efficiency and avoid the over-specifications of test vectors [13]. An untestable debug algorithm has also been utilized for low test coverage analysis [14]. However, the method of constructing learning conflicts in modern SAT solvers, like the unique implication point (UIP), has not been considered. The other problem is that the ATPG constraints are usually conservative during the early stage of the design [14]. The conservatism often results in the implementation not being sufficiently mature in practice. Therefore, in the early stages, the DFT engineers have some degree of freedom to relax or modify certain constraints, making that some of the aborted faults as well as untestable faults which are not led by the circuit structure can be potentially resolved. To address this issue, we employ a conflict diagnosis approach after running ATPG engine to resolve low test coverage. Take one aborted fault as an example. We consider that the reason for abortion is due to the encountered conflicts exceeding the backtrack limit. Finally, the statistical analysis for the learnt conflicts would provide meaningful suggestions to the DFT engineer, leading to a decrease in the number of aborted or untestable faults and improving the coverage rate. Motivated by the aforementioned discussions, this paper proposes a conflict-driven structural learning (CDSL) ATPG algorithm, which aims to utilize the advantages brought by the structural ATPG and SAT-based algorithms. To summarize, our contributions include: (i)We first build learnt conflict-based constraints di- rectly on circuit, aiming to prune the searching space by using the optimization process data. According to the implication graph which is directly related to the decision-making process, we construct two kinds of conflict constraints, i.e., decision- variable-based constraint and UIP-based constraint, leading to avoiding meaningless searching in subsequent iterations. (ii)We adopt the conflict-driven decision rules to im- prove the decision accuracy. After accumulating the learnt conflicts, we construct new implications and justification approaches based on those conflicts. Extensive experiments demonstrate the effectiveness of conflict constraints on impli-cation efficiency with fewer backtracks and aborted faults. (iii)We further construct the conflict diagnosis accord- ing to the learnt conflicts in the case of low coverage debug. In this method, we utilize the learnt conflicts to analyze the reason from PIs’ constraints and relax or modify certain of them, aiming at further improving the test coverage rate. The remainder of this paper is organized as follows. After some preliminaries in Section II, Section III presents our new SAT-based ATPG approach. Experimental results are demon- strated in Section IV, in which we show the effectiveness of the proposed framework both on solution quality and runtime. Finally, we conclude this work in Section V. II. P RELIMINARIES A. Conflict-Driven-Clause-Learning (CDCL) in SAT SAT-based ATPG makes use of efficient SAT solvers to solve APTG problems. It begins with building a CNF format SAT model which represents the fault condition and prop- agation between the PIs and the POs. In general, a CNF formulaconsists of a conjunction of clauses !, each of which denotes a disjunction of literals. A literal is either a variablexior its complement. Each variable can be assigned a logic value, either 0or1. Any general Boolean problems can be represented as a CNF formula model. A SAT solver either finds an assignment such that is satisfied, or proves that no such assignment exists, i.e., UNSAT. A key heuristics in modern SAT solver is Conflict-Driven-Clause-Learning (CDCL) algorithm [5]. In general, CDCL is a Branch-and- Bound (BB) search framework, in which each step a literal and a propositional value (either 0 or 1) are selected for branching purposes. A key characteristic of CDCL is to learn new clauses from conflicts during backtrack searches. B. Structural ATPG Algorithm Different from SAT-based algorithms, the structural ATPG algorithm is performed on the circuit directly. Until now, several kinds of algorithms like D-algorithm, PODEM, and FAN have been proposed. In practice, D-algorithm tries to propagate the stuck-at-fault value denoted by D(for Stuck- at-0) orD(for Stuck-at-1) to a primary output (PO) [1]. The conventional D-algorithm generates a decision structure to evaluate the value of every node in the circuit to obtain the test vectors. PODEM and FAN are the advanced variants by limiting the searching space and accelerating backtracing, while PODEM limits the searching space only to Primary Inputs (PIs) [15], and FAN limits the searching space to headlines [16]. C. Comparison between Structural ATPG and CDCL There exists a certain difference between CDCL and structural ATPG algorithm. The first difference must root in the branching rules. The structural ATPG algorithm is requirement-driven [1], which denotes that the decision or- der accords with the fault propagation and circuit structural characteristics. Unlike this, the initial decision order in CDCL accords to the input literal order which is random, and this order is modified based on the literal’s frequency in learnt conflict constraints after some backtracks. The second differ- ence roots the backtrack rules after conflict occurs. We take an example to discuss other differences, as shown in Figure 3. All the decision variables ( x0,x2,x3, andx4) are in square boxes, while all the implicated variables are in oval boxes. Each decision variable is assigned with a decision level according to the decision order. The direction of the arrow is consistent with the direction of the implication. Fig. 3. An example of a decision- making process. All decision vari- ables are in square boxes, and implications in are in oval boxes. The related decision level is also labeled.Figure 3 shows that, af- ter the fourth decision vari- able, a conflict occurs (i.e., x8cannot be 0and1at the same time). In the structural ATPG algorithm, the deci- sion pointer will backtrack to the last decision variable (i.e.,x3), but without analy- sis of the reason for the oc- currence of conflicts. In the given conflict-driven meth- ods [12]–[14], there will be added one learnt conflict constraintx4 6= 1 , which limits the following impli- cations under new searching rules. Apparently, a better searching strategy must combine both advantages of struc- tural ATPG and CDCL, i.e., the branching rules follow the structural ATPG algorithm which aims to decrease the cost of wrong decisions, while once conflict occurs, the reasons for conflict should be considered like CDCL to avoid same wrong searching path. III. P ROPOSED CDSL A LGORITHM Fig. 4. New proposed CDSL algorithm. Different from the conven- tional structural ATPG algorithm, we incorporate SAT’s heuristics such as learnt conflict constraints, conflict-driven implication, and conflict-driven branch/decision, aiming to prune the searching space based on data from the optimization process and find solutions or prove UNSAT, with fewer backtracks. After the new ATPG computation, we propose to add the conflict diagnosis in case of low coverage. Considering the above, we propose a conflict-driven struc- tural learning (CDSL) ATPG algorithm which combines two methods, as shown in Figure 4. Compared with the con- ventional structural ATPG and SAT-based ATPG algorithms, the CDSL algorithm has two advantages: (1) It accumulatesconflict constraints after backtracks, with the aim of avoiding the same wrong decisions and finding solutions with fewer backtracks. (2) It employs conflict-driven implications to prune the searching space and conflict-driven branching rules, with a score heuristics, to improve decision accuracy. Given a fault site, we first trace the circuit to get the logic cone related to fault propagation and activation. The decision rules begin at the fault site and follow the conventional struc- tural ATPG algorithm until one conflict occurs. In the process, all structural ATPG algorithms like D-algorithm, PODEM, and FAN can be used. A. Implication Graph Firstly, we construct an implication graph according to the decision-making process: (1) We construct a directed acyclic graph in which each vertex represents a variable’s assignment, and each incident edge to a vertex represents the reason leading to that assign- ment. If one implication is inferred via other implications, there also exists an edge among different implications. Thus, decision variables have no incident edges in contrast to implied variables that have assignments forced during propagation. (2) Each decision variable is assigned a decision level ac- cording to the related decision-making order, while its related implications have the same decision level. Note that each variable in CDSL’s implication graph denotes a logic gate. Once a conflict occurs, the proposed CDSL algorithm would trace the implication graph to find all the his- torical assignments which result in the conflict and construct learnt conflict constraint. B. Learnt Conflict Constraints Take Figure 3 as an example, in which a conflict occurs throughx8, we construct two kinds of learnt conflict con- straints in the proposed CDSL algorithm. (1) Decision Variable-based Conflict. The basic principle is that the current conflict, at least, is caused by all historical decision variables. As shown in Figure 3, before the conflict occurs, there are four decision variables, i.e., x0= 1,x1= 1 x2= 1 ,x3= 1 andx4= 1 , thereby we can add a learnt conflict constraint as x0+x1+x2+x3+x4that is constructed via the decision variables. It denotes that in the following decision-making process, even though the four variables can serve as decision variables, they cannot repeat the same assignments, in other words, when it is found that three of these variables repeat the historical assignments, the fourth variable must take the opposite assignment. (2) Unique Implication Point (UIP)-based Conflict. A UIP is a special node that any node at the current decision level such that any path from the decision variable to the conflict node must pass through it [17]. As shown in Figure 3, the conflict occurs in node x8whose decision level is 4. The inference of UIP-based learnt conflict constraints can be given as follows: (i) We first find the direct reason for the conflict node. Figure 3 exhibits that one x8’s direct reasons are x4andx7, and the other x8’s direct reason is x0andx2. Hereby, both x0,x2, andx4are decision variables and their decision level is0,2, and 4, respectively. x7is implications from x4,x5, andx9. Thus, the direct learnt conflict constraint can be given asx0+x2+x4+x7. (ii) Check the decision level, and we should decide whether some of the reason nodes are replaced by the corresponding parents. The evaluation rule is that in the final learnt conflict constraint, there exists only one variable whose decision level is the same as the conflict node, and this variable is UIP. (ii-a) Consider x0+x2+x4+x7, since both x7,x9, and x4are in decision level 4andx4is a decision variable, we utilizex7’s parent nodes (i.e., x4,x5andx9) to replace it. After deduplication, the learnt conflict constraint is updated asx0+x2+x4+x5+x9, in which the decision levels of x5 andx9are3and4, respectively. (ii-b) Since x9andx4are in the same decision level, we utilizex9’s parents (i.e., z1,x3andx4) to replace it, and then the learnt conflict is updated as x0+x2+x4+x5+z1+x3. Finally, we can obtain the UIP-based learnt conflict con- straint asx0+x2+x4+x5+z1+x3. Considering that the only variable whose decision level is the same as the conflict node isx4, thus,x4serves as the UIP node. Note that we only show the learnt relationship among different variables, not including the logic values. After accumulating different learnt conflict constraints, the proposed CDSL algorithm will utilize those in the following three aspects: C.Conflict-driven Implications All learnt conflict constraints are applied for the implication phase, aiming to avoid repeating the wrong searching paths. Take the UIP-based learnt conflict constraint x0+x2+x4+ x5+z1+x3of Figure 3 as an example, if we find that five of the related variables (i.e., x0,x2,x4,x5andz1) have the same assignments with historical ones, the sixth must be assigned as the opposite value. To avoid the extra computational overhead when too many learnt conflict constraints are accumulated, we also add a forgotten rule in the implication phase: if one learnt conflict constraint is not utilized in recent Nloops, this constraint is considered to be no longer relevant and it would be deleted in the following loops. Hereby, Nis a hyperparameter. D.Conflict-driven Branch Heuristics The learnt conflict constraints can also be applied through Variable State Independent Decaying Sum (VSIDS) heuristic, aiming to improve the decision accuracy in the following decision phase. There are three steps in the VSIDS strategy: a) We start by assigning each variable a floating point score. When a conflict occurs, the activity of some variables is increased by 1. In general, the initial score is set to 0. b) After each conflict, the variable activity is decayed periodically, aiming to trade off the historical decisions and following ones. Such decay factor is set [0;1]. c) To balance VSIDS and structural strategies, we would check each variable’s score during branching. The variable with the highest score is selected under a given probability. Further, different from the structural ATPG algorithm which requires backtracking to the last decision variable, we adopt anon-chronological backtrack rule in the proposed CDSL algorithm. This rule accords with the UIP-based conflict con- straint, and the backtrack point is the variable that is with the largest decision level except for the UIP node. Take Figure 3 as an example, the scores of x0,x5,x3andx4are higher than others’ after both decision-variable-based and UIP-based conflict constraints are accumulated, and once one conflict occurs, the backtrack point is chosen as x3.E. Conflict Diagnosis for Low Coverage Debug Except for the implications and branching, we also explore adopting the conflict diagnosis to beat the low test coverage in the initial phase of design: (i) Compute each logic gate’s score according to the fre- quency in the learnt conflict constraints. (ii) Choose the top-k gates according to the score’s rank. Then trace the circuit to find the related external constraints. Usually, those constraints are put on either primary inputs or the fan-in gates of decision level 0. In conflict diagnosis, we choose to relax or modify the identified external ATPG constraints, which would provide an opportunity to make the aborted or untestable fault testable. IV. E XPERIMENTAL RESULTS A. Experiments Setup In this section, we aim to evaluate the proposed CDSL algorithm from the following three aspects: RQ1 : Can it have a performance advantage over the traditional SAT-based algorithms? RQ2 : Can it be beneficial for improving test coverage compared to the structural algorithm? RQ3 : Can the conflict diagnosis be exploited to debug the aborted or untestable faults? In the following, the CDSL framework is implemented on the structural D-algorithm. and its performance is evaluated from two perspectives, one is the number of aborted faults (unob- served faults, abbreviated as UO) under the set aborted limit, the other one is fault coverage rate, i.e., Fault Coverage = NTestable NTotal, whereNTotal andNTestable are the number of total faults and testable faults, respectively. All experiments are carried out for industrial circuits, and their designs are shown in Table I. TABLE I DESIGN CHARACTERISTICS Circuit Fault Type #gates #State Circuit Fault Type #gates #State Stuck 1 Stuck-at 246078 14979 Tran 1 Transition 139871 9644 Stuck 2 Stuck-at 246078 14979 Tran 2 Transition 785559 26288 Stuck 3 Stuck-at 221004 18190 Tran 3 Transition 785559 383963 Stuck 4 Stuck-at 78600 12047 Tran 4 Transition 785559 357483 Stuck 5 Stuck-at 221004 18190 Tran 5 Transition 221004 357483 Stuck 6 Stuck-at 206221 15772 Tran 6 Transition 221004 331291 Stuck 7 Stuck-at 56586 8194 Tran 7 Transition 221004 374009 Stuck 8 Stuck-at 221004 357483 Tran 8 Transition 206221 331291 Stuck 9 Stuck-at 246078 331291 Tran 9 Transition 206221 331291 Stuck 10 Stuck-at 785559 26288 Tran 10 Transition 221004 331291 B. Evaluation on Run Time To answer RQ1 , we choose stuck-at faults to compare the proposed CDSL with SAT-based methods, as shown in Table II. The first column is the circuit name. The second and third columns show the number of aborted faults led by the proposed CDSL algorithm and related run time (in CPU seconds), respectively. Hereby, the aborted limit is set as 100. Then from left to right, there are four different baselines to evaluate the CDSL algorithm: i) A basic SAT-based framework, TG-Pro [6]. It is also the latest open-source framework. The SAT solver is chosen as Kissat2022 [10]. ii) The basic D-algorithm. It is also a module of the proposed CDSL algorithm. iii) An incremental SAT-based ATPG method with prepro- cessing procedure [4]. iv) A SAT-based ATPG method with a fault analysis mod- ule [18], which is a trained neural network and predicts the fault classification for appropriate algorithm selection. It is shown that compared with the conventional SAT- based ATPG and structural D-algorithm, the proposed CDSL algorithm can decrease the aborted faults by 25:6% and 49:88% on average, while the run time is decreased by 94:51% and25:88%, respectively. Although the two new variants, i.e., the SAT-based ATPG with preprocessing or with the learnt network-based fault analysis can lead to fewer aborted faults and better run time, the proposed CDSL can also decrease the UO by 45:23% and12:35%, respectively, and the related run time can be decreased 58:79% and93:09%. It is worth mentioning that when the backtrack limit is the same, both the conventional structural ATPG and the proposed CDSL algorithm can lead to fewer aborted faults than SAT- based methods. It is because the SAT’s heuristics, such as branching, restart, and local search, totally rely on the score based on accumulated conflicts. It denotes that the limited conflict constraints may affect the performance of heuristics. TABLE II PERFORMANCE OF CDSL ONUO AND RUNTIME CircuitCDSL TG-Pro Structural Incre Neural UO time UO time UO time UO time UO time Stuck 1 147 229 174 10952 226 814 162 1528 162 9125 Stuck 2 352 167 559 1722 793 128 638 218 475 1522 Stuck 3 253 33 195 780 271 58 139 678 175 672 Stuck 4 1 53 7 1103 8 101 12 206 7 856 Stuck 5 144 18 119 393 158 36 105 79 110 326 Stuck 6 1343 365 1318 5165 1949 1307 2125 806 986 4238 Stuck 7 236 97 485 1389 453 92 383 234 429 1109 Stuck 8 601 550 518 10543 664 498 836 631 492 7692 Stuck 9 514 75 987 977 1303 812 1189 235 836 901 Stuck 10 545 878 1197 11931 1028 984 1963 1368 975 9312 Average 414 247 556 4496 825 333 755 598 465 3569 Improvement / / 25.6%94.51%49.88%25.88%45.23%58.79%12.35%93.09% C. Evaluation on Coverage Rate To further compare the proposed CDSL with the structural algorithm, we construct a two-stage ATPG framework on transition faults. (i) In the first stage, we set a relatively small backtrack limit and close the conflict-driven modules. We aim at handling the easy-to-detect faults with a relatively small aborted limit (The aborted limit is set 20). (ii) In the second stage, we set a relatively large aborted limit and the proposed CDSL algorithm targets the aborted faults (The aborted limit is set at 100). There are two baselines in the following experiments: (1) The first baseline is the one-stage conventional D-algorithm. (2) The second is also a two-stage algorithm, but the conflict-driven modules are closed in both two stages. The results are shown in Table III.It is found that the one-stage conventional D-algorithm results in 8702 aborted faults on average, and the fault cov- erage rate is 92:95%. However, when the same D-algorithm is armed with a two-stage setting, the aborted fault can be decreased to 5975 and the fault coverage rate can reach 95:21%. Further, when the proposed CDSL is implemented with a two-stage setting, aborted faults can be decreased to 4667 , and the fault coverage rate can be increased to 96:14%. In other words, compared with the D-algorithm, the aborted faults can be decreased via 46:37% and the fault coverage rate can be increased via 3:19%, while compared with the two-stage algorithm which is without conflict-driven modules, the aborted faults can be decreased via 21:89% and the fault coverage rate is increased via 0:93%. TABLE III EVALUATION IN A TWO-STAGE FRAMEWORK CircuitOne-Stage without Conflict Prop Model UO coverage UO coverage UO coverage Tran 1 505 95.57% 402 96.785% 353 97.149% Tran 2 32319 98.71% 22710 99.109% 17154 99.325% Tran 3 105 97.86% 119 98.867% 98 99.029% Tran 4 604 97.59% 320 98.611% 214 98.928% Tran 5 5414 91.71% 3769 94.678% 2943 95.795% Tran 6 13211 90.55% 9110 93.548% 7339 94.777% Tran 7 14037 90.15% 9462 93.383% 7615 94.634% Tran 8 13436 90.50% 9152 93.603% 7364 94.819% Tran 9 1641 88.34% 671 91.342% 526 93.011% Tran 10 5757 88.53% 4043 92.25% 3067 93.97% Average 8702 92.95% 5975 95.21% 4667 96.14 % Improvement 46.37% 3.19% 21.89% 0.93% / / D. Evaluation on Conflict Diagnosis Finally, we evaluate the conflict diagnosis in the case of low coverage analysis. As described in Section III-E, according to the accumulated learnt conflicts, we first mark the top 5logic gates. After tracing the circuits from the labeled logic gates, the conflict-related PI nodes are found, and the corresponding logic value is marked as N(supposing that there are N related PI nodes). If there exist constraints on the found PI nodes, we would relax such constraints. Otherwise, if there are not any constraints on one of the found PI nodes, we prefer to add a constraint on this node and the logic value is the opposite of. Finally, we recall the ATPG engine to generate the test pattern or prove the untestability. The results are given in Table IV. It is shown that after the conflict diagnosis, the aborted faults decrease 8:89% on average, while the fault coverage rates increase by 0:271% . V. C ONCLUSIONS Aiming at addressing the efficiency problem brought by the SAT-based framework but exploiting efficient heuristics of modern SAT solver, we have proposed conflict-driven structural learning (CDSL) ATPG algorithm in this paper, which allows the structural ATPG to benefit from the SAT’s TABLE IV EVALUATION ON CONFLICT DIAGNOSIS Circuit UO Coverage Circuit UO Coverage Stuck 1 554 99.120% Tran 1 306 97.337% Stuck 2 522 99.010% Tran 2 14928 99.505% Stuck 3 920 98.606% Tran 3 82 99.210% Stuck 4 8 99.803% Tran 4 126 98.600% Stuck 5 852 97.679% Tran 5 2812 96.004% Stuck 6 35 99.786% Tran 6 7002 95.232% Stuck 7 392 98.938% Tran 7 7213 94.887% Stuck 8 2356 96.022% Tran 8 6579 94.872% Stuck 9 5910 95.931% Tran 9 442 93.859% Stuck 10 3827 99.873% Tran 10 2913 93.953% techniques such as conflict management and conflict-driven branching. The proposed CDSL algorithm is composed of three parts: (1) Learnt conflict constraints before each back- track has been constructed, aiming to learn from the mistakes and utilize the optimization process data to prune search space. (2) Conflict-driven implication and justification have been applied for decisions and implications, aiming to further increase the solving efficiency and decision effectiveness. (3) Conflict diagnosis based on the analysis of the learnt conflicts has been attempted to improve test and fault coverage rate by relaxing some of the external ATPG constraints. Extensive experimental results on industrial circuits have demonstrated the advantage of the proposed CDSL ATPG algorithm in three aspects: (i) Comparing with the conventional SAT-based ATPG and structural D-algorithm, the proposed CDSL algorithm has decreased the aborted faults by 25:6%and49:88% on average, while the run time is decreased by 94:51% and 25:88%, respectively. (ii) With a two-stage setting, compared with the D-algorithm, the aborted faults can be decreased via 46:37% and the fault coverage rate can be increased via 3:19%, while compared with the two-stage algorithm which is without conflict-driven modules, the aborted faults can be decreased via21:89% and fault coverage rate is increased via 0:93%. (iii) Conflict diagnosis has been shown to decrease the aborted faults via 8:89% on average while increasing the fault coverage rate0:271% . Future work includes the development of more SAT heuristics on structural ATPG heuristics. REFERENCES [1] J. P. Roth, “Diagnosis of automata failures: A calculus and a method,” IBM J. Res. Develop. , vol. 10, pp. 278– 291, 1966. [2] N. Wang, C. Wang, K.-H. Tsai, W.-T. Cheng, X. Lin, M. Kassab, and I. Pomeranz, “Tea: A test generation algorithm for designs with timing exceptions,” Asian Test Symposium , pp. 19–195, 2019. [3] M. Schulz, E. Trischler, and T. Sarfert, “Socrates: A highly efficient automatic test pattern generation system,” International Test Conference , pp. 1016–1026, 1987. [4] J. Huang, H. L. Zhen, N. Wang, M. Yuan, H. Mao, Y . Huang, and J. Tao, “Accelerate sat-based atpg via preprocessing and new conflict management heuristics,” 27th Asia and South Pacific Design Automation Confer- ence (ASP-DAC) , pp. 365–370, 2022.[5] B. Becker, R. Drechsler, and M. Sauer, “Recent advances in sat-based atpg: Non-standard fault models, multi constraints and optimization,” International Conference on Design and Technology of Integrated Systems in Nanoscale Era , pp. 1–10, 2014. [6] H. Chen and J. Marques-silva, “Tg-pro: A sat-based atpg system system description,” Journal on Satisfiability, Boolean Modeling and Computation , vol. 8, no. 1-2, pp. 83–88, 2011. [7] A. Czutro, I. Polian, M. Lewis, P. Engelke, S. M. Reddy, and B. Becker, “Tiguan: Thread-parallel integrated test pattern generator utilizing satisfiability analysis,” Inter- national Conference on VLSI Design , pp. 227–232, 2009. [8] S. Eggersgl ¨uß, K. Schmitz, R. Krenz-B ˚a˚ath, and R. Drechsler, “On optimization-based atpg and its appli- cation for highly compacted test sets.” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems. , pp. 2104–2117, 2016. [9] S. Eggersgl ¨uß, S. Holst, D. Tille, K. Miyase, and X. Wen., “Formal test point insertion for region-based low-capture-power compact at-speed scan test.” IEEE Asian Test Symposium (ATS) , pp. 173–178, 2016. [10] M. S. Cherif, D. Habet, and C. Terrioux, “Kissat mab: Upper confidence bound strategies to combine vsids and chb,” SAT COMPETITION , 2022. [11] D. Tille, S. Eggersgluss, and R. Drechsler, “Incremental solving techniques for sat-based atpg,” IEEE Transac- tions on Computer-Aided Design of Integrated Circuits and Systems , vol. 29, no. 7, pp. 1125–1130, 2010. [12] C. Wang, S. M. Reddy, I. Pomeranz, X. Lin, and J. Ra- jski, “Conflict driven techniques for improving determin- istic test pattern generation.” IEEE/ACM international conference on Computer-aided design , pp. 87–93, 2002. [13] S. Bommu, K. Chandrasekar, R. Kundu, and S. Sengupta, “Concat: Conflict driven learning in atpg for industrial designs.” IEEE International Test Conference (ITC) , pp. 1–10, 2008. [14] C. Kameshwar, S. Bommu, and S. Sengupta., “Low coverage analysis using dynamic un-testability debug in atpg.” IEEE VLSI Test Symposium (VTS) , pp. 291–296, 2011. [15] P. Goel, “An implicit enumeration algorithm to gener- ate tests for combinational logic circuits,” IEEE Trans. Comput. , vol. C-30, pp. 215–222, 1981. [16] K. T. and M. R. Mercer, “A topological search algorithm for atpg.” In 24th ACM/IEEE Design Automation Con- ference , pp. 502–508, 1987. [17] M.-S. Joao, I. Lynce, and S. Malik., “Conflict-driven clause learning sat solvers. handbook of satisfiability.” IOS Press , pp. 133–182, 2021. [18] J. Huang, H. L. Zhen, N. Wang, M. Yuan, H. Mao, and Y . Huang, “Neural fault analysis for sat-based atpg.” IEEE International Test Conference (ITC) , pp. 36–45, 2022.

This paper proposes a Conflict-Driven Structural Learning (CDSL) ATPG algorithm which combines the efficient heuristics of modern SAT solvers with the SAT-based framework to address the efficiency problem. The algorithm builds conflict-based constraints on the circuit to prune the search space, and adopts conflict-driven decision rules to improve decision accuracy. Additionally, a conflict diagnosis approach is used to analyze the reason for low coverage debug and modify certain constraints to improve the test coverage rate. Extensive experimental results demonstrate the effectiveness and efficiency of the proposed CDSL algorithm.

Learning Rational Subgoals from Demonstrations and Instructions Zhezheng Luo*1, Jiayuan Mao*1, Jiajun Wu2, Tom ´as Lozano-P ´erez1, Joshua B. Tenenbaum1, Leslie Pack Kaelbling1 1Massachusetts Institute of Technology2Stanford University Abstract We present a framework for learning useful subgoals that sup- port efficient long-term planning to achieve novel goals. At the core of our framework is a collection of rational subgoals (RSGs), which are essentially binary classifiers over the envi- ronmental states. RSGs can be learned from weakly-annotated data, in the form of unsegmented demonstration trajectories, paired with abstract task descriptions, which are composed of terms initially unknown to the agent (e.g., collect-wood then craft-boat then go-across-river ). Our framework also discov- ers dependencies between RSGs, e.g., the task collect-wood is a helpful subgoal for the task craft-boat . Given a goal de- scription, the learned subgoals and the derived dependencies facilitate off-the-shelf planning algorithms, such as Aand RRT, by setting helpful subgoals as waypoints to the plan- ner, which significantly improves performance-time efficiency. Project page: https://rsg.csail.mit.edu Introduction Being able to decompose complex tasks into subgoals is crit- ical for efficient long-term planning. Consider the example in Fig. 1: planning to craft a boat from scratch is hard, as it requires a long-term plan going from collecting materials to crafting boats, but it can be made easier if we know that hav- ing an axe andhaving wood are useful sub-goals. Planning hierarchically with these subgoals can substantially reduce the search required. It is also helpful to understand the tem- poral dependencies between these subgoals, such as having wood being a useful subgoal to achieve prior to crafting boat makes long-term planning much more efficient. In this work, we propose Rational Subgoals (RSGs), a framework for learning useful subgoals and their temporal dependencies from demonstrations. Our system learns with very weak supervision, in the form of a small number of un- segmented demonstrations of complex behaviors paired with abstract task descriptions. The descriptions are composed of terms that are initially unknown to the agent, much as an adult might narrate the high-level steps when demonstrating a cooking recipe to a child. These action terms indicate im- portant subgoals in the action sequence, and our agent learns *These authors contributed equally. Copyright ©2023, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.to detect when these subgoals are true in the world, infer their temporal dependencies, and leverage them to plan efficiently. Illustrated in Fig. 1, our model learns from a dataset of paired but unaligned low-level state-action sequences and the corresponding abstract task description ( collect-wood then craft-boat then go-across-river ). For each action term o(e.g., collect-wood ), our model learns a goal condition Go, which maps any state to a binary random variable, indicat- ing whether the state satisfies the goal condition. Given the training data, we decompose the observed trajectory into frag- ments, each of which corresponds to a “rational” sequence of actions for achieving a subgoal in the description. While this model-based approach enables great general- ity in generating behaviors, it suffers from the slow online computation. To speed up online planning, we compute a de- pendency matrix whose entries encode which subgoals might be helpful to achieve before accomplishing another subgoal (e.g., having wood is a helpful subgoal for the task crafting boat, and thus the entry ( having wood ,crafting boat ) will have a higher weight). During test time, given a final goal (e.g., craft boat ) and the initial state, a hierarchical search algorithm is applied at both the subgoal level and the lower, environmental-action level. The explicit learning of subgoals and their dependency structures brings two important advantages. First, the sub- goal dependency allows us to explicitly set helpful subgoals as waypoints for planners. This significantly improves their runtime efficiency. Second, compared to alternative subgoal parameterizations such as reward functions, subgoals in the form of a state classifier allows us to use simple and efficient planners. For example, in continuous spaces, we can use Rapidly-exploring Random Trees ( RRT) to search for plans in the robot configuration space. These planers do not require training and generalize immediately to novel environments. We evaluate RSGs in Crafting World (Chen, Gupta, and Marino 2021), an image-based grid-world domain with a rich set of object crafting tasks, and Playroom (Konidaris, Kaelbling, and Lozano-Perez 2018), a 2D continuous domain with geometric constraints. Our evaluation shows that our model clearly outperforms baselines on planning tasks where the agent needs to generate trajectories to accomplish a given task. Another important application of RSGs is to create a language interface for human-robot communication, which includes robots interpreting human actions and humans in-arXiv:2303.05487v1 [cs.AI] 9 Mar 2023 MoveRightMoveDownCollectMoveLeftCraft Subgoal1:collect-woodSubgoal2:craft-boat()*+!=,-./'()*+!=,-./'()*+!=,-./'()*+!=#%&'()*+"=,-./'()*+"=#%&'()*+"=,-./'Subgoal1:collect-wood=%&'(!Subgoal2:craft-boat=%&'("(a)(b)Figure 1: Interpreting a demonstration and its description in terms of RSGs: (a) Each RSG is represented as a subgoal Go. (b) The system infers a transition to the next subgoal if the Gcondition is satisfied. Such transition rules can be used to interpret demonstrations and to plan for tasks that require multiple steps to achieve. structing robots by specifying a sequence of subgoals. Our model enables compositional generalization through flexible re-composition of learned subgoals, which allows the robot to interpret and execute novel instructions. Rational Subgoal Learning and Planning We focus on learning rational subgoals from demonstration data and leveraging them for planning. Formally, our training data is a collection of paired unsegmented demonstrations (i.e., state and action sequences) and abstract descriptions (e.g., collect-wood then craft-boat ) composed of action terms (collect-wood , etc.) and connectives ( then,or). Our ultimate goal is to recover the grounding (i.e., the corresponding sub- goal specified by the action term) for each individual action term. These subgoals will be leveraged by planning algo- rithms to solve long-horizon planning problems. We begin this section with basic definitions of the rational subgoal representations and the language TLfor abstract de- scriptions. Second, we outline the planning algorithm we use to refine high-level instructions in TLinto environmental ac- tions that agents can execute, given the RSGs. Although any search algorithms or Markov Decision Process (MDP) solvers are in principle applicable for our planning task, in this paper, we have focused on a simple extension to the A* algorithm. Next, we present the algorithm we use to learn RSGs from data. Since we are working with unsegmented trajectories, the learning algorithm has two steps. It first computes a ra- tionality score for individual actions in the trajectory based on the optimal plan derived from the A* algorithm. Then, it uses a dynamic programming algorithm to find the best segmentation of the trajectory and updates the parameters. Finally, we describe a dependency discovery algorithm for RSGs and apply it to solve planning tasks given only a single goal action term (e.g., collect-gold ), in contrast to the earlier case where there are detailed step-by-step instructions. We call our representation rational subgoals because our learning algorithm is based on a rationality objective with -(a))=+(b))!=,-./01(d))=,2031(c))=,-./01456-34561-1-127#7$7#7$7#7$-34561-17#13456-1-7$Figure 2: Illustrative example of how finite state machines (FSM) are constructed from task descriptions. The super- starting node v0and the super-terminal node vTare high- lighted. respect to demonstration trajectories, and our planning algo- rithm chooses rational subgoals to accelerate the search. Formally, a rational subgoal (RSG) is a classifier that maps an environmental state sto a Boolean value, indicat- ing whether the goal condition is satisfied at s. Each RSG has an atomic name o(e.g., collect-wood ), and the corre- sponding goal classifier is denoted by Go. Depending on the representation of states, Gocan take various forms of neural networks, such as convolutional neural networks (CNNs) for image-based state representations. In both learning and planning, we will be using an ab- stract language to describe tasks, such as collect-wood then craft-boat . These descriptions are written in a formal task lan- guageTL. Syntactically, all atomic subgoals are in TL; and for allt1;t22TL ,(t1thent2),(t1ort2), and (t1andt2) are inTL. Semantically, a state sequence ssatisfies a task descriptiont, written sj=twhen: •Iftis aRSGo, then the first state does not satisfy Go, and the last state satisfies Go. Note that this implies that the sequence smust have at least 2states. •Ift= (t1thent2)then90< j < n such that (s1;:::;sj)j=t1and(sj;:::;sn)j=t2: taskt1should be accomplished before t2. •Ift= (t1ort2)thensj=t1orsj=t2: the agent should either complete t1ort2. •Ift= (t1andt2)then sj= (t1thent2)orsj= (t2thent1): the agent should complete both t1andt2, but in any order ( t1first ort2first) *. Note that the relation sj=tonly specifies whether scom- pletestbut not how optimal sis. Later on, when we define the planning problem, we will introduce the trajectory cost. Each task description t2TL can be represented with a non-deterministic finite state machine ( FSM), representing the sequential and branching structures. Each FSMtis a tuple (Vt;Et;VIt;VGt)which are subgoal nodes, edges, set of possible starting nodes and set of terminal nodes. Each node corresponds to an action term in the description, and each edge corresponds to a possible transition of changing subgoals. Fig. 2 illustrates the constructions for syntax in TL, and we provide the follow algorithm for the construction. •Single subgoal: A single subgoal sis corresponding FSM with a single node i.e. VIt=VGt=Vt=fsg, and Et=;. •t1thent2: We merge FSMt1and FSMt2by merging their subgoal nodes, edges and using VIt1as the new starting node set and VGt2as the new terminal node set. Then, we add all edges from VGt1toVIt2. Formally, FSMt1thent2= (Vt1[Vt2;Et1[Et2[(VGt1VIt2);VIt1;VGt2); whereindicates the Cartesian product, meaning that each terminal node of FSMt1can transit to any starting node of FSMt2. •t1or


ortn: Simply merge nFSMs without adding any new edges. Formally, FSMt1or


ortn= ([ iVti;[ iEti;[ iVIti;[ iVGti) •t1and


andtn: Build 2n

This paper presents a framework for learning rational subgoals from demonstrations and instructions, using A* search on FSM-augmented transition models. It compares the performance of RSGs with two baselines (IRL and Behavior Cloning) on primitive and compositional tasks, as well as novel tasks. It also discusses the use of Generative Adversarial Imitation Learning (GAIL) as a baseline for completing tasks on seen instructions. The results show that RSGs outperform all baselines on both the compositional and novel splits.

Multiplexed gradient descent: Fast online training of modern datasets on hardware neural networks without backpropagation A. N. McCaughan1, B. G. Oripov2, N. Ganesh1, S. W. Nam1, A. Dienstfrey1, S. M. Buckley1 1National Institute of Standards and Technology, Boulder, CO 80305 2University Colorado Boulder, Boulder, CO 80309 Abstract We present multiplexed gradient descent (MGD), a gradient descent framework designed to easily train analog or digital neural networks in hardware. MGD utilizes zero-order optimization techniques for online training of hardware neural networks. We demonstrate its ability to train neural networks on modern machine learning datasets, including CIFAR-10 and Fashion-MNIST, and compare its performance to backprop- agation. Assuming realistic timescales and hardware parameters, our results indicate that these optimization techniques can train a network on emerging hardware platforms orders of magnitude faster than the wall-clock time of training via backpropagation on a standard GPU, even in the presence of imperfect weight updates or device-to-device variations in the hardware. We additionally describe how it can be applied to existing hardware as part of chip-in-the-loop training, or integrated directly at the hardware level. Crucially, the MGD framework is highly exible, and its gradient descent pro- cess can be optimized to compensate for specic hardware limitations such as slow parameter-update speeds or limited input bandwidth. 1arXiv:2303.03986v1 [cs.LG] 5 Mar 2023 1 Introduction Machine learning has proven an invaluable tool for a variety of applications [1]. However, machine learning on traditional digital hardware is inecient, leading to a signicant eort towards building custom hardware that can perform machine learning tasks at high speeds with lower energy costs [2]. A number of hardware platforms have emerged using analog [3], digital [4, 5], or mixed-signal processing [6] that will potentially oer increased operational speeds and/or reduced energy costs [7]. However, many of the most promising hardware instantiations only perform the inference part of the machine learning algorithm. Meanwhile the larger portion of the energy cost is spent training on datasets [8], usually via gradient descent. Backpropagation is by far the most commonly used method of computing the gra- dient for gradient descent, but has proved to be challenging to implement in novel hardware platforms [9]. Though often con ated, training via gradient descent does not require backpropagation { backpropagation is only used to calculate the gradient. Other methods for computing the gradient in neural networks exist, but are much less ecient in software than backpropagation and so are rarely used in today's machine learning applications. This is not generally true in hardware, where backpropagation may not only be challenging to implement, but also may not be the most ecient way to compute the gradient. Of particular interest in hardware are model-free methods, in which we require no knowl- edge of the internal structure of the network (e.g topology, activation function, derivatives, etc), only the ability to perturb the network's parameters and measure the network's re- sponse. The simplest example of such a method is nite-dierence [10], which has been employed for chip-in-the-loop training [11]. However, nite-dierence has several other dis- advantages that prevent its widespread implementation in hardware, including the require- ments for extra memory at every synapse and global synchronization. Fortunately, there are a variety of other model-free methods that overcome some of the issues associated with nite-dierence [12, 13]. 2 In this paper, we show that model-free perturbative methods can be used to eciently train modern neural network architectures in a way that can be implemented natively within emerging hardware. These methods were investigated for training VLSI neural networks beginning in the 1990s [14, 15, 16, 17, 18, 19, 20, 21, 22, 23], and more recently on memristive crossbars [24] and photonic hardware [25], but all these demonstrations have been very limited in scale, comprising small datasets with only a few neurons. Below we describe a framework for applying these techniques to existing hardware at much larger scales, with an emphasis on creating simple, highly-localized circuits that could be implemented on-chip if desired. The framework is also extensible to training existing hardware systems via a chip-in-the-loop technique. We note that these methods have also been adapted in forward gradient approaches using auto-dierentiation, which have attracted recent interest in the machine learning literature [26, 27, 28]. We show that under realistic assumptions of the operating timescales of analog and digital hardware neural networks, one can train hardware to solve modern datasets such as CIFAR- 10 faster than training a software network on a GPU, even in the presence of signal noise and device-to-device variations in the hardware. A major advantage of this framework is that it can be used to perform online training of hardware platforms originally designed only for inference while making minimal hardware modications. 2 Multiplexed gradient descent 2.1 Computing the gradient with perturbations We begin with the basic assumption that we have some hardware with programmable pa- rameters (e.g. weights and biases) that can perform inference. Our goal is to augment the hardware minimally such that it can also be trained via gradient descent. We will show how to congure the hardware such that the network as a whole automatically performs gradient descent, without backpropagation. As an example, assume we have a hardware 3 instantiation of a feedforward multi-layer neural network as shown in Fig. 1. The hardware takes time-varying inputs x(t), training target ^ y(t), has variable parameters , outputs the inferencey(t), and computes a cost C(y(t);^y(t)). To allow us to compute the gradient of such a system, we rst add a small time-varying perturbation ~i(t) to each parameter base valuei(Fig. 1a, inset). This perturbation will slightly modulate the cost C, and that mod- ulation will be fed back to the parameters. This process will ultimately allow us to extract the gradient of the system. C neuron synapse ... ʃ update (a) (c)(b) ...... x1 x2 x3sinusoidalt sequential code Figure 1: (a) Schematic diagram showing the operation of the MGD framework in a feed- forward neural network using example sinusoidal perturbations. (a, inset) Each parameter iis modulated slightly from its base value iby the perturbation ~i. The result of these perturbations causes a modulation in the cost ~C, which is globally broadcast back to all the parameters. (b) A homodyne detection process is used to compute the partial gradient approximations Gifrom the integrated product of iand ~C. This partial gradient is then used to update iin the approximate direction of the gradient. (c) Example perturbation types that can be used with this process. Although the perturbations can take a variety of dierent forms, we will rst describe this process by using sinusoidal perturbations as they are conceptually straightforward to understand. In this scenario, each parameter iis slightly modulated at a unique frequency !iand amplitude
, giving the perturbation ~i(t) =
sin(!it). As each parameter is 4 modulated, it slightly changes y(t) which in turn changes the cost. Thus, if the parameters are modulated by frequencies !1,!2,!3, etc, those same frequencies will necessarily appear as small modulations in the cost ~C(t) on top of the baseline (unperturbed) cost value C0, such that C(t) =C0+~C(t) =C0+X i
Cisin(!it) (1) If we remove C0, we are left with a time varying signal ~C(t) =P i
Cisin(!it) corre- sponding only to the eects of our parameter perturbations. The amplitude
Ciis simply the amplitude of change in the cost due to ~i(t), the perturbation of parameter i. Since the gradient with respect to the cost dC=d is composed solely from the partial gradientsdC=d = (@C=@ 1; @C=@ 2; :::), if we can extract
Cifor each parameter we can produce an estimate of the complete gradient G= (
C1=
1;
C2=
2;:::). Now the task becomes to extract individual
Ciout of the summed signal ~C(t). Fortunately, to extract a given
Ci, all we need to do is integrate the product of the input perturbation ~i(t) with ~C(t). The integration takes the form of a homodyne detection, where unwanted perturbations (frequencies) from other parameters are eliminated via integration: Gi=1
2 i1 TZT t=0X k
Cksin(!kt)
isin(!it)dt =
Ci
iasT!1(2) where 1=
2 iis a normalization constant. The valueGiis the approximation for the partial gradient for parameter i.Gapproaches the exact gradient when both T!1 and the amplitude of the perturbation
iapproaches zero, and is only an approximation otherwise. Fortunately, even at realistic timescales and amplitudes, Gcontains meaningful information and can be used to perform gradient de- scent [12]. 5 For illustrative purposes we have described the algorithm using sinusoidal parameter perturbations. However, any collection of orthogonal, mean zero perturbations can be used [13], including a variety of analog and discrete perturbations as shown in Fig. 1c. In general, we will be integrating the product ei(t) = ~C(t)~i(t)=
2 i, which we refer to as the error signal, and Giwill be given by1 Gi=ZT t=0~C(t)~i(t)
2 idt (3) We discuss the eects of changing the perturbation type in Section 3.4. We also note that although many of the quantities described here are time-varying, in the following sections we will drop the explicit time dependence notation for the sake of brevity. 2.2 Gradient descent in the MGD framework Here we describe the practical implementation of a model-free gradient descent framework in hardware, which we term multiplexed gradient descent (MGD). To better understand the algorithm from a hardware perspective, we will run through the same computation previously described, but from the viewpoint of a single parameter (e.g. a synapse weight in a hardware neural network). The process begins with the application of a local perturbation ~ithat slightly modies the base value of the parameter i(Fig. 1a, inset). As previously described, this perturbation { and any other perturbations from other parameters { induce a change in the cost ~Con top of the baseline cost C0such that the cost at the output is C=C0+~C.~Cmay be extracted from Ceither by direct subtraction of C0or, in some analog scenarios, by a simple highpass lter. The resulting ~Csignal is broadcast globally to all parameters, so our parameter ihas access to it. (Note that although Fig. 1 shows a wireless broadcast tower for purposes of clarity, in most hardware platforms this will be a 1Note that here and in the simulation results, Giis being accumulated with time and is not normalized by 1=T, unlike Eq. 2. As described later, this allows us to vary the integration time without greatly impacting the rate of training{equivalently, one can integrate for a long time resulting in a large step down the gradient, or one can take a series of shorter steps instead and travel approximately the same distance along the gradient. 6 wired connection). However, we must assume that parameters other than the ith are also causing modulations in the cost as well. To our parameter i, these other modulations are unwanted and must be ltered out. As shown in Fig. 1b, for the parameter ito extract only its own eect on the cost, it can just integrate the product of its local perturbation ~iand the global cost signal ~Cit receives. This has the eect of isolating the contribution from i due to the pairwise orthogonality of the perturbation signals. From Eq. 3, this integration produces the partial gradient approximation Gi/
Ci=
i. The parameter can then use theGivalue to directly to reduce the cost by updating itself according to a gradient descent step i!i

This paper presents the Multiplexed Gradient Descent (MGD) algorithm, a model-free perturbative technique that is orders of magnitude faster than backpropagation and can be used to train hardware platforms based on emerging technologies. It examines the use of perturbative techniques to train large and small hardware systems, such as photonic or memristive crossbar hardware, without redesigning the hardware. It also looks at various research papers on topics such as distributed learning for analog VLSI neural networks, FPGA implementations of pulse density neural networks, memristor-based neural networks, single chip photonic deep neural networks, and various learning rules and algorithms for spiking neural networks. This research was funded by NIST and University Colorado Boulder.

Using Affine Combinations of BBOB Problems for Performance Assessment Diederick Vermetten Leiden Institute for Advanced Computer Science Leiden, The Netherlands d.l.vermetten@liacs.leidenuniv.nlFurong Ye Leiden Institute for Advanced Computer Science Leiden, The Netherlands f.ye@liacs.leidenuniv.nlCarola Doerr Sorbonne Université, CNRS, LIP6 Paris, France Carola.Doerr@lip6.fr ABSTRACT Benchmarking plays a major role in the development and analysis of optimization algorithms. As such, the way in which the used benchmark problems are defined significantly affects the insights that can be gained from any given benchmark study. One way to easily extend the range of available benchmark functions is through affine combinations between pairs of functions. From the perspective of landscape analysis, these function combinations smoothly transition between the two base functions. In this work, we show how these affine function combinations can be used to analyze the behavior of optimization algorithms. In particular, we highlight that by varying the weighting between the combined problems, we can gain insights into the effects of added global structure on the performance of optimization algorithms. By analyzing performance trajectories on more function combinations, we also show that aspects such as the scaling of objective functions and placement of the optimum can greatly impact how these results are interpreted. KEYWORDS Black-box Optimization, Benchmarking, Performance Analysis 1 INTRODUCTION Benchmarking is a key aspect in the development of optimization algorithms. Not only are benchmark problems used to compare the effectiveness of different optimizers with regard to a standardized set of problems, the analysis of algorithm behavior on these prob- lems is often used to gain insight into the characteristics of the algorithm. Because of this, the design of benchmark problems has a major impact on the field of optimization as a whole [1]. One of the most common benchmark suites in single-objective, continuous, noiseless optimization is fittingly called Black Box Op- timization Benchmark (BBOB) [ 7]. This suite is part of the COCO framework [ 6], which has seen significant adoption in the last decade. This suite consists of 24 problems, each defined to repre- sent a set of global landscape properties. For each of these problems, many different instances can be created through a set of transfor- mations, allowing researchers to test different invariances of their algorithm. Because of its popularity, studies into the specifics of the BBOB suite are numerous [13, 16, 17]. One particularly popular method to investigate continuous opti- mization problems is Exploratory Landscape Analysis (ELA) [ 15]. This technique aims to characterize the low-level landscape proper- ties through a large set of features. Applying this to the BBOB suite shows that instances of the 24 functions generally group together, with separation between functions being relatively robust [ 20].This observation raised the question of how the spaces between problems could be explored. In a recent study, affine combinations between pairs of BBOB problems were proposed and analyzed using ELA [ 4]. The resulting analysis shows that varying the weight of these combinations has a relatively smooth impact on the landscape features. As such, these new functions could potentially be used to study the transition between different landscapes, which opens up a more in-depth analysis of the relation between landscapes and algorithm behavior. To investigate to what extent the affine function combinations can be used to study algorithmic behavior, we perform a bench- marking study through which we investigate the effect of the affine combinations on the performance of five numerical black-box opti- mization algorithms. We make use of function combinations which include a sphere model to show the impact of added global structure on the relative ranking between algorithms. Additionally, we show that by combining functions with different global properties we don’t always obtain smooth transitions in performance. We pro- vide examples where the combination of two functions can either be significantly more challenging or slightly easier than the base functions it consists of. 2 RELATED WORK 2.1 BBOB Problem Suite Within continuous optimization benchmarking, one of the most popular suites of benchmarks is the BBOB family, which has been designed as part of the COCO framework. The noiseless, single- objective suite consists of 24 problems, each of which can be in- stantiated with a set of different transformations. These function instances aim to preserve the global function properties while vary- ing factors such as the location of the global optimum, such that an optimizer can not directly exploit these aspects. However, the exact influence these transformations have on the low-level landscape properties is not as straightforward, which can lead to noticeable differences in algorithm behavior on different instances of the same function [13]. 2.2 Affine Function Combinations While using function instances allows the BBOB suite to cover a wider range of problem landscapes than the raw functions alone, there are limits to the types of landscapes which can be created in this way. Recently, it has been proposed to use affine combinations between pairs of BBOB functions to generate new benchmark func- tions [ 4]. These combinations have been shown to smoothly fill the space of low-level landscape properties, as measured through a set of ELA features. These results have shown that even a relatively 1arXiv:2303.04573v1 [cs.NE] 8 Mar 2023 Diederick Vermetten, Furong Ye, and Carola Doerr simple function creation procedure has the potential to give us new insights into the way function landscapes work. 3 EXPERIMENTAL SETUP In this work, we make use of a slightly modified version of the affine function combinations from [ 4]. In particular, we define the combination between two functions from the BBOB suite as follows: 𝐶(𝐹1,𝐼1,𝐹2,𝐼2,𝛼)(𝑥)= exp 𝛼log

This paper examines the use of affine combinations of BBOB problems for performance assessment. It investigates the effect of the affine combinations on the performance of five numerical black-box optimization algorithms, and explores the potential of a modified version of affine function combinations to give new insights into the way function landscapes work. It also reviews various methods for comparing continuous optimizers in a black-box setting, and presents the IEEE Symposium Series on Computational Intelligence (SSCI) 2021, BIAS: A Toolbox for Benchmarking Structural Bias in the Continuous Domain (Vermetten et al., 2022), Reproducibility files and additional figures (Vermetten et al., 2023), and IOHanalyzer: Detailed Performance Analysis for Iterative Optimization Heuristic (Wang et al., 2022).

Magnetic Stochastic Synapses Machine learning using magnetic stochastic synapses Matthew O. A. Ellis,1,a)Alexander Welbourne,2,a)Stephan J. Kyle,2Paul W. Fry,3Dan A. Allwood,2Thomas J. Hayward,2and Eleni Vasilaki1 1)Department of Computer Science, University of Sheeld, Sheeld, S1 4DP, United Kingdom 2)Department of Materials Science and Engineering, University of Sheeld, Sheeld, S1 3JD, United Kingdom 3)Department of Electronic and Electrical Engineering, University of Sheeld, Sheeld, S1 3JD, United Kingdom (Dated: 3rd March 2023) The impressive performance of articial neural networks has come at the cost of high energy usage and CO 2 emissions. Unconventional computing architectures, with magnetic systems as a candidate, have potential as alternative energy-ecient hardware, but, still face challenges, such as stochastic behaviour, in implementa- tion. Here, we present a methodology for exploiting the traditionally detrimental stochastic eects in magnetic domain-wall motion in nanowires. We demonstrate functional binary stochastic synapses alongside a gradient learning rule that allows their training with applicability to a range of stochastic systems. The rule, utilising the mean and variance of the neuronal output distribution, nds a trade-o between synaptic stochasticity and energy eciency depending on the number of measurements of each synapse. For single measurements, the rule results in binary synapses with minimal stochasticity, sacricing potential performance for robustness. For multiple measurements, synaptic distributions are broad, approximating better-performing continuous synapses. This observation allows us to choose design principles depending on the desired performance and the device's operational speed and energy cost. We verify performance on physical hardware, showing it is comparable to a standard neural network. INTRODUCTION The meteoric rise of articial intelligence (AI) as a part of modern life has brought many advantages. However, as AI programs become increasingly more complex, their en- ergy footprint becomes larger1,2, with the training of one of today's state-of-the-art natural language processing models now requiring similar energy consumption to the childhood of an average American citizen3. Several non- traditional computing architectures aim to reduce this energy cost, including non-CMOS technologies4{7. How- ever, competitive performance with non-CMOS technolo- gies requires overcoming the latent advantage of years of development in CMOS. In biological neural networks, synapses are considered all-or-none or graded and non-deterministic, unlike the fully analogue synapses modelled in articial networks8. Inspired by biology, several approaches have considered networks with binary synapses and neurons, with the view that binary operations are simpler to compute and thus lower energy9{12. However, while these binarised neural networks are more robust to noise, they suer from lower performance than analogue versions. In con- trast, networks with stochastic synapses provide sam- pling mechanisms for probabilistic models13and can ri- val analogue networks at the expense of long sampling times14{19. Adapted training methods are required to provide higher performance for a lower number of sam- ples, while implementations require hardware that can a)These authors contributed equally to this work.natively (with low energy cost) provide the stochastic- ity required. Magnetic architectures are one possible route for unconventional computing. They have long promised a role in computing logic following the strong interest in the eld stemming from the data storage market6,7,20{26. The non-volatility of magnetic elements naturally allows for the data storage, while ultra-low- power control mechanisms, such as spin-polarised cur- rents or applied strain27,28oer routes towards energy- ecient logic-in-memory computing. Ongoing develop- ments have shown how to manipulate magnetic domains to both move data and process it22,29{31. However, mag- netic domain wall logic is limited by stochastic eects, particularly when compared to the low error tolerance environment of CMOS computing32,33. Here we propose a methodology where, rather than seeking to eliminate stochastic eects, they become a crucial part of our computing architecture. As a proof of concept, we demonstrate how a nanowire is usable as a stochastic magnetic synapse able to perform handwritten digit recognition using multiplexing of one of the hard- ware synapses. We have developed a learning rule that can eectively train articial neural networks made of such \noisy" synapses by considering the synaptic distribution. Sup- pose we allow a single measurement to identify the state of the synapse. In that case, the learning rule will ad- just its parameter, i.e. the eld at which the wall is propagated, to reduce the synaptic stochasticity. If we allow multiple measurements, the gradient rule will nd parameters that allow for a broad synaptic distribution, mimicking a continuous synapse and improving perfor- mance. Without the stochasticity, the operation wouldarXiv:2303.01886v1 [cs.ET] 3 Mar 2023 Magnetic Stochastic Synapses 2 be limited to binary operations, which lack the resolu- tion power of analogue synapses. With stochasticity, we have a exible system tunable between quick-run- time approximation and long-run-time performance. Our learning rule provides ecient network training despite the high or variable noise environment and diers from other stochastic neural network computing schemes that employ mean-eld-based learning rules14,16,19. Here, the inclusion of the network variance allows the training to nd better solutions in low sampling regimes, providing a trade-o between operational speed/energy cost and test accuracy. We have veried the model performance experimen- tally by transferring the trained weights to a network utilising such a hardware synapse, with excellent agree- ment between the experimental performance and that of a simulated network. Our observations allow for a de- sign framework where we can identify the number of re- quired measurements (and hence energy requirements) for a given desired accuracy and vice versa. This work opens up the prospect of utilising the low-energy-cost benets of spintronic-based logic5{7,34. In particular, it enables the use of domain wall-based nanowire devices24,31,35,36whilst transforming the hith- erto hindrance of noisy operation32,33into the basis of a high-performance stochastic machine learning paradigm. RESULTS Hardware stochastic synapse Our proposed elementary computation unit is a binary stochastic synapse based on a ferromagnetic nanowire with two favourable magnetic orientations. The tran- sitions between regions of diering magnetisation orien- tation are known as domain walls (DWs). While dier- ent forms of DWs exist, here they form a `vortex' pat- tern with a cyclical magnetisation texture. Our synapse was a 400 nm wide, 54 nm thick permalloy nanowire with notches patterned halfway along its length to create an articial defect site. Figure 1.a shows an SEM image of the system, with the inset enlarging the notch. DWs were nucleated at the left-hand side of the wire (false-coloured blue) by applying a voltage pulse across a gold current line (false-coloured orange). The operation of this system as a stochastic synapse is described schematically in gure 1.b. A vortex DW37can be injected into the wire by applying a current pulse in the line. This corresponds to presenting the synapse with an input of 1, while no DW injection corresponds to an input of 0. An applied magnetic eld is used to propagate the DW along the length of the wire. If the propagation eld is suciently high, the DW does not pin at the defect site and can pass to the end of the wire, resulting in an output of 1. If the propagation eld is low, the DW is pinned at the notch, resulting in an output of 0. For intermediate values of the eld, the behaviour becomesstochastic but with a well dened pinning probability. We can consider the eld control as controlling the weight in a binary synapse with detecting a DW on the right hand side of the nanowire as the output of the synapse. As the propagation eld is tuned, the probability of the DW passing changes. Figure 1.c shows this passing prob- ability, as measured using the focused Magneto-Optical Kerr eect (FMOKE), as a function of the propagation eld. The probability of passing behaves in a sigmoid- like manner, and the orange dashed line shows a t using a logistic sigmoid function f(hij) (see methods). Therefore, a binary stochastic synapse is determined by wij=( 1 with probability f(hij) 0 otherwise,(1) wheref(hij) is the DW passing probability function, hij is the propagation eld for the synapse connecting input neuronjwith output neuron i. Through this denition our synapses are purely excitatory, which corresponds to the physical representation of a magnetic DW being pinned or not, rather than the complementary binary scheme with values f

This paper presents a novel learning rule for magnetic stochastic synapses, which allows for weights to be trained that operate better in the low sampling regime compared to the mean-field versions. It covers the use of magnetic stochastic synapses for energy-efficient neuromorphic devices, such as connectionist reinforcement learning, spike-based reinforcement learning, voltage control of domain walls, and more. It also references research studies related to nanomagnetic reservoir computing, reservoir computing with emergent dynamics in a magnetic metamaterial, physical reservoir computing with nanomagnetic devices, and a digital biologically plausible implementation of binarized neural networks with differential hafnium oxide resistive memory arrays. Lastly, the article references the MNIST database of handwritten digits.

MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images Georgios Andreadis Leiden University Medical Center Leiden, The Netherlands G.Andreadis@lumc.nlPeter A.N. Bosman Centrum Wiskunde & Informatica Amsterdam, The Netherlands Peter.Bosman@cwi.nlTanja Alderliesten Leiden University Medical Center Leiden, The Netherlands T.Alderliesten@lumc.nl ABSTRACT Finding a realistic deformation that transforms one image into another, in case large deformations are required, is considered a key challenge in medical image analysis. Having a proper im- age registration approach to achieve this could unleash a number of applications requiring information to be transferred between images. Clinical adoption is currently hampered by many exist- ing methods requiring extensive configuration effort before each use, or not being able to (realistically) capture large deformations. A recent multi-objective approach that uses the Multi-Objective Real-Valued Gene-pool Optimal Mixing Evolutionary Algorithm (MO-RV-GOMEA) and a dual-dynamic mesh transformation model has shown promise, exposing the trade-offs inherent to image reg- istration problems and modeling large deformations in 2D. This work builds on this promise and introduces MOREA: the first evo- lutionary algorithm-based multi-objective approach to deformable registration of 3D images capable of tackling large deformations. MOREA includes a 3D biomechanical mesh model for physical plau- sibility and is fully GPU-accelerated. We compare MOREA to two state-of-the-art approaches on abdominal CT scans of 4 cervical cancer patients, with the latter two approaches configured for the best results per patient. Without requiring per-patient configura- tion, MOREA significantly outperforms these approaches on 3 of the 4 patients that represent the most difficult cases. KEYWORDS deformable image registration, multi-objective optimization, smart mesh initialization, repair method, GOMEA 1 INTRODUCTION In recent decades, the field of radiation oncology has experienced rapid developments. Key to its modern practice are medical images acquired before, during, and after treatment. Although these im- ages are already guiding clinical decision-making in many ways, the transfer of information between multiple images that feature large deformations or content mismatches has proven to be a hard challenge and has eluded widespread clinical adoption. In general, the challenge of Deformable Image Registration (DIR) is to find a realistic transformation that matches two or more image spaces to each other, as illustrated in Figure 1. Given this transformation, other metadata could be transferred between images, such as anno- tated contours [ 30] or 3D radiation dose distributions [ 33], opening up opportunities to make radiation treatment more precise [16]. The DIR problem consists of three main objectives: an image- based objective (for a visual comparison), a contour-based objective (for an assessment of object contour overlap), and a realism-basedobjective (to measure the energy required to perform the defor- mation). These objectives are conflicting, especially when large deformations and content mismatches are at play [ 1]. DIR is there- fore an inherently multi-objective problem, making Evolutionary Algorithms (EAs) well-suited for its optimization [19]. A diverse set of approaches to DIR has emerged [ 5,17,45]. These all take a single-objective approach, requiring the user to choose the weights associated with the optimization objectives for each use, a priori . This can however hinder clinical adoption, since it has been shown that choosing good weights (and other parameters) for specific patients is difficult in general and can strongly influence registration quality [ 36]. Even when configured for the best results, many existing approaches struggle with large deformations and content mismatches between images because of limitations of their underlying transformation models and (often gradient-descent- based) optimization techniques. This shortcoming forms a second obstacle to their translation into clinical workflows. Therefore, there still is a need for a DIR approach that does not require a priori objective weight configuration andcan tackle large deformations. The need to configure objective weights a priori has previously been addressed by taking a multi-objective approach [ 2]. This re- moves the need to select weights for the optimization objectives in a scalarized problem formulation a priori , since a set of solutions can be produced that appropriately represents the trade-off between different conflicting objectives, allowing the user to select a solu- tion from this set, a posteriori . To overcome the second obstacle, a flexible dual-dynamic triangular mesh transformation model that allows for inverse-consistent, biomechanical registration has been introduced [ 3]. This model can match structures on both images to capture large deformations. The Multi-Objective Real-Valued Gene- pool Optimal Mixing Evolutionary Algorithm (MO-RV-GOMEA) has proven to be effective at performing DIR with this model for 2D images by decomposing the problem into local, partial evalu- ations [ 10]. The Graphics Processing Unit (GPU) is exceptionally well-suited to execute these partial evaluations in parallel, yielding (a)Source image (b)Target image (c)Example registration Figure 1: Illustration of two images with large deformations and an example of a deformable image registration with MOREA’s dual-dynamic mesh transformation model.arXiv:2303.04873v1 [cs.CV] 8 Mar 2023 Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten significant speed-ups [ 12]. Recently, first steps have been taken to extend this GPU-accelerated approach to 3D images [ 4], for which the benefits of partial evaluations may be even greater due to the increase in the amount of image information (from 65k pixels in 2D to more than 2 million voxels in 3D), leading to more, but also costlier partial evaluations. While this extended approach has been shown to be capable of solving simple registration problems of sin- gle objects, it misses several crucial components required to tackle clinical problems that feature multiple interacting objects. In this work, we therefore introduce MOREA, the first EA-based Multi-Objective Registration approach capable of registering 3D im- ages with large deformations using a biomechanical model, without requiring a priori configuration of objective weights. In MOREA, a 3D tetrahedral mesh is initialized on interesting structures using a novel custom mesh generation approach, and a repair mechanism for folded meshes is embedded. With MOREA we furthermore im- prove on prior modeling strategies [ 4] for all objectives to ensure desirable deformations will be achieved. 2 DEFORMABLE IMAGE REGISTRATION FOR LARGE DEFORMATIONS In this section, we define the DIR optimization problem (Section 2.1) and examine existing approaches (Section 2.2). 2.1 Problem Definition The problem of DIR for a pair of 2 images is to find a non-rigid transformation 𝑇that deforms a source image 𝐼𝑠to match a tar- get image𝐼𝑡as closely as possible [ 40]. We distinguish between unidirectional andsymmetric registration: in unidirectional registra- tion, only𝑇(𝐼𝑠)≈𝐼𝑡is optimized, while in symmetric registration, 𝑇′(𝐼𝑡)≈𝐼𝑠is also optimized [ 40]. This can improve the physical viability of the registration. Another desirable distinction for reg- istrations is inverse-consistency [40], guaranteeing a one-to-one correspondence between any point in the source image and its corresponding point in the target image. Registrations can generally be evaluated according to three classes of quality metrics. Image intensity metrics compare the pre- dicted voxel intensity values of 𝑇(𝐼𝑠)to the voxel intensity values of𝐼𝑡, using metrics such as cross-correlation or mutual informa- tion [ 26].Contour metrics judge registration accuracy by applying 𝑇to pairs of sets of points, representing contours ( 𝐶𝑠and𝐶𝑡), and computing the distances between those point sets. One example is the Chamfer distance [ 22]: for each pair⟨𝐶𝑠,𝐶𝑡⟩, the longest mini- mum distance is calculated between points in 𝑇(𝐶𝑠)and any point in𝐶𝑡. DIR approaches can also use these contours at initialization time, to build transformation models for use during optimization. Finally, deformation magnitude metrics express registration realism by measuring the force needed to apply the deformation, using a physical model of the image space [ 23]. This can serve as a regular- ization mechanism, discouraging the registration to overfit. 2.2 Related Work These three quality metrics are conflicting objectives that form a trade-off [ 1]. A number of single-objective registration approaches have emerged in recent years, typically attempting to deal with thistrade-off by exploring different objective scalarizations. This how- ever has the downside of having to set objective weights, a priori . We categorize these existing approaches broadly according to the above defined classes of quality metrics, into classes of approaches mainly optimizing for (1) intensity match, (2) contour match, and (3) both matches simultaneously. These and other features are com- pared for selected prominent approaches in Table 1. An example of the first class, optimizing for intensity match, is the Elastix toolbox [ 28]. It uses a B-spline based transformation model, which uses Bézier curves to model physical space. With this model, Elastix optimizes for intensity, regularized by deformation magnitude metrics. While this is a good fit for many applications, we observe that registering more complex, large deformations with local discontinuities (such as studied in this work) can be difficult. The ANTs SyN registration approach [ 5] was conceived to model such large deformations, featuring symmetric, inverse-consistent, and intensity-based registration using time-varying velocity fields. A third intensity-based approach is the Demons algorithm [ 42], us- ing principles from optical flow and Maxwell’s Demons for inverse- consistent registration. A more recent version of this approach also has a mechanism to handle content mismatch between images [ 34]. Both the ANTs and Demons approach can in theory flexibly model large deformations, but lack biomechanical modeling capabilities and only operate on image intensity. This can hamper reliably producing anatomically valid registrations [30]. This is one reason to consider the second class of approaches. One of these approaches is the Thin-Plate Splines Robust Point Matching approach (TPS-RPM), which deforms contours using a thin-plate spline model [ 18]. Subsequent work validated this on an abdominal test case, registering a deforming bladder and two surrounding organs [ 44]. There is also a symmetric version of TPS- RPM, which improves robustness on large deformations [ 8]. Work conducted in parallel also applies a similar model to contours for ab- dominal registration problems [ 39]. While large deformations can be modeled, the biomechanical plausibility of the transformation is not guaranteed, and objective weights still require configuration. Another contour-based approach is MORFEUS [ 17], which registers a mesh representation of imaged objects using a Finite Element Method (FEM) solver. It has shown promising results on brachyther- apy applications in the abdomen [ 37]. Although MORFEUS uses a biomechanical model, which improves realism, it does not take image intensities into account, thus losing detail between object surfaces and relying too heavily on (user-supplied) contours. Recent work has targeted this shortcoming by proposing a com- bined contour-based and image-based approach: the ANAtomically CONstrained Deformation Algorithm (ANACONDA) [ 45] optimizes a fixed scalarization of image and contour terms by using the quasi- Newton algorithm. This approach however lacks biomechanical modeling, and also introduces yet another parameter to configure. Other hybrid attempts have also emerged, such as a combination of the Demons approach with local FEM meshes [ 48], or the use of an image-based registration step to derive tissue elasticities that are later used in an FEM-based registration approach [29]. In general, we see a gap: an approach that includes all registra- tion aspects in one model. As Table 1 shows, we target this gap with MOREA by being both image-based and contour-based, fea- turing biomechanical modeling, and exploiting the multi-objective MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images Feature Elastix [28] ANTs SyN [5] Demons [42] TPS-RPM [18] ANACONDA [45] MORFEUS [17] MOREA (this work) Image-based ✓ ✓ ✓ ✗ ✓ ✗ ✓ Contour-based ✗ ✗ ✗ ✓ ✓ ✓ ✓ Biomechanical ✗ ✗ ✗ ✗ ✗ ✓ ✓ Multi-objective ✗ ✗ ✗ ✗ ✗ ✗ ✓ Table 1: Comparison of selected prominent existing DIR approaches by supported registration features. nature of the DIR problem. These novelties are made possible by the flexibility and robustness of EAs, which are well-suited to op- timize non-differentiable, multi-objective problems. Additionally, the objective functions include millions of image voxel values and are therefore expensive to compute, calling for hardware acceler- ation. Modern model-based EAs such as MO-RV-GOMEA feature excellent GPU compatibility, making them a good fit for optimizing the DIR problem. 3 MO-RV-GOMEA The structure of Black-Box Optimization (BBO) problems only gets revealed through repeated function evaluations. Gray-Box Opti- mization (GBO) problems, on the other hand, have a (partly) known problem structure, which can be exploited during optimization. The GOMEA suite of EAs has proven to be exceptionally well suited for efficiently solving both benchmark and real-world GBO prob- lems [ 41]. Its extension to multi-objective, real-valued problems, MO-RV-GOMEA [ 11], has even found real-world adoption in clini- cal practice for prostate brachytherapy treatment planning [ 7,13]. We give an overview of the key working principles of MO-RV- GOMEA here. A detailed description may be found in literature [ 14]. Non-dominated solutions are preserved across generations in an elitist archive with a pre-specified capacity [ 31]. Each generation starts with the selection of a subset of non-dominated solutions from the current population. This selection is clustered into 𝑘equally sized clusters. For each cluster, MO-RV-GOMEA employs a linkage model that describes dependence relations between variables using a set of dependent variable sets, called Family of Subset (FOS) ele- ments. This linkage model can be learned during optimization in a BBO setting, but in MOREA, we employ a static linkage model based on topological proximity of variables (see Section 4.2.1). Variation then proceeds by considering variables in FOS elements jointly in a procedure called optimal mixing . In this step, distributions are estimated for each FOS element in each cluster, and new, partial solutions are sampled from these distributions. Newly sampled partial solutions are evaluated and accepted if their insertion into the parent solution results in a solution that dominates the parent solution or that is non-dominated in the current elitist archive. 4 APPROACH The approach outlined in this work builds on the recently pro- posed multi-objective approach for 3D images [ 4]. In this section, we present the new techniques we have added, in modeling the problem (Section 4.1), initializing the population of solutions (Sec- tion 4.2), and optimizing the deformations (Section 4.3).4.1 Modeling 4.1.1 Enhancing realism with tissue-specific elasticities. Adjacent work has indicated that using tissue-specific elasticities, instead of assuming one homogeneous elasticity for the entire image re- gion, can enhance the realism of resulting deformations [ 37,46]. Following this insight, we extend the deformation magnitude ob- jective used in existing work [ 4] by computing an elasticity factor for each tetrahedron, based on its underlying image region. Imple- mentation details for this computation are provided in Appendix A. We observe in exploratory experiments that this leads to better registration outcomes (see Appendix Section C.3.1). To compute the deformation magnitude objective, we consider all corresponding edges 𝑒𝑠and𝑒𝑡of each tetrahedron 𝛿∈Δ, be- longing to the mesh on the source image and the mesh on the target image, respectively. This includes 4 spoke edges that better capture flattening motion, giving a total of 10 edges per tetrahedron [ 4]. Given the tetrahedron-specific elasticity constant 𝑐𝛿, the objective is computed as follows: 𝑓magnitude =1 10|Δ|∑︁ 𝛿∈Δ∑︁ (𝑒𝑠,𝑒𝑡)∈𝐸𝛿𝑐𝛿(∥𝑒𝑠∥−∥𝑒𝑡∥)2 4.1.2 Robustly estimating image similarity. The intensity objective we use is defined as a voxel-to-voxel comparison by taking the sum of squared intensity differences, with special handling for compar- isons of foreground (i.e., non-zero intensity) and background (i.e., zero intensity) voxels. We use a random sampling technique that is well-suited for GPU acceleration (defined in detail in Appendix A). Using the set of all sampled image points on both images, 𝑃𝑠and 𝑃𝑡, and image intensities of source image 𝐼𝑠and target image 𝐼𝑡, the objective is defined as follows: 𝑓intensity =1 |𝑃𝑠|+|𝑃𝑡|∑︁ 𝑝𝑠∈𝑃𝑠ℎ(𝑝𝑠,𝑇(𝑝𝑠))+∑︁ 𝑝𝑡∈𝑃𝑡ℎ(𝑝𝑡,𝑇′(𝑝𝑡)) ℎ(𝑝𝑠,𝑝𝑡)=  (𝑝𝑠−𝑝𝑡)2𝑝𝑠>0∧𝑝𝑡>0 0 𝑝𝑠=0∧𝑝𝑡=0 1 otherwise 4.1.3 Approximating the guidance error. In contrast to previous work where an exact guidance measure was used as one of the ob- jectives [ 4], in this work we have opted to introduce a measure that is an approximation thereof that can be much more efficiently com- puted using the GPU-accelerated sampling method that we already use for the calculation of the values for the image similarity objec- tive. Preliminary experiments showed very similar results (when looking at the voxel displacement fields), also because a perfect Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten /gid01748 /gid01748/gid01748 /gid01748 /gid01748/gid01748 /gid01748/gid01748 /gid01748/gid01748/gid01748 /gid01748 (a)The initial configura- tion, with positive area signs for each triangle. /gid01748 /gid01748/gid01748 /gid01748 /gid01748/gid01748 /gid01748/gid01748 /gid01748/gid01748/gid01748 /gid01162(b)The fold, detected by a sign change in the folded (red) triangle. (c)The repair method, resolving the fold by moving the red point. Figure 2: 2D illustration of a mesh configuration with and without a constraint violation (fold). One of the triangles is folded, due to the red point having moved outside the cen- tral triangle, colored yellow. The folded area is colored red. guidance error is not necessarily the best solution. In Appendix A, we provide details regarding the implementation. MOREA’s guidance objective is computed at positions 𝑃𝑠and 𝑃𝑡, using the set 𝐺of all point set pairs ⟨𝐶𝑠,𝐶𝑡⟩𝑖and the minimal point-to-point-set distance 𝑑(𝑝,𝐶). The total number of guidance points is indicated as |𝐺𝑠|and|𝐺𝑡|, and a truncation radius as 𝑟. The guidance objective is now defined as follows: 𝑓guidance =1 |𝑃𝑠|+|𝑃𝑡|∑︁ ⟨𝐶𝑠,𝐶𝑡⟩∈𝐺" |𝐶𝑠| |𝐺𝑠|𝑔(𝑃𝑠,𝑇,𝐶𝑠,𝐶𝑡)+|𝐶𝑡| |𝐺𝑡|𝑔(𝑃𝑡,𝑇′,𝐶𝑡,𝐶𝑠)# 𝑔(𝑃,Φ,𝐶,𝐶′)=∑︁ 𝑝∈𝑃 𝑑(𝑝,𝐶)<𝑟" 𝑟−𝑑(𝑝,𝐶) 𝑟(𝑑(𝑝,𝐶)−𝑑(Φ(𝑝),𝐶′))2# 4.1.4 Rapidly computing constraints. MOREA’s solutions represent meshes with hundreds of points, which can easily get entangled into folded configurations. Such constraint violations should be prevented, to uphold the guarantee of inverse-consistency. Prior work [ 4] used a strategy that proved error-prone in more complex meshes. MOREA includes a novel fold detection method that is based on an observed phenomenon: a mesh fold will cause the sign of at least one tetrahedron’s volume to change, as illustrated in Figure 2 (the figure is in 2D, but this also holds in 3D). Our method uses this phenomenon to detect folds and to measure their severity,opening up repair opportunities (see Section 4.3.1). Implementation details for our method are provided in Appendix A. 4.2 Initialization of Registration Solutions Significant performance gains can be obtained if the initial guesses given to the optimizer are closer to desirable objective space regions than a random guess or grid-like initializations [ 9]. We introduce two techniques that provide such initial guesses. 4.2.1 Exploiting problem structures with mesh initialization. We initialize the meshes to align with objects in the image, adapting an existing method for 2D images [ 9] and expanding it to facilitate parallelization on the GPU. First, we place points on the contours of objects in the source image to capture their shape (see Fig. 3a). We choose these points by greedily taking a spread-out subset from the contour annotations also used for the guidance objective, as well as a small fraction of randomly chosen points across the image. Then, we perform a Delaunay tetrahedralization on these points, using the TetGen suite [ 25] (see Fig. 3b). This yields a mesh that we duplicate to the target image space to complete the dual-dynamic transformation model. As laid out in Section 3, MO-RV-GOMEA evaluates groups of variables (i.e., FOS elements) jointly during variation. Exploratory experiments have shown that using edges as FOS elements (i.e., groups of two connected points, with the variables encoding their coordinates), is beneficial for this problem. If two FOS elements are completely independent because their variables are not needed for the partial evaluation of each set, variation and evaluation for these FOS elements can be done in parallel. We conduct two further steps to facilitate parallel evaluation and optimization on the GPU. First, we execute a greedy set cover algorithm1to find a subset of edges that covers all points (see Fig. 3c), so that each variable (point coordinate) undergoes variation. We could alternatively use all edges, but this would lead to points being included in several FOS sets and thus undergoing variation multiple times per genera- tion. For parallelization purposes, it is more efficient to select an (approximately) minimal set of edges. Given the edge subset found by the set cover, we now determine which FOS elements can be safely optimized in parallel. For this, we build an interaction graph based on topological proximity [ 12], where two elements are connected if their sets of dependent tetra- hedra overlap, i.e., the tetrahedra that are reevaluated when an 1Source: https://github.com/martin-steinegger/setcover (a)Points placed on poten- tially interesting positions. (b)Custom mesh derived from these points. (c)Edges selected for varia- tion through set cover. (d)Interaction graph (blue) between selected edges. (e)Graph coloring computed on interaction graph. Figure 3: 2D illustration of the mesh initialization process, which produces a custom mesh and determines which groups of edges (i.e., FOS elements) can be optimized in parallel. Selected edges are highlighted in red, interaction edges in blue. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images element is changed (see Fig. 3d). Given this graph, parallel groups are created with the DSATUR graph coloring algorithm [ 15] (see Fig. 3e). The dependent tetrahedra of each parallel group can be evaluated in parallel on the GPU, which has been proven to lead to speed-ups of more than 100x on 2D images [12]. Tetrahedral mesh quality can further be improved by specifying surfaces that should be included in the generated mesh. We apply this principle to the bladder by generating a surface mesh using the Marching Cubes algorithm. We then specify its triangular surfaces as constraints to the mesh generation algorithm, ensuring that bladder surface triangles are included in the mesh. Exploratory experiments show superior performance when using this step (see Appendix B.3.1). 4.2.2 Ensuring diversity in initial population. To promote diversity in the initial population, prior work generates random deviations for each point in the mesh, starting at a grid-initialized solution [ 4]. We observe that this method can produce many folded mesh con- figurations in generated solutions, which get discarded and thus hamper convergence speed. In this work, we use a radial-basis- function approach to introduce large deformations free of mesh folds. Implementation details on how these fields are generated and applied to solution meshes are provided in Appendix A. 4.3 Repairing and Steering During optimization, we apply two techniques to improve the qual- ity of solutions obtained, and the time needed to reach them. 4.3.1 Repairing infeasible solutions. By default, infeasible solutions (i.e., solutions with either of the two meshes having one or more folds) are discarded. This, however, can hamper the creation of high-quality offspring, as infeasible solutions may still provide useful information for higher-quality search space regions. We therefore devise a repair method that attempts to reverse folds on a point-by-point basis. For each point in a folded tetrahedron, the method mutates the point using a Gaussian distribution scaled by its estimated distance to the surrounding 3D polygon. After 64 samples, the change with the best constraint improvement is selected, if present. If all samples result in a deterioration, repair is aborted. The repair process for one point is illustrated in Figure 2c. 4.3.2 Applying pressure with adaptive steering. In general, an ap- proximation set should be as diverse as possible while resembling the Pareto set as closely as possible. In practice, however, not all regions of the Pareto front are of equal interest to users. A user con- ducting medical DIR for images with large deformations is typically not interested in solutions with a small deformation magnitude. The user is actually most interested in solutions with good guid- ance objective values, and we would like the algorithm to steer its search towards that region in the objective space. Following earlier work [ 1], we implement an adaptive steering strategy, which steers the front towards high-quality guidance solutions after an explo- ration period of 100 generations. Given the best guidance objective value𝑠𝐺of any solution in the elitist archive, we only preserve solutions with guidance objective values between [𝑠𝐺; 1.5𝑠𝐺], i.e., this becomes a hard constraint.5 EXPERIMENTS We compare MOREA to existing state-of-the-art registration ap- proaches. Due to the complexity of the problem, we do not impose one time limit on all approaches, but rather ensure that they have (reasonably) converged. We repeat all approaches with all configu- rations 5 times, seeded reproducibly. All MOREA registration runs are run on Dell Precision 7920R machines with NVIDIA RTX A5000 GPUs. Additional information on experimental setup and results is provided in the appendix. 5.1 Registration Problems We test all approaches on 4 clinical registration problems with large deformations (see Table 2). We retrospectively select two successive Computerized Tomography (CT) scans of the abdominal area of cervical cancer patients, acquired for radiation treatment planning purposes, with a Philips Brilliance Big Bore scanner. On the first CT scan, the bladder of the patient is filled, and on the second scan, the bladder is empty and thus has shrunken significantly. This large deformation is challenging to register correctly while respecting the surrounding organs (e.g., rectum and bowel) and bony anatomy. Patients 1–3 represent common cases in clinical practice, exhibiting large deformations and little to no margin between bladder and bowel in the full-bladder scan. The bladder of Patient 4 largely preserves its shape and exhibits a wide margin between bladder and bowel, making registration easier. This case, however, is also rarer in practice, and therefore less representative. The axial slices of the CT scans have a thickness of 3 mm, with in-slice resolutions ranging between (0.86,0.86)mm and (1.07,1.07)mm. Each scan is resampled to (1.5,1.5,1.5)mm for consistency. Afterward, each scan pair is rigidly registered (i.e., translated, rotated, or scaled linearly) to align the bony anatomies of both scans, using bone contours delineated by a radiation therapy technologist (RTT). Each pair is cropped to an axis-aligned bounding box surrounding the bladder with a 30 mm margin, taking the maximal bounds from both images. This restricts the registration to the region where treatment was delivered, including the surrounding organs at risk. Contours of key organs in each scan have been annotated by an RTT and verified by a radiation oncologist. The sets of points defining these contours serve as input to the guidance objective of MOREA. We also use these clinical contours to generate binary masks for each organ and the bones by filling 2D polygonal esti- mates formed by contours on each slice. As is common in practice, these contours can overlap, since organs are delineated indepen- dently and are often surrounded by a small safety margin. Registra- tion approaches therefore need to be robust enough to handle this overlap. Several anatomically relevant corresponding landmarks have been annotated by an RTT and verified by a radiation oncolo- gist on both scans, for evaluation purposes (see Appendix D). 5.2 Registration Approaches We consider a number of existing, popular registration approaches for which executable code is available. For these approaches, we follow a two-phase configuration process. First, we explore relevant coarse-grained settings for a single patient scan pair (of Patient 1), Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten Instance Source Target Patient 1 Patient 2 Patient 3 Patient 4 Table 2: Sagittal slices of all registration problems, with or- gans contoured in different colors. to find a suitable configuration for the imaging modality and prob- lem difficulty. Then, we conduct fine-grained configuration on the remaining settings (e.g., objective scalarization weights) for each patient scan pair. We describe the resulting configuration for each approach below, including the general coarse-grained configuration of MOREA. A detailed overview of how we reached these configu- rations, with additional configuration experiments, can be found in Appendix C. 5.2.1 Elastix. We configure Elastix to conduct a regularized, multi- resolution [ 43] image registration. Recommended settings2did not yield satisfactory results on our scans, therefore we first register composite mask images onto each other for each patient. This is used as starting point for optimization on the original image intensities. As a fine-grained configuration step for each patient, we configure the weight assigned to the deformation magnitude 2Based on an official parameter settings database: https://elastix.lumc.nl/modelzoo/objective in a fixed sweep of exponentially increasing weights of [0,0.001,0.01,..., 10.0], as is done in related work [8]. 5.2.2 ANTs SyN. For the ANTs SyN algorithm, the recommended settings3for multi-resolution registration also were not satisfactory, which led us to conduct initial configuration experiments with sev- eral key parameters, listed in Appendix C. We also add a composite mask in an additional image channel that is registered alongside the image. For each patient, we test the same regularization weight of the overall deformation by testing the same weights as for Elastix. 5.2.3 This work: MOREA. MOREA uses a single-resolution ap- proach and is configured to generate a mesh of 600 points (i.e., the problem is 3600-dimensional), using the strategies for mesh gen- eration described in Section 4.2. We set the elitist archive capacity to 2000 and use 10 clusters during optimization, with a runtime budget of 500 generations, during which the EA converges (see Appendix D). As MOREA is a multi-objective approach returning an approximation set of registrations, we do not need to configure it further for each patient. 5.3 Evaluation of Registrations Solutions to complex registration problems, such as the problems in this study, require a multi-faceted evaluation. Below, we outline two main methods for evaluating registrations: surface-based ac- curacy and visual inspection. Additional methods are described in Appendix Section B.2 and applied in Appendices C and D. 5.3.1 Surface-based registration accuracy. A key part of evaluating registration accuracy is to assess how well the surfaces (contours) of objects align [ 16]. We use the Hausdorff distance, which represents the largest minimal distance between any two points on two object surfaces. This can be interpreted as the severity of the worst surface match. To account for potential deformation inaccuracies at the border regions of the image, we discard a margin of 15 mmon each side for the computation of this metric. Since this is smaller than the earlier cropping margin of 30 mm, the bladder and regions around it are left untouched by this second crop. 5.3.2 Visual inspection. Surface-based accuracy analysis is com- plemented by a visual inspection, since a registration with a good contour match can still have undesirable deformations in regions between contours. This inspection includes viewing slices of the target image overlaid with the source contours transformed using the computed forward DVF of the registration. To also inspect the deformation between contours, we also visualize the full deforma- tion: First, we render the DVF itself with a quiver plot. Second, we overlay a regular grid onto a slice and deform it with the DVF, which gives a different perspective. 5.4 Comparison of Registrations All registration solutions from all approaches are compared using the same evaluation pipeline, to ensure a fair comparison. Each approach is configured to output its registrations in the form of a forward and an inverse DVF, which define the deformation on the source and the target image, respectively. Existing approaches either 3Based on technical documentation: https://github.com/ANTsX/ANTs/wiki/Anatomy- of-an-antsRegistration-call MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images (a)Patient 1 (b)Patient 2 (c)Patient 3 (d)Patient 4 Figure 4: A selection of the best predicted deformations for each patient, represented by deformed contours rendered onto the target image with its reference contours (i.e., target in blue). Annotated slices showing all organs are provided in Table 2. (a) Elastix (b) ANTs (c) MOREA Figure 5: Forward deformation vector fields and deformed contours of selected predicted deformations on Patient 1, for all 3 approaches (down-sampled for visibility). Arrow colors represent deformation magnitudes, in voxels (1 voxel =1.5mm). directly or indirectly can be configured to output such DVFs. For MOREA, we rasterize the deformation encoded by the two deformed meshes of a solution, using an existing rasterization method [ 24]. Since we are comparing single-objective approaches to a multi- objective approach (MOREA), we need to select solutions from MOREA’s approximation set. We conduct this a posteriori selection by starting at the solution with the best guidance objective value and manually navigating through the approximation front to find a solution with a good trade-off between contour quality and realism. We also conduct statistical testing using the two-sided Mann- Whitney U test (a standard non-parametric test) to compare MOREA to ANTs and Elastix. The Hausdorff distance of the bladder contour is used as the test metric, as it describes the largest deforming organ. To correct for multiple tests in the pair-wise comparisons, we apply Bonferroni correction to the 𝛼-level and reduce it from 0.05 to 0.025. 6 RESULTS AND DISCUSSION Figure 4 shows selected outcomes from each per-patient fine- grained configuration experiment, along with a solution from MOREA’s approximation front for each patient. For Elastix, we select the runs with regularization weights 1.0, 1.0, 10.0, and 10.0 on Patients 1–4, respectively, and for ANTs, we select all runs with weight 0. The full results of our configuration experiments for bothProblem MOREA vs. Elastix MOREA vs. ANTs Patient 1 0.011 (+) 0.007 (+) Patient 2 0.007 (+) 0.007 (+) Patient 3 0.012 (+) 0.007 (+) Patient 4 0.007 (+) 0.195 ( -) Table 3: p-values of pair-wise comparisons of Hausdorff dis- tances for the bladder between approaches. A plus ( +) indi- cates a better mean with MOREA, a minus ( -) the opposite. Significant results are highlighted. existing approaches can be inspected in Appendix Sections B.1.2 and B.2.2. Convergence plots for Patient 1, which show how all approaches have converged to the results presented here, can be found in Appendix D. As described in Section 5.1, there is an intrinsic difference in difficulty between the scans. In general, we observe MOREA generally outperforming other approaches on the more difficult patients (1–3), as can be seen visually in the deformed contours shown in Figure 4 and in the additional renders and analyses provided in Appendix D. ForPatient 1 , we also render DVF slices in Figure 5, showing the transformation computed for each region of one slice. We observe that the deformations returned by Elastix and ANTs only deform Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten Figure 6: Approximation front produced by MOREA on Pa- tient 1. We render 3 zoomed-in registration solutions. the top region of the bladder. MOREA is the only approach which distributes this deformation across the entire bladder, which is a more realistic deformation in this flexible volume. Figure 6 plots the approximation set that is produced by MOREA on Patient 1, highlighting 3 solutions with slightly different deformations. This illustrates the range of solutions presented to the user, all of which spread the deformation across the bladder. Patient 2 , which features the largest volume change in the blad- der, seems to prove the most difficult: MOREA comes closest to modeling its deformation (see Fig. 4), although this comes at the cost of the bowel also being moved downwards. A probable cause is the little space (i.e., margin) left between the two organs in the source image. Here, MOREA’s result exposes a more fundamental problem that affects all approaches: structures separated by little to no margin in one image cannot be separated in the other image with a transformation model consisting of a single mesh. The change of bladder shape in Patient 3 is less severe than for Patient 2, but still proves challenging for Elastix and ANTs (see Fig. 4). Especially the back region (located left of the image center) does not match the target. Patient 4 represents a relatively easy registration problem, with little change in the shape of the bladder and a clear margin between bladder and bowel (see Fig. 2). On this problem, visual inspection shows that ANTs and MOREA both find a good bladder contour fit, while Elastix struggles with both bladder and bowel. Examining these results quantitatively, we conduct significance tests on the Hausdorff distance of the bladder, listed in Table 3. In all patients, the contour match of the bladder as deformed by MOREA is significantly superior to Elastix’s contour match. ANTs models the contour of the bladder significantly less accurately than MOREA in 3 out of 4 cases, with the fourth case (Patient 4) not having a significantly different result. Appendix D lists significance test results for all organs, which confirm these trends, but also show that MOREA’s Hausdorff distance can sometimes be significantlyhigher than that of ANTs or Elastix. This does not however need to imply worse registration performance, as a qualitative analysis shows. For example, the deformed shape of the sigmoid of Patient 2 found by ANTs is strongly off (see Figure 4). However, its metric value is deemed significantly better than MOREA’s, even though MOREA is closer to the target in terms of general shape. 7 CONCLUSIONS This work uniquely brings multiple lines of research in the field of deformable image registration together. We have introduced a reg- istration approach, MOREA, that is both contour-based and image- based, uses a biomechanical model, and performs multi-objective op- timization. This combination uniquely positions MOREA to tackle challenging 3D image registration problems with large deforma- tions and content mismatches. MOREA was built on the MO-RV- GOMEA model-based evolutionary algorithm with several problem- specific extensions, such as GPU acceleration, solution repair, and object-aligned mesh initialization. Our experiments have shown promising results on 4 cervical cancer patient scans, reaching higher contour registration accuracy than two state-of-the-art approaches on 3 of the 4 patients, representing the most difficult cases. Impor- tantly, the deformation produced by MOREA seems to be more uniformly spread across objects than the deformations produced by existing approaches, which is deemed to be more realistic. Solutions obtained by MOREA still contain local inaccuracies which does leave room for improvement, in particular in regions where organs interface. In fact, the results of this study expose a more fundamental problem in DIR, which is the inability of typical DIR models to capture local discontinuities and content mismatches. This motivates future research into the modeling of independent or- gan motion, following recent work on this topic [ 35,38]. MOREA’s extensible, biomechanical model could be well-positioned for ex- pansions to capture these phenomena. Given such an expanded approach, a larger validation study, with more patients and involv- ing domain experts, could help close the gap to clinical practice. ACKNOWLEDGMENTS The authors thank W. Visser-Groot and S.M. de Boer (Dept. of Ra- diation Oncology, LUMC, Leiden, NL) for their contributions to this study. This research is part of the research programme Open Technology Programme with project number 15586, which is fi- nanced by the Dutch Research Council (NWO), Elekta, and Xomnia. Further, the work is co-funded by the public-private partnership allowance for top consortia for knowledge and innovation (TKIs) from the Dutch Ministry of Economic Affairs. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images A TECHNICAL IMPLEMENTATION DETAILS FOR THE MOREA APPROACH In this appendix, we provide additional technical implementation details for the MOREA approach proposed in Section 4. A.1 Modeling the deformation magnitude MOREA’s deformation magnitude objective models heterogeneous elasticities for different image regions. For each tetrahedron 𝛿, we establish the elasticity of its underlying image region by sampling from object-specific binary masks (see Figure 7). These masks are computed for each object by filling the interior of its contour (avail- able as guidance), yielding a discrete object segmentation. We com- pute the overlap that each object mask has with the tetrahedron 𝛿, which produces one fraction per object. In the example given in Figure 7, this would be a fraction of 0.4 for the object corre- sponding to this mask. These object fractions are multiplied by pre-determined elasticity factors for different tissue types, yielding an overall element-specific factor for 𝛿. At present, only bones and bladder are assigned custom factors. The magnitude objective value for𝛿is multiplied by this factor to better model the actual energy required to deform this image region. A.2 Modeling the image similarity The image intensity objective of MOREA is defined as a sum of squared intensity differences at certain sample points. Modeling the partial objective value of one tetrahedron requires determining which image voxels to sample. The existing prototype [ 4] tries to find all voxels with center points lying inside the tetrahedron, us- ing a line-search-inspired method. We observe, however, that this discrete association of voxels with tetrahedra leads to undesirable behavior around tetrahedral surfaces, with voxels sometimes be- ing associated with multiple or no neighboring tetrahedra. This phenomenon can be used to improve the sampled value while not improving or even deteriorating the true value. In our approach, we therefore introduce a random-sampling based method which samples the image space continuously, in- terpolating intensity values between voxel centers. This is also better-suited for GPU acceleration, since there are less decision points at which execution needs to pause. We uniformly sample 𝑁 points in each tetrahedron using its barycentric coordinate system, with𝑁being determined by the volume of the tetrahedron. For each point, we sample 4 random real numbers 𝑟𝑖∈[0; 1]and take −log(𝑟𝑖)for a uniform spread. We then normalize the coordinates by their sum, to ensure that they lie in the tetrahedron. Instead of a conventional random number generator, we use the Sobol sequence, for a more even spread of sample points. We ensure reproducibility by seeding the Sobol sequence for each tetrahedron with a seed de- rived from its coordinates. Therefore, the same positions are always sampled per tetrahedron configuration. A.3 Modeling the guidance error The guidance error objective of MOREA approximates the contour match of a solution. Previous work [ 4] computes the extent of a contour match by considering each point in 𝐶𝑠and computing the distance of its corresponding version in target space to the closest point in the set 𝐶𝑡. This requires iterating over all points in 𝐶𝑠, Figure 7: 2D illustration of how one tetrahedral element (here: the red triangle) overlaps with the mask of an organ. The computed overlap fractions are used to establish the elasticity factor for this tetrahedron’s deformation magni- tude. (a)Source contour point set. T(ps) 1 1 2 2 3 4 4 5 5 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 8 8 (b)Target contour point set. Figure 8: Two point sets of object contours in a source and target image, with minimal distance maps visualized using isolines. A randomly sampled point 𝑝𝑠is close to the source contour, but the transformed 𝑇(𝑝𝑠)is farther away from the target contour. The yellow shaded area represents the trun- cation area beyond which sampled points are discarded. establishing which tetrahedron they are located in, and computing the transformation at that point. We introduce a new, continuous guidance formulation that approximates point-wise distances and proved to be faster and more robust, in preliminary experiments. During the random sampling process used for the intensity ob- jective on the source image 𝐼𝑠, we also consider the same locations on a distance map of 𝐶𝑠, which gives the closest point to the source contour (see Figure 8). The distance at that point in the map of 𝐶𝑠 is subtracted from the distance at the corresponding point in the map of𝐶𝑡, and weighted inversely by the distance to the source contour. The distances are truncated to a radius around each guid- ance point, measuring 2.5% of the width of the image, so that far away movements do not influence the guidance error of a point set. We normalize the guidance error of each point set by the number of points in that set compared to the total number of guidance points, to counteract biases towards more well-defined or larger contours. A.4 Accurately detecting mesh folds A function detecting constraint violations needs to have high pre- cision (i.e., accurately identify all violations) and low latency (i.e., quickly return its answer). It should furthermore be defined contin- uously, so that the method can also assess the severity of violations. This is important for methods that repair violations. Prior work on mesh-based 3D image registration [ 4] uses a ray- intersection method, testing if a point is inside a so-called bounding Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten Figure 9: A 2D vector field produced by our radial-basis- function approach used to generate solutions. Red dots mark attractors, with their size indicating their weight. polygon. This method has proven error-prone in 3D in preliminary experiments, producing false positives and negatives. We therefore develop a new method for detecting folds in a tetrahedral mesh, based on the signed volumes of its tetrahedra [ 21]. Our method calculates the signed volume of each tetrahedron in the initial mesh configuration, to establish a set of reference signs. When a point is moved, we recalculate the signed volumes of all tetrahedra that this affects and compare them to the respective reference signs. The signs of at least one tetrahedron will flip if a fold has occurred. We use this phenomenon to detect mesh constraint violations and to compute the severity of each violation, using the absolute value of the violating signed volume. A.5 Ensuring diversity in the initial population Even with a smartly initialized mesh, the diversity of the popula- tion at generation 0 plays an important role [ 32]. Prior work uses one reference solution and generates random deviations by sam- pling around each mesh point with increasingly large variance [ 4]. For low-resolution meshes, this method can be effective, but for higher-resolution meshes, this method can lead to many constraint violations in the generated solutions (i.e., folded mesh configura- tions). We introduce a method for initialization noise that generates large deformations free of constraint violations, inspired by ap- proaches using radial basis functions in other domains [ 47]. Our method places a number of Gaussian kernels on both source and target images and models a sense of gravity from mesh points to- wards these kernels. These forces are applied in incremental rounds, as long as they do not cause constraint violations. A deformation vector field generated by this strategy is depicted in Figure 9. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images B EXTENDED PROBLEM SPECIFICATION In this appendix, we provide additional information on the regis- tration problems used in this study and specify additional methods for evaluation and comparison of registration quality. B.1 Additional Problem Information Table 4 lists the in-slice resolutions of the CT scans used. This is the physical resolution of each slice prior to our resampling step to(1.5,1.5)mm. We also provide additional views on each medical image: For each patient, Table 5 lists two slices per source and target image. This provides a useful additional perspective, since some movements are better visible from a different angle. B.2 Additional Evaluation Methods We evaluate each solution with four types of methods, based on (1) surface-based registration accuracy, (2) visual inspection using 2D and 3D visualizations, (3) volume-based registration accuracy, (4) landmark registration accuracy. Method types (1) and (2) have been described in Section 5.3. Here, we give an additional strategy for (1), and outline additional methods (3) and (4). B.2.1 Surface-based registration accuracy. Alternatively to the Hausdorff distance, the 95th percentile of the Hausdorff distance is another indicator we use in our study. This represents the distance for which it holds that 95% of all surface point distances are smaller than this distance. Both Hausdorff and Hausdorff 95th percentile metrics are computed using the pymia PyPI package. B.2.2 Volume-based registration accuracy. Adjacent to surface ac- curacy, we are interested in the accuracy of individual volumes (e.g., organs, bones) represented in the images. A common metric for this is the Dice coefficient, which represents the fraction of volume overlap compared to total volumes. Using binary masks of each annotated object in the images, we compute this metric on a voxel-by-voxel basis. We compare the binary masks corresponding to the target image against binary masks of the source image trans- formed using the computed deformation. With the same reasoning as for surface-based evaluation (see Section 5.3), we discard the same border margin when evaluating volume-based metrics. B.2.3 Landmark registration accuracy. A set of corresponding land- marks not provided to the algorithm during optimization can be used to locally assess the accuracy of a registration. For each pair of landmarks, we transform the source landmark using the forward transformation to target space, and compute landmark accuracy as the Euclidean distance between the transformed source landmark and its corresponding target landmark. This is a common accuracy measure in image registration studies [ 16,20], but can be less accu- rate as an indicator of overall registration quality, since landmarks are placed on visible anatomical structures that often have limited movement, as is the case in our scans.B.3 Comparing Multi-Object Metrics The metrics of individual organs cannot be adequately interpreted in isolation, as organ motions are related and therefore form trade- offs. We visualize these trade-offs by plotting scores for different organs in one parallel coordinates plot, similar to the color-coded heatmap comparison presented in [ 27]. These line plots help inform decisions that need to take registration quality across registration targets into account. Patient Scan In-slice Resolution Patient 1Full bladder (0.86,0.86)mm Empty bladder (0.98,0.98)mm Patient 2Full bladder (1.04,1.04)mm Empty bladder (1.07,1.07)mm Patient 3Full bladder (0.98,0.98)mm Empty bladder (0.98,0.98)mm Patient 4Full bladder (1.04,1.04)mm Empty bladder (1.00,1.00)mm Table 4: In-slice resolutions for the slices of each CT scan, prior to resampling them to (1.5,1.5)mm. Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten Instance Source image: sagittal Target image: sagittal Source image: coronal Target image: coronal Patient 1 Patient 2 Patient 3 Patient 4 Table 5: Slices of all registration problems, with organs contoured. Sagittal: side view; coronal: front-to-back view. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images C CONFIGURATION OF COMPARED APPROACHES C.1 Elastix We use Elastix version 5.0.0. Based on parameter settings from the Elastix Model Zoo4, we apply multi-resolution Elastix registration to our registration problems with a range of configurations, trying to find the optimal configuration for each problem (see Section C.1.3 for our parameter files). Inspired by an approach implementing sym- metric registration in Elastix using a group-wise methodology [ 6], we also experiment with a symmetric variant which registers both images to a common image mid-space. For all setups, we relax con- vergence requirements by increasing the number of iterations per resolution to 10,000, which is significantly larger (5 times) than the computational budget given in most reference files. This is done to give Elastix sufficient opportunity to model the large defor- mations present. We also stabilize optimization by increasing the number of image sampling points from the frequently used 10,000 to 20,000. Although increasing the computational complexity, this should make image intensity approximations used internally during optimization more accurate and computed gradients more reliable. Elastix computes the inverse transform by default, meaning a vec- tor field defined in fixed (target) space leading to moving (source) space. To compute the forward transform, which is needed to trans- form annotations from moving (source) to fixed (target) space, we rerun the registrations with the given parameter files and the com- puted transform as initial transform, but replace the metric(s) with theDisplacementMagnitudePenalty metric. This effectively finds theforward transform of the computed inverse transform. Export- ing this forward transform in isolation, by removing the initial transform pointer from the parameter file, yields the desired DVF. Elastix does not support the optimization of object contour matches, which are optimized by the MOREA approach through the guidance objective. To ensure a fair comparison, we attempt to input this information as a pair of composite mask images to implicitly pass on contour information. Each mask image is made by combining the different binary object masks available for each scan, giving each object segmentation a different homogeneous intensity value. In runs where this feature is enabled, we precede the CT image registration run with a registration of these prepared composite masks. C.1.1 Coarse-grained configuration experiments. First, we conduct an initial set of runs on Patient 1 to establish a suitable base con- figuration for this problem modality and difficulty. We explore the influence of registration direction (unidirectional vs. symmetric) and the use of a composite mask registration step (with vs. without), assuming a regularization weight of 0.001, to give Elastix flexibility for large deformations (a large weight on the deformation magni- tude weight can hinder large deformations). In Figure 10, we plot the performance of Elastix using symmet- ric and unidirectional registration, reporting two different metrics (Dice score and 95th percentile of the Hausdorff distance). We ob- serve that unidirectional registration generally performs similarly or better compared to symmetric registration, except for the rec- tum and anal canal, in terms of Dice score. Due to the relatively 4https://elastix.lumc.nl/modelzoo/ (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 10: Comparison of symmetric and unidirectional reg- istration in Elastix, for multiple runs. The baseline score af- ter rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 11: Visual renders of deformations predicted by Elastix configurations using unidirectional and symmetric registration, without mask registration step. large performance gain in the bladder (the most strongly deforming organ), we choose unidirectional registration at this point. This choice is supported by visual inspection of Figure 11, which shows slightly better performance on the bladder in the coronal slice. We now turn to the use of a composite mask registration step, in an attempt to get larger deformations by simplifying the informa- tion input to Elastix. Figure 12 shows the same metrics, but with Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 12: Comparison of unidirectional registration with and without a composite mask registration step in Elastix, for multiple runs. The baseline score after rigid registration is plotted in blue. and without the use of such a step (while using unidirectional reg- istration). The results do not identify one clear superior approach, since the Dice score of the with-mask configuration is generally superior but the Hausdorff 95th percentile is lower for the without- mask configuration. Figure 13 indicates that adding a mask step improves the modeling of the base region of the bladder, but the middle region is merely contracted sideways without moving the top region downwards, thereby not resulting in anatomically real- istic deformations. Nevertheless, we choose this version over the version without mask registration step, since the large deformation needed is modeled more closely with the step added. C.1.2 Fine-grained configuration experiments per patient. For each patient, we try exponentially increasing regularization weights; an exponential regularization weight sweep that is also used in similar work [ 8]. The Dice scores on each patient are reported in Figure 14 and the 95th percentiles of the Hausdorff distance in Figure 15. Renders for each problem are provided in Figures 16–19. We observe that the optimal regularization weight varies strongly between different registration problems. While the scans of Patient 1 (Fig. 16) are best served with a weight of 1.0 out of the tried settings, the scans of Patient 3 (Fig. 18) seem better off with a weight of 10.0. (a) Sagittal slice. (b) Coronal slice. Figure 13: Visual renders of deformations predicted by Elastix configurations with and without a composite mask registration step, using unidirectional registration. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images (a) Patient 1. (b) Patient 2. (c) Patient 3. (d) Patient 4. Figure 14: Dice scores for per-patient fine-grained configuration runs in Elastix. The baseline score after rigid registration is plotted in blue. (a) Patient 1. (b) Patient 2. (c) Patient 3. (d) Patient 4. Figure 15: Hausdorff 95th percentiles for per-patient fine-grained configuration runs in Elastix. The baseline score after rigid registration is plotted in blue. Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten (a) Sagittal slice. (b) Coronal slice. Figure 16: Visual renders of deformations predicted by Elastix with different regularization weights, on Patient 1. (a) Sagittal slice. (b) Coronal slice. Figure 17: Visual renders of deformations predicted by Elastix with different regularization weights, on Patient 2. (a) Sagittal slice. (b) Coronal slice. Figure 18: Visual renders of deformations predicted by Elastix with different regularization weights, on Patient 3. (a) Sagittal slice. (b) Coronal slice. Figure 19: Visual renders of deformations predicted by Elastix with different regularization weights, on Patient 4. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images C.1.3 Parameter files. Below, we list the parameter files that we used for the different variants of Elastix registration. Tokens starting with the $character denote variables that are resolved before we pass the file to Elastix (e.g., a random seed that we increment at every repeat). Listing 1: Forward transform parameters for conventional, unidirectional deformation. // ImageTypes (FixedImagePixelType "short") (FixedImageDimension 3) (MovingImagePixelType "short") (MovingImageDimension 3) // Multi resolution (Registration "MultiMetricMultiResolutionRegistration") (HowToCombineTransforms "Compose") (NumberOfHistogramBins 32) (NumberOfResolutions 4) (MaximumNumberOfIterations 10000) // Optimizer (Optimizer "AdaptiveStochasticGradientDescent") (AutomaticParameterEstimation "true") (UseAdaptiveStepSizes "true") (CheckNumberOfSamples "true") (UseDirectionCosines "true") (RandomSeed $random_seed) // Metric (Metric "AdvancedMattesMutualInformation" "TransformBendingEnergyPenalty") (Metric0Weight 1.0) (Metric1Weight $regularization_weight) // Components (FixedImagePyramid "FixedSmoothingImagePyramid") (MovingImagePyramid "MovingSmoothingImagePyramid") (Interpolator "BSplineInterpolator") (ResampleInterpolator "FinalBSplineInterpolator") (Resampler "DefaultResampler") (Transform "BSplineTransform") // Transform (FinalGridSpacingInPhysicalUnits 2.0) // Sampling (ImageSampler "RandomCoordinate") (NewSamplesEveryIteration "true") (NumberOfSpatialSamples 20000) // Interpolation and resampling (BSplineInterpolationOrder 1) (FinalBSplineInterpolationOrder 3) (DefaultPixelValue 0) // Output and other (WriteTransformParametersEachIteration "false" "false" "false" "false" "false") (WriteTransformParametersEachResolution "true" "true" "true" "true" "true") (ShowExactMetricValue "false" "false" "false" "false" "false") (WriteResultImageAfterEachResolution "false") (WriteResultImage "true") (ResultImagePixelType "short") (ResultImageFormat "nii.gz")Listing 2: Forward transform parameters for symmetric de- formation. // ImageTypes (FixedImagePixelType "short") (FixedInternalImagePixelType "short") (FixedImageDimension 4) (MovingImagePixelType "short") (MovingInternalImagePixelType "short") (MovingImageDimension 4) // Multi resolution (Registration "MultiResolutionRegistration") (HowToCombineTransforms "Compose") (NumberOfHistogramBins 32) (NumberOfResolutions 4) (MaximumNumberOfIterations 10000) (MaximumNumberOfSamplingAttempts 10) // Optimizer (Optimizer "AdaptiveStochasticGradientDescent") (AutomaticParameterEstimation "true") (UseAdaptiveStepSizes "true") (CheckNumberOfSamples "true") (UseDirectionCosines "true") (RandomSeed \$random_seed) // Metric (Metric "$metric") (NumEigenValues 1) (TemplateImage "ArithmeticAverage" "ArithmeticAverage") (Combination "Sum" "Sum") (SubtractMean "true") (MovingImageDerivativeScales 1.0 1.0 1.0 0.0) // Components (FixedImagePyramid "FixedSmoothingImagePyramid") (MovingImagePyramid "MovingSmoothingImagePyramid") (ImagePyramidSchedule 8 8 8 0 4 4 4 0 2 2 2 0 1 1 1 0) (Interpolator "ReducedDimensionBSplineInterpolator") (ResampleInterpolator "FinalReducedDimensionBSplineInterpolator") (Resampler "DefaultResampler") (Transform "BSplineStackTransform") // Transform (FinalGridSpacingInPhysicalUnits 2.0) // Sampling (ImageSampler "RandomCoordinate") (NewSamplesEveryIteration "true") (NumberOfSpatialSamples 20000) // Interpolation and resampling (BSplineTransformSplineOrder 1) (FinalBSplineInterpolationOrder 3) (DefaultPixelValue 0) // Output and other (WriteTransformParametersEachIteration "false" "false" "false" "false") (WriteTransformParametersEachResolution "true" "true" "true" "true") (ShowExactMetricValue "false" "false" "false" "false") (WriteResultImageAfterEachResolution "false") (WriteResultImage "true") (ResultImagePixelType "short") (ResultImageFormat "nii.gz") Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten C.2 ANTs SyN We use ANTs SyN algorithm version 2.4.2. We bootstrap a regis- tration command using the antsRegistrationSyN.sh script and customize it to fit our problem (see Section C.2.3 for our run com- mands). Following official recommendations5, we consider the fol- lowing settings to be left tunable for this problem: (1) what region radius to use for the cross correlation metric, (2) whether to use composite masks as an additional image modality channel during registration, (3) what gradient step size to use, (4) what regular- ization weight to assign to local deformations between time steps, and (5) what regularization weight to assign to the total deforma- tion. We configure the first four parameters for Patient 1, and then configure the fifth parameter for each patient, separately. In our setup, we relaxed convergence limits compared to guide- lines to allow for longer, and hopefully more accurate registration. In terms of metrics, we do not use the point set registration metric that is mentioned in the manual, as the manual states that this metric is not currently supported in ANTs SyN. We encountered that ANTs SyN random seed does not have any effect on the outcome of registration with the Cross Correlation (CC) measure, even with a random sampling strategy. The current version seems fully deterministic, but without taking the random seed into account, therefore always producing the same output, regardless of the seed. This is problematic, since we would like to get multiple outputs that expose how the registration approach reacts to slightly varying inputs. To mitigate the lack of control on the determinism of the registration, we slightly perturb the sigma smoothing factors (see Listing 3) with very small (deterministically random) deltas. Δ3is normally distributed and capped between [−0.1,0.1],Δ2between[−0.05,0.05], andΔ1between[−0.01,0.01]. C.2.1 Coarse-grained configuration experiments. We conduct an initial set of coarse-grained configuration experiments on Patient 1 with the ANTs SyN algorithm. The officially recommended set- tings serve as our baseline: a cross-correlation radius of 4 voxels, a gradient step size of 0.1, registration of only the image itself (no additional channels), and an update regularization weight of 3.0. For each of these settings, we experiment with different deviations from the baseline. Cross correlation radius First, we investigate the impact of a different cross correlation radius. Larger values should improve registration accuracy, since more context information is taken into account when computing the cross correlation of a sample. Figure 20 con- firms this expectation, although it shows little impact overall. Most organs show little deviation in score, but the anal canal is registered more accurately in terms of Dice score when the radius is increased. We observe that there are diminishing returns here, e.g., a change of radius from 7 to 8 provides only marginal improvement. Still, we decide to use the largest setting tested (8 voxels, meaning 12 mm in the case of the clinical problems), since this setting provides the best outcome and there is no time limit on registration in our study. The visual render in Figure 21 shows the visual impact of this setting, which can be described as limited. 5https://github.com/ANTsX/ANTs/wiki/Anatomy-of-an-antsRegistration-call (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 20: Comparison of registrations with different region radii for the ANTs cross correlation metric. The baseline score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 21: Visual renders of deformations predicted by ANT configurations with different CC radii. Composite mask channel Second, we explore the effect of including a composite mask image channel during registration. Figure 22 provides evidence that including a mask channel has added value in terms of Dice score for registration of all organs. The difference in performance is only slightly visible in Figure 23, but the difference in metric values motivates our decision to use a mask channel in the upcoming patient-specific configuration steps. Gradient step size Third, we examine the impact of using a different gradient step size on the registration performance of ANTs. A MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 22: Comparison of registrations with and without a composite mask channel in ANTs. The baseline score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 23: Visual renders of deformations predicted by ANT configurations with and without a composite mask channel. larger step size between time points in ANTs’ registration could lead to larger deformations becoming feasible, since optimization is less likely to get stuck in local minima. Figure 24 indicates that choosing a larger step size than the recommended value of 0.1 can be beneficial, with 1.0 providing a good trade-off for different organs. Larger step sizes such as 5.0 cause the algorithm to overshoot the target and strongly deform a number of organs, as can be seen in the contour renders (Figure 25). We choose a gradient step size of 1.0 for its good trade-off between performance targets. Update regularization weight Finally, we use the deduced settings from the previous three sweeps to test which update regularization (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 24: Comparison of ANTs registrations with different gradient step sizes between time points. The baseline score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 25: Visual renders of deformations predicted by ANT configurations with different gradient step sizes. weight performs best. Figure 26 shows best overall performance for 4.0, in both metrics. Visually, Figure 27 indicates that weights 4.0 and 5.0 lead to the best registration outcomes, with little visible difference between the two. Based on visual and quantitative results, we choose an update regularization weight of 4.0 for the patient- specific configuration experiments. C.2.2 Fine-grained configuration experiments per patient. We try exponentially increasing total regularization weights for all prob- lem instances. Figures 28 and 29 plot the Dice scores and Hausdorff 95th percentiles for each problem instance, and Figures 30–33 show Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 26: Comparison of ANTs registrations with differ- ent update regularization weights between time points. The baseline score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 27: Visual renders of deformations predicted by ANT configurations with different update regularization weights. renders of the deformed contours that ANTs predicts for these in- stances. We observe that regularization has a strong impact on per- formance in all examined cases, but that often the (relatively) better outcomes are still acquired without regularization. Figures 30–32 show ANTs failing to model the large deformation taking place in the bladder and its surrounding organs, regardless of the regular- ization. The Dice and Hausdorff metric results underscore these observations. In Figure 33, ANTs shows that it can model the blad- der deformation quite closely, but it should be noted that this is morphologically also the easiest problem.C.2.3 Run commands. We list the two commands that we used for registration with ANTs. Tokens starting with the $character denote variables that are resolved before we execute these commands. Note that the random seed, even though given to the command, is not functional and does not change the output. Listing 3: ANTs registration command for multivariate reg- istration with composite masks. $ANTSPATH/antsRegistration --verbose 1 --random-seed $random_seed --dimensionality 3 --float 0 --collapse-output-transforms 1 --output [ , Warped.nii.gz, InverseWarped.nii.gz ] --interpolation Linear --use-histogram-matching 0 --winsorize-image-intensities [ 0.005, 0.995 ] --initial-moving-transform [ $fixed_composite_mask, $moving_composite_mask, 1 ] --transform SyN[ $gradient_step_size, $update_regularization_weight, $total_regularization_weight ] --metric CC[ $fixed_composite_mask, $moving_composite_mask, 1, $cross_correlation_radius ] --metric CC[ $fixed_image, $moving_image, 1, $cross_correlation_radius ] --convergence [ 2000x1000x500x250, 1e-6, 10 ] --shrink-factors 8x4x2x1 --smoothing-sigmas {3+delta_3}x{2+delta_2}x{1+delta_1}x0vox Listing 4: ANTs registration command for multivariate reg- istration without composite masks. $ANTSPATH/antsRegistration --verbose 1 --random-seed $random_seed --dimensionality 3 --float 0 --collapse-output-transforms 1 --output [ , Warped.nii.gz, InverseWarped.nii.gz ] --interpolation Linear --use-histogram-matching 0 --winsorize-image-intensities [ 0.005, 0.995 ] --initial-moving-transform [ $fixed_image, $moving_image, 1 ] --transform SyN[ $gradient_step_size, $update_regularization_weight, $total_regularization_weight ] --metric CC[ $fixed_image, $moving_image, 1, $cross_correlation_radius ] --convergence [ 2000x1000x500x250, 1e-6, 10 ] --shrink-factors 8x4x2x1 --smoothing-sigmas {3+delta_3}x{2+delta_2}x{1+delta_1}x0vox MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images (a) Patient 1. (b) Patient 2. (c) Patient 3. (d) Patient 4. Figure 28: Dice scores for per-patient fine-grained configuration runs in ANTs, with the baseline after rigid registration in blue. (a) Patient 1. (b) Patient 2. (c) Patient 3. (d) Patient 4. Figure 29: Hausdorff 95th percentiles for per-patient fine-grained configuration runs in ANTs, with the baseline after rigid registration in blue. Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten (a) Sagittal slice. (b) Coronal slice. Figure 30: Visual renders of deformations predicted by ANTs with different total regularization weights, on Patient 1. (a) Sagittal slice. (b) Coronal slice. Figure 31: Visual renders of deformations predicted by ANTs with different total regularization weights, on Patient 2. (a) Sagittal slice. (b) Coronal slice. Figure 32: Visual renders of deformations predicted by ANTs with different total regularization weights, on Patient 3. (a) Sagittal slice. (b) Coronal slice. Figure 33: Visual renders of deformations predicted by ANTs with different total regularization weights, on Patient 4. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images C.3 This Work: MOREA We describe several coarse-grained configuration experiments that we conducted with MOREA on Patient 1. The base parameter file we derived from these experiments can be found in Section C.3.2. We do not conduct fine-grained configuration steps, since MOREA is a multi-objective approach. For MOREA’s guidance objective, we perform an additional pre- processing step on each scan, to address the discrepancy between resolutions in different dimensions. The initial resampling step bringing each scan to a uniform voxel resolution of 1.5 mmleads to the between-slice dimension being over-sampled (originally, slices are 3 mm apart). Contour annotations are placed only on slices, which means that the new slices added by resampling to 1.5 mm, between original slices, do not have contour information. These slice “gaps” in the contours of objects can be exploited during optimization. We address this with an intermediate step, building a 3D model of each object across slices and generating border points from this model. C.3.1 Coarse-grained configuration experiments. Heterogeneous elasticity In Section 4.1, we describe a model that enables capturing biomechanical properties of different tissue types in the deformation magnitude objective. The core principle of this biomechanical model is to ascribe heterogeneous elasticities to different regions of image space, corresponding with objects (e.g., organs and bones) present. In this first configuration experiment, we compare the performance of this model with the performance of the model which is used by prior work [ 4], assuming homogeneous elasticity of image space. This experiment was conducted without a contour on the body, later experiments do have this contour. The metric results in Figure 34 indicate that the heterogeneous model generally receives higher Dice scores and similar Hausdorff 95th percentiles. Figure 35 shows renderings of selected solutions with the heterogeneous and homogeneous models, which confirm this trend. We observe in both slices that heterogeneous elasticity especially shows improved performance on the bladder deforma- tion, potentially due to the increased elasticity that this models assigns to the bladder. Mesh generation Using the biomechanical model that experiments in the previous subsection covered, we now investigate the impact of different mesh point placement strategies. The strategy used to create meshes from these points is described in Section 4.2.1. In this experiment, compare how well a random (Sobol-sequence based) placement compares to a contour-based strategy where points are sampled per contour and a contour-based strategy which has special handling for the bladder’s surface. Figure 36a shows the bladder being modeled best by the last strategy, with contour-based strategies in general performing better than random, across organs. The renders in Figure 37 indicate that a random placement method can model the general deformation, but is too coarse to accurately treat details of specific organs and parts of the bones. Both contour- based strategies perform well, but around the bladder’s surface, the strategy with special surface constraints excels. Supplying guidance information The multi-objective line of reg- istration approaches, which MOREA continues, can have a third (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 34: Comparison of the use of heterogeneous elas- ticities in the deformation magnitude objective of MOREA against the prior use of a homogeneous elasticity model, for multiple runs. The baseline score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 35: Visual renders of deformations predicted by MOREA with a heterogeneous elastic deformation model and a homogeneous model. objective that captures guidance (contour) match. In this experi- ment, we assess what the impact of this objective is on the quality of registrations. The quantitative results in Figure 38 leave little doubt that the adoption of a guidance objective is crucial to modeling large defor- mations. Without it, the bladder remains largely in place, as can be seen in Figure 39. It seems that in this problem, image information is not sufficient to guide the optimization. Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 36: Comparison of different mesh point placement strategies, for multiple runs. The baseline score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 37: Visual renders of deformations predicted by MOREA with different mesh point placement strategies. (a) Dice scores. (b) 95th percentiles of the Hausdorff distance. Figure 38: Comparison of MOREA registrations with and without guidance information, for multiple runs. The base- line score after rigid registration is plotted in blue. (a) Sagittal slice. (b) Coronal slice. Figure 39: Visual renders of deformations predicted by MOREA with and without guidance enabled. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images C.3.2 Parameter file. We pass parameters to MOREA in a self- written parameter file format. Below we list the parameter file used as basis for the experiments listed in this work. Listing 5: Parameter file used as basis for the main MOREA experiments. sweep_descriptor = "$experiment_descriptor" num_runs = 5 problem_id = "$problem_id" zip = true problem_guidance_enabled = true problem_guidance_selection = "-1" cuda_compute_level = 80 cuda_gpu_id = 0 ea_num_generations = 500 ea_population_size = 700 ea_num_clusters = 10 ea_archive_size = 2000 ea_adaptive_steering_enabled = true ea_adaptive_steering_activated_at_num_generations = 100 ea_adaptive_steering_guidance_threshold = 1.5 morea_init_noise_method = "global-gaussian" morea_init_noise_factor = 1.0 morea_mesh_generation_method = "annotation-group-random-bladder-10" morea_mesh_num_points = 600 morea_max_num_mesh_levels = 1 morea_num_generations_per_level = 0 morea_magnitude_metric = "biomechanical" morea_image_metric = "squared-differences" morea_guidance_metric = "continuous-per-group" morea_sampling_rate = 1.0 morea_fos_type = "edges" morea_symmetry_mode = "transform-both" morea_dual_dynamic_mode = "dual" morea_repair_method = "gaussian" morea_ams_strategy = "none" morea_num_disruption_kernels = 0 morea_disruption_frequency = 0 Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten D FULL EXPERIMENTAL RESULTS In this appendix, we list more extensive results of the experiments presented in Section 6. Figure 40 and 41 give full metric results for all patients, comparing the three approaches with parallel coordinate plots. Table 6 lists significance test results for all organ Hausdorff distances. A visual perspective is provided by Table 8, which shows an additional slice per patient, overlaid with the predicted deforma- tions. Below, we analyze convergence behavior (Section D.1) and landmark performance (Section D.2). D.1 Convergence Behavior We plot the convergence behavior of each approach on Patient 1 in Figure 42 to show how each approach has converged before yielding the results we show here. Elastix and ANTs both have a multi-resolution approach. To deal with the discontinuities in multi-stage resolution, we mark resolution switches in those plots with red vertical lines. Our configuration of Elastix also has a mask registration step, meaning that there are in total 8 segments (4 reso- lutions of mask registration and 4 resolutions of image registration). The scaling of the value to be optimized is not always normalized across resolutions, which explains the jumps in value ranges be- tween resolutions. Note that ANTs uses a separate “convergence value” to determine when it has converged, plotted in Figure 42d. For MOREA, we plot the achieved hypervolume and the best guid- ance objective value achieved. The sudden decrease in hypervolume at generation 100 is related to the adaptive steering strategy used, which purges any solutions with unfavorable guidance objective values from the elitist archive. D.2 Landmark Accuracy We list landmark registration accuracy on all 4 patients in Table 7. We aggregate all errors of all landmarks across repeats for one pa- tient and approach, and compute the mean and standard deviation on this sample set. Since these landmarks are generally placed on visible, anatomically stable locations, and typically not in strongly deforming regions, this accuracy should be interpreted as a measure of how well the method preserves certain anatomical structures. This measure is therefore less suitable as a measure of how well the registration problem is “solved”, for which visual (DVF and rendered) inspection is still key. For some landmarks, the precise lo- cation can be ambiguously defined or less visible on certain patients. These landmarks are, however, still accurately placeable between scans by using the visual context they are situated in and taking consistent placement decisions for each pair of scans. Generally, we observe that Elastix performs worse than ANTs and MOREA, and MOREA always improves or roughly maintains the baseline landmark registration error. We do not see a consis- tent correlation between actual registration performance on large deforming objects and target registration error values, due to the aforementioned reasons.Problem Contour MOREA / Elastix MOREA / ANTs Patient 1bladder 0.011 (+) 0.007 (+) bones 0.009 (+) 0.006 (+) rectum 0.007 (+) 0.007 (+) anal canal 0.007 (+) 0.007 (+) sigmoid 0.007 (+) 0.007 (+) bowel 0.010 (+) 0.011 (+) body 0.006 (+) 0.006 (-) Patient 2bladder 0.007 (+) 0.007 (+) bones 0.007 (+) 0.007 (+) rectum 0.118 (+) 0.007 (-) anal canal 0.123 (-) 0.180 (-) sigmoid 0.007 (+) 0.007 (-) bowel 0.401 (+) 0.007 (+) body 0.655 (+) 1.000 (-) Patient 3bladder 0.012 (+) 0.007 (+) bones 0.007 (+) 0.007 (+) rectum 0.290 (+) 0.007 (-) anal canal 0.118 (-) 0.007 (+) sigmoid 0.007 (+) 0.007 (+) bowel 0.007 (+) 0.056 (+) body 0.007 (+) 0.118 (+) Patient 4bladder 0.007 (+) 0.195 (-) bones 0.007 (-) 0.007 (-) rectum 0.010 (-) 0.007 (-) anal canal 0.606 (+) 0.007 (-) sigmoid 0.009 (+) 0.118 (+) bowel 0.119 (+) 0.119 (-) body 0.020 (-) 0.020 (-) Table 6: p-values of pair-wise comparisons of Hausdorff dis- tances for all contours between approaches, computed by the two-sided Mann-Whitney U test. A plus ( +) indicates a better mean with MOREA, a minus ( -) the opposite. Signifi- cant results are highlighted according to an 𝛼of 0.025. Problem Baseline Elastix ANTs MOREA Patient 1 4.8 ±3.1 5.6±2.8 4.2±2.0 4.8±2.0 Patient 2 7.5 ±4.0 11.8±7.3 7.7±4.3 7.8±3.8 Patient 3 9.5 ±6.7 6.4±2.0 7.7±2.6 6.5±1.9 Patient 4 14.1 ±9.5 8.1±4.3 6.3±3.4 6.8±4.0 Table 7: Target registration errors (mean and standard devi- ation) for the shown registrations of each approach on each patient, across repeats. All errors are specified in mm. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images Instance Transformed: sagittal Transformed: coronal Patient 1 Patient 2 Patient 3 Patient 4 Table 8: A selection of the best predicted deformations of the compared registration approaches, represented by deformed contours compared to the target contours and image. Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten (a) Patient 1. (b) Patient 2. (c) Patient 3. (d) Patient 4. Figure 40: Dice scores for all approaches on all patients. The baseline score after rigid registration is plotted in blue. (a) Patient 1. (b) Patient 2. (c) Patient 3. (d) Patient 4. Figure 41: Hausdorff distances for all approaches on all patients. The baseline score after rigid registration is plotted in blue. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images 0 10000 20000 30000 40000 50000 60000 70000 80000 Iterations2.12.01.91.81.71.61.51.41.31.2Objective value (a) Elastix: objective value at each iteration. 0 10000 20000 30000 40000 50000 60000 70000 80000 Iterations2.12.01.91.81.71.61.51.4Objective value (b) Elastix: best objective value achieved at each point. 0 10 20 30 40 50 60 70 80 Time steps0.960.940.920.900.880.860.840.820.800.78Objective value (c) ANTs: objective value at each iteration. 0 10 20 30 40 50 60 70 80 Time steps0.0020.0000.0020.0040.0060.0080.010Convergence value (d) ANTs: convergence measure at each iteration. 0 100 200 300 400 500 Generations1015202530354045Hypervolume (e) MOREA: hypervolume at each generation. 0 100 200 300 400 500 Generations0.00.10.20.30.40.5Guidance error (f) MOREA: best guidance objective value found at each generation. Figure 42: Convergence plots for all 3 approaches on one run of Patient 1. Vertical red lines indicate a change of resolution. For ANTs, this leads to 4 optimization segments. For Elastix, we first run a mask registration step (with 4 segments) and then an image registration step (with again 4 segments). Georgios Andreadis, Peter A.N. Bosman, and Tanja Alderliesten REFERENCES [1]T. Alderliesten, P. A. N. Bosman, and A. Bel. 2015. Getting the most out of additional guidance information in deformable image registration by leveraging multi-objective optimization. In SPIE Medical Imaging 2015: Image Processing . 94131R. [2]T. Alderliesten, J. J. Sonke, and P. A. N. Bosman. 2012. Multi-objective optimization for deformable image registration: proof of concept. In SPIE Medical Imaging 2012: Image Processing , Vol. 8314. 831420. [3]T. Alderliesten, J. J. Sonke, and P. A. N. Bosman. 2013. Deformable image reg- istration by multi-objective optimization using a dual-dynamic transformation model to account for large anatomical differences. In SPIE Medical Imaging 2013: Image Processing , Vol. 8669. 866910. [4]G. Andreadis, P. A. N. Bosman, and T. Alderliesten. 2022. Multi-objective dual simplex-mesh based deformable image registration for 3D medical images - proof of concept. In SPIE Medical Imaging 2022: Image Processing . 744–750. [5]B. B. Avants, C. L. Epstein, M. Grossman, and J. C. Gee. 2008. Symmetric dif- feomorphic image registration with cross-correlation: Evaluating automated labeling of elderly and neurodegenerative brain. Medical Image Analysis 12, 1 (2008), 26–41. [6]F. Bartel, M. Visser, M. de Ruiter, J. Belderbos, F. Barkhof, H. Vrenken, J. C. de Munck, and M. van Herk. 2019. Non-linear registration improves statistical power to detect hippocampal atrophy in aging and dementia. NeuroImage: Clinical 23 (2019), 101902. [7]D. L. J. Barten, B. R. Pieters, A. Bouter, M. C. van der Meer, S. C. Maree, K. A. Hinnen, H. Westerveld, P. A. N. Bosman, T. Alderliesten, N. van Wieringen, and A. Bel. 2023. Towards artificial intelligence-based automated treatment planning in clinical practice: A prospective study of the first clinical experiences in high-dose-rate prostate brachytherapy. Brachytherapy In Press (2023). [8]L. Bondar, M. S. Hoogeman, E. M. Vásquez Osorio, and B. J.M. Heijmen. 2010. A symmetric nonrigid registration method to handle large organ deformations in cervical cancer patients. Medical Physics 37, 7 (2010), 3760–3772. [9]P. A. N. Bosman and T. Alderliesten. 2016. Smart grid initialization reduces the computational complexity of multi-objective image registration based on a dual-dynamic transformation model to account for large anatomical differences. InSPIE Medical Imaging 2016: Image Processing . 978447. [10] A. Bouter, T. Alderliesten, and P. A. N. Bosman. 2017. A novel model-based evolutionary algorithm for multi-objective deformable image registration with content mismatch and large deformations: benchmarking efficiency and quality. InSPIE Medical Imaging 2017: Image Processing , Vol. 10133. 1013312. [11] A. Bouter, T. Alderliesten, and P. A. N. Bosman. 2021. Achieving highly scal- able evolutionary real-valued optimization by exploiting partial evaluations. Evolutionary Computation 29, 1 (2021), 129–155. [12] A. Bouter, T. Alderliesten, and P. A. N. Bosman. 2021. GPU-Accelerated Par- allel Gene-pool Optimal Mixing applied to Multi-Objective Deformable Image Registration. In IEEE Congress on Evolutionary Computation . 2539–2548. [13] A. Bouter, T. Alderliesten, B. R. Pieters, A. Bel, Y. Niatsetski, and P. A. N. Bosman. 2019. GPU-accelerated bi-objective treatment planning for prostate high-dose- rate brachytherapy. Medical Physics 46, 9 (2019), 3776–3787. [14] A. Bouter, N. H. Luong, C. Witteveen, T. Alderliesten, and P. A. N. Bosman. 2017. The multi-objective real-valued gene-pool optimal mixing evolutionary algorithm. InProceedings of the 2017 Genetic and Evolutionary Computation Conference . 537– 544. [15] D. Brélaz. 1979. New methods to color the vertices of a graph. Commun. ACM 22, 4 (1979), 251–256. [16] K. K. Brock, S. Mutic, T. R. McNutt, H. Li, and M. L. Kessler. 2017. Use of image registration and fusion algorithms and techniques in radiotherapy: Report of the AAPM Radiation Therapy Committee Task Group No. 132: Report. Medical Physics 44, 7 (2017), e43–e76. [17] K. K. Brock, M. B. Sharpe, L. A. Dawson, S. M. Kim, and D. A. Jaffray. 2005. Accu- racy of finite element model-based multi-organ deformable image registration. Medical Physics 32, 6 (2005), 1647–1659. [18] H. Chui and A. Rangarajan. 2000. A new algorithm for non-rigid point matching. InIEEE Conference on Computer Vision and Pattern Recognition . 44–51. [19] K. Deb. 2001. Multi-Objective Optimization using Evolutionary Algorithms . Wiley. [20] B. Eiben, V. Vavourakis, J. H. Hipwell, S. Kabus, T. Buelow, C. Lorenz, T. Mertzanidou, S. Reis, N. R. Williams, M. Keshtgar, and D. J. Hawkes. 2016. Symmet- ric Biomechanically Guided Prone-to-Supine Breast Image Registration. Annals of Biomedical Engineering 44, 1 (2016), 154–173. [21] C. Ericson. 2004. Real-time collision detection (1 ed.). CRC Press. [22] M. Faisal Beg, M. I. Miller, A. Trouvétrouv, and L. Younes. 2005. Computing Large Deformation Metric Mappings via Geodesic Flows of Diffeomorphisms. International Journal of Computer Vision 61, 2 (2005), 139–157. [23] B. Fischer and J. Modersitzki. 2008. Ill-posed medicine - An introduction to image registration. Inverse Problems 24, 3 (2008), 1–16. [24] J. Gascon, J. M. Espadero, A. G. Perez, R. Torres, and M. A. Otaduy. 2013. Fast deformation of volume data using tetrahedral mesh rasterization. In Proceed- ings - SCA 2013: 12th ACM SIGGRAPH / Eurographics Symposium on ComputerAnimation . 181–186. [25] S. Hang. 2015. TetGen, a Delaunay-Based Quality Tetrahedral Mesh Generator. ACM Trans. Math. Software 41, 2 (2015), 1–36. [26] F. Khalifa, G. M. Beache, G. Gimel’farb, J. S. Suri, and A. S. El-Baz. 2011. State-of- the-Art Medical Image Registration Methodologies: A Survey. In Multi Modal- ity State-of-the-Art Medical Image Segmentation and Registration Methodologies . Springer, 235–280. [27] A. Klein, J. Andersson, B. A. Ardekani, J. Ashburner, B. Avants, M. C. Chiang, G. E. Christensen, D. L. Collins, J. Gee, P. Hellier, J. H. Song, M. Jenkinson, C. Lepage, D. Rueckert, P. Thompson, T. Vercauteren, R. P. Woods, J. J. Mann, and R. V. Parsey. 2009. Evaluation of 14 nonlinear deformation algorithms applied to human brain MRI registration. NeuroImage 46, 3 (2009), 786–802. [28] S. Klein, M. Staring, K. Murphy, M. A. Viergever, and J. P.W. Pluim. 2010. Elastix: A toolbox for intensity-based medical image registration. IEEE Transactions on Medical Imaging 29, 1 (2010), 196–205. [29] M. Li, E. Castillo, X. L. Zheng, H. Y. Luo, R. Castillo, Y. Wu, and T. Guerrero. 2013. Modeling lung deformation: A combined deformable image registration method with spatially varying Young’s modulus estimates. Medical Physics 40, 8 (2013), 1–10. [30] G. Loi, M. Fusella, E. Lanzi, E. Cagni, C. Garibaldi, G. Iacoviello, F. Lucio, E. Menghi, R. Miceli, L. C. Orlandini, Antonella Roggio, Federica Rosica, Michele Stasi, Lidia Strigari, Silvia Strolin, and Christian Fiandra. 2018. Performance of commercially available deformable image registration platforms for contour propagation using patient-based computational phantoms: A multi-institutional study. Medical Physics 45, 2 (2018), 748–757. [31] H. N. Luong and P. A. N. Bosman. 2012. Elitist Archiving for Multi-Objective Evolutionary Algorithms: To Adapt or Not to Adapt. In Proceedings of the 12th Conference on Parallel Problem Solving from Nature . 72–81. [32] H. Maaranen, K. Miettinen, and A. Penttinen. 2007. On initial populations of a genetic algorithm for continuous optimization problems. Journal of Global Optimization 37, 3 (2007), 405–436. [33] R. Mohammadi, S. R. Mahdavi, R. Jaberi, Z. Siavashpour, L. Janani, A. S. Meigooni, and R. Reiazi. 2019. Evaluation of deformable image registration algorithm for determination of accumulated dose for brachytherapy of cervical cancer patients. Journal of Contemporary Brachytherapy 11, 5 (2019), 469–478. [34] S. Nithiananthan, S. Schafer, D. J. Mirota, J. W. Stayman, W. Zbijewski, D. D. Reh, G. L. Gallia, and J. H. Siewerdsen. 2012. Extra-dimensional Demons: A method for incorporating missing tissue in deformable image registration. Medical Physics 39, 9 (2012), 5718–5731. [35] D. F. Pace, M. Niethammer, and S. R. Aylward. 2012. Sliding Geometries in De- formable Image Registration. In International MICCAI Workshop on Computational and Clinical Challenges in Abdominal Imaging . 141–148. [36] K. Pirpinia, P. A. N. Bosman, C. E. Loo, G. Winter-Warnars, N. N. Y. Janssen, A. N. Scholten, J. J. Sonke, M. van Herk, and T. Alderliesten. 2017. The feasibility of manual parameter tuning for deformable breast MR image registration from a multi-objective optimization perspective. Physics in Medicine and Biology 62, 14 (2017), 5723–5743. [37] B. Rigaud, A. Klopp, S. Vedam, A. Venkatesan, N. Taku, A. Simon, P. Haigron, R. De Crevoisier, K. K. Brock, and G. Cazoulat. 2019. Deformable image registration for dose mapping between external beam radiotherapy and brachytherapy images of cervical cancer. Physics in Medicine and Biology 64, 11 (2019), 115023. [38] L. Risser, F. X. Vialard, H. Y. Baluwala, and J. A. Schnabel. 2013. Piecewise- diffeomorphic image registration: Application to the motion estimation between 3D CT lung images with sliding conditions. Medical Image Analysis 17, 2 (2013), 182–193. [39] B. Schaly, J. A. Kempe, G. S. Bauman, J. J. Battista, and J. van Dyk. 2004. Tracking the dose distribution in radiation therapy by accounting for variable anatomy. Physics in Medicine and Biology 49, 5 (2004), 791–805. [40] A. Sotiras and N. Paragios. 2012. Deformable Image Registration: A Survey . Tech- nical Report. Center for Visual Computing, Department of Applied Mathematics, Ecole Centrale de Paris, Equipe GALEN, INRIA Saclay. [41] D. Thierens and P. A. N. Bosman. 2011. Optimal mixing evolutionary algorithms. InProceedings of the 2011 Genetic and Evolutionary Computation Conference . 617–624. [42] J.-P. Thirion. 1998. Image matching as a diffusion process: an analogy with Maxwell’s Demons. Medical Image Analysis 2, 3 (1998), 243–260. [43] M. Unser, A. Aldroubi, and C. R. Gerfen. 1993. Multiresolution image registra- tion procedure using spline pyramids. In SPIE Mathematical Imaging: Wavelet Applications in Signal and Image Processing , Vol. 2034. 160–170. [44] E. M. Vásquez Osorio, M. S. Hoogeman, L. Bondar, P. C. Levendag, and B. J. M. Heijmen. 2009. A novel flexible framework with automatic feature correspon- dence optimization for nonrigid registration in radiotherapy. Medical Physics 36, 7 (2009), 2848–2859. [45] O. Weistrand and S. Svensson. 2015. The ANACONDA algorithm for deformable image registration in radiotherapy. Medical Physics 42, 1 (2015), 40–53. [46] S. Wognum, L. Bondar, A. G. Zolnay, X. Chai, M. C. C. M. Hulshof, M. S. Hoogeman, and A. Bel. 2013. Control over structure-specific flexibility improves anatomical accuracy for point-based deformable registration in bladder cancer radiotherapy. MOREA: a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images Medical Physics 40, 2 (2013), 1–15. [47] W. Zhang, Y. Ma, J. Zheng, and W. J. Allen. 2020. Tetrahedral mesh deformation with positional constraints. Computer Aided Geometric Design 81 (2020), 1–16.[48] H. Zhong, J. Kim, H. Li, T. Nurushev, B. Movsas, and I. J. Chetty. 2012. A finite element method to correct deformable image registration errors in low-contrast regions. Physics in Medicine and Biology 57, 11 (2012), 3499–3515.

This paper presents MOREA, a GPU-accelerated Evolutionary Algorithm for Multi-Objective Deformable Registration of 3D Medical Images. Experiments on 4 cervical cancer patient scans show that MOREA outperforms two state-of-the-art approaches in terms of contour registration accuracy. Additionally, the paper introduces a fold detection method, a radial-basis-function approach to introduce large deformations free of mesh folds, and a repair method to reverse folds on a point-by-point basis. Results indicate that the heterogeneous elasticity model generally receives higher Dice scores and similar Hausdorff 95th percentiles, and that contour-based strategies perform better than random mesh point placement.

Attention Is All You Need Ashish Vaswani Google Brain avaswani@google.comNoam Shazeer Google Brain noam@google.comNiki Parmar Google Research nikip@google.comJakob Uszkoreit Google Research usz@google.com Llion Jones Google Research llion@google.comAidan N. Gomezy University of Toronto aidan@cs.toronto.eduŁukasz Kaiser Google Brain lukaszkaiser@google.com Illia Polosukhinz illia.polosukhin@gmail.com Abstract The dominant sequence transduction models are based on complex recurrent or convolutional neural networks that include an encoder and a decoder. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014 English- to-German translation task, improving over the existing best results, including ensembles, by over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training costs of the best models from the literature. We show that the Transformer generalizes well to other tasks by applying it successfully to English constituency parsing both with large and limited training data. 1 Introduction Recurrent neural networks, long short-term memory [ 13] and gated recurrent [ 7] neural networks in particular, have been firmly established as state of the art approaches in sequence modeling and Equal contribution. Listing order is random. Jakob proposed replacing RNNs with self-attention and started the effort to evaluate this idea. Ashish, with Illia, designed and implemented the first Transformer models and has been crucially involved in every aspect of this work. Noam proposed scaled dot-product attention, multi-head attention and the parameter-free position representation and became the other person involved in nearly every detail. Niki designed, implemented, tuned and evaluated countless model variants in our original codebase and tensor2tensor. Llion also experimented with novel model variants, was responsible for our initial codebase, and efficient inference and visualizations. Lukasz and Aidan spent countless long days designing various parts of and implementing tensor2tensor, replacing our earlier codebase, greatly improving results and massively accelerating our research. yWork performed while at Google Brain. zWork performed while at Google Research. 31st Conference on Neural Information Processing Systems (NIPS 2017), Long Beach, CA, USA.arXiv:1706.03762v5 [cs.CL] 6 Dec 2017 transduction problems such as language modeling and machine translation [ 35,2,5]. Numerous efforts have since continued to push the boundaries of recurrent language models and encoder-decoder architectures [38, 24, 15]. Recurrent models typically factor computation along the symbol positions of the input and output sequences. Aligning the positions to steps in computation time, they generate a sequence of hidden statesht, as a function of the previous hidden state ht

This paper proposes the Transformer, a model architecture based on attention mechanisms that is superior in quality and requires less time to train than other models. It achieved a BLEU score of 28.4 on the WMT 2014 English-to-German translation task and a BLEU score of 41.8 on the WMT 2014 English-to-French translation task. The Transformer was also successfully applied to English constituency parsing and other tasks. The paper also discusses the attention mechanism, computational complexity, parallelization, and maximum path length of different layer types.

"arXiv:2303.04347v1 [cs.NE] 8 Mar 2023Published as a conference paper at ICLR 2022\nOPTIMAL ANN-SN(...TRUNCATED)

"This paper presents a method for converting an Artificial Neural Network (ANN) to a Spiking Neural (...TRUNCATED)

"Accepted to the ICLR 2023 TrustML-(un)Limited workshop\nMARK MYWORDS : DANGERS OF WATERMARKED\nIMAG(...TRUNCATED)

"This paper examines the vulnerability of pre-trained architectures to watermarks in the ImageNet da(...TRUNCATED)

"arXiv:2303.01695v1 [cs.NE] 3 Mar 2023EVOLUTIONARY MULTI -OBJECTIVE ALGORITHMS FOR THE\nKNAPSACK P(...TRUNCATED)

"This paper reviews five studies on evolutionary multi-objective algorithms for knapsack problems wi(...TRUNCATED)