File size: 8,436 Bytes
3e7e2b1
b68b461
3e7e2b1
 
 
 
 
 
b68b461
 
3e7e2b1
 
b68b461
 
 
 
 
3e7e2b1
 
b68b461
 
 
3e7e2b1
b68b461
 
 
 
 
 
 
 
3e7e2b1
 
 
 
 
 
 
 
 
b68b461
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
28745b3
b68b461
 
 
 
 
 
 
 
 
 
 
07b12d6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3e7e2b1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
07b12d6
 
 
 
3e7e2b1
 
 
b68b461
3e7e2b1
 
 
b68b461
3e7e2b1
 
b68b461
 
 
3e7e2b1
 
b68b461
 
3e7e2b1
 
 
 
 
b68b461
3e7e2b1
b68b461
 
 
 
 
 
 
 
 
3e7e2b1
b68b461
 
3e7e2b1
b68b461
3e7e2b1
 
 
 
 
 
 
 
 
 
 
 
 
 
b68b461
3e7e2b1
 
b68b461
 
3e7e2b1
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
"""OpenAmer-Server: OpenAI-kompatible Schnittstelle fuer die grossen Stufen.



Lehren aus dem ersten Versuch:

  1. Ein eigener uvicorn-Start kollidiert mit Gradios eigenem Server (Port belegt).

     Richtig ist, die Routen an Gradios eingebaute FastAPI zu haengen

     (demo.app) und Gradio starten zu lassen.

  2. Ohne ausdrueckliche Hardware-Anforderung laeuft der Space auf cpu-basic.

     32B auf der CPU ist nicht darstellbar - deshalb zero-a10g (ZeroGPU).



Stufen: Desktop (14,7B), Pro (24B), Ultra (32B) als Basis + eigener LoRA-Adapter.

Watch/Phone/Tab fehlen bewusst: fuer Phone und Tab gibt es keinen Adapter, und

Watch laeuft auf einem eigenen CPU-Space ohne Wartezeit.

"""
import time

import gradio as gr
import torch
from fastapi import Body
from fastapi.responses import JSONResponse

try:
    import spaces
except ImportError:                     # ausserhalb von ZeroGPU
    class spaces:
        @staticmethod
        def GPU(*a, **k):
            def huelle(f):
                return f
            return huelle

STUFEN = {
    "desktop": {"anzeige": "Desktop (14,7B)", "basis": "Qwen/Qwen2.5-14B-Instruct",
                "adapter": "openamer-max/openamer-max-desktop-adapter",
                "pruefstand": "44/45 (97,8 %)", "ollama": "amersacirovic/openamer-max-desktop"},
    "pro": {"anzeige": "Pro (24B)", "basis": "mistralai/Mistral-Small-24B-Instruct-2501",
            "adapter": "openamer-max/openamer-max-pro-adapter",
            "pruefstand": "43/45 (95,6 %)", "ollama": "amersacirovic/openamer-max-pro"},
    "ultra": {"anzeige": "Ultra (32B)", "basis": "Qwen/Qwen2.5-32B-Instruct",
              "adapter": "openamer-max/openamer-max-ultra-adapter",
              "pruefstand": "41/45 (91,1 %)", "ollama": "amersacirovic/openamer-max-ultra"},
}

SYSTEM = ("Du bist OpenAmer, ein lokaler KI-Assistent. Du antwortest knapp, sachlich und "
          "auf Deutsch, wenn der Nutzer Deutsch schreibt. Du erfindest keine Zahlen, "
          "Versionen oder Namen. Wenn du etwas nicht weisst, sagst du das.")

_geladen = {}


def _lade(schluessel):
    if schluessel in _geladen:
        return _geladen[schluessel]
    from peft import PeftModel
    from transformers import AutoModelForCausalLM, AutoTokenizer

    info = STUFEN[schluessel]
    tok = AutoTokenizer.from_pretrained(info["basis"])
    kw = {"device_map": "auto", "torch_dtype": torch.float16}
    if torch.cuda.is_available():
        from transformers import BitsAndBytesConfig
        kw["quantization_config"] = BitsAndBytesConfig(
            load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16,
            bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True)
    else:
        kw["torch_dtype"] = torch.float32
        kw["device_map"] = None
    modell = AutoModelForCausalLM.from_pretrained(info["basis"], **kw)
    modell = PeftModel.from_pretrained(modell, info["adapter"])
    modell.eval()
    _geladen[schluessel] = (modell, tok)
    return _geladen[schluessel]


@spaces.GPU(duration=60)
def erzeuge(schluessel, nachrichten, max_tokens):
    modell, tok = _lade(schluessel)
    text = tok.apply_chat_template(nachrichten, tokenize=False, add_generation_prompt=True)
    eingabe = tok(text, return_tensors="pt").to(modell.device)
    with torch.no_grad():
        aus = modell.generate(**eingabe, max_new_tokens=int(max_tokens), do_sample=False,
                              temperature=None, top_p=None, top_k=None,
                              pad_token_id=tok.eos_token_id)
    return tok.decode(aus[0][eingabe["input_ids"].shape[1]:], skip_special_tokens=True).strip()



