File size: 6,353 Bytes
17b2436
 
 
 
 
 
 
e05e496
 
 
 
 
17b2436
 
 
e05e496
 
 
17b2436
 
 
 
e05e496
e8a2ef5
17b2436
e05e496
 
 
 
17b2436
e05e496
 
17b2436
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e05e496
17b2436
 
 
 
e05e496
 
17b2436
e05e496
 
17b2436
 
e05e496
 
e8a2ef5
 
 
 
 
 
 
 
 
 
 
 
 
 
17b2436
 
 
e05e496
17b2436
 
e8a2ef5
17b2436
 
 
 
 
 
 
 
 
e05e496
 
17b2436
 
 
e05e496
17b2436
 
 
 
e05e496
 
 
17b2436
 
 
 
 
 
 
 
 
 
e05e496
7b2bc9e
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
"""Neuronal su ZeroGPU: qui gira SOLO il modello.
La pagina, gli strumenti, la voce, i ricordi e le sessioni stanno nello Space col container
(amogaddy/neuronal). Quando quello deve calcolare chiama `sessione`: qui parte il modello sulla GPU,
si collega al container, fa i calcoli che gli vengono chiesti e dopo pochi secondi restituisce la GPU.

All'accensione, sulla CPU (non consuma tempo di GPU): scarica llama.cpp e il modello, compila neuronal-brain."""
import asyncio, glob, hmac, os, re, subprocess, tarfile, time, urllib.request

import gradio as gr
import spaces
from huggingface_hub import hf_hub_download

from ponte import ponte

QUI = os.path.dirname(os.path.abspath(__file__))
BASE = "/tmp/neuronal"
LLAMA = "https://github.com/ggml-org/llama.cpp/releases/download/b11200/"
PACCHETTI = ["llama-b11200-bin-ubuntu-cuda-12.8-x64.tar.gz", "cudart-llama-b11200-bin-ubuntu-cuda-12.8-x64.tar.gz"]
# llama.cpp è compilato per una libreria di sistema più nuova di quella dello Space: se ne affianca una copia
UBUNTU = "http://archive.ubuntu.com/ubuntu/pool/main/g/"
DEB = [("glibc/", r"libc6_2\.39-0ubuntu8[.\d]*_amd64\.deb"), ("gcc-14/", r"libstdc\+\+6_14[^\"]*24\.04[.\d]*_amd64\.deb"),
       ("gcc-14/", r"libgcc-s1_14[^\"]*24\.04[.\d]*_amd64\.deb"), ("gcc-14/", r"libgomp1_14[^\"]*24\.04[.\d]*_amd64\.deb")]
CHIAVE = os.environ.get("NEURONAL_CHIAVE", "")
MASSIMO = 110                                # durata massima di una sessione di GPU, in secondi
REGISTRO = os.path.join(BASE, "sessioni.log")


def prepara():
    os.makedirs(BASE, exist_ok=True)
    t = time.time()
    for nome in PACCHETTI:
        fatto = os.path.join(BASE, nome + ".ok")
        if not os.path.exists(fatto):
            arch = os.path.join(BASE, nome)
            urllib.request.urlretrieve(LLAMA + nome, arch)
            with tarfile.open(arch) as tar:
                tar.extractall(os.path.join(BASE, "llama"))
            os.remove(arch)
            open(fatto, "w").close()
    libs = sorted({d for d, _, fs in os.walk(os.path.join(BASE, "llama")) if any(".so" in f for f in fs)})
    llama = next(d for d in libs if os.path.exists(os.path.join(d, "libllama.so")))

    sistema = os.path.join(BASE, "glibc")
    if not os.path.exists(os.path.join(sistema, ".ok")):
        for cartella, modello in DEB:
            elenco = urllib.request.urlopen(UBUNTU + cartella, timeout=60).read().decode()
            nome = sorted(set(re.findall(modello, elenco)))[-1]
            deb = os.path.join(BASE, nome)
            urllib.request.urlretrieve(UBUNTU + cartella + nome, deb)
            subprocess.run(["dpkg-deb", "-x", deb, sistema], check=True)
            os.remove(deb)
        open(os.path.join(sistema, ".ok"), "w").close()
    sis = os.path.join(sistema, "usr", "lib", "x86_64-linux-gnu")
    if not os.path.exists(os.path.join(sis, "libc.so.6")):
        sis = os.path.join(sistema, "lib", "x86_64-linux-gnu")

    cervello = os.path.join(BASE, "neuronal-brain")
    src = os.path.join(QUI, "src")
    subprocess.run(["gcc", "-O2", "-std=gnu11", "-o", cervello, os.path.join(src, "brain_worker.c"), os.path.join(src, "brain.c"),
                    "-I" + src, "-I" + os.path.join(src, "llama"), "-L" + llama, "-lmtmd", "-lllama", "-lggml", "-lggml-base",
                    "-lm", "-lpthread", "-Wl,--allow-shlib-undefined"], check=True)

    modello = hf_hub_download("prism-ml/Bonsai-27B-gguf", "Bonsai-27B-Q1_0.gguf")
    visione = hf_hub_download("prism-ml/Bonsai-27B-gguf", "Bonsai-27B-mmproj-Q8_0.gguf")
    print(f"Pronto in {time.time() - t:.0f} s: llama.cpp, modello e neuronal-brain.", flush=True)
    percorsi = os.pathsep.join([sis] + libs + ["/usr/lib/x86_64-linux-gnu"])
    return [os.path.join(sis, "ld-linux-x86-64.so.2"), "--library-path", percorsi, cervello, modello, llama, visione, "32768"]


