change

modal_backend/commentary.py

@@ -0,0 +1,170 @@
+import modal
+
+MODEL_ID = "openbmb/MiniCPM-o-4_5"
+MODEL_DIR = "/model-weights/minicpm-o-4_5"
+
+app = modal.App("f1-paddock-oracle")
+
+volume = modal.Volume.from_name("f1-model-weights", create_if_missing=True)
+
+image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .pip_install(
+        "torch==2.4.0",
+        "torchvision==0.19.0",
+        "torchaudio==2.4.0",
+        extra_index_url="https://download.pytorch.org/whl/cu121",
+    )
+    .pip_install(
+        "transformers==4.51.0",
+        "tokenizers==0.21.0",
+        "accelerate>=0.30.0",
+        "minicpmo-utils>=1.0.5",
+        "sentencepiece",
+        "soundfile",
+        "scipy",
+        "huggingface_hub",
+        "kokoro>=0.9.4",
+    )
+    .pip_install(
+        "click",
+        "spacy",
+    )
+)
+
+
+def _load_model():
+    import os
+    import shutil
+    import torch
+    from transformers import AutoModel, AutoTokenizer
+
+    hf_token = os.environ["HF_TOKEN"]
+
+    modules_cache = "/root/.cache/huggingface/modules"
+    if os.path.exists(modules_cache):
+        shutil.rmtree(modules_cache)
+
+    from huggingface_hub import snapshot_download
+
+    sentinel = os.path.join(MODEL_DIR, ".download_complete")
+    if not os.path.exists(sentinel):
+        if os.path.exists(MODEL_DIR):
+            shutil.rmtree(MODEL_DIR)
+        snapshot_download(repo_id=MODEL_ID, local_dir=MODEL_DIR, token=hf_token)
+        open(sentinel, "w").close()
+        volume.commit()
+
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, trust_remote_code=True)
+    model = AutoModel.from_pretrained(
+        MODEL_DIR,
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+    )
+    model.eval()
+    return model, tokenizer
+
+
+def _tts(text: str) -> bytes:
+    import io
+    import numpy as np
+    import scipy.io.wavfile as wav_writer
+    from kokoro import KPipeline
+
+    pipeline = KPipeline(lang_code="b")  # "b" = British English
+    samples = []
+    for _, _, audio in pipeline(text, voice="bm_daniel", speed=1.1):
+        samples.append(audio)
+
+    if not samples:
+        return b""
+
+    audio_np = np.concatenate(samples)
+    if audio_np.dtype != np.int16:
+        audio_np = (audio_np * 32767).clip(-32768, 32767).astype(np.int16)
+
+    buf = io.BytesIO()
+    wav_writer.write(buf, 24000, audio_np)
+    return buf.getvalue()
+
+
+@app.function(
+    image=image,
+    gpu="A100",
+    timeout=600,
+    secrets=[modal.Secret.from_name("hf-token")],
+    volumes={"/model-weights": volume},
+    scaledown_window=300,
+)
+def generate_commentary(prompt: str, warmup: bool = False) -> dict:
+    model, tokenizer = _load_model()
+
+    if warmup:
+        return {}
+
+    sys_msg = model.get_sys_prompt(mode="omni", language="en")
+    msgs = [sys_msg, {"role": "user", "content": [prompt]}]
+
+    text = model.chat(
+        msgs=msgs,
+        tokenizer=tokenizer,
+        max_new_tokens=512,
+        use_tts_template=False,
+        generate_audio=False,
+        do_sample=True,
+        temperature=0.7,
+    )
+    text = str(text)
+
+    audio_bytes = _tts(text)
+
+    return {"text": text, "audio_wav": audio_bytes}
+
+
+@app.function(
+    image=image,
+    gpu="A100",
+    timeout=600,
+    secrets=[modal.Secret.from_name("hf-token")],
+    volumes={"/model-weights": volume},
+    scaledown_window=300,
+)
+def persona_chat(system_prompt: str, user_message: str, warmup: bool = False) -> dict:
+    model, tokenizer = _load_model()
+
+    if warmup:
+        return {}
+
+    msgs = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_message},
+    ]
+
+    text = model.chat(
+        msgs=msgs,
+        tokenizer=tokenizer,
+        max_new_tokens=512,
+        use_tts_template=False,
+        generate_audio=False,
+        do_sample=True,
+        temperature=0.8,
+    )
+    text = str(text)
+
+    audio_bytes = _tts(text)
+
+    return {"text": text, "audio_wav": audio_bytes}
+
+
+@app.local_entrypoint()
+def smoke_test():
+    prompt = (
+        "LAP 47 of 57 at Monaco. Verstappen leads Hamilton by 6.2 seconds. "
+        "Hamilton is on worn mediums, tyre age 28 laps. "
+        "Generate a 2-sentence broadcast commentary update."
+    )
+    result = generate_commentary.remote(prompt=prompt, warmup=False)
+    assert result["text"], "Smoke test failed: empty text"
+    assert result["audio_wav"], "Smoke test failed: empty audio"
+    print(f"OK — text ({len(result['text'])} chars), audio ({len(result['audio_wav'])} bytes)")

