Delete app.py

app.py

@@ -1,495 +0,0 @@
-"""Velqora-160M-Instruct — Hugging Face Gradio + ZeroGPU chat demo.
-
-Model sources:
-  1) Maxilicious20/Velqora-160M-Instruct (HF safetensors, when available)
-  2) Maxilicious20/Velqora-160M-Instruct-GGUF (F16 fallback via Transformers)
-
-The model is intentionally experimental. The 'context off' setting prevents
-previous chat messages from being included in the prompt; the UI still shows them.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import Any
-
-# IMPORTANT: ZeroGPU patches CUDA handling. Import it BEFORE torch/transformers.
-# Do NOT initialize or move the model inside the @spaces.GPU call.
-import spaces
-import torch
-import gradio as gr
-from huggingface_hub import hf_hub_download, list_repo_files
-from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedTokenizerFast, LlamaConfig, LlamaForCausalLM
-
-
-LOGGER = logging.getLogger("velqora-chat")
-logging.basicConfig(level=logging.INFO)
-
-MODEL_REPO = "Maxilicious20/Velqora-160M-Instruct"
-GGUF_REPO = "Maxilicious20/Velqora-160M-Instruct-GGUF"
-CONTEXT_LENGTH = 2048
-
-# The temperature and top-p defaults reflect our earlier llama.cpp test command.
-# Other defaults are conservative choices, NOT empirically proven optima.
-DEFAULT_TEMPERATURE = 0.4
-DEFAULT_TOP_P = 0.9
-DEFAULT_TOP_K = 40
-DEFAULT_REPETITION_PENALTY = 1.10
-DEFAULT_MAX_NEW_TOKENS = 64
-DEFAULT_CONTEXT = False
-DEFAULT_CONTEXT_TURNS = 3
-
-SPECIAL_TOKENS = {
-    "<|unk|>": 0,
-    "<|pad|>": 1,
-    "<|bos|>": 2,
-    "<|eos|>": 3,
-    "<|im_start|>": 4,
-    "<|im_end|>": 5,
-    "<|eot_id|>": 6,
-}
-
-
-POPUP_JS = r"""() => {
-    if (document.getElementById('velqora-warning-overlay')) return;
-    const overlay = document.createElement('div');
-    overlay.id = 'velqora-warning-overlay';
-    overlay.innerHTML = `
-      <div class="velqora-warning-card" role="alertdialog"
-           aria-modal="true" aria-labelledby="velqora-warning-title"
-           aria-describedby="velqora-warning-description">
-        <div class="velqora-warning-symbol">!</div>
-        <h2 id="velqora-warning-title">Before you chat</h2>
-        <p id="velqora-warning-description">
-          <strong>We recommend keeping conversation context disabled.</strong>
-          Velqora-160M often interprets previous messages incorrectly.
-          This is a small experimental model: answers may be inaccurate,
-          and responses can contain repetitive phrases or loops.
-        </p>
-        <p class="velqora-warning-footnote">Please verify important information independently.</p>
-        <button id="velqora-warning-close" disabled aria-disabled="true">
-          Continue (5s)
-        </button>
-      </div>`;
-    document.body.appendChild(overlay);
-    const close = document.getElementById('velqora-warning-close');
-    let remaining = 5;
-    const timer = setInterval(() => {
-        remaining -= 1;
-        if (remaining <= 0) {
-            clearInterval(timer);
-            close.disabled = false;
-            close.setAttribute('aria-disabled', 'false');
-            close.textContent = 'I understand — continue';
-            close.focus();
-        } else {
-            close.textContent = `Continue (${remaining}s)`;
-        }
-    }, 1000);
-    close.addEventListener('click', () => {
-        if (close.disabled) return;
-        overlay.remove();
-    });
-}"""
-
-
-CSS = r"""
-.gradio-container { max-width: 1080px !important; margin: 0 auto; }
-#velqora-top { padding: 20px 0 8px; }
-#velqora-title { font-size: 2rem; font-weight: 800; letter-spacing: -.035em; }
-#velqora-subtitle { color: #64748b; margin-top: 0; }
-#velqora-chat { border-radius: 16px; }
-#velqora-warning-overlay {
-    position: fixed; z-index: 99999; inset: 0;
-    background: rgba(9, 17, 32, 0.64);
-    display: flex; justify-content: center; align-items: center;
-    padding: 20px; backdrop-filter: blur(5px);
-}
-.velqora-warning-card {
-    width: min(100%, 510px); background: #fff; color: #192233;
-    border-radius: 22px; padding: 30px;
-    box-shadow: 0 24px 90px rgba(0,0,0,.28);
-    font-family: system-ui, -apple-system, sans-serif;
-}
-.velqora-warning-symbol {
-    display: flex; align-items: center; justify-content: center;
-    width: 48px; height: 48px; margin-bottom: 12px;
-    color: #8a5100; background: #fff1d5;
-    border-radius: 13px; font-weight: 800; font-size: 26px;
-}
-.velqora-warning-card h2 { font-size: 24px; font-weight: 750; margin: 0 0 12px; }
-.velqora-warning-card p { font-size: 15px; line-height: 1.7; margin: 0 0 12px; }
-.velqora-warning-footnote { color: #64748b; }
-#velqora-warning-close {
-    width: 100%; background: #1865ca; color: #fff; border: none;
-    padding: 13px; border-radius: 12px; font-size: 15px; font-weight: 700;
-    cursor: pointer; margin-top: 12px;
-}
-#velqora-warning-close:disabled {
-    background: #b4c3d8; cursor: not-allowed;
-}
-#velqora-warning-close:not(:disabled):hover { background: #1155ae; }
-"""
-
-
-def load_tokenizer() -> Any:
-    """Load the original ByteLevel BPE tokenizer; never substitute a foreign tokenizer."""
-    try:
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO, use_fast=True)
-        LOGGER.info("Tokenizer loaded via AutoTokenizer from %s", MODEL_REPO)
-    except Exception as exc:
-        LOGGER.warning("AutoTokenizer could not load (%s); using tokenizer.json", exc)
-        tokenizer_path = hf_hub_download(repo_id=MODEL_REPO, filename="tokenizer.json")
-        tokenizer = PreTrainedTokenizerFast(
-            tokenizer_file=tokenizer_path,
-            unk_token="<|unk|>",
-            pad_token="<|pad|>",
-            bos_token="<|bos|>",
-            eos_token="<|eot_id|>",
-            additional_special_tokens=["<|im_start|>", "<|im_end|>", "<|eos|>"],
-        )
-
-    # Assert exact tokenizer special-token IDs from the native training format.
-    actual = {token: tokenizer.convert_tokens_to_ids(token) for token in SPECIAL_TOKENS}
-    mismatches = {token: (SPECIAL_TOKENS[token], actual[token])
-                  for token in SPECIAL_TOKENS if actual[token] != SPECIAL_TOKENS[token]}
-    if mismatches:
-        raise RuntimeError(
-            "Velqora tokenizer does not match the original special-token IDs: "
-            f"{mismatches}. Refusing to run inference with a different tokenizer."
-        )
-    return tokenizer
-
-
-def load_model() -> tuple[Any, str, str]:
-    """Load actual Velqora weights, preferring HF safetensors and then F16 GGUF."""
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    dtype = torch.float16 if device == "cuda" else torch.float32
-    failures: list[str] = []
-
-    try:
-        files = list_repo_files(MODEL_REPO)
-    except Exception as exc:
-        LOGGER.warning("Cannot list original model repo: %s", exc)
-        files = []
-        failures.append(f"Original repository listing failed: {exc}")
-
-    hf_weights = any(
-        file == "model.safetensors" or file.endswith(".safetensors")
-        or file == "pytorch_model.bin" or file.endswith(".bin")
-        for file in files
-    )
-    if hf_weights:
-        try:
-            model = AutoModelForCausalLM.from_pretrained(
-                MODEL_REPO, dtype=dtype, trust_remote_code=False,
-                low_cpu_mem_usage=False,
-            )
-            model.eval().to(device)
-            LOGGER.info("Loaded original Transformers weights from %s", MODEL_REPO)
-            return model, device, "Original Transformers checkpoint"
-        except Exception as exc:
-            LOGGER.exception("Loading HF checkpoint failed")
-            failures.append(f"Transformers checkpoint failed: {exc}")
-    else:
-        LOGGER.info("No standard HF weights found in %s; attempting GGUF fallback", MODEL_REPO)
-
-    try:
-        gguf_files = set(list_repo_files(GGUF_REPO))
-        preferred = [
-            "Velqora-160M-Instruct-F16.gguf",
-            "Velqora-160M-Instruct-Q8_0.gguf",
-            "Velqora-160M-Instruct-Q4_K_M.gguf",
-        ]
-        gguf_file = next((name for name in preferred if name in gguf_files), None)
-        if gguf_file is None:
-            raise FileNotFoundError(
-                "No supported GGUF checkpoint was found in the GGUF repository. "
-                "Expected F16, Q8_0 or Q4_K_M."
-            )
-        # Transformers supports loading Llama-architecture GGUF checkpoints as
-        # ordinary PyTorch models (dequantized as required). Needs the 'gguf' package.
-        # The GGUF repository may not contain config.json. Supply the
-        # known architecture explicitly rather than trying to infer it from
-        # a non-HF native config in the original model repository.
-        config = LlamaConfig(
-            vocab_size=32000,
-            hidden_size=1024,
-            intermediate_size=2560,
-            num_hidden_layers=12,
-            num_attention_heads=16,
-            num_key_value_heads=4,
-            max_position_embeddings=CONTEXT_LENGTH,
-            rope_theta=10000.0,
-            rms_norm_eps=1e-5,
-            hidden_act="silu",
-            tie_word_embeddings=True,
-            bos_token_id=2,
-            eos_token_id=6,
-            pad_token_id=1,
-        )
-        model = LlamaForCausalLM.from_pretrained(
-            GGUF_REPO,
-            gguf_file=gguf_file,
-            config=config,
-            dtype=dtype,
-            low_cpu_mem_usage=False,
-        )
-        model.eval().to(device)
-        LOGGER.info("Loaded %s from %s", gguf_file, GGUF_REPO)
-        return model, device, f"GGUF fallback ({gguf_file})"
-    except Exception as exc:
-        LOGGER.exception("Loading GGUF fallback failed")
-        failures.append(f"GGUF fallback failed: {exc}")
-
-    raise RuntimeError(
-        "Velqora-160M could not be loaded from its public repositories. "
-        "If the original repo contains only model.pt, upload the verified "
-        "Llama-compatible model.safetensors + config.json export, or ensure "
-        "the F16 GGUF file exists in the GGUF repo. Details: " + " | ".join(failures)
-    )
-
-
-TOKENIZER = load_tokenizer()
-MODEL, DEVICE, MODEL_SOURCE = load_model()
-
-
-def clean_user_text(text: str) -> str:
-    """Prevent pasted chat delimiters from injecting fake model roles."""
-    cleaned = (text or "").strip()
-    for token in SPECIAL_TOKENS:
-        cleaned = cleaned.replace(token, f"[{token[2:-2]}]")
-    return cleaned
-
-
-def encode_prompt(text: str) -> list[int]:
-    """Encode a chat prompt without silently adding BOS/EOS tokens."""
-    return TOKENIZER.encode(text, add_special_tokens=False)
-
-
-def make_prompt(history: list[dict[str, str]], max_new_tokens: int,
-                use_context: bool, context_turns: int) -> list[int]:
-    """Build a prompt fitting the 2048-token limit, preferring the latest question."""
-    if not history or history[-1].get("role") != "user":
-        raise ValueError("The latest chat message must be from the user.")
-
-    usable = CONTEXT_LENGTH - int(max_new_tokens) - 8
-    if usable < 40:
-        raise ValueError("Requested generation length leaves too little prompt space.")
-
-    prefix = "<|im_start|>user\n"
-    suffix = "<|im_end|><|im_start|>assistant\n"
-    latest = clean_user_text(str(history[-1].get("content") or ""))
-    if not latest:
-        raise ValueError("Message must not be empty.")
-
-    latest_ids = encode_prompt(latest)
-    framing = len(encode_prompt(prefix + suffix))
-    if len(latest_ids) + framing > usable:
-        latest_ids = latest_ids[-(usable - framing):]
-        latest = TOKENIZER.decode(latest_ids, skip_special_tokens=False)
-
-    current = prefix + latest + suffix
-    current_ids = encode_prompt(current)
-
-    if not use_context:
-        return current_ids
-
-    previous = history[:-1]
-    pairs: list[tuple[str, str]] = []
-    i = 0
-    while i + 1 < len(previous):
-        user = previous[i]
-        assistant = previous[i + 1]
-        if user.get("role") == "user" and assistant.get("role") == "assistant":
-            user_text = clean_user_text(str(user.get("content") or ""))
-            assistant_text = clean_user_text(str(assistant.get("content") or ""))
-            if user_text and assistant_text:
-                pairs.append((user_text, assistant_text))
-            i += 2
-        else:
-            i += 1
-
-    selected: list[str] = []
-    for question, answer in reversed(pairs[-int(context_turns):]):
-        pair = (
-            f"<|im_start|>user\n{question}<|im_end|>"
-            f"<|im_start|>assistant\n{answer}<|eot_id|>"
-        )
-        proposed = pair + "".join(selected) + current
-        proposed_ids = encode_prompt(proposed)
-        if len(proposed_ids) <= usable:
-            selected.insert(0, pair)
-        # Discard older turns if the prompt would exceed the context window.
-
-    return encode_prompt("".join(selected) + current)
-
-
-def submit_user(message: str, history: list[dict[str, str]] | None):
-    """Append a user's message to the visible chat history."""
-    history = list(history or [])
-    text = (message or "").strip()
-    if not text:
-        return message, history
-    if history and history[-1].get("role") == "user":
-        return message, history
-    return "", history + [{"role": "user", "content": text[:12000]}]
-
-
-def generation_duration(history, temperature, top_p, top_k,
-                        repetition_penalty, max_new_tokens, use_context, context_turns):
-    """Reserve proportional ZeroGPU time without booking too long for short replies."""
-    return max(35, min(120, 15 + int(max_new_tokens) * 0.5))
-
-
-@spaces.GPU(duration=generation_duration)
-def generate_reply(history: list[dict[str, str]], temperature: float,
-                   top_p: float, top_k: int, repetition_penalty: float,
-                   max_new_tokens: int, use_context: bool,
-                   context_turns: int) -> list[dict[str, str]]:
-    """Generate a Velqora response, optionally including recent conversation turns."""
-    history = list(history or [])
-    if not history or history[-1].get("role") != "user":
-        return history
-
-    try:
-        max_new_tokens = int(max_new_tokens)
-        input_ids = make_prompt(history, max_new_tokens, bool(use_context),
-                                int(context_turns))
-        ids = torch.tensor([input_ids], dtype=torch.long, device=DEVICE)
-        attention_mask = torch.ones_like(ids)
-        stop_ids = [SPECIAL_TOKENS["<|eot_id|>"],
-                    SPECIAL_TOKENS["<|eos|>"],
-                    SPECIAL_TOKENS["<|im_end|>"]]
-        with torch.inference_mode():
-            output = MODEL.generate(
-                input_ids=ids,
-                attention_mask=attention_mask,
-                max_new_tokens=max_new_tokens,
-                do_sample=True,
-                temperature=float(temperature),
-                top_p=float(top_p),
-                top_k=int(top_k),
-                repetition_penalty=float(repetition_penalty),
-                eos_token_id=stop_ids,
-                pad_token_id=SPECIAL_TOKENS["<|pad|>"],
-                use_cache=True,
-            )
-        new_tokens = output[0, len(input_ids):].tolist()
-        answer = TOKENIZER.decode(new_tokens, skip_special_tokens=False)
-        # Trim trailing delimiters and any generated spurious role transition.
-        for marker in ("<|eot_id|>", "<|eos|>", "<|im_end|>", "<|im_start|>"):
-            answer = answer.split(marker, 1)[0]
-        answer = answer.strip() or "(No text generated. Try again or adjust the settings.)"
-        return history + [{"role": "assistant", "content": answer}]
-    except Exception as exc:
-        LOGGER.exception("Generation failed")
-        return history + [{
-            "role": "assistant",
-            "content": f"⚠️ Generation failed: `{type(exc).__name__}`. "
-                       "Check the Space logs for details.",
-        }]
-
-
-def reset_settings():
-    """Restore conservative defaults; chat history remains unchanged."""
-    return (DEFAULT_TEMPERATURE, DEFAULT_TOP_P, DEFAULT_TOP_K,
-            DEFAULT_REPETITION_PENALTY, DEFAULT_MAX_NEW_TOKENS,
-            DEFAULT_CONTEXT, DEFAULT_CONTEXT_TURNS)
-
-
-with gr.Blocks(title="Velqora-160M Chat", css=CSS, js=POPUP_JS) as demo:
-    gr.Markdown(
-        "# Velqora-160M-Instruct\n"
-        "**Experimental small language model · 158.6M parameters · 2K context**\n\n"
-        "The model can make factual mistakes, misread context or repeat phrases. "
-        "Do not rely on it for important decisions.\n\n"
-        f"[Model](https://huggingface.co/{MODEL_REPO}) · "
-        f"[GGUF](https://huggingface.co/{GGUF_REPO}) · "
-        "**Knowledge cutoff: not documented**",
-        elem_id="velqora-top",
-    )
-
-    with gr.Row():
-        with gr.Column(scale=7, min_width=310):
-            chatbot = gr.Chatbot(
-                label="Velqora Chat",
-                height=510,
-                elem_id="velqora-chat",
-                buttons=["copy", "copy_all"],
-            )
-            user_input = gr.Textbox(
-                label="Your message",
-                placeholder="Type a short question (English is recommended)...",
-                lines=2,
-                max_lines=5,
-            )
-            with gr.Row():
-                send = gr.Button("Send", variant="primary", scale=4)
-                clear = gr.Button("Clear chat", scale=1)
-
-        with gr.Column(scale=3, min_width=250):
-            gr.Markdown("### Generation settings")
-            temperature = gr.Slider(0.1, 1.5, value=DEFAULT_TEMPERATURE,
-                                    step=0.05, label="Temperature")
-            top_p = gr.Slider(0.1, 1.0, value=DEFAULT_TOP_P,
-                              step=0.05, label="Top-p")
-            top_k = gr.Slider(1, 100, value=DEFAULT_TOP_K,
-                              step=1, label="Top-k")
-            repetition_penalty = gr.Slider(
-                1.0, 1.5, value=DEFAULT_REPETITION_PENALTY,
-                step=0.05, label="Repetition penalty")
-            max_new_tokens = gr.Slider(
-                16, 256, value=DEFAULT_MAX_NEW_TOKENS,
-                step=16, label="Maximum new tokens")
-            with gr.Accordion("Conversation context (experimental)", open=True):
-                context_enabled = gr.Checkbox(
-                    value=DEFAULT_CONTEXT,
-                    label="Include previous turns in the prompt",
-                    info="OFF is recommended. Prior context is often misunderstood.",
-                )
-                context_turns = gr.Slider(
-                    1, 6, value=DEFAULT_CONTEXT_TURNS,
-                    step=1, label="Maximum previous turns")
-            reset = gr.Button("Reset settings")
-            gr.Markdown(
-                "**Recommended defaults:** temperature 0.4 / top-p 0.9 / "
-                "context OFF. These are conservative experimental settings, "
-                "not independently optimized benchmark winners.\n\n"
-                "Responses consume ZeroGPU quota and may wait in a queue."
-            )
-
-    settings = [temperature, top_p, top_k, repetition_penalty,
-                max_new_tokens, context_enabled, context_turns]
-
-    submit_event = send.click(
-        fn=submit_user, inputs=[user_input, chatbot],
-        outputs=[user_input, chatbot], queue=False,
-    )
-    submit_event.then(
-        fn=generate_reply, inputs=[chatbot, *settings],
-        outputs=chatbot, concurrency_limit=1,
-    )
-    enter_event = user_input.submit(
-        fn=submit_user, inputs=[user_input, chatbot],
-        outputs=[user_input, chatbot], queue=False,
-    )
-    enter_event.then(
-        fn=generate_reply, inputs=[chatbot, *settings],
-        outputs=chatbot, concurrency_limit=1,
-    )
-    clear.click(lambda: ([], ""), inputs=None,
-                outputs=[chatbot, user_input], queue=False)
-    reset.click(reset_settings, inputs=None, outputs=settings, queue=False)
-
-    gr.Markdown(
-        "<small>Model source: " + MODEL_SOURCE + ". "
-        "Original training data cutoff is unknown; no calendar date is claimed.</small>"
-    )
-
-
-demo.queue(default_concurrency_limit=1)
-
-if __name__ == "__main__":
-    demo.launch()