Prywatna decyzja kredytowa

Wiarygodny kredyt: pytanie o decyzję podjętą na podstawie prywatnych danych

Instytucja kredytowa publikuje swój model scoringowy. Wnioskodawca uruchamia go na własnych danych i przekazuje kredytodawcy potwierdzenie z napisem „approved” lub „declined”. Kredytodawca nigdy nie widzi danych, a wnioskodawca nie może zmienić modelu ani podać mu zmyślonych danych.

Wait — I must output only the translation. Here it is:

Kredytodawca publikuje swój model scoringowy. Wnioskodawca uruchamia go na własnych danych i przekazuje kredytodawcy potwierdzenie z napisem „approved” albo „declined”. Kredytodawca nigdy nie widzi tych danych, a wnioskodawca nie może zmienić modelu ani podać mu zmyślonych danych.

To najmniejszy użyteczny przykład dowodzenia obliczenia, w którym program i parametry są publiczne, a dane wejściowe prywatne. Model to dwuwarstwowa sieć neuronowa w arytmetyce całkowitoliczbowej. Ten sam schemat pasuje do każdej reguły, którą regulator lub kontrahent chce móc przeczytać: formuły wyceny, testu kwalifikowalności, limitu ryzyka.

Example programs zawiera konfigurację wspólną dla wszystkich czterech stron z przykładami.

1. Co to dowodzi

Trzy strony:

• Kredytodawca wdraża program z modelem jako jego segmentem publicznym. Identyfikator programu wskazuje ten model. Każdy może odczytać wagi z łańcucha.
• Attester (biuro informacji kredytowej, bank, pracodawca) zna dane wnioskodawcy. Przekazuje wnioskodawcy wartości cech, losową 16-bajtową sól oraz swój podpis pod zobowiązaniem SHA-256(salt ‖ features).
• Wnioskodawca wywołuje program, podając sól i cechy jako prywatne dane wejściowe.

Wywołanie dowodzi, że:

1. każda cecha mieści się w zakresie, który model dla niej deklaruje;
2. wynik modelu dla tych cech jest równy progowi lub wyższy (status 1) albo niższy od niego (status 2);
3. opublikowane zobowiązanie jest SHA-256 z soli i dokładnie tych samych cech.

Kredytodawca sprawdza identyfikator programu w potwierdzeniu, jego status oraz to, że zobowiązanie jest jednym z tych, które attester podpisał. Dowiaduje się jednego bitu o wnioskodawcy.

Prywatne dane wejściowe same w sobie nic nie dowodzą o świecie. Bez punktu 3 wnioskodawca mógłby wpisać dowolne liczby. Zobowiązanie łączy liczby w dowodzie z liczbami, za którymi ktoś poręczył. Sam podpis kredytodawca sprawdza poza łańcuchem: weryfikacja Dilithium lub ECDSA nie mieści się w budżecie wywołania i nie musi być wewnątrz dowodu, ponieważ zobowiązanie jest publiczne.

2. Interfejs

Każde słowo publiczne jest wartością i32, zapisaną jako jej uzupełnienie do dwóch w u32.

Zobowiązanie jest publikowane tylko ze statusem 1 lub 2. Wejście poza zakresem zatrzymuje wykonanie, zanim cokolwiek zostanie zahaszowane.

3. Arytmetyka

Model używa wyłącznie liczb całkowitych. Maszyna nie ma arytmetyki zmiennoprzecinkowej, a weryfikator musi umieć dokładnie odtworzyć wynik, czego arytmetyka zmiennoprzecinkowa nie gwarantuje między maszynami.

hidden[j] = max( (b1[j] + Σ w1[j][i] · x[i]) >> s , 0 )      for each hidden unit j
score     = (b2 + Σ w2[j] · hidden[j]) >> s
approved  = score >= threshold

