---
title: 'BiVM: Diverse Approaches in AI & Digital Systems'
url: https://www.emergentmind.com/topics/bivm
type: topic
---

# BiVM: Diverse Approaches in AI & Digital Systems

In recent arXiv literature, **BiVM** is not a single standardized term but an overloaded label applied to several technically unrelated constructs. It appears as the name of an accurate and resource-efficient **Binarized neural network for Video Matting**, as a shorthand for **“BiVM”-style** binary and ultra-low-precision post-training quantization in vision-language models, as **bitline-voltage-based CiM/mapping** in digital computing-in-memory, as a **bi-directional Vision Mamba** formulation via LBMamba and LBVim, and as an expository shorthand for the **bilinear Vector AMP** family centered on BiG-VAMP [2507.04456] [2509.18763] [2201.01509] [2506.15976] [2009.06854]. Correct interpretation therefore depends on the surrounding research area, mathematical formalism, and implementation context.

## 1. Terminological scope and disambiguation

The term is used in multiple communities with distinct expansions and technical referents.

| Usage of “BiVM” | Meaning in the cited work | Representative paper |
|---|---|---|
| Video matting | **Binarized neural network for Video Matting** | "BiVM: Accurate Binarized Neural Network for Efficient Video Matting" [2507.04456] |
| Vision-language compression | **“BiVM”-style** ultra-low-precision PTQ for VLMs | "Bi-VLM: Pushing Ultra-Low Precision Post-Training Quantization Boundaries in Vision-Language Models" [2509.18763] |
| Digital CiM | **bitline-voltage-based CiM/mapping** | "ADRA: Extending Digital Computing-in-Memory with Asymmetric Dual-Row-Activation" [2201.01509] |
| Vision SSMs | **bi-directional Vision Mamba** via LBMamba/LBVim | "LBMamba: Locally Bi-directional Mamba" [2506.15976] |
| Bilinear inference | **bilinear Vector AMP** family, especially BiG-VAMP | "Bilinear Generalized Vector Approximate Message Passing" [2009.06854] |

A common source of confusion is to assume that these usages denote variants of one method family. They do not. The shared prefix **“Bi”** refers to different concepts in different papers: **Binarized**, **bitline-voltage**, **bi-directional**, or **bilinear**. This suggests that BiVM functions primarily as local shorthand within subfields rather than as a globally stable acronym.

## 2. BiVM as a binarized network for video matting

In video matting, BiVM is a 1-bit architecture designed for real-time deployment on edge hardware [2507.04456]. The task is to estimate an alpha matte $\alpha$ and foreground $F$ for a frame $I$ given background $B$, following the compositing equation
$$
I = \alpha F + (1 - \alpha) B.
$$
The paper explicitly targets the failure mode of naïve binarization in lightweight matting networks: encoder representations collapse under the information loss induced by the sign operator, while decoder computation remains dense in prediction-irrelevant regions. The analysis is framed through the information bottleneck objective
$$
\min_{p(t|x)} L_{IB} = I(X;T) - \beta I(T;Y),
$$
with the empirical claim that direct binarization sharply reduces both $I(X;T)$ and $I(T;Y)$.

The architecture remedies these defects through three components. The first is a binarization-friendly encoder with **elastic shortcuts and evolvable topology (EBB)**. EBB replaces grouped or pointwise-only MobileNetV3 convolutions with non-grouped regular convolutions, adds learnable elastic shortcuts at layer-wise, cross-layer, and block-wise granularity, and allows the effective topology to evolve during training through shortcut gates regularized by
$$
L_{EBB} = \sum_{i=1}^B (\gamma_i^C + \gamma_i^B).
$$
The second is a **sparse heterogeneous binarization (SHB)** decoder, which masks homogeneous parts so that high-resolution decoder computation is concentrated on incoherent regions. The incoherent-region mask is defined from low-resolution features by
$$
m_{inc}^{\tau} = \mathrm{bool}\!\left(|f_{N/16} - S_{\uparrow}(S_{\downarrow}(f_{N/16}))| - \tau\right),
$$
and the threshold is selected by entropy maximization over masked binarized features. The third is **localized binarization-aware mimicking (LBM)**, a teacher-student distillation mechanism localized to the most information-bearing regions:
$$
L_{LBM} = \sum_{f \in F} \left\| m_{inc}^{\tau^*} \odot \left( \frac{f^2}{\|f^2\|_2} - \frac{f^2_{FP}}{\|f^2_{FP}\|_2} \right) \right\|_2 .
$$

