Quaternion Approximate Networks (QUAN)

• Quaternion Approximate Networks (QUAN) are deep neural networks that approximate quaternion convolution using separable real-valued operations, enabling efficient inter-channel coupling and rotation awareness.
• QUAN employs techniques like Independent Quaternion Batch Normalization and custom fused CUDA kernels to boost parameter efficiency and runtime performance over naive quaternion implementations.
• Empirical results show QUAN achieves competitive accuracy in image classification and object detection using significantly fewer parameters compared to standard convolutional models.

Quaternion Approximate Networks (QUAN) are deep neural networks that use quaternion algebra as a structuring principle while implementing the resulting operators with standard real-valued convolutions and tensor operations rather than with a fully quaternion-domain execution stack. In the 2025 formulation, QUAN is presented for image classification and object detection, with emphasis on rotation-aware behavior, parameter efficiency, and deployment through custom CUDA kernels; in adjacent literature, the same broader design space also includes quaternion models that approximate dense quaternion operators through structural constraints such as block-circulant low-displacement-rank parameterizations rather than through exact dense Hamilton products (Grant et al., 5 Sep 2025, Frants et al., 8 Jan 2026).

1. Definition, scope, and lineage

QUAN sits within a longer line of quaternion neural-network research in which quaternion-valued layers are used to couple four correlated channels through Hamilton algebra. Early deep quaternion work established quaternion convolutions, quaternion batch normalization, and quaternion-aware initialization, and showed improved convergence with fewer parameters on CIFAR-10, CIFAR-100, and KITTI Road Segmentation (Gaudet et al., 2017). Subsequent quaternion CNN work for color images represented RGB pixels as pure quaternions and designed convolution kernels as rotations around the gray axis plus scaling, again emphasizing structured inter-channel coupling rather than independent channel processing (Zhu et al., 2019). In NLP, quaternion attention and Quaternion Transformers were used to obtain up to $75\%$ reduction in parameter size without significant loss in performance by replacing dense real-valued linear operators with Hamilton-structured layers (Tay et al., 2019).

Within that lineage, the 2025 QUAN formulation makes a more specific move: it does not attempt to execute a fully exact quaternion convolution everywhere, but instead approximates quaternion convolution through a separable Hamilton-inspired real-valued computation pattern. The paper explicitly positions this as a practical alternative to conventional quaternion neural networks, which it describes as costly, poorly supported in mainstream frameworks, and often slower when implemented naïvely (Grant et al., 5 Sep 2025). A neighboring but distinct direction is EdgeLDR, which constrains quaternion weights to a block-circulant low-displacement-rank family and evaluates them with complex-adjoint FFTs; that framework does not explicitly mention QUAN by name, but the accompanying technical discussion places it conceptually in the same “quaternion structured / compressed” space (Frants et al., 8 Jan 2026).

Work	Core contribution	Relation to QUAN
"Deep Quaternion Networks" (Gaudet et al., 2017)	Quaternion convolutions, quaternion batch-normalization, quaternion initialization	Foundational dense quaternion architecture
"Lightweight and Efficient Neural Natural Language Processing with Quaternion Networks" (Tay et al., 2019)	Quaternion attention and Quaternion Transformer with $75\%$ parameter reduction	Architectural parameter-efficient quaternionization
"Quaternion Approximation Networks for Enhanced Image Classification and Oriented Object Detection" (Grant et al., 5 Sep 2025)	Real-valued approximation of quaternion convolution, IQBN, quaternion attention and detection heads	Canonical QUAN formulation
"EdgeLDR: Quaternion Low-Displacement Rank Neural Networks for Edge-Efficient Deep Learning" (Frants et al., 8 Jan 2026)	Block-circulant quaternion LDR layers with FFT evaluation	Structural quaternion approximation adjacent to QUAN

2. Quaternion algebra and the approximation principle

The algebraic substrate is the standard quaternion field. A quaternion is written as

$$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$

with

$$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$

For $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$, the Hamilton product is

$$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$

This induces the familiar $4\times 4$ structured real block matrix used throughout quaternion deep learning, where four free real components generate a dense pattern of cross-component interactions (Gaudet et al., 2017, Tay et al., 2019).

Classical quaternion CNNs use the full Hamilton form, which retains all cross-component terms. QUAN instead introduces a separable approximation. Given quaternion input $x=(x_r,x_i,x_j,x_k)$ and kernel $W=(W_r,W_i,W_j,W_k)$, QUAN defines