Wagi są zapisane w stałoprzecinkowej reprezentacji z s bitami ułamkowymi: dla s = 8 waga 256 oznacza 1,0. Sumy są typu i64, a każde mnożenie i dodawanie jest sprawdzane, więc model z wagami na tyle dużymi, by spowodować przepełnienie, daje status 4 zamiast błędnego wyniku. >> na ujemnej wartości i64 zaokrągla w Rust w stronę minus nieskończoności, a >> w Pythonie robi to samo, dzięki czemu dziesięciowierszowa funkcja w Pythonie może służyć jako wzorzec.

Model demonstracyjny ma osiem cech i cztery jednostki ukryte. Jego wagi zostały napisane ręcznie na potrzeby tej strony. To nie jest model wytrenowany i nie mówi nic o kredycie.

{
  "shift": 8,
  "threshold": 600,
  "features": [
    {"name": "age_years", "min": 18, "max": 120},
    {"name": "income_thousands", "min": 0, "max": 100000},
    {"name": "debt_to_income_pct", "min": 0, "max": 1000},
    {"name": "on_time_payments_pct", "min": 0, "max": 100},
    {"name": "utilisation_pct", "min": 0, "max": 100},
    {"name": "history_years", "min": 0, "max": 100},
    {"name": "inquiries_12m", "min": 0, "max": 100},
    {"name": "delinquencies", "min": 0, "max": 100}
  ],
  "w1": [
    [  64,   96,  -512,  1536,  -640,  1024, -2048, -8192],
    [   0,  256, -1024,     0,     0,     0,     0,     0],
    [   0,    0,     0,  2560, -1280,     0, -4096, -16384],
    [ 128,    0,     0,     0,     0,  2048,     0,     0]
  ],
  "b1": [25600, 12800, -128000, 0],
  "w2": [160, 96, 224, 128],
  "b2": 76800
}

4. Guest

my-guests/score/src/main.rs, w całości:

#![no_std]
#![no_main]

use guest_sdk::{halt, read_input, read_public, sha256_compress, write_output};

const MAX_FEATURES: usize = 16;
const MAX_HIDDEN: usize = 16;

const APPROVED: u32 = 1;
const DECLINED: u32 = 2;
const OUT_OF_RANGE: u32 = 3;
const BAD_MODEL: u32 = 4;

/// SHA-256's initial state (FIPS 180-4 §5.3.3).
const IV: [u32; 8] = [
    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
];

/// SHA-256 of `words`, each word taken as four big-endian bytes. The message is whole words,
/// so the padding is whole words too: `0x80000000`, zeros, then the bit length in the last
/// word of a block (the length's high word is always zero here).
fn sha256_words(words: &[u32]) -> [u32; 8] {
    let mut buf = [0u32; 24];
    buf[16..].copy_from_slice(&IV);
    let mut fill = 0;
    for &w in words {
        buf[fill] = w;
        fill += 1;
        if fill == 16 {
            sha256_compress(&mut buf);
            fill = 0;
        }
    }
    buf[fill] = 0x8000_0000;
    fill += 1;
    if fill > 14 {
        buf[fill..16].fill(0);
        sha256_compress(&mut buf);
        fill = 0;
    }
    buf[fill..15].fill(0);
    buf[15] = 32 * words.len() as u32;
    sha256_compress(&mut buf);
    let mut out = [0u32; 8];
    out.copy_from_slice(&buf[16..]);
    out
}

/// `weight · x`, added to `acc`; `None` when it does not fit an i64.
fn mul_add(acc: i64, weight: u32, x: i64) -> Option<i64> {
    acc.checked_add((weight as i32 as i64).checked_mul(x)?)
}

