Paper deep dive
Tensor-Accelerated Eager Multi-Resolution Grids for Evolving Large-Scale Substrates
Romain Claret, Michael O'Neill, Paul Cotofrei, Kilian Stoffel
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 8/31/2026, 3:07:55 AM
Summary
The paper introduces EMR-HyperNEAT, a tensor-accelerated reformulation of ES-HyperNEAT for evolving neural network substrates. By replacing the sequential quadtree subdivision with an eager, parallel evaluation of all spatial positions across multiple resolutions, EMR-HyperNEAT enables GPU acceleration via JAX. This approach reduces computational complexity from O(4^D) to O(4^D/P), achieving significant speedups (up to 34x on GPU) and higher solve rates by discovering a superset of substrate positions compared to the original lazy method. It also enables recurrent substrate configurations through a connection type taxonomy.
Entities (10)
Relation Signals (7)
EMR-HyperNEAT → achievesspeedupon → XOR
confidence 95% · validates 12–34× on-device GPU speedup on XOR at depths 5–7
EMR-HyperNEAT → discoverssupersetof → ES-HyperNEAT
confidence 95% · EMR-HyperNEAT discovers a superset of the positions discovered by ES-HyperNEAT
EMR-HyperNEAT → isreformulationof → ES-HyperNEAT
confidence 95% · EMR-HyperNEAT replaces ES-HyperNEAT’s sequential quadtree with three parallelizable stages
ES-HyperNEAT → usesdatastructure → Quadtree
confidence 95% · it recursively subdivides space using a quadtree
EMR-HyperNEAT → achievesspeedupon → CRSP/Compustat
confidence 90% · On the CRSP/Compustat financial dataset (94K samples), EMR-HyperNEAT achieves 5.5× speedup
EMR-HyperNEAT → enables → Recurrent Substrates
confidence 90% · Recurrent substrate configurations become feasible through a connection type taxonomy
EMR-HyperNEAT → uses → JAX
confidence 90% · EMR-HyperNEAT implemented in JAX/Python
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:In neuroevolution, indirect encoding generates neural network connectivity from a compact genome rather than specifying each connection. ES-HyperNEAT automatically discovers where to place hidden nodes by examining CPPN output patterns: it recursively subdivides space using a quadtree, expanding regions where CPPN outputs show high variance. This adaptive approach discovers network topology without manual substrate specification, extending the fixed-grid HyperNEAT framework built on NEAT. However, the quadtree resists tensorization. Each depth level depends on the parent's variance, forcing sequential evaluation. Different CPPNs produce different subdivision patterns, preventing batching. And variable leaf counts are incompatible with JAX's static shape requirement for JIT compilation. Our prior work confirmed these limits at depths exceeding 5, and a JAX reimplementation of the quadtree yielded only marginal speedup despite batched optimizations, motivating the eager reformulation presented here. We present EMR-HyperNEAT, which evaluates all positions at all resolutions up front, then filters using the same variance criterion: ES-HyperNEAT's subdivide_if(var > $\theta$) becomes eval_all(); filter(var > $\theta$). This performs more CPPN queries than necessary, but all queries become independent and parallelizable across both cores and population members, reducing complexity from \BigO($4^D$) to \BigO($4^D/P$) across $P$ parallel cores. Recurrent substrate configurations become feasible through a connection type taxonomy. The experiments section validates 12-34$\times$ on-device GPU speedup on XOR at depths 5-7, and empirically higher solve rates across benchmarks.
Tags
Links
- Source: https://arxiv.org/abs/2608.27612v1
- Canonical: https://arxiv.org/abs/2608.27612v1
Trouble viewing inline? Open PDF directly →
Full Text
20,435 characters extracted from source content.
Expand or collapse full text
Tensor-Accelerated Eager Multi-Resolution Grids for Evolving Large-Scale Substrates Conference: Genetic and Evolutionary Computation Conference; July 13–17, 2026; San Jose, Costa RicaGenetic and Evolutionary Computation Conference (GECCO Companion ’26), July 13–17, 2026, San Jose, Costa RicaDOI: 10.1145/3795101.3805361ISBN: 979-8-4007-2488-6/2026/07CCS: Computing methodologies Neural networksCCS: Computing methodologies Genetic algorithmsCCS: Computing methodologies Parallel algorithms Romain Claret email: romain.claret@unine.ch Affiliation: University of Neuchâtel, Neuchâtel, Switzerland , Michael O’Neill email: m.oneill@ucd.ie Affiliation: University College Dublin, Dublin, Ireland , Paul Cotofrei email: paul.cotofrei@unine.ch Affiliation: University of Neuchâtel, Neuchâtel, Switzerland and Kilian Stoffel email: kilian.stoffel@unine.ch Affiliation: University of Neuchâtel, Neuchâtel, Switzerland Received 27 January 2026 Abstract. Evolvable-Substrate HyperNEAT (ES-HyperNEAT) discovers neural network topology by querying a Compositional Pattern-Producing Network (CPPN) at spatial positions and placing nodes where output variance is high. Its sequential quadtree cannot be tensorized directly: each network produces a different tree with dynamic shapes. We present Eager Multi-Resolution HyperNEAT (EMR-HyperNEAT), which reformulates adaptive substrate discovery as a batch tensor operation: shared position grids are precomputed for all depths, every position is evaluated in one vectorized CPPN call, then the same variance criterion filters the output. This tensor formulation supports population-level batching, one-time JIT compilation, chunked memory streaming, and six substrate configurations (feedforward through full recurrent) that sequential traversal could not support at scale. On the CRSP/Compustat financial dataset (94K samples), EMR-HyperNEAT achieves 5.5× speedup at depth 6; on XOR (pop 1000), 12–34× per-generation GPU speedup at depths 5–7 (∼100× 100× over 30 generations). The reformulation also discovers a superset of ES-HyperNEAT’s positions, yielding higher empirical solve rates. We validate substrate evolution up to depth 13 (358M positions, streamed from disk). Keywords: neuroevolution, ES-HyperNEAT, adaptive substrates, tensor reformulation, indirect encoding, recurrent networks †c-license: by 1. Introduction In neuroevolution, indirect encoding generates neural network connectivity from a compact genome rather than specifying each connection. ES-HyperNEAT (Risi and Stanley, 2012) automatically discovers where to place hidden nodes by examining CPPN (Stanley, 2007) output patterns: it recursively subdivides space using a quadtree, expanding regions where CPPN outputs show high variance. This adaptive approach discovers network topology without manual substrate specification, extending the fixed-grid HyperNEAT (Stanley et al., 2009) framework built on NEAT (Stanley and Miikkulainen, 2002). However, the quadtree resists tensorization. Each depth level depends on the parent’s variance, forcing sequential evaluation. Different CPPNs produce different subdivision patterns, preventing batching. And variable leaf counts are incompatible with JAX’s (Bradbury et al., 2018) static shape requirement for JIT compilation. Our prior work confirmed these limits at depths exceeding 5 (Claret et al., 2024), and a JAX reimplementation of the quadtree yielded only marginal speedup despite batched optimizations, motivating the eager reformulation presented here. We present EMR-HyperNEAT, which evaluates all positions at all resolutions up front, then filters using the same variance criterion: ES-HyperNEAT’s subdivide_if(var > θ) becomes eval_all(); filter(var > θ) (Figure 1). This performs more CPPN queries than necessary, but all queries become independent and parallelizable across both cores and population members, reducing complexity from (4D)O(4^D) to (4D/P)O(4^D/P) across P parallel cores (Section 3). Recurrent substrate configurations become feasible through a connection type taxonomy (Section 4). Section 5 validates 12–34× on-device GPU speedup on XOR at depths 5–7, and empirically higher solve rates across benchmarks. ES-HyperNEAT (Lazy)d=0var>θ> =1var>θ> =2var>θ> =3SequentialEMR-HyperNEAT (Eager)1d=04d=116d=264d=3Grid builtonce, thenquery ALLvar>θ> substrate Figure 1. Lazy vs eager substrate discovery. Left: ES-HyperNEAT subdivides sequentially. Right: EMR-HyperNEAT evaluates all depths in parallel, then filters by variance.Comparison of lazy (ES-HyperNEAT) and eager (EMR-HyperNEAT) substrate discovery approaches producing sparse neural network substrates. 2. Background NEAT (Stanley and Miikkulainen, 2002) evolves neural network topology and weights simultaneously. HyperNEAT (Stanley et al., 2009) extends NEAT with indirect encoding: a CPPN maps spatial coordinates (x1,y1,x2,y2)(x_1,y_1,x_2,y_2) to connection weights, so compact genomes can specify large-scale networks. ES-HyperNEAT (Risi and Stanley, 2012) removes the need for a predefined substrate by adaptively placing nodes via quadtree subdivision. In Phase 1, for each input coordinate, the quadtree expands regions where CPPN variance exceeds threshold θdiv _div, discovering H hidden positions. In Phase 2, each of the H positions undergoes its own quadtree traversal to discover hidden-to-hidden connections, requiring (H2)O(H^2) sequential queries. Since cost grows as 4D4^D, each additional depth roughly quadruples generation time. The quadtree traversal resists tensor batching for three reasons: (1) non-uniform subdivision patterns prevent batching via vmap; (2) children cannot be evaluated until parent variance is computed; and (3) variable leaf counts are incompatible with JAX’s static shape requirement for JIT compilation. 3. EMR-HyperNEAT Algorithm EMR-HyperNEAT replaces ES-HyperNEAT’s sequential quadtree with three parallelizable stages: (1) precompute static multiresolution grids, (2) batch-evaluate all CPPN queries via vmap, and (3) apply hierarchical variance filtering. 3.1. Hierarchical Grid and Batch Query At initialization, EMR-HyperNEAT precomputes a complete multiresolution grid from depth 0 to maximum depth D: (1) D=⋃d=0DGridd,Gridd=(2i+12d+1−1,2j+12d+1−1):i,j∈[0,2d+1)G_D= _d=0^DGrid_d,\;Grid_d= \ ( 2i+12^d+1-1, 2j+12^d+1-1 ):i,j∈[0,2^d+1) \ The total position count is Ntotal=(4D+2−4)/3N_total=(4^D+2-4)/3, growing from 1,364 at depth 4 to 87,380 at depth 7 and 358M at depth 13. All arrays have static shapes, compatible with JIT compilation. With positions in static arrays, CPPN queries become independent and parallel via =vmap(CPPN)(s,T)W=vmap(CPPN)(s,T), replacing N sequential queries with (N/P)O(N/P) wall-clock time. Population parallelization evaluates all genomes simultaneously. 3.2. Variance Filtering and Active Mask Variance is computed bottom-up from children to parents. The active mask propagates top-down: (2) active[d][i]=Trued=0active[d−1][pi]∧(var[d−1][pi]>θdiv)elseactive[d][i]= casesTrue&d=0\\ active[d-1][p_i] (var[d-1][p_i]> _div)&else cases Each parent controls all four children as a block, so filtering runs in parallel. Table 1 summarizes the complexity comparison. Table 1. Computational complexity. D = max depth, H = discovered hidden positions, P = parallel execution units. Operation ES-HyperNEAT EMR-HyperNEAT Grid Construction — (4D)O(4^D) once CPPN Query (Phase 1) (4D)O(4^D) seq. (4D/P)O(4^D/P) Variance Comp. (4D)O(4^D) seq. (4D/P)O(4^D/P) Mask Propagation (4D)O(4^D) seq. (4D/P)O(4^D/P) h→ Query (Phase 2) (H2)O(H^2) seq. (H2/P)O(H^2/P) Total (4D+H2)O(4^D+H^2) ((4D+H2)/P)O((4^D+H^2)/P) Theorem 1 (Superset Discovery). Under identical variance thresholds θdiv _div and band thresholds θband _band, EMR-HyperNEAT discovers a superset of the positions discovered by ES-HyperNEAT. When both algorithms discover identical position sets, they produce identical connection sets. Proof. ES-HyperNEAT’s quadtree prunes subtrees when parent variance falls below θdiv _div. Since low parent variance does not imply low child variance, high-variance children within low-variance parents are never evaluated. EMR-HyperNEAT’s eager evaluation computes all positions before applying variance masks, recovering these positions. Therefore every position discovered by ES-HyperNEAT is also discovered by EMR-HyperNEAT (superset property). This also handles initial_depth=0 robustly: ES-HyperNEAT may discover no nodes if root variance is insufficient, while EMR-HyperNEAT evaluates all positions regardless. ∎ 3.3. Threshold Adaptation The two approaches compute variance over different regions: ES-HyperNEAT only looks inside regions whose parent already passed the threshold, while EMR-HyperNEAT looks at all positions including low-variance regions. ES-HyperNEAT’s original thresholds (θdiv=0.5 _div=0.5, θband=0.3 _band=0.3) produce no solutions under eager evaluation. EMR-HyperNEAT uses adapted thresholds (θvar=0.03 _var=0.03, weight magnitude filtering at 0.1) that are functionally equivalent for the eager context. This adaptation is a necessary consequence of the reformulation, not an independent parameter choice. 4. Connection Type Taxonomy EMR-HyperNEAT’s parallelization of Phase 2 makes recurrent substrate configurations computationally feasible. In HyperNEAT substrates, comparing source and target Y coordinates classifies connections into four primitives: Forward (ys<yty_s<y_t), Backward (ys>yty_s>y_t, feedback), Lateral (ys=yty_s=y_t, same layer), and Self-loop (s=ts=t). Enabling or disabling these produces six substrate configurations (Table 2). Table 2. Six substrate configurations available in EMR-HyperNEAT. F=Forward, H=hidden-to-hidden, B=Backward, L=Lateral, S=Self. Config F H B L S Notes Feedforward ✓ Fastest; skips Phase 2 h→ ✓ ✓ ES-HN default Backward ✓ ✓ ✓ Feedback loops Lateral ✓ ✓ ✓ Same-layer links Self ✓ ✓ ✓ State memory Full Recurrent ✓ ✓ ✓ ✓ ✓ All connections Cross-problem evaluation (depth 5, pop 300, 10 replications) shows connection types significantly affect convergence (Table 3). On XOR, Backward and Lateral achieve 100% (p<0.001p<0.001 vs Feedforward’s 20%). On Visual Discrimination (2D spatial classification) (Stanley et al., 2009), Backward achieves 100% convergence while Lateral and Self hurt performance. Table 3. Cross-problem convergence rate (%) by connection type. Bold = best or tied. p: Fisher’s exact, best vs feedforward. Problem F h→ Back Lat Self Full p XOR 20 50 100 100 90 60 <<0.001 Visual 90 70 100 40 40 90 <<0.001 Retina 100 80 90 80 100 100 n.s. 5. Experimental Evaluation 5.1. Setup CPU: Apple M4 Max (JAX CPU backend). GPU: NVIDIA RTX 2080 Ti 11GB (JAX CUDA backend). Baseline: PUREPLES (et al., 2017), the reference Python implementation of ES-HyperNEAT (ES-HN). Problem: XOR (4 input patterns), standard neuroevolution benchmark (Stanley and Miikkulainen, 2002). Both algorithms: 30 generations, 8 populations (50–1000), depths 1–7, h→ connection type, 3 replications (504 runs total). EMR-HyperNEAT implemented in JAX/Python on TensorNEAT (Wang et al., 2024); each experiment ran in process isolation to ensure timing includes JIT compilation overhead. 5.2. Scaling and Speedup Table 4 presents per-generation timing. Figure 2 shows total runtime scaling including depths 8–13 via memory streaming, with cumulative runtime IQR median approaching ∼100× 100× over 30 generations at depth 7. Table 4. Average time per generation (XOR, pop=1000, h→ type). Speedup excludes one-time JIT compilation. Depth ES-HN EMR JIT Speedup CPU/GPU 1–3 0.3–1.0s 1–3s / 0.9–2.3s 4–8s / 7–17s 0.2–0.3× 4 4.27s 5s / 2.9s 12s / 18s 0.85× / 1.5× 5 46.3s 10s / 3.9s 15s / 19s 4.6× / 12× 6 200.4s 28s / 8.9s 30s / 24s 7.2× / 23× 7 2,020s 165s / 60s† 60s / 39s 12.2× / 34׆ †GPU depth 7 uses memory streaming (50–70s/gen on 11GB VRAM). 123456789101112131s10s1min10min1h10h1d1w2w1mo3moon-device computationmemory streaming∼ 5000× (≈4D≈ 4^D)∼ 7× (near-linear)∼ 4000× (≈4D≈ 4^D)disk I/ODepthTotal RuntimeES-HNEMR (CPU)EMR (GPU)CPU JITGPU JITCCM ES-HNCCM EMR Figure 2. Runtime over 30 generations (log y-axis). IQR bands: d1–7 use 8 pops × 3 seeds; d8–13 use GPU↔ streaming (pop 300, 1000, 3 seeds). The d13 widening reflects disk I/O dominating JIT and per-gen cost. CCM lines: financial data (Center for Research in Security Prices (CRSP), 2019) (94K samples, pop 100). Trend arrows: ∼5000× 5000× ES-HN (≈4D≈ 4^D), ∼7× 7× EMR on-device, ∼4000× 4000× EMR streaming (≈4D≈ 4^D).Log-scale runtime comparison from 1 second to 3 months across depths 1–13. ES-HyperNEAT grows exponentially and becomes infeasible past depth~7. EMR GPU scales near-linearly on-device for depths 1–7, then follows 4-to-the-D scaling under GPU-RAM streaming for depths 7–12. At depth 13, disk I/O becomes the dominant cost, shown by an annotation arrow. Bands show IQR across 8 populations and 3 replications. Statistical validation (Table 5) confirms that at depths ≥ 5, EMR-HyperNEAT GPU achieves significant speedups (p<.001p<.001, Cliff’s δ≥0.99δ≥ 0.99, large effect) after Holm-Bonferroni correction. Speedup increases with depth (Spearman ρ=0.96ρ=0.96, p<.001p<.001). Runtime variance also diverges: at depth 7, estimated σ is 3.6h (ES-HN), 31min (EMR CPU), 1.9min (EMR GPU), a 114× tighter bound. Table 5. Statistical comparison vs ES-HN: Mann-Whitney U (one-sided), Cliff’s delta. Significant at α=0.05α=0.05 for GPU depths ≥5≥ 5 after Holm-Bonferroni correction. EMR GPU EMR CPU Depth p δ Speedup p δ Speedup 1–3 >>0.99 −-1.00L 0.1–0.3× >>0.99 −-1.00L 0.1–0.3× 4 <<.001 0.59L 1.6× .915 -0.23S 0.8× 5 <<.001 0.99L 6.8× <<.001 0.70L 3.5× 6 <<.001 1.00L 42× <<.001 0.98L 11× 7 <<.001 1.00L 75× <<.001 0.91L 15× Effect size: S=small, L=large. 5.3. Solution Quality Table 6 shows EMR-HyperNEAT achieves equal or higher solve rates. At depth 6, ES-HyperNEAT solves XOR in only 33% of runs (pop=300) while EMR-HyperNEAT achieves 100%, due to bottom-up evaluation recovering positions that top-down traversal misses. Both achieve identical maximum fitness (0.99+) when successful. Table 6. Per-generation time and solve rate (XOR, h→ type with cache). JIT = one-time compilation overhead. Depth Algorithm Pop 300 + JIT Pop 500 + JIT 4 ES-HN 1.5s / 67% - 2.5s / 33% - EMR (CPU) 2s / 100% 11s 3s / 100% 10s EMR (GPU) 0.9s / 100% 10s 1.3s / 100% 12s 5 ES-HN 6.8s / 0% - 22.2s / 100% - EMR (CPU) 6s / 100% 15s 7s / 100% 14s EMR (GPU) 1.2s / 100% 10s 1.9s / 100% 13s 6 ES-HN 147.8s / 33% - 220.5s / 0% - EMR (CPU) 12s / 100% 16s 40s / 100% 31s EMR (GPU) 2.6s / 100% 12s 4.3s / 100% 15s 7 ES-HN 652s / 0% - 1,649s / 0% - EMR (CPU) 48s / 100% 46s 94s / 100% 72s EMR (GPU) 7.9s / 100% 17s 13s / 100% 23s 5.4. Real-World Benchmark Table 7 compares performance on CRSP/Compustat Merged financial data (94,464 observations) (Center for Research in Security Prices (CRSP), 2019). At depth 6, EMR-HyperNEAT is 5.5× faster despite streaming deeper layers from CPU RAM when GPU memory is insufficient. ES-HyperNEAT exhibits exponential scaling (depth 5→ 6: 11.3× slower); EMR-HyperNEAT scales linearly on-device. Table 7. Per-generation time on CCM financial dataset (94,464 samples, pop=100). EMR uses h→ type (GPU). Depth ES-HN EMR EMR JIT Speedup 1–3 1.9–2.4s 5.5–6.2s 11–13s 0.35–0.39× 4 4.2s 6.6s 13s 0.64× 5 21.9s 23s 46s 0.95× 6 247.9s 45s† 89s 5.5× †Streams deeper layers from CPU RAM (GPU memory insufficient). 6. Discussion The threshold adaptation (0.03 vs 0.5) is a necessary consequence of the reformulation: ES-HyperNEAT’s original thresholds produce no solutions under eager evaluation because variance is computed over all positions rather than only inside already-accepted regions. The adapted thresholds produce more hidden node candidates, contributing to the higher solve rates at depths 5–7 (Table 6), at the cost of redundant CPPN queries amortized by parallelism. EMR-HyperNEAT is advantageous when JIT overhead (4–60s) is amortized across generations. JAX caches compiled functions, so experiments at matching depth and population size skip JIT, and the precomputed grid (∼ 683 KB at depth 7) is reused across problems. At low depth with few generations, ES-HyperNEAT remains preferable. Caching accelerates computation further: cached h→ connections reduce subsequent discovery from ∼ 27s to ∼ 3ms. Memory scales as 4D4^D: depth 5 <<620 MB, depth 7 ∼ 10 GB (pop 500). At depth 13 (358M positions, pop 300), weight arrays stored on disk dominate both JIT (∼ 5.3 h) and per-gen cost (∼ 5.8 h), visible as the d12→ 13 widening in Figure 2. 7. Conclusion To our knowledge, EMR-HyperNEAT is the first massively parallel adaptive substrate discovery algorithm. The lazy-to-eager reformulation yields significant speedups that grow with depth (Tables 4–7), validated on both XOR and financial data (94K samples). Beyond speedup, bottom-up evaluation discovers a superset of substrate positions (Theorem 1), which yields higher solve rates in practice, and the connection type taxonomy makes recurrent substrates computationally tractable. This makes previously unreachable substrate configurations accessible, opening per-node substrate complexification at new depth and population scales, though further efficiency gains via selective evaluation remain constrained by the need to preserve parallelization. Code Availability https://github.com/RomainClaret/emr-hyperneat Acknowledgements. Generative AI tools assisted with visualizations, pseudocode conversion, and draft revision. References Bradbury et al. (2018) J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, C. Leary, D. Maclaurin, G. Necula, A. Paszke, J. VanderPlas, S. Wanderman-Milne, et al. JAX: composable transformations of python+ numpy programs. Cited by: §1. Center for Research in Security Prices (CRSP) (2019) Center for Research in Security Prices (CRSP) CRSP/compustat merged database (ccm). University of Chicago Booth School of Business, CRSP. Note: Accessed via WRDS External Links: Link Cited by: Figure 2, §5.4. Claret et al. (2024) R. Claret, M. O’Neill, P. Cotofrei, and K. Stoffel Investigating hyperparameter optimization and transferability for es-hyperneat: a tpe approach. In Proceedings of the Genetic and Evolutionary Computation Conference Companion, p. 1879–1887. Cited by: §1. et al. (2017) Pureples - pure python library for es-hyperneat Note: https://github.com/ukuleleplayer/pureples Cited by: §5.1. Risi and Stanley (2012) S. Risi and K. O. Stanley An enhanced hypercube-based encoding for evolving the placement, density, and connectivity of neurons. Artificial life 18 (4), p. 331–363. Cited by: §1, §2. Stanley et al. (2009) K. O. Stanley, D. B. D’Ambrosio, and J. Gauci A hypercube-based encoding for evolving large-scale neural networks. Artificial life 15 (2), p. 185–212. Cited by: §1, §2, §4. Stanley and Miikkulainen (2002) K. O. Stanley and R. Miikkulainen Evolving neural networks through augmenting topologies. Evolutionary computation 10 (2), p. 99–127. Cited by: §1, §2, §5.1. Stanley (2007) K. O. Stanley Compositional pattern producing networks: a novel abstraction of development. Genetic programming and evolvable machines 8 (2), p. 131–162. Cited by: §1. Wang et al. (2024) L. Wang, M. Zhao, E. Liu, K. Sun, and R. Cheng Tensorized neuroevolution of augmenting topologies for gpu acceleration. In Proceedings of the Genetic and Evolutionary Computation Conference, p. 1156–1164. Cited by: §5.1.