Upload 6 files

README.md

@@ -1,14 +1,21 @@
----
-title: Svision
-emoji: 📉
-colorFrom: gray
-colorTo: blue
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Image description using Salamandra-7B-vision
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Salamandra-Vision 7B · ZeroGPU Space (API + Clientes)
+
+Space Gradio (ZeroGPU) que sirve **UI + API** para `BSC-LT/salamandra-7b-vision`.  
+Clientes incluidos: `clients/client_requests.py` (local/CLI) y `clients/streamlit_client_app.py` (Space Streamlit).
+
+## Despliegue del Space (ZeroGPU)
+1. Crea Space → SDK **Gradio**, Hardware **ZeroGPU**.
+2. Sube `app.py`, `requirements.txt`, `README.md`, carpeta `examples`.
+3. Opcional: `MODEL_ID=BSC-LT/salamandra-7b-vision`.
+
+## Endpoints
+- UI: interfaz Gradio.
+- **REST puro**: `POST /api/describe_raw` (multipart: `image`, `text`, `max_new_tokens`, `temperature`).
+- Gradio clásico: `POST /api/predict/describe` (recomendado con `gradio_client`).
+
+> ZeroGPU sólo con Gradio; exponemos API desde Gradio. Clients externos (requests/Streamlit) funcionan bien. Para cargas altas y fair-use del clúster, considera forwarding de token por usuario (más sencillo en apps Gradio). :contentReference[oaicite:8]{index=8}
+
+## Cliente local (sin Gradio UI)
+```bash
+python clients/client_requests.py --space-url "https://<usuario>-<space>.hf.space" \
+  --image examples/demo.jpg --text "Descríbela en catalán."

api_schemas.py

@@ -0,0 +1,17 @@
+# api_schemas.py
+DESCRIBE_RAW_MULTIPART = {
+  "method": "POST",
+  "path": "/api/describe_raw",
+  "multipart_fields": [
+    {"name": "image", "type": "file"},
+    {"name": "text", "type": "text", "default": "Describe la imagen con detalle."},
+    {"name": "max_new_tokens", "type": "int", "default": 256},
+    {"name": "temperature", "type": "float", "default": 0.7}
+  ]
+}
+
+PREDICT_JSON = {
+  "method": "POST",
+  "path": "/api/predict/describe",
+  "json_body": {"data": ["<file or url>", "prompt text", 256, 0.7]}
+}

app.py

@@ -0,0 +1,85 @@
+# app.py
+import os
+from typing import Tuple, List
+
+import gradio as gr
+import spaces  # <- habilita ZeroGPU decorators
+import torch
+from PIL import Image
+from transformers import AutoProcessor, LlavaOnevisionForConditionalGeneration
+
+MODEL_ID = os.environ.get("MODEL_ID", "BSC-LT/salamandra-7b-vision")
+DTYPE = torch.float16  # half precision para H200/A100
+DEVICE = "cuda"        # ZeroGPU asigna gpu por llamada en @spaces.GPU
+
+# Carga perezosa: sólo la primera vez que se invoca en GPU
+_model = None
+_processor = None
+
+def _lazy_load():
+    global _model, _processor
+    if _model is None or _processor is None:
+        _processor = AutoProcessor.from_pretrained(MODEL_ID)
+        _model = LlavaOnevisionForConditionalGeneration.from_pretrained(
+            MODEL_ID,
+            torch_dtype=DTYPE,
+            low_cpu_mem_usage=True,
+            trust_remote_code=True,
+            device_map=None,  # movemos explícitamente a cuda con @spaces.GPU
+            use_safetensors=True,
+        )
+    return _model, _processor
+
+@spaces.GPU  # <- asegura que la función se ejecute con GPU asignada
+def describe(image: Image.Image, prompt_text: str, max_new_tokens: int, temperature: float) -> str:
+    """
+    Devuelve una descripción a partir de imagen + prompt en texto.
+    """
+    model, processor = _lazy_load()
+
+    # Formateo estilo chat template recomendado por el model card
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image"},
+                {"type": "text", "text": prompt_text or "Descriu la imatge amb el màxim detall possible."},
+            ],
+        }
+    ]
+    prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
+
+    # A GPU justo antes de inferir (ZeroGPU)
+    model = model.to(DEVICE)
+    inputs = processor(images=image, text=prompt, return_tensors="pt").to(DEVICE, DTYPE)
+
+    with torch.inference_mode():
+        output = model.generate(
+            **inputs,
+            max_new_tokens=int(max_new_tokens),
+            temperature=float(temperature),
+        )
+
+    text = processor.decode(output[0], skip_special_tokens=True)
+    return text.strip()
+
+with gr.Blocks(title="Salamandra Vision 7B (ZeroGPU)") as demo:
+    gr.Markdown("# Salamandra-Vision 7B · ZeroGPU\nEnvía una imagen y un texto/prompta, recibe una descripción.")
+
+    with gr.Row():
+        with gr.Column():
+            in_img = gr.Image(label="Imagen", type="pil")
+            in_txt = gr.Textbox(
+                label="Texto/prompta",
+                value="Describe la imagen con el mayor detalle posible (en catalán o español)."
+            )
+            max_new = gr.Slider(16, 1024, value=256, step=16, label="max_new_tokens")
+            temp = gr.Slider(0.0, 1.5, value=0.7, step=0.05, label="temperature")
+            btn = gr.Button("Generar", variant="primary")
+        with gr.Column():
+            out = gr.Textbox(label="Descripción", lines=18)
+
+    btn.click(describe, inputs=[in_img, in_txt, max_new, temp], outputs=out, api_name="describe")
+
+# Cola de Gradio: útil para ZeroGPU y picos de demanda
+demo.queue(concurrency_count=1, max_size=16).launch()

clients/client_requests.py

@@ -0,0 +1,39 @@
+# clients/client_requests.py
+import argparse, base64, json, os
+import requests
+
+def call_describe_raw(space_base_url: str, image_path: str, text: str, max_new_tokens: int = 256, temperature: float = 0.7):
+    """
+    Golpea el endpoint REST puro /api/describe_raw (multipart/form-data).
+    Ej.: space_base_url = "https://<usuario>-<space>.hf.space"
+    """
+    url = space_base_url.rstrip("/") + "/api/describe_raw"
+    with open(image_path, "rb") as f:
+        files = {"image": (os.path.basename(image_path), f, "application/octet-stream")}
+        data = {"text": text, "max_new_tokens": str(max_new_tokens), "temperature": str(temperature)}
+        r = requests.post(url, files=files, data=data, timeout=600)
+    r.raise_for_status()
+    return r.json()["text"]
+
+def call_predict_legacy(space_base_url: str, image_path: str, text: str, max_new_tokens: int = 256, temperature: float = 0.7):
+    """
+    Alternativa: endpoint estándar /api/predict/describe (formato Gradio).
+    Enviamos la imagen como URL de carga previa no disponible aquí, así que
+    preferimos /api/describe_raw. Se incluye por compatibilidad.
+    """
+    url = space_base_url.rstrip("/") + "/api/predict/describe"
+    # Para /api/predict lo normal es usar gradio_client que gestiona subidas;
+    # con requests puro, tendrías que hacer upload previo a /upload y referenciar la URL.
+    # Lo dejamos como placeholder educativo.
+    raise NotImplementedError("Usa call_describe_raw para HTTP directo.")
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--space-url", required=True, help="https://<usuario>-<space>.hf.space")
+    ap.add_argument("--image", required=True)
+    ap.add_argument("--text", default="Describe la imagen con detalle.")
+    ap.add_argument("--max-new-tokens", type=int, default=256)
+    ap.add_argument("--temperature", type=float, default=0.7)
+    args = ap.parse_args()
+    out = call_describe_raw(args.space_url, args.image, args.text, args.max_new_tokens, args.temperature)
+    print(out)

clients/streamlit_client_app.py

@@ -0,0 +1,24 @@
+# clients/streamlit_client_app.py
+import os, requests, streamlit as st
+
+SPACE_URL = os.environ.get("UPSTREAM_SPACE_URL", "https://<usuario>-<space>.hf.space")
+
+st.set_page_config(page_title="Cliente Salamandra (Streamlit)", layout="centered")
+st.title("Cliente Salamandra · Streamlit")
+
+img = st.file_uploader("Sube una imagen", type=["jpg","jpeg","png"])
+prompt = st.text_area("Texto/prompt", "Describe la imagen con detalle (ES/CA).")
+cols = st.columns(2)
+max_new = cols[0].slider("max_new_tokens", 16, 1024, 256, 16)
+temperature = cols[1].slider("temperature", 0.0, 1.5, 0.7, 0.05)
+
+if st.button("Generar") and img is not None:
+    with st.spinner("Llamando al Space ZeroGPU..."):
+        url = SPACE_URL.rstrip("/") + "/api/describe_raw"
+        files = {"image": (img.name, img.getvalue(), "application/octet-stream")}
+        data = {"text": prompt, "max_new_tokens": str(max_new), "temperature": str(temperature)}
+        r = requests.post(url, files=files, data=data, timeout=600)
+        if r.ok:
+            st.text_area("Descripción", r.json().get("text",""), height=300)
+        else:
+            st.error(f"Error {r.status_code}: {r.text}")

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.44.0
+spaces>=0.25.0
+transformers>=4.44.0
+torch>=2.2
+accelerate>=0.30.0
+safetensors>=0.4.2
+pillow>=10.3