openamer-max's picture
OpenAI-kompatible Schnittstelle fuer Desktop/Pro/Ultra
28745b3 verified
Raw History Blame Contribute Delete
8.44 kB
"""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()