Compression Erases What a Prompt Says Before It Erases What Script It Is In

Text-to-image generators already fail people who prompt in non-Latin scripts. Asked for a stove or a house in Hindi or Bengali, Stable Diffusion often draws a deity, a turban, or a generic "Asian couple." The script of the prompt overrides what the prompt actually asks for. Separately, the compression used to fit large models onto phones and cheap servers is known to hurt rare languages and minority groups first. Pruning removes weights, quantization lowers their numerical precision, and distillation trains a smaller copy. Nobody has asked what happens when the two meet, even though compressed, on-device generators are exactly what many non-Latin-script users will run.

This proposal makes a specific, testable claim about that meeting point. Inside the text encoder, the part of the generator that turns a prompt into a vector, a non-Latin prompt's representation can be split into two parts. One is a large shared component that just says "this is Devanagari" or "this is Hangul." The other is a small prompt-specific component that says "stove" rather than "house." Compression methods minimize overall reconstruction error. That error is dominated by the large shared component, so they keep it and discard the small one. The prediction is that compressed generators fall back on script stereotypes more often than uncompressed ones. We then test whether a compression objective that explicitly preserves the prompt-specific part fixes this, and whether it beats simpler remedies.

Core Claim

For a text encoder $f$ and a prompt $p$ written in script $s$, write

$$f(p) = \mu_s + r(p),$$

where $\mu_s$ is the mean encoder output over a reference set of prompts in script $s$ (the "script centroid") and $r(p)$ is the remainder, which carries what distinguishes this prompt from others in the same script. Define the centroid dominance of a script as $D_s = \lVert \mu_s \rVert^2 / \mathbb{E}_p \lVert r(p) \rVert^2$.

The claim has three parts. First, compression error falls disproportionately on $r$, so $D_s$ rises after compression. Second, the rise in $D_s$ predicts the loss of semantic correctness and of within-language diversity in the generated images. Third, scripts whose uncompressed $D_s$ is already high suffer most.

This is a mechanism, not just an audit. It connects the "cultural default" behaviour found by Navigating Text-to-Image Generative Bias Across Indic Languages to the capacity-crunch story from multilingual compression. That paper shows, on uncompressed models only, that native-script prompts collapse into a few archetypes and lose distinctiveness. What Do Compressed Multilingual Machine Translation Models Forget? found that 30% magnitude pruning of M2M-100 cost very-low-resource languages nearly 40% of their performance, while average BLEU under 8-bit quantization barely moved.

The research file contains no study that compresses a text-to-image text encoder or diffusion model and audits script or homoglyph behaviour. The closest work differs as follows:

The proposal also has to face a constraint from that second paper. Quantization moved demographic bias in no consistent direction across models. If script effects under compression turn out just as erratic, the claim is wrong, and our design reports that outcome rather than hiding it.

Research Program

Models. We work with two generators that differ in how multilingual their text encoder is. Stable Diffusion v1.5 uses an English-centric CLIP text encoder. AltDiffusion uses a multilingual encoder, which earlier work found less sensitive to homoglyphs (Exploiting Cultural Biases via Homoglyphs). The pairing matters because of a floor effect: Navigating Text-to-Image Generative Bias Across Indic Languages reports Stable Diffusion's semantic correctness falling to as low as 7.3% in some Indic languages. For those languages compression has little left to destroy. We therefore expect the native-script signal to show mainly on AltDiffusion and on Devanagari-script languages, where the uncompressed baseline is higher.

Two kinds of prompt. Homoglyph prompts serve as a clean causal probe. A single swapped character changes the script but leaves the meaning untouched, so any rise in cultural attributes isolates the centroid push. Native Indic prompts from IndicTTI are the deployment target, where the remainder $r$ is the meaning the user actually wants.

Compression conditions. We match the settings used in prior work so results are comparable:

Locating the damage. We compress three parts of the generator separately: the text encoder alone, the cross-attention projections alone (the layers that let the image generator read the text vectors), and the image-generating network alone. This answers the localization question that no paper in the file addresses.