/// Runs the model in the public segment over the private features.
fn score(features: &[i32], hidden: usize, shift: u32) -> Option<i64> {
    let n = features.len();
    // The public segment after the header and the feature ranges:
    // hidden × n first-layer weights, hidden biases, hidden second-layer weights, one bias.
    let w1 = 4 + 2 * n;
    let b1 = w1 + hidden * n;
    let w2 = b1 + hidden;
    let b2 = w2 + hidden;

    let mut out = read_public(b2 as u32) as i32 as i64;
    for j in 0..hidden {
        let mut acc = read_public((b1 + j) as u32) as i32 as i64;
        for (i, &x) in features.iter().enumerate() {
            acc = mul_add(acc, read_public((w1 + j * n + i) as u32), x as i64)?;
        }
        // Fixed point: drop the fractional bits, then ReLU.
        let h = (acc >> shift).max(0);
        out = mul_add(out, read_public((w2 + j) as u32), h)?;
    }
    Some(out >> shift)
}

/// Public segment, fixed at deploy (every value an i32):
///   [features n, hidden units, threshold, fractional bits,
///    n × (min, max), hidden × n weights, hidden biases, hidden weights, bias]
/// Private input: [salt (4 words), n features].
/// Outputs: [status, 0, commitment (first 5 words), 0], where
/// commitment = SHA-256(salt ‖ features), every word big-endian.
#[no_mangle]
pub extern "C" fn main() -> ! {
    let n = read_public(0) as usize;
    let hidden = read_public(1) as usize;
    let threshold = read_public(2) as i32 as i64;
    let shift = read_public(3);
    if n == 0 || n > MAX_FEATURES || hidden == 0 || hidden > MAX_HIDDEN || shift > 31 {
        write_output(0, BAD_MODEL);
        halt();
    }

    // The committed message: the salt, then the features, in input order.
    let mut message = [0u32; 4 + MAX_FEATURES];
    for (i, w) in message.iter_mut().enumerate().take(4 + n) {
        *w = read_input(i as u32);
    }
    let mut features = [0i32; MAX_FEATURES];
    let mut in_range = true;
    for i in 0..n {
        let x = message[4 + i] as i32;
        let min = read_public(4 + 2 * i as u32) as i32;
        let max = read_public(5 + 2 * i as u32) as i32;
        in_range &= min <= x && x <= max;
        features[i] = x;
    }
    if !in_range {
        write_output(0, OUT_OF_RANGE);
        halt();
    }

    let status = match score(&features[..n], hidden, shift) {
        Some(s) if s >= threshold => APPROVED,
        Some(_) => DECLINED,
        None => BAD_MODEL,
    };
    let commitment = sha256_words(&message[..4 + n]);

    write_output(0, status);
    for k in 0..5 {
        write_output(2 + k as u32, commitment[k]);
    }
    halt();
}

Model to dane, nie kod. Wagi są odczytywane przez read_public, więc jeden wdrożony obraz obsługuje dowolny model do 16 cech i 16 jednostek ukrytych. Zmiana modelu to nowe wdrożenie tego samego kodu z nowym segmentem publicznym i nowym identyfikatorem programu. Kredytodawca nie może podmienić wag pod wnioskodawcą, a wnioskodawca nie może wybrać łagodniejszego modelu: potwierdzenie wskazuje identyfikator programu, a identyfikator wiąże wagi.

Zakresy są częścią modelu. Bez nich wnioskodawca nie mógłby skłamać co do wartości (zobowiązanie to uniemożliwia), ale attester mógłby podpisać nonsens, taki jak wiek −5, który model z ujemną wagą by nagrodził. Sprawdzenie ogranicza też arytmetykę.

Sól pełni dwie role. Sprawia, że zobowiązania nie da się odgadnąć: osiem małych liczb całkowitych ma niewiele entropii i bez soli każdy mógłby haszować kandydatów na wnioskodawców i porównywać wyniki. Ponadto przenosi 128 losowych bitów przez obliczenie. Zanim zestaw ograniczeń 7 zaślepił sumy magistrali w dowodzie, wywołanie na kilku małych słowach prywatnych dało się złamać siłowo z samego dowodu, a uwagi fullnode’a nakazywały takim programom czytać losowe słowa. Chain 18 działa na zestawie ograniczeń 8, w którym to naprawiono, ale sól kosztuje cztery słowa wejścia i usuwa wątpliwość.

