Spaces:
Running on Zero
Running on Zero
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()
|