The method: residual-preserving compression. We replace the usual full-output reconstruction loss used to calibrate quantization, select pruning masks, or train distilled students. The new loss is a per-script, normalized error on the remainder:

$$\mathcal{L} = \sum_{s} \frac{\mathbb{E}_{p \in s} \lVert \tilde r(p) - r(p) \rVert^2}{\mathbb{E}_{p \in s} \lVert r(p) \rVert^2} + \lambda \, \mathbb{E}_{p} \lVert \tilde f(p) - f(p) \rVert^2 .$$

Here $\tilde f$ is the compressed encoder, $\tilde r(p) = \tilde f(p) - \tilde\mu_s$ is its remainder with $\tilde\mu_s$ recomputed from the compressed encoder, and $\lambda$ weights an ordinary full-output term.

The normalization is the key ingredient. Without it, the loss is dominated by the scripts and components with the largest norm. This is the same failure that group-blind objectives produce in pruning, as documented by FairGRAPE and Balancing Act.

The objective deliberately preserves $\mu_s$ rather than erasing it. Script association is also how users legitimately ask for regional content, the dual-use problem noted by Struppek et al. We therefore separately check that culturally specific prompts, such as "a woman in a saree" written in Hindi, still produce the right content.

Measurement. All evaluators stay uncompressed and fixed. These are BLIP-2 for the visual question-answering probe, the round-trip captioner for IndicTTI's correctness metrics, and CLIP for Relative Bias. Because the Indic paper warns that these evaluators carry their own biases, we add a human-annotated sample of 500 images per condition. We report agreement between the automatic and human judgments.

Baselines

Uncompressed reference. The first reference is the uncompressed model. For Stable Diffusion, IndicTTI reports semantic correctness of 64.5% in English, falling to as low as 7.3% in Indic languages (Navigating Text-to-Image Generative Bias Across Indic Languages). We re-run it on our hardware rather than relying on those figures. Every compressed condition is reported as a change from this re-run.

Naive compression. The do-nothing compression baseline is standard compression with default English or LAION calibration data and an ordinary full-output or task loss. This is what a practitioner shipping an on-device model would actually do. It matches our method in sparsity, bit-width, student size, and calibration budget. For CLIP-family models in this setting, the reported reference point is that most FACET scenarios showed no statistically significant change in disparity (p > 0.05) under 8-bit quantization (You Never Know). The file has no reported script-level result for it.

Script-balanced compression. The strongest competitor uses the ordinary full-output objective, but with calibration and distillation data balanced across the 10 IndicTTI scripts. For pruning it adds FairGRAPE-style group-wise importance, with scripts as the groups (FairGRAPE). On face attributes, FairGRAPE reduced degradation disparity by up to 90% relative to SNIP and GraSP. There is no reported result on Lacuna for FairGRAPE or script-balanced calibration on text-to-image or script bias.

This competitor is the real threat. It addresses the same imbalance with less machinery. It receives the identical data pool, the same number of calibration prompts and optimization steps, and its own hyperparameter search with the same tuning budget as ours.

Homoglyph Unlearning after compression. We apply Homoglyph Unlearning to the compressed encoder, as a post-hoc repair. The reported uncompressed numbers are a Relative Bias reduction of up to 90%, a 1.16-point drop in ImageNet top-1, and an FID change of 0.17 (The Biased Artist).

Ablation. The ablation isolating our key ingredient keeps the same balanced data and the residual decomposition but removes the per-script normalization.

What counts as beating the competitors. Our method must beat script-balanced compression on the drop in IndicTTI's Cyclic Language-Grounded Correctness and Distinctiveness Within Language, averaged over Indic languages. The margin must exceed the seed-to-seed standard deviation. At the same time it must stay within the Homoglyph Unlearning cost envelope on MS-COCO FID and ImageNet zero-shot accuracy. Matching script-balanced compression would mean the decomposition is unnecessary, and we would report that.

Why not just…?