$\begin{split} y_r &= W_r \otimes x_r - W_i \otimes x_i - W_j \otimes x_j - W_k \otimes x_k, \ y_i &= W_r \otimes x_r + W_i \otimes x_i + W_j \otimes x_j - W_k \otimes x_k, \ y_j &= W_r \otimes x_r - W_i \otimes x_i + W_j \otimes x_j + W_k \otimes x_k, \ y_k &= W_r \otimes x_r + W_i \otimes x_i - W_j \otimes x_j + W_k \otimes x_k. \end{split}$

The dropped terms are precisely the cross-component interactions such as $75\%$0 that appear in an exact Hamilton convolution. The retained coupling is encoded by the fixed sign-pattern matrix

$75\%$1

The paper describes this as preserving a quaternion-like symmetric structure while reducing the computation from 16 component-wise convolutions to effectively 4 real convolutions followed by linear mixing, with complexity $75\%$2 rather than $75\%$3 for a naïve Hamilton implementation (Grant et al., 5 Sep 2025).

For RGB inputs, QUAN uses a Poincaré-ball-inspired embedding. For pixel values $75\%$4,

$75\%$5

The paper reports that among the tested mappings—luminance-based, mean brightness, raw normalized, purely imaginary “Hamilton” mapping, and Poincaré—Poincaré plus SiLU performed best (Grant et al., 5 Sep 2025).

A recurrent misconception is that QUAN is simply a standard quaternion CNN written differently. It is not. The defining design choice is approximation: exact Hamilton algebra is relaxed, but a fixed quaternion-like coupling is retained. The paper further notes that QUAN is not a strict group-equivariant model in the formal sense of G-CNNs or steerable CNNs, even though its abstract frames the method as targeting rotation equivariant classification and detection (Grant et al., 5 Sep 2025).

3. Core modules, normalization, and optimization machinery

The principal training-specific module introduced by QUAN is Independent Quaternion Batch Normalization (IQBN). Given a quaternion feature tensor $75\%$6 with components $75\%$7, IQBN computes per-component statistics

$75\%$8

for each $75\%$9, followed by learned affine parameters $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$0. Unlike earlier quaternion batch-normalization schemes that whiten a full $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$1 covariance, IQBN normalizes the four components independently. The paper reports about $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$2 CIFAR-10 accuracy gain over a traditional quaternion BN and uses IQBN as its default normalization layer (Grant et al., 5 Sep 2025).

Architecturally, the classification model is a Quaternion Wide ResNet, specifically QWRN-16-4, obtained by replacing the main convolutional layers of Wide ResNet-16-4 with QUAN convolutions and applying IQBN plus SiLU after quaternion layers. For detection, the paper modifies YOLOv11n by replacing standard convolutions with QConv and by introducing QC3k2, QSPPF, and QC2PSA. QC3k2 is the quaternion version of a Cross Stage Partial block, QSPPF is a quaternion Spatial Pyramid Pooling Fast block, and QC2PSA is a quaternion Partial Spatial Attention block in which attention weights are applied consistently across the four components of each quaternion (Grant et al., 5 Sep 2025).

The implementation claim is explicitly practical rather than symbolic. QUAN uses standard real-valued convolutions and tensor operations, with custom fused CUDA kernels that compute the four component-wise convolutions and apply the mixing matrix in the same kernel. The paper states that a naïve pure quaternion implementation was $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$3 slower than real CNN baselines, whereas the approximate QUAN implementation attains inference times comparable to standard convolutions, with only small overhead in the reported settings (Grant et al., 5 Sep 2025).

In the broader quaternion literature, correct gradient propagation is nontrivial. “Quaternion Backpropagation” shows that the naïve derivative

$$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$4

does not satisfy valid product and chain rules, and derives quaternion backpropagation using GHR calculus instead (Pöppelbaum et al., 2022). A later time-series compression paper further relates GHR-based quaternion backpropagation to automatic differentiation in real-valued lifted implementations, which is directly relevant to the real-valued execution strategy used by practical quaternion approximations (Pöppelbaum et al., 2024). This suggests that QUAN’s real-operator implementation is aligned with a broader tendency in quaternion deep learning: preserving quaternion structure in parameter tying and algebraic coupling while delegating actual differentiation and execution to real-valued kernels.