modal_backend/deploy.py

@@ -0,0 +1,8 @@
+"""Single deploy entry point — registers both functions under one app.
+
+Deploy with:
+    modal deploy modal_backend/deploy.py
+"""
+
+from modal_backend.commentary import app, generate_commentary, persona_chat  # noqa: F401
+from modal_backend.strategy import reason_strategy  # noqa: F401

modal_backend/keepwarm.py

@@ -0,0 +1,23 @@
+"""Keep-warm scheduler — pings both containers every 5 minutes with warmup=True.
+
+Deploy manually with:
+    modal deploy modal_backend/keepwarm.py
+
+Stop manually with:
+    modal app stop f1-paddock-oracle-keepwarm
+
+Do NOT include this in the main app deploy.
+"""
+
+import modal
+
+from modal_backend.commentary import generate_commentary
+from modal_backend.strategy import reason_strategy
+
+app = modal.App("f1-paddock-oracle-keepwarm")
+
+
+@app.function(schedule=modal.Period(minutes=5))
+def ping_containers():
+    generate_commentary.remote(prompt="", warmup=True)
+    reason_strategy.remote(prompt="", warmup=True)

modal_backend/strategy.py

@@ -0,0 +1,113 @@
+import modal
+
+from modal_backend.commentary import app
+
+model_volume = modal.Volume.from_name("f1-model-cache", create_if_missing=True)
+
+image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .pip_install(
+        "torch==2.4.0",
+        extra_index_url="https://download.pytorch.org/whl/cu121",
+    )
+    .pip_install(
+        "transformers==4.51.0",
+        "accelerate>=0.30.0",
+        "huggingface-hub>=0.22.0",
+        "sentencepiece",
+    )
+    .env({"HF_HOME": "/model-cache", "TRANSFORMERS_CACHE": "/model-cache"})
+)
+
+MODEL_ID = "nvidia/Llama-3.1-Nemotron-Nano-8B-v1"
+
+SYSTEM_PROMPT = """You are a senior F1 strategist with deep knowledge of historical races.
+The user will describe a real race and change one variable.
+Your task:
+1. Briefly acknowledge the actual race outcome (1 sentence)
+2. Reason through how the changed variable affects pit windows, undercut/overcut risk, tire deg, and track position (3–5 sentences)
+3. Narrate the alternate outcome with specific lap numbers and position changes
+4. Produce a plausible alternate final top-5
+
+Be specific. Reference real team strategies and driver tendencies."""
+
+
+def _load_model():
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    import torch
+
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+    model.eval()
+    return model, tokenizer
+
+
+@app.function(
+    image=image,
+    gpu="A100",
+    timeout=300,
+    volumes={"/model-cache": model_volume},
+    secrets=[modal.Secret.from_name("hf-token")],
+)
+def reason_strategy(prompt: str, warmup: bool = False) -> dict:
+    import os
+    import torch
+
+    hf_token = os.environ.get("HF_TOKEN", "")
+    if hf_token:
+        from huggingface_hub import login
+        login(token=hf_token)
+
+    model, tokenizer = _load_model()
+
+    if warmup:
+        return {"status": "warm"}
+
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": prompt},
+    ]
+
+    input_text = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    inputs = tokenizer(input_text, return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=512,
+            do_sample=True,
+            temperature=0.7,
+            top_p=0.9,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+
+    new_tokens = output_ids[0][inputs["input_ids"].shape[-1]:]
+    reasoning_chain = tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
+    return {"reasoning_chain": reasoning_chain}
+
+
+@app.local_entrypoint()
+def main():
+    sample_prompt = (
+        "Race: 2023 British Grand Prix\n"
+        "Original outcome: Verstappen won from pole, Hamilton finished P4 after a late pit.\n"
+        "User change: What if Hamilton had pitted 5 laps earlier on lap 30 for fresh mediums?"
+    )
+
+    print("Running warmup...")
+    result = reason_strategy.remote(prompt="", warmup=True)
+    print(f"Warmup result: {result}")
+
+    print("\nRunning strategy inference...")
+    result = reason_strategy.remote(prompt=sample_prompt, warmup=False)
+    reasoning = result.get("reasoning_chain", "")
+    assert reasoning, "reasoning_chain is empty — inference failed"
+    print(f"\nReasoning chain:\n{reasoning}")