BiVM binarizes both weights and activations. The binarization rule is
$$
b = \mathrm{sign}(x) \in \{-1,+1\},
$$
with
$$
b_w = \mathrm{sign}(w), \qquad b_a = \mathrm{sign}(a - \tau),
$$
and a per-layer scale $s = \mathrm{mean}(|w|)$ so that the forward operator becomes
$$
o = s (b_w \otimes b_a),
$$
implemented via XNOR-popcount on ARM CPUs. The sign gradient is approximated by a clipped straight-through estimator,
$$
\frac{\partial \mathrm{sign}(x)}{\partial x} \approx 1_{|x| \leq 1}.
$$
As customary, the very first and very last layers remain in full precision.

Training proceeds in four stages following RVM. The EBB encoder is first pretrained on ImageNet for 200 epochs using
$$
L_{pre} = L_{CE} + \lambda_{EBB} L_{EBB},
$$
with $\lambda_{EBB} = 1e^{-4}$. Matting optimization then uses
$$
L^{M} = L_{l1}^{\alpha} + L_{lap}^{\alpha} + 5 L_{tc}^{\alpha} + L_{l1}^{F} + 5 L_{tc}^{F},
$$
and
$$
L_{matting} = L^{M} + \lambda_{LBM} L_{LBM},
$$
with $\lambda_{LBM} = 1e^{-4}$.

The reported empirical gains are substantial. On VM at low resolution, BiVM (1-bit) improves over ReActNet-binarized RVM (1-bit) from **MAD 28.49 to 11.82** and from **MSE 18.16 to 5.75**. At high resolution on VM, it improves over ReAct RVM (1-bit) from **SAD 31.60 to 14.54**, from **MSE 20.29 to 8.19**, and from **dtSSD 4.08 to 3.17** [2507.04456]. The system reports **14.3x FLOPs reduction**, **21.6x parameter size reduction**, **13.2x faster on ARM CPUs**, and **52.6%** decoder FLOPs reduction via SHB. The paper also states that BiVM surpasses alternative binarized video matting networks, including state-of-the-art binarization methods, while bringing high-quality video matting closer to real-time on edge devices.

## 3. “BiVM”-style ultra-low-precision quantization for vision-language models

In the vision-language model literature, the directly named method is **Bi-VLM**, but the paper’s summary describes it as a **binary/ultra-low-precision PTQ method (“BiVM”-style) for VLMs** [2509.18763]. Its purpose is to push post-training quantization to **bitwidth $\leq 2$ bits** for weights while preserving accuracy on VLMs such as **LLaVA**, **Llama-3.2-Vision**, and **Qwen2.5-VL**.

The central mechanism is a non-uniform partition of each layer’s weights according to **Gaussian quantiles**. For layer $l$ with weights $W_l$, the method assumes a symmetric, near-Gaussian empirical distribution with mean $\mu_l$ and standard deviation $\sigma_l$. A salient upper percentile $p_l^{sal}$ defines an outlier tail, while the remaining mass is divided into $N_{uns}$ equal inlier bands. With $\Phi$ denoting the standard normal CDF and $\Phi^{-1}$ its inverse,
$$
z^{(k)} = \Phi^{-1}\!\left(\frac{1 + k \cdot p_l^{uns}}{2}\right), \qquad p_l^{uns} = \frac{1 - p_l^{sal}}{N_{uns}},
$$
and the subsets are
$$
S_l = \{ w \in W_l : |w| > \mu_l + \sigma_l z^{(N_{uns})} \},
$$
$$
S_l^{c(k)} = \{ w \in W_l : \mu_l + \sigma_l z^{(k-1)} < |w| \leq \mu_l + \sigma_l z^{(k)} \}.
$$
Salient weights are quantized to **2-bit** precision, while inlier weights are **binarized (1-bit)**. The paper reports that outliers are rare but impactful, at **≈5% in vision encoders** and **≈1% in language models**.

