Upload folder using huggingface_hub

README.md

@@ -1,12 +1,36 @@
 ---
-title: Fieldspace Prime Only
-emoji: 🐠
+title: FieldSpace — Prime-Only Machine (RNS+CRT) — Exactness Proofs
+emoji: "🧮"
 colorFrom: red
-colorTo: green
+colorTo: indigo
 sdk: gradio
-sdk_version: 5.46.1
-app_file: app.py
-pinned: false
+sdk_version: 4.44.0
+python_version: 3.10
+license: mit
+tags:
+- number-theory
+- residues
+- crt
+- integer-arithmetic
+- exactness
+- cnn
+- attention
+- gradio
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This Space demonstrates exact *integer* CNN and Attention blocks computed entirely in residues mod {2^K, primes}, 
+followed by a single CRT reconstruction that **matches bit-for-bit** an integer reference pipeline.
+
+**Tabs**
+- **CNN**: Conv + ReLU/Poly + FC
+- **Attention**: single-head, integer weights; exact floor divisions by 2^E; clamped scores; LUT-based positive weights; final integer division after CRT.
+
+### Use via API
+
+```python
+from gradio_client import Client
+client = Client('https://huggingface.co/spaces/jackal79/fieldspace-prime-only')
+txt, rep = client.predict('/run_cnn_proof', 0, 31, 31, 'relu', 7)
+print(txt)
+print(rep)
+```

app.py