4. Tasks, loss functions, and empirical profile

QUAN was evaluated on image classification, axis-aligned object detection, oriented object detection, and robotic perception. For classification, the reported comparison at WRN-16-4 scale is:

• WRN-16-4: 2.75M parameters, $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$5 on CIFAR-10, $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$6 on CIFAR-100.
• ResNet34: 3.6M parameters, $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$7 on CIFAR-10, $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$8 on CIFAR-100.
• QUAN-WRN: 0.717M parameters, $$q = q_r + q_i \mathbf{i} + q_j \mathbf{j} + q_k \mathbf{k},$$9 on CIFAR-10, $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$0 on CIFAR-100.
• Deep QCNN: 0.933M parameters, $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$1 on CIFAR-10, $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$2 on CIFAR-100.

On an ImageNet 100-class subset, QUAN reports $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$3 top-1 with 5.39M parameters versus $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$4 for ResNet34 with 21.8M parameters. The paper summarizes this as better accuracy with roughly $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$5 fewer parameters and notes only about a $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$6 average increase in training time versus standard real-valued WRN (Grant et al., 5 Sep 2025).

For detection, the paper distinguishes between axis-aligned and oriented settings. On COCO 2017, QUAN-YOLO11n uses 1.187M parameters and reaches mAP50-95 $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$7, compared with 2.65M parameters and $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$8 for YOLO11n. On a robotic axis-aligned dataset, QUAN-YOLO11n uses 0.67M parameters and reaches mAP50-95 $$\mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{i}\mathbf{j}\mathbf{k} = -1.$$9, compared with 2.61M parameters and $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$0 for YOLO11n. For oriented detection, on DOTA, QUAN-YOLO11n uses 1.24M parameters and reaches mAP@50 $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$1 and mAP@50-95 $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$2, against 2.66M parameters, $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$3, and $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$4 for YOLO11n-obb. On the robotic oriented dataset, QUAN-YOLO11n uses 0.69M parameters and reaches mAP@50 $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$5 and mAP@50-95 $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$6, compared with 2.66M parameters, $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$7, and $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$8 for YOLO11n-obb, while also showing a slight speedup in the reported timing figures (Grant et al., 5 Sep 2025).

The oriented-detection head predicts a quaternion orientation $$p = p_r + p_i \mathbf{i} + p_j \mathbf{j} + p_k \mathbf{k}$$9 in addition to class probabilities and box parameters. The total loss is

$$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$0

with

$$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$1

and

$$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$2

This loss uses the geometry of unit quaternions directly for orientation prediction and explicitly handles the sign ambiguity $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$3 through the absolute inner product (Grant et al., 5 Sep 2025).

The empirical profile therefore has two distinct aspects. First, in small-to-moderate-scale classification and robotic oriented detection, QUAN improves parameter efficiency without sacrificing and sometimes improving accuracy. Second, on larger datasets such as COCO and DOTA, the paper reports slight underperformance relative to YOLO baselines and attributes it to smaller model capacity and constrained training resources (Grant et al., 5 Sep 2025).

5. Relationship to other quaternion approximate and compressed models

QUAN is one member of a broader family of quaternion approximation strategies. One prominent family keeps exact quaternion algebra but imposes structured or compressed parameterizations. EdgeLDR is the clearest example in the supplied literature: it approximates dense quaternion weights by constraining them to a block-circulant low-displacement-rank manifold, introduces quaternion block-circulant linear and convolutional layers, and evaluates them through a complex adjoint representation and FFTs, with $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$4 target complexity in the structured dimensions (Frants et al., 8 Jan 2026). The technical comparison explicitly characterizes EdgeLDR as an architectural approximation rather than a post-hoc approximation and places it in neighboring conceptual space to QUAN-type methods.

Another family uses dense quaternion layers directly for parameter efficiency. In NLP, Quaternion attention and Quaternion Transformer models replace real-valued feed-forward layers, Q/K/V projections, and attention operations with Hamilton-structured counterparts, obtaining up to $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$5 reduction in parameter size without significant loss and, in some tasks, improved performance (Tay et al., 2019). In vision, Deep Quaternion Networks showed that replacing real and complex layers with quaternion counterparts could reduce parameter count to about one quarter of the real model while improving convergence, especially on segmentation (Gaudet et al., 2017). Quaternion CNNs for color images went further in a different direction by parameterizing each color transform as a rotation around the gray axis plus scaling, which can be read as a highly constrained approximation class inside the space of all $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$6 color-mixing transforms (Zhu et al., 2019).