The quantization objective is a unified reconstruction loss
$$
\min \|W - AB\|_F^2,
$$
where $A = \mathrm{diag}(a_1,\dots,a_m)$ is a row-wise scaling matrix and $B$ holds quantized entries in $[-1,1]$. The layer decomposition is
$$
W_l = W_l^{sal} + \sum_{k=1}^{N_{uns}} W_l^{uns(k)}.
$$
For the salient component, Bi-VLM solves
$$
\min \|W_l^{sal} - a \odot B_l^{sal}\|_F^2,
$$
with row-wise scales and 2-bit discrete values, using alternating least squares plus adaptive level mapping. For the inlier bands, the optimization is strict binarization with one scalar per group:
$$
\min \|W_l^{uns(k)} - a_l^{uns(k)} B_l^{uns(k)}\|_F^2,
$$
with
$$
B_l^{uns(k)*} = \mathrm{sign}(W_l^{uns(k)}), \qquad
a_l^{uns(k)*} = \frac{\langle W_l^{uns(k)}, B_l^{uns(k)} \rangle}{\|B_l^{uns(k)}\|_F^2}.
$$

A layer-wise salient percentile is then selected by bounded gradient-free search. Using a calibration set of **64 samples**, the paper minimizes the normalized reconstruction error
$$
J(p; W_l, N_{uns}, N_b)
= \frac{
\|W_l^{sal} - a \odot B_l^{sal}\|_F^2
+ \sum_k \|W_l^{uns(k)} - a_l^{uns(k)} B_l^{uns(k)}\|_F^2
}{
\|W_l\|_F^2
},
$$
subject to $p \in [0, p_l^{sal,max}]$, with **Brent’s method** used to obtain $p_l^{sal,opt}$.

The implementation is layer-wise and is applied to both the language model and the vision encoder. The paper states that the **vision encoder is highly sensitive to ultra-low-bit weight quantization on average**, the **adaptor/projector is less sensitive**, and the **LM is considerably sensitive**. Activations are not quantized: inference keeps activations in **FP16/FP32**. A practical policy uses **2 bits for salient weights** and **1 bit for inliers**, with **$p_l^{sal,max} \approx 1\%$ for LM layers** and **up to $\approx 5\%$ for vision layers**.

Across **Llama 3.2-Vision Instruct 11B**, **Llava-One-Vision 7B**, and **Qwen2.5-VL-7B-Instruct**, the paper reports that for the **language model part**, Bi-VLM outperforms the SOTA by **3%-47%**, and for the **overall VLM**, it outperforms the SOTA by **4%-45%** across **MME**, **MMMU**, **ScienceQA-IMG**, and **VizWiz-VQA** [2509.18763]. It also reports average storage down to **~1.01 bits/weight** in one configuration, assuming 16-bit scales. A further observation is that, after quantization, **image tokens exhibit 90%–99% redundancy**. Attention-based token saliency analysis motivates pruning image tokens inside the LM rather than inside the vision encoder, with **≈86%–95%, up to 99%** of image tokens removable under limited accuracy drop. This places Bi-VLM at the intersection of quantization and structured token reduction rather than simple 1-bit compression alone.

## 4. BiVM as bitline-voltage mapping in digital computing-in-memory

In digital computing-in-memory, **BiVM** refers to the **bitline-voltage-based CiM/mapping** induced by simultaneous activation of two rows in a memory array [2201.01509]. Here the term does not denote a neural model; it denotes the analog-to-digital mapping from stored bits $(A_i,B_i)$ to a bitline or senseline quantity such as $V_{BL}$ or $I_{SL}$, and then to sensed Boolean or arithmetic outputs.