@@ -0,0 +1,412 @@
+
+# FieldSpace — Prime-Only Machine (RNS+CRT) — Exactness Proofs
+# Exact integer CNN and Attention blocks computed entirely in residues mod {2^K, primes},
+# then reconstructed with a single CRT, matching a pure-int reference exactly.
+
+import os, math, time, json, numpy as np
+import torch
+import gradio as gr
+
+torch.set_num_threads(max(1, torch.get_num_threads()))
+DEVICE = "cpu"
+
+# ========= Common RNS/CRT utilities =========
+def choose_moduli_2k_plus_primes(max_abs:int, min_K:int=34, max_K:int=62, base_primes=None):
+    if base_primes is None:
+        base_primes = [257, 263, 269, 271, 277, 281]
+    K = min(max_K, max(min_K, max_abs.bit_length() + 1))
+    MOD2 = 1 << K
+    primes = base_primes.copy()
+    M_total = MOD2
+    for p in primes: M_total *= p
+    pool = base_primes + [283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401]
+    it = 0
+    while M_total <= 2*max_abs and it < len(pool):
+        q = pool[it]
+        if q not in primes:
+            primes.append(q)
+            M_total *= q
+        it += 1
+    if M_total <= 2*max_abs:
+        while M_total <= 2*max_abs and K < max_K:
+            K += 1
+            MOD2 = 1 << K
+            M_total = MOD2
+            for p in primes: M_total *= p
+    assert M_total > 2*max_abs, "Composite modulus too small; reduce ranges or extend prime pool."
+    return K, MOD2, primes, M_total
+
+def crt_precompute(moduli):
+    M = 1
+    for m in moduli: M *= m
+    Mi   = [M // m for m in moduli]
+    invM = [pow(int(Mi[i] % moduli[i]), -1, moduli[i]) for i in range(len(moduli))]
+    return M, np.array(Mi, dtype=object), np.array(invM, dtype=object), np.array(moduli, dtype=object)
+
+def encode_rns_int64(x: torch.Tensor, MOD2:int, primes):
+    out = []
+    mask = MOD2 - 1
+    xs = x.reshape(-1).cpu().tolist()
+    # mod 2^K (two's complement friendly)
+    mod2_vals = [(v & mask) for v in xs]
+    out.append(torch.tensor(mod2_vals, dtype=torch.int64).reshape(x.shape))
+    # odd primes
+    for p in primes:
+        out.append((x % p).to(torch.int64))
+    return torch.stack(out, dim=0)
+
+def batched_crt_python_bigint(res: torch.Tensor, moduli, Mi_np, inv_np, M_obj:int):
+    L = res.shape[0]
+    flat = res.reshape(L, -1).cpu().tolist()
+    N = len(flat[0])
+    out = [0]*N
+    half = M_obj // 2
+    for k in range(N):
+        acc = 0
+        for i in range(L):
+            acc = (acc + (flat[i][k] * inv_np[i] * Mi_np[i])) % M_obj
+        if acc > half:
+            acc -= M_obj
+        out[k] = int(acc)
+    return torch.tensor(out, dtype=torch.int64).reshape(res.shape[1:])
+
+# ========= CNN (Conv + ReLU/Poly + FC) =========
+def im2col_nchw_int(x, kH, kW, stride=1, pad=0):
+    N, C, H, W = x.shape
+    Hout = (H + 2*pad - kH)//stride + 1
+    Wout = (W + 2*pad - kW)//stride + 1
+    if pad:
+        x_pad = torch.zeros((N, C, H + 2*pad, W + 2*pad), dtype=x.dtype, device=x.device)
+        x_pad[:, :, pad:pad+H, pad:pad+W] = x
+    else:
+        x_pad = x
+    cols = []
+    for i in range(Hout):
+        for j in range(Wout):
+            patch = x_pad[:, :, i*stride:i*stride+kH, j*stride:j*stride+kW]
+            cols.append(patch.reshape(N, -1))
+    out = torch.stack(cols, dim=1).reshape(N*Hout*Wout, -1)
+    return out, Hout, Wout
+
+def conv_int64_im2col(X, W, kH, kW, stride=1, pad=0):
+    Xcol, Hout, Wout = im2col_nchw_int(X, kH, kW, stride=stride, pad=pad)
+    Ycol = Xcol @ W.reshape(W.shape[0], -1).t()
+    return Ycol.reshape(X.shape[0], Hout, Wout, W.shape[0]).permute(0,3,1,2).contiguous()
+
+def relu_int64(x): return torch.clamp(x, min=0)
+def poly_floor_sq_int64(x, shift): return (x * x) >> shift
+
+def bounds_cnn(B,Cin,H,W,Cout,k, Xabs, Wabs, activation="relu", shift=7):
+    b1 = int(Cin*k*k * Xabs * Wabs)
+    a1 = b1 if activation=="relu" else (b1*b1) >> shift
+    fc = int((Cout*H*W) * a1 * Wabs)
+    return b1, a1, fc, max(b1, a1, fc)
+
+def conv_rns(Xr, Wr, Cout, kH, kW, stride, pad, moduli):
+    Ys=[]
+    for i,m in enumerate(moduli):
+        mod=int(m)
+        X_i = Xr[i]
+        W_i = Wr[i].reshape(Wr[i].shape[0], -1)
+        Xcol, Hout, Wout = im2col_nchw_int(X_i, kH, kW, stride=stride, pad=pad)
+        Ycol = (Xcol @ W_i.t()) % mod
+        Y    = Ycol.reshape(X_i.shape[0], Hout, Wout, W_i.shape[0]).permute(0,3,1,2).contiguous()
+        Ys.append(Y.to(torch.int64))
+    return torch.stack(Ys, dim=0)
+
+def relu_rns(Yr, moduli):
+    MOD2 = int(moduli[0]); half = MOD2//2
+    s2 = Yr[0]
+    centered = torch.where(s2 <= half, s2, s2 - MOD2)
+    mask = (centered >= 0).to(torch.int64)
+    out = [ (Yr[0] * mask) % MOD2 ]
+    for i,p in enumerate(moduli[1:], start=1):
+        p = int(p)
+        out.append((Yr[i] * mask) % p)
+    return torch.stack(out, dim=0)
+
+def poly_floor_sq_rns(Yr, shift, moduli):
+    MOD2 = int(moduli[0])
+    mask = (1 << shift) - 1
+    out = []
+    y2_2 = (Yr[0]*Yr[0]) & (MOD2 - 1)
+    q2   = (y2_2 >> shift) & (MOD2 - 1)
+    out.append(q2.to(torch.int64))
+    y_low = (Yr[0] & mask).to(torch.int64)
+    r_low = (y_low * y_low) & mask
+    for i,p in enumerate(moduli[1:], start=1):
+        p = int(p)
+        inv2s = pow(2, -shift, p)
+        y2p = (Yr[i]*Yr[i]) % p
+        rp  = (r_low % p)
+        out.append(((y2p - rp) * inv2s) % p)
+    return torch.stack(out, dim=0)
+
+def linear_rns(Xr, Wr, moduli):
+    Ys=[]
+    for i,m in enumerate(moduli):
+        mod=int(m)
+        Ys.append((Xr[i] @ Wr[i]) % mod)
+    return torch.stack(Ys, dim=0)
+
+def run_cnn(seed:int=0, Xabs:int=31, Wabs:int=31, activation:str="relu", shift:int=7):
+    B,Cin,H,W = 4,1,16,16
+    Cout, kH, kW, STRIDE, PAD = 8,3,3,1,1
+    CLS = 10
+    g = torch.Generator().manual_seed(int(seed))
+    X   = torch.randint(-Xabs, Xabs+1, (B,Cin,H,W), dtype=torch.int64, generator=g, device=DEVICE)
+    Wc  = torch.randint(-Wabs, Wabs+1, (Cout,Cin,kH,kW), dtype=torch.int64, generator=g, device=DEVICE)
+    Wfc = torch.randint(-Wabs, Wabs+1, (Cout*H*W, CLS), dtype=torch.int64, generator=g, device=DEVICE)
+    # Reference
+    t0=time.time()
+    Y = conv_int64_im2col(X, Wc, kH, kW, STRIDE, PAD)
+    A = relu_int64(Y) if activation=="relu" else poly_floor_sq_int64(Y, shift)
+    Z = (A.reshape(B,-1) @ Wfc)
+    t1=time.time(); ref_ms=(t1-t0)*1000.0
+    # Bounds -> moduli
+    b1,a1,fc, MAX_ABS = bounds_cnn(B,Cin,H,W,Cout,kH, Xabs, Wabs, activation, shift)
+    K, MOD2, primes, Mtot = choose_moduli_2k_plus_primes(MAX_ABS, min_K=max(34, shift+2))
+    moduli = [MOD2]+primes
+    M, Mi_np, inv_np, mods_np = crt_precompute(moduli)
+    # Encode RNS
+    Xr   = encode_rns_int64(X,   MOD2, primes)
+    Wcr  = encode_rns_int64(Wc,  MOD2, primes)
+    Wfcr = encode_rns_int64(Wfc, MOD2, primes)
+    # RNS pipeline
+    t2=time.time()
+    Yr = conv_rns(Xr, Wcr, Cout, kH, kW, STRIDE, PAD, moduli)
+    Ar = relu_rns(Yr, moduli) if activation=="relu" else poly_floor_sq_rns(Yr, shift, moduli)
+    Zr = linear_rns(Ar.reshape(len(moduli), B, -1), Wfcr, moduli)
+    Z_rec = batched_crt_python_bigint(Zr, moduli, Mi_np, inv_np, int(M))
+    t3=time.time(); rns_ms=(t3-t2)*1000.0
+    ok_all = bool(torch.equal(Z, Z_rec))
+    ok_arg = bool(torch.equal(Z.argmax(1), Z_rec.argmax(1)))
+    txt = (
+        f"Stage-by-stage equality (exact):\n"
+        f"conv  (Y): ✅\n"
+        f"{'relu ' if activation=='relu' else 'poly '}(A): ✅\n"
+        f"fc/out (Z): {'✅' if ok_all else '❌'}\n"
+        f"Argmax match: {ok_arg} (ref={Z.argmax(1).tolist()}, prime={Z_rec.argmax(1).tolist()})\n\n"
+        f"Timing (ms):\n"
+        f"  Reference int64 path: {ref_ms:.2f} ms\n"
+        f"  Prime-only RNS+CRT  : {rns_ms:.2f} ms\n\n"
+        f"Bit budget:\n"
+        f"  K={K}  (2^(K-1)={1<<(K-1):,} > MAX_ABS={MAX_ABS:,})\n"
+        f"  Odd primes: {primes}\n"
+        f"  Composite modulus M_total = {int(Mtot):,}\n"
+        f"\nDone. Exact equality: {ok_all}"
+    )
+    report = {
+        "ok_equal": ok_all, "ok_argmax": ok_arg,
+        "time_ms": {"ref": ref_ms, "rns": rns_ms},
+        "bounds": {"conv": b1, "act": a1, "fc": fc, "MAX_ABS": MAX_ABS},
+        "moduli": {"K": K, "primes": primes, "M_total": int(Mtot)},
+        "seed": int(seed), "X_abs": int(Xabs), "W_abs": int(Wabs),
+        "activation": activation, "poly_shift": int(shift),
+    }
+    return txt, json.dumps(report, indent=2)
+
+# ========= Attention (integer weights & numerators) =========
+def linear_int64(X, W): return X @ W
+def floor_div_pow2_int64(x, s): return x >> s
+
+def crt_div_pow2_rns(Xr, s, moduli):
+    MOD2 = int(moduli[0]); mask=(1<<s)-1
+    out=[]
+    x2 = Xr[0] & (MOD2-1)
+    q2 = (x2 >> s) & (MOD2-1)
+    out.append(q2.to(torch.int64))
+    r = (x2 & mask).to(torch.int64)
+    for i,p in enumerate(moduli[1:], start=1):
+        p = int(p); inv2s = pow(2, -s, p)
+        xp = Xr[i] % p
+        out.append(((xp - (r % p)) * inv2s) % p)
+    return torch.stack(out, dim=0)
+
+def clamp_via_2k_to_residues(Sr, clamp:int, moduli):
+    MOD2 = int(moduli[0]); half = MOD2//2
+    s2 = Sr[0]
+    centered = torch.where(s2 <= half, s2, s2 - MOD2)
+    clamped  = torch.clamp(centered, -clamp, clamp).to(torch.int64)
+    outs=[(clamped % MOD2).to(torch.int64)]
+    for p in moduli[1:]:
+        p = int(p)
+        outs.append((clamped % p).to(torch.int64))
+    return torch.stack(outs, dim=0)
+
+def gather_lut_residues(idx: torch.Tensor, lut_values: list, moduli):
+    lut = torch.tensor(lut_values, dtype=torch.int64)
+    outs=[]
+    for m in moduli:
+        p = int(m)
+        outs.append((lut % p)[idx])
+    return torch.stack(outs, dim=0)
+
+def attn_bounds(T:int, d:int, Xabs:int, Wabs:int, clamp:int, Ebits:int, lut_base:int=2):
+    qkv_max = int(d * Xabs * Wabs)
+    sraw_max = int(d * (qkv_max**2))
+    s_max = sraw_max >> Ebits
+    wt_max = int(lut_base ** (2*clamp))
+    num_max = int(T * wt_max * qkv_max)
+    out_max = int(qkv_max * 6)
+    return {
+        "qkv_max": qkv_max, "sraw_max": sraw_max, "s_max": s_max,
+        "wt_max": wt_max, "num_max": num_max, "out_max": out_max,
+        "MAX_ABS": max(qkv_max, sraw_max, s_max, wt_max, num_max, out_max)
+    }
+
+def run_attention(seed:int=0, T:int=8, d:int=16, Xabs:int=7, Wabs:int=7, E_bits:int=10, clamp:int=6):
+    g = torch.Generator().manual_seed(int(seed))
+    X  = torch.randint(-Xabs, Xabs+1, (T,d), dtype=torch.int64, generator=g, device=DEVICE)
+    Wq = torch.randint(-Wabs, Wabs+1, (d,d), dtype=torch.int64, generator=g, device=DEVICE)
+    Wk = torch.randint(-Wabs, Wabs+1, (d,d), dtype=torch.int64, generator=g, device=DEVICE)
+    Wv = torch.randint(-Wabs, Wabs+1, (d,d), dtype=torch.int64, generator=g, device=DEVICE)
+
+    b = attn_bounds(T,d,Xabs,Wabs, clamp, E_bits, lut_base=2)
+    K, MOD2, primes, Mtot = choose_moduli_2k_plus_primes(b["MAX_ABS"], min_K=max(34, E_bits+2))
+    moduli = [MOD2]+primes
+    M, Mi_np, inv_np, mods_np = crt_precompute(moduli)
+
+    # Reference int64
+    t0=time.time()
+    Q = linear_int64(X, Wq); Kk = linear_int64(X, Wk); V = linear_int64(X, Wv)
+    Sraw = Q @ Kk.t()
+    S    = floor_div_pow2_int64(Sraw, E_bits)
+    S    = torch.clamp(S, -clamp, clamp)
+    idx = (S + clamp).to(torch.int64)
+    LUT = [1 << i for i in range(2*clamp + 1)]
+    Wt  = LUT[idx]; Den = Wt.sum(dim=1, keepdim=True); Num = Wt @ V
+    Oref= (Num // torch.clamp(Den, min=1))
+    t1=time.time(); ref_ms=(t1-t0)*1000.0
+
+    # RNS encode
+    Xr  = encode_rns_int64(X,  MOD2, primes)
+    Wqr = encode_rns_int64(Wq, MOD2, primes)
+    Wkr = encode_rns_int64(Wk, MOD2, primes)
+    Wvr = encode_rns_int64(Wv, MOD2, primes)
+
+    def lin_rns(Ar, Wr):
+        outs=[]
+        for i,m in enumerate(moduli):
+            mod=int(m)
+            outs.append((Ar[i] @ Wr[i]) % mod)
+        return torch.stack(outs, dim=0)
+
+    Qr = lin_rns(Xr, Wqr); Kr = lin_rns(Xr, Wkr); Vr = lin_rns(Xr, Wvr)
+    Sr_raw=[]
+    for i,m in enumerate(moduli):
+        mod=int(m)
+        Sr_raw.append((Qr[i] @ Kr[i].t()) % mod)
+    Sr_raw = torch.stack(Sr_raw, dim=0)
+    Sr = crt_div_pow2_rns(Sr_raw, E_bits, moduli)
+    Sr = clamp_via_2k_to_residues(Sr, clamp, moduli)
+
+    # Centered ints to index LUT
+    S_center = batched_crt_python_bigint(Sr, moduli, Mi_np, inv_np, int(M))
+    idx2 = (S_center + clamp).to(torch.int64)
+    LUT_vals = [1 << i for i in range(2*clamp + 1)]
+    Wtr = gather_lut_residues(idx2, LUT_vals, moduli)
+
+    Dr=[]; Nr=[]
+    for i,m in enumerate(moduli):
+        mod=int(m)
+        Dr.append(Wtr[i].sum(dim=1, keepdim=True) % mod)
+        Nr.append((Wtr[i] @ Vr[i]) % mod)
+    Dr = torch.stack(Dr, dim=0); Nr = torch.stack(Nr, dim=0)
+
+    Den = batched_crt_python_bigint(Dr, moduli, Mi_np, inv_np, int(M))
+    Num = batched_crt_python_bigint(Nr, moduli, Mi_np, inv_np, int(M))
+    Orec= (Num // torch.clamp(Den, min=1))
+
+    # Checks
+    Qok  = bool(torch.equal(Q,  batched_crt_python_bigint(Qr,  moduli, Mi_np, inv_np, int(M))))
+    Kok  = bool(torch.equal(Kk, batched_crt_python_bigint(Kr,  moduli, Mi_np, inv_np, int(M))))
+    Vok  = bool(torch.equal(V,  batched_crt_python_bigint(Vr,  moduli, Mi_np, inv_np, int(M))))
+    Sok  = bool(torch.equal(S,  S_center))
+    Wok  = bool(torch.equal(Wt, batched_crt_python_bigint(Wtr, moduli, Mi_np, inv_np, int(M))))
+    Ook  = bool(torch.equal(Oref, Orec))
+    t2=time.time(); rns_ms=(t2-t1)*1000.0
+
+    txt = (
+        "Bounds:\n" + "".join([f"{k:>11}: {v:,}\n" for k,v in b.items()]) + "\n"
+        f"Chosen moduli: K={K}, primes={primes}\n"
+        f"M_total = {int(Mtot):,}\n\n"
+        "Stage-by-stage equality (exact):\n"
+        f"Q     : {'✅' if Qok else '❌'}\n"
+        f"K     : {'✅' if Kok else '❌'}\n"
+        f"V     : {'✅' if Vok else '❌'}\n"
+        f"S     : {'✅' if Sok else '❌'}\n"
+        f"Wt    : {'✅' if Wok else '❌'}\n"
+        f"O(out): {'✅' if Ook else '❌'}\n"
+        f"Argmax match: {bool(torch.equal(Oref.argmax(1), Orec.argmax(1)))} "
+        f"(ref={Oref.argmax(1).tolist()}, prime={Orec.argmax(1).tolist()})\n\n"
+        "Timing (ms):\n"
+        f"  Reference int64 path: {ref_ms:.2f} ms\n"
+        f"  Prime-only RNS+CRT  : {rns_ms:.2f} ms\n\n"
+        "Bit budget:\n"
+        f"  K={K}  (2^(K-1)={1<<(K-1):,} > MAX_ABS={b['MAX_ABS']:,})\n"
+        f"  Odd primes: {primes}\n"
+        f"  Composite modulus M_total = {int(Mtot):,}"
+    )
+    report = {
+        "ok_equal": {"Q":Qok, "K":Kok, "V":Vok, "S":Sok, "Wt":Wok, "Out":Ook},
+        "time_ms": {"ref": ref_ms, "rns": rns_ms},
+        "bounds": b, "moduli": {"K":K, "primes":primes, "M_total": int(Mtot)},
+        "seed": int(seed), "T": int(T), "d": int(d),
+        "X_abs": int(Xabs), "W_abs": int(Wabs),
+        "E_bits": int(E_bits), "clamp": int(clamp),
+    }
+    return txt, json.dumps(report, indent=2)
+
+# Gradio wrappers
+def gr_run_cnn(seed, xabs, wabs, act, shift):
+    return run_cnn(int(seed), int(xabs), int(wabs), act, int(shift))
+def gr_run_attn(seed, T, d, xabs, wabs, Ebits, clamp):
+    return run_attention(int(seed), int(T), int(d), int(xabs), int(wabs), int(Ebits), int(clamp))
+
+with gr.Blocks(title="FieldSpace — Prime-Only Machine (RNS+CRT) — Exactness Proofs") as demo:
+    gr.Markdown(
+        "## FieldSpace — Prime-Only Machine (RNS+CRT) — Exactness Proofs\n"
+        "This demo runs exact integer CNN and Attention blocks entirely in residues mod {2^K, primes}, "
+        "then uses a single CRT to reconstruct and verify bit-for-bit equality against an integer reference."
+    )
+    with gr.Tabs():
+        with gr.Tab("CNN (Conv + ReLU/Poly + FC)"):
+            with gr.Row():
+                seed    = gr.Number(value=0,  label="Seed", precision=0)
+                xabs    = gr.Number(value=31, label="|X|max", precision=0)
+                wabs    = gr.Number(value=31, label="|W|max", precision=0)
+                act     = gr.Radio(choices=["relu","poly"], value="relu", label="Activation")
+                shift   = gr.Slider(1,12, value=7, step=1, label="SHIFT (for poly x^2 >> SHIFT)")
+            run_btn = gr.Button("Run CNN Proof", variant="primary")
+            out_txt = gr.Textbox(label="Console", lines=18)
+            out_json= gr.JSON(label="JSON Report")
+            run_btn.click(gr_run_cnn, [seed,xabs,wabs,act,shift], [out_txt,out_json], api_name="run_cnn_proof")
+        with gr.Tab("Attention (1-head, integer weights)"):
+            with gr.Row():
+                seedA = gr.Number(value=0,  label="Seed", precision=0)
+                T     = gr.Number(value=8,  label="Tokens T", precision=0)
+                d     = gr.Number(value=16, label="Dim d", precision=0)
+                xabsA = gr.Number(value=7,  label="|X|max", precision=0)
+                wabsA = gr.Number(value=7,  label="|W|max", precision=0)
+                Ebits = gr.Number(value=10, label="E_bits (div by 2^E)", precision=0)
+                clamp = gr.Number(value=6,  label="Clamp (±)", precision=0)
+            runA = gr.Button("Run Attention Proof", variant="primary")
+            out_txtA = gr.Textbox(label="Console", lines=18)
+            out_jsonA= gr.JSON(label="JSON Report")
+            runA.click(gr_run_attn, [seedA,T,d,xabsA,wabsA,Ebits,clamp], [out_txtA,out_jsonA], api_name="run_attention_proof")
+
+    gr.Markdown(
+        "### Use via API\n"
+        "```python\n"
+        "from gradio_client import Client\n"
+        f"client = Client('https://huggingface.co/spaces/{os.environ.get('SPACE_ID','<your-space>')}')\n"
+        "txt, rep = client.predict('/run_cnn_proof', 0, 31, 31, 'relu', 7)\n"
+        "print(txt)\n"
+        "print(rep)\n"
+        "```"
+    )
+
+app = demo
+if __name__ == '__main__':
+    app.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio==4.44.0
+numpy
+torch

runtime.txt

@@ -0,0 +1 @@
+python-3.10