def antworte_ui(stufe_name, frage_text, tokens_anzahl):
    schluessel = next((k for k, v in STUFEN.items() if v['anzeige'] == stufe_name),
                      'desktop')
    if not frage_text or not frage_text.strip():
        return 'Bitte eine Frage eingeben.'
    t0 = time.time()
    try:
        text = erzeuge(schluessel, [{'role': 'system', 'content': SYSTEM},
                                    {'role': 'user', 'content': frage_text}],
                       tokens_anzahl)
    except Exception as e:
        return 'Fehler: ' + str(e)[:200]
    nl = chr(10)
    kopf = STUFEN[schluessel]['anzeige'] + ' | ' + STUFEN[schluessel]['pruefstand']
    return text + nl + nl + kopf + ' | ' + format(time.time() - t0, '.1f') + 's'

beschreibung = """

# OpenAmer-Server — kostenlos, ohne Schlüssel



Dieselbe Schnittstelle, die die Web-App nutzt: `POST /v1/chat/completions`.



| Modell | Parameter | Prüfstand (45 Fälle) |

|---|---|---|

| `desktop` | 14,70B | 44/45 (97,8 %) |

| `pro` | 24,00B | 43/45 (95,6 %) |

| `ultra` | 32,00B | 41/45 (91,1 %) |



**Ehrlich:** Der erste Aufruf einer Stufe lädt das Modell — etwa eine Minute. Ein

Wechsel der Stufe lädt neu. Die kleinste Stufe (`watch`, 0,6B) läuft auf einem

eigenen CPU-Server und antwortet in Sekunden.

"""

with gr.Blocks(title="OpenAmer-Server") as demo:
    gr.Markdown(beschreibung)
    with gr.Row():
        stufe = gr.Dropdown(choices=[v["anzeige"] for v in STUFEN.values()],
                            value="Desktop (14,7B)", label="Stufe")
        tokens = gr.Slider(32, 256, value=96, step=32, label="Maximale Länge")
    frage = gr.Textbox(label="Frage", placeholder="Was ist OpenAmer?", lines=2)
    knopf = gr.Button("Antworten", variant="primary")
    ausgabe = gr.Textbox(label="Antwort", lines=8)
    # Die Verdrahtung gehoert INNERHALB des Blocks - ausserhalb wirft Gradio
    # "Cannot call click outside of a gradio.Blocks context".
    knopf.click(antworte_ui, [stufe, frage, tokens], ausgabe)
    frage.submit(antworte_ui, [stufe, frage, tokens], ausgabe)




# ------------------------------------------------------------------ OpenAI-Routen
# Gradio bringt eine FastAPI mit (demo.app). Routen dort einhaengen ist der
# offizielle Weg - ein eigener uvicorn-Start kollidiert mit Gradios Port.


@demo.app.get("/v1/models")
def modelle():
    return {"object": "list",
            "data": [{"id": k, "object": "model", "owned_by": "openamer",
                      "name": v["anzeige"], "pruefstand": v["pruefstand"]}
                     for k, v in STUFEN.items()]}


@demo.app.post("/v1/chat/completions")
def chat(anfrage: dict = Body(...)):
    roh = (anfrage.get("model") or "desktop").split("/")[-1].lower()
    schluessel = {"watch": "desktop", "phone": "desktop", "tab": "desktop"}.get(roh, roh)
    if schluessel not in STUFEN:
        return JSONResponse(status_code=400, content={
            "error": {"message": f"Unbekanntes Modell '{roh}'. Verfuegbar: "
                                 f"{', '.join(STUFEN)}", "type": "invalid_request_error"}})
    nachrichten = anfrage.get("messages") or []
    if not nachrichten:
        return JSONResponse(status_code=400, content={
            "error": {"message": "messages fehlt", "type": "invalid_request_error"}})
    if not any(m.get("role") == "system" for m in nachrichten):
        nachrichten = [{"role": "system", "content": SYSTEM}] + nachrichten
    t0 = time.time()
    try:
        text = erzeuge(schluessel, nachrichten, anfrage.get("max_tokens") or 256)
    except Exception as e:
        return JSONResponse(status_code=503, content={
            "error": {"message": f"Stufe '{schluessel}' nicht ladbar: {str(e)[:180]}",
                      "type": "server_error"}})
    zeichen = sum(len(m.get("content") or "") for m in nachrichten)
    return {"id": "chatcmpl-" + str(int(t0 * 1000)), "object": "chat.completion",
            "created": int(t0), "model": schluessel,
            "choices": [{"index": 0, "finish_reason": "stop",
                         "message": {"role": "assistant", "content": text}}],
            "usage": {"prompt_tokens": zeichen // 4,
                      "completion_tokens": max(1, len(text) // 4),
                      "total_tokens": (zeichen + len(text)) // 4},
            "openamer": {"stufe": STUFEN[schluessel]["anzeige"],
                         "pruefstand": STUFEN[schluessel]["pruefstand"],
                         "dauer_s": round(time.time() - t0, 1)}}


@demo.app.get("/health")
def health():
    return {"status": "ok", "stufen": list(STUFEN), "geladen": list(_geladen),
            "gpu": torch.cuda.is_available()}


demo.launch()