Configure space for deployment

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PORT=7860
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,87 @@
 ---
-title: Code Embed Qwen Rerank Sentiment
-emoji: 🔥
-colorFrom: yellow
-colorTo: purple
+title: Code-Embed-Qwen-rerank-sentiment
+colorFrom: gray
+colorTo: indigo
 sdk: docker
-pinned: false
+app_port: 7860
+pinned: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Code-Embed-Qwen-rerank-sentiment
+
+Lazy-loading CPU-first code and multimodal retrieval API. This is the only custom Space in the set because it needs code embeddings, a Qwen reranker, sentiment classification, and CLIP image embeddings without keeping every model resident in memory at once.
+
+## Model Set
+
+- Text / code embeddings: `jinaai/jina-code-embeddings-0.5b`
+- Reranker: `Qwen/Qwen3-Reranker-0.6B`
+- Classifier: `clapAI/modernBERT-base-multilingual-sentiment`
+- Image embeddings: `sentence-transformers/clip-ViT-B-32`
+
+## Endpoints
+
+- `GET /health`
+- `GET /models`
+- `POST /embeddings`
+- `POST /rerank`
+- `POST /classify`
+- `POST /embeddings_image`
+- `GET /openapi.json`
+
+## Example Requests
+
+### Code Embeddings
+
+```bash
+curl -X POST "$SPACE_URL/embeddings" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "code-embed",
+    "input": ["def quick_sort(arr): return sorted(arr)"]
+  }'
+```
+
+### Image Embeddings
+
+```bash
+curl -X POST "$SPACE_URL/embeddings" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "clip-image",
+    "modality": "image",
+    "input": ["https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png"]
+  }'
+```
+
+### Reranking
+
+```bash
+curl -X POST "$SPACE_URL/rerank" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "code-rerank",
+    "query": "python quick sort implementation",
+    "documents": [
+      "def quick_sort(arr): return sorted(arr)",
+      "SELECT * FROM users ORDER BY created_at DESC"
+    ],
+    "return_documents": true
+  }'
+```
+
+### Classification
+
+```bash
+curl -X POST "$SPACE_URL/classify" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "code-sentiment",
+    "input": ["The API is fast and easy to use."]
+  }'
+```
+
+## Notes
+
+- The server lazy-loads one model family at a time to fit `cpu-basic` more safely.
+- The first request after switching tasks will be slower because the model may need to be loaded.
+- Jina embedding and reranking models are under `CC BY-NC 4.0`; verify that license for your use case.

app.py