Under conventional symmetric dual-row activation with identical wordline bias $V_{WL} = V_{GREAD}$, the sensed current is
$$
I_{SL} = I_{cell}(A_i; V_{GREAD}) + I_{cell}(B_i; V_{GREAD}),
$$
with
$$
I_{cell}(x; V_{GREAD}) =
\begin{cases}
I_{LRS}, & x=1 \\
I_{HRS}, & x=0 .
\end{cases}
$$
The four bit patterns produce three distinct analog levels:
- $(0,0) \Rightarrow I_{00} = I_{HRS} + I_{HRS}$
- $(0,1) \Rightarrow I_{01} = I_{HRS} + I_{LRS}$
- $(1,0) \Rightarrow I_{10} = I_{LRS} + I_{HRS}$
- $(1,1) \Rightarrow I_{11} = I_{LRS} + I_{LRS}$

Because the activation is symmetric,
$$
I_{01} = I_{10},
$$
so the mapping is many-to-one. This allows commutative functions such as **AND**, **OR**, **XOR**, and addition, but it prevents direct one-access realization of non-commutative operations such as subtraction and comparison.

The paper introduces **ADRA (Asymmetric Dual-Row Activation)** to remove this BiVM ambiguity by using different read biases on the two asserted wordlines:
$$
V_{WL1} = V_{GREAD1}, \qquad V_{WL2} = V_{GREAD2}, \qquad V_{GREAD2} > V_{GREAD1}.
$$
Then
$$
I_{01} = I_{HRS}(V_{GREAD1}) + I_{LRS}(V_{GREAD2}),
$$
$$
I_{10} = I_{LRS}(V_{GREAD1}) + I_{HRS}(V_{GREAD2}),
$$
and in general $I_{01} \neq I_{10}$. In voltage-mode sensing,
$$
V_{BL}(t_{eval}) \approx V_{READ} - \frac{t_{eval}}{C_{BL}} I_{SL},
$$
so all four input cases can map to distinct discharge levels. This one-to-one mapping enables a third sense amplifier to resolve operand identity, not only commutative functions.

The paper shows that ADRA can deliver, in one memory access, **OR**, **AND**, and **B**, with **A** reconstructed digitally by
$$
A = (A + B)\overline{B} + (AB)B.
$$
With $A$ and $B$ available, arbitrary two-input Boolean functions follow. The same mechanism enables non-commutative arithmetic. For subtraction,
$$
D_i = A_i \oplus B_i \oplus b_i,
$$
$$
b_{i+1} = \overline{A_i} B_i \lor ((\overline{A_i} \oplus B_i) b_i),
$$
and comparison $A ? B$ is derived from the subtraction result. The core point is that asymmetric BiVM distinguishes $(0,1)$ from $(1,0)$ at the analog level, which is the missing information in conventional symmetric schemes.

The implementation is demonstrated for **FeFET-based non-volatile memory**, where the threshold shift obeys
$$
\Delta V_{th} = \alpha P_r,
$$
and the read current follows a MOSFET-like law
$$
I_D \approx \frac{1}{2} \mu_n C_{ox} \frac{W}{L} (V_{GS} - V_{th})^2.
$$
For the evaluated stack, the paper reports **$V_{READ} = 1.0$ V**, **$V_{GREAD2} = 1.0$ V**, **$V_{GREAD1} = 0.83$ V**, and sense margins of **> 1 $\mu$A** in current mode and **> 50 mV** in voltage mode. Against a near-memory baseline requiring two full accesses per operation, ADRA reduces **EDP by 23.2%–72.6%**, with **speedup ≈ 1.94x** and **energy ↓ 41.18%** in one current-mode configuration, while the additional hardware overhead is reported as **2.9% to 10.4%** at full parallelism, or **0.34%–3.16%** with 4:1 column multiplexing [2201.01509].

## 5. BiVM as bi-directional Vision Mamba

In the state-space-model literature, the phrase **“bi-directional Vision Mamba” (BiVM)** is used to describe the design realized by **LBMamba** and the **LBVim** backbone [2506.15976]. The underlying problem is that standard Mamba is unidirectional: each state depends only on previous states. Prior vision variants typically restore future context with a full backward scan, but that doubles the computational load.

