yes

app.py

@@ -1,22 +1,14 @@
-"""
-Mirel – Minimal Rose LoRA Inference (HF Space)
-ZeroGPU-only, no Harmony, no extra config
-Single file: app.py
-"""
 from __future__ import annotations
-import os, gc, json, torch
+import os, gc, torch
 from typing import Optional, Dict, Any, List
 import gradio as gr
 import spaces
 from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
 
-# -----------------------
-# Constants / Env
-# -----------------------
-MODEL_ID = os.getenv("MODEL_ID", "openai/gpt-oss-20b")
-# Default to your Rose LoRA
-ADAPTER_ID = os.getenv("ADAPTER_ID", "AbstractPhil/mirel-gpt-oss-20b")
-ADAPTER_SUBFOLDER = os.getenv("ADAPTER_SUBFOLDER", "checkpoints/checkpoint-516")
+MODEL_ID = "openai/gpt-oss-20b"
+ADAPTER_ID = "AbstractPhil/mirel-gpt-oss-20b"
+ADAPTER_SUBFOLDER = "checkpoints/checkpoint-516"
 HF_TOKEN: Optional[str] = (
     os.getenv("HF_TOKEN")
     or os.getenv("HUGGING_FACE_HUB_TOKEN")
@@ -26,28 +18,16 @@ HF_TOKEN: Optional[str] = (
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
-# Tokenizer is lightweight; OK to load on CPU at import time
+# Load tokenizer on CPU
 tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True, token=HF_TOKEN)
 if tokenizer.pad_token_id is None:
     tokenizer.pad_token_id = tokenizer.eos_token_id
 
-# -----------------------
-# ZeroGPU inference (GPU work ONLY inside this function)
-# -----------------------
 @spaces.GPU(duration=120)
-def gpu_generate(prompt_str: str, seed: Optional[int] = None, max_new_tokens: int = 512) -> str:
-    """Minimal generation using GPT-OSS-20B + Rose LoRA.
-    - All CUDA work stays inside this function (ZeroGPU-safe).
-    - No Harmony, no extra knobs; rely on model defaults.
-    """
+def gpu_generate(prompt_str: str, max_new_tokens: int = 512) -> str:
     torch.set_grad_enabled(False)
     model = None
     try:
-        if seed is not None:
-            torch.manual_seed(int(seed))
-
-        from peft import PeftModel
-
         model_kwargs = dict(
             attn_implementation="eager",
             torch_dtype="auto",
@@ -58,92 +38,57 @@ def gpu_generate(prompt_str: str, seed: Optional[int] = None, max_new_tokens: in
             token=HF_TOKEN,
         )
         base_model = AutoModelForCausalLM.from_pretrained(MODEL_ID, **model_kwargs)
-
-        if ADAPTER_ID:
-            peft_kwargs: Dict[str, Any] = {"is_trainable": False, "token": HF_TOKEN}
-            if ADAPTER_SUBFOLDER:
-                peft_kwargs["subfolder"] = ADAPTER_SUBFOLDER
-            peft_model = PeftModel.from_pretrained(base_model, ADAPTER_ID, **peft_kwargs)
-            model = peft_model.merge_and_unload()
-        else:
-            model = base_model
-
+        peft_kwargs: Dict[str, Any] = {"is_trainable": False, "token": HF_TOKEN}
+        if ADAPTER_SUBFOLDER:
+            peft_kwargs["subfolder"] = ADAPTER_SUBFOLDER
+        peft_model = PeftModel.from_pretrained(base_model, ADAPTER_ID, **peft_kwargs)
+        model = peft_model.merge_and_unload()
         model.eval()
-        if getattr(model.config, "pad_token_id", None) is None:
-            model.config.pad_token_id = tokenizer.pad_token_id
+        model.config.pad_token_id = tokenizer.pad_token_id
 
-        device = next(model.parameters()).device
         enc = tokenizer(prompt_str, return_tensors="pt")
-        input_ids = enc["input_ids"].to(device)
-        attention_mask = enc.get("attention_mask")
-        if attention_mask is None:
-            attention_mask = (input_ids != tokenizer.pad_token_id).long().to(device)
+        input_ids = enc["input_ids"].to(model.device)
+        attention_mask = (input_ids != tokenizer.pad_token_id).long().to(model.device)
 
-        prompt_len = int(input_ids.shape[-1])
+        prompt_len = input_ids.shape[-1]
         output_ids = model.generate(
             input_ids=input_ids,
             attention_mask=attention_mask,
-            max_new_tokens=int(max_new_tokens),
-            pad_token_id=model.config.pad_token_id,
+            max_new_tokens=max_new_tokens,
+            pad_token_id=tokenizer.pad_token_id,
         )
         new_ids = output_ids[0, prompt_len:]
         return tokenizer.decode(new_ids, skip_special_tokens=True)
     except Exception as e:
         return f"[Error] {type(e).__name__}: {e}"
     finally:
-        try:
-            del model
-        except Exception:
-            pass
+        del model
         gc.collect()
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
 
-
 def ui_generate(message, history):
-    try:
-        # ChatInterface(type='messages') gives OpenAI-style dicts.
-        msgs: List[Dict[str, str]] = []
-        # Keep defaults: no explicit system beyond template defaults
-        if isinstance(history, list):
-            for m in history:
-                if isinstance(m, dict) and "role" in m:
-                    msgs.append({"role": m.get("role", "user"), "content": str(m.get("content", ""))})
-                elif isinstance(m, (list, tuple)) and len(m) >= 2:
-                    u, a = m[0], m[1]
-                    if u:
-                        msgs.append({"role": "user", "content": str(u)})
-                    if a:
-                        msgs.append({"role": "assistant", "content": str(a)})
-        if isinstance(message, dict):
-            msgs.append({"role": message.get("role", "user"), "content": str(message.get("content", ""))})
-        else:
-            msgs.append({"role": "user", "content": str(message)})
-
-        prompt = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
-        return gpu_generate(prompt)
-    except Exception as e:
-        return f"[Error] {type(e).__name__}: {e}"
-def ui_generate(message, history, temperature, max_new_tokens, rose_alpha, rose_tokens, rose_json, seed):
-    try:
-        msgs = _build_messages(message, history)
-        prompt = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
-        return gpu_generate(prompt, float(temperature), int(max_new_tokens), rose_tokens or "", rose_json or "", float(rose_alpha), int(seed) if seed is not None else None)
-    except Exception as e:
-        return f"[Error] {type(e).__name__}: {e}"
+    msgs: List[Dict[str, str]] = []
+    if isinstance(history, list):
+        for m in history:
+            if isinstance(m, dict) and "role" in m:
+                msgs.append(m)
+            elif isinstance(m, (list, tuple)) and len(m) >= 2:
+                if m[0]:
+                    msgs.append({"role": "user", "content": str(m[0])})
+                if m[1]:
+                    msgs.append({"role": "assistant", "content": str(m[1])})
+    if isinstance(message, dict):
+        msgs.append(message)
+    else:
+        msgs.append({"role": "user", "content": str(message)})
+
+    prompt = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
+    return gpu_generate(prompt)
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # Mirel – Rose LoRA (ZeroGPU, minimal)
-    Loads GPT‑OSS‑20B + Rose LoRA and generates with default settings.
-    """)
-
-    gr.ChatInterface(
-        fn=ui_generate,
-        type="messages",
-        title="Mirel",
-        cache_examples=False,
-    )
+    gr.Markdown("""# Mirel – Rose LoRA (ZeroGPU, Minimal)""")
+    gr.ChatInterface(fn=ui_generate, type="messages", title="Mirel", cache_examples=False)
 
 if __name__ == "__main__":
-    demo.queue(max_size=16).launch(server_name="0.0.0.0", server_port=7860)
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)