5. Strona hosta

score.py używa wyłącznie biblioteki standardowej Pythona:

score.py setup   <model.json>                            writes public.txt
score.py witness <model.json> <salt: 32 hex> <x0> <x1> …  prints the private words;
                                                        stderr: the score, the decision, the commitment
score.py commit  <salt: 32 hex> <x0> <x1> …              prints the commitment alone

Wzorcowa funkcja oceniająca i zobowiązanie, w całości:

def score(m, x):
    """The guest's arithmetic exactly: integers, a floor shift after each layer, ReLU between."""
    out = m["b2"]
    for row, b, w2 in zip(m["w1"], m["b1"], m["w2"]):
        h = max((b + sum(w * xi for w, xi in zip(row, x))) >> m["shift"], 0)
        out += w2 * h
    return out >> m["shift"]

def commitment(salt: bytes, x):
    return hashlib.sha256(salt + b"".join(struct.pack(">i", xi) for xi in x)).digest()

$ cd my-guests/score
$ python3 score.py setup model.json
wrote public.txt (61 words)
$ cat public.txt
8 4 600 8 18 120 0 100000 0 1000 0 100 0 100 0 100 0 100 0 100 64 96 4294966784 1536 4294966656 1024 4294965248 4294959104 0 256 4294966272 0 0 0 0 0 0 0 0 2560 4294966016 0 4294963200 4294950912 128 0 0 0 0 2048 0 0 25600 12800 4294839296 0 160 96 224 128 76800

Duże liczby to wagi ujemne: 4294966784 to −512.

Guest przetestowano względem tego wzorca na 300 losowych wnioskodawcach, porównując decyzję i wszystkie pięć słów zobowiązania, a także na wnioskodawcach, których wyniki wynoszą 599 i 600. Zgadzają się w każdym przypadku.

6. Kompilacja i uruchomienie

$ rand-guest build my-guests/score --max-words 65535
462 words against a cap of 65535 (fits); 0 ecall(s) with a non-static a7
OK
wrote my-guests/score/image.bin and its .sha256 (462 words, hc c63d7b15a165a11d007ce48bc37563b71f77fcc4991ffe0182c8cf4c77b6e7b5, program id ce8d234faf737c24bdd2826933ac843973c140c53e76fbb2cccaef3073da9818)

Wnioskodawca w wieku 41 lat z dochodem 85 tysięcy, zadłużeniem 28% dochodu, 97% płatności w terminie, wykorzystaniem limitu 22%, 12-letnią historią, jednym zapytaniem i bez zaległości:

$ python3 score.py witness model.json 00112233445566778899aabbccddeeff 41 85 28 97 22 12 1 0 > witness.txt
score 1075 approved
commitment 9430c3818f5966f8dd33f78e05a7d079355191e6
$ cat witness.txt
1122867 1146447479 2291772091 3437096703 41 85 28 97 22 12 1 0
$ rand-guest run image.bin --public $(cat public.txt) --input $(cat witness.txt) --tier 14
out[0] = 1
out[1] = 0
out[2] = 2486223745
out[3] = 2405000952
out[4] = 3711170446
out[5] = 94883961
out[6] = 894538214
out[7] = 0
cycles 1810
tier 12
tier 14: fits (cycles 1946 of 16383, Poseidon2 permutations 136 of 2048)

2486223745 to 0x9430c381, pierwsze cztery bajty zobowiązania. Wynik, 1075, nie pojawia się nigdzie w danych wyjściowych.

Drugi wnioskodawca (23, 31, 55, 82, 91, 2, 6, 2, z inną solą) uzyskuje wynik 417 i daje out[0] = 2 z własnym zobowiązaniem, w tych samych 1,810 cykli. Pierwszy wnioskodawca z wiekiem zmienionym na 17 daje out[0] = 3 i brak zobowiązania.

7. Budżet