Why not just normalize Unicode before the prompt reaches the model? For homoglyph attacks this largely works, and we do not claim otherwise. That is why homoglyphs are used here only as a controlled probe. Normalization does nothing for legitimate Devanagari or Bengali prompts, which contain no homoglyphs. Struppek et al. also note that lookalike characters spread across many Unicode blocks, so aggressive mapping damages genuine non-English text (Exploiting Cultural Biases via Homoglyphs). The native-script results are the part of this proposal normalization cannot touch.

Why not just translate every prompt to English first? On-device, the translator must also be compressed. The one compressed-translation study in the file found 30% pruning nearly doubled off-target translations, from 5.9% to 13.7%, and hit very-low-resource languages hardest (What Do Compressed Multilingual Machine Translation Models Forget?). It is still a serious baseline. We include a translate-then-generate pipeline using the same pruned M2M-100 setting and compare its IndicTTI scores and total parameter budget against our native-script compressed models. If it wins at equal size, that is a useful negative result.

Why not just balance the calibration data across scripts? This is the most plausible simple fix, and it may be enough for quantization, where only a calibration set is involved. Our argument that it falls short is specific. Balanced data with an unnormalized full-output loss still lets each script's large centroid dominate that script's error, so the small remainder can still be sacrificed. The ablation that differs only in normalization settles this directly. If the two methods tie, the mechanism is wrong for that compression type, and we recommend the simpler method.

Why not just run Homoglyph Unlearning after compressing? That method aligns homoglyph prompts to Latin ones. It has no target for native-script prompts, where there is no Latin version with the same characters to align to. It could also remove legitimate regional association. It is included as a baseline on the homoglyph probe, where it should be strong. The question is whether it helps IndicTTI at all.

Proposed Experiments and Decisive Checks

Benchmarks. The experiments use IndicTTI's 1,000 COCO-derived prompts in 30 languages and 10 scripts, scored with Cyclic Language-Grounded Correctness, Image-Grounded Correctness, Self-Consistency Across Languages, and Distinctiveness Within Language. They also use the People, Buildings, and Misc homoglyph prompt sets with Relative Bias and the visual question-answering score. MS-COCO FID and ImageNet zero-shot accuracy measure general quality. All of this runs over the compression grid and the three locations described above, with three seeds per condition.

Check 1: does the mechanism hold? Across every model, compression type, and script, the change in centroid dominance $D_s$ should be positive. It should also correlate with the drop in Distinctiveness Within Language and Cyclic Language-Grounded Correctness. We test whether the uncompressed $D_s$ predicts each script's eventual loss, for example whether Bengali-script languages, which the Indic paper found already worse than Devanagari, have higher $D_s$ and fall further. If the change in $D_s$ has no consistent sign across quantization settings, mirroring Slyman et al., the core claim fails for quantization. We then restrict it to pruning and distillation.

Check 2: does the homoglyph probe confirm it? If compression shrinks the remainder relative to the centroid, a single homoglyph should push images further toward cultural attributes in compressed models than in the uncompressed one. On Stable Diffusion v1.5 the uncompressed shift reported by The Biased Artist is from near 0% to over 67% "Asian appearance," which we first reproduce. The weak-learner account predicts a peak at 4- to 6-layer distilled students. The mechanism should also show up in longer, attribute-rich prompts, where homoglyph effects normally fade (Exploiting Cultural Biases via Homoglyphs), because those prompts carry a larger remainder.

Check 3: where does the damage come from? Compressing only the text encoder should account for most of the loss in script fidelity. Compressing only the image-generating network should mainly hurt FID. Cross-attention-only compression is the open case.

Check 4: does the method work, and does it keep legitimate cultural content? Residual-preserving compression must beat script-balanced compression on native-script correctness and distinctiveness at equal size and budget. It must also not lower the accuracy of explicitly cultural prompts, as judged by human annotators. Passing the first test while failing the second would mean we had erased culture rather than preserved meaning, and that would count as a failure of the method.