LBMamba avoids the extra global sweep by embedding a **lightweight local backward scan inside the forward selective scan**. The forward Mamba recurrence is
$$
h_t^f = \bar{A}^f h_{t-1}^f + \bar{B}^f x_t,
\qquad
y_t^f = C^f h_t^f + D^f x_t,
$$
with input-dependent parameterization
$$
\bar{A}_t^f = \exp(\Delta_t A^f), \qquad
\bar{B}_t^f = \Delta_t B^f(x_t), \qquad
C_t^f = C^f(x_t), \qquad
\Delta_t = \mathrm{softplus}(\Delta(x_t)).
$$
The local backward recurrence is computed inside each thread-private tile of size $M$:
$$
h_t^b =
\begin{cases}
B^f x_t, & t \% M = 0 \\
\bar{A}^f h_{t+1}^b + \bar{B}^f x_t, & \text{otherwise}
\end{cases}
$$
and the fused state is
$$
h_t = h_t^f + (h_t^b - B^f x_t),
\qquad
y_t = C^f h_t + D^f x_t.
$$
The crucial implementation detail is that this backward aggregation is executed entirely in **per-thread registers**, so it incurs almost no extra memory traffic or inter-thread communication.

Global context is recovered across depth rather than within one layer. LBVim alternates scan direction every two layers by reversing the token sequence at the end of each encoder. A forward scan on the reversed sequence is effectively a backward scan in the original order. The paper states that this recovers a global receptive field **without ever doing an extra global backward sweep**. Effective receptive field visualizations are reported to support this claim.

The method uses a hardware-aware tile size rule:
- **$L > 256 \rightarrow M = 16$**
- **$128 < L \leq 256 \rightarrow M = 8$**
- **$L \leq 128 \rightarrow M = 4$**

At kernel level, LBMamba incurs **+27% FLOPs** relative to the vanilla Mamba kernel, but only a **1.9–2.3% throughput drop**, with **GPU memory unchanged**. At backbone level, replacing a conventional bi-directional sweep with LBVim yields much larger savings. For example, at **256×256**, **Vim-Ti** is reported at **2.1G FLOPs, 795 img/s, 755M memory**, while **LBVim-Ti** is **1.9G FLOPs, 1421 img/s, 608M memory**; analogous throughput gains of roughly **79%–83%** are reported at **512×512** and **1024×1024** [2506.15976].

Accuracy results are reported under matched throughput budgets. On **ImageNet-1K**, **LBVim-300** at **906 img/s** reaches **77.7% top-1**, versus **76.1%** for **Vim-Ti** at **889 img/s**; **LBVim-528** reaches **81.1%** versus **80.3%** for **Vim-S** at similar speed. On **ADE20K**, the same-throughput gains are **0.6% to 2.7% higher mIoU**. On **COCO**, the paper reports **0.9% higher APb** and **1.1% higher APm**. Integration into **MambaMIL** for whole-slide images yields up to **3.06% better AUC**, **3.39% better F1**, and **1.67% better accuracy** on public datasets. In this usage, BiVM denotes a bidirectionality strategy for SSMs rather than binarization or compression.

## 6. BiVM as bilinear Vector AMP and the BiG-VAMP family

A different expository use treats **BiVM** as the **bilinear Vector AMP** family, particularly the **Bilinear Generalized VAMP (BiG-VAMP)** algorithm [2009.06854]. This usage arises in probabilistic inference rather than neural network design.

The canonical bilinear model is
$$
Y = Z + W, \qquad Z = U V^T,
$$
with unknown factors $U \in \mathbb{R}^{N \times r}$ and $V \in \mathbb{R}^{M \times r}$ and additive Gaussian noise $W$. More generally, the output channel is separable:
$$
p(Y|Z) = \prod_{i=1}^{N} \prod_{j=1}^{M} p(y_{ij}|z_{ij}),
$$
which allows non-Gaussian observations such as quantization and erasures. The factor priors are row-separable,
$$
p(U) = \prod_{i=1}^N p_u(u_i), \qquad p(V) = \prod_{j=1}^M p_v(v_j),
$$
and a temperature parameter $\beta \in \{1, +\infty\}$ unifies MMSE and MAP formulations.