To najtańszy z czterech programów. Przejście w przód to 36 mnożeń. Model na granicach programu, z 16 cechami i 16 jednostkami ukrytymi, to 272 mnożenia i 325-słowowy segment publiczny. W emulatorze mierzy 7,900 cykli, około połowy tieru 14.

Przebieg nie zależy od danych: 200 losowych wnioskodawców, zatwierdzonych i odrzuconych, zajęło dokładnie 1,810 cykli każdy. Limit gazu deklarowany w wywołaniu jest publiczny i zaokrąglany z gazu przebiegu, więc program, którego liczba cykli zależałaby od wejść, ujawniałby ich niewielką część. Ten nie ma w ten sposób czego ujawniać.

Od chain 18 portfel wypisuje dokładny gaz przebiegu i deklarowany limit:

gas: 2011 (declaring 2048, tier 12)

1,948 wierszy po 1 gazie, plus 63 za jedną kompresję.

8. Wdrożenie

61 słów modelu opłaca się tak samo jak słowa kodu: 0.001 + 0.0001 × (462 + 61) = 0.0533 RAND.

$ rand fee deploy 462 --public-words 61
0.0533 RAND
$ rand program deploy image.bin --public public.txt
program id: 7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c (462 words, hc 157b3dc61da165a18be47c00b76375c3c4fc771f01fe1f994ccfc882b5e7b677, public input 61 words, digest a08a7c691c45babeb39e953930d4d7174662b7b8adcc2d0f4e6c193d362d6668)
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 7.4s: tier 10, 1364940 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 123.5s: tier 14, 1497319 bytes
submitted deploy d47a9323ea53bfafc3faa36d004416d374bf3c2a48971d87e346be426b0caf14
  0 RAND out, 59.7229 RAND change, fee 0.0533 RAND, anchored at height 98062, proved in 123.5s (bundle) + 7.4s (auth)

9. Wywołanie

$ rand call 7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c \
    $(sed 's/[0-9][0-9]*/--input &/g' witness.txt)