@@ -0,0 +1,435 @@
+import base64
+import gc
+import io
+import math
+import time
+import uuid
+from typing import Any, Literal
+
+import numpy as np
+import requests
+import torch
+import torch.nn.functional as F
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import PlainTextResponse
+from PIL import Image
+from pydantic import BaseModel, Field
+from sentence_transformers import SentenceTransformer
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer
+
+torch.set_grad_enabled(False)
+torch.set_num_threads(2)
+
+OWNER = "chmielvu"
+APP_TITLE = "Code-Embed-Qwen-rerank-sentiment"
+DEFAULT_MODEL = "default/not-specified"
+
+MODEL_CONFIG = {
+    "code-embed": {
+        "repo_id": "jinaai/jina-code-embeddings-0.5b",
+        "kind": "sentence-transformer",
+    },
+    "clip-image": {
+        "repo_id": "sentence-transformers/clip-ViT-B-32",
+        "kind": "sentence-transformer",
+    },
+    "code-rerank": {
+        "repo_id": "Qwen/Qwen3-Reranker-0.6B",
+        "kind": "qwen-reranker",
+    },
+    "code-sentiment": {
+        "repo_id": "clapAI/modernBERT-base-multilingual-sentiment",
+        "kind": "sequence-classification",
+    },
+}
+
+QWEN_RERANK_INSTRUCTION = (
+    "Given a developer or code search query, retrieve relevant passages, issue text, "
+    "or code snippets that answer the query."
+)
+
+app = FastAPI(
+    title=APP_TITLE,
+    summary=(
+        "CPU-first lazy-loading inference API for code embeddings, reranking, "
+        "classification, and CLIP image embeddings."
+    ),
+    version="1.0.0",
+)
+
+_loaded_name: str | None = None
+_loaded_kind: str | None = None
+_loaded_bundle: dict[str, Any] = {}
+
+
+class EmbeddingRequest(BaseModel):
+    input: str | list[str]
+    model: str = DEFAULT_MODEL
+    encoding_format: Literal["float", "base64"] = "float"
+    user: str | None = None
+    dimensions: int = 0
+    modality: Literal["text", "image"] = "text"
+
+
+class RerankRequest(BaseModel):
+    query: str = Field(..., max_length=122880)
+    documents: list[str] = Field(..., min_length=1, max_length=2048)
+    return_documents: bool = False
+    raw_scores: bool = False
+    model: str = DEFAULT_MODEL
+    top_n: int | None = None
+
+
+class ClassifyRequest(BaseModel):
+    input: list[str] = Field(..., min_length=1, max_length=2048)
+    model: str = DEFAULT_MODEL
+    raw_scores: bool = False
+
+
+def _now_ts() -> int:
+    return int(time.time())
+
+
+def _make_id(prefix: str) -> str:
+    return f"{prefix}-{uuid.uuid4().hex}"
+
+
+def _resolve_model_name(route: str, requested: str, modality: str | None = None) -> str:
+    if requested != DEFAULT_MODEL:
+        if requested not in MODEL_CONFIG:
+            raise HTTPException(status_code=400, detail=f"Unknown model '{requested}'")
+        return requested
+    if route == "embeddings" and modality == "image":
+        return "clip-image"
+    defaults = {
+        "embeddings": "code-embed",
+        "rerank": "code-rerank",
+        "classify": "code-sentiment",
+    }
+    return defaults[route]
+
+
+def _unload_current_model() -> None:
+    global _loaded_name, _loaded_kind, _loaded_bundle
+    _loaded_name = None
+    _loaded_kind = None
+    _loaded_bundle = {}
+    gc.collect()
+
+
+def _load_sentence_transformer(repo_id: str) -> dict[str, Any]:
+    model = SentenceTransformer(repo_id, trust_remote_code=True, device="cpu")
+    return {"model": model}
+
+
+def _load_qwen_reranker(repo_id: str) -> dict[str, Any]:
+    tokenizer = AutoTokenizer.from_pretrained(repo_id, padding_side="left")
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    model = AutoModelForCausalLM.from_pretrained(repo_id).eval()
+    token_false_id = tokenizer.convert_tokens_to_ids("no")
+    token_true_id = tokenizer.convert_tokens_to_ids("yes")
+    prefix = (
+        "<|im_start|>system\n"
+        'Judge whether the Document meets the requirements based on the Query and '
+        'the Instruct provided. Note that the answer can only be "yes" or "no".'
+        "<|im_end|>\n<|im_start|>user\n"
+    )
+    suffix = "<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
+    prefix_tokens = tokenizer.encode(prefix, add_special_tokens=False)
+    suffix_tokens = tokenizer.encode(suffix, add_special_tokens=False)
+    return {
+        "model": model,
+        "tokenizer": tokenizer,
+        "token_false_id": token_false_id,
+        "token_true_id": token_true_id,
+        "prefix_tokens": prefix_tokens,
+        "suffix_tokens": suffix_tokens,
+        "max_length": 4096,
+    }
+
+
+def _load_sequence_classifier(repo_id: str) -> dict[str, Any]:
+    tokenizer = AutoTokenizer.from_pretrained(repo_id)
+    model = AutoModelForSequenceClassification.from_pretrained(repo_id).eval()
+    return {"model": model, "tokenizer": tokenizer}
+
+
+def _get_model_bundle(name: str) -> tuple[str, dict[str, Any]]:
+    global _loaded_name, _loaded_kind, _loaded_bundle
+    if _loaded_name == name:
+        return _loaded_kind or "", _loaded_bundle
+
+    _unload_current_model()
+    config = MODEL_CONFIG[name]
+    kind = config["kind"]
+    repo_id = config["repo_id"]
+
+    if kind == "sentence-transformer":
+        bundle = _load_sentence_transformer(repo_id)
+    elif kind == "qwen-reranker":
+        bundle = _load_qwen_reranker(repo_id)
+    elif kind == "sequence-classification":
+        bundle = _load_sequence_classifier(repo_id)
+    else:
+        raise HTTPException(status_code=500, detail=f"Unsupported kind '{kind}'")
+
+    _loaded_name = name
+    _loaded_kind = kind
+    _loaded_bundle = bundle
+    return kind, bundle
+
+
+def _usage_from_strings(values: list[str], tokenizer: Any | None = None) -> dict[str, int]:
+    if tokenizer is None:
+        total = sum(max(1, len(value.split())) for value in values)
+        return {"prompt_tokens": total, "total_tokens": total}
+    total = 0
+    for value in values:
+        total += len(tokenizer.encode(value, add_special_tokens=True))
+    return {"prompt_tokens": total, "total_tokens": total}
+
+
+def _truncate_embedding(vector: np.ndarray, dimensions: int) -> np.ndarray:
+    if dimensions and 0 < dimensions < vector.shape[0]:
+        vector = vector[:dimensions]
+        norm = np.linalg.norm(vector)
+        if norm > 0:
+            vector = vector / norm
+    return vector
+
+
+def _vector_to_payload(vector: np.ndarray, encoding_format: str) -> list[float] | str:
+    vector = vector.astype(np.float32)
+    if encoding_format == "base64":
+        return base64.b64encode(vector.tobytes()).decode("ascii")
+    return vector.tolist()
+
+
+def _normalize_inputs(value: str | list[str]) -> list[str]:
+    return value if isinstance(value, list) else [value]
+
+
+def _load_image_from_input(value: str) -> Image.Image:
+    if value.startswith("data:"):
+        _, data = value.split(",", 1)
+        raw = base64.b64decode(data)
+        return Image.open(io.BytesIO(raw)).convert("RGB")
+    response = requests.get(value, timeout=30)
+    response.raise_for_status()
+    return Image.open(io.BytesIO(response.content)).convert("RGB")
+
+
+def _format_rerank_pair(query: str, document: str) -> str:
+    return f"<Instruct>: {QWEN_RERANK_INSTRUCTION}\n<Query>: {query}\n<Document>: {document}"
+
+
+def _score_rerank(query: str, documents: list[str], raw_scores: bool, bundle: dict[str, Any]) -> list[float]:
+    tokenizer = bundle["tokenizer"]
+    model = bundle["model"]
+    prefix_tokens = bundle["prefix_tokens"]
+    suffix_tokens = bundle["suffix_tokens"]
+    token_true_id = bundle["token_true_id"]
+    token_false_id = bundle["token_false_id"]
+    max_length = bundle["max_length"]
+
+    pairs = [_format_rerank_pair(query, document) for document in documents]
+    inputs = tokenizer(
+        pairs,
+        padding=False,
+        truncation="longest_first",
+        return_attention_mask=False,
+        max_length=max_length - len(prefix_tokens) - len(suffix_tokens),
+    )
+
+    for idx, token_ids in enumerate(inputs["input_ids"]):
+        inputs["input_ids"][idx] = prefix_tokens + token_ids + suffix_tokens
+
+    padded = tokenizer.pad(inputs, padding=True, return_tensors="pt", max_length=max_length)
+    logits = model(**padded).logits[:, -1, :]
+    true_logits = logits[:, token_true_id]
+    false_logits = logits[:, token_false_id]
+
+    if raw_scores:
+        return (true_logits - false_logits).detach().cpu().tolist()
+
+    stacked = torch.stack([false_logits, true_logits], dim=1)
+    probs = torch.nn.functional.softmax(stacked, dim=1)[:, 1]
+    return probs.detach().cpu().tolist()
+
+
+def _classify_scores(texts: list[str], raw_scores: bool, bundle: dict[str, Any]) -> list[list[dict[str, float | str]]]:
+    tokenizer = bundle["tokenizer"]
+    model = bundle["model"]
+    encoded = tokenizer(
+        texts,
+        padding=True,
+        truncation=True,
+        max_length=1024,
+        return_tensors="pt",
+    )
+    logits = model(**encoded).logits.detach().cpu()
+    problem_type = getattr(model.config, "problem_type", None)
+
+    if problem_type == "multi_label_classification":
+        score_tensor = torch.sigmoid(logits)
+    else:
+        score_tensor = torch.softmax(logits, dim=-1)
+
+    label_lookup = model.config.id2label
+    results: list[list[dict[str, float | str]]] = []
+    for row_idx in range(logits.shape[0]):
+        values = logits[row_idx] if raw_scores else score_tensor[row_idx]
+        row = [
+            {
+                "label": label_lookup[col_idx],
+                "score": float(values[col_idx].item()),
+            }
+            for col_idx in range(values.shape[0])
+        ]
+        row.sort(key=lambda item: item["score"], reverse=True)
+        results.append(row)
+    return results
+
+
+@app.get("/")
+def root() -> dict[str, str]:
+    return {"message": APP_TITLE}
+
+
+@app.get("/health")
+def health() -> dict[str, float]:
+    return {"unix": time.time()}
+
+
+@app.get("/models")
+@app.get("/v1/models")
+@app.get("/openai/v1/models")
+def models() -> dict[str, Any]:
+    created = _now_ts()
+    return {
+        "object": "list",
+        "data": [
+            {
+                "id": model_name,
+                "object": "model",
+                "created": created,
+                "owned_by": OWNER,
+                "root": config["repo_id"],
+            }
+            for model_name, config in MODEL_CONFIG.items()
+        ],
+    }
+
+
+@app.post("/embeddings")
+@app.post("/v1/embeddings")
+@app.post("/openai/v1/embeddings")
+def embeddings(request: EmbeddingRequest) -> dict[str, Any]:
+    model_name = _resolve_model_name("embeddings", request.model, request.modality)
+    kind, bundle = _get_model_bundle(model_name)
+    if kind != "sentence-transformer":
+        raise HTTPException(status_code=400, detail=f"Model '{model_name}' does not support embeddings")
+
+    values = _normalize_inputs(request.input)
+    model = bundle["model"]
+
+    if request.modality == "image":
+        images = [_load_image_from_input(value) for value in values]
+        embeddings_np = np.asarray(model.encode(images, convert_to_numpy=True))
+        usage = {"prompt_tokens": 0, "total_tokens": 0}
+    else:
+        embeddings_np = np.asarray(model.encode(values, convert_to_numpy=True))
+        tokenizer = getattr(model, "tokenizer", None)
+        usage = _usage_from_strings(values, tokenizer)
+
+    data = []
+    for idx, vector in enumerate(embeddings_np):
+        vector = _truncate_embedding(vector, request.dimensions)
+        data.append(
+            {
+                "object": "embedding",
+                "embedding": _vector_to_payload(vector, request.encoding_format),
+                "index": idx,
+            }
+        )
+
+    return {
+        "object": "list",
+        "data": data,
+        "model": model_name,
+        "usage": usage,
+        "id": _make_id("emb"),
+        "created": _now_ts(),
+    }
+
+
+@app.post("/embeddings_image")
+def embeddings_image(request: EmbeddingRequest) -> dict[str, Any]:
+    image_request = EmbeddingRequest(
+        input=request.input,
+        model="clip-image" if request.model == DEFAULT_MODEL else request.model,
+        encoding_format=request.encoding_format,
+        user=request.user,
+        dimensions=request.dimensions,
+        modality="image",
+    )
+    return embeddings(image_request)
+
+
+@app.post("/rerank")
+@app.post("/v1/rerank")
+@app.post("/openai/v1/rerank")
+def rerank(request: RerankRequest) -> dict[str, Any]:
+    model_name = _resolve_model_name("rerank", request.model)
+    kind, bundle = _get_model_bundle(model_name)
+    if kind != "qwen-reranker":
+        raise HTTPException(status_code=400, detail=f"Model '{model_name}' does not support reranking")
+
+    scores = _score_rerank(request.query, request.documents, request.raw_scores, bundle)
+    results = []
+    for idx, score in enumerate(scores):
+        item = {"index": idx, "relevance_score": float(score)}
+        if request.return_documents:
+            item["document"] = request.documents[idx]
+        results.append(item)
+
+    results.sort(key=lambda item: item["relevance_score"], reverse=True)
+    if request.top_n is not None:
+        results = results[: request.top_n]
+
+    usage = _usage_from_strings([request.query] + request.documents, bundle["tokenizer"])
+    return {
+        "object": "rerank",
+        "results": results,
+        "model": model_name,
+        "usage": usage,
+        "id": _make_id("rerank"),
+        "created": _now_ts(),
+    }
+
+
+@app.post("/classify")
+@app.post("/v1/classify")
+@app.post("/openai/v1/classify")
+def classify(request: ClassifyRequest) -> dict[str, Any]:
+    model_name = _resolve_model_name("classify", request.model)
+    kind, bundle = _get_model_bundle(model_name)
+    if kind != "sequence-classification":
+        raise HTTPException(status_code=400, detail=f"Model '{model_name}' does not support classification")
+
+    data = _classify_scores(request.input, request.raw_scores, bundle)
+    usage = _usage_from_strings(request.input, bundle["tokenizer"])
+    return {
+        "object": "classify",
+        "data": data,
+        "model": model_name,
+        "usage": usage,
+        "id": _make_id("classify"),
+        "created": _now_ts(),
+    }
+
+
+@app.get("/metrics", response_class=PlainTextResponse)
+def metrics() -> str:
+    return ""

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.128.0
+uvicorn[standard]==0.35.0
+torch>=2.3.0
+transformers>=4.57.0
+sentence-transformers>=3.0.0
+pillow>=10.0.0
+requests>=2.32.0
+numpy>=1.26.0