COMANDO = prepara()


def valida(chiave):
    return bool(CHIAVE) and hmac.compare_digest(str(chiave), CHIAVE)


def limita(secondi):
    try:
        return max(10, min(int(secondi), MASSIMO))
    except (TypeError, ValueError):
        return 10


def durata(chiave, url, secondi):
    """Quanta GPU chiedere: il tempo della sessione più il margine per chiudere. ZeroGPU concede la sessione
    solo se nel tempo del giorno ne resta almeno altrettanto, ma conta solo quello usato davvero."""
    return limita(secondi) + 8


@spaces.GPU(duration=durata)
def sessione(chiave, url, secondi):
    """Avvia il modello sulla GPU e lo collega al motore di Neuronal che l'ha chiesto."""
    if not valida(chiave):
        return "chiave sbagliata"
    if not re.fullmatch(r"wss?://[A-Za-z0-9.\-:]+/ws\?role=brain&ticket=[0-9a-f]{16,40}", str(url)):
        return "indirizzo non valido"
    secondi = limita(secondi)
    with open(REGISTRO, "ab") as reg:
        reg.write(f"\n--- {time.strftime('%H:%M:%S')} sessione di {secondi} s\n".encode())
        reg.flush()
        try:
            usati = asyncio.run(ponte(COMANDO, url, secondi, stderr=reg))
        except Exception as e:
            reg.write(f"ponte: {type(e).__name__}: {e}\n".encode())
            return f"collegamento al motore non riuscito ({type(e).__name__})"
    return f"ok {usati:.1f}"


def diagnosi(chiave):
    """Le ultime righe scritte dal modello (per capire un problema senza usare la GPU)."""
    if not valida(chiave):
        return "chiave sbagliata"
    try:
        return open(REGISTRO, encoding="utf-8", errors="replace").read()[-6000:]
    except OSError:
        return "nessuna sessione finora"


with gr.Blocks(title="Neuronal GPU") as pagina:
    gr.Markdown("# 🧠 Neuronal — il modello\nQui gira solo il modello di Neuronal, sulla GPU. "
                "Per usarlo vai su **[amogaddy/neuronal](https://huggingface.co/spaces/amogaddy/neuronal)**: "
                "la pagina, gli strumenti e la voce sono lì.\n\nMade in Italy 🇮🇹")
    with gr.Accordion("Servizio (lo usa il motore di Neuronal)", open=False):
        chiave = gr.Textbox(label="Chiave", type="password")
        url = gr.Textbox(label="Motore")
        secondi = gr.Number(label="Secondi", value=50)
        esito = gr.Textbox(label="Esito", lines=12)
        gr.Button("Sessione").click(sessione, [chiave, url, secondi], esito, api_name="sessione")
        gr.Button("Diagnosi").click(diagnosi, [chiave], esito, api_name="diagnosi")

pagina.launch(show_error=True)