proving the call locally (12 inputs stay private, over the program's 61-word public input)…
gas: 2011 (declaring 2048, tier 12)
fee 0.005673037 RAND (incl. two price steps of headroom)
proved in 30.6s: tier 12, 1838256 bytes, outputs [1, 0, 2486223745, 2405000952, 3711170446, 94883961, 894538214, 0]
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 6.8s: tier 10, 1369611 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 124.3s: tier 14, 1499112 bytes
submitted call 454c1b9eb1e159e682d4ff26b71f77d8a950b813533d91a89293dd432fdcf6f7
  0 RAND out, 59.696058627 RAND change, fee 0.005673037 RAND, anchored at height 98832, proved in 124.3s (bundle) + 6.8s (auth)
{
  "h_in": "ef80c744a8cdea62b56e334baaf7372e4a2e6c8282d37aa8ae96b4f039ec1a22",
  "h_pub": "a08a7c691c45babeb39e953930d4d7174662b7b8adcc2d0f4e6c193d362d6668",
  "height": 98993,
  "index": 0,
  "outputs": [
    1,
    0,
    2486223745,
    2405000952,
    3711170446,
    94883961,
    894538214,
    0
  ],
  "program": "7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c",
  "tier": 12,
  "tx": "454c1b9eb1e159e682d4ff26b71f77d8a950b813533d91a89293dd432fdcf6f7"
}
input transcript published; open it with `rand open-call 454c1b9eb1e159e682d4ff26b71f77d8a950b813533d91a89293dd432fdcf6f7`

Status 1 i zobowiązanie 9430c381 8f5966f8 dd33f78e 05a7d079 355191e6 w zapisie szesnastkowym. h_pub to skrót 61 słów modelu. Cech, soli ani wyniku nie ma w transakcji.

Wywołanie trwało nieco ponad trzy minuty na laptopie z Apple Silicon: 31 s na dowód wywołania, 7 s na autoryzację wydatku i 124 s na pakiet, przy szczytowym zużyciu 6.2 GB. Dowód ma 1,838,256 bajtów.

10. Sprawdź sam

Strona kredytodawcy, mająca wyłącznie potwierdzenie i podpisane przez attestera zobowiązanie:

1. Model. rand_getProgramPublic dla identyfikatora programu zwraca 61 słów. Porównaj je z opublikowanym model.json (score.py setup odtwarza je).
2. Kod. Zbuduj ponownie my-guests/score na tym samym commicie circuits i porównaj hc z code_hash programu.
3. Potwierdzenie. program to identyfikator modelu, wyjście 0 to 1, slot 7 nie jest 3735928559.
4. Zobowiązanie. Wyjścia od 2 do 6, wypisane szesnastkowo, to pierwsze 20 bajtów zobowiązania, które podpisał attester:

$ python3 score.py commit 00112233445566778899aabbccddeeff 41 85 28 97 22 12 1 0
9430c3818f5966f8dd33f78e05a7d079355191e6

Odrzucenie to także pokwitowanie. Wywołanie drugiego wnioskodawcy, 119e7834…1b3b w chain 18 (powtórzone w chain 20 jako c8a60183…9f73, które również odrzuca), zostało udowodnione i zatwierdzone w ten sam sposób:

$ python3 score.py witness model.json 0f1e2d3c4b5a69788796a5b4c3d2e1f0 23 31 55 82 91 2 6 2 > witness.txt
score 417 declined
commitment 0313ea462178574c49a10fe7ea1d84207652e1a3
$ rand call 7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c \
    $(sed 's/[0-9][0-9]*/--input &/g' witness.txt)
…
gas: 2011 (declaring 2048, tier 12)
proved in 26.1s: tier 12, 1836624 bytes, outputs [2, 0, 51636806, 561534796, 1235292135, 3927802912, 1985143203, 0]
…
submitted call 119e7834033edd19bba8e10c1a764e8bdbc0b1c8415a42f041faa392c6411b3b

Status 2, a 51636806 to 0x0313ea46. Gaz, zadeklarowany limit i tier są takie same jak w wywołaniu zatwierdzonym, więc oba wywołania różnią się w łańcuchu wyłącznie słowem statusu i zobowiązaniem. Wnioskodawca nie ma powodu publikować odrzucenia, ale pożyczkodawca może zażądać pokwitowania w obu przypadkach, a wnioskodawca, któremu odmówiono, nie jest w stanie przedstawić pokwitowania zatwierdzenia.

Czego dowód nie zapewnia

• Prawdziwych danych. Dowód pokazuje, że model został uruchomiony na zobowiązanych wartościach. Czy te wartości są prawdziwe, zależy od słowa attestera, a pożyczkodawca musi w tej kwestii zaufać podpisowi attestera.
• Niepowiązywalnego wnioskodawcy. Zobowiązanie jest stałym identyfikatorem: attester może je rozpoznać, a dwa pokwitowania z tym samym zobowiązaniem dotyczą tego samego wnioskodawcy i tych samych danych. Nowa sól od attestera przy każdym wniosku rozwiązuje drugi problem, ale nie pierwszy.
• Tajnego modelu. Wagi są publiczne. W przypadku reguły, którą ludzie muszą móc przeczytać, to właśnie jest sens, a dla pożyczkodawcy traktującego swój model jako tajemnicę handlową stanowi to wadę. Wnioskodawca może też szukać danych wejściowych, które przeszłyby ocenę, ale nie może ich użyć bez podpisu attestera pod nimi.
• Ochrony przed sondowaniem przez nieuczciwego attestera. Każdy, kto zna cechy, może samodzielnie uruchomić publiczny model. Prywatność dotyczy tu wnioskodawcy wobec pożyczkodawcy i opinii publicznej, a nie wobec strony, która dostarczyła dane.
• Dużego modelu. Szesnaście cech i szesnaście ukrytych jednostek to karta wyników, a nie głęboka sieć. Wywołanie jest ograniczone do tier 14, czyli około szesnastu tysięcy cykli.