A more modular use of quaternion approximation appears in domain prompt learning for vision-LLMs. There, quaternion layers are inserted as targeted fusion modules that pack generalized contextual embeddings and domain-specific vision features into orthogonal quaternion axes, using small quaternion blocks rather than a fully quaternionized backbone. On the RSICD dataset, the ablation “Ours w/o QN” reports HM $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$7, whereas the full quaternion version reports HM $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$8, indicating that quaternion fusion provided a stronger inductive bias than the corresponding real-valued fusion block (Cao et al., 2023).

Low-rank tensor approaches supply a still different approximation regime. “Quaternion tensor low rank approximation” defines QT-product, QT-SVD, QT-rank, and non-convex quaternion tensor $$\begin{aligned} p \otimes q &= (p_r q_r - p_i q_i - p_j q_j - p_k q_k) \ &\quad + (p_r q_i + p_i q_r + p_j q_k - p_k q_j)\mathbf{i} \ &\quad + (p_r q_j - p_i q_k + p_j q_r + p_k q_i)\mathbf{j} \ &\quad + (p_r q_k + p_i q_j - p_j q_i + p_k q_r)\mathbf{k}. \end{aligned}$$9-norms, and uses them for completion and denoising. The paper explicitly frames this framework as a mathematical and algorithmic backbone for Quaternion Approximate Networks, since it allows quaternion-valued linear operators and low-rank approximations of quaternion tensors through Tucker, TT, and QT-based ranks (Zahir et al., 2024). This suggests a taxonomy in which QUAN’s separable Hamilton-inspired real convolutions, EdgeLDR’s block-circulant LDR operators, and QT-based low-rank tensor factorizations are all legitimate quaternion approximation strategies, but they constrain different parts of the operator class.

6. Limitations, misconceptions, and open directions

The principal limitation stated in the QUAN formulation is approximation error relative to exact quaternion algebra. By dropping cross-component terms, QUAN is “not a faithful Hamilton product”; by the same token, it does not provide formal group-equivariance guarantees. The paper also reports that inference can still be slightly slower than standard real convolutions in some settings, and that on large datasets such as COCO and DOTA the small QUAN models underperform YOLO baselines, although they do so with substantially fewer parameters (Grant et al., 5 Sep 2025).

A second limitation concerns modality assumptions. QUAN’s Poincaré mapping and four-component structure are tailored primarily to RGB and similar 3–4 channel inputs. The paper explicitly remarks that other modalities may require different mapping strategies (Grant et al., 5 Sep 2025). Related quaternion prompt-learning work also leaves two quaternion axes effectively unused in its main formulation, placing one modality on the real axis and another on the $4\times 4$0-axis while setting $4\times 4$1 and $4\times 4$2 to zero or noise. That design choice demonstrates practical utility, but it also indicates unused representational degrees of freedom (Cao et al., 2023).

A third limitation is optimization theory. The broader quaternion backpropagation literature shows that naïve quaternion derivatives are mathematically inconsistent because product and chain rules fail, and that valid training requires GHR calculus or an equivalent real-valued implementation that preserves the same structure (Pöppelbaum et al., 2022). This has a direct implication for approximate or quantized quaternion models: approximations that break the algebraic relations too aggressively may cease to correspond even approximately to a valid quaternion network.

Open directions are explicit in the neighboring papers. EdgeLDR lists hardware-aware implementations, kernel fusion, efficient FFTs on accelerators, combining LDR structure with quantization, and approximation bounds for quaternion block-circulant operators as open problems (Frants et al., 8 Jan 2026). Quaternion tensor low-rank approximation suggests QT-product-based factorization and non-convex low-rank penalties as natural mechanisms for compressing quaternion weights or feature maps (Zahir et al., 2024). Domain prompt learning suggests extending quaternion blocks deeper into Transformers and using all four axes more deliberately for different modalities or uncertainty factors (Cao et al., 2023). A plausible implication is that future QUAN variants will combine several of these strategies simultaneously: separable Hamilton-inspired real operators for runtime practicality, structured quaternion parameterizations for stronger compression, and QT-based low-rank regularization for further control of model capacity.