BiG-VAMP is described as a loopy-BP approximation in the VAMP style. It splits each of $U$, $V$, and $Z$ into Gaussian-extrinsic copies and alternates three modules: a **bi-LMMSE** module, **prior denoisers** for $U$ and $V$, and an **output denoiser** for $Z$. The prior denoisers are
$$
\widehat{u}_{i,p}^{+} = g_u(\widehat{u}_{i,e}^{-}; \gamma_{U,e}^{-1}),
\qquad
\widehat{v}_{j,p}^{+} = g_v(\widehat{v}_{j,e}^{-}; \gamma_{V,e}^{-1}),
$$
while the output denoiser is
$$
\widehat{z}_{ij,p}^{+} = g_z(y_{ij}, \widehat{z}_{ij,e}^{-}, \gamma_{Z,e}^{-1}).
$$
The bi-LMMSE step updates posterior means and covariances through $r \times r$ precision blocks $\Lambda_U$ and $\Lambda_V$, along with extrinsic corrections that play the role of Onsager terms. The linear-output special case **Bi-VAMP** is obtained by setting $\widehat{Z}_e^+ = Y$ and $\gamma_{Z,e}^+ = \gamma_w$.

A defining feature is the accompanying **state evolution (SE)** theory, which predicts asymptotic empirical mean-squared error under matched priors and channels. The paper reports close agreement between SE and empirical performance in **matrix factorization**, **dictionary learning**, and **matrix completion**, and uses the SE framework to examine phase transitions, including a **low detectability region** in matrix completion at low SNR [2009.06854]. The algorithm is explicitly positioned against **BiG-AMP**, **BAd-VAMP**, and **LowRAMP**, with the claim that BiG-VAMP accommodates a broader class of structured priors and generalized output channels while improving robustness and accuracy.

This interpretation of BiVM is conceptually far removed from the others. Here the central objects are posterior means, divergences, extrinsic precisions, and large-system asymptotics, not binary networks, token pruning, memory circuits, or bidirectional scans.

## 7. Cross-domain interpretation and common misconceptions

Several misconceptions recur when the term is encountered without context. The first is that **BiVM is a single method family**. The cited literature does not support that reading. In one case it is a named 1-bit video matting architecture with EBB, SHB, and LBM [2507.04456]; in another it is the bitline-voltage mapping abstraction whose ambiguity ADRA resolves in digital CiM [2201.01509]. In the state-space literature, it denotes a bi-directional Vision Mamba strategy implemented through LBMamba and LBVim [2506.15976]. In bilinear inference, it can denote the bilinear Vector AMP family around BiG-VAMP [2009.06854]. In VLM compression, the named method is **Bi-VLM**, while the summary characterizes it as **“BiVM”-style** rather than formally titling it BiVM [2509.18763].

A second misconception is that the shared prefix **“Bi”** implies a shared mechanism. It does not. In the cited papers, **“Bi”** refers respectively to **Binarized**, **bitline-voltage**, **bi-directional**, or **bilinear**. This suggests that lexical similarity is accidental at the level of research practice, even though all usages concern some form of efficiency, asymmetry, or dual structure.

A third misconception is that all BiVM-related work is about low-bit neural inference. That description fits the video matting network and the Bi-VLM quantization framework, but not the CiM mapping formalism, the LBMamba/LBVim vision backbone, or BiG-VAMP. Conversely, the CiM and bilinear-inference uses are not neural compression methods in the ordinary sense.

For technical reading, the most reliable disambiguators are the equations and implementation primitives. If the paper discusses **XNOR-popcount**, **alpha mattes**, and **ARM CPU** deployment, it is the video-matting BiVM. If it discusses **Gaussian quantiles**, **salient percentile search**, and **1–2 bit PTQ** for VLMs, it is the Bi-VLM line. If it centers on **wordline biases**, **sense amplifiers**, and **$I_{01} \neq I_{10}$**, it is the CiM BiVM. If it uses **selective scan**, **register-resident local backward windows**, and **sequence reversal**, it is the bi-directional Vision Mamba usage. If it uses **posterior denoisers**, **extrinsic precisions**, and **state evolution**, it is the bilinear VAMP interpretation.

Source: https://www.emergentmind.com/topics/bivm