Arithmeettisen koodauksen piilotetut sudenkuopat: Miksi puristimesi hukkaa bittiä turhaan

Olet ehkä toteuttanut arithmeettisen koodauksen ja tuntenut itsesi neroeksi. Algoritmi muuntaa bittisekvenssit todennäköisyysväleiksi tyylikkäästi. Ongelma on, että netistä löytyvät perusversiot pettävät hiljaisesti.

Ei puhuta suorituskyvystä CPU-sykleissä (vaikka sekin on tärkeää). Kyse on puristussuhteesta – siitä, miksi entropy codingia ylipäätään käytetään.

Perustoteutus, joka pettää

Tyypillinen esimerkki menee suunnilleen näin:

let mut left: u32 = 0;
let mut right: u32 = u32::MAX;

fn encode_bit(bit: bool, probability: f32) {
    let mid = left + ((right - left) as f32 * probability) as u32;
    if !bit {
        right = mid;
    } else {
        left = mid + 1;
    }
    
    while left >> 24 == right >> 24 {
        output_byte((left >> 24) as u8);
        left <<= 8;
        right = (right << 8) | 0xff;
    }
}

Selkeää, eikö? Pidät yllä väliä [left, right], joka kutistuu bittien todennäköisyyksien mukaan. Kun yläbytit ovat samat, syljetät tavun ulos ja saat lisää tarkkuutta.

Vika? Toteutus on matemaattisesti epäsymmetrinen.

Tavurajan petos

Ihanteellisessa, äärettömän tarkassa mallissa samanpituiset välit käyttäytyvät samalla tavalla. 32-bittisessä versiossa ei.

Katsotaan kahta tapausta:

1. Väli alkaen left = 0 ei kutistu alle 2^24 bittiä.
2. Väli alkaen left = 2^31 - 1 voi supistua jopa 2 bittiin.

Syy on ehdossa left >> 24 == right >> 24. Se riippuu välin sijainnista, ei pelkästään pituudesta.

Kun väli ylittää tavurajan – kuten [2^31 - 1, 2^31] – se kutistuu vaarallisen pieneksi. Todennäköisyys 0.95 voi kvantittua 50/50-jaon takia. Tuloksena hukattuja bittejä, enemmän kuin entropiateoria lupaa.

Dekooderin salattu monimutkaisuus

Dekooderissa on samanlainen ongelma:

fn decode_bit(probability: f32) -> bool {
    let mid = left + ((right - left) as f32 * probability) as u32;
    if x <= mid {
        right = mid;
        bit = false;
    } else {
        left = mid + 1;
        bit = true;
    }
    
    while left >> 24 == right >> 24 {
        left <<= 8;
        right = (right << 8) | 0xff;
        x = (x << 8) | (bytes.next().unwrap() as u32);
    }
    
    bit
}

Se seuraa kolmea muuttujaa: left, right ja x. Matemaattisesti riittäisi välin pituus (right - left) ja pisteen paikka (x - left).

Tarkkuuslenkki pakottaa erilliset left ja right. Logiikka sitoo itsensä absoluuttiseen sijaintiin, ei suhteelliseen kokoon.

Seuraukset:

• Enemmän rekisteripainetta
• Heikommat optimoinnit
• Monimutkaisempi koodi

Kaikki turhan ehdon takia.

Ratkaisu edessä

Korjaus vaatii suhteen tarkkuuteen. Unohda yläbyttien vertailu (sijainnista riippuva). Siirry välin pituuteen perustuvaan syljetyslogiikkaan (sijainnista riippumaton).

Vaativa muutos koko enkooderi/dekooderi-silmukkaan. Palkinto? Parempi puristus, yksinkertaisempi ja nopeampi dekooderi.

Miksi tämä kiinnostaa NameOceanissa

NameOceanissa autamme kehittäjiä Vibe Hostingin AI-sovelluksista optimoiduille systeemeille. Puristatko pilvitallennukseen, API-payloadeihin tai massadatoihin? Nämä perusteet ratkaisevat.

Moni ottaa valmiin kirjasen ilman sen rajoja. 5–10 % parempi puristus ei tunnu miltään – ennen kuin skaalaat petatavuihin tai miljooniin pyyntöihin.

Oppi: "kirjan" toteutus ei ole täydellinen. Kaiva syvemmälle. Kyseenalaista epäsymmetriat. Huiput eivät kopioi algoritmeja – ne tuntevat reunaehtonsa.

Pilvi-infrastruktuurissa pienet algoritmikorjaukset kertautuvat miljoonissa pyynnöissä. Optimoi pinoasi fiksusti: yksityiskohdat ratkaisevat. Jos domainit tai hosting kaipaa boostia, tsekkaa NameOcean.